This section covers problems related to variables.

I have a variable and I assign it a value, but the value does not change in the debugger.

You are not using the variable in the code. As a result, the compiler optimizes the final output file so that the variable is not used.

• Remove the unused variable from your code.
• Modify your code to use the variable.

I notice that values seem to be changing incorrectly. I encounter one of these two problems:

• Two or more variables are set to the same value simultaneously.
• One variable receives a value that is supposed to be assigned to another.

The compiler has recognized that the variables are not used concurrently, and has given the variables the same storage location. What you are seeing is a kind of automatic compiler optimization called "lifetime based register allocation," also known as "register coloring." Register coloring checks to see how variables are used in a routine. If two or more variables are in the same scope but are not used at the same time, the compiler may use the same processor register for both variables. Using registers instead of memory to store and manipulate variables improves a program's performance.

Listing 11.7 is a good example of the kind of code that results in register coloring. Because four different variables are set but never used simultaneously, the compiler has arranged for all four to use the same register. The debugger, however, has no way of knowing that all four variables share the same register, so it shows all four variables changing with each assignment.

void main(void)
{
	long a = 0, b = 0, c = 0, d = 0;

	a = 1; /* a is set to 1 */
	a = 2; /* a is set to 2, b remains unchanged */
	a = 3; /* a is set to 3, c remains unchanged */
	a = 4; /* a is set to 4, d remains unchanged */
}

• Do nothing. Register coloring is not a problem.
• To prevent register coloring in C/C++, declare your variables with the volatile keyword. Do this with a preprocessor directive so that you can easily remove the volatile storage class specifiers after debugging. See the C Compilers Reference and the Assembler Guide for more information.

The debugger shows variables in the Variables pane or Global Variables window that are not declared in the source code.

The compiler often creates its own temporary variables in the object code as it translates source code. These temporary variables have a dollar sign ($) in their names. The debugger also displays C++ virtual base class types with a $ prefix.

The compiler and linker often add variables from libraries and run-time routines that help initialize and terminate your program.

• None. This is not a problem that needs correction.

After I choose Data > Show Types, some enumerated values appears as having type "?anonx," where x is an arbitrary number.

The debugger cannot display the names of enumerated types if the names are not defined in the source code. At compile time, the compiler assigns a generic type name to such enumerated types. It is this generic name that the debugger displays.

For example, in Listing 11.8, with Show Types selected, variable myMarx appears as having the anonymous type ?anonx, because its enumerated type has no name. On the other hand, variable myBeatle appears with type Beatle, because its enumerated type is defined with that name.

// Debugger displays as anonymous type
enum {Groucho,
			Harpo,
			Chico,
			Zeppo } myMarx = Harpo;

// Debugger displays as type Beatle
typedef enum Beatle {John,
										Paul,
										George,
										Ringo} myBeatle = John;

• None. This is not a problem that needs correction.

I declared my own data type. Why can I not view a variable as that type?

The symbolics file includes information only about types that are used in the program. Types defined in typedef statements are not stored in the symbolics file, so you need to view the variable as the type from which it is derived. For example, if you declare a type MyLong based on the long data type, you can view it as a long, but not as a MyLong. For more information, refer to "Viewing data as different types".

• Use the base data type.
• Choose Data > Show Types to see how the debugger labels the type.

A user-defined type in an expression in the Expressions window gives an "· undefined identifier ·" value.

The debugger does not recognize data types that are simply aliases of another type, because such alias types are not included in the symbolics file.

For example, given the Pascal type declaration

the expression

in the Expressions window will display its value as "· undefined identifier ·." To get the correct result, use the following expression instead:

To learn more, see "Expression Limitations".

• Use the original data type instead of the defined data type.