One major difference is the fact that the code is compiled. On a VAX system, each MACRO-32 instruction is a single machine instruction. On an Alpha system, each MACRO-32 instruction may be compiled into many Alpha machine instructions. A major side effect of this difference is the relocation and rescheduling of code if you do not specify /NOOPTIMIZE in your compile command. After you have debugged your code, you can recompile without /NOOPTIMIZE to improve performance.

C.10.4.2 Symbolic Variables

Another major difference between debugging compiled code and debugging assembled code is a new concept to MACRO--2, the definition of symbolic variables for examining routine arguments. The arguments do not reside in a vector in memory on Alpha and Integrity servers.

In the compiled code, the arguments can reside in some combination of:

• Registers
• On the stack above the routine's stack frame
• In the stack frame, if the argument list was "homed" or if there are calls out of the routine that require the register arguments to be saved.

The compiler does not require that you read the generated code to locate the arguments. Instead, it provides $ARGn symbols that point to the correct argument locations. $ARG1 is the first argument, $ARG2 is the second argument, and so forth. These symbols are defined in CALL_ENTRY and JSB_ENTRY directives, but not in EXCEPTION_ENTRY directives.

C.10.4.3 Locating Arguments Without $ARGn Symbols

There may be additional arguments in your code for which the compiler did not generate a $ARGn symbol. The number of $ARGn symbols defined for a .CALL_ENTRY routine is the maximum number detected by the compiler (either by automatic detection or as specified by MAX_ARGS) or 16, whichever is less. For a .JSB_ENTRY routine, since the arguments are homed in the caller's stack frame and the compiler cannot detect the actual number, it always creates eight $ARGn symbols.

In most cases, you can easily find any additional arguments, but in some cases you cannot.

C.10.4.4 Arguments That Are Easy to Locate

You can easily find additional arguments if:

• The argument list is not homed, and $ARGn symbols are defined to $ARG7 or higher. If the argument list is not homed, the $ARGn symbols $ARG7 and above always point into the list of parameters passed as quadwords on the stack. Subsequent arguments will be in quadwords following the last defined $ARGn symbol.
• The argument list has been homed, and you want to examine an argument that is less than or equal to the maximum number detected by the compiler (either by automatic detection or as specified by MAX_ARGS). If the argument list is homed, $ARGn symbols always point into the homed argument list. Subsequent arguments will be in longwords following the last defined $ARGn symbol.

For example, you can examine arguments beyond the eighth argument in a JSB routine (where the argument list must be homed in the caller), as follows:

DBG> EX $ARG8 ; highest defined $ARGn . . . DBG> EX .+4 ; next arg is in next longword . . . DBG> EX .+4 ; and so on

This example assumes that the caller detected at least ten arguments when homing the argument list.

To find arguments beyond the last $ARGn symbol in a routine that did not home the arguments, proceed exactly as in the previous example except substitute EX .+8 for EX .+4.

C.10.4.5 Arguments That Are Not Easy to Locate

You cannot easily find additional arguments if:

• The argument list is homed, and you want to examine arguments beyond the number detected by the compiler. The $ARGn symbols point to the longwords that are stored in the homed argument list. The compiler only moves as many arguments as it can detect into this list. Examining longwords beyond the last argument that was homed will result in examining various other stack context.
• The argument list is not homed, and $ARGn symbols are defined only as high as $ARG6. In this case, the existing $ARGn symbols will either point to registers or to quadword locations in the stack frame. In both cases, subsequent arguments cannot be examined by looking at quadword locations beyond the defined $ARGn symbols.

The only way to find the additional arguments in these cases is to examine the compiled machine code to determine where the arguments reside. Both of these problems are eliminated if MAX_ARGS is specified correctly for the maximum argument that you want to examine.

C.10.4.6 Debugging Code with Floating-Point Data

The following list provides important information about debugging compiled MACRO-32 code with floating-point data on an Alpha system:

• You can use the EXAMINE/FLOAT command to examine an Alpha integer register for a floating-point value.
  Even though there is a set of registers for floating-point operations on Alpha systems, those registers are not used by compiled MACRO-32 code that contains floating-point operations. Only the Alpha integer registers are used.
  Floating-point operations in compiled MACRO-32 code are performed by emulation routines that operate outside the compiler. Therefore, performing MACRO-32 floating-point operations on, say, R7, has no effect on Alpha floating-point register 7.
• When using the EXAMINE command to examine a location that was declared with a .FLOAT directive or other floating-point storage directives, the debugger automatically displays the value as floating-point data.
• When using the EXAMINE command to examine the G_FLOAT data type the debugger automatically displays the value as floating-point data.
• You can deposit floating-point data in an Alpha integer register with the DEPOSIT command.
• H_FLOAT is unsupported.

The following list provides important information about debugging compiled MACRO-32 code with packed decimal data on an Alpha system:

• When using the EXAMINE command to examine a location that was declared with a .PACKED directive, the debugger automatically displays the value as a packed decimal data type.
• You can deposit packed decimal data. The syntax is the same as it is on VAX.

The following subtopics describe debugger support for MACRO-64.

C.11.1 Operators in Language Expressions

Language MACRO-64 does not have expressions in the same sense as high-level languages. Only assembly-time expressions and only a limited set of operators are accepted. To permit the MACRO-64 programmer to use expressions at debug-time as freely as in other languages, the debugger accepts a number of operators in MACRO-64 language expressions that are not found in MACRO-64 itself. In particular, the debugger accepts a complete set of comparison and Boolean operators modeled after BLISS. It also accepts the indirection operator and the normal arithmetic operators.

Kind	Symbol	Function
Prefix	@	Indirection
Prefix	.	Indirection
Prefix	+	Unary plus
Prefix	-	Unary minus (negation)
Infix	+	Addition
Infix	-	Subtraction
Infix	*	Multiplication
Infix	/	Division
Infix	MOD	Remainder
Infix	@	Left shift
Infix	EQL	Equal to
Infix	EQLU	Equal to
Infix	NEQ	Not equal to
Infix	NEQU	Not equal to
Infix	GTR	Greater than
Infix	GTRU	Greater than unsigned
Infix	GEQ	Greater than or equal to
Infix	GEQU	Greater than or equal to unsigned
Infix	LSS	Less than
Infix	LSSU	Less than unsigned
Infix	LEQ	Less than or equal to
Infix	LEQU	Less than or equal to unsigned
Prefix	NOT	Bit-wise NOT
Infix	AND	Bit-wise AND
Infix	OR	Bit-wise OR
Infix	XOR	Bit-wise exclusive OR
Infix	EQV	Bit-wise equivalence

C.11.2 Constructs in Language and Address Expressions

MACRO-64 binds a data type to a label name according to the data directive that follows the label definition. For example, in the following code fragment, the .LONG data directive directs MACRO-64 to bind the longword integer data type to labels V1, V2, and V3:

.PSECT A, NOEXE .BYTE 5 V1: V2: V3: .LONG 7

To confirm the type bound to V1, V2, and V3, issue a SHOW SYMBOL/TYPE command with a V* parameter. The following display results:

data .MAIN.\V1 atomic type, longword integer, size: 4 bytes data .MAIN.\V2 atomic type, longword integer, size: 4 bytes data .MAIN.\V3 atomic type, longword integer, size: 4 bytes)

Supported MACRO-64 directives follow:

MACRO-64 Directives	Operating System Data Type Name
.BYTE	Byte Unsigned (BU)
.WORD	Word Unsigned (WU)
.LONG	Longword Unsigned (LU)
.SIGNED_BYTE	Byte Integer (B)
.SIGNED_WORD	Word Integer (W)
.LONG	Longword Integer (L)
.QUAD	Quadword Integer (Q)
.F_FLOATING	F_Floating (F)
.D_FLOATING	D_Floating (D)
.G_FLOATING	G_Floating (G)
.S_FLOATING (Alpha specific)	S_Floating (S)
.T_FLOATING (Alpha specific)	T_Floating (T)
(Not applicable)	Packed decimal (P)

C.12 Pascal

Supported Pascal operators in language expressions include:

Kind	Symbol	Function
Prefix	+	Unary plus
Prefix	-	Unary minus (negation)
Infix	+	Addition, concatenation
Infix	-	Subtraction
Infix	*	Multiplication
Infix	/	Real division
Infix	DIV	Integer division
Infix	MOD	Modulus
Infix	REM	Remainder
Infix	IN	Set membership
Infix	=	Equal to
Infix	<>	Not equal to
Infix	>	Greater than
Infix	>=	Greater than or equal to
Infix	<	Less than
Infix	<=	Less than or equal to
Prefix	NOT	Logical NOT
Infix	AND	Logical AND
Infix	OR	Logical OR

The typecast operator (::) is not supported in language expressions.

C.12.2 Constructs in Language and Address Expressions

Supported Pascal predefined symbols follow:

Symbol	Meaning
TRUE	Boolean True
FALSE	Boolean False
NIL	Nil pointer

C.12.4 Built-In Functions

Supported Pascal built-in functions follow:

Symbol	Meaning
SUCC	Logical successor
PRED	Logical predecessor

C.12.5 Data Types

Supported Pascal data types follow:

Pascal Data Type	Operating System Data Type Name
INTEGER	Longword Integer (L)
INTEGER	Word Integer (W,WU)
INTEGER	Byte Integer (B,BU)
UNSIGNED	Longword Unsigned (LU)
UNSIGNED	Word Unsigned (WU)
UNSIGNED	Byte Unsigned (BU)
SINGLE, REAL	F_Floating (F)
REAL (Alpha and Integrity servers specific)	IEEE S_Floating (FS)
DOUBLE	D_Floating (D)
DOUBLE	G_Floating (G)
DOUBLE (Alpha and Integrity servers specific)	IEEE T_Floating (FT)
QUADRUPLE (Integrity servers specific)	H_Floating (H)
BOOLEAN	(None)
CHAR	ASCII Text (T)
VARYING OF CHAR	Varying Text (VT)
SET	(None)
FILE	(None)
Enumerations	(None)
Subranges	(None)
Typed Pointers	(None)
Arrays	(None)
Records	(None)
Variant records	(None)

The debugger accepts Pascal set constants such as [1,2,5,8..10] or [RED, BLUE] in Pascal language expressions.

Floating-point numbers of type REAL may be represented by F_Floating or IEEE S_Floating, depending on compiler switches or source code attributes.

Floating-point numbers of type DOUBLE may be represented by D_Floating, G_Floating, or IEEE T_Floating, depending on compiler switches or source code attributes.

C.12.6 Additional Information

In general, you can examine, evaluate, and deposit into variables, record fields, and array components. An exception to this occurs under the following circumstances: if a variable is not referenced in a program, the Pascal compiler might not allocate the variable. If the variable is not allocated and you try to examine it or deposit into it, you will receive an error message.

When you deposit data into a variable, the debugger truncates the high-order bits if the value being deposited is larger than the variable; the debugger fills the high-order bits with zeros if the value being deposited is smaller than the variable. If the deposit violates the rules of assignment compatibility, the debugger displays an informational message.

You can examine and deposit into automatic variables (within any active block); however, because automatic variables are allocated in stack storage and are contained in registers, their values are considered undefined until the variables are initialized or assigned a value.

C.12.7 Restrictions

You can examine a VARYING OF CHAR string, but you cannot examine the .LENGTH or .BODY fields using the normal language syntax. For example, if VARS is the name of a string variable, the following commands are not supported:

DBG> EXAMINE VARS.LENGTH DBG> EXAMINE VARS.BODY

To examine these fields, use the techniques illustrated in the following examples.

Use	Instead of
EXAMINE/WORD VARS	EXAMINE VARS.LENGTH
EXAMINE/ASCII VARS+2	EXAMINE VARS.BODY

C.13 PL/I (Alpha Only)

The following subtopics describe debugger support for PL/I.

C.13.1 Operators in Language Expressions

Supported PL/I operators in language expressions include:

Kind	Symbol	Function
Prefix	+	Unary plus
Prefix	-	Unary minus (negation)
Infix	+	Addition
Infix	-	Subtraction
Infix	*	Multiplication
Infix	/	Division
Infix	**	Exponentiation
Infix	||	Concatenation
Infix	=	Equal to
Infix	^=	Not equal to
Infix	>	Greater than
Infix	>=	Greater than or equal to
Infix	^<	Greater than or equal to
Infix	<	Less than
Infix	<=	Less than or equal to
Infix	^>	Less than or equal to
Prefix	^	Bit-wise NOT
Infix	&	Bit-wise AND
Infix	|	Bit-wise OR