All 3 questions pretty much boil down to the same special rule: a pointer to struct may alias with a pointer to one of the types that is also a member of that struct. Meaning that restrict might improve performance a tiny bit, as the compiler no longer needs to assume that a pointer to int might modify some int member of the struct.
Example:
typedef struct { int a; double b; } struct_t; void func (struct_t* s, int* i) { s->a++; *i = 123; printf("%d\n", s->a); }
On clang 20.1 x86 -O3 I get this code generation:
func: inc dword ptr [rdi] mov dword ptr [rsi], 123 mov esi, dword ptr [rdi] lea rdi, [rip + .L.str] xor eax, eax jmp printf@PLT
As in, a is incremented by 1 in-place, then later after *i has been modified, it reloads a from memory esi, dword ptr [rdi]. Because it can't assume that writing to *i didn't change a.
After changing to struct_t* restrict s:
func: mov eax, dword ptr [rdi] inc eax mov dword ptr [rdi], eax mov dword ptr [rsi], 123 lea rdi, [rip + .L.str] mov esi, eax xor eax, eax jmp printf@PLT
This isn't obviously much faster, but now the inc is carried out on a register instead of a read-modify-write in RAM. The compiler doesn't have to assume that the 123 write affected a. It stores the new value of a back in RAM before writing 123 to i. And then later uses the new value of a still kept in a register to pass to printf mov esi, eax, without reloading it from RAM.
