¿Cómo evitar que gcc optimice algunas declaraciones en C?

Para ensuciar una página (activando el bit sucio en la entrada de la tabla de páginas), toco los primeros bytes de la página así:

pageptr[0] = pageptr[0];

Pero en la práctica, gcc ignorará la declaración por eliminación de tienda muerta. Para evitar que gcc lo optimice, reescribo la declaración de la siguiente manera:

volatile int tmp;
tmp = pageptr[0];
pageptr[0] = tmp;

Parece que el truco funciona, pero algo feo. Me gustaría saber si hay alguna directiva o sintaxis que tenga el mismo efecto. Y no quiero usar una -O0bandera, ya que también traerá una gran penalización de rendimiento.

Desactivar la optimización soluciona el problema, pero no es necesario. Una alternativa más segura es hacer que sea ilegal que el compilador optimice la tienda usando el volatilecalificador de tipo.

// Assuming pageptr is unsigned char * already...
unsigned char *pageptr = ...;
((unsigned char volatile *)pageptr)[0] = pageptr[0];

El volatilecalificador de tipo indica al compilador que sea estricto con las cargas y los almacenes de memoria. Uno de los objetivos volatilees informar al compilador que el acceso a la memoria tiene efectos secundarios y, por lo tanto, debe conservarse. En este caso, la tienda tiene el efecto secundario de provocar un error de página y desea que el compilador conserve el error de página.

De esta manera, el código circundante aún se puede optimizar y su código es portátil para otros compiladores que no entienden la sintaxis #pragmao GCC __attribute__.

Puedes usar

#pragma GCC push_options
#pragma GCC optimize ("O0")

your code

#pragma GCC pop_options

para deshabilitar optimizaciones desde GCC 4.4.

Consulte la documentación de GCC si necesita más detalles.

En lugar de utilizar los nuevos pragmas, también puede utilizarlos __attribute__((optimize("O0")))para sus necesidades. Esto tiene la ventaja de que solo se aplica a una única función y no a todas las funciones definidas en el mismo archivo.

Ejemplo de uso:

void __attribute__((optimize("O0"))) foo(unsigned char data) {
    // unmodifiable compiler code
}