Re: Bounds checking, Optimization techniques and undefined behavior

On 08/05/2019 10:03, David Brown wrote:


>
> [I'm looking at C11 and don't see where it says you can't cast away
> const. What am I missing? I agree any approach here is ugly and we're
> near the limits of what you can say in C. -John]
>


6.7.3p6 :


"""
If an attempt is made to modify an object defined with a const-qualified
type through use of an lvalue with non-const-qualified type, the
behavior is undefined.
"""




Consider this code:


int v = 10;
const int c = 20;


void change(const int * p, int n) {
*(int*) p = n;
}


int foo(int a) {
change(&v, a); // OK
change(&c, a); // Usually compiles, but NOT OK


return c;
}






You can cast away const (via pointers), but if the original declaration
of the object was const, it is undefined behaviour.


Compiling this with gcc x86 and optimisation (with
<https://godbolt.org>), you get this:


change:
                mov DWORD PTR [rdi], esi
                ret
foo:
                mov DWORD PTR v[rip], edi
                mov eax, 20
                mov DWORD PTR c[rip], edi
                ret
c:
                .long 20
v:
                .long 10




Although the call "change(&c, a)" attempts to modify "c" (which will
likely cause a fault on many systems), the compiler assumes the value of
"c" is still 20 for the return.
[Oh, look at that. Tried it with clang, did the same thing returning a constant 20. -John]

Return to the comp.compilers page.
Search the comp.compilers archives again.