Realizando compilador alocação de memória na pilha de tamanhos diferentes

Question

Eu tenho construir meu próprio compilador e uma grande parte do que é, obviamente, o alocador de registo, que combina variáveis ??temporárias com registros da máquina de forma tão eficiente quanto possível. Em uma arquitetura como o x86 não há muitos registros por isso há uma série de derrames em que as variáveis ??devem ser armazenados na memória (pilha). Há também variáveis ??armazenadas na memória, porque eles são muito grandes para caber em um registo.

O alocador registo é realmente chamado novamente para alocar as variáveis ??na memória de forma eficiente, de modo que tanto espaço é compartilhado possível. O verdadeiro problema é que não há maneira de restringir o alocador de registo para o lugar de duas variáveis ??em memória ao lado do outro (desde então eu posso dar-lhe variáveis ??maiores como um número de variáveis ??menores) e para permitir que o alocador para mover as variáveis ??menores em torno de modo que as variáveis ??maiores podem caber, e eu estou querendo saber se existem algoritmos em torno de lidar com isso, caso contrário, eu tenho que dividir a memória em diferentes áreas, cada uma das variáveis ??realização de um tamanho diferente.

Aqui está um exemplo para demonstrar isto:

void f(){
    int32_t a, b;
    //something happens to a and b...
    int64_t c;
    //something happens to c...
}

Existem algumas hipóteses para fazer aqui com o propósito do exemplo ... que as variáveis ??não são otimizados para longe, a e b não são mais útil uma vez que c foi definido e que todas as variáveis ??são atribuídos a pilha memória. É evidente que eu iria querer 'c' para usar a mesma memória como 'a' e 'b' apenas utilizado e, portanto, só alocar 8 bytes, no entanto, a versão atual do meu compilador iria alocar um total de 16 bytes.

A minha pergunta é, como posso alocar variáveis ??na memória de diferentes tamanhos de forma eficiente?

Answer 1

É evidente que o alocador de registo não é suficiente geral para alocar espaço de pilha, uma vez que não faz sentido a se aglutinar registros-at adjacentes menos em um x86.

Por que não expandi-lo a fazer exatamente isso? Ou, melhor ainda, dividir ou subclasse-lo para lidar diretamente registrar e alocações de pilha.

Quanto ao alocador de pilha, não é geralmente eficiente tempo de execução nem particularmente eficiente do espaço para minimizar a pilha usada no caso (raro) que duas variáveis ??poderiam compartilhar a mesma alocação devido ao âmbito não-sobreposição. As operações para alocar e desalocar o espaço de pilha extra na transição escopo é improvável que valer a pena. Mesmo no mais crítico de processamento em tempo real, um é geralmente muito mais interessados ??em robustez e velocidade do que raspar fora de alguns bytes de espaço de pilha.