Why do I get multiple ASM instructions per addition? (Visual Studio 2022 Community)

Question

Here's the C program, I use Visual Studio Community 2022 with MSVC compiler. What are all those mov instructions, I don't use any compiler optimization flags.

#include <stdio.h>
int main(void) {
    int a = 11;
    int b = 13;
    a += b;
    a += 15;
    a += 17;
    a += 23;
    return 0;
}

Here's the disassembly view of the running program.

    int a = 11;
00007FF75AB9175D  mov         dword ptr [a],0Bh  
    int b = 13;
00007FF75AB91764  mov         dword ptr [b],0Dh  
    a += b;
00007FF75AB9176B  mov         eax,dword ptr [b]  
00007FF75AB9176E  mov         ecx,dword ptr [a]  
00007FF75AB91771  add         ecx,eax  
00007FF75AB91773  mov         eax,ecx  
00007FF75AB91775  mov         dword ptr [a],eax  
    a += 15;
00007FF75AB91778  mov         eax,dword ptr [a]  
00007FF75AB9177B  add         eax,0Fh  
00007FF75AB9177E  mov         dword ptr [a],eax  
    a += 17;
00007FF75AB91781  mov         eax,dword ptr [a]  
00007FF75AB91784  add         eax,11h  
00007FF75AB91787  mov         dword ptr [a],eax  
    a += 23;
00007FF75AB9178A  mov         eax,dword ptr [a]  
00007FF75AB9178D  add         eax,17h  
00007FF75AB91790  mov         dword ptr [a],eax 

Answer 1

Why do I get multiple ASM instructions per addition?

The generated assembly does not have multiple instructions per addition. For the most part, it has one instruction per C “operation.”

The statement a += 15; does not just say to add 15. First, a += 15 is defined to be the same as a = a + 15 (except the location for a is determined only once).¹ Then, the specifications of the C standard say these operations will be performed:

• For the a in a + 15, the value of a will be fetched from memory.²
• For the +, the value of a and 15 will be added.³
• For a =, the value resulting from the + will be stored in a.⁴

That is effectively a load, an add, and a store, which is exactly what we see in the generated assembly:

mov         eax,dword ptr [a]  //  Load the value of a.
add         eax,0Fh            //  Add the value of a and 15.
mov         dword ptr [a],eax  //  Store the new value into a.

Footnotes

¹ This is specified in C 2018 6.5.16.2 3: “A compound assignment of the form E1 op= E2 is equivalent to the simple assignment expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once,…”

² C 2018 6.3.2.1 2: “Except when it is the operand of the sizeof operator, the unary & operator, the ++ operator, the -- operator, or the left operand of the . operator or an assignment operator, an lvalue that does not have array type is converted to the value stored in the designated object (and is no longer an lvalue); this is called lvalue conversion.

³ C 2018 6.5.6 5: “The result of the binary + operator is the sum of the operands.”

⁴ C 2018 C 6.5.16.1 2: “In simple assignment (=), the value of the right operand is converted to the type of the assignment expression and replaces the value stored in the object designated by the left operand.”