Re: So You Think You Can Const?

Ben Bacarisse <ben@bsb.me.uk> writes:

Julio Di Egidio <julio@diegidio.name> writes:
>

On 07/01/2025 23:11, Kaz Kylheku wrote:
>

On 2025-01-07, Julio Di Egidio <julio@diegidio.name> wrote:

>
<snipped>
>

In particular, I am using C90, and compiling with
`gcc ... -ansi -pedantic -Wall -Wextra` (as I have
the requirement to ideally support any device).
>
To the question, I was reading this, but I am not
sure what the quoted passage means:
>
Matt Stancliff, "So You Think You Can Const?",
<https://matt.sh/sytycc>
<< Your compiler, at its discretion, may also choose
     to place any const declarations in read-only storage,
     so if you attempt to hack around the const blocks,
     you could get undefined behavior. >>

>
An object defined with a type that is const-qualified
could be put into write-protected storage.

>
What do you/we mean by "object" in this context?  (Sorry, I do have
forgotten, the glossary to begin with.)

>
An object (in C) is a contiguous region of storage, the contents of
which can represent values.
>

Overall, I am surmising this and only this might go write-protected:
>
  MyStruct_t const T = {...};

>
Yes, though you should extend your concern beyond what might be
write-protected.  Modifying an object whose type is const qualified
is undefined, even if the object is in writable storage.  A compiler
may assume that such an object has not changed because in a program
that has undefined behaviour, all bets are off.  [...]

We need to be careful about what is being asserted here.  There
are cases where a compiler may not assume that a const object
has not changed, despite the rule that assigning to a const
object is undefined behavior:

    #include <stdio.h>
    typedef union { const int foo; int bas; } Foobas;

    int
    main(){
     Foobas  fb     =  { 0 };

        printf( "  fb.foo is %d\n", fb.foo );
        fb.bas = 7;
        printf( "  fb.foo is %d\n", fb.foo );
        return  0;
    }

The object fb.foo is indeed a const object, but an access of
fb.foo must not assume that it retains its original value after
the assignment to fb.bas.