CODEWITHSUNDEEP
cgccoptimization
Makogan
Makogan

Reputation: 9540

Is it possible to disable gcc/g++ optimisations for specific sections of code?

I am compiling some code that works without optimisation but breaks with optimisations enabled. I suspect certain critical sections of the code of being optimised out, resulting in the logic breaking.

I want to do something like:

code...

#disable opt

more code...

#enable opt

Even better if I can set the level of optimisation for that section (like O0, O1...)

For those suggesting it is the code:

The section of the code being deleted is (checked by disassembling the object file):

void wait(uint32_t time)
{
  while (time > 0) {
    time--;
  }
}

I seriously doubt there is something wrong with that code

Upvotes: 2

Views: 4654

Answers (3)

ScottK
ScottK

Reputation: 1556

If optimization causes your program to crash, then you have a bug and should fix it. Hiding the problem by not optimizing this portion of code is poor practice that will leave your code fragile, and its like leaving a landmine for the next developer who supports your code. Worse, by ignoring it, you will not learn how to debug these problems.

Some Possible Root Causes:

Hardware Accesses being optimized out: Use Volatile It is unlikely that critical code is being optimized out, although if you are touching hardware registers then you should add the volatile attribute to force the compiler to access those registers regardless of the optimization settings.

Race Condition: Use a Mutex or Semaphore to control access to shared data It is more likely that you have a race condition that is timing specific, and the optimization causes this timing condition to show itself. That is a good thing, because it means you can fix it. Do you have multiple threads or processes that access the same hardware or shared data? You might need to add a mutex or semaphore to control access to avoid timing problems.

Heisenbug: This is when the behavior of code changes based on whether or not debug statements are added, or whether the code is optimized or not. There is a nice example here where the optimized code does floating point comparisons in registers in high precision, but when printf's are added, then the values are stored as doubles and compared with less precision. This resulted in the code failing one way, but not the other. Perhaps that will give you some ideas.

Timing Loop gets Optimized Out: Creating a wait function that works by creating a timing loop that increments a local variable in order to add a delay is not good programming style. Such loops can be completely optimized out based on the compiler and optimization settings. In addition, the amount of delay will change if you move to a different processor. Delay functions should work based on CPU ticks or real-time, which will not get optimized out. Have the delay function use the CPU clock, or a real time clock, or call a standard function such as nanosleep() or use a select with a timeout. Note that if you are using a CPU tick, be sure to comment the function well and highlight that the implementation needs to be target specific.

Bottom line: As others have suggested, place the suspect code in a separate file and compile that single source file without optimization. Test it to ensure it works, then migrate half the code back into the original, and retest with half the code optimized and half not, to determine where your bug is. Once you know which half has the Heisenbug, use divide and conquer to repeat the process until you identify the smallest portion of code that fails when optimized.

If you can find the bug at that point, great. Otherwise post that fragment here so we can help debug it. Provide the compiler optmization flags used to cause it to fail when optimized.

Upvotes: 7

Jonathan Leffler
Jonathan Leffler

Reputation: 753455

You can poke around the GCC documentation. For example:

  • Function specific option pragmas

    #pragma GCC optimize ("string"...)

    This pragma allows you to set global optimization options for functions defined later in the source file. One or more strings can be specified. Each function that is defined after this point is as if attribute((optimize("STRING"))) was specified for that function. The parenthesis around the options is optional. See Function Attributes, for more information about the optimize attribute and the attribute syntax.

    See also the pragmas for push_options, pop_options and reset_options.

  • Common function attributes

    optimize The optimize attribute is used to specify that a function is to be compiled with different optimization options than specified on the command line. Arguments can either be numbers or strings. Numbers are assumed to be an optimization level. Strings that begin with O are assumed to be an optimization option, while other options are assumed to be used with a -f prefix. You can also use the '#pragma GCC optimize' pragma to set the optimization options that affect more than one function. See Function Specific Option Pragmas, for details about the '#pragma GCC optimize' pragma.

    This attribute should be used for debugging purposes only. It is not suitable in production code.

  • Optimize options

    This page lists a lot of optimization options that can be used with the -f option on the command line, and hence with the optimize attribute and/or pragma.

Upvotes: 3

John Zwinck
John Zwinck

Reputation: 249093

The best thing you can do is to move the code you do not want optimized into a separate source file. Compile that without optimization, and link it against the rest of your code.

With GCC you can also declare a function with __attribute__((optimize("O0")) to inhibit optimization.

Upvotes: 2

Related Questions