Re: const volatile

[David Brown <david at westcontrol dot com>]

(Please keep the gcc help list on the copies here - it saves duplication 
of answers, and means everyone gets to see them.)

On 26/09/2018 17:24, Kalamatee wrote:
> On Wed, 26 Sep 2018 at 16:00, David Brown <david@westcontrol.com 
> <mailto:david@westcontrol.com>> wrote:
>
>     On 26/09/18 14:54, Kalamatee wrote:
>      > Hi
>      >
>      > I am wondering if there is a reason globals marked const volatile
>     are put
>      > into the data section and not read-only as const should imply?
>      >
>
>     "const" says /you/ promise not to change the value from your code.
>     "volatile" says that something else might change its value unknown to
>     the compiler.
>
>     It is rare to define "const volatile" variables.  It is usually more
>     useful to declare pointers to them.  They are used for things like
>     read-only hardware registers in microcontrollers, or for data that is
>     set from outside a program but is constant from within it (perhaps you
>     patch your binaries with a serial number, or a checksum - you could use
>     a pointer to const volatile for reading the number in the code).
>
>     The only real use of defined "const volatile" variables I have had is
>     for debugging - these would be variables that cannot be changed by the
>     code, but you might change them via a debugger.  Usually such things are
>     temporary during software development, and it's easier just to make them
>     normal volatile variables.
>
>      > I am trying to compile code for m68k AmigaOS which is resident
>     using the
>      > mathlib functions which need certain constants as volatile to prevent
>      > incorrect sequence re-ordering in gcc's optimizations - however
>     doing so
>      > puts the value in bss data without const.
>      >
>
>     That is almost certainly not the best way to get the sequencing you
>     want.  Post more details on what you are trying to do, and I am sure
>     someone can give you advice.
>
>
> This comes from the standard sun mathlib code.
>
> Here’s one example where it isn’t for the sequence but to cause a 
> controlled crash in the correct way -:
> https://github.com/ezrec/AROS-mirror/blob/ABI_V1/AROS/compiler/stdc/math/e_log.c

I am not an expert in floating point details, especially not for 
non-finite things, but to my mind this code is clearly unnecessary.  The 
compiler will give the same result for "-two54 / vzero" whether vzero is 
declared "static const volatile double = 0.0;", or without the volatile, 
or given just as the literal 0.0 in the code.  Without the volatile, the 
code will be (marginally) shorter and faster as the construction of the 
infinity will be done at compile-time instead of run-time.

Wait for others to give an opinion before changing this, however.

>      > How can we have a global that is both volatile (to prevent incorrect
>      > sequencing) and const (so it is read only and stored in read only
>     data
>      > section) ?
>
>     Why does it matter where the data is stored?
>
>
> Because .data/.bss cannot exist in the rom image.

That is irrelevant.  If the "const volatile" variable has an explicit 
initialisation, it will be allocated to .data and initialised at startup 
just like any other initialised data variable.  If it is not explicitly 
initialised, it will be allocated to .bss and zeroed at startup - like 
any other uninitialised variable.

It is only from /your/ code - code run after "main()" starts - that 
"const" says you can't write to the variable.  The C startup code will 
initialise it as normal before main() starts.

>      >
>      > Thanks for any insight that may be provided.
>      >