assigning to const int via pointer

assigning to const int via pointer

[Joe Steeve]

[-- Attachment #1: Type: text/plain, Size: 463 bytes --]


The following code assigns a value to a `const int` via a
pointer.,

#include <stdio.h>

int 
main()
{
  const int x=5;
  int *ptr;
  ptr = &x;
  *ptr = 10;
  printf("%d",x);
}

The code gives `10` for the following compilation

    $gcc -o test test.c

It gives `5` when using optimisations switches.,

    $gcc -o test -O2 test.c

Feature or bug or any explanation for this? 

-- 
.O. A proud GNU user
..O http://www.joesteeve.tk/
OOO http://gnukid.5gigs.com/

[-- Attachment #2: Type: application/pgp-signature, Size: 188 bytes --]

Re: assigning to const int via pointer

[Sriharsha]

One more addition;

If you declare x as volatile, i.e.
volatile const int x=5;

then, even with Optimization, the result is 10.

Another thing, I observed with gdb, is that the variable ptr is actually 
eliminated during Optimization O2.
to confirm, compile the code as:
gcc -O2 -g -Wall test.c
Now run it in gdb:

gdb a.out

here, the listing will show the code as it is, but try:
print *ptr
It says, "No symbol "ptr" in the current context"

Regards,
Harsha.

Joe Steeve wrote:

>The following code assigns a value to a `const int` via a
>pointer.,
>
>#include <stdio.h>
>
>int 
>main()
>{
>  const int x=5;
>  int *ptr;
>  ptr = &x;
>  *ptr = 10;
>  printf("%d",x);
>}
>
>The code gives `10` for the following compilation
>
>    $gcc -o test test.c
>
>It gives `5` when using optimisations switches.,
>
>    $gcc -o test -O2 test.c
>
>Feature or bug or any explanation for this? 
>
>  
>

-- 
 *****************************
 * Sriharsha Vedurmudi			
 * Software Engineer		
 * 
 * Redpine Signals Inc.	
 * Gate #395, Plot 87,88			
 * Sagar Society, Road #2, 
 * Banjara Hills,		
 * Hyderabad - 500 034			
 * www.redpinesignals.com	
 *							
 * +91-40-23559911  (Office)
 * +91-98851-37338  (Mobile)
 *****************************

Re: assigning to const int via pointer

[Ian Lance Taylor]

Joe Steeve <joe_steeve@gmx.net> writes:

> The following code assigns a value to a `const int` via a
> pointer.,
> 
> #include <stdio.h>
> 
> int 
> main()
> {
>   const int x=5;
>   int *ptr;
>   ptr = &x;
>   *ptr = 10;
>   printf("%d",x);
> }
> 
> The code gives `10` for the following compilation
> 
>     $gcc -o test test.c
> 
> It gives `5` when using optimisations switches.,
> 
>     $gcc -o test -O2 test.c
> 
> Feature or bug or any explanation for this? 

When you declare that the variable is const, you are declaring that
the value does not change.  When you do change it, you are using
undefined behaviour.  When the compiler sees undefined behaviour, it
does not behave predictably.

ISO C99 6.7.3: "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."

Ian

Re: assigning to const int via pointer

[Sriharsha]

Ian Lance Taylor wrote:

>Joe Steeve <joe_steeve@gmx.net> writes:
>
>  
>
>>The following code assigns a value to a `const int` via a
>>pointer.,
>>
>>#include <stdio.h>
>>
>>int 
>>main()
>>{
>>  const int x=5;
>>  int *ptr;
>>  ptr = &x;
>>  *ptr = 10;
>>  printf("%d",x);
>>}
>>
>>The code gives `10` for the following compilation
>>
>>    $gcc -o test test.c
>>
>>It gives `5` when using optimisations switches.,
>>
>>    $gcc -o test -O2 test.c
>>
>>Feature or bug or any explanation for this? 
>>    
>>
>
>When you declare that the variable is const, you are declaring that
>the value does not change.  When you do change it, you are using
>undefined behaviour.  When the compiler sees undefined behaviour, it
>does not behave predictably.
>
>ISO C99 6.7.3: "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."
>  
>
I am a little confused. The rule says:
If an attempt is made to modify an object, defined with a 
const-qualified type, through use of an lvalue with a 
non-const-qualified type, the behavior is undefined.

Now, in the above, program, we are not trying to alter the value of the 
variable x as follows:
x = 10;

But we are trying to alter the contents of a memory location, which 
happens to be where the variable 'x' refers to,  by using a pointer, 
which is defined behaviour.

According to the rule, you cannot use the variable, declared as a 
const-qualified type, on the left hand side (lvalue, or assigned-to 
variable), but it does not say anything about the memory being modified.

Please correct me if I am wrong. Also, when you qualify the type of x to 
be a volatile, then the behaviour is as expected. So, there must be some 
other reason why the variable "int *ptr" is being discarded by 
Optimization. Check out that without optimization, you are able to 
change the contents. Also, I've tried this with a few other compilers 
(without optimization) and they all change the contents.

Harsha

>Ian
>
>  
>

-- 
 *****************************
 * Sriharsha Vedurmudi			
 * Software Engineer		
 * 
 * Redpine Signals Inc.	
 * Gate #395, Plot 87,88			
 * Sagar Society, Road #2, 
 * Banjara Hills,		
 * Hyderabad - 500 034			
 * www.redpinesignals.com	
 *							
 * +91-40-23559911  (Office)
 * +91-98851-37338  (Mobile)
 *****************************

Re: assigning to const int via pointer

[Gabriel Dos Reis]

Sriharsha <sriharsha.v@redpinesignals.com> writes:

| Ian Lance Taylor wrote:
| 
| >Joe Steeve <joe_steeve@gmx.net> writes:
| >
| >
| >>The following code assigns a value to a `const int` via a
| >>pointer.,
| >>
| >>#include <stdio.h>
| >>
| >> int main()
| >>{
| >>  const int x=5;
| >>  int *ptr;
| >>  ptr = &x;
| >>  *ptr = 10;
| >>  printf("%d",x);
| >>}
| >>
| >>The code gives `10` for the following compilation
| >>
| >>    $gcc -o test test.c
| >>
| >>It gives `5` when using optimisations switches.,
| >>
| >>    $gcc -o test -O2 test.c
| >>
| >> Feature or bug or any explanation for this?
| >
| >When you declare that the variable is const, you are declaring that
| >the value does not change.  When you do change it, you are using
| >undefined behaviour.  When the compiler sees undefined behaviour, it
| >does not behave predictably.
| >
| >ISO C99 6.7.3: "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."
| >
| I am a little confused. The rule says:
| If an attempt is made to modify an object, defined with a
| const-qualified type, through use of an lvalue with a
| non-const-qualified type, the behavior is undefined.
| 
| Now, in the above, program, we are not trying to alter the value of
| the variable x as follows:
| x = 10;
| 
| But we are trying to alter the contents of a memory location, which
| happens to be where the variable 'x' refers to,  by using a pointer,
| which is defined behaviour.

which is precisely what the rule outlaws.  

-- Gaby

Re: assigning to const int via pointer

[Ian Lance Taylor]

Sriharsha <sriharsha.v@redpinesignals.com> writes:

> >>The following code assigns a value to a `const int` via a
> >>pointer.,
> >>
> >>#include <stdio.h>
> >>
> >> int main()
> >>{
> >>  const int x=5;
> >>  int *ptr;
> >>  ptr = &x;
> >>  *ptr = 10;
> >>  printf("%d",x);
> >>}
> >>
> >>The code gives `10` for the following compilation
> >>
> >>    $gcc -o test test.c
> >>
> >>It gives `5` when using optimisations switches.,
> >>
> >>    $gcc -o test -O2 test.c
> >>
> >> Feature or bug or any explanation for this?
> >
> >When you declare that the variable is const, you are declaring that
> >the value does not change.  When you do change it, you are using
> >undefined behaviour.  When the compiler sees undefined behaviour, it
> >does not behave predictably.
> >
> >ISO C99 6.7.3: "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."
> >
> I am a little confused.

Yes.

> The rule says:
> If an attempt is made to modify an object, defined with a
> const-qualified type, through use of an lvalue with a
> non-const-qualified type, the behavior is undefined.
> 
> Now, in the above, program, we are not trying to alter the value of
> the variable x as follows:
> x = 10;
> 
> But we are trying to alter the contents of a memory location, which
> happens to be where the variable 'x' refers to,  by using a pointer,
> which is defined behaviour.

No.  Note that the rule is about modifying "an object".  The object in
question was defined by the definition of 'x', and thus was defined
using a const-qualified type.  The assignment through 'ptr' is
modifying an object defined with a const-qualified type.

> According to the rule, you cannot use the variable, declared as a
> const-qualified type, on the left hand side (lvalue, or assigned-to
> variable), but it does not say anything about the memory being
> modified.

No.  The rule I quoted doesn't say that you can't use a
const-qualified type as an lvalue.  It says that you can't use an
lvalue with a non-const-qualified type to modify an object defined
with a const-qualified type.  *ptr is an lvalue with a
non-const-qualified type.  It is being used to modify the object
defined by the declaration of x with a const-qualified type.

> Please correct me if I am wrong. Also, when you qualify the type of x
> to be a volatile, then the behaviour is as expected. So, there must be
> some other reason why the variable "int *ptr" is being discarded by
> Optimization. Check out that without optimization, you are able to
> change the contents. Also, I've tried this with a few other compilers
> (without optimization) and they all change the contents.

The program performs undefined behaviour.  Therefore the compiled
results are unpredictable.  It is not surprising that the behaviour is
different among different compilers and different optimization levels.

Ian

Re: assigning to const int via pointer

[Joe Steeve]

[-- Attachment #1: Type: text/plain, Size: 351 bytes --]

Ian Lance Taylor <ian@airs.com> writes:
> ISO C99 6.7.3: "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."

Thanks., that clarifies the confusion. :)

-- 
.O. A proud GNU user
..O http://www.joesteeve.tk/
OOO http://gnukid.5gigs.com/

[-- Attachment #2: Type: application/pgp-signature, Size: 188 bytes --]

Re: assigning to const int via pointer

[Sriharsha]

Got it now. Thank you.

Ian Lance Taylor wrote:

>Sriharsha <sriharsha.v@redpinesignals.com> writes:
>
>  
>
>>>>The following code assigns a value to a `const int` via a
>>>>pointer.,
>>>>
>>>>#include <stdio.h>
>>>>
>>>>int main()
>>>>{
>>>> const int x=5;
>>>> int *ptr;
>>>> ptr = &x;
>>>> *ptr = 10;
>>>> printf("%d",x);
>>>>}
>>>>
>>>>The code gives `10` for the following compilation
>>>>
>>>>   $gcc -o test test.c
>>>>
>>>>It gives `5` when using optimisations switches.,
>>>>
>>>>   $gcc -o test -O2 test.c
>>>>
>>>>Feature or bug or any explanation for this?
>>>>        
>>>>
>>>When you declare that the variable is const, you are declaring that
>>>the value does not change.  When you do change it, you are using
>>>undefined behaviour.  When the compiler sees undefined behaviour, it
>>>does not behave predictably.
>>>
>>>ISO C99 6.7.3: "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."
>>>
>>>      
>>>
>>I am a little confused.
>>    
>>
>
>Yes.
>
>  
>
>>The rule says:
>>If an attempt is made to modify an object, defined with a
>>const-qualified type, through use of an lvalue with a
>>non-const-qualified type, the behavior is undefined.
>>
>>Now, in the above, program, we are not trying to alter the value of
>>the variable x as follows:
>>x = 10;
>>
>>But we are trying to alter the contents of a memory location, which
>>happens to be where the variable 'x' refers to,  by using a pointer,
>>which is defined behaviour.
>>    
>>
>
>No.  Note that the rule is about modifying "an object".  The object in
>question was defined by the definition of 'x', and thus was defined
>using a const-qualified type.  The assignment through 'ptr' is
>modifying an object defined with a const-qualified type.
>
>  
>
>>According to the rule, you cannot use the variable, declared as a
>>const-qualified type, on the left hand side (lvalue, or assigned-to
>>variable), but it does not say anything about the memory being
>>modified.
>>    
>>
>
>No.  The rule I quoted doesn't say that you can't use a
>const-qualified type as an lvalue.  It says that you can't use an
>lvalue with a non-const-qualified type to modify an object defined
>with a const-qualified type.  *ptr is an lvalue with a
>non-const-qualified type.  It is being used to modify the object
>defined by the declaration of x with a const-qualified type.
>
>  
>
>>Please correct me if I am wrong. Also, when you qualify the type of x
>>to be a volatile, then the behaviour is as expected. So, there must be
>>some other reason why the variable "int *ptr" is being discarded by
>>Optimization. Check out that without optimization, you are able to
>>change the contents. Also, I've tried this with a few other compilers
>>(without optimization) and they all change the contents.
>>    
>>
>
>The program performs undefined behaviour.  Therefore the compiled
>results are unpredictable.  It is not surprising that the behaviour is
>different among different compilers and different optimization levels.
>
>Ian
>
>  
>

-- 
 *****************************
 * Sriharsha Vedurmudi			
 * Software Engineer		
 * 
 * Redpine Signals Inc.	
 * Gate #395, Plot 87,88			
 * Sagar Society, Road #2, 
 * Banjara Hills,		
 * Hyderabad - 500 034			
 * www.redpinesignals.com	
 *							
 * +91-40-23559911  (Office)
 * +91-98851-37338  (Mobile)
 *****************************