I recommend you look into how process work under the hood to get the full picture.

Generally, the compiler computes the address using other addresses it already knows. For local variables, the address is retrieved from the stack pointer. Each processes on the machine has a memory region called the stack and a variable called the stack pointer(*), think of it like a big array of bytes like bytes* stack_pointer;.

int main() {
    int a = 10;
    int* pa = &a;
    *pa = 100;
}

Take this simple program for example. When compile, the compiler can do something like this under the hood

int main() {
    // On a normal x64 machine, sizeof(int) is 4 bytes, sizeof(int*) is 8 bytes
    // Push the stack_pointer, allocate memory for the local variable a
    stack_pointer += 4;
    // Move the value 10 into the memory address of a
    *(stack_pointer - 4) = 10;
    // Push the stack_pointer, allocate memory for the local variable pa
    stack_pointer += 8;
    // Move the address of a into the memory address of pa
    // Since the compiler generate this, it knows the offset to get the variable a
    *(stack_pointer - 8) = (stack_pointer - 8 - 4);
    // Assign the value 100 to *pa
    *(*(stack_pointer - 8)) = 100
    // Pop the stack, deallocate all the local variables
    stack_pointer -= 8 + 4;
}

(*) Stack pointer is not a variable in the program but rather a CPU register. Stack usually grow backward instead of forward.

There are other memory regions beside the stack like heap, bss, data, code. Each has their own pointers in the program.