mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
04c9cf0a8c
The .option arch/rvc/norvc/push/pop directives can only take effect for a small/large specific code region, so they are not file-level architecture setting. They should only affect the mapping symbols only rather than the file-level elf architecture attribute. Otherwise, the elf architecture attribute will appear to missing some extensions when -flto merges files with different .option architecture settings. gas/ PR 32014 * config/tc-riscv.c (file_arch_str): New const char *, rather than the arch_str in the riscv_rps_as.subset_list, it's file-level so only be affected by .attribute arch directive. (riscv_reset_subsets_list_arch_str): Renamed to riscv_set_arch_str, and also can handle both file_arch_str and arch_str in subset_list, just give the pointer address as the input. (riscv_set_arch): Called by -march and .attribute arch, so set both file_arch_str and arch_str in subset_list. (s_riscv_option): Updated .option arch/rvc/norvc/push/pop that only set the arch_str in subset_list. (riscv_write_out_attrs): Output elf architecture attribute according to file_arch_str. Freed file_arch_str. * doc/c-riscv.texi: Added destrbution that .option directives shouldn't affect the elf attribute settings. * testsuite/gas/riscv/option-arch.s: From option-arch-01/02/03 merged. * testsuite/gas/riscv/option-arch-dis.d: Likewise, for dis-assembler. * testsuite/gas/riscv/option-arch-attr.d: Likewise, to check readelf -A.
869 lines
31 KiB
Plaintext
869 lines
31 KiB
Plaintext
@c Copyright (C) 2016-2024 Free Software Foundation, Inc.
|
|
@c This is part of the GAS manual.
|
|
@c For copying conditions, see the file as.texinfo
|
|
@c man end
|
|
|
|
@ifset GENERIC
|
|
@page
|
|
@node RISC-V-Dependent
|
|
@chapter RISC-V Dependent Features
|
|
@end ifset
|
|
@ifclear GENERIC
|
|
@node Machine Dependencies
|
|
@chapter RISC-V Dependent Features
|
|
@end ifclear
|
|
|
|
@cindex RISC-V support
|
|
@menu
|
|
* RISC-V-Options:: RISC-V Options
|
|
* RISC-V-Directives:: RISC-V Directives
|
|
* RISC-V-Modifiers:: RISC-V Assembler Modifiers
|
|
* RISC-V-Floating-Point:: RISC-V Floating Point
|
|
* RISC-V-Formats:: RISC-V Instruction Formats
|
|
* RISC-V-ATTRIBUTE:: RISC-V Object Attribute
|
|
* RISC-V-CustomExts:: RISC-V Custom (Vendor-Defined) Extensions
|
|
@end menu
|
|
|
|
@node RISC-V-Options
|
|
@section RISC-V Options
|
|
|
|
The following table lists all available RISC-V specific options.
|
|
|
|
@c man begin OPTIONS
|
|
@table @gcctabopt
|
|
|
|
@cindex @samp{-fpic} option, RISC-V
|
|
@item -fpic
|
|
@itemx -fPIC
|
|
Generate position-independent code
|
|
|
|
@cindex @samp{-fno-pic} option, RISC-V
|
|
@item -fno-pic
|
|
Don't generate position-independent code (default)
|
|
|
|
@cindex @samp{-march=ISA} option, RISC-V
|
|
@item -march=ISA
|
|
Select the base isa, as specified by ISA. For example -march=rv32ima.
|
|
If this option and the architecture attributes aren't set, then assembler
|
|
will check the default configure setting --with-arch=ISA.
|
|
|
|
@cindex @samp{-misa-spec=ISAspec} option, RISC-V
|
|
@item -misa-spec=ISAspec
|
|
Select the default isa spec version. If the version of ISA isn't set
|
|
by -march, then assembler helps to set the version according to
|
|
the default chosen spec. If this option isn't set, then assembler will
|
|
check the default configure setting --with-isa-spec=ISAspec.
|
|
|
|
@cindex @samp{-mpriv-spec=PRIVspec} option, RISC-V
|
|
@item -mpriv-spec=PRIVspec
|
|
Select the privileged spec version. We can decide whether the CSR is valid or
|
|
not according to the chosen spec. If this option and the privilege attributes
|
|
aren't set, then assembler will check the default configure setting
|
|
--with-priv-spec=PRIVspec.
|
|
|
|
@cindex @samp{-mabi=ABI} option, RISC-V
|
|
@item -mabi=ABI
|
|
Selects the ABI, which is either "ilp32" or "lp64", optionally followed
|
|
by "f", "d", or "q" to indicate single-precision, double-precision, or
|
|
quad-precision floating-point calling convention, or none or "e" to indicate
|
|
the soft-float calling convention ("e" indicates a soft-float RVE ABI).
|
|
|
|
@cindex @samp{-mrelax} option, RISC-V
|
|
@item -mrelax
|
|
Take advantage of linker relaxations to reduce the number of instructions
|
|
required to materialize symbol addresses. (default)
|
|
|
|
@cindex @samp{-mno-relax} option, RISC-V
|
|
@item -mno-relax
|
|
Don't do linker relaxations.
|
|
|
|
@cindex @samp{-march-attr} option, RISC-V
|
|
@item -march-attr
|
|
Generate the default contents for the riscv elf attribute section if the
|
|
.attribute directives are not set. This section is used to record the
|
|
information that a linker or runtime loader needs to check compatibility.
|
|
This information includes ISA string, stack alignment requirement, unaligned
|
|
memory accesses, and the major, minor and revision version of privileged
|
|
specification.
|
|
|
|
@cindex @samp{-mno-arch-attr} option, RISC-V
|
|
@item -mno-arch-attr
|
|
Don't generate the default riscv elf attribute section if the .attribute
|
|
directives are not set.
|
|
|
|
@cindex @samp{-mcsr-check} option, RISC-V
|
|
@item -mcsr-check
|
|
Enable the CSR checking for the ISA-dependent CRS and the read-only CSR.
|
|
The ISA-dependent CSR are only valid when the specific ISA is set. The
|
|
read-only CSR can not be written by the CSR instructions.
|
|
|
|
@cindex @samp{-mno-csr-check} option, RISC-V
|
|
@item -mno-csr-check
|
|
Don't do CSR checking.
|
|
|
|
@cindex @samp{-mlittle-endian} option, RISC-V
|
|
@item -mlittle-endian
|
|
Generate code for a little endian machine.
|
|
|
|
@cindex @samp{-mbig-endian} option, RISC-V
|
|
@item -mbig-endian
|
|
Generate code for a big endian machine.
|
|
@end table
|
|
@c man end
|
|
|
|
@node RISC-V-Directives
|
|
@section RISC-V Directives
|
|
@cindex machine directives, RISC-V
|
|
@cindex RISC-V machine directives
|
|
|
|
The following table lists all available RISC-V specific directives.
|
|
|
|
@table @code
|
|
|
|
@cindex @code{align} directive
|
|
@item .align @var{size-log-2}
|
|
Align to the given boundary, with the size given as log2 the number of bytes to
|
|
align to.
|
|
|
|
@cindex Data directives
|
|
@item .half @var{value}
|
|
@itemx .word @var{value}
|
|
@itemx .dword @var{value}
|
|
Emits a half-word, word, or double-word value at the current position.
|
|
|
|
@cindex DTP-relative data directives
|
|
@item .dtprelword @var{value}
|
|
@itemx .dtpreldword @var{value}
|
|
Emits a DTP-relative word (or double-word) at the current position. This is
|
|
meant to be used by the compiler in shared libraries for DWARF debug info for
|
|
thread local variables.
|
|
|
|
@cindex LEB128 directives
|
|
@item .uleb128 @var{value}
|
|
@itemx .sleb128 @var{value}
|
|
Emits a signed or unsigned LEB128 value at the current position. This only
|
|
accepts constant expressions, because symbol addresses can change with
|
|
relaxation, and we don't support relocations to modify LEB128 values at link
|
|
time.
|
|
|
|
@cindex Option directive
|
|
@cindex @code{option} directive
|
|
@item .option @var{argument}
|
|
Modifies RISC-V specific assembler options inline with the assembly code.
|
|
This is used when particular instruction sequences must be assembled with a
|
|
specific set of options. For example, since we relax addressing sequences to
|
|
shorter GP-relative sequences when possible the initial load of GP must not be
|
|
relaxed and should be emitted as something like
|
|
|
|
@smallexample
|
|
.option push
|
|
.option norelax
|
|
la gp, __global_pointer$
|
|
.option pop
|
|
@end smallexample
|
|
|
|
in order to produce after linker relaxation the expected
|
|
|
|
@smallexample
|
|
auipc gp, %pcrel_hi(__global_pointer$)
|
|
addi gp, gp, %pcrel_lo(__global_pointer$)
|
|
@end smallexample
|
|
|
|
instead of just
|
|
|
|
@smallexample
|
|
addi gp, gp, 0
|
|
@end smallexample
|
|
|
|
It's not expected that options are changed in this manner during regular use,
|
|
but there are a handful of esoteric cases like the one above where users need
|
|
to disable particular features of the assembler for particular code sequences.
|
|
However, it's also useful to enable/disable the extensions for some specific
|
|
code regions by @samp{.option arch, +-}. This is very common in the ifunc
|
|
libraries. We can support functions which are implemented by different
|
|
extensions in the same library, but these should not affect any file-level
|
|
settings, like the elf architecture attribute. The complete list of option
|
|
arguments is shown below:
|
|
|
|
@table @code
|
|
@item push
|
|
@itemx pop
|
|
Pushes or pops the current option stack. These should be used whenever
|
|
changing an option in line with assembly code in order to ensure the user's
|
|
command-line options are respected for the bulk of the file being assembled.
|
|
|
|
@item rvc
|
|
@itemx norvc
|
|
Enables or disables the generation of compressed instructions. Instructions
|
|
are opportunistically compressed by the RISC-V assembler when possible, but
|
|
sometimes this behavior is not desirable, especially when handling alignments.
|
|
|
|
@item pic
|
|
@itemx nopic
|
|
Enables or disables position-independent code generation. Unless you really
|
|
know what you're doing, this should only be at the top of a file.
|
|
|
|
@item relax
|
|
@itemx norelax
|
|
Enables or disables relaxation. The RISC-V assembler and linker
|
|
opportunistically relax some code sequences, but sometimes this behavior is not
|
|
desirable.
|
|
|
|
@item csr-check
|
|
@itemx no-csr-check
|
|
Enables or disables the CSR checking.
|
|
|
|
@item arch, @var{+extension[version]} [,...,@var{+extension_n[version_n]}]
|
|
@itemx arch, @var{-extension} [,...,@var{-extension_n}]
|
|
@itemx arch, @var{ISA}
|
|
Enables or disables the extensions for specific code region. For example,
|
|
@samp{.option arch, +m2p0} means add m extension with version 2.0, and
|
|
@samp{.option arch, -f, -d} means remove extensions, f and d, from the
|
|
architecture string. Note that, @samp{.option arch, +c, -c} have the same
|
|
behavior as @samp{.option rvc, norvc}. However, they are also undesirable
|
|
sometimes. Besides, @samp{.option arch, -i} is illegal, since we cannot
|
|
remove the base i extension anytime. If you want to reset the whole ISA
|
|
string, you can also use @samp{.option arch, rv32imac} to overwrite the
|
|
previous settings.
|
|
@end table
|
|
|
|
@cindex INSN directives
|
|
@item .insn @var{type}, @var{operand} [,...,@var{operand_n}]
|
|
@itemx .insn @var{insn_length}, @var{value}
|
|
@itemx .insn @var{value}
|
|
This directive permits the numeric representation of an instructions
|
|
and makes the assembler insert the operands according to one of the
|
|
instruction formats for @samp{.insn} (@ref{RISC-V-Formats}).
|
|
For example, the instruction @samp{add a0, a1, a2} could be written as
|
|
@samp{.insn r 0x33, 0, 0, a0, a1, a2}. But in fact, the instruction
|
|
formats are difficult to use for some users, so most of them are using
|
|
@samp{.word} to encode the instruction directly, rather than using
|
|
@samp{.insn}. It is fine for now, but will be wrong when the mapping
|
|
symbols are supported, since @samp{.word} will not be shown as an
|
|
instruction, it should be shown as data. Therefore, we also support
|
|
two more formats of the @samp{.insn}, the instruction @samp{add a0, a1, a2}
|
|
could also be written as @samp{.insn 0x4, 0xc58533} or @samp{.insn 0xc58533}.
|
|
When the @var{insn_length} is set, then assembler will check if the
|
|
@var{value} is a valid @var{insn_length} bytes instruction.
|
|
|
|
@cindex @code{.attribute} directive, RISC-V
|
|
@item .attribute @var{tag}, @var{value}
|
|
Set the object attribute @var{tag} to @var{value}.
|
|
|
|
The @var{tag} is either an attribute number, or one of the following:
|
|
@code{Tag_RISCV_arch}, @code{Tag_RISCV_stack_align},
|
|
@code{Tag_RISCV_unaligned_access}, @code{Tag_RISCV_priv_spec},
|
|
@code{Tag_RISCV_priv_spec_minor}, @code{Tag_RISCV_priv_spec_revision}.
|
|
|
|
@end table
|
|
|
|
@node RISC-V-Modifiers
|
|
@section RISC-V Assembler Modifiers
|
|
|
|
The RISC-V assembler supports following modifiers for relocatable addresses
|
|
used in RISC-V instruction operands. However, we also support some pseudo
|
|
instructions that are easier to use than these modifiers.
|
|
|
|
@table @code
|
|
@item %lo(@var{symbol})
|
|
The low 12 bits of absolute address for @var{symbol}.
|
|
|
|
@item %hi(@var{symbol})
|
|
The high 20 bits of absolute address for @var{symbol}. This is usually
|
|
used with the %lo modifier to represent a 32-bit absolute address.
|
|
|
|
@smallexample
|
|
lui a0, %hi(@var{symbol}) // R_RISCV_HI20
|
|
addi a0, a0, %lo(@var{symbol}) // R_RISCV_LO12_I
|
|
|
|
lui a0, %hi(@var{symbol}) // R_RISCV_HI20
|
|
load/store a0, %lo(@var{symbol})(a0) // R_RISCV_LO12_I/S
|
|
@end smallexample
|
|
|
|
@item %pcrel_lo(@var{label})
|
|
The low 12 bits of relative address between pc and @var{symbol}.
|
|
The @var{symbol} is related to the high part instruction which is marked
|
|
by @var{label}.
|
|
|
|
@item %pcrel_hi(@var{symbol})
|
|
The high 20 bits of relative address between pc and @var{symbol}.
|
|
This is usually used with the %pcrel_lo modifier to represent a +/-2GB
|
|
pc-relative range.
|
|
|
|
@smallexample
|
|
@var{label}:
|
|
auipc a0, %pcrel_hi(@var{symbol}) // R_RISCV_PCREL_HI20
|
|
addi a0, a0, %pcrel_lo(@var{label}) // R_RISCV_PCREL_LO12_I
|
|
|
|
@var{label}:
|
|
auipc a0, %pcrel_hi(@var{symbol}) // R_RISCV_PCREL_HI20
|
|
load/store a0, %pcrel_lo(@var{label})(a0) // R_RISCV_PCREL_LO12_I/S
|
|
@end smallexample
|
|
|
|
Or you can use the pseudo lla/lw/sw/... instruction to do this.
|
|
|
|
@smallexample
|
|
lla a0, @var{symbol}
|
|
@end smallexample
|
|
|
|
@item %got_pcrel_hi(@var{symbol})
|
|
The high 20 bits of relative address between pc and the GOT entry of
|
|
@var{symbol}. This is usually used with the %pcrel_lo modifier to access
|
|
the GOT entry.
|
|
|
|
@smallexample
|
|
@var{label}:
|
|
auipc a0, %got_pcrel_hi(@var{symbol}) // R_RISCV_GOT_HI20
|
|
addi a0, a0, %pcrel_lo(@var{label}) // R_RISCV_PCREL_LO12_I
|
|
|
|
@var{label}:
|
|
auipc a0, %got_pcrel_hi(@var{symbol}) // R_RISCV_GOT_HI20
|
|
load/store a0, %pcrel_lo(@var{label})(a0) // R_RISCV_PCREL_LO12_I/S
|
|
@end smallexample
|
|
|
|
Also, the pseudo la instruction with PIC has similar behavior.
|
|
|
|
@item %tprel_add(@var{symbol})
|
|
This is used purely to associate the R_RISCV_TPREL_ADD relocation for
|
|
TLS relaxation. This one is only valid as the fourth operand to the normally
|
|
3 operand add instruction.
|
|
|
|
@item %tprel_lo(@var{symbol})
|
|
The low 12 bits of relative address between tp and @var{symbol}.
|
|
|
|
@item %tprel_hi(@var{symbol})
|
|
The high 20 bits of relative address between tp and @var{symbol}. This is
|
|
usually used with the %tprel_lo and %tprel_add modifiers to access the thread
|
|
local variable @var{symbol} in TLS Local Exec.
|
|
|
|
@smallexample
|
|
lui a5, %tprel_hi(@var{symbol}) // R_RISCV_TPREL_HI20
|
|
add a5, a5, tp, %tprel_add(@var{symbol}) // R_RISCV_TPREL_ADD
|
|
load/store t0, %tprel_lo(@var{symbol})(a5) // R_RISCV_TPREL_LO12_I/S
|
|
@end smallexample
|
|
|
|
@item %tls_ie_pcrel_hi(@var{symbol})
|
|
The high 20 bits of relative address between pc and GOT entry. It is
|
|
usually used with the %pcrel_lo modifier to access the thread local
|
|
variable @var{symbol} in TLS Initial Exec.
|
|
|
|
@smallexample
|
|
la.tls.ie a5, @var{symbol}
|
|
add a5, a5, tp
|
|
load/store t0, 0(a5)
|
|
@end smallexample
|
|
|
|
The pseudo la.tls.ie instruction can be expended to
|
|
|
|
@smallexample
|
|
@var{label}:
|
|
auipc a5, %tls_ie_pcrel_hi(@var{symbol}) // R_RISCV_TLS_GOT_HI20
|
|
load a5, %pcrel_lo(@var{label})(a5) // R_RISCV_PCREL_LO12_I
|
|
@end smallexample
|
|
|
|
@item %tls_gd_pcrel_hi(@var{symbol})
|
|
The high 20 bits of relative address between pc and GOT entry. It is
|
|
usually used with the %pcrel_lo modifier to access the thread local variable
|
|
@var{symbol} in TLS Global Dynamic.
|
|
|
|
@smallexample
|
|
la.tls.gd a0, @var{symbol}
|
|
call __tls_get_addr@@plt
|
|
mv a5, a0
|
|
load/store t0, 0(a5)
|
|
@end smallexample
|
|
|
|
The pseudo la.tls.gd instruction can be expended to
|
|
|
|
@smallexample
|
|
@var{label}:
|
|
auipc a0, %tls_gd_pcrel_hi(@var{symbol}) // R_RISCV_TLS_GD_HI20
|
|
addi a0, a0, %pcrel_lo(@var{label}) // R_RISCV_PCREL_LO12_I
|
|
@end smallexample
|
|
|
|
@end table
|
|
|
|
@node RISC-V-Floating-Point
|
|
@section RISC-V Floating Point
|
|
@cindex floating point, risc-v (@sc{ieee})
|
|
@cindex RISC-V floating point (@sc{ieee})
|
|
|
|
The RISC-V architecture uses @sc{ieee} floating-point numbers.
|
|
|
|
The RISC-V Zfa extension includes a load-immediate instruction
|
|
for floating-point registers, which allows specifying the immediate
|
|
(from a pool of 32 predefined values defined in the specification)
|
|
as operand.
|
|
E.g. to load the value @code{0.0625} as single-precision FP value into
|
|
the FP register @code{ft1} one of the following instructions can be used:
|
|
|
|
fli.s ft1, 0.0625 # dec floating-point literal
|
|
fli.s ft1, 0x1p-4 # hex floating-point literal
|
|
fli.s ft1, 0x0.8p-3
|
|
fli.s ft1, 0x1.0p-4
|
|
fli.s ft1, 0x2p-5
|
|
fli.s ft1, 0x4p-6
|
|
...
|
|
|
|
As can be seen, many valid ways exist to express a floating-point value.
|
|
This is realized by parsing the value operand using strtof() and
|
|
comparing the parsed value against built-in float-constants that
|
|
are written as hex floating-point literals.
|
|
|
|
This approach works on all machines that use IEEE 754.
|
|
However, there is a chance that this fails on other machines
|
|
with the following error message:
|
|
|
|
Error: improper fli value operand
|
|
Error: illegal operands `fli.s ft1,0.0625
|
|
|
|
The error indicates that parsing @samp{0x1p-4} and @samp{0.0625}
|
|
to single-precision floating point numbers will not result
|
|
in two equal values on that machine.
|
|
|
|
If you encounter this problem, then please report it.
|
|
|
|
@node RISC-V-Formats
|
|
@section RISC-V Instruction Formats
|
|
@cindex instruction formats, risc-v
|
|
@cindex RISC-V instruction formats
|
|
|
|
The RISC-V Instruction Set Manual Volume I: User-Level ISA lists 15
|
|
instruction formats where some of the formats have multiple variants.
|
|
For the @samp{.insn} pseudo directive the assembler recognizes some
|
|
of the formats.
|
|
Typically, the most general variant of the instruction format is used
|
|
by the @samp{.insn} directive.
|
|
|
|
The following table lists the abbreviations used in the table of
|
|
instruction formats:
|
|
|
|
@display
|
|
@multitable @columnfractions .15 .40
|
|
@item opcode7 @tab Unsigned immediate or opcode name for 7-bits opcode.
|
|
@item opcode2 @tab Unsigned immediate or opcode name for 2-bits opcode.
|
|
@item func7 @tab Unsigned immediate for 7-bits function code.
|
|
@item func6 @tab Unsigned immediate for 6-bits function code.
|
|
@item func4 @tab Unsigned immediate for 4-bits function code.
|
|
@item func3 @tab Unsigned immediate for 3-bits function code.
|
|
@item func2 @tab Unsigned immediate for 2-bits function code.
|
|
@item rd @tab Destination register number for operand x, can be GPR or FPR.
|
|
@item rd' @tab Destination register number for operand x,
|
|
only accept s0-s1, a0-a5, fs0-fs1 and fa0-fa5.
|
|
@item rs1 @tab First source register number for operand x, can be GPR or FPR.
|
|
@item rs1' @tab First source register number for operand x,
|
|
only accept s0-s1, a0-a5, fs0-fs1 and fa0-fa5.
|
|
@item rs2 @tab Second source register number for operand x, can be GPR or FPR.
|
|
@item rs2' @tab Second source register number for operand x,
|
|
only accept s0-s1, a0-a5, fs0-fs1 and fa0-fa5.
|
|
@item simm12 @tab Sign-extended 12-bit immediate for operand x.
|
|
@item simm20 @tab Sign-extended 20-bit immediate for operand x.
|
|
@item simm6 @tab Sign-extended 6-bit immediate for operand x.
|
|
@item uimm5 @tab Unsigned 5-bit immediate for operand x.
|
|
@item uimm6 @tab Unsigned 6-bit immediate for operand x.
|
|
@item uimm8 @tab Unsigned 8-bit immediate for operand x.
|
|
@item symbol @tab Symbol or label reference for operand x.
|
|
@end multitable
|
|
@end display
|
|
|
|
The following table lists all available opcode name:
|
|
|
|
@table @code
|
|
@item C0
|
|
@item C1
|
|
@item C2
|
|
Opcode space for compressed instructions.
|
|
|
|
@item LOAD
|
|
Opcode space for load instructions.
|
|
|
|
@item LOAD_FP
|
|
Opcode space for floating-point load instructions.
|
|
|
|
@item STORE
|
|
Opcode space for store instructions.
|
|
|
|
@item STORE_FP
|
|
Opcode space for floating-point store instructions.
|
|
|
|
@item AUIPC
|
|
Opcode space for auipc instruction.
|
|
|
|
@item LUI
|
|
Opcode space for lui instruction.
|
|
|
|
@item BRANCH
|
|
Opcode space for branch instructions.
|
|
|
|
@item JAL
|
|
Opcode space for jal instruction.
|
|
|
|
@item JALR
|
|
Opcode space for jalr instruction.
|
|
|
|
@item OP
|
|
Opcode space for ALU instructions.
|
|
|
|
@item OP_32
|
|
Opcode space for 32-bits ALU instructions.
|
|
|
|
@item OP_IMM
|
|
Opcode space for ALU with immediate instructions.
|
|
|
|
@item OP_IMM_32
|
|
Opcode space for 32-bits ALU with immediate instructions.
|
|
|
|
@item OP_FP
|
|
Opcode space for floating-point operation instructions.
|
|
|
|
@item MADD
|
|
Opcode space for madd instruction.
|
|
|
|
@item MSUB
|
|
Opcode space for msub instruction.
|
|
|
|
@item NMADD
|
|
Opcode space for nmadd instruction.
|
|
|
|
@item NMSUB
|
|
Opcode space for msub instruction.
|
|
|
|
@item AMO
|
|
Opcode space for atomic memory operation instructions.
|
|
|
|
@item MISC_MEM
|
|
Opcode space for misc instructions.
|
|
|
|
@item SYSTEM
|
|
Opcode space for system instructions.
|
|
|
|
@item CUSTOM_0
|
|
@item CUSTOM_1
|
|
@item CUSTOM_2
|
|
@item CUSTOM_3
|
|
Opcode space for customize instructions.
|
|
|
|
@end table
|
|
|
|
An instruction is two or four bytes in length and must be aligned
|
|
on a 2 byte boundary. The first two bits of the instruction specify the
|
|
length of the instruction, 00, 01 and 10 indicates a two byte instruction,
|
|
11 indicates a four byte instruction.
|
|
|
|
The following table lists the RISC-V instruction formats that are available
|
|
with the @samp{.insn} pseudo directive:
|
|
|
|
@table @code
|
|
@item R type: .insn r opcode7, func3, func7, rd, rs1, rs2
|
|
@verbatim
|
|
+-------+-----+-----+-------+----+---------+
|
|
| func7 | rs2 | rs1 | func3 | rd | opcode7 |
|
|
+-------+-----+-----+-------+----+---------+
|
|
31 25 20 15 12 7 0
|
|
@end verbatim
|
|
|
|
@item R type with 4 register operands: .insn r opcode7, func3, func2, rd, rs1, rs2, rs3
|
|
@itemx R4 type: .insn r4 opcode7, func3, func2, rd, rs1, rs2, rs3
|
|
@verbatim
|
|
+-----+-------+-----+-----+-------+----+---------+
|
|
| rs3 | func2 | rs2 | rs1 | func3 | rd | opcode7 |
|
|
+-----+-------+-----+-----+-------+----+---------+
|
|
31 27 25 20 15 12 7 0
|
|
@end verbatim
|
|
|
|
@item I type: .insn i opcode7, func3, rd, rs1, simm12
|
|
@itemx I type: .insn i opcode7, func3, rd, simm12(rs1)
|
|
@verbatim
|
|
+--------------+-----+-------+----+---------+
|
|
| simm12[11:0] | rs1 | func3 | rd | opcode7 |
|
|
+--------------+-----+-------+----+---------+
|
|
31 20 15 12 7 0
|
|
@end verbatim
|
|
|
|
@item S type: .insn s opcode7, func3, rs2, simm12(rs1)
|
|
@verbatim
|
|
+--------------+-----+-----+-------+-------------+---------+
|
|
| simm12[11:5] | rs2 | rs1 | func3 | simm12[4:0] | opcode7 |
|
|
+--------------+-----+-----+-------+-------------+---------+
|
|
31 25 20 15 12 7 0
|
|
@end verbatim
|
|
|
|
@item B type: .insn s opcode7, func3, rs1, rs2, symbol
|
|
@itemx SB type: .insn sb opcode7, func3, rs1, rs2, symbol
|
|
@verbatim
|
|
+-----------------+-----+-----+-------+----------------+---------+
|
|
| simm12[12|10:5] | rs2 | rs1 | func3 | simm12[4:1|11] | opcode7 |
|
|
+-----------------+-----+-----+-------+----------------+---------+
|
|
31 25 20 15 12 7 0
|
|
@end verbatim
|
|
|
|
@item U type: .insn u opcode7, rd, simm20
|
|
@verbatim
|
|
+--------------+----+---------+
|
|
| simm20[19:0] | rd | opcode7 |
|
|
+--------------+----+---------+
|
|
31 12 7 0
|
|
@end verbatim
|
|
|
|
@item J type: .insn j opcode7, rd, symbol
|
|
@itemx UJ type: .insn uj opcode7, rd, symbol
|
|
@verbatim
|
|
+------------+--------------+------------+---------------+----+---------+
|
|
| simm20[20] | simm20[10:1] | simm20[11] | simm20[19:12] | rd | opcode7 |
|
|
+------------+--------------+------------+---------------+----+---------+
|
|
31 30 21 20 12 7 0
|
|
@end verbatim
|
|
|
|
@item CR type: .insn cr opcode2, func4, rd, rs2
|
|
@verbatim
|
|
+-------+--------+-----+---------+
|
|
| func4 | rd/rs1 | rs2 | opcode2 |
|
|
+-------+--------+-----+---------+
|
|
15 12 7 2 0
|
|
@end verbatim
|
|
|
|
@item CI type: .insn ci opcode2, func3, rd, simm6
|
|
@verbatim
|
|
+-------+----------+--------+------------+---------+
|
|
| func3 | simm6[5] | rd/rs1 | simm6[4:0] | opcode2 |
|
|
+-------+----------+--------+------------+---------+
|
|
15 13 12 7 2 0
|
|
@end verbatim
|
|
|
|
@item CIW type: .insn ciw opcode2, func3, rd', uimm8
|
|
@verbatim
|
|
+-------+------------+-----+---------+
|
|
| func3 | uimm8[7:0] | rd' | opcode2 |
|
|
+-------+-------- ---+-----+---------+
|
|
15 13 5 2 0
|
|
@end verbatim
|
|
|
|
@item CSS type: .insn css opcode2, func3, rd, uimm6
|
|
@verbatim
|
|
+-------+------------+----+---------+
|
|
| func3 | uimm6[5:0] | rd | opcode2 |
|
|
+-------+------------+----+---------+
|
|
15 13 7 2 0
|
|
@end verbatim
|
|
|
|
@item CL type: .insn cl opcode2, func3, rd', uimm5(rs1')
|
|
@verbatim
|
|
+-------+------------+------+------------+------+---------+
|
|
| func3 | uimm5[4:2] | rs1' | uimm5[1:0] | rd' | opcode2 |
|
|
+-------+------------+------+------------+------+---------+
|
|
15 13 10 7 5 2 0
|
|
@end verbatim
|
|
|
|
@item CS type: .insn cs opcode2, func3, rs2', uimm5(rs1')
|
|
@verbatim
|
|
+-------+------------+------+------------+------+---------+
|
|
| func3 | uimm5[4:2] | rs1' | uimm5[1:0] | rs2' | opcode2 |
|
|
+-------+------------+------+------------+------+---------+
|
|
15 13 10 7 5 2 0
|
|
@end verbatim
|
|
|
|
@item CA type: .insn ca opcode2, func6, func2, rd', rs2'
|
|
@verbatim
|
|
+-- ----+----------+-------+------+---------+
|
|
| func6 | rd'/rs1' | func2 | rs2' | opcode2 |
|
|
+-------+----------+-------+------+---------+
|
|
15 10 7 5 2 0
|
|
@end verbatim
|
|
|
|
@item CB type: .insn cb opcode2, func3, rs1', symbol
|
|
@verbatim
|
|
+-------+--------------+------+------------------+---------+
|
|
| func3 | simm8[8|4:3] | rs1' | simm8[7:6|2:1|5] | opcode2 |
|
|
+-------+--------------+------+------------------+---------+
|
|
15 13 10 7 2 0
|
|
@end verbatim
|
|
|
|
@item CJ type: .insn cj opcode2, func3, symbol
|
|
@verbatim
|
|
+-------+-------------------------------+---------+
|
|
| func3 | simm11[11|4|9:8|10|6|7|3:1|5] | opcode2 |
|
|
+-------+-------------------------------+---------+
|
|
15 13 2 0
|
|
@end verbatim
|
|
|
|
|
|
@end table
|
|
|
|
For the complete list of all instruction format variants see
|
|
The RISC-V Instruction Set Manual Volume I: User-Level ISA.
|
|
|
|
@node RISC-V-ATTRIBUTE
|
|
@section RISC-V Object Attribute
|
|
@cindex Object Attribute, RISC-V
|
|
|
|
RISC-V attributes have a string value if the tag number is odd and an integer
|
|
value if the tag number is even.
|
|
|
|
@table @r
|
|
@item Tag_RISCV_stack_align (4)
|
|
Tag_RISCV_strict_align records the N-byte stack alignment for this object. The
|
|
default value is 16 for RV32I or RV64I, and 4 for RV32E.
|
|
|
|
The smallest value will be used if object files with different
|
|
Tag_RISCV_stack_align values are merged.
|
|
|
|
@item Tag_RISCV_arch (5)
|
|
Tag_RISCV_arch contains a string for the target architecture taken from the
|
|
option @option{-march}. Different architectures will be integrated into a
|
|
superset when object files are merged.
|
|
|
|
Note that the version information of the target architecture must be presented
|
|
explicitly in the attribute and abbreviations must be expanded. The version
|
|
information, if not given by @option{-march}, must be in accordance with the
|
|
default specified by the tool. For example, the architecture @code{RV32I} has
|
|
to be recorded in the attribute as @code{RV32I2P0} in which @code{2P0} stands
|
|
for the default version of its base ISA. On the other hand, the architecture
|
|
@code{RV32G} has to be presented as @code{RV32I2P0_M2P0_A2P0_F2P0_D2P0} in
|
|
which the abbreviation @code{G} is expanded to the @code{IMAFD} combination
|
|
with default versions of the standard extensions.
|
|
|
|
@item Tag_RISCV_unaligned_access (6)
|
|
Tag_RISCV_unaligned_access is 0 for files that do not allow any unaligned
|
|
memory accesses, and 1 for files that do allow unaligned memory accesses.
|
|
|
|
@item Tag_RISCV_priv_spec (8)
|
|
@item Tag_RISCV_priv_spec_minor (10)
|
|
@item Tag_RISCV_priv_spec_revision (12)
|
|
Tag_RISCV_priv_spec contains the major/minor/revision version information of
|
|
the privileged specification. It will report errors if object files of
|
|
different privileged specification versions are merged.
|
|
|
|
@end table
|
|
|
|
@node RISC-V-CustomExts
|
|
@section RISC-V Custom (Vendor-Defined) Extensions
|
|
@cindex custom (vendor-defined) extensions, RISC-V
|
|
@cindex RISC-V custom (vendor-defined) extensions
|
|
|
|
The following table lists the custom (vendor-defined) RISC-V
|
|
extensions supported and provides the location of their
|
|
publicly-released documentation:
|
|
|
|
@table @r
|
|
@item XCvAlu
|
|
The XCvAlu extension provides instructions for general ALU operations.
|
|
|
|
It is documented in @url{https://docs.openhwgroup.org/projects/cv32e40p-user-manual/en/latest/instruction_set_extensions.html}
|
|
|
|
@item XCvBi
|
|
The XCvBi extension provides instructions for branch immediate operations.
|
|
|
|
It is documented in @url{https://docs.openhwgroup.org/projects/cv32e40p-user-manual/en/latest/instruction_set_extensions.html}
|
|
|
|
@item XCvBitmanip
|
|
The XCvBitmanip extension provides instructions for bitmanip operations.
|
|
|
|
It is documented in @url{https://docs.openhwgroup.org/projects/cv32e40p-user-manual/en/latest/instruction_set_extensions.html}
|
|
|
|
@item XCvElw
|
|
The XCvElw extension provides instructions for event load word operations.
|
|
|
|
It is documented in @url{https://docs.openhwgroup.org/projects/cv32e40p-user-manual/en/latest/instruction_set_extensions.html}
|
|
|
|
@item XCvMac
|
|
The XCvMac extension provides instructions for multiply-accumulate operations.
|
|
|
|
It is documented in @url{https://docs.openhwgroup.org/projects/cv32e40p-user-manual/en/latest/instruction_set_extensions.html}
|
|
|
|
@item XCvMem
|
|
The XCvMem extension provides instructions for post inc load/store operations.
|
|
|
|
It is documented in @url{https://docs.openhwgroup.org/projects/cv32e40p-user-manual/en/latest/instruction_set_extensions.html}
|
|
|
|
@item XTheadBa
|
|
The XTheadBa extension provides instructions for address calculations.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadBb
|
|
The XTheadBb extension provides instructions for basic bit-manipulation
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadBs
|
|
The XTheadBs extension provides single-bit instructions.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadCmo
|
|
The XTheadCmo extension provides instructions for cache management.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadCondMov
|
|
The XTheadCondMov extension provides instructions for conditional moves.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadFMemIdx
|
|
The XTheadFMemIdx extension provides floating-point memory operations.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadFmv
|
|
The XTheadFmv extension provides access to the upper 32 bits of a doulbe-precision floating point register.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.1.0/xthead-2022-11-07-2.1.0.pdf}.
|
|
|
|
@item XTheadInt
|
|
The XTheadInt extension provides access to ISR stack management instructions.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.1.0/xthead-2022-11-07-2.1.0.pdf}.
|
|
|
|
@item XTheadMac
|
|
The XTheadMac extension provides multiply-accumulate instructions.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadMemIdx
|
|
The XTheadMemIdx extension provides GPR memory operations.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadMemPair
|
|
The XTheadMemPair extension provides two-GP-register memory operations.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadSync
|
|
The XTheadSync extension provides instructions for multi-processor synchronization.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.0.0/xthead-2022-09-05-2.0.0.pdf}.
|
|
|
|
@item XTheadVector
|
|
The XTheadVector extension provides instructions for thead vector.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.3.0/xthead-2023-11-10-2.3.0.pdf}.
|
|
|
|
@item XTheadZvamo
|
|
The XTheadZvamo extension is a subextension of the XTheadVector extension,
|
|
and it provides AMO instructions for the T-Head VECTOR vendor extension.
|
|
|
|
It is documented in @url{https://github.com/T-head-Semi/thead-extension-spec/releases/download/2.3.0/xthead-2023-11-10-2.3.0.pdf}.
|
|
|
|
@item XVentanaCondOps
|
|
XVentanaCondOps extension provides instructions for branchless
|
|
sequences that perform conditional arithmetic, conditional
|
|
bitwise-logic, and conditional select operations.
|
|
|
|
It is documented in @url{https://github.com/ventanamicro/ventana-custom-extensions/releases/download/v1.0.0/ventana-custom-extensions-v1.0.0.pdf}.
|
|
|
|
@item XSfVcp
|
|
The XSfVcp (VCIX) extension provides flexible instructions for extending
|
|
vector coprocessor. To accelerate performance, system designers may use
|
|
VCIX as a low-latency, high-throughput interface to a coprocessor.
|
|
|
|
It is documented in @url{https://sifive.cdn.prismic.io/sifive/c3829e36-8552-41f0-a841-79945784241b_vcix-spec-software.pdf}.
|
|
|
|
@item XSfCease
|
|
XSfCease provides an instruction to instigates power-down sequence.
|
|
|
|
It is documented in @url{https://sifive.cdn.prismic.io/sifive/767804da-53b2-4893-97d5-b7c030ae0a94_s76mc_core_complex_manual_21G3.pdf}.
|
|
|
|
@end table
|