Computadores e Programaç˜ao (MAB-353) Lista 1 v.0

Computadores e Programação (MAB-353)
Lista 1 v.0 - Em grupo de no máximo três alunos
100 pontos - Entrega em 30/04/2015 (15 dias de prazo)
Prof. Paulo Aguiar (DCC/IM/UFRJ)
Questão 1
(20 pontos)
a) (5) Crie um arquivo de texto em Linux de nome arq contendo apenas a letra a. Obtenha o número de
bytes deste arquivo. Usando um editor binário liste o conteúdo deste arquivo. Copie a tela do editor binário
do seu Linux e coloque-a como resposta.
b) (5) Altere agora este arquivo para que ele contenha a letra â (a com acento circunflexo). Obtenha o
número de bytes deste arquivo. Usando um editor binário liste o conteúdo deste arquivo. Copie a tela do
editor binário do seu Linux e coloque-a como resposta.
c) (10) Pesquise e descubra como o final de um arquivo é determinado em Linux. Resuma o resultado
de sua pesquisa citando a(s) fonte(s). Caso encontre mais de uma resposta, procure determinar a correta e
compare os resultados.
Questão 2
Geração de Máscara. (20 pontos)
Escreva um código para implementar a seguinte função:
/* Gere uma máscara que indica a posição do 1 mais à direita. Assuma w=32.
Por exemplo 0XFF00 − > 0x100, e 0x6600 −− > 0x200.
Se x=0, então retorne 0. */
int rightmost one (unsigned x) {
...
return ...; }
Sua função deve seguir as regras de codificação ao nı́vel de bit para inteiros (página 120 do livro texto),
exceto que você pode assumir que o tipo int tem w = 32 bits. Explique a lógica de sua solução.
Questão 3
Representação de números em C2. (20 pontos)
Justifique porque -12345 representado como um número unsigned short int (16 bits) sem sinal resulta
em 53191? Justifique passo a passo a sua resposta.
Questão 4
Chamada de rotina e código de montagem. (20 pontos)
int rotina (unsigned int x) {
unsigned int y;
y = x/7;
return y;
1
}
main (void){
printf("%d\n",rotina(7));
}
O código acima foi compilado e gerado o código de montagem (removidas as linhas de diretivas do gcc):
rotina:
movl 4(%esp), %ecx
movl $613566757, %edx
movl %ecx, %eax
mull %edx
movl %ecx, %eax
subl %edx, %eax
shrl %eax
addl %edx, %eax
shrl $2, %eax
ret
.LC0:
.string "%d\n"
main:
pushl %ebp
movl %esp, %ebp
andl $-16, %esp
subl $16, %esp
movl $1, 4(%esp)
movl $.LC0, (%esp)
call printf
leave
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
....................................................................
a) (5) Comente cada linha do código de montagem da rotina rotina e demonstre que ele de fato executa
as instruções em C e y é retornado com o valor x/7. 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) (3) No código C, main chama rotina (7). E no código de montagem, o quê acontece? Explique.
c) (3) A rotina rotina cria um registro de ativação? Explique.
d) (5) Comente e justifique cada linha do código de montagem de main.
e) (4) A compilação foi feita de forma otimizada ou não? Justifique com argumentos sólidos.
Questão 5 Código de montagem. (20 pontos)
Seja dado o código C:
#include <stdio.h>
void dump (void *p, int n) {
unsigned char *p1 = p;
while (n--) {
printf("Endereco %p : %02X\n", p1, *p1); /* imprime n bytes a partir de um endereço p */
p1++; /* incrementa o ponteiro */
}
2
}
int main (void) {
long long int x, y, z;
x = 0x3FFFFFFF;
y = 0x5FFFFFFF;
z = x * y;
dump(&z, sizeof(z)); /* imprime os bytes na memória em endereços crescentes */
}
Compilando sem otimização foi gerado o seguinte código de montagem para main:
main:
pushl %ebp
movl %esp, %ebp
andl $-16, %esp
subl $48, %esp
movl $1073741823, 32(%esp)
movl $0, 36(%esp)
movl $1610612735, 40(%esp)
movl $0, 44(%esp)
movl 36(%esp), %eax
imull 40(%esp), %eax
movl %eax, %edx
movl 44(%esp), %eax
imull 32(%esp), %eax
leal (%edx,%eax), %ecx
movl 40(%esp), %eax
mull 32(%esp)
addl %edx, %ecx
movl %ecx, %edx
movl %eax, 24(%esp)
movl %edx, 28(%esp)
movl $8, 4(%esp)
leal 24(%esp), %eax
movl %eax, (%esp)
call dump
leave
ret
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
a) (4) Comente cada linha do código de main e explique a sua correspondência com o código C.
Compilando com otimização, agora foi gerado o código abaixo:
main:
pushl %ebp
movl %esp, %ebp
andl $-16, %esp
subl $32, %esp
leal 24(%esp), %eax
movl %eax, (%esp)
movl $8, 4(%esp)
movl $1, 24(%esp)
movl $1073741823, 28(%esp)
call dump
leave
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
..............................................................
3
b) (4) Justifique cada linha deste código de montagem. Explique o que a otimização fez, comparando os dois
códigos de montagem gerados a partir do mesmo código C. Faça seus comentários.
c) A rotina main foi modificada e as variáveis x e y foram suprimidas, sendo z calculada direto pela
multiplicação dos valores.
int main (void) {
long long int z;
z = 0x3FFFFFFF * 0x5FFFFFFF;
dump(&z, sizeof(z)); /* imprime os bytes na memória em endereços crescentes */
}
c1) (4) Edite um arquivo meu.c com este novo main, com a rotina dump inclusa, e compile com as opções
-m32 -O1 -o meu, para gerar o aquivo excutável meu. Se a compilação gerar alguma mensagem, copie a tela
e cole a mensagem aqui como resposta. Rode o executáve meu e copie a tela de saida.
c2) (4) Gere o código de montagem em meu.s compilando meu.c com as opções -m32 -O1 -S. Imprima o
código de montagem de main e comente linha a linha, justificando a saı́da que foi impressa.
c3) (4)Tente explicar o que aconteceu e entenda o comportamento do C na multiplicação para obtenção
de z.
4