How should I understand theese C syntax?

Question

As the code below, function pointer y, z, b behave the same. Even *x would be understand as data of pointer x and &x would understand as pointer to x.

typedef void (*func)(void);

void x(void){
    printf("asdsag\n");
    return;
}

int main(int argc, char const *argv[])
{
    func y = *x;
    func z = x;
    func b = &x;
    y();
    z();
    b();
    return 0;
}

Now look at this code.

void test(int **p){
    printf("%p\n",p);
    return;
}
int main(int argc, char const *argv[])
{
    int * p[5];
    test(p);
    test(&p);
    return 0;
}

This code print same pointer for all 3 case. Here is asembly after compile above code

main:
    @ args = 0, pretend = 0, frame = 32
    @ frame_needed = 1, uses_anonymous_args = 0
    push    {r7, lr}
    sub sp, sp, #32
    add r7, sp, #0
    str r0, [r7, #4]
    str r1, [r7]
    ldr r3, [r7, #12]
    mov r0, r3
    bl  test
    add r3, r7, #12
    mov r0, r3
    bl  test
    add r3, r7, #12
    mov r0, r3
    bl  test
    movs    r3, #0
    mov r0, r3
    adds    r7, r7, #32
    mov sp, r7
    @ sp needed
    pop {r7, pc}
    .size   main, .-main

It is seem that they take same r7+#12 for all three case.

[Question] For all given information above, what should I understand p,*p,&p in C99?

[Info] This is build with gcc-linaro-7.2.1-2017.11-x86_64_arm-linux-gnueabihf

[Update] Update for @tadman about imcompatible pointer

#include <stdio.h>

void test1(void **p){
    printf("%p\n",p);
    return;
}

void test2(void *p){
    printf("%p\n",p);
    return;
}

int main(int argc, char const *argv[])
{
    void * p[5] = {0};
    test1(p);
    test2(&p);
    return 0;
}

There is no warning even with -Wall Here is the output:

0x7fff5615bb20
0x7fff5615bb20

P/S I was wrong in the first case, so I delete it.

Answer 1

In the first case you have a function, like this:

typedef void (*f)(void);

void p(void) {
}

int main(int argc, char const *argv[]) {
    func a = p;
    func b = *p;
    func c = &p;
    a();
    b();
    c();

    return 0;
}

All three of these work because p and &p are the same thing, the & operator on a function is optional and is basically a "do nothing" operator. On clang at least * is also a no-op, which isn't documented but appears to be the case. As such you can do &p or *p or &*p or ****&&**&*p and you get the same thing.

In the second case you have actual data:

void test(int **p) {
}

int main(int argc, char const *argv[]) {
    int *p[5];

    test(p);  // Valid: int** -> int**
    test(&p); // Invalid: Incompatible pointer int*** -> int**
    test(*p); // Invalid: incompatible pointer int* -> int**

    return 0;
}

The first is defined behaviour, you're passing an identical pointer type in so it works. The second two are just junk code. Maybe they'll compile, but the behaviour is undefined. Whatever they do is completely arbitrary.

Answer 2

Don't confuse levels of indirection of function pointers and regular pointers. This is a particularly quirky thing about the C standard.

§ 6.3.2.1

Lvalues, arrays, and function designators

...

4. A function designator is an expression that has function type. Except when it is the operand of the sizeof operator,67) or the unary & operator, a function designator with type "function returning type" is converted to an expression that has type "pointer to function returning type".

Emphasis on-

function designator with type "function returning type" is converted to an expression that has type "pointer to function returning type".

(Mention the correct part of the standard, thanks to @John Bollinger)

Which essentially means a, b, and c are all the same here

func a = p;
func b = *p;
func c = &p;

All of them can be treated like a regular function and be called with (...).

The behavior is much, much different for regular pointers though - as in your next example.

int * p[5];
test(*p);
test(p);
test(&p);

So int* p[5] declares an array of 5 pointers. So the type of p is int*[5], the type of each element in p (such as p[0]) is int*.

So, with test(*p), you're just passing p[0] (because *(p + 0) == p[0] == *p) - which is of type int*. Conversion from int* to int** is undefined and hence that's a big no no.

With test(&p), you're passing a value of type int*(*)[5]. Once again, different levels of indirection - and not on function types - the real rules apply here. The behavior is undefined.

test(p) is fine though, p, as a type int*[5] gets decayed to int** which is a valid argument to test

(Edited to reflect non decayed versions of the pointer types, thanks to thanks to @John Bollinger)

Also since we're talking about undefined behavior so much and in case you are confused. It basically means that the behavior has no well defined result - you might observe something apparently defined on your PC and your environment - but that same behavior is not guaranteed globally.

3.4.3

undefined behavior

behavior, upon use of a nonportable or erroneous program construct or of erroneous data, for which this document imposes no requirements