CODEWITHSUNDEEP
cmemorystackprintf
user2709465
user2709465

Reputation:

What happens to this in memory/compilation?

The code:

#include <stdio.h>

int main(int argc, char *argv[])
{
    //what happens?
    10*10;

    //what happens?
    printf("%d", 10*10);   

    return 0;
}

What happens in memory/compilation in this two lines. Does it is stored? (10*10)

Upvotes: 1

Views: 88

Answers (6)

Brian Cain
Brian Cain

Reputation: 14619

Ask your compiler! They'll probably all have an interesting answer.

Here's what gcc -c noop.c -o noop.o -g3 had to say (I ran the object code through objdump --disassemble --source to produce the output below):

#include <stdio.h>

void test_code()
{
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
    10*10;

    //what happens?
    printf("%d", 10*10);
   4:   b8 00 00 00 00          mov    $0x0,%eax
   9:   be 64 00 00 00          mov    $0x64,%esi
   e:   48 89 c7                mov    %rax,%rdi
  11:   b8 00 00 00 00          mov    $0x0,%eax
  16:   e8 00 00 00 00          callq  1b <test_code+0x1b>
}
  1b:   5d                      pop    %rbp
  1c:   c3                      retq

My compiler took the 10*10 being passed to printf and multiplied it at compile time and then used the result as an immediate ($064, aka 100 in decimal) and put it into a register to be used for printf:

mov    $0x64,%esi

The 10*10 expression not assigned to any identifier was elided. Note that it's likely possible to find some compiler somewhere that decides to execute this computation and store it in registers.

Upvotes: 2

Deduplicator
Deduplicator

Reputation: 45664

The C standard describes what the program does on an abstract machine.

But to really decide what actually happens, you need to always keep in mind one rule: The compiler must only output code with observable behavior if no constraint was violated "as if" it did what you said.
It is explicitly allowed to use any other way to achieve that result it favors.

This rule is known colloquially as the "as-if"-rule.

Thus, your program is equal to e.g:

#include <stdio.h>
int main(void) {
    fputs("100", stdout);
}

Or

#include <stdio.h>
int main(void) {
    putchar('1');
    putchar('0');
    putchar('0');
}

Upvotes: 0

brokenfoot
brokenfoot

Reputation: 11629

In the first case, since the operation is not used anywhere, the compiler may optimise your code and not execute the instruction at all.

In the second case, the value is calculated using registers (stack) and printed to the console, not stored anywhere else.

Upvotes: 0

Mahonri Moriancumer
Mahonri Moriancumer

Reputation: 6003

10*10;

Not stored. My guess is that it should give a compiler warning or error.

printf("%d", 10*10);

Should print: 100. The value of (10*10) is calculated (most likely by the compiler, not at run-time), and then sent to printf() by pushing the value (100) onto the stack. Hence, the value is stored on the stack until the original (pre-call-to-printf()) stack frame is restored upon printf()'s return.

Upvotes: 0

Gusman
Gusman

Reputation: 15151

In first question nothing, an expression like that is converted to a value by the compiler, and as you are not assigning to a variable it does nothing, the compiler removes it.

In the second one the value 100 is passed to printf.

You must note that it depends on compiler what to does, in ones tu willl be preparsed, in others will be executed the operation.

Upvotes: 0

Greg Hewgill
Greg Hewgill

Reputation: 993303

The statement

10*10;

has no effect. The compiler may choose to not generate any code at all for this statement. On the other hand,

printf("%d", 10*10);

passes the result of 10*10 to the printf function, which prints the result (100) to the standard output.

Upvotes: 5

Related Questions