Estrutura do tema ISA do IA-32 1. Desenvolvimento de programas

Análise do
Instruction Set Architecture (5)
CISC versus RISC
Caracterização das arquiteturas RISC
Estrutura do tema ISA do IA-32
1. 
2. 
3. 
4. 
5. 
6. 
Desenvolvimento de programas no IA-32 em Linux
Acesso a operandos e operações
Suporte a estruturas de controlo
Suporte à invocação/regresso de funções
Análise comparativa: IA-32 (CISC) e MIPS (RISC)
Acesso e manipulação de dados estruturados
AJProença, Sistemas de Computação, UMinho, 2013/14
1
– 
– 
– 
– 
– 
conjunto reduzido e simples de instruções
formatos simples de instruções
operandos sempre em registos
modos simples de endereçamento à memória
uma operação elementar por ciclo máquina
Ex de uma arquitetura RISC:
ARM
AJProença, Sistemas de Computação, UMinho, 2013/14
Análise do nível ISA:
o modelo RISC versus IA-32 (1)
RISC versus IA-32 :
Análise do nível ISA:
o modelo RISC versus IA-32 (2)
RISC versus IA-32 (cont.):
–  RISC: conjunto reduzido e simples de instruções
–  RISC: modos simples de endereçamento à memória
•  pouco mais que o subset do IA-32 já apresentado...
•  instruções simples, mas eficientes
•  apenas 1 modo de especificar o endereço:
Mem[Cte+(Regb)] ou Mem[(Regb)+(Regi)]
•  2 ou 3 modos de especificar o endereço:
Mem[Cte+(Regb)]
e/ou
Mem[(Regb)+(Regi)]
e/ou
Mem[Cte+(Regb)+(Regi)]
–  operações aritméticas e lógicas:
•  3-operandos (RISC) versus 2-operandos (IA-32)
•  RISC: operandos sempre em registos,
32 registos genéricos visíveis ao programador,
sendo normalmente
–  1 reg apenas de leitura, com o valor 0
–  1 reg usado para guardar o endereço de regresso da função
–  1 reg usado como stack pointer (convenção do s/w)
– 
...
AJProença, Sistemas de Computação, UMinho, 2013/14
2
–  RISC: uma operação elementar por ciclo máquina
•  por ex. push/pop (IA-32)
substituído pelo par de instruções
sub&store/load&add (RISC)
– 
3
...
AJProença, Sistemas de Computação, UMinho, 2013/14
4
Funções em assembly:
IA-32 versus MIPS (RISC) (1)
Análise do nível ISA:
o modelo RISC versus IA-32 (3)
RISC versus IA-32 (cont.):
–  RISC: formatos simples de instruções
Principal diferença na implementação de funções:
–  na organização dos registos
•  IA-32: poucos registos genéricos =>
•  comprimento fixo e poucas variações
•  ex.: MIPS
variáveis e argumentos normalmente na stack
•  RISC: 32 registos genéricos =>
registos para variáveis locais, &
registos para passagem de argumentos &
registo para endereço de regresso
–  consequências:
•  menor utilização da stack nas arquitecturas RISC
•  RISC potencialmente mais eficiente
Análise de um exemplo (swap) ...
AJProença, Sistemas de Computação, UMinho, 2013/14
5
AJProença, Sistemas de Computação, UMinho, 2013/14
6
Funções em assembly:
IA-32 versus MIPS (RISC) (2)
Revisão da codificação
de swap e call_swap no IA-32
void swap(int *xp, int *yp)
{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}
_swap:
pushl
movl
pushl
%ebp
%esp, %ebp
%ebx
movl
movl
movl
movl
movl
movl
12(%ebp),%ecx
8(%ebp), %edx
(%ecx), %eax
(%edx), %ebx
%eax, (%edx)
%ebx, (%ecx)
movl
movl
popl
ret
-4(%ebp), %ebx
%ebp, %esp
%ebp
AJProença, Sistemas de Computação, UMinho, 2013/14
_swap:
pushl
movl
pushl
movl
movl
movl
movl
movl
movl
popl
popl
ret
_call_swap:
pushl
movl
subl
movl
movl
leal
movl
leal
movl
call
movl
popl
ret
void call_swap()
{
int zip1 = 15213;
int zip2 = 91125;
swap(&zip1, &zip2);
}
_call_swap:
pushl %ebp
movl
%esp, %ebp
subl
$24, %esp
movl
movl
leal
movl
leal
movl
call
$15213, -4(%ebp)
$91125, -8(%ebp)
-4(%ebp), %eax
%eax,
(%esp)
-8(%ebp), %eax
%eax,
4(%esp)
_swap
movl
popl
ret
%ebp, %esp
%ebp
7
IA-32
%ebp
%esp, %ebp
%ebx
8(%ebp), %edx
12(%ebp), %ecx
(%edx), %ebx
(%ecx), %eax
%eax, (%edx)
%ebx, (%ecx)
%ebx
%ebp
%ebp
%esp, %ebp
$24, %esp
$15213, -4(%ebp)
$91125, -8(%ebp)
-4(%ebp), %eax
%eax, (%esp)
-8(%ebp), %eax
%eax, 4(%esp)
_swap
%ebp, %esp
Total:
%ebp
63 bytes
AJProença, Sistemas de Computação, UMinho, 2013/14
swap:
lw
lw
sw
sw
j
$v1,0($a0)
$v0,0($a1)
$v0,0($a0)
$v1,0($a1)
MIPS
$ra
call_swap:
subu
sw
$sp,$sp,32
$ra,24($sp)
li
sw
li
ori
sw
addu
addu
jal
$v0,15213
$v0,16($sp)
$v0, 0x10000
$v0,$v0,0x63f5
$v0,20($sp)
$a0,$sp,16
$a1,$sp,20
swap
lw
addu
j
$ra,24($sp)
$sp,$sp,32
$ra
# &zip1= sp+16
# &zip2= sp+20
Total:
72 bytes
8
Funções em assembly:
IA-32 versus MIPS (RISC) (3)
call_swap
1. Invocar swap
• salvaguardar registos
• passagem de argumentos
• chamar rotina e guardar endereço de regresso
leal
pushl
leal
pushl
call
-4(%ebp),%eax
%eax
-8(%ebp),%eax
%eax
swap
MIPS
Não há reg para salvag.
Calcula &zip2
Push &zip2
Calcula &zip1
Push &zip1
Invoca swap
sw
addu
addu
jal
$ra,24($sp)
$a0,$sp,16
$a1,$sp,20
swap
Funções em assembly:
IA-32 versus MIPS (RISC) (4)
swap
1. Inicializar swap
• atualizar frame pointer
• salvaguardar registos
• reservar espaço p/ locais
IA-32
swap:
pushl %ebp
!Salvag. antigo %ebp
movl %esp,%ebp !%ebp novo frame pointer
pushl %ebx
!Salvag. %ebx
Acessos
à stack
Salvag. reg c/ ender. regresso
!Coloca &zip1 no reg argum 0
!Coloca &zip2 no reg argum 1
Frame pointer p/ actualizar: NÃO
Registos p/ salvaguardar:
NÃO
Espaço p/ locais:
NÃO
MIPS
Invoca swap
9
AJProença, Sistemas de Computação, UMinho, 2013/14
Funções em assembly:
IA-32 versus MIPS (RISC) (5)
movl
movl
movl
movl
movl
movl
12(%ebp),%ecx
8(%ebp),%edx
(%ecx),%eax
(%edx),%ebx
%eax,(%edx)
%ebx,(%ecx)
swap
MIPS
Coloca yp em reg
Coloca xp em reg
Coloca y em reg
Coloca x em reg
Armazena y em *xp
Armazena x em *yp
lw
lw
sw
sw
$v1,0($a0)
$v0,0($a1)
$v0,0($a0)
$v1,0($a1)
AJProença, Sistemas de Computação, UMinho, 2013/14
Acessos
à stack
Não é preciso espaço p/ locais
AJProença, Sistemas de Computação, UMinho, 2013/14
2. Corpo de swap ...
IA-32
Funções em assembly:
IA-32 versus MIPS (RISC) (6)
3. Término de swap ...
• libertar espaço de var locais
• recuperar registos
• recuperar antigo frame pointer
• regressar a call_swap
IA-32
Acessos
à memória
popl %ebx
movl %ebp,%esp
popl %ebp
ret
!
(todas...)
Coloca x em reg
Coloca y em reg
Armazena y em *xp
Armazena x em *yp
swap
Não há espaço a libertar
!Recupera %ebx
!Recupera %esp
!Recupera %ebp
!Regressa à função chamadora
MIPS
11
10
j
$ra
AJProença, Sistemas de Computação, UMinho, 2013/14
IA-32
Acessos
à stack
Espaço a libertar de var locais: NÃO
Recuperação de registos:
NÃO
Recuperação do frame ptr: NÃO
!Regressa à função chamadora
12
Funções em assembly:
IA-32 versus MIPS (RISC) (7)
call_swap
2. Terminar invocação de swap...
• libertar espaço de argumentos na stack...
• recuperar registos
addl $8,(%esp)
MIPS
Atualiza stack pointer
Não há reg s a recuperar
IA-32
Acessos
à stack
Espaço a libertar na stack: NÃO
lw
$ra,24($sp) Recupera reg c/ ender regresso
Total de acessos à stack: 14 no IA-32, 6 no MIPS !
AJProença, Sistemas de Computação, UMinho, 2013/14
13