unexpected value of the variable after code conversion

Question

I'm trying to convert code from C++ to ASM based on AT&T code to convert:

void func() {
    int num = 1;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
                       /* code to swap */
            std::cout <<"before: " << num;
            num = num << 3;
            std::cout << " after: " << num << std::endl;
                      /* end code to swap */
        }
    }
}

After the change the code looks like this:

void func() {
    int num = 1;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            std::cout <<"before: " << num;
            asm (
                "mov -4(%rbp), %eax \n"
                "sall $3, %eax \n"
                "mov %eax, -4(%rbp) \n"
            );
            std::cout << " after: " << num << std::endl;
        }
    }
}

The same example without the use of both loops works correctly, but when you add them, it does not work anymore. While 1 example gives correct results, the second code after changing the code prints only number 1, I assume that after adding 2 loops, the location of the variable changes from -4(%rbp) to another address.

My assumptions:

int num is in  -4(%rbp)
int i is in -8(%rbp)
int j is in -12(%rbp)

Im using GCC Compiler with Dev C++

Answer 1

Well, on godbolt your code "seems" to be running correctly. However, what you are doing is undefined behavior: the code will break if something changes in the environment. You should use proper (extended) GCC assembly that refers to local variables.

void func() {
    int num = 1;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            std::cout <<"before: " << num;
            asm (
                "sal $3, %[num];"
                :[num] "+r" (num)
            );
            std::cout << " after: " << num << std::endl;
        }
    }
}

i.e. you directly use (num) as an input-output register +r and assign it a label [num]. You then only have to run the shift arithmetic left command (not necessary to add the 'l') which uses that register and writes back to it.

Answer 2

I'm not familiar with AT&T code you are referring to. It seems to be your motivation for doing this. In general, hand coding ASM is avoided for general functions like this. ASM is incredibly error prone.

That said, since the compiler is free to store the local variables anywhere it wants the code as written likely won't work. The compiler may provide syntax to solve this. But it would be entirely compiler specific. I believe Visual Studio compilers do, but I haven't written a line of assembly language in at least 10 years.

If the goal is performance, generally introducing a three instruction assembly language change won't improve performance. Unless of course the compiler is not very good at optimization. Though there are exceptions I suppose for instructions looping over large data sets in parallel. But personally I'll let the compiler developers figure out how to implement those reliably.

Of course, if the goal is learning about doing things like this. Then that's cool, many new devs now days don't really understand what the language is doing at the assembly language level. If that's the case then take a look at this link. If it applies to your compiler it should allow you to have the compiler pre-position the items you need in the registers you want. GNU GCC Asm

Answer 3

Your assumptions are most likely wrong, the compiler is free to order those variables in the stack frame in any way it wants (and even not put them in the stack frame in some cases).

Assuming you want to use assembler code, you should be able to find the actual location of num by putting num++ in you code and seeing what the compiler generates.

However, keep in mind this freedom the compiler has also extends to the freedom to change its mind based on your code changes, or even the phase of the moon or what time of the day you decide to compile your code :-) That means it may be at a different in your checking code than it is in your non-checking code.

---

For example, entering this code into godbolt using x86-64 gcc 10.2:

void func() {
    int num = 42;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 2; j++)
            asm (
                "mov -4(%rbp), %eax \n"
                "sall $3, %eax \n"
                "mov %eax, -4(%rbp) \n"
            );
}

starts off with num being at -12(%rbp):

pushq   %rbp
movq    %rsp, %rbp
movl    $42, -12(%rbp)

When you comment out the outer loop and then the inner loop, it moves (respectively) to -8(%rbp) and -4(%rbp).

Now there are certainly ways in which you can get the correct address of a C variable into your assembler code but, like asm itself, they're not necessarily portable. If you really want to have full control over where things are located, you may want to consider writing your code in assembler fully.

But, to be honest, I can't really see what you're gaining by doing so in this case. Other than education, possibly, which you're certainly getting with these issues :-)