Volatile pointer points to non volatile data

Question

I understand that the declaration

int *volatile ptr;

means that the pointer itself is volatile

int a=10;
int *volatile ptr=&a;

Now both ptr and a are being updated. Will it cause any potential problems like old value of a being returned when accessing ptr?

To clarify the use case of volatile pointer in my scenario:

1. To communicate from interrupt context to task context I am passing addresses to circular queue (which is array of pointers) which will be accessed from task context.
2. The pointers in this queue are declared volatile.
3. At index x in queue ,pointer y is present which points to variable a.
4. Now if I write new pointer to queue (example pointer z which points to variable b) at index x in interrupt context.
5. When I read index x in task context, since queue is declared as volatile, the pointers will not be optimised.

My doubt is since what the pointer is pointing to is not volatile is there a chance that compiler has optimized for index x and on deferencing pointer at index x it will point to variable a instead of variable b

Answer 1

If both ptr and the int that ptr points to are updated by a different thread or by your hardware, you have to declare ptr like this:

int volatile * volatile ptr=&a;

Or:

volatile int * volatile ptr=&a;

Typically in embedded programming, as @Lundin points out, the adresses don't change, so this is sufficient:

volatile int * ptr=&a;

Or:

int volatile * ptr=&a;

Answer 2

int* volatile only means that the pointer itself is volatile. The pointed-at data is not volatile-qualified, meaning that the following scenario may cause optimizer bugs:

int a=10;
int* volatile ptr=&a;

int main()
{
  for(;;)
  {
    printf("%d\n", *ptr);
  }
}

void some_ISR (void)
{
  a = something;
}

The compiler is careful not to assume that ptr does not point at the same address every lap in the loop, but apart from that it is free to assume: "aha, after reading ptr it is still pointing at a I see. It has not been updated and I know it is 10". In theory the compiler is free to generate machine code such as this pseudo:

val = *ptr

forever
{
  ptr = (update it by reading from memory)
  if ptr != previous
    val =*ptr

  print val        
  previous = ptr
}

Such optimizations may make sense if the compiler can keep the previous value stashed away in a CPU register etc. Suppose it can get rid of a lot of the printf overhead this way, that would be a major optimization.

So, no this does not give you protection against incorrect optimizations. To achieve that, use volatile int* instead. Or if the pointers themselves may also change, volatile int* volatile.

---

To communicate from interrupt context to task context I am passing addresses to circular queue (which is array of pointers) which will be accessed from task context.

That only makes sense if the pointer itself is changed to point elsewhere by the interrupt. Again, it doesn't mean that the pointed-at data will be updated. But as you write "The pointers in this queue are declared volatile.", you are good, assuming this means that the pointers are volatile* type and not type*volatile.

Unrelated to this whole issue, you also need a protection against non-atomic access of shared variables. volatile does not give that.

Answer 3

Any use of a through a volatile pointer will make the dereference volatile also (as the value of the pointer is not cached, the dereference must be done anyway) But, the better is to make both uncacheable, so a possible way to implement is:

volatile int a;
volatile int * volatile ptr = &a;

Think twice, as you haven't declared a as volatile, should you have done it you'd get a warning:

pru.c

 #include <stdio.h>
 int main()
 {
    volatile int a;
    int * volatile ptr = &a;
 }

and output

$ make pru
pru.c:5:17: warning: initializing 'int *volatile' with an expression of type 'volatile int *' discards qualifiers
      [-Wincompatible-pointer-types-discards-qualifiers]
    int * volatile ptr = &a;
                   ^     ~~
1 warning generated.

as you see from the warning, the qualifier discarded refers to the pointed value. In case of ptr being declared non-volatile the same warning is issued:

pru2.c

 #include <stdio.h>
 int main()
 {
    volatile int a;
    int * ptr = &a;
 }

and

$ make pru2
cc -O -pipe  pru.c  -o pru
pru.c:5:8: warning: initializing 'int *' with an expression of type 'volatile int *' discards qualifiers
      [-Wincompatible-pointer-types-discards-qualifiers]
        int * ptr = &a;
              ^     ~~
1 warning generated.