Semántica volátil en C99

Question

Tengo un problema con algún código de nivel bajo Estoy escribiendo, necesito usar objetos como volátiles, pero no es necesariamente así que quiero que los tipos sean declarados como volátiles (por razones de reutilización). Sin embargo, puedo definir el puntero a una variante calificada de una estructura como se detalla en el siguiente segmento.

struct x { 
    int bar; 
}; 

struct x foobar; 
... 
volatile struct x *foo = &foobar; 

Ahora foo es efectivamente un puntero a un objeto del tipo:

volatile struct x { 
    volatile int x; 
}; 

desde volátil se aplican a todos los miembros de la estructura. Ahora mi pregunta es cuando un objeto contiene un puntero a otro objeto, ¿cómo se aplica la volatilidad?

struct x { 
    struct y *bar; 
}; 

¿Un puntero a una instancia volátil x continuación, a continuación, tratar esto como:

volatile struct x { 
    struct y * volatile bar; 
}; 

o como:

volatile struct x { 
    volatile struct y * volatile bar; 
}; 

He leído a través de la norma C, y se no es muy claro con respecto a esto, y puedo interpretar fácilmente la redacción de múltiples maneras.

Answer 1

En su ejemplo, usted obtiene un puntero volátil, eso es todo, la volatilidad no se extiende al objeto.

Expandir mi respuesta volátil es un atómico relajado, eso significa que el acceso es atómico, pero las instrucciones no lo serán. Por lo tanto, no puede incrementar o disminuir de manera segura un elemento volátil, por lo que no puede usar un puntero volátil para la interación, solo operaciones de almacenamiento/carga (asignación). Lo mismo vale para un número int u otro, y volátil tampoco funciona con flotantes porque se procesan en la tubería FPU, no en la CPU. En general, los volátiles no son demasiado útiles, pero los compiladores de Microsoft colocan automáticamente guardias de instrucciones en torno a los volátiles, lo que los convierte en verdaderos valores atómicos, pero eso no forma parte del estándar.

Answer 2

Leyendo a través del estándar here, parece que el puntero es volátil, pero no el contenido real de la propia estructura. Interpreté eso del ejemplo dado, const t * volatile p (en la parte inferior del enlace). El texto, sin embargo, es vaga, pero creo que esto sería un ejemplo similar:

struct foo { 
    int bar; 
}; 

struct foo *volatile x; 

Tenga en cuenta que no he probado esto, así que puede ser tremendamente errónea ... es simplemente lo que he reunidos a partir de una lectura superficial del estándar.

Además, cdecl aclara algo de la vaguedad.Por ejemplo:

cdecl> explicar volatile struct x* foo
foo declarar como puntero a struct volátil x

Considerando lo siguiente:

cdecl> explicar struct x* volatile foo
declarar foo tan volátil puntero a struct x

En una instancia, la estructura es volátil. En el otro, el puntero.