Thread: Restricted pointers C99.

Hello to all according to the theory this snippet of code :

Code:

#include<stdio.h>
void f( int * restrict p , int *q);

int main( void )
{
	int x=3;
	
	f(&x , &x);
	
	printf("%d" , x);
	
return 0;
}
void f ( int * restrict p , int *q ) 
{
	(*q) += 1;  // x = 4
	
	*q = *p + 2;  // x = 6
	
	return;
}

procudes Undefined Behaviour or not? I think yes... but I am not sure.

Thank you in advance for your time.

Yes, this is undefined behaviour - qualifying 'p' with 'restrict' says that all accesses to the object pointed to by 'p' in that block will be through 'p' or the result will be undefined. However, all accesses to the object pointed to by 'p' are not made through 'p' since some accesses to that object are made through 'q'.

Ok we solved this. It is Undefined behaviour when you use restricted pointers with that why... It is your responsibility to ensure that your code will avoid the UB phenomena.

I have some queries-issues too ....

1. However, all accesses to the object pointed to by 'p' are not made through 'p' since some accesses to that object are made through 'q'.

Do you have an example????

2.
If a restricted pointer is declared as a local variable without the extern storage class, restrict applies only to p when the block in which p is declared is being executed ..... When restrict is applied to a pointer variable with file scope, however the restriction lasts for the entire execution of the program

It follows the same rules for the ordinary variables... like local variables and external however it is logical because a pointer is exactly a variable.

3. There are even situations in which an alias created from a restricted pointer is legal.For example a restricted pointer p can be legally copied into another restricted pointer variable q, provided that p is local to a function and q is define inside a block nested within the function body

Code:

#include<stdio.h>
void f( int * restrict p , int *q);
 
int main( void )
{
    int x=3;
     
    f(&x , &x);
     
    printf("%d" , x);  // 5
     
return 0;
}
void f ( int * restrict p , int * restrict q )
{
   q = p;
   
   *q = 5;
     
    return;
}

This is legal???? Inside a block nested within the function body???? Hmmm I think is something like {...} in the function I am not sure that I have understood clearly... any help???

Thank you for the discussion.

Originally Posted by Mr.Lnx

1. However, all accesses to the object pointed to by 'p' are not made through 'p' since some accesses to that object are made through 'q'.

Do you have an example????

Erm... you gave the example in your first post...

Originally Posted by Mr.Lnx

Code:

*q = *p + 2;  // x = 6

Here you access the same object through both 'q' and 'p'.

Can I ask what the end-goal is here?

Originally Posted by Mr.Lnx

3. There are even situations in which an alias created from a restricted pointer is legal.For example a restricted pointer p can be legally copied into another restricted pointer variable q, provided that p is local to a function and q is define inside a block nested within the function body

This is legal???? Inside a block nested within the function body???? Hmmm I think is something like {...} in the function I am not sure that I have understood clearly... any help???

I don't know what you intend to show in your example, but it doesn't appear to bear any relation to point 3. Also, you should make it clear where you get that point from - is it something you are asserting is true, or something you have been told? It seems to have materialised out of thin air.

The C99 standard gives the following example:

Originally Posted by C99 Section 6.7.3.1, point 11

The rule limiting assignments between restricted pointers does not distinguish between a
function call and an equivalent nested block. With one exception, only ‘‘outer-to-inner’’ assignments
between restricted pointers declared in nested blocks have defined behavior.

Code:

{
    int * restrict p1;
    int * restrict q1;
    p1 = q1; // undefined behavior
    {
        int * restrict p2 = p1; // valid
        int * restrict q2 = q1; // valid
        p1 = q2;
        // undefined behavior
        p2 = q2;
        // undefined behavior
    }
}

It might be worth referring to the standard.