@c Copyright (C) 2002 Free Software Foundation, Inc. @c This is part of the GAS manual. @c For copying conditions, see the file as.texinfo. @c @ifset GENERIC @page @node Xtensa-Dependent @chapter Xtensa Dependent Features @end ifset @ifclear GENERIC @node Machine Dependencies @chapter Xtensa Dependent Features @end ifclear @cindex Xtensa architecture This chapter covers features of the @sc{gnu} assembler that are specific to the Xtensa architecture. For details about the Xtensa instruction set, please consult the @cite{Xtensa Instruction Set Architecture (ISA) Reference Manual}. @menu * Xtensa Options:: Command-line Options. * Xtensa Syntax:: Assembler Syntax for Xtensa Processors. * Xtensa Optimizations:: Assembler Optimizations. * Xtensa Relaxation:: Other Automatic Transformations. * Xtensa Directives:: Directives for Xtensa Processors. @end menu @node Xtensa Options @section Command Line Options The Xtensa version of the @sc{gnu} assembler supports these special options: @table @code @item --density | --no-density @kindex --density @kindex --no-density @cindex Xtensa density option @cindex density option, Xtensa Enable or disable use of the Xtensa code density option (16-bit instructions). @xref{Density Instructions, ,Using Density Instructions}. If the processor is configured with the density option, this is enabled by default; otherwise, it is always disabled. @item --relax | --no-relax @kindex --relax @kindex --no-relax Enable or disable relaxation of instructions with immediate operands that are outside the legal range for the instructions. @xref{Xtensa Relaxation, ,Xtensa Relaxation}. The default is @samp{--relax} and this default should almost always be used. If relaxation is disabled with @samp{--no-relax}, instruction operands that are out of range will cause errors. Note: In the current implementation, these options also control whether assembler optimizations are performed, making these options equivalent to @samp{--generics} and @samp{--no-generics}. @item --generics | --no-generics @kindex --generics @kindex --no-generics Enable or disable all assembler transformations of Xtensa instructions, including both relaxation and optimization. The default is @samp{--generics}; @samp{--no-generics} should only be used in the rare cases when the instructions must be exactly as specified in the assembly source. @c The @samp{--no-generics} option is like @samp{--no-relax} @c except that it also disables assembler optimizations (@pxref{Xtensa @c Optimizations}). As with @samp{--no-relax}, using @samp{--no-generics} causes out of range instruction operands to be errors. @item --text-section-literals | --no-text-section-literals @kindex --text-section-literals @kindex --no-text-section-literals Control the treatment of literal pools. The default is @samp{--no-@-text-@-section-@-literals}, which places literals in a separate section in the output file. This allows the literal pool to be placed in a data RAM/ROM, and it also allows the linker to combine literal pools from separate object files to remove redundant literals and improve code size. With @samp{--text-@-section-@-literals}, the literals are interspersed in the text section in order to keep them as close as possible to their references. This may be necessary for large assembly files. @item --target-align | --no-target-align @kindex --target-align @kindex --no-target-align Enable or disable automatic alignment to reduce branch penalties at some expense in code size. @xref{Xtensa Automatic Alignment, ,Automatic Instruction Alignment}. This optimization is enabled by default. Note that the assembler will always align instructions like @code{LOOP} that have fixed alignment requirements. @item --longcalls | --no-longcalls @kindex --longcalls @kindex --no-longcalls Enable or disable transformation of call instructions to allow calls across a greater range of addresses. @xref{Xtensa Call Relaxation, ,Function Call Relaxation}. This option should be used when call targets can potentially be out of range, but it degrades both code size and performance. The default is @samp{--no-@-longcalls}. @end table @node Xtensa Syntax @section Assembler Syntax @cindex syntax, Xtensa assembler @cindex Xtensa assembler syntax Block comments are delimited by @samp{/*} and @samp{*/}. End of line comments may be introduced with either @samp{#} or @samp{//}. Instructions consist of a leading opcode or macro name followed by whitespace and an optional comma-separated list of operands: @smallexample @var{opcode} [@var{operand},@dots{}] @end smallexample Instructions must be separated by a newline or semicolon. @menu * Xtensa Opcodes:: Opcode Naming Conventions. * Xtensa Registers:: Register Naming. @end menu @node Xtensa Opcodes @subsection Opcode Names @cindex Xtensa opcode names @cindex opcode names, Xtenxa See the @cite{Xtensa Instruction Set Architecture (ISA) Reference Manual} for a complete list of opcodes and descriptions of their semantics. @cindex generic opcodes @cindex specific opcodes @cindex _ opcode prefix The Xtensa assembler distinguishes between @dfn{generic} and @dfn{specific} opcodes. Specific opcodes correspond directly to Xtensa machine instructions. Prefixing an opcode with an underscore character (@samp{_}) identifies it as a specific opcode. Opcodes without a leading underscore are generic, which means the assembler is required to preserve their semantics but may not translate them directly to the specific opcodes with the same names. Instead, the assembler may optimize a generic opcode and select a better instruction to use in its place (@pxref{Xtensa Optimizations, ,Xtensa Optimizations}), or the assembler may relax the instruction to handle operands that are out of range for the corresponding specific opcode (@pxref{Xtensa Relaxation, ,Xtensa Relaxation}). Only use specific opcodes when it is essential to select the exact machine instructions produced by the assembler. Using specific opcodes unnecessarily only makes the code less efficient, by disabling assembler optimization, and less flexible, by disabling relaxation. Note that this special handling of underscore prefixes only applies to Xtensa opcodes, not to either built-in macros or user-defined macros. When an underscore prefix is used with a macro (e.g., @code{_NOP}), it refers to a different macro. The assembler generally provides built-in macros both with and without the underscore prefix, where the underscore versions behave as if the underscore carries through to the instructions in the macros. For example, @code{_NOP} expands to @code{_OR a1,a1,a1}. The underscore prefix only applies to individual instructions, not to series of instructions. For example, if a series of instructions have underscore prefixes, the assembler will not transform the individual instructions, but it may insert other instructions between them (e.g., to align a @code{LOOP} instruction). To prevent the assembler from modifying a series of instructions as a whole, use the @code{no-generics} directive. @xref{Generics Directive, ,generics}. @node Xtensa Registers @subsection Register Names @cindex Xtensa register names @cindex register names, Xtensa @cindex sp register An initial @samp{$} character is optional in all register names. General purpose registers are named @samp{a0}@dots{}@samp{a15}. Additional registers may be added by processor configuration options. In particular, the @sc{mac16} option adds a @sc{mr} register bank. Its registers are named @samp{m0}@dots{}@samp{m3}. As a special feature, @samp{sp} is also supported as a synonym for @samp{a1}. @node Xtensa Optimizations @section Xtensa Optimizations @cindex optimizations The optimizations currently supported by @code{@value{AS}} are generation of density instructions where appropriate and automatic branch target alignment. @menu * Density Instructions:: Using Density Instructions. * Xtensa Automatic Alignment:: Automatic Instruction Alignment. @end menu @node Density Instructions @subsection Using Density Instructions @cindex density instructions The Xtensa instruction set has a code density option that provides 16-bit versions of some of the most commonly used opcodes. Use of these opcodes can significantly reduce code size. When possible, the assembler automatically translates generic instructions from the core Xtensa instruction set into equivalent instructions from the Xtensa code density option. This translation can be disabled by using specific opcodes (@pxref{Xtensa Opcodes, ,Opcode Names}), by using the @samp{--no-density} command-line option (@pxref{Xtensa Options, ,Command Line Options}), or by using the @code{no-density} directive (@pxref{Density Directive, ,density}). It is a good idea @emph{not} to use the density instuctions directly. The assembler will automatically select dense instructions where possible. If you later need to avoid using the code density option, you can disable it in the assembler without having to modify the code. @node Xtensa Automatic Alignment @subsection Automatic Instruction Alignment @cindex alignment of @code{LOOP} instructions @cindex alignment of @code{ENTRY} instructions @cindex alignment of branch targets @cindex @code{LOOP} instructions, alignment @cindex @code{ENTRY} instructions, alignment @cindex branch target alignment The Xtensa assembler will automatically align certain instructions, both to optimize performance and to satisfy architectural requirements. When the @code{--target-@-align} command-line option is enabled (@pxref{Xtensa Options, ,Command Line Options}), the assembler attempts to widen density instructions preceding a branch target so that the target instruction does not cross a 4-byte boundary. Similarly, the assembler also attempts to align each instruction following a call instruction. If there are not enough preceding safe density instructions to align a target, no widening will be performed. This alignment has the potential to reduce branch penalties at some expense in code size. The assembler will not attempt to align labels with the prefixes @code{.Ln} and @code{.LM}, since these labels are used for debugging information and are not typically branch targets. The @code{LOOP} family of instructions must be aligned on either a 1 or 2 mod 4 byte boundary. The assembler knows about this restriction and inserts the minimal number of 2 or 3 byte no-op instructions to satisfy it. When no-op instructions are added, any label immediately preceding the original loop will be moved in order to refer to the loop instruction, not the newly generated no-op instruction. Similarly, the @code{ENTRY} instruction must be aligned on a 0 mod 4 byte boundary. The assembler satisfies this requirement by inserting zero bytes when required. In addition, labels immediately preceding the @code{ENTRY} instruction will be moved to the newly aligned instruction location. @node Xtensa Relaxation @section Xtensa Relaxation @cindex relaxation When an instruction operand is outside the range allowed for that particular instruction field, @code{@value{AS}} can transform the code to use a functionally-equivalent instruction or sequence of instructions. This process is known as @dfn{relaxation}. This is typically done for branch instructions because the distance of the branch targets is not known until assembly-time. The Xtensa assembler offers branch relaxation and also extends this concept to function calls, @code{MOVI} instructions and other instructions with immediate fields. @menu * Xtensa Branch Relaxation:: Relaxation of Branches. * Xtensa Call Relaxation:: Relaxation of Function Calls. * Xtensa Immediate Relaxation:: Relaxation of other Immediate Fields. @end menu @node Xtensa Branch Relaxation @subsection Conditional Branch Relaxation @cindex relaxation of branch instructions @cindex branch instructions, relaxation When the target of a branch is too far away from the branch itself, i.e., when the offset from the branch to the target is too large to fit in the immediate field of the branch instruction, it may be necessary to replace the branch with a branch around a jump. For example, @smallexample beqz a2, L @end smallexample may result in: @smallexample bnez.n a2, M j L M: @end smallexample (The @code{BNEZ.N} instruction would be used in this example only if the density option is available. Otherwise, @code{BNEZ} would be used.) @node Xtensa Call Relaxation @subsection Function Call Relaxation @cindex relaxation of call instructions @cindex call instructions, relaxation Function calls may require relaxation because the Xtensa immediate call instructions (@code{CALL0}, @code{CALL4}, @code{CALL8} and @code{CALL12}) provide a PC-relative offset of only 512 Kbytes in either direction. For larger programs, it may be necessary to use indirect calls (@code{CALLX0}, @code{CALLX4}, @code{CALLX8} and @code{CALLX12}) where the target address is specified in a register. The Xtensa assembler can automatically relax immediate call instructions into indirect call instructions. This relaxation is done by loading the address of the called function into the callee's return address register and then using a @code{CALLX} instruction. So, for example: @smallexample call8 func @end smallexample might be relaxed to: @smallexample .literal .L1, func l32r a8, .L1 callx8 a8 @end smallexample Because the addresses of targets of function calls are not generally known until link-time, the assembler must assume the worst and relax all the calls to functions in other source files, not just those that really will be out of range. The linker can recognize calls that were unnecessarily relaxed, but it can only partially remove the overhead introduced by the assembler. Call relaxation has a negative effect on both code size and performance, so this relaxation is disabled by default. If a program is too large and some of the calls are out of range, function call relaxation can be enabled using the @samp{--longcalls} command-line option or the @code{longcalls} directive (@pxref{Longcalls Directive, ,longcalls}). @node Xtensa Immediate Relaxation @subsection Other Immediate Field Relaxation @cindex immediate fields, relaxation @cindex relaxation of immediate fields @cindex @code{MOVI} instructions, relaxation @cindex relaxation of @code{MOVI} instructions The @code{MOVI} machine instruction can only materialize values in the range from -2048 to 2047. Values outside this range are best materalized with @code{L32R} instructions. Thus: @smallexample movi a0, 100000 @end smallexample is assembled into the following machine code: @smallexample .literal .L1, 100000 l32r a0, .L1 @end smallexample @cindex @code{L8UI} instructions, relaxation @cindex @code{L16SI} instructions, relaxation @cindex @code{L16UI} instructions, relaxation @cindex @code{L32I} instructions, relaxation @cindex relaxation of @code{L8UI} instructions @cindex relaxation of @code{L16SI} instructions @cindex relaxation of @code{L16UI} instructions @cindex relaxation of @code{L32I} instructions The @code{L8UI} machine instruction can only be used with immediate offsets in the range from 0 to 255. The @code{L16SI} and @code{L16UI} machine instructions can only be used with offsets from 0 to 510. The @code{L32I} machine instruction can only be used with offsets from 0 to 1020. A load offset outside these ranges can be materalized with an @code{L32R} instruction if the destination register of the load is different than the source address register. For example: @smallexample l32i a1, a0, 2040 @end smallexample is translated to: @smallexample .literal .L1, 2040 l32r a1, .L1 addi a1, a0, a1 l32i a1, a1, 0 @end smallexample @noindent If the load destination and source address register are the same, an out-of-range offset causes an error. @cindex @code{ADDI} instructions, relaxation @cindex relaxation of @code{ADDI} instructions The Xtensa @code{ADDI} instruction only allows immediate operands in the range from -128 to 127. There are a number of alternate instruction sequences for the generic @code{ADDI} operation. First, if the immediate is 0, the @code{ADDI} will be turned into a @code{MOV.N} instruction (or the equivalent @code{OR} instruction if the code density option is not available). If the @code{ADDI} immediate is outside of the range -128 to 127, but inside the range -32896 to 32639, an @code{ADDMI} instruction or @code{ADDMI}/@code{ADDI} sequence will be used. Finally, if the immediate is outside of this range and a free register is available, an @code{L32R}/@code{ADD} sequence will be used with a literal allocated from the literal pool. For example: @smallexample addi a5, a6, 0 addi a5, a6, 512 addi a5, a6, 513 addi a5, a6, 50000 @end smallexample is assembled into the following: @smallexample .literal .L1, 50000 mov.n a5, a6 addmi a5, a6, 0x200 addmi a5, a6, 0x200 addi a5, a5, 1 l32r a5, .L1 add a5, a6, a5 @end smallexample @node Xtensa Directives @section Directives @cindex Xtensa directives @cindex directives, Xtensa The Xtensa assember supports a region-based directive syntax: @smallexample .begin @var{directive} [@var{options}] @dots{} .end @var{directive} @end smallexample All the Xtensa-specific directives that apply to a region of code use this syntax. The directive applies to code between the @code{.begin} and the @code{.end}. The state of the option after the @code{.end} reverts to what it was before the @code{.begin}. A nested @code{.begin}/@code{.end} region can further change the state of the directive without having to be aware of its outer state. For example, consider: @smallexample .begin no-density L: add a0, a1, a2 .begin density M: add a0, a1, a2 .end density N: add a0, a1, a2 .end no-density @end smallexample The generic @code{ADD} opcodes at @code{L} and @code{N} in the outer @code{no-density} region both result in @code{ADD} machine instructions, but the assembler selects an @code{ADD.N} instruction for the generic @code{ADD} at @code{M} in the inner @code{density} region. The advantage of this style is that it works well inside macros which can preserve the context of their callers. @cindex precedence of directives @cindex directives, precedence When command-line options and assembler directives are used at the same time and conflict, the one that overrides a default behavior takes precedence over one that is the same as the default. For example, if the code density option is available, the default is to select density instructions whenever possible. So, if the above is assembled with the @samp{--no-density} flag, which overrides the default, all the generic @code{ADD} instructions result in @code{ADD} machine instructions. If assembled with the @samp{--density} flag, which is already the default, the @code{no-density} directive takes precedence and only one of the generic @code{ADD} instructions is optimized to be a @code{ADD.N} machine instruction. An underscore prefix identifying a specific opcode always takes precedence over directives and command-line flags. The following directives are available: @menu * Density Directive:: Disable Use of Density Instructions. * Relax Directive:: Disable Assembler Relaxation. * Longcalls Directive:: Use Indirect Calls for Greater Range. * Generics Directive:: Disable All Assembler Transformations. * Literal Directive:: Intermix Literals with Instructions. * Literal Position Directive:: Specify Inline Literal Pool Locations. * Literal Prefix Directive:: Specify Literal Section Name Prefix. * Freeregs Directive:: List Registers Available for Assembler Use. * Frame Directive:: Describe a stack frame. @end menu @node Density Directive @subsection density @cindex @code{density} directive @cindex @code{no-density} directive The @code{density} and @code{no-density} directives enable or disable optimization of generic instructions into density instructions within the region. @xref{Density Instructions, ,Using Density Instructions}. @smallexample .begin [no-]density .end [no-]density @end smallexample This optimization is enabled by default unless the Xtensa configuration does not support the code density option or the @samp{--no-density} command-line option was specified. @node Relax Directive @subsection relax @cindex @code{relax} directive @cindex @code{no-relax} directive The @code{relax} directive enables or disables relaxation within the region. @xref{Xtensa Relaxation, ,Xtensa Relaxation}. Note: In the current implementation, these directives also control whether assembler optimizations are performed, making them equivalent to the @code{generics} and @code{no-generics} directives. @smallexample .begin [no-]relax .end [no-]relax @end smallexample Relaxation is enabled by default unless the @samp{--no-relax} command-line option was specified. @node Longcalls Directive @subsection longcalls @cindex @code{longcalls} directive @cindex @code{no-longcalls} directive The @code{longcalls} directive enables or disables function call relaxation. @xref{Xtensa Call Relaxation, ,Function Call Relaxation}. @smallexample .begin [no-]longcalls .end [no-]longcalls @end smallexample Call relaxation is disabled by default unless the @samp{--longcalls} command-line option is specified. @node Generics Directive @subsection generics @cindex @code{generics} directive @cindex @code{no-generics} directive This directive enables or disables all assembler transformation, including relaxation (@pxref{Xtensa Relaxation, ,Xtensa Relaxation}) and optimization (@pxref{Xtensa Optimizations, ,Xtensa Optimizations}). @smallexample .begin [no-]generics .end [no-]generics @end smallexample Disabling generics is roughly equivalent to adding an underscore prefix to every opcode within the region, so that every opcode is treated as a specific opcode. @xref{Xtensa Opcodes, ,Opcode Names}. In the current implementation of @code{@value{AS}}, built-in macros are also disabled within a @code{no-generics} region. @node Literal Directive @subsection literal @cindex @code{literal} directive The @code{.literal} directive is used to define literal pool data, i.e., read-only 32-bit data accessed via @code{L32R} instructions. @smallexample .literal @var{label}, @var{value}[, @var{value}@dots{}] @end smallexample This directive is similar to the standard @code{.word} directive, except that the actual location of the literal data is determined by the assembler and linker, not by the position of the @code{.literal} directive. Using this directive gives the assembler freedom to locate the literal data in the most appropriate place and possibly to combine identical literals. For example, the code: @smallexample entry sp, 40 .literal .L1, sym l32r a4, .L1 @end smallexample can be used to load a pointer to the symbol @code{sym} into register @code{a4}. The value of @code{sym} will not be placed between the @code{ENTRY} and @code{L32R} instructions; instead, the assembler puts the data in a literal pool. By default literal pools are placed in a separate section; however, when using the @samp{--text-@-section-@-literals} option (@pxref{Xtensa Options, ,Command Line Options}), the literal pools are placed in the current section. These text section literal pools are created automatically before @code{ENTRY} instructions and manually after @samp{.literal_position} directives (@pxref{Literal Position Directive, ,literal_position}). If there are no preceding @code{ENTRY} instructions or @code{.literal_position} directives, the assembler will print a warning and place the literal pool at the beginning of the current section. In such cases, explicit @code{.literal_position} directives should be used to place the literal pools. @node Literal Position Directive @subsection literal_position @cindex @code{literal_position} directive When using @samp{--text-@-section-@-literals} to place literals inline in the section being assembled, the @code{.literal_position} directive can be used to mark a potential location for a literal pool. @smallexample .literal_position @end smallexample The @code{.literal_position} directive is ignored when the @samp{--text-@-section-@-literals} option is not used. The assembler will automatically place text section literal pools before @code{ENTRY} instructions, so the @code{.literal_position} directive is only needed to specify some other location for a literal pool. You may need to add an explicit jump instruction to skip over an inline literal pool. For example, an interrupt vector does not begin with an @code{ENTRY} instruction so the assembler will be unable to automatically find a good place to put a literal pool. Moreover, the code for the interrupt vector must be at a specific starting address, so the literal pool cannot come before the start of the code. The literal pool for the vector must be explicitly positioned in the middle of the vector (before any uses of the literals, of course). The @code{.literal_position} directive can be used to do this. In the following code, the literal for @samp{M} will automatically be aligned correctly and is placed after the unconditional jump. @smallexample .global M code_start: j continue .literal_position .align 4 continue: movi a4, M @end smallexample @node Literal Prefix Directive @subsection literal_prefix @cindex @code{literal_prefix} directive The @code{literal_prefix} directive allows you to specify different sections to hold literals from different portions of an assembly file. With this directive, a single assembly file can be used to generate code into multiple sections, including literals generated by the assembler. @smallexample .begin literal_prefix [@var{name}] .end literal_prefix @end smallexample For the code inside the delimited region, the assembler puts literals in the section @code{@var{name}.literal}. If this section does not yet exist, the assembler creates it. The @var{name} parameter is optional. If @var{name} is not specified, the literal prefix is set to the ``default'' for the file. This default is usually @code{.literal} but can be changed with the @samp{--rename-section} command-line argument. @node Freeregs Directive @subsection freeregs @cindex @code{freeregs} directive This directive tells the assembler that the given registers are unused in the region. @smallexample .begin freeregs @var{ri}[,@var{ri}@dots{}] .end freeregs @end smallexample This allows the assembler to use these registers for relaxations or optimizations. (They are actually only for relaxations at present, but the possibility of optimizations exists in the future.) Nested @code{freeregs} directives can be used to add additional registers to the list of those available to the assembler. For example: @smallexample .begin freeregs a3, a4 .begin freeregs a5 @end smallexample has the effect of declaring @code{a3}, @code{a4}, and @code{a5} all free. @node Frame Directive @subsection frame @cindex @code{frame} directive This directive tells the assembler to emit information to allow the debugger to locate a function's stack frame. The syntax is: @smallexample .frame @var{reg}, @var{size} @end smallexample where @var{reg} is the register used to hold the frame pointer (usually the same as the stack pointer) and @var{size} is the size in bytes of the stack frame. The @code{.frame} directive is typically placed immediately after the @code{ENTRY} instruction for a function. In almost all circumstances, this information just duplicates the information given in the function's @code{ENTRY} instruction; however, there are two cases where this is not true: @enumerate @item The size of the stack frame is too big to fit in the immediate field of the @code{ENTRY} instruction. @item The frame pointer is different than the stack pointer, as with functions that call @code{alloca}. @end enumerate @c Local Variables: @c fill-column: 72 @c End: