Computadores e Programação (MAB-353) Primeira Prova -Prof. Paulo Aguiar (DCC/UFRJ) 19/05/ pontos

Transcrição

1 Computadores e Programação (MAB-353) Primeira Prova -Prof. Paulo Aguiar (DCC/UFRJ) 19/05/ pontos Nome: GABARITO (revisado) Questão 1 (20 pontos) Preencha os pontilhados do código C com variável e/ou operador lógico e/ou operador aritmético, ou combinação deles que faça sentido no código C com o correspondente código de montagem. Se tivéssemos algo como *s ou *s ou!i, isso seria preenchido num único pontilhado, pois seria uma combinação. char *gets(char *s) { int c; char *dest = s; int gotchar = 0; while ((... = getchar())... \n EOF) { *dest++ =...;... =...;... = \0 ; if ( EOF ) return NULL; return...; sabendo que foi gerado o seguinte código de montagem: gets: pushl %ebp... movl %esp, %ebp... subl $24, %esp... movl 8(%ebp), %eax... movl %eax, -20(%ebp)... movl $0, -16(%ebp)... jmp.l2....l4: movl -20(%ebp), %eax... leal 1(%eax), %edx... movl %edx, -20(%ebp)... movl -12(%ebp), %edx... movb %dl, (%eax)... movl $1, -16(%ebp)... call getchar... movl %eax, -12(%ebp)... cmpl $10, -12(%ebp)... je.l3... cmpl $-1, -12(%ebp)... 1

2 jne.l4....l3: movl -20(%ebp), %eax... leal 1(%eax), %edx... movl %edx, -20(%ebp)... movb $0, (%eax)... cmpl $-1, -12(%ebp)... jne.l5... cmpl $0, -16(%ebp)... jne.l5... movl $0, %eax... jmp.l6....l5: movl 8(%ebp), %eax....l6: leave... ret... A. (7 pontos) Preencha os pontilhados do código C com as operações lógicas e/ou aritméticas e/ou variáveis correspondentes. O preenchimento tem que estar justificado nos comentários do código de montagem. B. (9 pontos) Justifique a existência de cada linha do código de montagem, mostrando a associação dela com o código C, quando for o caso. Não descreva o que cada instrução faz, pois isso assumo que você já sabe. O que interessa e conta ponto é explicar a engenharia reversa. Sem a devida explicação o preenchimento do código C não será contabilizado. C. (2 pontos) Explique o que a instrução leave faz. Demonstre seu conhecimento, indicando o que poderia ser usado no lugar dela, mas fazendo uso apenas de movl e leal. Não pode usar popl e/ou pushl. D.(2 pontos) Explique o que a instrução ret faz. Qual a condição a ser satisfeita para que a execução de ret tenha sucesso? Demonstre seu conhecimento, indicando o que poderia ser usado no lugar dela, mas fazendo uso apenas de movl, leal, e com uso do registrador %eip (contador de programa). Não pode usar popl e/ou pushl. R: A. char *gets(char *s) { int c; char *dest = s; int gotchar = 0; while ((c = getchar())!= \n && c!= EOF) { *dest++ = c; /* incrementa depois que fez dest = c*/ gotchar = 1; *dest++ = \0 ; if (c == EOF &&!gotchar) return NULL; return s; B. gets: 2

3 pushl %ebp prepara o registro de ativaç~ao salvando a base anterior... movl %esp, %ebp aponta o topo da pilha para a base do registro de ativaç~ao... subl $24, %esp abre 6 espaços na pilha... movl 8(%ebp), %eax pega s (ponteiro para caractere)... movl %eax, -20(%ebp) salva s em %ebp-20, local do ponteiro dest (dest = s)... movl $0, -16(%ebp) zera (%ebp-16), i.e., gotchar = 0... jmp.l2 desvia incondicionalmente para.l2, corpo do while....l4: corpo do while abaixo movl -20(%ebp), %eax pega dest... leal 1(%eax), %edx calcula dest++... movl %edx, -20(%ebp) salva valor atualizado de dest... movl -12(%ebp), %edx copia (%ebp-12) = c para %edx... movb %dl, (%eax) faz *dest = c (*dest=c;dest++ ou *dest++=c em uma única linha)... movl $1, -16(%ebp) gotchar = 1... condiç~ao do while call getchar chama getchar(), sem par^ametros... movl %eax, -12(%ebp) retorno c salvo na posiç~ao %ebp-12, ou seja c = getchar()... cmpl $10, -12(%ebp) compara c com \n = je.l3 segue se c!= \n (primeira condiç~ao para permanecer no while) cmpl $-1, -12(%ebp) compara c com -1 (EOF) (segunda condiç~ao)... jne.l4 permanece no while apenas se (c!= EOF) && (c!= \n )....L3: movl -20(%ebp), %eax pega dest... leal 1(%eax), %edx dest++... movl %edx, -20(%ebp) atualiza dest... movb $0, (%eax) insere o final da lista \0 ou seja *dest++ = \0... cmpl $-1, -12(%ebp) checa se c == EOF (primeira condiç~ao do if )... jne.l5 sai do if se c!= EOF e testa segunda condiç~ao se c == EOF... cmpl $0, -16(%ebp) compara gotchar com 0 (segunda condiç~ao do if)... jne.l5 se gotchar == 0 n~ao desvia, i.e. executa if se (c==eof) &&!gotchar movl $0, %eax prepara o retorno com 0, ou seja return NULL... jmp.l6 desvia para retornar com NULL....L5: movl 8(%ebp), %eax retorna s....l6: leave prepara o retorno... ret retorna... C. Leave prepara para o retorno da rotina, apontando o topo da pilha para a base, onde está salvo a base anterior (SFP) e dando um pop para salvar este valor no registrador da base (%ebp). Então, leave é equivalente a: movl %ebp, %esp movl (%esp), %ebp leal $4(%esp), %esp # aponta topo para a base do registro # restaura base anterior # incrementa o topo para apontar para o RIP A duas últimas instruções são equivalentes a popl. Após o leave, o topo da pilha tem que estar apontando para o RIP, endereço da instrução seguinte ao call no caller. D. Ret carrega o RIP que está na pilha para o %eip e transfere o controle. Para que isso funcione, o topo da pilha tem que estar apontando para a memória onde está o RIP (return instruction pointer). Então, ret é equivalente a: movl (%esp), %eip # copia o RIP para o program counter leal $4(%esp), %esp # incrementa o ponteiro para decrementar a pilha de uma posiç~ao. 3

4 As duas instruções são equivalentes a popl %eip. Lembrar que o pop depois de copiar, ele decrementa a pilha de uma posiçao de 4 bytes, apontando para a posição imediatamente superior à posição do RIP, que seria o topo da pilha antes da execução do call. Questão 2 (20 pontos) É dado o código C, onde nas linhas pontilhadas foi suprimido o valor constante inteiro que é o mesmo nas três posições: #include <stdio.h> void xxx(unsigned int n) { if (n/...) xxx (n/...); printf("%x\n", n%...); main(){ xxx(29); foi gerado o seguinte código de montagem para a subrotina xxx, onde = 0x38e38e39:.LC0:.string "%x\n" xxx: pushl %ebx subl $24, %esp movl 32(%esp), %ebx cmpl $8, %ebx jbe.l2 movl $ , %edx movl %ebx, %eax mull %edx shrl %edx movl %edx, (%esp) call xxx movl $ , %edx movl %ebx, %eax mull %edx shrl %edx leal (%edx,%edx,8), %eax subl %eax, %ebx movl %ebx, 8(%esp) movl $.LC0, 4(%esp) movl $1, (%esp) call printf_chk addl $24, %esp popl %ebx ret xxx: 1 pushl %ebx // salva %ebx 2 subl $24, %esp // abre 6 espaços na pilha 3 movl 32(%esp), %ebx // pega n (na ordem na pilha: 6 espaços, %ebx, RIP e n) 4 cmpl $8, %ebx // compara n com 8, logo a divis~ao é por 9 5 jbe.l2 // se menor ou igual n~ao chama recursivamente, logo a divis~ao é por 9 6 movl $ , %edx // insere 0x38E38E39= (9 é arredondamento) 4

5 7 movl %ebx, %eax // pega n 8 mull %edx // multiplica 0x38E38E39 * n => %edx:%eax 9 shrl %edx // 0x38E38E39*n*2**(-33) = *n // base8= =7/64+7/(64*64)+...=7/64[1/(1-1/64)])= 7/63=1/9. 10 movl %edx, (%esp) // copia n/9 para a pilha 11 call xxx // chama rotina recursivamente, xxx(n/9) // vai preparar a impress~ao 12 movl $ , %edx // insere 0x38E38E39 13 movl %ebx, %eax // pega n (par^ametro de chamada da invocaç~ao atual) 14 mull %edx // multiplica 0x38E38E39 * n => %edx:%eax 15 shrl %edx // 0x38E38E39*n*2**(-33) = *n // base8= =7/64+7/(64*64)+...=7/64[1/(1-1/64)])= 7/63=1/9. 16 leal (%edx,%edx,8), %eax // calcula 9*n/9 (maneira mais fácil de determinar a constante suprimida) 17 subl %eax, %ebx // calcula n - 9*n/9 = n%9 (código n~ao otimizado) 18 movl %ebx, 8(%esp) // armazena na pilha 19 movl $.LC0, 4(%esp) // lista de impress~ao 20 movl $1, (%esp) // par^ametro de erro 21 call printf_chk // chamada de impress~ao 22 addl $24, %esp // devolve espaço na pilha 23 popl %ebx // restaura %ebx 24 ret a) (5 pontos) Comente e justifique cada linha do código de montagem. b) (5 pontos) Qual valor fica armazenado em %edx após a execução da linha 9? Obtenha o valor da constante a partir das operações executadas pelo GCC. Tem que relacionar os valores manipulados e a multiplicação na linha 8. Detalhe para ganhar pontos integrais no item. R: Veja os comentários no código de montagem. c) (5 pontos) Existem várias maneiras de identificar no código de montagem o valor constante suprimido do código C. Aponte pelo menos mais duas indicações, além do visto no item b. R: linhas 4 e 5; e linhas 16 e 17. d) (5 pontos) O que será impresso pelo programa acima? Seja preciso na ordem e no conteúdo de cada linha impressa. R: Cada chamada a xxx() imprime o resto da divisão do argumento por 9. Inicialmente main chama xxx(29), que chama xxx(3). xxx(3) imprime 3 numa linha e retorna. xxx(29) por sua vez imprime = 2 numa nova linha e retorna. Dessa forma, temos a representação do número na base 9. No nosso caso, 29 = 3* Se tivéssemos chamado em main xxx(124), seria impresso 1, 4 e 7 na ordem em linhas separadas pois 124 = Questão 3 (20 pontos) Suponha que seja escrito o seguinte código em C para uma função unsigned foo(float f) { union{ foat f; unsigned int u; temp; temp.f = f; return temp.u; ; 5

6 a) (5 pontos) Indique o número de bytes requeridos pela union. b) Assuma que você compilou usando as opções -m32 -O2 -S e a rotina não cria o registro de ativação. gcc gera pouquíssimas linhas no código de montagem. b1) (5 pontos) Indique como é passado o parâmetro da rotina. b2) (5 pontos) Ao entrar na rotina, que informação está no topo da pilha? b3) (5 pontos) Quais seriam estas linhas de código de montagem que o gcc gerou? R: a) 4 bytes, já que ambos os tipos possuem este tamanho. b1) O parâmetro é passado pela pilha em MEM[%esp + 4], pois não é criado registro de ativação e a rotina não usa área na pilha. b2) No topo da pilha, MEM[%esp] está o RIP, que é o endereço de retorno para execução. b3) A rotina retorna o que foi passado em %eax, pois para o assembly não importa o que o código C interpreta a representação do registrador, se float ou se unsigned int. São geradas duas linhas apenas, dado que o código foi compilado de forma otimizada e não é criado registro de ativação. Assim temos: movl 4(%esp), %eax ret # copia o valor de retorno # retorna corretamente, já que o RIP está no topo da pilha Questão 4 (20 pontos) Seja dada a seguinte declaração de uma estrutura em Linux: struct rec { char c; int *p; char a[5]; int i; int j; a) (5) Indique os offsets de cada campo em Linux e o número de bytes que serão necessários para a estrutura. R: c(0), p (4), a[0](8),a[1](9), a[2](10), a[3](11), a[4](12), i(16), j(20), sendo necessários 24 bytes. Os campos de 4 bytes ou mais são alinhados em fronteiras de 4 bytes em Linux. b) (15) Assumindo que se inicia com um ponteiro r para a estrutura em %edx, escreva exatamente 4 linhas em assembly para implementar r > p = r > a[r > i r > j]. Use apenas %edx e %eax. R: Veja que pelo enunciado o que deve ser colocado no campo p é o valor de a[r > i r > j], esperando que este valor faça sentido como ponteiro. Mas como temos um char, é preciso mover de char para int usando movzbl ou movsbl quando trouxer o valor do char para ser carregado em um registrador de 32 bits. Veja que a máquina não discute se o valor a ser carregado como endereço faz sentido ou não. Temos abaixo a solução para a questão: 1 movl 16(%edx), %eax # pega r->i 2 subl 20(%edx), %eax # r->i - r->j 3 movzbl (ou movsbl) 8(%edx, %eax), %eax # pega a[r->i - r->j] e armazena 4 bytes 4 movl %eax, 4(%edx) # armazena em r-> p Questão 5 (20 pontos) Considere o código C, onde M e N são constantes declaradas com #define: int mat1[m][n]; int mat2[n][m]; int sum_element(int i, int j){ return mat1[i][j] + mat2[j][i]; Foi gerado o código de montagem seguinte: 6

7 sum_element: 1 movl 4(%esp), %edx pega i 2 movl 8(%esp), %eax pega j 3 leal (%edx,%edx,2), %ecx calcula 3i 4 addl %eax, %ecx calcula 3i + j 5 leal (%edx,%eax,8), %edx calcula 8j + i 6 subl %eax, %edx calcula 7j + i 7 movl mat1(,%ecx,4), %eax acessa mat1[i][j], indicando que N=3 8 addl mat2(,%edx,4), %eax acessa mat2[j][i], indicando que M=7 9 ret a) (2) Qual a localização na pilha de i e j passados como argumentos para sum element? Justifique. R: i está em %esp+4 e j em %esp + 8, pois não é criado registro de ativação. b) (4) Após a execução da linha 4, qual o valor armazendo em %ecx em termos de i e j? R: %ecx = 3i +j. c) (4) Após a execução da linha 6, qual o valor armazendo em %edx em termos de i e j? R: %edx = 7j+i. d) (10) Qual o valor das constantes M e N? R: N=3, M=7. 7