int a = 1;
int* x = &a;
//-> &*x equal to &a
If the pointer x has the adress of a and *x points to a's value, compiler couldn't know that *x was referring to exactly a, it could only know a's value if I pass *x.
But turns out it knows. So how does this work? does compiler pass the adress too or is it just cancelling * when I put & like &*x compiles as if its just like x or the other way?
1, a, x, *x are all expressions.
Some expressions have addresses (they are called "lvalues"), others don't (they are called "rvalues").
1 is a rvalue, it doesn't have an address. So &1 doesn't compile.
a is an lvalue, so it does have an address.
*x is also an lvalue, so it too has an address. This is just how the language works. It could've been made differently (*x could've been an rvalue), but it was made an lvalue, because it's convenient to have the address available.
For the operator &, there's no difference between a and *x, since both have the same value category (both are lvalues).
You seem to have assumed (even without knowing the terms) that only variable names are lvalues (only they have addresses), which is not the case.
Regarding the &(*x), from C11, chapter 6.5.3.2,
The unary
&operator yields the address of its operand. If the operand has type type, the result has type pointer to type. If the operand is the result of a unary*operator, neither that operator nor the&operator is evaluated and the result is as if both were omitted, except that the constraints on the operators still apply and the result is not an lvalue. [...]
An expression of the form &*p has some special considerations. It is not evaluated by first evaluating *p and taking the address of that, but rather the & and * cancel, to yield simply p.
This allows you to write something like
#include <iostream>
int main() {
int* p = nullptr;
int* q = &*p;
std::cout << p << q;
}
without any undefined behaviour.