How does a C++ compiler compile variable names? [closed]

Answer 1

It's implementation-specific.

Typically, the location of variables will be based on all sorts of factors and optimizations. They may not live in RAM at all, as they may be optimised to live entirely within registers, or optimised away entirely.

Variable names don't exist at run-time; they're discarded during compilation. However, the compiler may emit debug information that's stored in the application binary, to allow the developers to debug the application. This is usually removed in release versions, though.

I have no idea about the specifics of Gameshark. But in many cases, the location of a particular variable can be figured out by taking a look at the machine code for the application.

Answer 2

So there are two parts to this, and I'll do my best.

When compiling, a compiler will convert the C++ code into an internal representation. This is then converted into using the CPU's registers as efficiently as possible, and pushing the rest of the data into RAM. As the program executes, data from ram will get copied back and forth into registers.

On your other question, one method I've seen that people use for this is for the gold that a user has. A program could take the entire memory space of the game and copy it. Then, the user does something (a minimal action) to gain or lose gold. The external application then searches through the entire memory space for what values have changed, and what previously was the original amount of gold, and what is now the current amount of gold. Once they find this location, they are able to edit the memory location and update it with whatever value they want.

Generally, the more complicated the game is, the harder that method is.

Answer 3

Here is a simple program in C:

int main() {
    int a = 5;
    int b = 7;

    int c = a + b;

    return 0;
}

If you compile it with gcc -m32 -S -O0 -o main.s main.c under Linux, you'll get something like this

    .file   "main.c"
    .text
    .globl  main
    .type   main, @function
main:
.LFB0:
    /* %ebp is a Base Pointer Register */
    pushl   %ebp
    movl    %esp, %ebp

    /* Here we reserve space for our variables */
    subl    $16, %esp

    /* a's address is %ebp - 4 */
    movl    $5, -4(%ebp)

    /* b's address is %ebp - 8 */
    movl    $7, -8(%ebp)

    /* a + b */
    movl    -8(%ebp), %eax
    movl    -4(%ebp), %edx
    addl    %edx, %eax

    /* c's address is %ebp - 12 */
    movl    %eax, -12(%ebp)

    /* return 0 */
    movl    $0, %eax
    leave
    ret

As you can see, in this case, variables' addresses are calculated as offsets of a base pointer of a function. If you enable optimisations, variables' values may be stored in registers.