Realizar la asignación compilador de memoria en la pila de diferentes tamaños

Question

He estado construyendo mi propio compilador y una gran parte de ella es, obviamente, el asignador de registro, lo que coincide con las variables temporales registros de la máquina tan eficientemente como sea posible. En una arquitectura x86 como el que no hay muchos registros por lo que hay una serie de derrames en el que las variables deben ser almacenados en la memoria (la pila). También hay variables almacenadas en la memoria, ya que son demasiado grandes para caber en un registro.

El asignador de registro se invoca realmente más la asignación de las variables en la memoria de manera eficiente, de manera que todo el espacio se comparte como sea posible. El verdadero problema es que no hay manera de limitar el asignador de registro para colocar dos variables en la memoria junto a la otra (ya que entonces se puede dar a las variables de mayor tamaño como un número de variables más pequeñas) y para permitir que el asignador para mover las variables más pequeños alrededor de manera que las variables de mayor tamaño pueden caber, y me pregunto si hay algún algoritmos alrededor de manejar esta situación, de lo contrario tengo que dividir la memoria en diferentes áreas, cada uno con variables de un tamaño diferente.

Este es un ejemplo para demostrar esto:

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

Hay algunas suposiciones para hacer aquí con el propósito del ejemplo ... que las variables no están optimizados distancia, A y B ya no son útiles una vez c se ha definido y que todas las variables se asignan a apilar memoria. Está claro que me gustaría 'c' para utilizar la misma memoria que 'a' y 'b' acaba de utilizar y por tanto sólo asignar 8 bytes, sin embargo, la versión actual de mi compilador asignar un total de 16 bytes.

Mi pregunta es, ¿cómo puedo asignar las variables en memoria de diferentes tamaños de manera eficiente?

Answer 1

Es evidente que el asignador de registro no es lo suficientemente general para asignar espacio de pila, ya que no tiene sentido a confluir los registros y con menos adyacentes en un sistema x86.

¿Por qué no ampliarlo a hacer eso? O, mejor aún, dividir o subclase de manejar directamente registrar y apilar las asignaciones.

Como para el asignador de pila, no es por lo general eficiente en el tiempo ni particularmente eficiente del espacio para minimizar la pila utilizan en el caso (raro) que dos variables podrían compartir la misma asignación debido a alcance que no se solapan ejecución. Las operaciones para asignar y desasignar el espacio de pila adicional en la transición alcance es poco probable que sea la pena. Incluso en el más crítico de procesamiento en tiempo real, uno es por lo general mucho más interesado en la robustez y velocidad que el afeitado de unos pocos bytes de espacio de pila.