Gabarito Lista de Exercícios - Arquitetura de Computadores II

Prévia do material em texto

Arquitetura de Computadores II 
Primeira Lista de Exercícios 
Prof. Adalberto Gualeve 
1) Para cada uma das instruções a seguir, determine o sufixo apropriado baseado nos operandos 
movl__ %eax, (%esp) 
movw__ (%eax), %dx 
movb__ $0xFF, %bl 
movb__ (%esp,%edx), %dh 
pushb_ $0xFF 
movw__ %dx, (%eax) 
popl__ %edi 
 
2) Cada uma das linhas de código a seguir gera um erro quando é chamado o montador. Explique o 
que há de errado em cada linha. 
movb $0xF, (%bl) 
­ o operando destino é endereçado por um registrador de 8bits, o que não é possível 
movl %ax, (%esp) 
­ uso incorreto do registrador %ax para o sufixo `l` da instrução mov 
movw (%eax), 4(%esp) 
­ muitas referências à memória pela instrução `mov` 
movb %ah, %sh 
­ nome de registrador `%sh` inválido 
movl %eax, $0x123 
­ posições dos operandos invertidas 
movl %eax,%dx 
­ incompatibilidade de tamanhos de registradores (32 e 16bits) na mesma instrução 
movl %si, 8(%ebp) 
­ uso incorreto do registrador %si para o sufixo `l` da instrução mov 
 
 
 
 
3) Suponha que o registrador %eax contenha o valor x e o registrador %ecx contenha o valor de y. 
Preencha a tabela abaixo com os valores que são armazenados em %edx para cada fórmula usada. 
 
Instrução…………………………..Resultado……………. 
leal 6(%eax), %edx _x+6____ 
leal (%eax,%ecx), %edx _x+y____ 
leal (%eax,%ecx,4), %edx _x+4y___ 
leal 7(%eax,%eax,8), %edx _9x+7___ 
leal 0xA(, %ecx, 4), %edx _4y+10__ 
leal 9(%eax,%ecx,2), %edx _x+2y+9_ 
 
4) Assuma que os seguintes valores estão armazenados na memória e registradores: 
Endereço Valor Registrador Valor 
0x100 0xFF %eax 0x100 
0x104 0xAB %ecx 0x1 
0x108 0x13 %edx 0x3 
0x10c 0x11  
 
Preencha a seguinte tabela mostrando os efeitos das instruções abaixo tanto nos 
registradores quanto na memória. 
 
 
Instrução Destino Valor 
 
addl %ecx, (%eax) _0x100_ _0x1__ 
 
subl %edx, 4(%eax) _0x104_ _0x3_ 
 
imull 16, (%eax,%edx,4) _0x10c_ _0x110_ 
 
incl 8 (%eax) _0x100_ _0x00_ 
 
decl %ecx _%ecx_ _0x00_ 
 
subl %edx, %eax _%eax_ _0xFD_ 
 
5) Suponha que você queira gerar o seguinte código em linguagem C: 
int shift_left2_rightn( int x, int n ) { 
x = x << 2; 
x = x >> n; 
return x; 
} 
 
O código abaixo é uma parte do código assembly que faz os deslocamentos e retorno do 
resultado no registrador %eax. Duas operações foram omitidas e os parâmetros x e n 
recebidos pela função estão nos endereços apontados por %esp nos deslocamentos 4 e 8 
respectivamente. Preencha as instruções omitidas: 
 
(1) movl 4(%esp), %eax ; Recebe x 
 
(2) sall $2, %eax ; x<<=2 
 
(3) movl 8(%esp), %ecx ; Recebe n 
 
(4) sarl %cl, %eax ; x >>=n 
 
 
6) O seguinte código C 
int comp( data_t   a, data_t  b ) { 
return  a COMP b ; 
} 
 
retorna uma comparação entre os argumentos a e b, definidos como tipo data_t. A 
comparação é feita pela operação COMP. Suponha que “a” está em %edx e “b” está em 
%eax. Para cada uma das seguintes instruções abaixo, determinar quais tipos de dados 
data_t e que comparações COMP poderiam ser geradas pelo compilador. (Pode haver 
várias respostas corretas; você deve listar todas elas.) 
 
a) 
cmpl %eax, %edx 
setl %al 
int comp( int   a, int  b ) { 
return  a < b ; 
} 
 
b) 
cmpw %ax, %dx 
setge %al 
int comp( short int   a, short int  b ) { 
return  a >= b ; 
} 
 
c) 
cmpb %eax, %edx 
setb %al 
int comp( unsigned char   a, unsigned char  b ) { 
return  a < b ; 
} 
 
d) 
cmpl %eax, %edx 
setne %al 
int comp( int   a, int  b ) { 
return  a != b ; 
} 
 
 
 
7) Nas listagens abaixo geradas por um desmontador, algumas informações foram substituídas por 
Xs. Responda as seguintes questões sobre essas instruções: 
 
a) Qual o alvo da instrução “je” abaixo? 
804828f: 74 05 je 8048296 
8048291: e8 1e 00 00 00 call 80482b4 
 
(obs.:  0x8048291 + 0x05 = 0x8048296) 
 
b) Qual o alvo da instrução “jb” abaixo? 
8048357: 72 e7 jb 8048340 
8048359: c6 05 10 a0 04 08 01 movb $0x1, 0x804a010 
 
(obs.:  8048359 + 0xe7 = 0x8048340) 
 
c) Qual o endereço da instrução “mov” abaixo? 
803837d: 74 12 je 8038391 
803837f: b8 00 00 00 00 mov $0x0, %eax 
 
(obs.:  8038391 - 0x12 = 0x803837f) 
 
d) No código a seguir, o alvo do jump está codificado no formato PC­relativo como um 
número em complemento a dois de 4­bytes. A ordem dos bytes é little­endian. Qual o 
endereço alvo do jump? 
80482bf: e9 e0 ff ff ff jmp 80482a4 
80482c4: 90 nop 
 
(obs.:  80482c4 + 0xffffffe0 = 0x80482a4) 
   
8) Iniciando com o código C na seguinte forma: 
int teste( int x, int y ) { 
int val = _________; 
if ( _________ ) { 
if ( _________ ) 
val = _________ ; 
else 
val = _________ ; 
}  else if ( _________ ) 
val = _________ ; 
return val; 
} 
 
o gcc gera o seguinte código assembly: 
 
movl 4(%esp), %edx 
movl 8(%esp), %ecx 
cmpl $­3, %edx 
jge .L2 
leal (%edx,%ecx), %eax 
cmpl %ecx, %edx 
jl .L4 
movl %edx, %eax 
imull %ecx, %eax 
ret 
.L2: 
movl %ecx, %eax 
xorl %edx, %eax 
cmpl $2, %edx 
jle .L4 
movl %edx, %eax 
subl %ecx, %eax 
.L4: 
ret 
 
Preencha as expressões que faltam no código C.