Construo de Compiladores ca

Universidade Federal de Uberlandia

Prof.: Alexsandro Soares Alexandre dos Santos Rodrigues Wattyla Calazans Gomes de Oliveira 8 de maro de 2012 c

Resumo
Este relatrio aborda todo o contedo necessrio para a construo de um compilador o u a ca para a linguagem MiniJava, utilizando do Netwide Assembler(NASM). Tambm faz parte e deste, toda a experiencia adquirida na matria de Compiladores do curso de Cincia da Come e putao da Universidade Federal de Uberlndia no ano de 2012. ca a

1) Introduo ca
Este guia descreve a linguagem de programao MiniJava, que ser usada como linguaca a gem fonte para o projeto a disciplina Construo de Compilador da disciplina. MiniJava um ca e subconjunto da linguagem Java, ou seja, todo programa MiniJava tambm um programa e e Java, mas h muitas caracter a sticas da linguagem Java que no aparecem em MiniJava. Por a exemplo, a sobrecarga de mtodos no permitida em MiniJava, e o unico tipo de array e a e poss um array de inteiros. vel e Ao nal apresentamos alguns programas de escrito em MiniJava e o mesmo programas em Nasm. Um dos objetivos a ser alcanaado por este trabalho o de fazer com que um programa c e escrito em MiniJava seja compilado pela NASM.

1.1) Conceitos - Assembly e Assembler

O primeiro conceito que importa esclarecer precisamente a distino entre Assembly e ca e Assembler. Assim, o termo assembly refere-se ` linguagem de programao, que tambm a ca e e designada por linguagem de baixo-n vel, uma vez que se encontra intimamente relacionada com o processador a que se destina. Deste modo, cada processador, de cada fabricante(Intel, AMD, Motorola,...), tem o seu prprio assembly, j que cada um tem estrutura interna dio a ferente, mas o termo assembly aplica-se a todos eles (i.e. no h uma linguagem assema a blyIntelou assemblyAMD, tal como existe Pascal ou C). O que acontece dizer-se que se e est a utilizar o assembly do Pentium, do Athlon, ou do Motorola68000. Em princ a pio, um programa que utilize o assembly do Pentium no ser executado por um processador de outro a a fabricante, a menos que sejam compat veis entre si. O termo assembler (montadorem ingls) refere-se a um programa que permite facilitar e o trabalho com a linguagem assembly, fazendo com que esta se assemelhe um pouco mais a

uma linguagem de alto-n vel. De facto, torna-se muito complicado para os programadores humanos escrever programas usando a linguagem purado processador (linguagem-mquina), a a qual constitu por um conjunto mais ou menos extenso de bits (ex: a instruo mov e da ca ah,40h, muito usada em assembly, corresponde a 1011010010000000 - bits a unica coisa e que as mquinas entendem!). O assembler atribui nomes (mnemnicas) aos conjuntos de a o bits que constituem as instrues do processador, facilitando a sua compreenso pelos humaco a nos. O assembler tambm chama a si a execuo de um conjunto de aces necessrias para e ca co a que um programa possa ser executado (p.ex. o controlo de certos registos do processador), escondendo essas operaes ao programador. co

2) NASM - Netwide Assembler

O NASM ( Netwide Assembler) um assembler e desassembler para a Intel x86 arquie tetura. Ele pode ser usado para escrever programas em 16-bit e 32-bits, foi originalmente escrito por Simon Tatham com a ajuda de Julian Hall, e atualmente mantido por uma pequena equipe liderada por H. Peter Anvin. NASM pode produzir vrios formatos binrios a a incluindo COFF, ELF e Mach-O entre outros. A variedade de formatos de sa permite que programas sejam retargetted a praticada mente qualquer sistema operacional x86. Alm disso, NASM pode criar arquivos binrios e a simples e pode ser executado em plataformas no-x86, como o SPARC e PowerPC, embora a gerar programas utilizvel por essas mquinas. a a

2.1) Instalao do NASM ca

2.1.1) No Windows
Primeiramente entre no site ocial do NASM, www.nasm.us e, clicando em DOWNLOADS, procure pela ultima verso lanada. Aps isso, clique no diretrio Win32, e baixe o a c o o arquivo nasm-XXX-win32.zip ( onde XXX a verso do NASM ), e o extraia em sua prpria e a o alguma pasta (exemplo c:/nasm). Aps isso, v em Iniciar Painel de controle Sistema o a Conguraes avanadas Variveis do ambiente, e em variveis do sistema, clique em novo. co c a a No nome da varivel, coloque NASM e em valor, coloque aonde o executavel do nasm est ( a a exemplo: C:/nasm/nasm-XXX/nasm.exe ).

2.1.2) No Linux
2

Podemos achar a verso para rodar o NASM em Linux no seguinte site SourceForge.net. a Aps a instalao da verso desejada, crie um diretrio na area do usurio e coloque o nasmo ca a o a XXX.tar.gz (onde XXX representa a verso do nasm) neste diretrio e o descompacteo arquivo a o de instalao. Feito isso, abrir o tar do arquivo de instalao nesse diretorio: tar xvf nasmca ca xxx.tar, entrar no diretrio criado durante o processo de untar: cd nasm-xxx. Para mais o informaes, abrir o arquivo INSTALL localizado no diretrio. co o

2.2) Conjunto de instruoes c

Em NASM temos o seguinte conjunto de instrues: co ADD - Adio : Executa a adio normal entre dois operandos, um fonte e outro destino, ca ca devolvendo o resultado no destino. CALL - Chama um procedimento : Chamar uma sub-rotina. Isto implica em mudar o uxo normal de execuo, processar uma sub-rotina e voltar ao ponto do programa imediaca tamente posterior ` instruo de chamada da sub-rotina. a ca CMP - Compara dois operandos : Efetuar uma subtrao entre dois operandos, alterando ca os ags, mas no devolvendo o resultado no operando-destino. a DIV - Diviso : Executar a diviso no sinalizada entre dois operandos. Com esta insa a a truo pode-se dividir o contedo do acumulador AX por um registrador de 8 bits ou por um ca u byte na memria, obtendo-se o quociente em AL e o resto em AH; ou dividir o contedo em o u DX:AX (valor de 32 bits) por um registrador de 16 bits ou palavra na memria, obtendo-se o ento o quociente em AX e o resto da diviso em DX. a a INC - Incremento : Somar 1 ao contedo de um operando, que pode ser registrador ou u posio de memria. ca o INT - Interrupo : Alterar o uxo normal de execuo do programa, desviando-se para ca ca uma rotina de interrupo, cujo vetor (endereo formado por CS:IP) est presente numa taca c a bela nos primeiros 1.024 bytes da memria. o J(condio) - Pulo com condio : Desviar o uxo do processamento para o operando-alvo, ca ca se uma condio testada for encontrada. ca JMP - Pulo : Provocar um desvio incondicional no uxo de processamento, transferindo a execuo para o operando-alvo. ca LEA - Carregamento efetivo de endereo : Carregar o endereo de oset, ou deslocamento c c de um operando na memria para o registrador de 16 bits, o endereo de um operando na o c memria o

LOOP : Decrementar o contedo do registrador contador CX e provocar um desvio no u uxo do processamento para o operando-alvo, se o valor em CX ainda no for 0. a MOV - Move : Copiar o contedo do operando-fonte para o operando-destino. O contedo u u da fonte no afetado. a e MUL - Multiplicao : Efetuar uma multiplicao no sinalizada entre o contedo do acuca ca a u mulador (AL ou AX) pelo operando-fonte, devolvendo o resultado no acumulador AX (caso a operao tenha envolvido AL com um operando de 8 bits), ou em DX e AX (caso a operao ca ca tenha envolvido AX e um operando de 16 bits). POP : Retirar a palavra armazenada no topo da pilha, colocando-a no registrador ou posio de memria especicada que necessariamente deve ser de 16 bits. ca o PUSH : Colocar, na rea de memria usada como pilha, o contedo de um registrador ou a o u posio de memria. Esta rea endereada por SS e SP. ca o a e c RET - Retornar : Encerrar uma sub-rotina, transferindo o uxo do processamento para a instruo seguinte ` chamada da sub-rotina. ca a SUB - Subtrao : Efetuar uma subtrao entre o contedo do operando-fonte e o contedo ca ca u u do operando-destino. O resultado da operao estar no operando-destino. ca a

2.3) Registradores
EAX - registrador acumulador EBX - registrador base ECX - registrador contador EDX - registrador de dados ESI - registrador de ndice da fonte dos dados EDI - registrador de ndice do destino dos dados EBP - registrador ponteiro para a moldura de chamada de funo ca ESP - registrador ponteiro para a pilha de execuo ca Esses nomes derivam da forma como eram utilizados nas arquiteturas anteriores a IA32 (8086, 80286...), em que cada registrador desempenhava um papel espec co. Na arquitetura i386, todos eles so de uso geral, embora eles continuem a poder ser utilizados em seus papis a e tradicionais. Podemos tambm observar na gura 1 alguns outros registradores e os seus e bytes.

Figura 1: Registradores NASM

2.4) Stack Frame

Cada programa do computador, quando executado, usa uma regio de memria chae a o mada de pilha que permite que funes funcionem corretamente. Esta pilha e igual a um co pilha de pratos, o ultimo prato empilhado e o primeiro que vai sair (UEPS), a diferena de c uma pilha de pratos e a pilha do computador, e que a pilha do computador e invertida, ou seja ,o topo ca em baixo. Voc pode colocar um valores no topo da pilha atravs de uma e e instruo chamada push. ca O registrador esp (Stack Pointer), e o registrador que guarda o endereo do topo da pilha, c seja l aonde ele estiver. Quando damos push na pilha, o registrador esp subtra por 4 a e do para que ele aponte para o novo topo da pilha (pois cada seguimentoda pilha tem comprimento 4 bytes, e a pilha cresce para baixo). Para remover alguma coisa da pilha, usamos a instruo pop, que adicionar 4 no regisca a trador esp. As instrues push e pop precisam de um operando, um valor ser colocado na co pilha, ou um lugarpara receber a informao que tirada da pilha. Se ns queremos obter ca e o o valor no topo da pilha, sem remov-lo, podemos usar o registrador esp para obter o valor e e guardar em algum lugar, como um registrador. Exemplo: mov eax, [esp] ; o valor que o esp esta apontando e copiado para o registrador eax ;e preciso colocar o esp entre colchetes. mov eax, esp ;se for colocado assim, o endereo que o esp esta guardando e copiado para c ;eax e no o contedo. a u Como chamar uma funo passo a passo. ca 5

Dar o push em todas a variveis na pilha, com a intruo call voc chama a funo. A a ca e ca instruo call faz duas coisas. Primeiro ela d push do endereo da prxima instruo, que ca a c o ca e o endereo de retorno, na pilha. Em seguida modica o ponteiro de instruo eip (Instruction c ca Pointer) para apontar para o in cio da funo. Depois salvar o registrador do ponteiro da ca base, ebp (Base Pointer), com push ebp; .O registrador ebp tambem e conhecido por frame pointer. Copiar o ponteiro do topo da pilha para ebp com mov esp,ebp; . A funo chamada ca reserva espao na pilha para as variveis locais que ela ir precisar. Isso feito alterando c a a e o ponteiro do topo da pilha. Quando uma funo termina de ser executada, so feitas trs ca a e coisas. Primeiro, ela armazena o valor de retorno em eax. Segundo, a pilha alterada para e aonde ela estava antes de ser chamada . Terceiro, retorna o controle do programa para de onde ele foi chamado. A instruo ret usada para retornar o controle, dando um pop da ca e pilha, alterando o ponteiro de instruo, eip, para o valor que estava no topo da pilha. Resca tauramos o ponteiro da pilha esp e o ponteiro da base ebp para o qu eles eram antes da e funo ser chamada. ca mov ebp,esp; pop ebp; ret; Enm, o controle voltou para o cdigo que chamou a funo, e agora ele pode examio ca nar o valor de retorno em eax. O cdigo que chamou tambm precisa dar pop de todos os o e parmetros que foram colocados na pilha, para que a a pilha volte para o que ela era antes. a

3) Execuo do NASM ca
Ao instalar o NASM (vide item 2.1), o prximo passo ser abri-lo. Para isto, abra o o a Prompt de Comando e, digitando o comando cd, chegue at a pasta aonde foi colocado o e nasm.exe (exemplo cd c:/nasm/nasm-xxx). Veja a gura 2. Aps isso, voc estara na pasta o e do nasm, ento agora s faltar criar o executvel do arquivo assembly criado. Para isto, usaa o a a remos como exemplo um programa de nome exemplo1.asm. Ento agora, digite o comando a nasm -o exemplo1.com exemplo1.asm, e o executvel ser criado. Em seguida digita exema a plo1 para abrir o exemplo1.exe. Veja a gura 3, com os comandos de criao de executvel ca a mais execuo do arquivo. ca

4) Programas em NASM

Figura 2: Chegando na pasta do nasm.exe.

Figura 3: Criao do executvel e execuo do arquivo. ca a ca

A seguir apresentaremos uma sequncia de programas desenvolvidos e na linguagem NASM e MiniJava. 4.1) Programa Vazio start : mov AH, 0 i n t 21h ; i n i c i o do programa ; AH = 0 , e s t a f u n a o pode s e r usada para c ; i n v o c a ao DOS, e n c e r r a n d o o programa

p u b l i c c l a s s ProgramaVazio { }
7

4.2) Programa Atribui s e c t i o n . data x : dd 0 mov eax , 4 mov [ x ] , eax i n t 21h ; i n i c i a a s e a o de dados , para implementa ao c c ; de dados ; d e c l a r a uma v a r i a v e l x com v a l o r i n i c i a l 0 ; move o v a l o r 4 para o r e g i s t r a d o r eax ; a t r i b u i o v a l o r de eax em x ; f i n a l i z a o programa

p u b l i c c l a s s ProgramaAtribui { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { int x = 4; } } 4.3) Programa Soma s e c t i o n . data x : dd 0 y : dd 0 z : dd 0 mov eax , 2 mov [ x ] , eax mov eax , 5 mov [ y ] , eax ; ; ; ; ; inicia a de dados variavel variavel variavel s e a o de dados para implementa ao c c x com v a l o r i n i c i a l 0 y com v a l o r i n i c i a l 0 z com v a l o r i n i c i a l 0

; move o v a l o r 2 para eax ( eax = 2 ) ; a t r i b u i o v a l o r de eax para a v a r i a v e l x ; move o v a l o r 5 para eax ( eax = 5 ) ; a t r i b u i o v a l o r de eax para a v a r i a v e l y ; ( y = eax ) ; a t r i b u i o v a l o r de x a cx ( cx = x ) ; a t r i b u i o v a l o r de cx para z ( z = cx == 2 )
8

mov cx , [ x ] mov [ z ] , cx

mov cx , [ y ] add [ z ] , cx i n t 21h

; a t r i b u i o v a l o de y a cx ( cx = y ) ; a d i c i o n a o v a l o r de cx a z ( z = cx + z ) ; e n c e r r a o programa

p u b l i c c l a s s ProgramaSoma { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { int x ,y , z ; x = 2; y = 5; z = x + y; } } 4.4) Programa Imprimi Soma section . text ; i n i c i a a s e a o t e x t o para implementa ao de c c ; textos ; i n i c i a a s e a o dados , para implementa ao de c c ; dados

s e c t i o n . data

x : t i m e s 4 db 0 ; 32 b i t s i n t e g e r = 4 b y t e s y : t i m e s 4 db 0 z : t i m e s 4 db 0 mov eax , 2 mov [ x ] , eax mov eax , 5 mov [ y ] , eax mov cx , [ x ] mov [ z ] , cx ; a t r i b u i a eax o v a l o r 2 ( eax = 2 ) ; a t r i b u i o v a l o r de eax para x ( x = eax ) ; a t r i b u i a eax o v a l o r 5 ( eax = 5 ) ; a t r i b u i o v a l o r de eax para y ( y = eax ) ; a t r i b u i a cx o v a l o r de x ( cx = x ) ; a t r i b u i a z o v a l o r de cx ( z = cx )
9

mov cx , [ y ] add [ z ] , cx

; a t r i b u i a cx o v a l o r y ( cx = y ) ; a d i c i o n a ao v a l o r de z o v a l o r de cx ; ( z = z + cx )

p r o c e d i m e n t o I m p r i m i r : ; come o do procedimento para i m p r i m i r c mov cx , [ z ] mov ax , cx mov dx , ax add dx , 0 ; a t r i b u i a cx o v a l o r de z ( cx = z ) ; a t r i b u i a ax o v a l o r de cx ( ax = cx ) ; a t r i b u i a dx o v a l o r de ax ( dx = ax ) ; c o n v e r t e dx em d i g i t o h e x a d e c i m a l ; obs : n e s s e c a s o como o numero e 7 entao ; nao ha problema em u s a r e s t e comando ; imprimi o v a l o r hex ; f i n a l i z a programa

mov ah , 2 h i n t 21h mov ah , 4Ch i n t 21h

p u b l i c c l a s s ImprimeSoma { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { int x ,y , z ; x = 2; y = 5; z = x + y; System . out . p r i n t l n ( z ) ; } } 4.5) Programa Imprimi Texto s e c t i o n . data

; i n i c i a s e a o de implementa ao de dado c c
10

s db Alo Mundo$ section . text o rg 100h l e a dx , [ s ] mov ah , 9 i n t 21h mov ah , 4 Ch i n t 21h

; c a d e i a de c a r a c t e r e s nomeada como s

; i n i c i a s e a o de implementa ao de t e x t o c c ; p o s i a o de memoria u t i l i z a d a c ; aponta para o i n i c i o da c a d e i a ; e s c r e v e a c a d e i a de c a r a c t e r e ; p r o c e s s o para f i n a l i z a c a o do programa

p u b l i c c l a s s ProgramaAlo { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { S t r i n g s = Alo Mundo ; System . out . p r i n t l n ( s ) ; } } 4.6) Programa Condicional s e c t i o n . data c e r t o db Certo$ e r r a d o db Errado$ ; x : dw 10 32; section . text o rg 100h mov ax , [ x ] ; cmp ax , 4 ; jnz erro

; i n i c i a s e a o de implementa ao de dado c c ; c a d e i a de c a r a c t e r e s nomeada como s

; i n i c i a s e a o de implementa ao de t e x t o c c ; p o s i a o de memoria u t i l i z a d a c

; e s c r e v e Certo s e x = 4 l e a dx , [ c e r t o ] ; aponta para o i n i c i o da c a d e i a mov ah , 9 ;

11

i n t 21h ; jmp fim ; ; e s c r e v e Errado s e x != 4 erro : l e a dx , [ e r r a d o ] ; aponta para o i n i c i o da c a d e i a mov ah , 9 ; e s c r e v e a c a d e i a de c a r a c t e r e i n t 21h ; ; p r o c e s s o para f i n a l i z a a o do programa c fim : mov ah , 4 Ch i n t 21h p u b l i c c l a s s ProgramaCondicional { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { i n t x = 10 32; i f ( x == 4){ System . out . p r i n t l n ( CERTO ) ; } else{ System . out . p r i n t l n ( ERRADO ) ; } } } 4.7) Programa Repetio ca s e c t i o n . data s : db x = $ ; x : dw 0 ; section . text ;
12

o rg 100h ; mov ax , [ x ] ; while : cmp jnc add add jmp escreve : lea mov int lea mov int dx , [ s ] ; ah , 9 ; 21h ; dx , [ x ] ; ah , 9 ; 21h ; ax , 5 ; escreve ax , ax ; ax , 1 ; while ;

; p r o c e s s o para f i n a l i z a a o do programa c fim : mov ah , 4 Ch i n t 21h p u b l i c c l a s s ProgramaRepeticao { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { int x = 0; w h i l e ( x < 5){ x += 1 ; } System . out . p r i n t l n ( x = +x ) ; } } 4.8) Programa Fatorial s e c t i o n . data

; i n i c i a s e a o de implementa ao de dado c c
13

msg db D i g i t e um numero$ msg2 db O f a t o r i a l de$ l e r db 6 3 , 0 t i m e s 64 DB 0 ; t i m e s 64 db 0 s e c t i o n . bass n : resd 0 fat : resd 0 section . text o rg 100h

; i n i c i a s e a o de implementa ao de t e x t o c c ; p o s i a o de memoria u t i l i z a d a c

l e a dx , [ msg ] ; aponta para o i n i c i o da c a d e i a mov ah , 9 i n t 21h Ler : lea mov int mov mov mov mov While : cmp jno mov add mov mul mov mov sub mov jmp cl ,0 Escreve ebx , [ f a t ] ebx , ebx eax , [ n ] ebx [ f a t ] , eax eax , [ n ] eax , 1 [ n ] , eax While
14

dx , [ l e r ] ax , 0AH 21h cl , [ l e r ] [n] , cl eax , 1 [ f a t ] , eax

Escreve : mov lea int mov lea int ah , 9 dx , [ msg2 ] ; aponta para o i n i c i o da c a d e i a 21h ah , 9 ; dx , [ n ] ; aponta para o i n i c i o da c a d e i a 21h

; p r o c e s s o para f i n a l i z a a o do programa c fim : mov ah , 4 Ch i n t 21h import j a v a . u t i l . Scanner ; public c l a s s ProgramaFatorial { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { Scanner s = new Scanner ( System . i n ) ; int n; int fat ; System . out . p r i n t l n ( D i g i t e um numero ) ; n = s . nextInt ( ) ; fat = 1; w h i l e ( n > 0){ fat = fat n; n = n1; } System . out . p r i n t l n ( O f a t o r i a l de +n+ Ac + f a t ) ; } } 4.9) Programa Positivo s e c t i o n . data

; i n i c i a s e a o de implementa ao de dado c c

15

msg db D i g i t e um numero$ ; msg2 db Numero p o s i t i v o $ ; msg3 db Zero$ ; msg4 db Numero n e g a t i v o $ ; l e r db 6 3 , 0 t i m e s 64 db 0 ; s e c t i o n . bss n : resd 1; section . text o rg 100h escreve : l e a dx , [ msg ] ; aponta para o i n i c i o da c a d e i a mov ah , 9 ; i n t 21h ; lerA : lea mov int mov mov cmp jno dx , [ l e r ] ax , 0AH; 21h ; cl , [ l e r ] ; [n] , cl ; cl , 0 ; else ;

; i n i c i a s e a o de implementa ao de t e x t o c c ; p o s i a o de memoria u t i l i z a d a c

; e s c r e v e Numero p o s i t i v o s e x > 4 l e a dx , [ msg2 ] ; aponta para o i n i c i o da c a d e i a mov ah , 9 ; i n t 21h ; jmp fim ;

else : mov c l , [ n ] ;
16

cmp jnz lea mov int jmp elsee :

cl ,0 elsee ; dx , [ msg3 ] ; ah , 9 ; 21h ; fim ;

l e a dx , [ msg4 ] ; mov ah , 9 ; i n t 21h ; ; p r o c e s s o para f i n a l i z a a o do programa c fim : mov ah , 4 Ch i n t 21h import j a v a . u t i l . Scanner ; public c l a s s ProgramaPositivo { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { System . out . p r i n t l n ( D i g i t e um numero ) ; Scanner s = new Scanner ( System . i n ) ; int n = s . nextInt ( ) ; i f ( n > 0){ System . out . p r i n t l n ( Numero p o s i t i v o ) ; } else{ i f ( n == 0){ System . out . p r i n t l n ( Zero ) ; } else System . out . p r i n t l n ( Numero n e g a t i v o ) ; }
17

} } 4.10) Programa Triangulo s e c t i o n . data

; i n i c i a s e a o de implementa ao de dado c c

msg : db D i g i t e t r e s numeros i n t e i r o s e p o s i t i v o s $ ; msg2 : db T r i a n g u l o E q u i l a t e r o $ ; msg3 : db T r i a n g u l o Escaleno$ ; msg4 : db Essa medidas nao formam um t r i a n g u l o $ ; msg5 : db T r i a n g o l o I s o s c e l e s $ ; l e r : t i m e s 64 db 0 ; l e r A : t i m e s 64 db 0 ; l e r B : t i m e s 64 db 0 ; section x : resd y : resd z : resd . bss 1; 1; 1;

section . text o rg 100h escreve :

; i n i c i a s e a o de implementa ao de t e x t o c c ; p o s i a o de memoria u t i l i z a d a c

l e a dx , [ msg ] ; aponta para o i n i c i o da c a d e i a mov ah , 9 ; i n t 21h ; ; ler lea mov int mov mov lea mov dx , [ l e r ] ax , 0AH; 21h ; cl , [ l e r ] ; [x] , cl ; dx , [ l e r A ] ax , 0AH;
18

int mov mov lea mov int mov mov

21h ; cl , [ lerA ] ; [y] , cl ; dx , [ l e r B ] ax , 0AH; 21h ; cl , [ lerB ] ; [ z ] , cl ;

mov ax , [ x ] ; mov bx , [ y ] ; mov cx , [ z ] ; ; If add add cmp jnc add add cmp jnc add add cmp jnc ; if cmp jnz cmp jnz ; entao l e a dx , [ msg2 ] ; mov ah , 9 ;
19

dx , bx ; dx , cx ; ax , dx ; elseA ; dx , ax ; dx , cx ; bx , dx ; elseA ; dx , ax ; dx , bx ; cx , dx ; elseA ;

ax , bx ; elseB ; bx , cx ; elseB ;

i n t 21h ; jmp fim ; elseB : ; if cmp jnz lea mov int jmp ax , bx ; comparacaoA ; dx , [ msg5 ] ; ah , 9 ; 21h ; fim ;

comparacaoA : cmp ax , cx ; j n z comparacaoB ; l e a dx , [ msg5 ] ; mov ah , 9 ; i n t 21h ; jmp fim ; comparacaoB : cmp bx , cx ; jnz elseC ; l e a dx , [ msg5 ] ; mov ah , 9 ; i n t 21h ; jmp fim ; elseC : ; if cmp ax , bx ; j z elseA ; cmp ax , cx ; j z elseA ; cmp bx , cx ;
20

j z elseA ; l e a dx , [ msg5 ] ; mov ah , 3 ; i n t 21h ; jmp fim ; elseA : lea mov int jmp dx , [ msg4 ] ; aponta para o i n i c i o da c a d e i a ah , 9 ; 21h ; fim ;

; p r o c e s s o para f i n a l i z a a o do programa c fim : mov ah , 4 Ch i n t 21h import j a v a . u t i l . Scanner ;

p u b l i c c l a s s ProgramaTriangulo { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { Scanner s = new Scanner ( System . i n ) ; System . out . p r i n t l n ( D i g i t e t r A a s numeros i n t e i r o s e p o s int x = s . nextInt ( ) ; int y = s . nextInt ( ) ; int z = s . nextInt ( ) ; i f ( x < y + z && y < x + z && z < x + y ){ i f ( x == y && y == z ){ System . out . p r i n t l n ( T r i a n g u l o E q u i l a t e r o ) ; } else{ i f ( x == y | | x == z | | y == z ){ System . out . p r i n t l n ( T r i a n g u l o I s o s c e l e s ) ; } else{ i f ( ! ( x==y ) | | ! ( x==z ) | | ! ( y==z ) ) {
21

System . out . p r i n t l n ( T r i a n g u l o E s c a l e n o

} else{ System . out . p r i n t l n ( E s s a s medidas nao fo } } } } } } 4.11) Programa Intercala ; Codigo que f a z a l i g a a o com o g c c c . file i n t e r c a l a . cpp . section . t e x t $ g e t c h a r , x . linkonce discard . globl getchar getchar ; . def . scl 2; . type 32; . endef getchar : LFB2 : . cfi startproc ; push ebp ; . c f i d e f c f a o f f s e t 8; . c f i o f f s e t 5 , 8; mov esp , ebp ; . c f i d e f c f a r e g i s t e r 5; sub esp , 2 4 ; mov eax , imp iob ; mov 4 ( eax ) , eax ; leal 1( eax ) , edx ; mov eax , i m p iob ;
22

mov mov mov test js mov mov mov mov leal mov mov jmp L2 : mov mov call L3 :

edx , 4 ( eax ) ; imp i o b , eax ; 4 ( eax ) , eax ; eax , eax ; L2 ; imp i o b , eax ; ( eax ) , edx ; ( edx ) , a l ; a l , eax ; 1 ( edx ) , ecx ; imp i o b , edx ; ecx , ( edx ) ; L3 ; imp i o b , eax ; eax , ( esp ) ; filbuf ;

leave ; . c f i r e s t o r e 5; . c f i d e f c f a 4 , 4; ret ; . cfi endproc ; LFE2 : . def main ; . scl 2; . type 32; . endef . s e c t i o n . rdata , dr LC0 : . a s c i i %d \ 0 ; LC1 : . a s c i i %d \ 0 ; . text ; . globl main ; . def main ; . s c l
23

2;

. type

32;

. endef ;

main : LFB8 : . cfi startproc ; pushl %ebp ; . c f i d e f c f a o f f s e t 8; . c f i o f f s e t 5 , 8; movl %esp , %ebp ; . c f i d e f c f a r e g i s t e r 5; andl $ 16 , %esp ; subl $192 , %esp ; main ; Chama a f u n c a o main call movl $1 , 184(% esp ) movl 184(% esp ) , %eax movl %eax , 188(% esp ) jmp L5 L6 : leal movl sall addl movl movl call movl movl movl movl incl leal movl sall addl movl movl call 104( esp ) , eax ; 188( esp ) , edx ; $2 , edx ; edx , eax ; eax , 4 ( esp ) ; $LC0 , ( esp ) ; scanf ; 188( esp ) , eax ; 104( esp , eax , 4 ) , edx ; 184(% esp ) , eax ; edx , 24 ( esp , eax , 4 ) ; 184( esp ) ; 144( esp ) , eax ; 188( esp ) , edx ; $2 , edx ; edx , eax ; eax , 4 ( esp ) ; $LC0 , ( esp ) ; scanf ;
24

movl movl movl movl incl incl L5 : cmpl setle testb jne movl jmp L8 : movl movl movl movl call incl L7 :

188( esp ) , eax ; 144( esp , eax , 4 ) , edx ; 184( esp ) , eax ; edx , 24 ( esp , eax , 4 ) ; 184( esp ) ; 188( esp ) ; $9 , 188( esp ) ; al ; al , a l ; L6 ; $1 , 188 ( esp ) ; L7 ; 188( esp ) , eax ; 2 4( esp , eax , 4 ) , eax ; eax , 4 ( esp ) ; $LC1 , ( esp ) ; printf ; 188( esp ) ;

cmpl $19 , 188( esp ) ; setle al ; testb %a l , %a l ; jne L8 ; getchar ; call call getchar ; movl $0 , %eax ; leave ; . c f i r e s t o r e 5; . c f i d e f c f a 4 , 4; ret ; . cfi endproc ; LFE8 : . def filbuf ;
25

. scl

2;

. type

32;

. def . def

scanf ; . scl printf ;

2; . scl

. type 2;

32; . type

. endef 32;

import j a v a . u t i l . Scanner ; public c l a s s ProgramaIntercala { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { Scanner s = new Scanner ( System . i n ) ; i n t v e r t 1 [ ] = new i n t [ 1 0 ] ; i n t v e r t 2 [ ] = new i n t [ 1 0 ] ; i n t v e r t 3 [ ] = new i n t [ 2 0 ] ; int j = 1; int i = 1; w h i l e ( i <10){ vert1 [ i ] = s . nextInt ( ) ; vert3 [ j ] = vert1 [ i ] ; j = j + 1; vert2 [ i ] = s . nextInt ( ) ; vert3 [ j ] = vert2 [ i ] ; j = j + 1; i = i + 1; } i = 1; w h i l e ( i < 20){ System . out . p r i n t l n ( v e r t 3 [ i ] ) ; i = i + 1; } } } 4.12) Programa Salario s e c t i o n . data ; d e c l a r a c a o de dados s db O novo s a l a r i o e$ ; s t r i n g

26

p e r c : dd 0 ; v a r i a v e i s v a l o r : dd 0 s a l : dd 0 aumento : dd 0 novoSal : dd 0 s e c t i o n . t e x t ; d e c l a r a c a o de t e x t o o rg 500h ; e s p a o a l o c a d o c mov int lea mov int ah , 8 21h dx , [ s a l ] ah , 0 ah 21h

c a l l Calculo mov cx , [ v a l o r ] mov [ aumento ] , cx mov mov add mov cx , [ s a l ] dx , [ aumento ] cx , dx [ novoSal ] , cx

l e a eax , [ s ] mov ah , 9 i n t 21h l e a eax , [ novoSal ] mov ah , 9 i n t 21h mov ah , 4Ch i n t 21h
27

C a l c u l o : ; f u n a o c a l c u l o f a z v a l o r = s a l p e r c /100 c mov int lea mov mov mov mul mov div mov ret import j a v a . u t i l . Scanner ; public c l a s s ProgramaSalario { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) { Scanner s = new Scanner ( System . i n ) ; int sal = s . nextInt ( ) ; i n t aumento = c a l c u l o ( s a l ) ; i n t novoSal = soma ( s a l , aumento ) ; System . out . p r i n t l n ( O novo\+novoSal \ Ac +novoSal ) ; } p u b l i c s t a t i c i n t c a l c u l o ( i n t s a l ){ Scanner s = new Scanner ( System . i n ) ; int perc = s . nextInt ( ) ; int valor = s a l perc /100; return valor ; } p u b l i c s t a t i c i n t soma ( i n t x , i n t y ){ r e t u r n ( x+y ) ;
28

ah , 8 21h dx , [ p e r c ] ah , 0 ah ax , [ s a l ] cx , [ p e r c ] cx cx , [ p e r c ] cx [ v a l o r ] , dx

} } 4.13) Programa Salario 2 s e c t i o n . data ; d e c l a r a c a o de dados s db O novo s a l a r i o e$ ; s t r i n g p e r c : dd 0 ; v a r i a v e i s v a l o r : dd 0 s a l : dd 0 aumento : dd 0 novoSal : dd 0 s e c t i o n . t e x t ; d e c l a r a c a o de t e x t o o rg 500h ; e s p a o a l o c a d o c mov int lea mov int ah , 8 21h dx , [ s a l ] ah , 0 ah 21h

c a l l C a l c u l o ; chamada de f u n c a o mov cx , [ v a l o r ] mov [ aumento ] , cx c a l l Soma ; chamada de f u n a o c mov [ novoSal ] , cx l e a eax , [ s ] mov ah , 9 ; imprimi t e x t o s i n t 21h

29

l e a eax , [ novoSal ] mov ah , 9 ; imprimi numero i n t 21h mov ah , 4Ch i n t 21h C a l c u l o : ; f u n a o c a l c u l o f a z v a l o r = s a l p e r c /100 c mov int lea mov mov mov mul mov div mov ret Soma : ; f u n a o soma c mov cx , [ s a l ] mov dx , [ aumento ] add cx , dx ret import j a v a . u t i l . Scanner ; public c l a s s ProgramaSalario2 { p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
30

ah , 8 21h dx , [ p e r c ] ah , 0 ah ax , [ s a l ] cx , [ p e r c ] cx cx , [ p e r c ] cx [ v a l o r ] , dx

Scanner s = new Scanner ( System . i n ) ; int sal = s . nextInt ( ) ; i n t aumento = c a l c u l o ( s a l ) ; i n t novoSal = s a l + aumento ; System . out . p r i n t l n ( Novo s a l a r i o Ac +novoSal ) ; } p u b l i c s t a t i c i n t c a l c u l o ( i n t s a l ){ Scanner s = new Scanner ( System . i n ) ; int perc = s . nextInt ( ) ; int valor = s a l perc /100; return valor ; } }

31