Selecção de Instruções

(1)

1 1 Compilação – 2003/04 Compilação – 2003/04 T12T12

Selecção de Instruções

(2)

Resumo

●

Objectivo:

– A partir da IR,A partir da IR,

– Gerar código para uma arquitectura concretaGerar código para uma arquitectura concreta

● máquinas CISCmáquinas CISC

● máquinas load/store (RISC)máquinas load/store (RISC)

– Ainda não resolver Ainda não resolver todotodo o problema o problema

● omitir alocação de registosomitir alocação de registos

● deixar as optimizações de foradeixar as optimizações de fora

●

Meios:

(3)

Padrões

●

Ideia

– emparelhar os padrões correspondentes às instruções emparelhar os padrões correspondentes às instruções

da máquina com os que ocorrem na IR.

●

Requisito

– especificação detalhada da arquitectura objectoespecificação detalhada da arquitectura objecto

● registos (temporários)registos (temporários) ● organização de memóriaorganização de memória ● instruçõesinstruções

(4)

4 4 Compilação – 2003/04

Compilação – 2003/04 T12T12

A Arquitectura

Jouette

●

Baseada em arquitecturas reais

– load/store (ala RISC)load/store (ala RISC)

● movimentos entre registos e memóriamovimentos entre registos e memória ● operações só sobre registosoperações só sobre registos

– muitos registosmuitos registos

– um só tipo de dadosum só tipo de dados

(5)

Instruções

Nome

Nome SemânticaSemântica PadrõesPadrões

- Ri temp(_)

ADD Ri = Rj + Rk _+_ MUL Ri = Rj * Rk _*_ SUB Ri = Rj – Rk _-_ DIV Ri = Rj / Rk _/_

ADDI Ri = Rj + a _+const(_) const(_)+_ SUBI Ri = Rj – a _-const(_)

LOAD Ri = M[Rj + c] mem(_+const(_)) mem(const(_)+_) mem(const(_)) STORE M[Rj + c] = Ri move(mem(_,const(_)), _) etc.

(6)

Exemplo

●

Um mesmo padrão IR pode ser “preenchido” com

diversas sequências de código:

move mem mem + + temp(fp) const(x) mem _* temp(i) const(4) + temp(fp) const(a) load R1 = M[fp + a] addi R2 = R0 + 4 mul R2 = R1 * R2 add R1 = R1 + R2 load R2 = M[fp + x] store M[R1 + 0] = R2

(7)

Exemplo

●

Outra sequência com a mesma semântica:

move mem mem + + temp(fp) const(x) mem _* temp(i) const(4) + temp(fp) const(a) load R1 = M[fp + a] addi R2 = R0 + 4 mul R2 = R1 * R2 add R1 = R1 + R2 addi R2 = fp + x movem M[R1] = M[R2]

(8)

Mural: “tiling”

●

Um “mural” (o “quadro” feito pela árvore IR) pode

ser “preenchido” com “azulejos”

– o “azulejo” é a instrução, na sua representação de o “azulejo” é a instrução, na sua representação de

fragmento de IR

– o objectivo é cobrir integralmente o programa (ie. o o objectivo é cobrir integralmente o programa (ie. o

“mural”)

●

Casos particulares

(9)

Tilings optimos e optimais

●

Associar um

custo

a cada instrução

●

optimo

– um tiling com custo mínimoum tiling com custo mínimo

●

optimal

– um tiling com custo que não pode ser minorado um tiling com custo que não pode ser minorado

juntando dois azulejos num maior

●

modelo simplista

– custo duma instrução depende do contexto (p/ex custo duma instrução depende do contexto (p/ex

pipelining)

(10)

10 10 Compilação – 2003/04

Algoritmos de Selecção de Instruções

●

“

Maximal munch”

– mais simplesmais simples – top-downtop-down

– para cada sub-árvore IR ainda não coberta:para cada sub-árvore IR ainda não coberta:

● encontrar a instrução que “engole” (daí o nome) o maior encontrar a instrução que “engole” (daí o nome) o maior

número de nós IR

● marcar as suas sub-árvores ainda não cobertas para a marcar as suas sub-árvores ainda não cobertas para a

próxima passagem

– deve garantir cobertura de todos os nós elementares deve garantir cobertura de todos os nós elementares

da IR com

da IR com algumalgum padrão de instrução, para evitar o padrão de instrução, para evitar o fracasso do processo.

(11)

11 11 Compilação – 2003/04

Algoritmos de Selecção de Instruções

●

Programação Dinâmica

– mais complexamais complexa – bottom-upbottom-up

– cálculo com base em cálculo com base em custoscustos de sub-árvores de sub-árvores

– é escolhido o “tiling” que oferece o é escolhido o “tiling” que oferece o menormenor custo total, custo total,

dado por:

● custo do nócusto do nó

(12)

12 12 Compilação – 2003/04

Algoritmos de Selecção de

Instruções

●

Gramáticas de Árvores

– Especificam padrões de árvore e as instruções Especificam padrões de árvore e as instruções

associadas

– Diversos tipos de gramática dão diversos tipos de Diversos tipos de gramática dão diversos tipos de

algoritmo:

● bottom-up (ala LR)bottom-up (ala LR)

● top-down (ala LL, DCG)top-down (ala LL, DCG)

– Algoritmos podem ser não-determinísticosAlgoritmos podem ser não-determinísticos

● aumenta expressividadeaumenta expressividade ● permite combinarpermite combinar

– estrutura da árvore_{estrutura da árvore} – condições arbitrárias_{condições arbitrárias}

(13)

13 13 Compilação – 2003/04

Máquinas “reais” CISC e RISC

●

Máquinas RISC típicas

– ““muitos” registos (32 ou múltiplos)muitos” registos (32 ou múltiplos)

– registos indiferenciados (inteiros/endereços)registos indiferenciados (inteiros/endereços) – operações com 3 operandos (Rd = Rs OP Rt)operações com 3 operandos (Rd = Rs OP Rt) – instruções load/store com M[R+const]instruções load/store com M[R+const]

– instruções de tamanho fixoinstruções de tamanho fixo

– um só resultado/efeito por instruçãoum só resultado/efeito por instrução

(14)

14 14 Compilação – 2003/04

Máquinas “reais” CISC e RISC

●

Máquinas CISC...

– ““poucos” registos (entre 5/6 e 8 ou 16 no máximo)poucos” registos (entre 5/6 e 8 ou 16 no máximo) – registos classificados, com usos particulares ou registos classificados, com usos particulares ou

implícitos

– operações que podem aceder à memória, geralmente operações que podem aceder à memória, geralmente

com muitos “modos de endereçamento”

– operações com 2 operandos (operações com 2 operandos (RdRd = = RdRd OP Rs) OP Rs) – instruções de tamanho variávelinstruções de tamanho variável

– instruções com efeitos secundários (p/ex modos “auto-instruções com efeitos secundários (p/ex modos

“auto-incremento”)

incremento”)

(15)

15 15 Compilação – 2003/04

Geração de Código para CISC (1)

●

Poucos registos

– continuar como anteriormente e assumir que o continuar como anteriormente e assumir que o

alocador de registos irá funcionar “bem”

●

Classes de registos (especializadas)

– decompor as operações “genéricas” em múltiplas, decompor as operações “genéricas” em múltiplas,

assumindo que o alocador de registos irá suprimir

movimentos evitáveis

●

Operações com 2 operandos:

(16)

16 16 Compilação – 2003/04

Geração de Código para CISC (2)

●

Operações com operandos em memória

– pouco pertinentepouco pertinente

– código que movimenta entre a memória e os registos, código que movimenta entre a memória e os registos,

opera sobre os registos e volta a movimentar não é

mais lento que código que opera sobre a memória,

embora possa ser mais comprido.

●

Modos de endereçamento

– como anteriormentecomo anteriormente

(17)

17 17 Compilação – 2003/04

Geração de Código para CISC (3)

●

Operações com efeitos secundários

– difíceis de enquadrar na árvore de IRdifíceis de enquadrar na árvore de IR – várias abordagens possíveis:várias abordagens possíveis:

● ignorar a sua existência (não gerar esse código!)ignorar a sua existência (não gerar esse código!) ● ““apanhar” casos particularesapanhar” casos particulares

● usar um modelo de selecção de instruções diferente, p/ex um usar um modelo de selecção de instruções diferente, p/ex um

baseado em padrões dum DAG de IR em vez duma árvore

de IR