x86_64 alinear pila y recuperar sin guardar registros

Question

Estoy escribiendo rutinas de manejo de interrupciones para x86_64. El ABI especifica que antes de llamar a una función C, debo alinear la pila a 16 bytes. El ISA x86_64 especifica que al ingresar a un ISR, mi pila está alineada con 8 bytes. Necesito alinear mi puntero de pila a 16 bytes por lo tanto. El problema es que al regresar de mi función C, debo recuperar el puntero de la pila (potencialmente) desalineado para que pueda regresar de mi interrupción correctamente.

Me pregunto si hay una manera de hacerlo sin usar un registro de propósito general?

Answer 1

aquí está mi solución a la cuestión que se plantean:

pushq %rsp 
pushq (%rsp) 
andq $-0x10, %rsp 
    call function 
movq 8(%rsp), %rsp 

Los dos impulsos deje la pila con la misma alineación que tenía originalmente, y una copia del original %rsp en (%rsp) y 8(%rsp). El andq alinea la pila; si ya estaba alineado en 16 bytes, nada cambia, si estaba alineado en 8 bytes, restará 8 de %rsp, lo que significa que el %rsp original está ahora en y 16(%rsp). Así que podemos restaurarlo incondicionalmente desde 8(%rsp).

Answer 2

No hay forma de hacerlo sin un registro adicional, porque la operación de alineación es destructiva para el registro rsp. Que tiene que hacer algo a lo largo

push %rbp   ;save rbp for stack pointer 
mov %rsp, %rbp ;move old sp to rbp 
and $-0x10, %rsp ;align stack 
...     
...    ;if you want to use %rbp here, save it on the stack before 
... 
mov %rbp, %rsp ;old stack pointer 
pop %rbp 
iret 

Answer 3

Sospecho que la única manera de hacerlo sin necesidad de utilizar un registro adicional requiere la escritura y la lectura adicional a la memoria lo que sería el único punto de no utilizar un registro adicional.

Ofreceré la solución actual que tengo. Guardo rbp para que pueda usarlo para el almacenamiento temporal y luego restaurarlo antes de la llamada a la función. Esto es similar a drhirsch a responder

movq %rbp, -24(%rsp) //store original rbp 3 words beyond the stack 
movq %rsp, %rbp //store original rsp 
subq $8, %rsp //buy a word on the stack 
andq $-0x10, %rsp //16 byte align the stack (growing downwards) 
//We now have 1 or 2 words free on the stack (depending on the original 
// alignment). This is why we put rbp 3 words beyond the stack 
movq %rbp, (%rsp) //store the original rsp right here 
movq -24(%rbp), %rbp //restore original rbp 
call foo 
movq (%rsp), %rsp //restore original rsp 
iretq 

Answer 4

Probablemente más lento que usar% ebp como han descrito otros, pero ¿qué tal:

push %rsp 
    test $0xf, %rsp 
    jz aligned 
    push (%rsp) // duplicate the top of the stack 
aligned: 
    // now have 16-byte alignment with the original stack pointer 
    // on the top of the stack, either once or twice 
     : 
    pop %rsp 
    iret 

Esto se aprovecha del hecho de que la pila ya es de 8 bytes alineados , y que una instrucción de inserción puede leer el valor que se extraerá de la memoria.