GCC - Cómo realinear la pila?

Question

Intento crear una aplicación que utilice pthreads y __m128 tipo de SSE. De acuerdo con el manual de GCC, la alineación predeterminada de la pila es de 16 bytes. Para usar __m128, el requisito es la alineación de 16 bytes.

Mi CPU de destino admite SSE. Utilizo un compilador de GCC que no admite la realineación de la pila en tiempo de ejecución (por ejemplo, -mstackrealign). No puedo usar ninguna otra versión del compilador de GCC.

Mi aplicación de prueba se parece a:

#include <xmmintrin.h> 
#include <pthread.h> 
void *f(void *x){ 
    __m128 y; 
    ... 
} 
int main(void){ 
    pthread_t p; 
    pthread_create(&p, NULL, f, NULL); 
} 

La aplicación genera una excepción y salidas. Después de una depuración simple (printf "% p", & y), encontré que la variable y no está alineada con 16 bytes.

Mi pregunta es: ¿cómo puedo realinear la pila correctamente (16 bytes) sin utilizar ninguna bandera GCC y atributos (no ayudan)? ¿Debo usar GCC en línea Ensamblador dentro de esta función de subproceso f()?

Answer 1

He resuelto este problema. Aquí está mi solución:

void another_function(){ 
    __m128 y; 
    ... 
} 
void *f(void *x){ 
asm("pushl %esp"); 
asm("subl $16,%esp"); 
asm("andl $-0x10,%esp"); 
another_function(); 
asm("popl %esp"); 
} 

En primer lugar, aumentamos la pila por 16 bytes. Segundo, hacemos un mordisco menos significativo igual a 0x0. Conservamos el puntero de la pila usando operandos push/pop. Llamamos a otra función, que tiene todas sus propias variables locales de 16 bytes alineados. Todas las funciones anidadas también tendrán sus variables locales alineadas a 16 bytes.

Y funciona!

Answer 2

Esto no debería estar sucediendo en el primer lugar, pero para evitar el problema que puede probar:

void *f(void *x) 
{ 
    __m128 y __attribute__ ((aligned (16))); 
    ... 
} 

Answer 3

Asignar en la pila una matriz que es de 15 bytes más grande que sizeof(__m128), y utilizar el primera dirección alineada en esa matriz. Si necesita varios, colóquelos en una matriz con un solo margen de 15 bytes para la alineación.

No recuerdo si la asignación de una matriz unsigned char lo protege de optimizaciones estrictas de aliasing por parte del compilador o si solo funciona al revés.

#include <stdint.h> 

void *f(void *x) 
{ 
    unsigned char y[sizeof(__m128)+15]; 
    __m128 *py = (__m128*) (((uintptr_t)&y) + 15) & ~(uintptr_t)15); 
    ... 
} 

Answer 4

Otra solución sería utilizar una función de relleno, que primero alinea la pila y luego llama al f. Por lo tanto, en lugar de llamar directamente al f, llame al pad, que primero almohadilla la pila y luego llama al foo con una pila alineada.

El código se vería así:

#include <xmmintrin.h> 
#include <pthread.h> 

#define ALIGNMENT 16 

void *f(void *x) { 
    __m128 y; 
    // other stuff 
} 

void * pad(void *val) { 
    unsigned int x; // to get the current address from the stack 
    unsigned char pad[ALIGNMENT - ((unsigned int) &x) % ALIGNMENT]; 
    return f(val); 
} 

int main(void){ 
    pthread_t p; 
    pthread_create(&p, NULL, pad, NULL); 
} 

Answer 5

momento de resucitar un viejo hilo ...

Para aquellos con un compilador más reciente que la OP, OP menciona una opción -mstackrealign, que me llevan a __attribute__((force_align_arg_pointer)). Si su función está siendo optimizada para usar SSE, pero %ebp está desalineada, esto hará las correcciones de tiempo de ejecución si es necesario para usted, de forma transparente. También descubrí que esto es solo un problema en i386. El ABI x86_64 garantiza que los argumentos están alineados con 16 bytes.

__attribute__((force_align_arg_pointer)) void i_crash_when_not_aligned_to_16_bytes() { ... }

Artículo interesante para aquellos que quieran aprender más: http://wiki.osdev.org/System_V_ABI