as: V850 Opcodes
9.48.5 Opcodes
--------------
'as' implements all the standard V850 opcodes.
'as' also implements the following pseudo ops:
'hi0()'
Computes the higher 16 bits of the given expression and stores it
into the immediate operand field of the given instruction. For
example:
'mulhi hi0(here - there), r5, r6'
computes the difference between the address of labels 'here' and
'there', takes the upper 16 bits of this difference, shifts it down
16 bits and then multiplies it by the lower 16 bits in register 5,
putting the result into register 6.
'lo()'
Computes the lower 16 bits of the given expression and stores it
into the immediate operand field of the given instruction. For
example:
'addi lo(here - there), r5, r6'
computes the difference between the address of labels 'here' and
'there', takes the lower 16 bits of this difference and adds it to
register 5, putting the result into register 6.
'hi()'
Computes the higher 16 bits of the given expression and then adds
the value of the most significant bit of the lower 16 bits of the
expression and stores the result into the immediate operand field
of the given instruction. For example the following code can be
used to compute the address of the label 'here' and store it into
register 6:
'movhi hi(here), r0, r6' 'movea lo(here), r6, r6'
The reason for this special behaviour is that movea performs a sign
extension on its immediate operand. So for example if the address
of 'here' was 0xFFFFFFFF then without the special behaviour of the
hi() pseudo-op the movhi instruction would put 0xFFFF0000 into r6,
then the movea instruction would takes its immediate operand,
0xFFFF, sign extend it to 32 bits, 0xFFFFFFFF, and then add it into
r6 giving 0xFFFEFFFF which is wrong (the fifth nibble is E). With
the hi() pseudo op adding in the top bit of the lo() pseudo op, the
movhi instruction actually stores 0 into r6 (0xFFFF + 1 = 0x0000),
so that the movea instruction stores 0xFFFFFFFF into r6 - the right
value.
'hilo()'
Computes the 32 bit value of the given expression and stores it
into the immediate operand field of the given instruction (which
must be a mov instruction). For example:
'mov hilo(here), r6'
computes the absolute address of label 'here' and puts the result
into register 6.
'sdaoff()'
Computes the offset of the named variable from the start of the
Small Data Area (whose address is held in register 4, the GP
register) and stores the result as a 16 bit signed value in the
immediate operand field of the given instruction. For example:
'ld.w sdaoff(_a_variable)[gp],r6'
loads the contents of the location pointed to by the label
'_a_variable' into register 6, provided that the label is located
somewhere within +/- 32K of the address held in the GP register.
[Note the linker assumes that the GP register contains a fixed
address set to the address of the label called '__gp'. This can
either be set up automatically by the linker, or specifically set
by using the '--defsym __gp=<value>' command-line option].
'tdaoff()'
Computes the offset of the named variable from the start of the
Tiny Data Area (whose address is held in register 30, the EP
register) and stores the result as a 4,5, 7 or 8 bit unsigned value
in the immediate operand field of the given instruction. For
example:
'sld.w tdaoff(_a_variable)[ep],r6'
loads the contents of the location pointed to by the label
'_a_variable' into register 6, provided that the label is located
somewhere within +256 bytes of the address held in the EP register.
[Note the linker assumes that the EP register contains a fixed
address set to the address of the label called '__ep'. This can
either be set up automatically by the linker, or specifically set
by using the '--defsym __ep=<value>' command-line option].
'zdaoff()'
Computes the offset of the named variable from address 0 and stores
the result as a 16 bit signed value in the immediate operand field
of the given instruction. For example:
'movea zdaoff(_a_variable),zero,r6'
puts the address of the label '_a_variable' into register 6,
assuming that the label is somewhere within the first 32K of
memory. (Strictly speaking it also possible to access the last 32K
of memory as well, as the offsets are signed).
'ctoff()'
Computes the offset of the named variable from the start of the
Call Table Area (whose address is held in system register 20, the
CTBP register) and stores the result a 6 or 16 bit unsigned value
in the immediate field of then given instruction or piece of data.
For example:
'callt ctoff(table_func1)'
will put the call the function whose address is held in the call
table at the location labeled 'table_func1'.
'.longcall name'
Indicates that the following sequence of instructions is a long
call to function 'name'. The linker will attempt to shorten this
call sequence if 'name' is within a 22bit offset of the call. Only
valid if the '-mrelax' command-line switch has been enabled.
'.longjump name'
Indicates that the following sequence of instructions is a long
jump to label 'name'. The linker will attempt to shorten this code
sequence if 'name' is within a 22bit offset of the jump. Only
valid if the '-mrelax' command-line switch has been enabled.
For information on the V850 instruction set, see 'V850 Family
32-/16-Bit single-Chip Microcontroller Architecture Manual' from NEC.
Ltd.
Info Catalog
as: V850 Directives
as: V850-Dependent