What is the difference between debug and release, of a project

Optimization Level

Stack Checking

Asserts

Verbose Diagnostics

Additional symbolic and line numbering information in objects

Stuff that would tend to aid debugging and testing phases of the software/hardware

it is whatever you configure it to be!

@TDK​  and @Community member​  have given you some typical examples.

Quite complete answers already provided by community. Just a few more points.

Default optimization levels in GCC for the configurations:

• Debug --> Optimization off -O0
• Release --> Optimize for size -Os

If you run low on memory when using "Debug" due to -O0, then you could switch this configuration to rely on -Og which introduces optimization that should not disturb the debug experience.

There are also different philosophies on addressing optimization levels in build configurations.

Some developers thinks that Release and Debug should have as similar optimization related settings as possible in order to make sure that you "debug what you ship and ship what you debug".

Why would that example "break", and why would it behave differently at -O0?

JW

PS. For reference, this is the code under the link:

extern void error();

typedef enum { S0 = 3, S1 = 13 } T;

bool f()
{
 static T state = S0;

 switch ( state )
 {
 case S0: state = S1; break;
 case S1: state = S0; break;
 default: error(); break;
 }
// return state == S1;
}

Oh, it's C++, not C.

Language matters, too.

JW

> For example, the unreachable code has no effect when the example is compiled as C using GCC, but it does when compiling under Clang (the default is optimised out).

There is no unreachable code in C, enum specifiers (i.e. the type generated from the enum, not the individual enum symbols/constants) are compatible with int (more precisely, with some of char, signed integer or unsigned integer type, by compiler's choice, C99 6.7.2.2#4), so they can take any value within that type, not just the enumerated values (C99 6.3#2, "Conversion of an operand value to a compatible type causes no change to the value or the representation.")

This is one of the many minor but important differences between C and C++ (the other in this example is treatment of no-return-from-function-with-non-void-return-type).

I wonder what were the conditions under which Clang optimized out the default.

I tried in goldbolt, and indeed, Clang set to C removes that branch with -O2 even with -fno-strict-enums. IMO that's a flaw and I'd like to hear the author's rationale for this.

JW

Oh.

Now I see.

I've seen

static T state = 50;

which would indeed some sort of violation in C++ and perfectly OK in C.

::blushing::

Sorry for the confusion.

Your explanation is then perfectly valid and yes, the default branch can be optimized out, together with the error() call and, consequently, if there's nothing else to call error(), that function can be eliminated too.

In fact, as state is static (i.e. not visible outside f()), and there are no side effects (as it's not volatile), both this variable and thus the whole f() function can be optimized out.

JW