Is x += 1 more efficient than x = x + 1?

by

Just to give you a “real-world” example, consider this program:

int main()
{
    int i = 0;
    i += 1;
    i++;
    i = i + 1;
    return 0;
}

Compiling it with GCC, in Darwin 11 with the following flags:

  • -S stop in assembler
  • -m32 to 32-bit platform, just to simplify things a bit

Will generate the following program, except for the comments and blank lines which I added. Take a look specially in the comments.

        .section        __TEXT,__text,regular,pure_instructions
        .globl  _main
        .align  4, 0x90
_main:
        pushl   %ebp              # cdecl function stuff
        movl    %esp, %ebp        #
        subl    $12, %esp         # get room for variables    
        movl    $0, -12(%ebp)     # i = 0;

        ; i += 1
        movl    -12(%ebp), %eax   # load i in register a
        addl    $1, %eax          # add 1 to register a
        movl    %eax, -12(%ebp)   # store it back in memory

        ; i++
        movl    -12(%ebp), %eax   #
        addl    $1, %eax          # just the same
        movl    %eax, -12(%ebp)   #

        ; i = i + 1
        movl    -12(%ebp), %eax   #
        addl    $1, %eax          # just the same
        movl    %eax, -12(%ebp)   #

        movl    $0, -8(%ebp)
        movl    -8(%ebp), %eax
        movl    %eax, -4(%ebp)
        movl    -4(%ebp), %eax
        addl    $12, %esp
        popl    %ebp
        ret

.subsections_via_symbols

More Related Contents:

  1. Difference between pre- and postfix incrementation in C (++a and a++) [duplicate]
  2. optimized sum of an array of doubles in C [duplicate]
  3. Improve INSERT-per-second performance of SQLite
  4. Why are these constructs using pre and post-increment undefined behavior?
  5. Why does the order of the loops affect performance when iterating over a 2D array?
  6. Trying to understand gcc option -fomit-frame-pointer
  7. Why is this code using strlen heavily 6.5x slower with GCC optimizations enabled?
  8. Matrix multiplication: Small difference in matrix size, large difference in timings
  9. Which ordering of nested loops for iterating over a 2D array is more efficient [duplicate]
  10. Is it faster to count down than it is to count up?
  11. What is the fastest way to swap values in C?
  12. Loop with function call faster than an empty loop
  13. Why vectorizing the loop does not have performance improvement
  14. Pointer Arithmetic: ++*ptr or *ptr++?
  15. How to do unsigned saturating addition in C?
  16. Efficient 4×4 matrix vector multiplication with SSE: horizontal add and dot product – what’s the point?
  17. No performance gain after using openMP on a program optimize for sequential running
  18. Output of multiple post and pre increments in one statement [duplicate]
  19. When is assembly faster than C? [closed]
  20. AVX/SSE version of xorshift128+
  21. Why is memcmp so much faster than a for loop check?
  22. How does the CPU cache affect the performance of a C program
  23. why does GCC __builtin_prefetch not improve performance?
  24. Concatenating strings in C, which method is more efficient?
  25. faster alternative to memcpy?
  26. Algorithm to find all the exact divisors of a given integer
  27. Which is better way to calculate nCr
  28. Faster approach to checking for an all-zero buffer in C?
  29. Performance: memset
  30. Why vectorizing the loop over 64-bit elements does not have performance improvement over large buffers?

Leave a Comment