Is RVO (Return Value Optimization) applicable for all objects?

by

Return Value Optimization can always be applied, what cannot be universally applied is Named Return Value Optimization. Basically, for the optimization to take place, the compiler must know what object is going to be returned at the place where the object is constructed.

In the case of RVO (where a temporary is returned) that condition is trivially met: the object is constructed in the return statement, and well, it is returned.

In the case of NRVO, you would have to analyze the code to understand whether the compiler can know or not that information. If the analysis of the function is simple, chances are that the compiler will optimize it (single return statement that does not contain a conditional, for example; multiple return statements of the same object; multiple return statements like T f() { if (condition) { T r; return r; } else { T r2; return r2; } } where the compiler knows that r or r2 will be returned…)

Note that you can only assume the optimization in simple cases, specifically, the example in wikipedia could actually be optimized by a smart enough compiler:

std::string f( bool x ) {
   std::string a("a"), b("b");
   if ( x ) return a; 
   else return b;
}

Can be rewritten by the compiler into:

std::string f( bool x ) {
   if ( x ) {
      std::string a("a"), b("b");
      return a;
   } else {
      std::string a("a"), b("b");
      return b;
   }
}

And the compiler can know at this time that in the first branch a is to be constructed in place of the returned object, and in the second branch the same applies to b. But I would not count on that. If the code is complex, assume that the compiler will not be able to produce the optimization.

EDIT: There is one case that I have not mentioned explicitly, the compiler is not allowed (in most cases even if it was allowed, it could not possibly do it) to optimize away the copy from an argument to the function to the return statement:

T f( T value ) { return value; } // Cannot be optimized away --but can be converted into
                                 // a move operation if available.

More Related Contents:

  1. gcc optimization flag -O3 makes code slower than -O2
  2. Is the compiler allowed to optimize out heap memory allocations?
  3. __builtin_prefetch, How much does it read?
  4. GCC C++ “Hello World” program -> .exe is 500kb big when compiled on Windows. How can I reduce its size?
  5. Does a c/c++ compiler optimize constant divisions by power-of-two value into shifts?
  6. Does GCC inline C++ functions without the ‘inline’ keyword?
  7. List of common C++ Optimization Techniques [closed]
  8. How to overload std::swap()
  9. How exactly does __attribute__((constructor)) work?
  10. Why does integer overflow on x86 with GCC cause an infinite loop?
  11. Capturing function exit time with __gnu_mcount_nc
  12. Why is my program slow when looping over exactly 8192 elements?
  13. Virtual functions and performance – C++
  14. How to prevent GCC from optimizing out a busy wait loop?
  15. GCC STL bound checking
  16. undefined reference to `__stack_chk_fail’
  17. Update GCC on OSX
  18. error: use of deleted function
  19. Linking problems due to symbols with abi::cxx11?
  20. RDRAND and RDSEED intrinsics on various compilers?
  21. How to enable experimental C++11 concurrency features in MinGW?
  22. C++ : friend declaration ‘declares a non-template function
  23. Can I link a plain file into my executable? [duplicate]
  24. What does -fPIC mean when building a shared library?
  25. Static and Dynamic/Shared Linking with MinGW
  26. Skip some arguments in a C++ function?
  27. Can I hint the optimizer by giving the range of an integer?
  28. What does exactly the warning mean about hidden symbol being referenced by DSO?
  29. C++ static initialization vs __attribute__((constructor))
  30. GCC std::thread not found in namespace std

Leave a Comment