Computadores e Programaç˜ao (MAB-353 2015

Computadores e Programação (MAB-353 2015-2)
Lista1 (rev1) - Grupo de até 3 alunos - 100 pontos
Primeira Parte (questões 1 a 3, 65 pontos), entrega definida para o dia 24/05/2016.
Segunda Parte (questões 4 e 5, 35 pontos), entrega para o dia 31/05/2016
Grupo: .........................................................................
Questão 1
(25 pontos) Seja dado o código C abaixo:
#include <stdio.h>
void dump (void *p, int n) {
unsigned char *p1 = p;
while (n--) {
printf("Endereco %p : %02X\n", p1, *p1);/* imprime a partir de um endereço p */
p1++; /* incrementa o ponteiro */
}
}
int main (void) {
int i,j;
j = 0x5fffffff;
i = 0x0000ffff;
int z = i*j;
dump(&z, sizeof(z));
}
/* imprime os bytes na memória em endereços crescentes */
a) (3) Converta x e y em representação 2**n - 1.
b) (2) Compile o código acima em 32 bits (gcc -m32) e obtenha o valor de z em hexa.
c) (5) Explique e justifique claramente o resultado de z, usando as representações acima, como feito em
aula.
d) (5) Gere o código de montagem sem otimização e justifique cada linha do código de montagem de main
(não é preciso comentar a rotina dump), desconsiderando as linhas iniciadas com ponto, que são indicações
ao compilador gcc.
e) (2) As variáveis x, y e z estão representadas em que registrador ou posição de memória?
f) (3) Gere o código com otimização -O1 e justifique comente cada linha do código de montagem.
g) (5) Assumindo que agora x, y e z sejam definidos como long long int qual seria o novo valor de z
em hexa? Justifique analiticamente e deduza a resposta que seria obtida obtida.
1
Questão 2
Chamada de rotina e código de montagem. (20 pontos)
int rotina (unsigned int x) {
unsigned int y;
y = x/......;
/* divisor inteiro a ser descoberto pela engenharia reversa */
return y;
}
O código C acima foi compilado e gerado o seguinte código de montagem (removidas as linhas de diretivas
do gcc):
rotina:
movl $-252645135, %edx
movl %edx, %eax
mull 4(%esp)
movl %edx, %eax
shrl $4, %eax
ret
.................................................................
.................................................................
.................................................................
.................................................................
.................................................................
.................................................................
a) (10) Comente cada linha do código de montagem e descubra o divisor inteiro com base neste código.
Faça o passo a passo, como feito em sala de aula. Você precisa justificar a existência de cada linha de código.
Faça as conversões que forem necessárias para justificar a ação do gcc. Não deixe de comentar nenhuma
linha.
b) (5) Qual o valor do divisor inteiro desconhecido? Justifique.
c) (5) A compilação foi feita de forma otimizada ou não? Justifique com argumentos sólidos.
Questão 3
(20 pontos)
a) (10) Faça a engenharia reversa para descobrir o que foi apagado nas lacunas.
#include <stdio.h>
main(){
int y = .....;
int x;
.... = .......................................;
printf(" %d \n", ..............);
return ......... ;
}
b) (10) Justifique cada linha do código de montagem gerado e associe ao código C a ser descoberto:
main:
pushl %ebp
movl %esp, %ebp
andl $-16, %esp
subl $32, %esp
movl $3, 24(%esp)
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
2
cmpl $0, 24(%esp)
jne .L2
cmpl $0, 24(%esp)
je .L3
movl $1, %eax
cltd
idivl 24(%esp)
testl %eax, %eax
je .L3
.L2:
movl $1, %eax
jmp .L4
.L3:
movl $0, %eax
.L4:
movl %eax, 28(%esp)
movl 28(%esp), %eax
movl %eax, 4(%esp)
movl $.LC0, (%esp)
call printf
movl 28(%esp), %eax
leave
ret
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
........................................................................
Questão 4 (20 pontos) Consultando o código de montagem, faça a engenharia reversa e descubra as linhas
apagadas e/ou lacunas do código C. Comente todas as linhas do código de montagem, procurando associar
à linha do código C, quando for o caso.
main(){
int a[........];
int x=0;
int i=0;
...........................;
while(...............){
a[i+1] = ..............................................;
..........................;
}
for (..................;.........................;....................) {
...............................................
continue; /* avança para próxima interaç~
ao do for */
x = .......................................;
}
printf(....................., ...........);
}
.LC0:
.string "%d\n"
main:
pushl %ebp
.............................................................
movl %esp, %ebp
.............................................................
pushl %esi
.............................................................
pushl %ebx
.............................................................
andl $-16, %esp
.............................................................
subl $64, %esp
.............................................................
3
movl $1, 24(%esp)
.............................................................
leal 24(%esp), %ebx
.............................................................
movl %ebx, %esi
.............................................................
leal 60(%esp), %ecx
.............................................................
movl %ebx, %eax
.............................................................
.L3:
movl (%eax), %edx
.............................................................
negl %edx
.............................................................
addl %edx, %edx
.............................................................
movl %edx, 4(%eax)
.............................................................
addl $4, %eax
.............................................................
cmpl %ecx, %eax
.............................................................
jne .L3
.............................................................
addl $40, %esi
.............................................................
movl %ebx, %eax
.............................................................
movl $0, %ecx
.............................................................
.L6:
movl (%eax), %edx
.............................................................
leal (%ecx,%edx), %ebx
.............................................................
testl %edx, %edx
.............................................................
cmovns %ebx, %ecx
.............................................................
addl $4, %eax
.............................................................
cmpl %esi, %eax
.............................................................
jne .L6
.............................................................
movl %ecx, 4(%esp)
.............................................................
movl $.LC0, (%esp)
.............................................................
call printf
leal -8(%ebp), %esp
.............................................................
popl %ebx
.............................................................
popl %esi
.............................................................
popl %ebp
.............................................................
ret
.............................................................
Questão 5 (15 pontos) Dado o código C e o correpondente código de montagem, procure determinar o
valor no define que foi apagado e justifique pela engeharia reversa.
#define N .....
#define M .....
#define L .....
typedef int mat1[N][M];
typedef int mat2[M][L];
int func(mat1 A, mat2 B, int i , int j , int k){
int x;
x = A[i][j]*B[j][k];
return x;
}
func:
pushl %ebp
......................................................
movl %esp, %ebp ......................................................
subl $16, %esp ......................................................
movl 16(%ebp), %eax ......................................................
imull $52, %eax, %edx ......................................................
4
movl 8(%ebp), %eax ......................................................
addl %eax, %edx ......................................................
movl 20(%ebp), %eax ......................................................
movl (%edx,%eax,4), %edx ......................................................
movl 20(%ebp), %eax ......................................................
sall $2, %eax ......................................................
leal 0(,%eax,8), %ecx ......................................................
subl %eax, %ecx ......................................................
movl 12(%ebp), %eax ......................................................
addl %eax, %ecx ......................................................
movl 24(%ebp), %eax ......................................................
movl (%ecx,%eax,4), %eax ......................................................
imull %edx, %eax ......................................................
movl %eax, -4(%ebp) ......................................................
movl -4(%ebp), %eax ......................................................
leave ......................................................
ret ......................................................
5