50

I am using gdb to debug a C++ program.

I have this code:

int x = floor(sqrt(3));

and I want to view the value of x. However, gdb claims that x is "< optimized_out >". How do I view the value of x? Should I change my compiler flags?

dangerChihuahua007
  • 20,299
  • 35
  • 117
  • 206

5 Answers5

58

On high optimization levels, the compiler can eliminate intermediate values, as you have seen here. There are a number of options:

  • You can reduce the optimization level to make it easier for the debugger to keep track of things. -O0 is certain to work (but will be quite a lot slower), -O1 might work okay as well.
  • You can add some explicit print statements to log the output value.
  • You can also usually force the compiler to retain this specific value by making it volatile (but remember to un-make it volatile when you're done!). Note, however, that since control flow is also subject to alteration in optimized code, even if you can see the value of the variable, it may not be entirely clear what point in the code you're at when you're looking at the variable in question.
bdonlan
  • 224,562
  • 31
  • 268
  • 324
  • 4
    You can often also disassemble the function and deduce what register the "optimized out" variable really resides in, and print that variable. There are development efforts under way to make GCC emit sufficiently detailed debug info so that GDB would in the future be able to do this for you. – Employed Russian Feb 03 '12 at 05:11
  • 1
    @EmployedRussian, this can work if the variable does in fact exist, but it's possible for the actual work of computing the variable to be eliminated, so it doesn't work in all cases. – bdonlan Feb 03 '12 at 05:12
  • It's also possible for a local variable to exist in a register only. `gcc` can optimize your code to be this way - another possible cause for unviewable variables. See this answer for how to view register variables: http://stackoverflow.com/a/1354762/350875 – appas Jun 30 '15 at 23:04
  • Even with `-O0` almost every variable is "optimized out" for me with g++ / gdb. Compiling with `-g -fcoroutines -fno-inline -O0 -pthread -std=gnu++2a`. – sleep Oct 01 '21 at 05:56
18

If you can't or don't want to disable optimization, then you can try declaring the variable as volatile. This is usually enough to make your compiler preserve the variable in the final code.

Alternatively, in recent GCC versions you can disable optimization for just a function, like this:

void my_function() __attribute__((optimize(0)))
{
  int x = floor(sqrt(3));
}
Gigi
  • 4,953
  • 24
  • 25
  • 1
    For me, this attribute is undefined. When I used `optnone` instead, the variable got optimized out regardless (clang 3.8). – starturtle Aug 04 '16 at 08:18
4

When using reverse debugging, try to step back closer to the definition point of the variable

As shown at: What does <value optimized out> mean in gdb? it is often the case that within functions:

  • at the start of the function, the value of variables can be observed
  • towards the end of the function however, the variable is more and more likely to become <optimized out>, as it was stored only in a register due to optimizations, and not on memory on the stack. So when it is not needed anymore, the register is likely to be reused and overwritten by another variable, and then the debug metadata informs GDB of that.

Therefore, if you are using some kind of reverse debugging such as Mozilla rr, which you will do all the time once you try it once, then one good bet is to try and step back closer to the point of definition/last usage of the variable with reverse-finish + reverse-next and see if you can observe it there.

This can be observed concretely with the example code shown at What does <value optimized out> mean in gdb? and has saved me a few times, especially when running the unoptimized program makes it take too long to reach the point of interest (which is unsurprising given the terribly inefficient assembly generated by -O0 as seen on that answer).

Ciro Santilli OurBigBook.com
  • 347,512
  • 102
  • 1,199
  • 985
1

Create your own 'global variable' and print the optimized out variable into this global variable. Make sure to remove these globals created by you after you are done with the debugging!

Gautham Krishnan
  • 19
  • 1
0

With C++ in Visual Studio with the VisualGDB extension, I've seen class-scoped variables that are syntactically correct, but with the runtime variable inspection and hover text claiming the values are optimized out, even though they are actually not.

In order to view the value, prefixing the variable name with the class name in the quick watch or watch window resolved for me.

For example: the myvariable value that appears to be optimized out in myclass can be viewed with myclass::myvariable.

gojimmypi
  • 426
  • 4
  • 7