Performance difference of “if if” vs “if else if”

by

Assuming simple types (in this case, I used int) and no funny business (didn’t redefine operator= for int), at least with GCC 4.6 on AMD64, there is no difference. The generated code is identical:

0000000000000000 <case_1>:                                   0000000000000040 <case_2>:
   0:   85 ff                   test   %edi,%edi               40:   85 ff                   test   %edi,%edi
   2:   74 14                   je     18 <case_1+0x18>        42:   74 14                   je     58 <case_2+0x18>
   4:   83 ff 01                cmp    $0x1,%edi               44:   83 ff 01                cmp    $0x1,%edi
   7:   74 27                   je     30 <case_1+0x30>        47:   74 27                   je     70 <case_2+0x30>
   9:   83 ff 02                cmp    $0x2,%edi               49:   83 ff 02                cmp    $0x2,%edi
   c:   74 12                   je     20 <case_1+0x20>        4c:   74 12                   je     60 <case_2+0x20>
   e:   66 90                   xchg   %ax,%ax                 4e:   66 90                   xchg   %ax,%ax
  10:   f3 c3                   repz retq                      50:   f3 c3                   repz retq 
  12:   66 0f 1f 44 00 00       nopw   0x0(%rax,%rax,1)        52:   66 0f 1f 44 00 00       nopw   0x0(%rax,%rax,1)
  18:   31 c0                   xor    %eax,%eax               58:   31 c0                   xor    %eax,%eax
  1a:   e9 00 00 00 00          jmpq   1f <case_1+0x1f>        5a:   e9 00 00 00 00          jmpq   5f <case_2+0x1f>
  1f:   90                      nop                            5f:   90                      nop
  20:   31 c0                   xor    %eax,%eax               60:   31 c0                   xor    %eax,%eax
  22:   e9 00 00 00 00          jmpq   27 <case_1+0x27>        62:   e9 00 00 00 00          jmpq   67 <case_2+0x27>
  27:   66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)        67:   66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
  2e:   00 00                                                  6e:   00 00 
  30:   31 c0                   xor    %eax,%eax               70:   31 c0                   xor    %eax,%eax
  32:   e9 00 00 00 00          jmpq   37 <case_1+0x37>        72:   e9 00 00 00 00          jmpq   77 <case_2+0x37>
  37:   66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
  3e:   00 00

The extra instruction at the end of case_1 is just for padding (to get the next function aligned).

This isn’t really surprising, figuring out that p isn’t changed in that function is fairly basic optimization. If p could be changed (e.g., passed-by-reference or pointer to the various do_… functions, or was a reference or pointer itself, so there could be an alias) then the behavior is different, and of course the generated code would be too.

More Related Contents:

  1. What does [&] in the declaration of [&](Type& variable) mean? [duplicate]
  2. What is the effect of extern “C” in C++?
  3. Where and why do I have to put the “template” and “typename” keywords?
  4. Initialization of all elements of an array to one default value in C++?
  5. Timer function to provide time in nano seconds using C++
  6. When does a constexpr function get evaluated at compile time?
  7. Why do C++11-deleted functions participate in overload resolution?
  8. Benefits of Initialization lists
  9. How do I calculate the week number given a date?
  10. boost_1_60_0 .zip installation in windows
  11. How do I avoid implicit conversions on non-constructing functions?
  12. Disambiguate class-member in multiple inheritance
  13. Converting multidimensional arrays to pointers in c++
  14. how to dynamically declare an array of objects with a constructor in c++
  15. How to get current timestamp in milliseconds since 1970 just the way Java gets
  16. C/C++ function definitions without assembly
  17. Debugging template instantiations
  18. So can unique_ptr be used safely in stl collections?
  19. What issues can I expect compiling C code with a C++ compiler?
  20. error: passing ‘const …’ as ‘this’ argument of ‘…’ discards qualifiers
  21. Vary range of uniform_int_distribution
  22. Convert char array to single int?
  23. Why can you add an integer to a string literal?
  24. boost::property_tree XML pretty printing
  25. Dangling references and undefined behavior
  26. How to initialize a struct to 0 in C++
  27. Differences between running an executable with Visual Studio debugger vs without debugger
  28. Is there a case where including the same header twice is actually helpful?
  29. Undefined reference error with new filesystem library and clang++7
  30. popen equivalent in c++

Leave a Comment