SMP/AC 2013/14

Sistemas de Microprocessadores 2013/2014
Sistemas de Microprocessadores - MIEEC - Ano Lectivo 2013/14
João P Barreto (jpbar@deec.uc.pt)
Introdução

Os Computadores são Inteligentes?
Na perspectiva do programador:
§ Operações/Funções muito complexas:
Ä (map (lambda (x) (* x x)) '(1 2 3 4))
§ Gestão automática de memória:
Ä List l = new List;
§ Estruturas "básicas" pré-definidas:
Ä Integers, floats, caracteres, operadores, print commands
Computers
are smart!

Os Computadores são Inteligentes?
No mundo "real" do hardware:
§ Meia dúzia de operações lógicas:
Ä {and, or, not}
§ A memória não se gere sozinha
§ Só dois valores possíveis:
Ä {0, 1} ou {low, high} ou {off, on}
Computers are
dumb !

SMP/AC
SMP na "Big Picture" …
Coordenação de muitos
níveis (layers) de abstração
I/O systemProcessor
Compiler
Operating
System!
(Mac OSX)
Application (ex: browser)
Digital Design
Circuit Design
Instruction Set!
Architecture
Datapath & Control
transistors
MemoryHardware
Software Assembler

Vamos fazer a ponte entre PC e LSD ...
lw $t0, 0($2)
lw $t1, 4($2)
sw $t1, 0($2)
sw $t0, 4($2)
High Level Language
Program (e.g., C)
Assembly Language
Program (e.g.,MIPS)
Machine Language
Program (MIPS)
Hardware Architecture Description
(Logic, Logisim, Verilog, etc.)
Compiler
Assembler
Machine
Interpretation
temp = v[k];!
v[k] = v[k+1];!
v[k+1] = temp;
0000 1001 1100 0110 1010 1111 0101 1000
1010 1111 0101 1000 0000 1001 1100 0110
1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111
Logic Circuit Description
(Logisim, etc.)
Architecture
Implementation

Complexidade dos µPs
“Lei de Moore”!
O número de transistores
por chip duplica cada 1.5
anos
Gordon Moore 
Co-fundador da  
Intel
#deTransístoresnumCI

Capacidade de memória (Single-Chip DRAM)
Ano
Capacidade
(Mbit)
1980 0.0625
1983 0.25
1986 1
1989 4
1992 16
1996 64
1998 128
2000 256
2002 512
2004 1024 (1Gbit)
!
• Agora 1.4X/ano, ou 2X cada 2 anos.
• 8000X desde 1980!
Bits

Performance(vs.VAX-11/780)
1.0000
10.0000
100.0000
1000.0000
10000.0000
1978 1980 1982 1984 1986 1988 1990 1992 1994 1996 1998 2000 2002 2004 2006
25%/year
52%/year
20%/year
Desmpenho de um µP (SPECint)
• VAX : 1.25x/ano 1978 a 1986
• RISC + x86: 1.52x/ano 1986 a 2002
• RISC + x86: 1.20x/ano 2002 …
1.25x/year
1.52x/year
1.20x/year
Performance(vs.VAX-11/780)
A abrandar devido a limitações físicas
(já se fala de nanotubos de carbono
para dissipação mais eficiente)

Pondo as coisas em perspectiva …
“If the automobile had followed the
same development cycle as the
computer, 
a Rolls-Royce would today cost
$100, 
get a million miles per gallon,  
and explode once a year,  
killing everyone inside.”  
– Robert X. Cringely

Objectivos
Perceber os principios e ideias dominantes que estão por detrás da
computação e engenharia:
!
§ Principios de abstração usados para construir as diferentes camadas dos
sistemas
§ Dados são bytes em memória: o seu tipo (integers, floating point,
characters) é uma interpretação determinada pelo programa
§ Armazenamento de programas: instruções são bytes na memória, a
diferença entre instruções e dados é a forma como são interpretados
§ Príncipios de localidade usados na hierarquia de memória
§ Aumento de desempenho tirando partido do paralelismo
§ Compilação v. Interpretação

Competências Adicionais
Programação em C
§ Quem sabe uma linguagem (Python/C) deve ser capaz de aprender outra
de forma autónoma
§ Consolidação das competências de programação
§ Compreensão da razão de ser de muitas das regras de sintaxe
§ No final serão programadores muito mais "hardware aware"
Programação em Assembly
§ Competência adquirida como efeito "colateral" de compreender os grandes
príncipios que regem uma máquina-computador
Desenho e Arquitectura de Computadores
§ Introdução ao desenho de hardware
§ Poderão continuar a aprender em Arquitectura de Computadores e
Projecto de Sistemas de Digitais (4º ano do Ramo de Computadores)

Tópicos que vamos abordar ...
!
Módulo 1: A Linguagem C e o Hardware
§ Linguagem C (básico + ponteiros)
§ Gestão de Memória (alocação dinâmica, estática, etc)
§ Portos de I/O e programação de hardware
Módulo 2: Programação em Assembly para o MIPS
§ Instruções Aritméticas Básicas
§ Leitura e escrita da memória
§ Controlo de Fluxo
§ Codificação de instruções
§ Números e representação em floating point
§ make-ing an Executable (compilação, assemblagem, etc)
Módulo 3: Introdução à Arquitectura de Computadores
§ Organização do CPU
§ Pipelining
§ Caches e Hierarquia de Memória
§ Polling e interrupções

Funcionamento: Pré - Requisitos
•Domínio de pelo menos uma linguagem de
programação
-Definição de variáveis, Operadores, Ciclos, Rotinas e
Procedimentos, principios de algoritmia, etc
!
•Conhecimentos básicos de Sistemas Digitais
-Portas lógicas, Mux, Demux, Flip-flops, circuitos
combinacionais, circuitos sequenciais/máquinas de estado,
etc.
!
•Representação de números inteiros positivos e
negativos
-Binário, hexadecimal, complementos de 2, overflow, bit, Kbit,
Mbit, Byte, KByte, MByte, etc

Funcionamento: Aulas & Laboratórios
•Uma aula semanal de 2 horas para exposição e discussão
teórica
‣ 1 hora de preparação através da leitura prévia dos slides
‣ 2 a 3 horas de estudo posterior para consolidar os conhecimentos
!
•Uma aula semanal de 3 horas para a realização de práticas
laboratoriais
‣1 trabalho por semana (total de 12 trabalhos)
‣2 horas de preparação prévia
‣Instalar "tools" no computador pessoal a partir da primeira aula
!
•Notas:
‣O tempo de preparação e estudo são valores mínimos
aconselhados
‣Não há picos de trabalho (carga média semanal à volta de 10
horas)

Funcionamento: Atitude e Método
•Ser participativo nas aulas, não hesitando em interromper o
instrutor sempre que algo não é claro.
‣Já que estou na aula vou aproveitar para não ter que estudar tanto
em casa.
‣O instrutor só pode saber que está a ir muito depressa se alguém lhe
disser
‣A aula passa a ser bem mais interessante para toda a gente
!
•Ler os slides antes da aula (1 hora) e preparar os trabalhos
(2horas)
!
•Tirar notas para apoiar o estudo
‣As notas permitem-me recordar o que foi dito na aula (que pode não
estar nos livros)
‣Vou saber aquilo a que o professor dá mais importância (útil para o
exame)

Funcionamento: Avaliação
A avaliação de Época Normal consiste em:
25% para o desempenho nas aulas laboratoriais
25% para uma frequência a realizar no meio do semestre
(quarta-feira, 2 de Abril de 2014, pelas 15:30)
50% para um exame teórico final
!
A avaliação nas restantes épocas consiste em
25% para o desempenho nas aulas laboratoriais
75% para um exame teórico final
!
!
!

Notas Importantes:
!
O aluno será avaliado em cada aula laboratorial. A nota final da
prática será obtida através da média das 85% melhores
classificações.
!
Os estudantes trabalhadores têm de cumprir a componente
laboratorial. No caso de haver dificuldades de horários deverão
contactar o docente das teóricas IMEDIATAMENTE
!
Não é permitido os alunos frequentarem regularmente turmas
práticas em que não estejam inscritos (situações pontuais deverão
merecer anuência prévia do docente responsável).

Notas Importantes:
!
A FRAUDE não será tolerada!!!!!
!
Os alunos que obtenham uma nota final igual ou superior a
16 valores poderão ser chamados a fazer uma prova
adicional (defesa de nota) em que o 16 fica garantido.
Nessa prova tanto poderão subir como descer (e.g.
alguém admitido à defesa de nota com 16 poderá
terminar com 20). Quem preferir não fazer a prova terá
sempre 16 valores
!

Bibliografia
P&H - "Computer Organization and Design: The
Hardware/Software Interface", Third Edition,
Patterson and Hennessy.
!
K&R - "The C Programming Language", Kernighan
and Ritchie, 2nd edition
!
Slides
!
Textos Fornecidos na página WoC

A Equipa ...
João P. Barreto - Gab.1.1
Coordenação / Teórica + Labs
jpbar@deec.uc.pt
Tiago Morgado - Gab.3A.24
Labs
tiago.morgado@co.it.pt
We Want
YOU!
Gabriel Falcão - Gab.3A.1
Labs
gff@deec.uc.pt

Linguagem C 
- Ponteiros e Arrays -

Programa em C espalhado por ficheiros
#include<stdio.h>
int IntroduzFaltas();
!
int main(){
int total=15, faltas;
faltas=IntroduzFaltas();
printf("Vai entao assistir a %d aulas n",total-faltas);
}
#include<stdio.h>
!
int IntroduzFaltas(){
int tmp;
printf("Quantas faltas vai dar? ");
scanf("%d",&tmp);
return(tmp);
}
Ficheiromain.cFicheirointro.c

Compilação : Overview
O compilador converte C em código máquina (string
the 0s e 1s) que é específico da arquitectura.
§ Diferente do Java que converte para um bytecode
independente da arquitectura (máquina virtuais).
§ Diferente do Python que interpreta o código permitindo
interactividade.
§ Para o C a geração do executável passa normalmente por
duas etapas principais:
Ä A compilação, que converte ficheiros .c (código fonte) em
ficheiros .o (código objecto).
gcc -c main.c
gcc -c intro.c
!
Ä A linkagem, que junta os ficheiros .o num executável final
gcc -o final.exe main.o intro.o

Anatomia de um Computador
PortosdeI/O
Memória GPU
Sound
Blaster
Keyboard
Mouse
Modem
Controlo (e. g.
interrupcões)
Endereços
DADOS

Endereço vs. Valor
Considere a memória como sendo um grande array:
§ Cada célula do array tem um endereço associado
§ Cada célula do array contém um valor
!
Não confundir o endereço, que referencia uma
determinada célula de memória, com o valor
armazenado nessa célula de memória.
!
É ridículo dizer que vocês e o vosso endereço de
correio são a mesma coisa !
23 42 ......
101 102 103 104 105 ...

Ponteiros (revisão)
Um endereço referencia uma determinada zona da
memória. Por outras palavras, aponta para essa zona
de memória.
Ponteiro: uma variável que contém um endereço de
memória
23 42 ......
101 102 103 104 105 ...
x y
zona (endereço)
Nome
da variável
p
104

Ponteiros (revisão)
Operador & : obtém o endereço da variável
Operador *: dá acesso ao valor apontado, tanto para fins de leitura, como escrita.
printf(“p points to %dn”,*p);
x = 3;
p ? x 3
p =&x;
p x 3
p ? x ?int *p, x;
p x 5
*p = 5;

Ponteiros e Passagem de Parâmetros (revisão)
!
Em C a passagem de parâmetros é sempre feita “por valor”
void addOne (int x) { 
x = x + 1; 
}
int y = 3;
addOne(y);
!
y é ainda = 3
void addOne (int *p) { 
*p = *p + 1; 
}
int y = 3;
!
addOne(&y);
!
y é agora = 4

Sintaxe do C: Função main (revisão)
Para a função main aceitar parâmetros de entrada
passados pela linha de comando, utilize o seguinte:
!
int main (int argc, char *argv[])
!
O que é isto significa?
§ argc indica o número de strings na linha de comando (o
executável conta um, mais um por cada argumento adicional).
Ä Example: unix% sort myFile
§ argv é um ponteiro para uma array que contém as strings da
linha de comando (ver adiante).

Concluíndo ...
As declarações são feitas no inicio de cada função/
bloco.
Só o 0 e o NULL são avaliados como FALSO.
Os dados estão todos em memória. Cada célula/zona
de memória tem um endereço para ser referenciada e
um valor armazenado. (não confudir endereço com
valor).
Um ponteiro é a "versão C" de um endereço .
* “segue" um ponteiro para obter o valor apontado
& obtém o endereço de uma variável
Os ponteiros podem referenciar qualquer tipo de
dados (int, char, uma struct, etc.).

Trabalho para Casa ...
P&H - Computer Organization and Design!
Capítulo 1 (ler) Secções 3.1, 3.2 e 3.3 (ignorar referências ao MIPS)!
!
K&R - The C Programming Language!
Capítulos 1 a 5 (revisão de programação em C)!
!

Linguagem C 
- Ponteiros e Arrays -
(Continuação)
C

Ponteiros e Alocação (1/2)
Depois de declararmos um ponteiro:
!
int *ptr;
!
ptr não aponta ainda para nada (na realidade aponta
para algo … só não sabemos o quê!). Podemos:
!
§ Fazê-lo apontar para algo que já existe (operador &), ou
§ Alocar espaço em memória e pô-lo a apontar para algo novo
… (veremos isto mais à frente)

Ponteiros & Alocação (2/2)
Apontar algo que já existe:
int *ptr, var1, var2;
var1 = 5;
ptr = &var1;
var2 = *ptr;
!
var1 e var2 têm espaço que foi implicitamente
alocado (neste caso 4 bytes)
ptr var1 ? var2 ?5 5?

Atenção aos Ponteiros !!!
Declarar um ponteiro somente aloca espaço para
guardar um endereço de memória - não aloca nenhum
espaço a ser apontado.
As variáveis em C não são inicializadas, elas podem
conter qualquer coisa.
O que fará a seguinte função?
void f()
{
int *ptr;
*ptr = 5;
}
DESASTRE

Tabelas/Arrays (1/5)
Declaração:
int ar[2];
declara uma tabela de inteiros com 2 elementos. Uma
tabela/array é só um bloco de memória (neste caso de
8 bytes).
Declaração: 
int ar[] = {795, 635};
declara e preenche uma tabela de inteiros de 2
elementos.
Acesso a elementos:
ar[num];
devolve o numº elemento (atenção o primeiro elemento
é acedido com num=0).

Arrays são (quase) idênticos a ponteiros
§ char *string e char string[] são declarações muito
semelhantes
§ As diferenças são subtis: incremento, declaração de
preenchimento de células, etc
!
Conceito Chave: Uma variável array (o "nome da
tabela") é um ponteiro para o primeiro elemento..

!
Consequências:
!
§ ar é uma variável array mas em muitos aspectos comporta-se
como um ponteiro
§ ar[0] é o mesmo que *ar
§ ar[2] é o mesmo que *(ar+2)
§ Podemos utilizar aritmética de ponteiros para aceder aos
elementos de uma tabela de forma mais conveniente.
!
O que está errado na seguinte função?
!
char *foo() { 
char string[32]; ...; 
return string; 
}

Array de dimensão n; queremos aceder aos elementos
de 0 a n-1, usando como teste de saída a comparação
com o endereço da "casa" depois do fim do array.
int ar[10], *p, *q, sum = 0; 
... 
p = &ar[0]; q = &ar[10]; 
while (p != q) 
sum += *p++; /* sum = sum + *p; p = p + 1; */
O C assume que depois da tabela continua a ser um
endereço válido, i.e., não causa um erro de bus ou um
segmentation fault
O que aconteceria se acrescentassemos a seguinte
instrução?
*q=20;

Erro Frequente: Uma tabela em C NÃO sabe a sua
própria dimensão, e os seus limites não são verificados
automaticamente!
§ Consequência: Podemos acidentalmente transpôr os limites
da tabela. É necessário evitar isto de forma explicita
§ Consequência: Uma função que percorra uma tabela tem que
receber a variável array e a respectiva dimensão.
!
Segmentation faults e bus errors:
§ Isto são "runtime errors" muito difíceis de detectar. É preciso
ser cuidadoso! (Nas práticas veremos como fazer o debug
usando gdb…)

Segmentation Fault vs Bus Error?
Retirado de
http://www.hyperdictionary.com/
!
Bus Error
§ A fatal failure in the execution of a machine language
instruction resulting from the processor detecting an
anomalous condition on its bus. Such conditions include
invalid address alignment (accessing a multi-byte number at
an odd address), accessing a physical address that does not
correspond to any device, or some other device-specific
hardware error. A bus error triggers a processor-level
exception which Unix translates into a “SIGBUS” signal which,
if not caught, will terminate the current process.
!
Segmentation Fault
§ An error in which a running Unix program attempts to access
memory not allocated to it and terminates with a segmentation
violation error and usually a core dump.

Boas e Más Práticas
Má Prática
int i, ar[10]; 
for(i = 0; i < 10; i++){ ... }
!
Boa Prática  
#define ARRAY_SIZE 10 
int i, a[ARRAY_SIZE]; 
for(i = 0; i < ARRAY_SIZE; i++){ ... }
!
Porquê? SINGLE SOURCE OF TRUTH
§ Evitar ter múltiplas cópias do número 10.

Aritmética de Ponteiros (1/4)
!
Um ponteiro é simplesmente um endereço de memória.
Podemos adicionar-lhe valores de forma a percorrermos
uma tabela/array.
p+1 é um ponteiro para o próximo elemento do array.
*p++ vs (*p)++ ?
§ x = *p++ ⇒ x = *p ; p = p + 1;
§ x = (*p)++ ⇒ x = *p ; *p = *p + 1;
O que acontece se cada célula da tabela tiver uma
dimensão superior a 1 byte?
§ O C trata disto automáticamente. Na realidade p+1 não
adiciona 1 ao endereço de memória, adiciona sim o
tamanho de cada elemento da tabela. (por isso é que
associamos tipos aos ponteiros)

!
Quais são as operações válidas?
§ Adicionar inteiros a ponteiros.
§ Subtrair 2 ponteiros no mesmo array (para saber a dua
distância relativa).
§ Comparar ponteiros (<, <=, ==, !=, >, >=)
§ Comparar o ponteiro com NULL (indica que o ponteiro não
aponta para nada).
!
... tudo o resto é inválido por não fazer sentido
§ Adicionar 2 ponteiros
§ Multiplicar 2 ponteiros
§ Subrair um ponteiro de um inteiro

int get(int array[], int n)
{
return (array[n]);
/* OR */
return *(array + n);
}
O C sabe o tamanho daquilo que o ponteiro aponta (definido
implicitamente na declaração) – assim uma adição/subtracção
move o ponteiro o número adequado de bytes.
§ 1 byte para char, 4 bytes para int, etc.
!
As seguintes instruções são equivalentes:

Podemos utilizar a aritmética de ponteiros para
"caminhar" ao longo da memória:
void copy(int *from, int *to, int n) {
int i;
for (i=0; i<n; i++) {
*to++ = *from++;
}
}

Representação ASCII the carácteres
Os carácteres são
representados através
de bytes
Existem várias
codificações: ASCII,
unicode, etc
É tudo um questão de
interpretação ...
char a='A';
a=a+3;
puts(&a);
O que aparece?

Uma string em C é um array de carácteres.
char string[] = "abc";
!
Como é que sabemos quando uma string termina?
§ O último carácter é seguido de um byte a 0 (null terminator)
!
!
!
!
!
Um erro comum é esquecer de alocar um byte para o terminador
C Strings
int strlen(char s[])
{
int n = 0;
while (s[n] != 0) n++;
return n;
}

Arrays bi-dimensionais (1/2)
#define ROW_SIZE 3
#define COL_SIZE 2
!
...
char Mat[ROW_SIZE][COL_SIZE];
char aux=0;
int i, j;
for ( i=0; i<ROW_SIZE; i++)
for ( j=0; j<COL_SIZE; j++) {
Mat[i][j]=aux;
aux++;
}
...
6
5
4
3
2
1
0 Mat
Endereços
MEMÒRIA
0 1
2 3
4 5
Mat =

Arrays bi-dimensionais (2/2)
O C arruma um array bi-dimensional empilhando as linhas
umas a seguir às outras.
!
O espaço total de memória ocupado é
ROW_SIZExCOL_SIZE
!
Temos que:
Mat[2][1] é o mesmo que Mat[2*COL_SIZE+1]

Arrays vs. Ponteiros
O nome de um array é um ponteiro para o primeiro
elemento da tabela (indíce 0).
Um parâmetro tabela pode ser declarado como um
array ou um ponteiro.
int strlen(char s[])
{
int n = 0;
while (s[n] != 0)
n++;
return n;
}
int strlen(char *s)
{
int n = 0;
while (s[n] != 0)
n++;
return n;
}
Pode ser escrito: 
while (s[n])

!
ptr + 1
1 + ptr
ptr + ptr
ptr - 1
1 - ptr
ptr - ptr
ptr1 == ptr2
ptr == 1
ptr == NULL
ptr == NULL
How many of the following are invalid?
I. pointer + integer
II. integer + pointer
III. pointer + pointer
IV. pointer – integer
V. integer – pointer
VI. pointer – pointer
VII. compare pointer to pointer
VIII. compare pointer to integer
IX. compare pointer to 0
X. compare pointer to NULL
QUIZ - Aritmética de Ponteiros
#invalid
1
2
3
4
5
6
7
8
9
(1)0

Concluindo …
Ponteiros e arrays são virtualmente o mesmo
!
O C sabe como incrementar ponteiros
!
O C é uma linguagem eficiente com muito poucas
protecções
§ Os limites das arrays não são verificados
§ As variáveis não são automaticamente inicializadas
!
(Atenção) O custo da eficiência é um "overhead"
adicional para o programador
§ “C gives you a lot of extra rope but be careful not to hang
yourself with it!” (tirado de K&R)

Linguagem C 
- Alocação Dinâmica -

Alocação dinâmica de memória (1/4)
Em C existe a função sizeof() que dá a dimensão em bytes do tipo ou
variável que é passada como parâmetro.
!
Partir do príncipio que conhecemos o tamanho dos objectos pode dar
origem a erros e é uma má prática, por isso utilize sizeof(type)
§ Há muitos anos o tamanho de um int eram 16 bits, e muitos
programas foram escritos com este pressuposto.
§ Qual é o tamanho actual de um int?
!
“sizeof” determina o tamanho para arrays:
int ar[3]; // Or: int ar[] = {54, 47, 99}
sizeof(ar) ⇒ 12
§ …bem como para arrays cujo tamanho é definido em run-time:
int n = 3;
int ar[n]; // Or: int ar[fun_that_returns_3()];
sizeof(ar) ⇒ 12

Para alocar memória para algo novo utilize a função
malloc() com a ajuda de typecast e sizeof:
!
ptr = (int *) malloc (sizeof(int));
§ ptr aponta para um espaço algures na memória com tamanho
(sizeof(int)) bytes.
§ (int *) indica ao compilador o tipo de objectos que irá ser
guardado naquele espaço (chama-se um typecast ou
simplesmente cast).
!
malloc é raramente utilizado para uma única variável
ptr = (int *) malloc (n*sizeof(int));
§ Isto um array de n inteiros.

Depois do malloc() ser chamado, a memória
alocada contém só lixo, portanto não a utilize até ter
definido os valores aí guardados.
!
Depois de alocar dinâmicamente espaço, deverá
libertá-lo de forma também dinâmica:
free(ptr);
!
Utilize a função free()para fazer a limpeza
§ Embora o programa liberte toda a memória na saída (ou
quando o main termina), não seja preguiçoso!
§ Nunca sabe quando o seu código será re-aproveitado e o
main transformado numa sub-rotina!

As seguintes acções fazem com que o seu programa "crash" ou
se comporte estranhamente mais à frente. Estes dois erros são
bugs MUITO MUITO difíceis de se apanhar, portanto atenção:
§ free()ing a mesma zona de memória mais do que uma vez
§ chamar free() sobre algo que não foi devolvido por
malloc()
!
O runtime não verifica este tipo de erros
§ A alocação de memória é tão crítica para o desempenho que
simplesmente não há tempo para fazer estas verificações
§ Assim, este tipo de erros faz com que as estruturas internas
de gestão de memória sejam corrompidas
§ E o problema só se manifesta mais tarde numa zona de
código que não tem nada a ver …!

Duferença súbtil entre arrays e ponteiros
void foo() { 
int *p, *q, x, a[1]; // a[] = {3} also works here  
p = (int *) malloc (sizeof(int)); 
q = &x; 
 
*p = 1; // p[0] would also work here  
*q = 2; // q[0] would also work here  
*a = 3; // a[0] would also work here 
 
printf("*p:%u, p:%u, &p:%un", *p, p, &p); 
printf("*q:%u, q:%u, &q:%un", *q, q, &q); 
printf("*a:%u, a:%u, &a:%un", *a, a, &a);
}
? ? ......
12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 ...
p q x a
? ? ?
unnamed-malloc-space
52 32 2 3 1
*p:1, p:52, &p:24
*q:2, q:32, &q:28
*a:3, a:36, &a:36

Binky Video

Which are guaranteed to print out 5?
I: main() {  
int *a-ptr; *a-ptr = 5; printf(“%d”, *a-ptr); }
II: main() { 
int *p, a = 5;  
p = &a; ... 
/* code; a & p NEVER on LHS of = */  
printf(“%d”, a); }
III: main() { 
int *ptr; 
ptr = (int *) malloc (sizeof(int)); 
*ptr = 5; 
printf(“%d”, *ptr); }
QUIZ
I II III 
0: - - - 
1: - - YES 
2: - YES - 
3: - YES YES 
4: YES - -  
5: YES - YES 
6: YES YES - 
7: YES YES YES
Nota: LHS significa "Left Hand Side"

QUIZ
!
!
{ char a= 0xFF;
unsigned char b=0xFF;
printf(" %d %d n", a, b);
...
!
!
§ O que é que aparece no ecrãn?

Para saber mais ...
K&R - The C Programming Language
§ Capítulo 5
!
Tutorial de Nick Parlante
!
Links úteis para Introdução ao C
§ http://man.he.net/ (man pages de Unix)
§ http://linux.die.net/man/ (man pages de Unix)
!
§ http://www.lysator.liu.se/c/bwk-tutor.html
§ http://www.allfreetutorials.com/content/view/16/33/ (vários tutoriais)

Linguagem C 
- Zonas de Memória -

Variáveis Globais
A declaração de ponteiros não aloca memória
em frente do ponteiro
Até agora falámos de duas maneiras
diferentes de alocar memória:
§ Declaração de variáveis locais
int i; char *string; int ar[n];
§ Alocação dinâmica em runtime usando "malloc"
ptr = (struct Node *) malloc(sizeof(struct
Node)*n);
Existe uma terceira possibilidade ...
§ Declaração de variáveis fora de uma função (i.e.
antes do main)
Ä É similar às variavéis locais mas tem um âmbito
global, podendo ser lida e escrita de qualquer ponto
do programa
int myGlobal;
main() {
}

Gestão de Memória em C (1/2)
Um programa em C define três zonas de memória
distintas para o armazenamento de dados
§ Static Storage: onde ficam as variáveis globais que podem ser
lidas/escritas por qualquer função do programa. Este espaço está
alocado permanetemente durante todo o tempo em que o
programa corre (daí o nome estático)
§ A Pilha/Stack: armazenamento de variáveis locais, parâmetros,
endereços de retorno, etc.
§ A Heap (dynamic malloc storage): os dados são válidos até ao
instante em que o programador faz a desalocação manual com
free().
!
O C precisa de saber a localização dos objectos na
memória, senão as coisas não funcionam como devem.

O espaço de endereçamento de
um programa contém 4 regiões:
§ stack: variáveis locais, cresce para
baixo
§ heap: espaço requisitado via malloc()
; cresce para cima.
§ Dados estáticos: variáveis globais
declaradas for a do main(), tamanho
constante durante a execução.
§ código: Carregado quando o programa
começa, o tamanho não se modifica.
O Sistema Operativo
evita a sobreposição da
Stack com a Heap
code
static data
heap
stack
~ FFFF FFFFhex
~ 0hex
Gestão de Memória em C (2/2)

Onde é que as variáveis são alocadas?
Se são declaradas fora de
qualquer função/procedimento,
então são alocadas na zona
estática.
!
Se são declaradas dentro da
função, então são alocadas na
“stack” sendo o espaço liberto
quando o procedimento termina.
§ NB: main() is a procedure
int myGlobal;
main() {
int myTemp;
}

SP
A Pilha/Stack (1/2)
Um "Stack Frame" incluí:
§ Endereços de retorno
§ Parâmetros
§ Espaço para variáveis locais
Os "Stack frames" são blocos
contíguos de memória; o "stack
pointer" indica qual é o "frame" no
topo da pilha (ver FILO)
Quando uma rotina termina o seu
"stack frame" é descartado (não
explicitamente apagado). Isto
permite libertar memória para futuras
utilizações
frame
frame
frame
frame

A Pilha/Stack (2/2)
Last In, First Out (LIFO) data structure
main ()
{ a(0);
}
void a (int m)
{ b(1);
}
void b (int n)
{ c(2);
}
void c (int o)
{ d(3);
}
void d (int p)
{
}
stack
Stack Pointer
Stack Pointer
Stack Pointer
Stack Pointer
Stack Pointer
Stack
grows
down

Os ponteiros em C permitem-nos aceder a zonas de
memória que foram entretanto desalocadas. Isto pode levar a
problemas de consistência e bugs difíceis de encontrar !
!
int *ptr () { 
int y; 
y = 3; 
return &y; 
}; 
main () { 
int *stackAddr,content;  
stackAddr = ptr(); 
content = *stackAddr; 
printf("%d", content); /* 3 */ 
content = *stackAddr; 
printf("%d", content); /*13451514 */ 
};
main
ptr() 
(y==3)
SP
main
SP
main
printf() 
(y==?)
SP
Quem gere a pilha ?

A Heap (Memória Dinâmica)
!
Grande bloco de memória, onde a alocação não é feita de
forma contígua. É uma espécie de "espaço comunal" do
programa.
!
Em C, é necessário especificar o número exacto de bytes
que se pretende alocar
int *ptr; 
ptr = (int *) malloc(sizeof(int)); 
/* malloc returns type (void *), 
so need to cast to right type */
§ malloc(): aloca memória não inicializada na área da heap

Características das diferentes zonas de memória
Variáveis estáticas
§ Espaço de memória acessível a partir de qualquer zona do
programa
§ O espaço de memória permanece alocado durante todo o
"runtime" (pouco eficiente)
!
Pilha/Stack
§ Guarda variáveis locais, endereços de retorno, etc.
§ A memória é desalocada sempre que uma rotina termina,
permitindo a re-utilização por um novo procedimento.
§ Funciona como o "bloco de notas" das funções/procedimentos
§ Não é adequada para armazenar dados de grandes dimensões
(stack overflow)
§ Não permite a partilha de dados entre diferentes procedimentos

Características das diferentes zonas de memória
Heap / Alocação dinâmica
§ Alocação em "runtime" de blocos de memória
§ A alocação não é contígua, e os blocos podem ficar muito distantes
no espaço de endereçamento
§ Em C, a dealocação tem que ser feita de forma explícita pelo
programador (no Garbage Collector)
§ Os mecanismos de gestão de memória são complexos de forma a
evitar a fragmentação

Gestão de Memória
Como é feita a gestão de memória?
!
§ Zona do código e variáveis estáticas é fácil:  
estas zonas nunca aumentam ou diminuem
!
§ O espaço da pilha também é fácil:  
As "stack frames" são criadas e destruídas usando uma ordem
last-in, first-out (LIFO)
!
§ Gerir a heap já é mais complicado: 
a memória pode ser alocada / desalocada em qualquer
instante

Requisitos da Gestão da Heap
As funções malloc() e free() devem executar
rapidamente.
!
Pretende-se o mínimo de overhead na gestão de memória
!
Queremos evitar fragmentação (externa)* –  
quando a maior parte da memória está dividida em vários
blocos pequenos
§ Neste caso podemos ter muito bytes disponíveis mas não sermos
capazes de dar resposta a uma solicitação de espaço porque os
bytes livres não são contíguos.

Gestão da Heap (1/2)
Exemplo
§ Request R1 for 100 bytes
§ Request R2 for 1 byte
§ Memory from R1 is freed
R2 (1 byte)
R1 (100 bytes)

Gestão da Heap (2/2)
Exemplo
§ Request R2 for 1 byte
§ Memory from R1 is freed
R2 (1 byte)
R3?
R3?

QUIZ do Intervalo
int main(void){ 
int A[] = {5,10}; 
int *p = A; 
 
printf(“%u %d %d %dn”,p,*p,A[0],A[1]); 
p = p + 1; 
*p = *p + 1; 
}
Se o primeiro printf mostrar 100 5 5 10, qual será o output dos outros dois printf ?
1: 101 10 5 10 then 101 11 5 11 
2: 104 10 5 10 then 104 11 5 11 
3: 101 <other> 5 10 then 101 <3-others> 
4: 104 <other> 5 10 then 104 <3-others> 
5: Um dos dois printfs causa um ERROR  
6: Rendo-me!
A[1]
5 10
A[0] p

Linguagem C 
- Gestão da Memória Dinâmica-

Mecanismos de Gestão da Heap
Alocação Dinâmica "Manual" - Caso do C, em que o
programador é responsável por alocar e libertar os blocos de
memória
§ Malloc()/free() implementação do K&R Sec 8.7 (ler só introdução)
§ Slab Alocators
§ Buddy System
Alocação "Automática" / Garbage Collectors - O sistema
mantém registo de forma automática das zonas da heap que
estão alocadas e em uso, reclamando todas as restantes*
§ Contagem de referências
§ Mark and Sweep
§ Copying Garbage Collection
* O overhead com Garbage Collectors é obviamente maior

Implementração do Malloc/Free (K&R Sec. 8.7)
Cada bloco de memória na heap tem um cabeçalho
com dois campos:
§ tamanho do bloco e
§ um ponteiro para o bloco livre seguinte
!
Todos os blocos livres são mantidos numa lista ligada
circular (a "free list").
!
Normalmente os blocos da "free list" estão por ordem
crescente de endereços no espaço de endereçamento
!
No caso de um bloco ser alocado, o sue ponteiro fica
NULL.

Implementração do Malloc/Free (K&R Sec. 8.7)
malloc() procura na "free list" um bloco que seja
suficientemente grande para satisfazer o pedido.
§ Se existir, então bloco é partido de forma a satisfazer o pedido, e
a "sobra" é mantida na lista.
§ Se não existir então é feito um pedido ao sistema operativo de
mais áreas de memória.
!
free() verifica se os blocos adjacentes ao bloco liberto
tambésm estão livres.
§ Se sim, então os blocos adjacentes são juntos (coalesced) num
único bloco de maiores dimensões (evitar fragmentação)
§ Se não, o bloco é simplesmente adicionado à "free list".

Qual é o bloco que o malloc()escolhe?
Se existirem vários blocos na "free list" que
satisfaçam os requisitos, qual deles é que é escolhido?
!
§ best-fit: escolhe o bloco mais pequeno que satisfaça os
requisitos de espaço
!
§ first-fit: Escolhe o primeiro bloco que satisfaça os requisitos
!
§ next-fit: semelhante ao first-fit, mas lembra-se onde terminou a
pesquisa da última vez, e retoma-a a partir desse ponto (não
volta ao inicio)

QUIZ - Prós e Contras dos "Fit"
A. Um contra do first-fit é que resulta em vários pequenos blocos
no inicio da free list
B. Um contra do next-fit é que é mais lento do que o first-fit, dado
que demora mais tempo à procura de um bloco adequado
C. Um contra do best-fit é que gera muitos blocos de pequenas
dimensões na free list
ABC
0: FFF
1: FFT
2: FTF
3: FTT
4: TFF
5: TFT
6: TTF
7: TTT

Slab Allocator (1/2)
Um sistema alternativo utilizado na GNU libc
!
Divide os blocos que formam a heap em "grandes" e
"pequenos". Os "grandes" são geridos através de uma
freelist como anterioremente
!
Para blocos pequenos, a alocação é feita em blocos
que são múltiplos de potências de 2
§ e.g., se o programa quiser alocar 20 bytes, dá-se-lhe 32 bytes.

Slab Allocator (2/2)
A gestão dos pequenos blocos é fácil; basta usar um bitmap para
cada gama de blocos do mesmo tamanho
!
!
!
!
!
!
Os bitmaps permitem minimizar os overheads na alocação de blocos
pequenos (mais frequentes)
!
As desvantagens do esquema são
!Existem zonas alocadas que não são utilizadas (caso dos 32 bytes para
20 pedidos)
!A alocação de blocos grandes é lenta
16 byte blocks:
32 byte blocks:
64 byte blocks:
16 byte block bitmap: 11011000

Fragmentação Externa vs Interna
Com o slab allocator, a diferença entre o tamanho
requisitado e a potência de 2 mais próxima faz com que
se desperdice muito espaço
§ e.g., se o programa quer alocar 20 bytes e nós damos 32
bytes, então há 12 bytes que não são utilizados
!
Repare que isto não é fragmentação externa. A
fragmentação externa refere-se aos espaço
desperdiçado entre blocos alocados.
Este problema é conhecido por fragmentação interna.
Trata-se de espaço desperdiçado dentro de um bloco já
alocado.

Buddy System (1/2)
Outro sistema de gestão de memória usado no kernel
do Linux.
!
É semelhante ao “slab allocator”, mas só aloca blocos
em tamanhos que são potência 2 (fragmentação
interna é ainda possível)
!
Matém free-lists separadas para cada tamanho
§ e.g., listas separadas para 16 byte, 32 byte, 64 byte, etc.

Buddy System (2/2)
Se não há um bloco de tamanho n disponível, então
procura um bloco de tamanho 2n e divide-o em dois blocos
de tamanho n
Quando o bloco de tamanho n é liberto, então, se o
vizinho (buddy) estiver também livre, os dois são
combinados num bloco de 2n  
 
 
!
!
Tem as mesmas vantagens de velocidade que o slab
buddies NOT buddies

Esquemas de Alocação
Qual destes sistemas é o melhor?
!
§ Não existe um esquema que seja melhor para toda
e qualquer aplicação
§ As aplicações têm diferentes padrões de alocação/
dealocação.
§ Um esquema que funcione bem para uma
aplicação, poderá não funcionar bem para outra.

Gestão automática de memória
É díficil gerir e manter registos das alocação/
desalocações de memória – porque não tentar faze-lo
de forma automática?
!
Se conseguirmos saber em cada instante de runtime
os blocos da heap que estão a ser usados, então todo
o espaço restante está livre para alocação.
§ A memória que não está a ser apontada chama-se garbage (é
impossível aceder-lhe). O processo de a recuperar chama-se
garbage collection. No C a recuperação/libertação de memória
tem que ser feita manualmente
!
Como conseguimos saber o que está a ser usado?

Manter Registo da Memória Utilizada
As técnica dependem da linguagem de programação
utilizada e precisam da ajuda do compilador.
!
Pode começar-se por manter registo de todos os
ponteiros, definidos tanto como váriaveis globais ou locais
(root set). (para isto o compilador tem de colaborar)
!
Ideia Chave: Durante o runtime mantém-se registo dos
objectos dinâmicos apontados por esses ponteiros.
§ Á partida um objecto que não seja apontado por ninguém é
garbage e pode ser desalocado.

Manter Registo da Memória Utilizada
Mas o problema não é assim tão simples …
§ O que é que acontece se houver um type cast daquilo que é
apontado pelo ponteiro? (permitido pelo C)
§ O que acontece se são definidas variáveis ponteiro na zona
alocada?
A pesquisa de garbage tem de ser sempre feita de forma
recursiva.
Não é um mecanismo simples e envolve sempre maiores
overheads do que a gestão manual
Os "Garbage Collectors" estão fora do nosso programa,
mas os alunos interessados poderão consultar o material
suplementar fornecido na WoC.

Concluindo …
O C tem 3 zonas de memória
§ Armazenamento estático: variáveis globais
§ A Pilha: variáveis locais, parâmetros, etc
§ A heap (alocação dinâmica): malloc() aloca espaço, free() liberta
espaço.
Várias técnicas para gerir a heap via malloc e free: best-,
first-, next-fit
§ 2 tipos de fragmentação de memória: interna e externa; todas as
técnicas sofrem com pelo menos uma delas
§ Cada técnica tem pontos fortes e fracos, e nenhuma é melhor para
todos os casos
A gestão automática de memória liberta o programador da
responsabilidade de gerir a memória. O preço é um maior
overhead durante a execução.

Para saber mais ...
Hilfiger Notes (fornecidas na WoC)
!
Artigo a explicar a divisão de memória no C (atenção
dividem a zona estática em inicializada e não inicializada)
!http://www.informit.com/articles/article.aspx?p=173438
!
A Wikipedia ao nosso serviço
!http://en.wikipedia.org/wiki/Dynamic_memory_allocation
!http://en.wikipedia.org/wiki/
Garbage_collection_(computer_science)

Sistemas Microprocessadores 2013/2014
Introdução ao MIPS 
- Linguagem Assembly e Operações
Aritméticas -

Linguagem Assembly
• Tarefa principal do CPU: Executar muitas instruções.
!
• As instruções definem as acções/operações básicas
que o CPU é capaz de levar a cabo.
!
• Diferentes CPUs implementam diferentes conjuntos de
instruções. O conjunto de instruções implementado por
um determinado CPU designa-se por Instruction Set
Arquitecture (ISA).
§ Examplos: Intel 80x86 (Pentium 4), IBM/Motorola PowerPC
(Macintosh), MIPS, Intel IA64, ...

Instruction Set Architectures
• Inicialmente a filosofia de desenvolvimento consistia em
adicionar mais instruções aos novos processadores para
realizar tarefas cada vez mais complexas
§ A arquitectura VAX tinha instruções para a multiplicação de
polinómios!
§ Estes eram os processadores CISC (Complete Instruction Set
Computing)
!
• A partir da década de 80 a filosofia RISC - Reduced
Instruction Set Computing - começou a impor-se
§ Manter um "instruction set" pequeno e simples facilita o desenho de
hardware mais rápido (smaller is faster).
§ As operações complicadas são feitas pelo software através da
composição de várias instruções simples.

Arquitectura do MIPS
• MIPS – companhia de semicondutores que
construiu uma das primeiras arquitecturas
comerciais RISC.
• A MIPS adquiriu recentemente a CHIPIDEA por
mais de 20 milhões de euros. Da fusão resultou a
maior companhia mundial do sector.
• Nesta disciplina iremos estudar a arquitectura do
MIPS em detalhe.
• Porquê o MIPS e não o Intel 80x86?
§ MIPS é simples e elegante. O design da Intel é mais turtuoso
devido à necessidade de manter compatibilidade com versões
anteriores (legacy issues).
§ MIPS é mais usado que Intel em aplicações embebidas.
E há mais computadores embebidos que PCs.

"Variáveis" em Assembly: Registos (1/3)
• Ao contrário de Linguagens de Alto Nível, como o C e o
Python, o assembly não pode usar variáveis
§ Porque não? "Keep the hardware simple"
!
• Os operandos em assembly são os registos
§ Pequeno número de locais de armazenamento construídos
directamente em hardware
§ As operações só podem ser realizadas sobre os registos!
!
• Benefício: Como os registos são construídos
directamente em hardware, são muito rápidos  
(uma mudança num registo é feita em menos de um
nano-segundo )

• Desvantagem: Como os registos são construídos em
hardware, existe um número pré-determinado que não
pode ser aumentado.
§ Solução: O código do MIPS tem que ser feito com cuidado de
forma a usar eficientemente os recursos disponíveis.
!
• O MIPS tem 32 registos ... e o x86 ainda tem menos!
§ Porquê 32? Smaller is faster
!
• Os registos no MIPS têem todos 32 bits
§ Os grupos de 32 bits chamam-se uma word na arquitectura do
MIPS
§ Atenção que a dimensão de uma word muda entre diferentes
arquitecturas

• Os registos estão numerados de 0 a 31
!
!
• Os registos tanto podem ser referenciados por um número como por um nome:
§ Referência por número :
$0, $1, $2, … $30, $31
§ Referência por nome :
Ä Semelhante às variáveis em C
$16 - $23 è $s0 - $s7
Ä Variáveis temporárias
$8 - $15 è $t0 - $t7
§ Mais à frente falaremos dos nomes dos 16 registos que faltam.
!
• Utilize preferencialmente nomes para tornar o seu código mais legível

QUIZ
Para Pensar:
!
- Quais serão os programas compilados que ocuparão mais
espaço em memória? Os programas para uma arquitectura
CISC ou RISC?
!
- Em que medida o aumento no tamanho das memórias
disponíveis terá ajudado à mudança de CISC para RISC

C, Java variáveis vs. registos
• Nas linguagens de alto nível como o C, as variáveis têm
de ser previamente declarada como pertencendo a um
determinado tipo
§ Exemplo:  
int fahr, celsius;  
char a, b, c, d, e;
• Uma variável só pode representar um valor do tipo
declarado (e.g. não podemos misturar e comparar
variáveis do tipo int e char).
!
• Em assembly os registos não têm um tipo pré-definido.
As operações sobre os registos é que vão definir
implicitamente o tipo dos dados.

Comentários em Assembly
• Utilizar comentários também ajuda a tornar o código
mais legível!
!
• Em MIPS para comentar uma linha utilize o simbolo
cardinal (#)
!
• Nota: Diferente do C
§ Os comentários em C têm a forma  
/* comment */  
e podem ter múltiplas linhas

Instruções em Assembly
• Em assembly, cada linha de código (designada por
Instrução), executa uma, e uma só, acção de uma lista
de comandos simples pré-estabelecidos
!
• Ao contrário do que acontece no C, cada linha contém
no máximo uma instrução para o processador.
!
• As instruções em assembly são equivalentes às
operações (=, +, -, *, /) em C ou Java.
!
• OK, chega de conversa introdutória … vamos começar
a controlar o MIPS!

• Sintáxe:
1 2, 3, 4
Onde :
1) nome da operação
2) operando que recebe o resultado (“destination”)
3) 1º operando (“source1”)
!
• A sintáxe é rígida:
§ 1 operador + 3 operandos
§ Porquê? Regularidade para manter o hardware simples
Adição e Subtracção no MIPS (1/4)

• Adição em assembly
§ Exemplo: add $s0,$s1,$s2 (MIPS)
Equivalente a: a = b + c (C)
onde os registos do MIPS $s0,$s1,$s2 estão associados com
as variáveis do C a, b, c
!
• Subtração em assembly
§ Exemplo: sub $s3,$s4,$s5 (MIPS)
Equivalente a: d = e - f (C)
onde os registos do MIPS $s3,$s4,$s5 estão associados com
as variáveis do C d, e, f

• Qual é o equivalente à seguinte instrução em C?
a = b + c + d - e;
!
• Dividir em múltiplas instruções
add $t0, $s1, $s2 # temp = b + c
add $t0, $t0, $s3 # temp = temp + d
sub $s0, $t0, $s4 # a = temp - e
!
• Nota: Uma única linha em C pode dar origem a várias linhas
em assembly do MIPS.
!
• Nota: Tudo aquilo que estiver depois do cardinal é ignorado
(comentários)

• Qual é o equivalente da seguinte instrução?
f = (g + h) - (i + j);
!
• Temos que utilizar registos temporários
add $t0,$s1,$s2 # temp = g + h
add $t1,$s3,$s4 # temp = i + j
sub $s0,$t0,$t1 # f=(g+h)-(i+j)

Registo Zero
• O número zero (0) é um "imediato" que aparece muito
frequentemente no código.
!
• Definimos um registo zero ($0 ou $zero) para termos o
valor 0 sempre à mão; e.g.
add $s0,$s1,$zero (MIPS)
f = g (C)
onde os registos do MIPS $s0,$s1 estão associados com as
variáveis do C f, g
!
• O registo $zero está definido no hardware, e a instrução
add $zero,$zero,$s0
não faz nada

Valores Imediatos (1/2)
• As constantes númericas designam-se pro "imediatos".
!
• Os "imediatos" aparecem frequentemente no código. Sempre
que aparecem valores constantes temos que usar instruções
específicas (Porquê?)
!
• Adição com imediatos:
addi $s0,$s1,10 (MIPS)
f = g + 10 (C)
Onde os registos $s0,$s1 estão associados às variáveis do C f, g
!
• Sintáxe semelhante à instrução add, excepto no facto que o
último argumento é um número em vez de um registo

Valores Imediatos (2/2)
• Não existe uma instrução no MIPS para subtração com
imediatos: Porquê?
!
• O conjunto de instruções elementares deve ter a menor
dimensão possível de forma a simplificar o hardware.
§ Se uma operação pode ser decomposta em instruções mais
simples, então não faz sentido inclui-la no "instruction set"
§ addi …, -X é o mesmo que subi …, X portanto não há subi
!
• addi $s0,$s1,-10 (MIPS)
f = g - 10 (C)
onde os registos $s0,$s1 estão associados com as variáveis do C
f, g

QUIZ
A. Os Tipos é algo característico das declarações em C,
que se reflecte nas instruções (operadores) do MIPS.
!
B. Assumindo os 16 registos que vimos, como só existem
8 variáveis locais ($s) e 8 variáveis temporárias ($t),
nós não podemos escrever em assembly do MIPS
expressões em C que contenham involvam mais do que
16 variáveis.
!
C. Se a variável p (armazenada no registo $s0) for um
ponteiro para um array de ints, então a instrução em C
p++; corresponde a addi $s0 $s0 1
ABC
1: FFF
2: FFT
3: FTF
4: FTT
5: TFF
6: TFT
7: TTF
8: TTT

Concluindo …
• Na linguagem Assembly do MIPS:
§ Os registos substituem as variáveis em C
§ Existe uma instrução elementar por linha
§ "Simpler is Better"
§ "Smaller is Faster"
!
• Novas instruções que aprendemos:
add, addi, sub
!
• Novos registos:
Variáveis género C: $s0 - $s7
Variáveis temporárias: $t0 - $t9
Zero: $zero

Introdução à Linguagem Assembly  
- Load & Store -

A Memória
• Até aqui mapeámos as variáveis do C em registos do processador; o que
fazer com estruturas de dados de maiores dimensões como as tabelas/
arrays?
!
• As estruturas de dados são guardadas na memória, que é 1 dos 5
componentes fundamentais do computador
!
• As instruções aritméticas do MIPS só operam sobre registos, e nunca
sobre a memória.
!
• As instruções de transferência de dados permitem transferir dados entre
os registos e a memória:
§ Da memória para um registo
§ De um registo para a memória

Anatomia: os 5 componentes de um Computador
Processor
Computer
Control
(“brain”)
Datapath
Memory Devices
Input
Output
Personal Computer

• Os registos estão no "datapath" do processador.
!
• Se os operandos estiverem em memória, então:
Processor
Computer
Control
(“brain”)
Datapath
Registers
Memory Devices
Input
Output
Load (from)
Store (to)
Estas são as instruções para “data transfer” …
1. Os dados são
transferidos para os
registos,
2. a acção é realizada,
!
3. o resultado é colocado
de volta na memória.

Data Transfer: Memória para Reg. (1/4)
• Para transferir uma "word" de dados precisamos de
especificar duas coisas:
§ Registo: especifica-se usando o # de referência ($0 - $31) ou o
nome simbólico ($s0,…, $t0, …)
§ Endereço de memória: mais difícil
Ä Pense na memória como sendo uma grande tabela uni-
dimensional. Cada elemento dessa tabela é referenciado
por um ponteiro que corresponde ao endereço de uma
célula do array (char=1 byte) .
Ä Muitas vezes iremos crer incrementar esse ponteiro/
endereço
!
• Lembre-se:
§ “Load FROM memory”

• Para especificar um endereço de memória de onde quer
copiar precisa de duas coisas:
§ Um registo contendo um ponteiro para memória
§ Um deslocamento (offset) numérico (sempre bytes pois em
assembly não existem tipos)
!
• O endereço de memória pretendido é a soma destes dois
elementos.
!
• Exemplo: 8($t0)
§ Especifica o endereço de memória apontado pelo valor no registo
$t0, mais 8 bytes

• Sintáxe da instrução Load :
1 2, 3 (4)
Em que
2) registo que recebe o valor
3) deslocamento em bytes (offset)
4) registo contendo o endereço base (ponteiro) para a memória
!
• Nome da Operação:
§ lw (que significa Load Word, ou seja transferir 32 bits (1 word) de
cada vez)

• Exemplo: lw $t0,12($s0)
Esta instrução agarra no valor que está no registo $s0 (ponteiro
base), adiciona-lhe um deslocamento de 12 bytes para obter o
endereço de memória, e transfere para $t0 o conteúdo das 4
células de memória apontadas por esse endereço.
!
• Notas:
§ $s0 é chamado o registo base
§ 12 é chamado o offset
§ O offset é geralmente usado para aceder aos elementos de um array
ou estrutura: o registo base aponta para o inicio desse array ou
estrutura (nota o offset é sempre uma constante).
Data ﬂow

Data Transfer: Registo para Memória
• Queremos agora transferir do registo para a memória
§ A instrução store tem uma sintáxe semelhante ao load
• MIPS Instruction Name:
sw (significa Store Word, ou seja transferir 32 bits (1 word) de
cada vez)
!
!
• Exemplo: sw $t0,10($s0)
Esta instrução agarra no ponteiro em $s0, adiciona-lhe 10 bytes, e depois
guarda o valor do registo $t0 no endereço de memória assim calculado
!
• Lembre-se: “Store INTO memory”
Data ﬂow

Ponteiro vs. Valor
• Conceito Chave: Um registo guarda sempre um valor de 32
bits. Esse valor pode ser um int, um unsigned int, um
ponteiro (endereço de memória), etc. O "tipo" é implicitamente
definido pela operação sobre os dados
!
• Se fizer add $t2,$t1,$t0
então $t0 e $t1 contém valores/parcelas 
• Se fizer lw $t2,0($t0)
então $t0 deve conter um ponteiro
!
• Não faça confusão com isto!

Endereçamento: Byte vs. word
• Todas as words em memória têm um endereço.
!
• Os primeiros computadores referenciavam as words da mesma
forma que o C numera elementos num array:
§ Memory[0], Memory[1], Memory[2], …
“endereço” de uma word
No entanto os computadores precisam de referenciar
simultaneamente bytes e words (4 bytes/word)
!
Hoje em dia todas as arquitecturas endereçam a memória em bytes
(i.e.,“Byte Addressed”). Assim para aceder a words de 32-bits os
endereços têm que dar saltos de 4 bytes
§ Memory[0], Memory[4], Memory[8], …

Compilação de Acessos à Memória
• Qual o offset que devemos usar com lw para aceder a
A[5], sendo A uma tabela de int em C?
§ Para seleccionar A[5]temos que 4x5=20: byte v. word
!
• Desafio: Compile a instrução à mão usando registos:
§ g = h + A[5]com g: $s1, h: $s2, endereço base de A: $s3
!
§ Transfira da memória para o registo:
!! lw $t0,20($s3) # $t0 gets A[5]
Ä Adicione 20 a $s3 para seleccionar A[5]e coloque em $t0
!
§ Adicione o resutado a h e coloque em g 
! add $s1,$s2,$t0 # $s1 = h+A[5]

Notas sobre a memmória
• Erro Frequente: Esquecermo-nos que os endereços
de words sucessivas numa máquina com “Byte
Addressing” diferem em mais do que 1.
§ Muitos programadores de assembly cometem erros por
assumirem que o endereço da próxima word pode ser obtido
incrementando o registo em 1 unidade em vez de adicionarem
o número de bytes da word (diferente do C).
§ Ao contrário do que acontece no C, em assembly não existe a
noção de tipo, e é impossível o computador saber o tamanho
de uma word fazendo o ajuste implícito do incremento dos
ponteiros.
§ Lembre-se também que no lw e sw, a soma do endereço de
base com o offset deve ser sempre um múltiplo de 4 ( word
aligned memory )

Alinhamento de Memória
• No MIPS as words e objectos são guardados em memória
em bytes cujo endereço é sempre múltiplo de 4.
Alinhamento de Memória: os objectos começam sem pre
em endereços que são múltiplos do seu tamanho
§ Lembram-se do “Bus Error”?
0 1 2 3
Aligned
Not
Aligned
0, 4, 8, or Chex
O Último digíto hexa
do endereço é:
1, 5, 9, or Dhex
2, 6, A, or Ehex
3, 7, B, or Fhex

Registos vs Memória
• O que acontece se houver mais variáveis do que registos?
§ O compilador tenta manter as variáveis mais utilizadas nos registos
§ As variáveis menos usadas são armazenadas em memória: spilling
§ Consulte o comando register o C
!
• Porque não manter todas as variáveis em memória?
§ Smaller is faster: os registos são mais rápidos do que a memória
§ Os registos são mais versáteis:
Ä Cada instrução aritmética do MIPS pode ler 2 registos, fazer uma
operação sobre os dados, e escrever o resultado num registo
Ä Uma instrução de transferência de dados só pode ler ou escrever 1
operando.

QUIZ
Queremos traduzir a instrução *x = *y para assembly do MIPS
(x, y ptrs armazenados em: $s0 $s1)
A: add $s0, $s1, zero
B: add $s1, $s0, zero
C: lw $s0, 0($s1)
D: lw $s1, 0($s0)
E: lw $t0, 0($s1)
F: sw $t0, 0($s0)
G: lw $s0, 0($t0)
H: sw $s1, 0($t0)
0: A
1: B
2: C
3: D
4: E→F
5: E→G
6: F→E
7: F→H
8: H→G
9: G→H

E concluindo ...
• A memória é endereçada em bytes, mas as instruções lw e
sw acedem a uma word (4 bytes) de cada vez.
!
• Um ponteiro (usado em lw e sw) é só um endereço de
memórias. Podemos adicionar ou subtrair valores ao
endereço base (using offset).
!
• Novas instruções que vimos:
lw, sw

Para saber mais ...
• P&H - Capítulos 2.1, 2.2, 2.3 e 2.6
!
• P&H - Capítulo 2.9 páginas 95 e 96

- Instruções de Decisão -

Registos no MIPS (Revisão)
• Como os registos são construídos em hardware, existe um número pré-
determinado que não pode ser aumentado.
§ Solução: O código do MIPS tem que ser feito com cuidado de forma a usar
eficientemente os recursos disponíveis.
!
• O MIPS tem 32 registos de 32 bits cada (word). Os registos estão numerados
de 0 a 31
• Os registos tanto podem ser referenciados por um número como por um nome:
§ Referência por número :
$0, $1, $2, … $30, $31
§ Referência por nome :
Ä Semelhante às variáveis em C
$16 - $23 è $s0 - $s7
Ä Variáveis temporárias
$8 - $15 è $t0 - $t7

Operações Aritméticas no MIPS (Revisão)
• Sintáxe:
1 2, 3, 4
Onde :
2) operando que recebe o resultado (“destination”)
!
• Adição e subração em assembly
§ add $s0,$s1,$s2 # $s0=$s1+$s2
§ sub $s3,$s4,$s5 # $s3=$s4-$s5
§ addi $s0,$s1,10 # $s0=$s1+10
§ add $zero,$zero,$s0 # O que acontece?

Overflow Aritmético (1/2)
• Relembrar: O overflow acontece quando existe um erro
numa operação aritmética devido á precisão limitada dos
computadores (número fixo de bits por registo)
!
• Exemplo (números de 4-bits sem sinal):
+15 1111
+3 0011
+18 1 0010
§ Não há espaço para o 5º bit da soma, assim a solução seri 0010,
que é +2 em decimal, e portanto está errada.

Overflow Aritmético (2/2)
!
• Algumas linguagens detectam o overflow (Ada), enquanto
outras não (C)
!
• No MIPS existem 2 tipos de instruções:
§ add (add), add immediate (addi) e subtract (sub) em que o
overflow é detectado
§ add unsigned (addu), add immediate unsigned (addiu) e subtract
unsigned (subu) que não fazem detecção de overflow (no caso de
ocorrer é ignorado)
!
• O compilador utiliza a aritmética conveniente
§ O compilador de C para o MIPS utiliza 
addu, addiu, subu

Instruções “Lógicas”
!
• Shift Left: sll $s1,$s2,2 #s1=s2<<2
§ Guarda em $s1 o valor de $s2 deslocada 2 bits para a esquerda,
colocando 0’s nos bits da direita que ficam “livres”; (<< em C)
§ Antes: 00 00 00 02 hex 
0000 0000 0000 0000 0000 0000 0000 0010two
§ Depois: 00 00 00 08hex 
0000 0000 0000 0000 0000 0000 0000 1000two
§ QUIZ: Qual é o efeito aritmético do sll?
!
• Shift Right: srl é o deslocamento no sentido oposto; >>

• Os registos estão no "datapath" do processador.
!
• Se os operandos estiverem em memória, então:
Processor
Computer
Control
(“brain”)
Datapath
Registers
Memory Devices
Input
Output
Load (from)
Store (to)
Estas são as instruções para “data transfer” …
1. Os dados são
transferidos para os
registos,
2. a acção é realizada,
!
3. o resultado é colocado
de volta na memória.

Transferência de Dados (Revisão)
• Sintáxe das instruções Load/Store :
1 2, 3 (4)
Em que
2) registo que recebe/fornece o valor
3) deslocamento em bytes (offset)
4) registo contendo o endereço base (ponteiro) para a memória
!
• Instruções:
§ lw $t0,12($s0) #Escreve no registo $t0 a word
#que está no endereço de memória
#$s0+12
§ sw $t0,10($s0) #Escreve no endereço de memória
#$s0+10 o conteúdo de $t0

Notas sobre a memória (Revisão)
• Erro Frequente: Esquecermo-nos que os endereços de
words sucessivas numa máquina com “Byte Addressing”
diferem em mais do que 1.
§ Muitos programadores de assembly cometem erros por assumirem
que o endereço da próxima word pode ser obtido incrementando o
registo em 1 unidade em vez de adicionarem o número de bytes da
word (diferente do C).
§ Ao contrário do que acontece no C, em assembly não existe a
noção de tipo, e é impossível o computador saber o tamanho de
uma word fazendo o ajuste implícito do incremento dos ponteiros.
§ Lembre-se também que no lw e sw, a soma do endereço de base
com o offset deve ser sempre um múltiplo de 4 ( word aligned
memory )

Alinhamento de Memória (Revisão)
• No MIPS as words e objectos são guardados em memória
em bytes cujo endereço é sempre múltiplo de 4.
Alinhamento de Memória: os objectos começam sempre
em endereços que são múltiplos do seu tamanho
§ Lembram-se do “Bus Error”?
0 1 2 3
Aligned
Not
Aligned
0, 4, 8, or Chex
O Último digíto hexa
do endereço é:
1, 5, 9, or Dhex
2, 6, A, or Ehex
3, 7, B, or Fhex

Registos vs Memória (revisão)
• O que acontece se houver mais variáveis do que registos?
§ O compilador tenta manter as variáveis mais utilizadas nos registos
§ As variáveis menos usadas são armazenadas em memória: spilling
§ Consulte o comando register o C
!
• Porque não manter todas as variáveis em memória?
§ Smaller is faster: os registos são mais rápidos do que a memória
§ Os registos são mais versáteis:
Ä Cada instrução aritmética do MIPS pode ler 2 registos, fazer uma
operação sobre os dados, e escrever o resultado num registo
Ä Uma instrução de transferência de dados só pode ler ou escrever 1
operando.

Leitura e escrita de bytes (1/2)
• Para além da transferência de “words” (4 bytes usando lw
e sw), o MIPS permite também a transferência de bytes:
§ load byte: lb
§ store byte: sb
!
• O formato das instruções é semelhante ao lw, sw
E.g., lb $s0, 3($s1)
o byte de memória com endereço = “3” + “contéudo do
registo s1” é copiado para o byte menos significativo do
registo s0.

Leitura e escrita de bytes (2/2)
• O que é que acontece com os outros 24 bits do registo de
32 bits?
§ lb: estensão de sinal para preencher os 24 bits mais significativos
(relembrar que a representação em complementos de 2 assume
um número fixo de bits)
x
byte 
lido…é copiado (extensão de sinal)
Este bit
xxxx xxxx xxxx xxxx xxxx xxxx zzz zzzz
• No caso de leitura de “chars” nós não queremos que
haja extensão de sinal!
• Neste caso devemos usar a seguinte instrução
load byte unsigned: lbu

Concluindo
• A memória é endereçada em bytes, mas as instruções lw e
sw acedem a uma word (4 bytes) de cada vez.
• Um ponteiro (usado em lw e sw) é só um endereço de
memórias. Podemos adicionar ou subtrair valores ao
endereço base (using offset).
• Para carregar e armazenar bytes devemos utilizar as
instruções lb/sb (signed) e lbu/sbu (unsigned)
• As instruções addu/subu/addui não causam overflow
• Novas instruções que vimos:
lw, sw, sll, srl, addu, addiu, subu, lb, sb

QUIZ
Queremos traduzir a instrução *x = *y para assembly do MIPS
(x, y ptrs armazenados em: $s0 $s1)
!
A: add $s0, $s1, zero
B: add $s1, $s0, zero
C: lw $s0, 0($s1)
D: lw $s1, 0($s0)
E: lw $t0, 0($s1)
F: sw $t0, 0($s0)
G: lw $s0, 0($t0)
H: sw $s1, 0($t0)
0: A
1: B
2: C
3: D
4: E→F
5: E→G
6: F→E
7: F→H
8: H→G
9: G→H

O que vimos até agora ...
• As instruções que vimos até agora só manipulam informação (operações
aritméticas e transferência de dados) …
!
• Para construir um computador precisamos de tomar decisões e alterar a
sequência de execução durante o “runtime” … imagine como seria fazer um
programa se não existissem instruções “if”, “while”, “for”, etc!
!
• O C ( e o MIPS) permitem usar labels como suporte ao comando “goto”.
§ C: o uso de “breaks” e “goto” é deselegante e altamente desaconselhado;
§ MIPS: A utilização de “goto” é a única forma de modificar o fluxo sequencial
de execução!

Decisões em C: o comando if
• Existem 2 tipos de “if statements” em C
if (condition) clause
if (condition) clause1 else clause2
!
• Rearranje o 2º if da seguinte forma:
if (condition) goto L1; 
clause2; 
goto L2; 
L1: clause1;
L2:
!
• Não é tão elegante como if-else, mas faz mesma coisa

Instruções de decisão no MIPS
• Instrução de decisão no MIPS:
beq register1, register2, L1
beq significa “Branch if (registers are) equal”
A tradução em C seria:  
if (register1==register2) goto L1
!
• Instrução de decisão complementar
bne register1, register2, L1
bne significa “Branch if (registers are) NOT equal”
A tradução em C seria :  
if (register1!=register2) goto L1
!
• Estas instruções são os “conditional branches” (saltos

Instrução “goto” no MIPS
• Para além dos saltos condicionais, o MIPS tem ainda o
salto incondicional (unconditional branch):
j label
!
§ O salto na execução é feito directamente para o sítio referenciado
por “label” sem ser necessário satisfazer uma condição
!
• Equivalente em C a:  
goto label
!
• Tecnicamente tem o mesmo efeito que :
beq $0,$0,label

Compilação de um if em C (1/2)
• Compile à mão
if (i == j)
f=g+h;  
else
f=g-h;
!
• Assumindo o seguinte
mapeamento variável-registo: 
 
f: $s0 
g: $s1 
h: $s2 
i: $s3 
j: $s4
Exit
i == j?
f=g+h f=g-h
(false)  
i != j
(true)  
i == j

Compilação de um if em C (2/2)
•Compile à mão
if (i == j)
f=g+h;  
else
f=g-h;
!
!
• Código em assembly para MIPS:
beq $s3,$s4,True # branch i==j 
sub $s0,$s1,$s2 # f=g-h(false) 
j Fim # goto Fim 
True: add $s0,$s1,$s2 # f=g+h (true) 
Fin:
!
Nota: O compilador cria automaticamente labels quando aparecem instruções de
decisão (branches). 
Exit
i == j?
f=g+h f=g-h
(false)  
i != j
(true)  
i == j

Ciclos (Loops) em C/Assembly (1/3)
• Ciclo simples em C; A[] é um array de ints
do {
g = g + A[i];
i = i + j;}
while (i != h);
• Re-esrevendo de uma forma deselegante:
Loop: g = g + A[i]; 
i = i + j; 
if (i != h)
goto Loop;
• Assumindo agora o seguinte mapeamento variável-registo: 
g, h, i, j, base of A 
$s1, $s2, $s3, $s4, $s5

Ciclos (Loops) em C/Assembly (2/3)
!
• Código compilado para MIPS:
Loop: sll $t1,$s3,2 #$t1= 4*i 
add $t1,$t1,$s5 #$t1=addr A 
lw $t1,0($t1) #$t1=A[i] 
add $s1,$s1,$t1 #g=g+A[i] 
add $s3,$s3,$s4 #i=i+j 
bne $s3,$s2,Loop # goto Loop 
# if i!=h
• Código original (guia):
Loop: g = g + A[i]; 
i = i + j; 
if (i != h) goto Loop;

Ciclos/Loops em C/Assembly (3/3)
• Existem 3 tipos diferentes de ciclos em C:
§ while
§ do… while
§ For
!
• Cada um destes ciclos pode ser re-escrito usando um dos
outros dois. Assim o método utilizado para o do… while
pode ser também usado para implementar o while e for.
!
• Ideia Chave: Apesar de existirem diferentes formas de
construir um ciclo em MIPS, todos eles passam por tomar
uma decisão com um conditional branch

Desigualdades no MIPS (1/4)
• Até agora só trabalhámos com igualdades  
(== e != no C). No entanto um programa também trabalha
com desigualdades (< e > no C).
!
• Instruções de desigualdade no MIPS :
§ “Set on Less Than”
§ Sintaxe: slt reg1,reg2,reg3
§ Significado:
if (reg2 < reg3)  
reg1 = 1;  
else
reg1 = 0;
“set” significa “set to 1”,

• Compile “à mão” o seguinte código
if (g < h) goto Less; # assuma g:$s0, h:$s1
!
• O resultado em assembly para o MIPS é …
slt $t0,$s0,$s1 # $t0 = 1 if g<h  
bne $t0,$0,Less # goto Less 
# if $t0!=0 
# (if (g<h)) Less:
!
• O registo $0 contém sempre o valor 0, e por isso é frequentemente utilizado
com bne e beq depois de uma instrução slt.
!
• O par de instruções slt è bne significa if(… < …)goto…

• Com o slt podemos implementar “<” ! Mas como será
que podemos implementar o >, ≤ e ≥ ?
!
• Poderiam haver mais 3 instruções similares, mas:
§ Filosofia do MIPS: Simpler is Better, Smaller is faster
!
• Será que podemos implementar o ≥ usando unicamente o
slt e “branches”?
!
• E quanto ao >?
!
• E ao ≤?

# a:$s0, b:$s1  
slt $t0,$s0,$s1 # $t0 = 1 if a<b  
beq $t0,$0,skip # skip if a >= b 
<stuff> # do if a<b
skip:
!
Existem sempre duas variações:
Usar slt $t0,$s1,$s0 em vez de slt $t0,$s0,$s1
!
Usar bne em vez de beq

Desigualdades e Imediatos
• Existe também uma versão do slt para trabalhar com
argumentos imediatos (constantes) : slti
§ Ùtil em ciclos for
if (g >= 1) goto Loop
Loop: . . . 
 
slti $t0,$s0,1 # $t0 = 1 if 
# $s0<1 (g<1) 
beq $t0,$0,Loop # goto Loop 
# if $t0==0 
# (if (g>=1)
C
M 
I 
P 
S
O par slt è beq signiﬁca em C if(… ≥ …)goto…

E quanto aos números sem sinal?
• Existem também uma instrução de desigualdade para
trabalhar com números sem sinal (unsigned) :
sltu, sltiu
…que coloca o registo de output a 1 (set) ou 0 (reset) em
função de uma comparação sem sinal
!
• Qual é o valor de $t0 e $t1?
($s0 = FFFF FFFAhex, $s1 = 0000 FFFAhex)
slt $t0, $s0, $s1
sltu $t1, $s0, $s1

Signed/Unsigned tem diferentes significados!
• Os termos Signed/Unsigned estão “sobre
utilizados”. É preciso ter cuidado com os seus
múltiplos significados
!
§ Faz / Não faz extensão de sinal  
(lb, lbu)
!
§ Não detecta overflow
(addu, addiu, subu, multu, divu)
!
§ Faz comparação com/sem sinal
(slt, slti/sltu, sltiu)

Exemplo: O Switch do C (1/3)
• Escolha entre quatro alternativas diferentes em função de k ter os
valores 0, 1, 2 ou 3. Compile “à mão” o seguinte código em C: 
 
switch (k) { 
case 0: f=i+j; break; /* k=0 */ 
case 1: f=g+h; break; /* k=1 */ 
case 2: f=g–h; break; /* k=2 */ 
case 3: f=i–j; break; /* k=3 */ 
}

Exemplo: O Switch do C (2/3)
• Isto é um ciclo complicado, portanto o primeiro passo é
simplificar.
!
• Escreva o ciclo como uma cadeia de declarações if-else,
as quais já sabemos compilar:
if(k==0) f=i+j;  
else if(k==1) f=g+h;  
else if(k==2) f=g–h; 
else if(k==3) f=i–j;
!
• Assumindo o seguinte mapeamento:
f:$s0, g:$s1, h:$s2, 
i:$s3, j:$s4, k:$s5

Exemplo: O switch do C (3/3)
• O código compilado é: 
 
bne $s5,$0,L1 # branch k!=0 
add $s0,$s3,$s4 #k==0 so f=i+j 
j Exit # end of case so Exit 
L1: addi $t0,$s5,-1 # $t0=k-1 
bne $t0,$0,L2 # branch k!=1 
add $s0,$s1,$s2 #k==1 so f=g+h 
L2: addi $t0,$s5,-2 # $t0=k-2 
bne $t0,$0,L3 # branch k!=2 
sub $s0,$s1,$s2 #k==2 so f=g-h 
L3: addi $t0,$s5,-3 # $t0=k-3 
bne $t0,$0,Exit # branch k!=3 
sub $s0,$s3,$s4 #k==3 so f=i-j  
Exit:

QUIZ
Indique o que deveria estar na zona com os pontos de interrogação!
do {i--;} while(???);
Loop:addi $s0,$s0,-1 # i = i - 1 
slti $t0,$s1,2 # $t0 =(j < 2) 
beq $t0,$0 ,Loop # goto Loop if $t0 == 0
slt $t0,$s1,$s0 # $t0 =(j < i) 
bne $t0,$0 ,Loop # goto Loop if $t0 != 0
0: j < 2 && j < i 
1: j ≥ 2 && j < i 
2: j < 2 && j ≥ i 
3: j ≥ 2 && j ≥ i 
4: j > 2 && j < i 
5: j < 2 || j < i 
6: j ≥ 2 || j < i 
7: j < 2 || j ≥ i 
8: j ≥ 2 || j ≥ i 
9: j > 2 || j < i
($s0=i, $s1=j)

Concluindo
• Os branches permitem tomar a decisão do que vai ser executado em
“runtime” em vez de “compile time”.
!
• As decisões em C são feitas usando conditional statements como o
if, while, do while, for.
!
• As decisões em MIPS são feitas usando conditional branches: beq e
bne.
!
• Para complementar os conditional branches em decisões que
involvam desigualdades, vimos as instruções “Set on Less Than”: slt,
slti, sltu, sltiu
!
• Novas instruções que vimos: 
beq, bne, j, slt, slti, sltu, sltiu

Notas para mim
• Explicar pseudo-instruções (e.g. Move, branches)
• Explicar Operandos imediatos de 32 bits (instruções la e li)
• Explicar syscall
• Explicar trap e EPC

Para saber mais ...
• P&H - Capítulos 2.1, 2.2, 2.3, 2.5 e 2.6
!
• P&H - Capítulo 3.3
!
!
• Resolver a ficha de trabalho

- Funções e Procedimentos -

Revisão
• Os branches permitem tomar a decisão do que vai ser executado em
“runtime” em vez de “compile time”.
!
• As decisões em C são feitas usando conditional statements como o
if, while, do while, for.
!
• As decisões em MIPS são feitas usando conditional branches: beq e
bne.
!
• Para complementar os conditional branches em decisões que
involvam desigualdades, vimos as instruções “Set on Less Than”: slt,
slti, sltu, sltiu
!
• Novas instruções que vimos: 
beq, bne, j, slt, slti, sltu, sltiu

Funções em C
main() { 
int i,j,k,m; 
... 
i = mult(j,k); ...  
m = mult(i,i); ...
}
/* forma burra de implementar mult */
int mult (int mcand, int mlier){ 
int product;
product = 0; 
while (mlier > 0) { 
product = product + mcand; 
mlier = mlier -1; } 
return product;
}
Numa chamada a
função que
informação é que o
compilador/
programador
precisa de registar ?
!
Que instruções
permitem fazer isto?

Chamada de funções - Bookkeeping
• No MIPS os registos são fundamentais para
guardar a informação necessária à chamada de
funções.
!
• Convenção de utilização de registos:
§ Endereço de retorno. $ra
§ Argumentos / Parâmetros: $a0, $a1, $a2, $a3
§ Retorno de valores: $v0, $v1
§ Variáveis locais: $s0, $s1, … , $s7
!
• Veremos mais tarde que a stack também é utilizada.

Instruções de suporte a funções (1/6)
... sum(a,b);... /* a,b:$s0,$s1 */ 
} 
int sum(int x, int y) { 
return x+y; 
}
address 
1000  
1004  
1008  
1012  
1016
2000  
2004
C
M 
I 
P 
S
No MIPS todas as instruções
têm 4 bytes e são armazenadas
em memória de forma
semelhante aos dados. Estes
são os endereços onde o
programa está armazenado.

... sum(a,b);... /* a,b:$s0,$s1 */ 
} 
return x+y; 
}
address 
1000 add $a0,$s0,$zero # x = a 
1004 add $a1,$s1,$zero # y = b  
1008 addi $ra,$zero,1016 #$ra=1016 
1012 j sum #jump to sum 
1016 ...
2000 sum: add $v0,$a0,$a1 
2004 jr $ra # nova instrução - salta
C
M 
I 
P 
S

... sum(a,b);... /* a,b:$s0,$s1 */ 
} 
return x+y; 
}
!
§ Pergunta: Porquê utilizar jr? Porque não j?
§ Resposta: A função sum pode ser chamada de muitos sítios
diferentes. Assim, não podemos regressar para um endereço fizo
pré-definido. É preciso disponibilizar um mecanismo para dizer
“regressa aqui” !
2000 sum: add $v0,$a0,$a1 
2004 jr $ra # new instruction
C
M 
I 
P 
S

• Instrução para simultaneament saltar e fazer a salvaguarda do
endereço de retorno: jump and link (jal)
!
• Sem jal: 
1008 addi $ra,$zero,1016 #$ra=1016 
1012 j sum #goto sum
!
• Com jal: 
1008 jal sum # $ra=1012,goto sum
!
• Será que jal é imprescíndivel?
§ “Make the common case fast”: a chamada a funções é uma
operação muito ferquente.
§ Para além disso com jal o programador não precisa de saber
onde é que o código vai ser carregado.

• A sintáxe do jal (jump and link) é semelhante à do j
(jump):
jal label
!
• Na verdade o jal deveria ser chamado laj (link and
jump):
§ Passo 1 (link) - Guarda o endereço da próxima instrução em $ra
§ Passo 2(jump) - Salta para a instrução assinalada por label
!
• Porque é que é guardado o endereço da instrução
seguinte em vez da instrução corrente?

Instrução de Suporte a Funções (6/6)
• Sintáxe do jr (jump register):
!
jr register
!
• Em vez de darmos um “label” ao jump, passamos um
registo que contém o endereço para onde queremos saltar.
!
• Estas duas instruções são muito úteis para chamada de
funções:
§ jal guarda o endereço de retorno no registo ($ra)
§ jr $ra salta de volta para o sítio onde a função foi chamada (se
entretanto não alterarmos o conteúdo do registo)

Nested Procedures (1/2)
int sumSquare(int x, int y) { 
return mult(x,x)+ y; 
}
!
• Alguém chamou sumSquare, e agora sumSquare está a
chamar mult.
!
• Assim o endereço que está $ra é o sítio para onde
sumSquare vai ter que regressar. No entanto o registo vai
ser escrito pela chamada a mult.
!
• Vamos ter que guardar o endereço de retorno de
sumSquare antes de fazer a chamada a mult.

Nested Procedures (2/2)
• Iremos ver para a frente que normalmente precisamos de guardar
outras informações para além do contéudo de $ra.
!
• Onde será que podemos guardar essa informação?
!
• Quando um programa em C está a correr existem 3 zonas diferentes
de memória:
§ Static: Variáveis declaradas uma única vez no inicio do programa. Esta
zona só é desalocada quando o programa termina.
§ Heap: Variáveis declaradas de forma dinâmica
§ Stack: Espaço para ser utilizado pelas funções/procedmentos durante a
execução. Este é a zona onde fazemos a salvaguarda de contexto!

Revisão da alocação de memória em C
0
∞Address
Code Programa
Static Variáveis Globais
Heap
Espaço criado explicitamente,  
e.g., malloc(); ponteiros do C
Stack
Espaço para guardar
informação dos
procedimentos$sp
stack
pointer

Utilização da Pilha (1/2)
• O registo $sp contém sempre o endereço da última zona
de memória que está a ser ocupada pela stack (topo da
pilha ... ou melhor fundo da pilha!).
!
• Para utilizar a pilha, devemos decrementar o ponteiro $sp
pelo número de bytes que vamos precisar para guardar a
informação.
!
• Como é que devemos então compilar o programa?
int sumSquare(int x, int y) { 
return mult(x,x)+ y; 
}

SMP/AC 2013/14

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a SMP/AC 2013/14

Semelhante a SMP/AC 2013/14 (8)

SMP/AC 2013/14