Situação. Geração de Código. Renato Ferreira. Encerramos a parte de Front- End. Back- End. Análise Léxica Análise SintáFca Análise SemânFca

Transcrição

1 Geração de Código Renato Ferreira Situação Encerramos a parte de Front- End Análise Léxica Análise SintáFca Análise SemânFca Back- End OFmização Geração de Código 1

2 Ambiente de Execução Antes de discufr a geração em si, precisamos relembrar certos conceitos Várias estratégias padrão que são uflizadas nas estruturas dos códigos executáveis Começaram do Assembly Ouvimos falar quando estudamos algoritmos Sumário Gerencia de recursos em tempo de execução Correspondência entre Estruturas estáfcas (tempo de compilação) Estruturas dinâmicas (tempo de execução) Organização da memória 2

3 Gerência Recursos A execução de um programa começa com o auxílio do Sistema Operacional Na invocação O SO aloca espaço para o programa O código é carregado do disco nesse espaço O SO faz o goto para o entry- point (main) ObjeFvos para Geração de Código Dois objefvos Correção Eficiência A complicação vem da combinação dos dois! 3

4 Premissas sobre a execução 1. Execução Sequencial o controle passa de um ponto para outro de maneira bem definida 2. Procedimentos aninhados Quando um procedimento é chamado, eventualmente o controle retorna para o ponto logo após a chamada Não é verdade sempre! AFvação Uma invocação (chamada) de um procedimento P corresponde a uma afvação de P A vida de uma afvação é Todos os passos da execução de P Incluíndo os procedimentos invocados por P 4

5 Vida de Variáveis A vida de uma variável x é a porção da execução entre o primeiro momento onde algo é atribuído para a variável e o úlfmo momento que o valor da variável foi lido Observe que Vida é um conceito dinâmico Escopo é um conceito estáfco Árvores de AFvação A premissa (2) garante que se P chama Q, então Q retorna antes de P. Ou seja, o aninhamento das vidas das afvações são perfeitamente aninhadas As afvações podem ser representadas por árvores de afvação! 5

6 Class Main { g(): Int {1}; } f(): Int {g()}; Exemplo main(): Int {g(); f(); }; Class Main { g(): Int{1}; } Exemplo 2 f(x:int): Int { if x = 0 then g() else f(x- 1) fi}; main(): Int {f(3)}; 6

7 Observações A árvore de afvações depende do comportamento da execução A árvore de afvação pode ser diferente para cada entrada Como é perfeitamente aninhada, uma pilha pode ser uflizada para acompanhar as afvações afvas ;- ) Class Main { g(): Int {1}; } f(): Int [g()}; Exemplo main(): Int {{g(); f(); }}; 7

8 Registro de AFvação Informação necessária para gerenciar a afvação de um procedimento também chamado de frame (quadro, moldura) Se o procedimento F chama G, então no registro de afvação de G tem alguma informação de F e de G Conteúdo do Registro de AFvação Quando F chama G, F fica suspenso até que G seja completada. Contém informação suficiente para confnuar a execução de F. Pode conter: Endereço de retorno de G (algum ponto em F) Parâmetros (valor de retorno) Espaço para variáveis locais de G 8

9 Exemplo Torre de Hanoi Qual é o Ponto O compilador precisa determinar, em tempo de compilacão, como serão os registros de afvação, e gerar código que acesse e mantenha corretamente esses registros. O Registro de AFvação e o Gerador de Código precisam ser projetados em conjunto! 9

10 Discussão A vantagem de se colocar o valor de retorno no topo do registro de afvação é que ele pode ser encontrado a parfr de um offset fixo em relação ao frame do procedimento chamador É preciso enxergar a Matrix!!! Compiladores reais uflizam registradores valor de retorno parâmetros *** Variáveis Globais / Constantes Todas as referências a variáveis globais apontam para o mesmo objeto Não pode ser representado em registro de afvação Variáveis globais recebem endereços fixos na memória variáveis estáfcas, ou estafcamente alocadas. recursos de linguagens 10

11 Alocação Dinâmica Existem valores que precisam sobreviver a afvação de procedimentos que os criam: method foo() { new Bar } objeto Bar vive depois que foo retornar! Linguagens que permitem alocação dinâmica usam um heap para armazenamento dinâmico Organização Global Área de código contém código objeto Fpicamente fixa, e read- only Área estáfca contém dados tamanho fixo, read/write Pilha registros de afvação Heap O resto! Código Área EstáFca Heap Pilha 11

12 SinteFzando Existem informações estáfcas e dinâmicas EstáFcas manfdas pelo compilador em tempo de compilação Dinâmicas são manfdas pelo executável, produzidas pelo compilador para realizarem sua tarefa em tempo de execução Não é só gerar código! Tem que construir as estruturas de dados e de execução, e mantê- las Além do código em si. Organização dos dados Aspectos da máquina alvo precisam ser considerados para garanfr os objefvos do código gerado. Direção em que a pilha cresce Alinhamento (uma preocupação grande) 12

13 Alinhamento Maioria das máquinas modernas são de 32 ou 64 bits 8 bits no byte palavras de 4 ou 8 bytes A máquina pode endereçar byte, ou palavra Dado é dito alinhado se ele começa no limite de uma palavra A maioria das máquinas tem restrições quanto ao alinhamento Pelo menos um impacto significafvo no desempenho Máquinas de Pilha O modelo de avaliação simples Não existem variáveis ou registradores Todos os resultados são armazenados na pilha Cada instrução: pega os operandos do topo da pilha Remove esses operandos da pilha Calcula o resultado da operação Coloca esse resultado na pilha 13

14 Um exemplo de máquina de pilha Considere duas instruções push i Coloca o inteiro i no topo da pilha add refra dois elementos do topo da pilha, soma, e guarda o resultado na pilha O programa que calcula push 7 push 5 add Pra que máquinas de pilha? Cada operação pega seus operandos e coloca o resultado no mesmo lugar Esquema uniforme de compilação Portanto, compilador mais simples 14

15 Mais mofvos A localização dos operandos é implícita sempre o topo da pilha Não há necessidade de codificar os operandos explicitamente Não há necessidade de codificar a localização do resultado Instrução add ao invés de add r 1, r 2, r 3 codificação mais simples programas mais compactos Java bytecode usa um modelo de avaliação de pilha OFmizando uma máquina de pilha Um add realiza 3 operações na memória 2 reads e 1 write O topo da pilha é frequentemente acessado Idéia brilhante: manter o topo da pilha em registrador (acumulador) Acesso a registradores é bem mais eficiente O add passa a ser: acc = acc + topo_da_pilha Apenas 1 acesso à memória 15

16 Máquina de pilha com acumulador Invariantes O resultado de uma expressão está no acumulador Para uma operação op(e 1, e 2,, e n ) avaliar as expressões e 1 a e n cada resultado vai sendo empilhada até e n- 1 Então avalia- se op A avaliação de cada expressão preserva a pilha Um exemplo: 3 + (7 + 5) Código Acumulador Pilha acc 3 3 <anterior> push acc 3 3, <anterior> acc 7 7 3, <anterior> push acc 7 7, 3, <anterior> acc 5 5 7, 3, <anterior> acc acc + topo_da_pilha 12 7, 3, <anterior> pop 12 3, <anterior> acc acc + topo_da_pilha 15 3, <anterior> pop 15 <anterior> É importante preservar a pilha! 16

17 Básico de Geração de Código O Assembly do MIPS Uma linguagem fonte simples Uma implementacão da linguagem simples e uma máquina de pilha The máquinas de pilha para o MIPS O compilador gera código para uma máquina de pilha com acumulador Queremos o código gerado para o processador MIPS Simule a máquina de pilha uflizando instruções e registradores do MIPS 17

18 Simulando a Máquina de Pilha O acumulador é manfdo no registrador $a0 A pilha é manfda na memória cresce para os endereços menores convenção padrão na arquiteturas MIPS O endereço da próxima localização da pilha é manfda no registrador $sp o topo da pilha fica no endereço $sp + 4 Assembly do MIPS Arquitetura Arquitetura RISC Operações aritméfcas uflizam registradores para operandos e resultados ufliza loads e stores para acesso à memória 32 registradores de propósito geral de 32 bits Vamos usar: $a0, $sp e $t1 (temporário) Leia a documentação do SPIM para maiores detalhes 18

19 Algumas instruções MIPS lw reg 1 offset(reg 2 ) Carrega uma palavra de 32 bits do endereço reg 2 + offset em reg 1 add reg 1 reg 2 reg 3 reg 1 ß reg 2 + reg 3 sw reg 1 offset(reg 2 ) Armazena o valor de reg 1 no endereço reg 2 + offset addiu reg1 reg2 imm reg1 ß reg2 + imm u significa unsigned (não verifica bit de overflow) li reg imm reg ß imm Exemplo: máquina de pilha assembly mips acc ß 7 li $a0 7 push acc sw $a0 0($sp) addiu $sp $sp - 4 acc ß 5 li $a0 5 acc ß acc + topo_da_pilha lw $t1 4($sp) add $a0 $a0 $t1 pop addiu $sp $sp 4 19

20 Generalizando Uma linguagem mais simples de inteiros e operações com inteiros: P à D; P D D à def id(args) = E ARGS à id, ARGS id E à int id if E 1 = E 2 then E 3 else E 4 E 1 + E 2 E 1 E 2 id(e 1,, E n ) Nossa pequena linguagem A primeira função definida, f, é a função main executar o programa para a entrada i significa calcular f(i) Um programa para calcular números de Fibonacci def fib(x) = if x = 1 then 0 else if x = 2 then 1 else fib(x- 1)+fib(x- 2) 20

21 Estratégia de geração de código Para cada expressão e, gerar código MIPS tal que: calcule o valor de e em $a0 preserve $sp e o conteúdo da pilha Vamos definir a função de geração de código cgen(e), cujo resultado será o código gerado para e Geração de Código para Constantes Para avaliar constantes, simplesmente copie o valor constante para o acumulador: cgen(i) = li $a0 i Isso preserva a pilha Esquema de cores: Vermelho: tempo de compilação Azul: tempo de execução 21

22 Geração de código para Add cgen(e1 + e2) = cgen(e1) sw $a0 0($sp) addiu $sp $sp - 4 cgen(e2) lw $t1 4($sp) add $a0 $t1 $a0 addiu $sp $sp 4 Observações O código do add é um template com buracos para a avalição das duas expressões A geração de código para a máquina de pilha é recursiva código para e 1 + e 2 é o código de e 1 e o código de e 2 montado Geração de código pode ser realizada como uma varredura recursiva na AST pelo menos para expressões! 22

23 Geração de código para Sub Nova instrução: sub reg 1 reg 2 reg 3 cgen(e1 - e2) = cgen(e1) sw $a0 0($sp) addiu $sp $sp - 4 cgen(e2) lw $t1 4($sp) sub $a0 $t1 $a0 addiu $sp $sp 4 Geração de código para condicionais Precisamos de instruções para controle de fluxo Nova instrução: beq reg 1 reg 2 label desvia para label se reg 1 = reg 2 Nova instrução: b label goto label 23

24 Geração de código para if cgen(if e1 = e2 then e 3 else e 4 ) = cgen(e1) sw $a0 0($sp) addiu $sp $sp - 4 cgen(e2) lw $t1 4($sp) addiu $sp $sp 4 beq $a0 $t1 true_branch false_branch: cgen(e4) b end_if true_branch: cgen(e3) end_if: Código para Procedimentos É preciso gerar código para o procedimento e para a chamada do procedimento Manutenção do registro de afvação Para a linguagem proposta, um RA simples é suficiente O resultado da função está no registrador Parâmetros no RA Para f(x 1,..., x n ) empilha x n,..., x 1 São as única variáveis da linguagem 24

25 O Registro de AFvação A funcionalidade em pilha garante que o $sp será o mesmo após a chamada da função Falta apenas o endereço de retorno Um apontador para o RA corrente é úfl UFliza registrador $fp Necessidade se tornará aparente Sumarizando Para a linguagem proposta: Apontador para o RA corrente Parâmetros reais Endereço de retorno é o suficiente f(x, y) sp retorno x y fp anfgo fp Registro de AFvação de f pilha 25

26 Geração de Código A sequencia de chamada são as instruções que organizam a invocação de uma função/ procedimento Uma nova instrução: jal label Goto para label, armazenando o endereço chamado no registrador $ra Na maioria das arquiteturas o endereço de retorno é armazenado diretamente na pilha pela instrução CALL Geração de código para a chamada cgen(f(e 1,..., e n )) = sw $fp 0($sp) addiu $sp $sp - 4 cgen(e n ) sw $a0 0($sp) addiu $sp $sp cgen(e 1 ) sw $a0 0($sp) addiu $sp $sp - 4 jal f_entry O chamador salva o valor do $fp anfgo Então empilha os parâmetros na ordem inversa E então realiza a chamada, salvando o endereço de retorno no registrador $ra Nesse momento o controle é transferido para a função sendo invocada 26

27 Geração de código para a definição cgen(def f(x1,..., xn) = e) = move $fp, $sp sw $ra 0($sp) addiu $sp $sp - 4 cgen(e) lw $ra 4($sp) addiu $sp $sp z lw $fp 0($sp) jr $ra Nova instrução jr reg goto para o endereço no registrador reg frame pointer está no fundo da pilha o procedimento, além de empilhar o endereço de retorno, precisa desempilhar os parâmetros e o RA ao final Manter o tamanho do RA em z nesse exemplo z = 4*n+8 Geração de código para variáveis ÚlFmo construtor da linguagem As variáveis são os parâmetros das funções Estão todas no AR Empilhadas pelo chamador Problema: Como a pilha cresce com temporários, as variáveis não estão a uma distância constante de $sp Solução: para isso serve o $fp cgen(x i ) = lw $a0 z($fp) (z = 4*i) 27

28 Sumarizando O Registro de AFvação deve ser projetado junto com o gerador de código A geração de código é um caminhamento recursivo na AST Recomenda- se uma máquina de pilha para o seu compilador COOL (simples) Sumarizando Um compilador de verdade faz coisas um pouco diferentes Ênfase em manter os valores em registradores (especialmente o frame atual) Valores intermediários são organizados no RA, e não simplesmente empilhados e desempilhados 28

29 Geração de Código para Objetos Linguagens orientadas a objetos se tornaram comuns Implementação delas acrescenta detalhes Aspecto fundamental: mecanismos de herança: Se uma classe B é subclasse de A, então qualquer método de A pode ser invocado para um objeto da classe B Ou seja, o código gerado para a classe A tem que rodar normalmente para objetos da classe B Dois aspectos Como representar os objetos na memória Como realizar a invocação dos métodos Dinâmica 29

30 Código Exemplo Class A { a: Int <- 0; d: Int <- 1; f(): Int { a <- a + d }; } Class B inherits A { b: Int <- 2; f(): Int { a }; g(): Int { a <- a b }; } Class C inherits A { c: Int <- 3; h(): Int {a <- a * c }; } Layout dos objetos Atributos a e d são herdados pelas classes B e C Todos os métodos em todas as classes referem- se a a Para os métodos da classe A funcionarem corretamente para objetos das classes A, B e C, então o atributo a tem que estar no mesmo lugar em cada objeto Pense em objetos como uma struct em C 30

31 Layout dos objetos Organizados em regiões conˆguas de memória Cada atributo está armazenado a um offset fixo do objeto Acrescenta- se os métodos para a invocação Class Tag Object Size Dispatch Pointer Atributo 1 Atributo 2 Dispatch Pointer Aponta pra uma tabela que contém os métodos de cada classe Especialização de métodos resolvido aqui Na chamada, gerar código para invocar o i- ésimo procedimento apontado por essa tabela. Cada objeto aponta para a tabela apropriada 31