Writing Assembler Code

On the RS/6000 IBM AIX operating system, TotalView lets you use assembler code in eval points, conditional breakpoints, and in the Tools > Evaluate Dialog Box. However, if you want to use assembler constructs, you must enable compiled expressions. See “About Interpreted and Compiled Expressions” for instructions.

To indicate that an expression in the breakpoint or Evaluate Dialog Box is an assembler expression, click the Assembler button in the Action Point > Properties Dialog Box.

Figure 245: Using Assembler Expressions

You write assembler expressions in the target machine’s native assembler language and in a TotalView assembler language. However, the operators available to construct expressions in instruction operands, and the set of available pseudo-operators, are the same on all machines, and are described below.

The TotalView assembler accepts instructions using the same mnemonics recognized by the native assembler, and it recognizes the same names for registers that native assemblers recognize.

Some architectures provide extended mnemonics that do not correspond exactly with machine instructions and which represent important, special cases of instructions, or provide for assembling short, commonly used sequences of instructions. The TotalView assembler recognizes mnemonics if:

They assemble to exactly one instruction.

The relationship between the operands of the extended mnemonics and the fields in the assembled instruction code is a simple one-to-one correspondence.

Assembler language labels are indicated as name: and appear at the beginning of a line. You can place a label alone on a line. The symbols you can use include labels defined in the assembler expression and all program symbols.

The TotalView assembler operators are described in the following table:

 

Operators	Description
+	Plus
–	Minus (also unary)
*	Multiplication
#	Remainder
/	Division
&	Bitwise AND
^	Bitwise XOR
!	Bitwise OR NOT (also unary minus, bitwise NOT)
|	Bitwise OR
(expr)	Grouping
<<	Left shift
>>	Right shift
“text”	Text string, 1-4 characters long, is right-justified in a 32-bit word
hi16 (expr)	Low 16 bits of operand expr
hi32 (expr)	High 32 bits of operand expr
lo16 (expr)	High 16 bits of operand expr
lo32 (expr)	Low 32 bits of operand expr

The TotalView assembler pseudo-operations are as follows:

 

Pseudo Ops	Description
$debug [ 0 | 1 ]	Internal debugging option. With no operand, toggle debugging; 0 => turn debugging off 1 => turn debugging on
$hold $holdprocess	Hold the process
$holdstopall $holdprocessstopall	Hold the process and stop the control group
$holdthread	Hold the thread
$holdthreadstop $holdthreadstopprocess	Hold the thread and stop the process
$holdthreadstopall	Hold the thread and stop the control group
$long_branch expr	Branch to location expr using a single instruction in an architecture-independent way; using registers is not required
$ptree	Internal debugging option. Print assembler tree
$stop $stopprocess	Stop the process
$stopall	Stop the control group
$stopthread	Stop the thread
name=expr	Same as def name,expr
align expr [, expr ]	Align location counter to an operand 1 alignment; use operand 2 (or 0) as the fill value for skipped bytes
ascii string	Same as string
asciz string	Zero-terminated string
bss name,size-expr[,expr]	Define name to represent size-expr bytes of storage in the bss section with alignment optional expr; the default alignment depends on the size:
	if size-expr >= 8 then 8 else if size-expr >= 4 then 4 else if size-expr >= 2 then 2 else 1
byte expr [, expr ] ...	Place expr values into a series of bytes
comm name,expr	Define name to represent expr bytes of storage in the bss section; name is declared global; alignment is as in bss without an alignment argument
data	Assemble code into data section (data)
def name,expr	Define a symbol with expr as its value
double expr [, expr ] ...	Place expr values into a series of doubles
equiv name,name	Make operand 1 an abbreviation for operand 2
fill expr, expr, expr	Fill storage with operand 1 objects of size operand 2, filled with value operand 3
float expr [, expr ] ...	Place expr values into a series of floating point numbers
global name	Declare name as global
half expr [, expr ] ...	Place expr values into a series of 16-bit words
lcomm name,expr[,expr]	Identical to bss
lsym name,expr	Same as def name,expr but allows redefinition of a previously defined name
org expr [, expr ]	Set location counter to operand 1 and set operand 2 (or 0) to fill skipped bytes
quad expr [, expr ] ...	Place expr values into a series of 64-bit words
string string	Place string into storage
text	Assemble code into text section (code)
word expr [, expr ] ...	Place expr values into a series of 32-bit words
zero expr	Fill expr bytes with zeros