Is it sufficient to declare an instance of a structure-typed variable as volatile (if its fields are accessed in re-entrant code), or must one declare specific fields of the structure as volatile?
Phrased differently, what are the semantic differences (if any) between:
typdef struct {
uint8_t bar;
} foo_t;
volatile foo_t foo_inst;
and
typedef struct{
volatile uint8_t bar;
} foo_t;
foo_t foo_inst;
I recognize that declaring a pointer-typed variable as volatile (e.g. volatile uint8_t * foo) merely informs the compiler that the address pointed-to by foo may change, while making no statement about the values pointed to by foo. It is unclear to me whether an analogy holds for structure-typed variables.
Answer
In your example, the two are the same. But the issues revolve around pointers.
First off, volatile uint8_t *foo; tells the compiler the memory being pointed to is volatile. If you want to mark the pointer itself as volatile, you would need to do uint8_t * volatile foo;
And that is where you get to the main differences between marking the struct as volatile vs marking individual fields. If you had:
typedef struct
{
uint8_t *field;
} foo;
volatile foo f;
That would act like:
typedef struct
{
uint8_t * volatile field;
} foo;
and not like:
typedef struct
{
volatile uint8_t *field;
} foo;