Chapter 5

Instruction-Set Mapping

The tables in this chapter describe the relationship between hardware instructions of the SPARC architecture, as defined in The SPARC Architecture Manual and the assembly language instruction set recognized by the SunOS 5.x SPARC assembler.

The SPARC-V9 instruction set is described in Appendix E, SPARC-V9 Instruction Set.

5.1 Table Notation

Table 5-1 shows the table notation used in this chapter to describe the instruction set of the assembler. The following notations are commonly suffixed to assembler mnemonics (uppercase letters refer to SPARC architecture instruction names.

Table 5-1

Notations	Describes	Comment
`address`	`reg_rs1 + reg_rs2` `reg_rs1 + const13` `reg_rs1 - const13` `const13 + reg_rs1` `const13`	Address formed from register contents, immediate constant, or both.
`asi`		Alternate address space identifier; an unsigned 8-bit value. It can be the result of the evaluation of a symbol expression.
`const13`		A signed constant which fits in 13 bits. It can be the result of the evaluation of a symbol expression.
`const22`		A constant which fits in 22 bits. It can be the result of the evaluation of a symbol expression.
`creg`	`%c0 ... %c31`	Coprocessor registers.
`freg`	`%f0 ... %f31`	Floating-point registers.
`imm7`		A signed or unsigned constant that can be represented in 7 bits (it is in the range -64 ... 127). It can be the result of the evaluation of a symbol expression.
`reg`	`%r0 ... %r31`	General purpose registers.
	`%g0 ... %g7`	Same as `%r0 ... %r7` (Globals)
	`%o0 ... %o7`	Same as `%r8 ... %r15` (Outs)
	`%l0 ... %l7`	Same as `%r16 ... %r23` (Locals)
	`%i0 ... %i7`	Same as `%r24 ... %r31` (Ins)
`reg`_rd		Destination register.
`reg`_rs1`, reg`_rs2		Source register 1, source register 2.
`reg_or_imm`	`reg`_rs2`, const13`	Value from either a single register, or an immediate constant.
`regaddr`	`reg`_rs1 `reg`_rs1 `+ reg`_rs2	Address formed with register contents only.
`Software_trap_number`	`reg_rs1 + reg_rs2` `reg_rs1 + imm7` `reg_rs1 - imm7` `uimm7` `imm7 + reg_rs1`	A value formed from register contents, immediate constant, or both. The resulting value must be in the range 0.....127, inclusive.
`uimm7`		An unsigned constant that can be represented in 7 bits (it is in the range 0 ... 127). It can be the result of the evaluation of a symbol expression.

5.2 Integer Instructions

The notations described in Table 5-2 are commonly suffixed to assembler mnemonics (uppercase letters for architecture instruction names).

Table 5-2

Notation	Description
`a`	Instructions that deal with alternate space
`b`	Byte instructions
`c`	Reference to coprocessor registers
`d`	Doubleword instructions
`f`	Reference to floating-point registers
`h`	Halfword instructions
`q`	Quadword instructions
`sr`	Status register

Table 5-3 outlines the correspondence between SPARC hardware integer instructions and SPARC assembly language instructions.

The syntax of individual instructions is designed so that a destination operand (if any), which may be either a register or a reference to a memory location, is always the last operand in a statement.

Note - In Table 5-3,

Braces ({ }) indicate optional arguments.

Braces are not literally coded.
Brackets ([ ]) indicate indirection: the contents of the addressed memory location are being read from or written to.

Brackets are coded literally in the assembly language. Note that the usage of brackets described in Chapter 2, Assembler Syntax differs from the usage of these brackets.
All Bicc and Bfcc instructions described may indicate that the annul bit is to be set by appending ",a" to the opcode mnemonic; for example,

"bgeu,a label"

Table 5-3

Opcode	Mnemonic	Argument List	Operation	Comments
`ADD`	`add`	reg_rs1, reg_or_imm, reg_rd	Add
`ADDcc`	`addcc`	reg_rs1, reg_or_imm, reg_rd	Add and modify `icc`
`ADDX`	`addx`	reg_rs1, reg_or_imm, reg_rd	Add with carry
`ADDXcc`	`addxcc`	reg_rs1, reg_or_imm, reg_rd
`AND`	`and`	reg_rs1, reg_or_imm, reg_rd	And
`ANDcc`	`andcc`	reg_rs1, reg_or_imm, reg_rd
`ANDcc`	`andn`	reg_rs1, reg_or_imm, reg_rd
`ANDNcc`	`andcc`	reg_rs1, reg_or_imm, reg_rd
`BN`	`bn{,a}`	`label`	Branch on integer condition codes	branch never
`BNE`	`bne{,a}`	`label`		synonym: `bnz`
`BE` `BG` `BLE` `BGE` `BI` `BGU` `BLEU`	`be{,a}` `bg{,a}` `ble{,a}` `bge{,a}` `bl{,a}` `bgu{,a}` `bleu{,a}`	`label` `label` `label` `label` `label` `label` `label`		synonym: `bz`
`BCC`	`bcc{,a}`	`label`		synonym: `bgeu`
`BCS` `BPOS` `BNEG` `BVC` `BVS`	`bcs{,a}` `bpos{,a}` `bneg{,a}` `bvc{,a}` `bvs{,a}`	`label` `label` `label` `label` `label`		synonym: `blu`
`BA`	`ba{,a}`	`label`		synonym: `b`
`CALL`	`call`	`label`	Call subprogram
`CBccc`	`cbn{,a}` `cb3{,a}` `cb2{,a}` `cb23{,a}` `cb1{,a}` `cb13{,eo}` `cb12{,a}` `cb123{,a}` `cb0{,a}` `cb03{,a}` `cb02{,a}` `cb023{,a}` `cb01{,a}` `cb013{,a}` `cb012{,a}` `cba{,a}`	`label` `label` `label` `label` `label` `label` `label` `label` `label` `label` `label` `label` `label` `label` `label` `label`	Branch on coprocessor condition codes	branch never
`FBN` `FBU` `FBG` `FBUG` `FBL` `FBUL` `FBLG`	`fbn{,a}` `fbu{,a}` `fbg{,a}` `fbug{,a}` `fbl{,a}` `fbul{,a}` `fblg{,a}`	`label` `label` `label` `label` `label` `label` `label`	Branch on floating-point condition codes	branch never
`FBNE`	`fbne{,a}`	`label`		synonym: `fbnz`
`FBE`	`fbe{,a}`	`label`		synonym: `fbz`
`FBUE` `FBGE` `FBUGE` `FBLE` `FBULE` `FBO` `FBA`	`fbue{,a}` `fbge{,a}` `fbuge{,a}` `fble{,a}` `fbule{,a}` `fbo{,a}` `fba{,a}`	`label` `label` `label` `label` `label` `label` `label`
`FLUSH`	`flush`	address	Instruction cache flush
`JMPL`	`jmpl`	address, reg_rd	Jump and link
`LDSB`	`ldsb`	[address], reg_rd	Load signed byte
`LDSH`	`ldsh`	[address], reg_rd	Load signed halfword
`LDSTUB`	`ldstub`	[address], reg_rd	Load-store unsigned byte
`LDUB`	`ldub`	[address], reg_rd	Load unsigned byte
`LDUH`	`lduh`	[address], reg_rd	Load unsigned halfword
`LD`	`ld`	[address], reg_rd	Load word
`LDD`	`ldd`	[address], reg_rd	Load double word	reg_rd must be even
`LDF`	`ld`	[address], freg_rd
`LDFSR`	`ld`	[address], %fsr	Load floating-point register
`LDDF`	`ldd`	[address], freg_rd	Load double floating-point	freg_rd must be even
`LDC`	`ld`	[address], creg_rd	Load coprocessor
`LDCSR`	`ld`	[address], %csr	Load double coprocessor
`LDDC`	`ldd`	[address], creg_rd
`LDSBA` `LDSHA` `LDUBA` `LDUHA` `LDA`	`ldsba` `ldsha` `lduba` `lduha` `lda`	[regaddr]asi, reg_rd [regaddr]asi, reg_rd [regaddr]asi, reg_rd [regaddr]asi, reg_rd [regaddr]asi, reg_rd	Load signed byte from alternate space
`LDDA`	`ldda`	[regaddr]asi, reg_rd		reg_rd must be even
`LDSTUBA`	`ldstuba`	[regaddr]asi, reg_rd
`MULScc`	`mulscc`	reg_rs1, reg_or_imm, reg_rd	Multiply step (and modify `icc`)
`NOP`	`nop`		No operation
`OR` `ORcc` `ORN` `ORNcc`	`or` `orcc` `orn` `orncc`	reg_rs1, reg_or_imm, reg_rd reg_rs1, reg_or_imm, reg_rd reg_rs1, reg_or_imm, reg_rd reg_rs1, reg_or_imm, reg_rd	Inclusive `or`
`RDASR`	`rd`	`%asr`n_rs1, reg_rd
`RDY`	`rd`	`%y`, reg_rd		See synthetic instructions.
`RDPSR`	`rd`	`%psr`, reg_rd		See synthetic instructions.
`RDWIM`	`rd`	`%wim`, reg_rd		See synthetic instructions.
`RDTBR`	`rd`	`%tbr`, reg_rd		See synthetic instructions.
`RESTORE`	`restore`	reg_rs1, reg_or_imm, reg _rd		See synthetic instructions.
`RETT`	`rett`	address	Return from trap
`SAVE`	`save`	reg_rs1, reg_or_imm, reg_rd		See synthetic instructions.
`SDIV`	`sdiv`	reg_rs1, reg_or_imm, reg_rd	Signed divide
`SDIVcc`	`sdivcc`	reg_rs1, reg_or_imm, reg_rd	Signed divide and modify `icc`
`SMUL`	`smul`	reg_rs1, reg_or_imm, reg_rd	Signed multiply
`SMULcc`	`smulcc`	reg_rs1, reg_or_imm, reg_rd	Signed multiply and modify `icc`
`SETHI`	`sethi`	const22, reg_rd	Set high 22 bits of register
	`sethi`	`%hi`(value), reg_rd		See synthetic instructions.
`SLL`	`sll`	reg_rs1, reg_or_imm, reg_rd	Shift left logical
`SRL`	`srl`	reg_rs1, reg_or_imm, reg_rd	Shift right logical
`SRA`	`sra`	reg_rs1, reg_or_imm, reg_rd	Shift right arithmetic
`STB`	`stb`	reg_rd, [address]	Store byte	Synonyms: `stub`, `stsb`
`STH`	`sth`	reg_rd, [address]	Store half-word	Synonyms: `stuh`, `stsh`
`ST`	`st`	reg_rd, [address]
`STD`	`std`	reg_rd, [address]		reg_rd Must be even
`STF`	`st`	freg_rd, [address]
`STDF`	`std`	freg_rd, [address]
`STFSR`	`st`	`%fsr`, [address]	Store floating-point status register	freg_rd Must be even
`STDFQ`	`std`	`%fq`, [address]	Store double floating-point queue
`STC`	`st`	creg_rd, [address]	Store coprocessor	creg_rd Must be even
`STDC`	`std`	creg_rd, [address]		creg_rd Must be even
`STCSR`	`st`	`%csr`, [address]
`STDCQ`	`std`	`%cq`, [address]	Store double coprocessor
`STBA`	`stba`	reg_rd [regaddr]asi	Store byte into alternate space	Synonyms: stuba, stsba
`STHA`	`stha`	reg_rd [regaddr]asi		Synonyms: stuha, stsha
`STA`	`sta`	reg_rd, [regaddr]asi
`STDA`	`stda`	reg_rd, [regaddr]asi		reg_rd Must be even
`SUB`	`sub`	reg_rs1, reg_or_imm, reg_rd	Subtract
`SUBcc`	`subcc`	reg_rs1, reg_or_imm, reg_rd	Subtract and modify `icc`
`SUBX`	`subx`	reg_rs1, reg_or_imm, reg_rd	Subtract with carry
`SUBXcc`	`subxcc`	reg_rs1, reg_or_imm, reg_rd
`SWAP` `SWAPA`	`swap` `swapa`	[address], reg_rd [regaddr]asi, reg_rd	Swap memory word with register
`Ticc`	`tn`	`software_trap_number`	Trap on integer condition code	Trap never
	`tne`	`software_trap_number`	Note: Trap numbers 16-31 are reserved for the user. Currently-defined trap numbers are those defined in `/usr/include/sys/trap.h`	Synonym: `tnz`
	`te` `tg` `tle` `tge` `tl` `tgu`	`software_trap_number` `software_trap_number` `software_trap_number` `software_trap_number` `software_trap_number` `software_trap_number`		Synonym: `tz`
	`tleu`	`software_trap_number`		Synonym: `tcc`
	`tlu` `tgeu` `tpos` `tneg`	`software_trap_number` `software_trap_number` `software_trap_number` `software_trap_number`		Synonym: `tcc`
	`tvc` `tvs` `ta`	`software_trap_number` `software_trap_number` `software_trap_number`		Synonym: `t`
`TADDcc` `TSUBcc`	`taddcc` `tsubcc`	reg_rs1, reg_or_imm, reg_rd reg_rs1, reg_or_imm, reg_rd	Tagged add and modify `icc`
`TADDccTV` `TSUBccTV`	`taddcctv` `tsubcctv`	reg_rs1, reg_or_imm, reg_rd reg_rs1, reg_or_imm, reg_rd	Tagged add and modify `icc` and trap on overflow
`UDIV`	`udiv`	reg_rs1, reg_or_imm, reg_rd	Unsigned divide
`UDIVcc`	`udivcc`	reg_rs1, reg_or_imm, reg_rd	Unsigned divide and modify `icc`
`UMUL`	`umul`	reg_rs1, reg_or_imm, reg_rd	Unsigned multiply
`UMULcc`	`umulcc`	reg_rs1, reg_or_imm, reg_rd	Unsigned multiply and modify `icc`
`UNIMP`	`unimp`	`const22`	Illegal instruction
`WRASR`	`wr`	reg_or_imm, `%asr`n_rs1
`WRY`	`wr`	reg_rs1, reg_or_imm, `%y`		See synthetic instructions
`WRPSR`	`wr`	reg_rs1, reg_or_imm, `%psr`		See synthetic instructions
`WRWIM`	`wr`	reg_rs1, reg_or_imm, `%wim`		See synthetic instructions
`WRTBR`	`wr`	reg_rs1, reg_or_imm, `%tbr`		See synthetic instructions
`XNOR` `XNORcc`	`xnor` `xnorcc`	reg_rs1, reg_or_imm, reg_rd reg_rs1, reg_or_imm, reg_rd	Exclusive `nor`
`XOR` `XORcc`	`xor` `xorcc`	reg_rs1, reg_or_imm, reg_rd reg_rs1, reg_or_imm, reg_rd	Exclusive `or`