call __tls_get_addr, %tldm_call(symbol) nop sethi %tldo_hix22(symbol), %l1 xor %l1, %tldo_lox10(symbol), %l1 add %o0, %l1, %l1, %tldo_add(symbol) Initial Exec: sethi %tie_hi22(symbol), %l1 add %l1, %tie_lo10(symbol), %l1 ld [%l7 + %l1], %o0, %tie_ld(symbol) add %g7, %o0, %o0, %tie_add(symbol) sethi %tie_hi22(symbol), %l1 add %l1, %tie_lo10(symbol), %l1 ldx [%l7 + %l1], %o0, %tie_ldx(symbol) add %g7, %o0, %o0, %tie_add(symbol) And finally, Local Exec: sethi %tle_hix22(symbol), %l1 add %l1, %tle_lox10(symbol), %l1 add %g7, %l1, %l1 When assembling for 64-bit, and a secondary constant addend is specified in an address expression that would normally generate an `R_SPARC_LO10' relocation, the assembler will emit an `R_SPARC_OLO10' instead.  File: as.info, Node: Sparc-Size-Translations, Prev: Sparc-Relocs, Up: Sparc-Syntax 9.35.3.5 Size Translations .......................... Often it is desirable to write code in an operand size agnostic manner. `as' provides support for this via operand size opcode translations. Translations are supported for loads, stores, shifts, compare-and-swap atomics, and the `clr' synthetic instruction. If generating 32-bit code, `as' will generate the 32-bit opcode. Whereas if 64-bit code is being generated, the 64-bit opcode will be emitted. For example `ldn' will be transformed into `ld' for 32-bit code and `ldx' for 64-bit code. Here is an example meant to demonstrate all the supported opcode translations: ldn [%o0], %o1 ldna [%o0] %asi, %o2 stn %o1, [%o0] stna %o2, [%o0] %asi slln %o3, 3, %o3 srln %o4, 8, %o4 sran %o5, 12, %o5 casn [%o0], %o1, %o2 casna [%o0] %asi, %o1, %o2 clrn %g1 In 32-bit mode `as' will emit: ld [%o0], %o1 lda [%o0] %asi, %o2 st %o1, [%o0] sta %o2, [%o0] %asi sll %o3, 3, %o3 srl %o4, 8, %o4 sra %o5, 12, %o5 cas [%o0], %o1, %o2 casa [%o0] %asi, %o1, %o2 clr %g1 And in 64-bit mode `as' will emit: ldx [%o0], %o1 ldxa [%o0] %asi, %o2 stx %o1, [%o0] stxa %o2, [%o0] %asi sllx %o3, 3, %o3 srlx %o4, 8, %o4 srax %o5, 12, %o5 casx [%o0], %o1, %o2 casxa [%o0] %asi, %o1, %o2 clrx %g1 Finally, the `.nword' translating directive is supported as well. It is documented in the section on Sparc machine directives.  File: as.info, Node: Sparc-Float, Next: Sparc-Directives, Prev: Sparc-Syntax, Up: Sparc-Dependent 9.35.4 Floating Point --------------------- The Sparc uses IEEE floating-point numbers.  File: as.info, Node: Sparc-Directives, Prev: Sparc-Float, Up: Sparc-Dependent 9.35.5 Sparc Machine Directives ------------------------------- The Sparc version of `as' supports the following additional machine directives: `.align' This must be followed by the desired alignment in bytes. `.common' This must be followed by a symbol name, a positive number, and `"bss"'. This behaves somewhat like `.comm', but the syntax is different. `.half' This is functionally identical to `.short'. `.nword' On the Sparc, the `.nword' directive produces native word sized value, ie. if assembling with -32 it is equivalent to `.word', if assembling with -64 it is equivalent to `.xword'. `.proc' This directive is ignored. Any text following it on the same line is also ignored. `.register' This directive declares use of a global application or system register. It must be followed by a register name %g2, %g3, %g6 or %g7, comma and the symbol name for that register. If symbol name is `#scratch', it is a scratch register, if it is `#ignore', it just suppresses any errors about using undeclared global register, but does not emit any information about it into the object file. This can be useful e.g. if you save the register before use and restore it after. `.reserve' This must be followed by a symbol name, a positive number, and `"bss"'. This behaves somewhat like `.lcomm', but the syntax is different. `.seg' This must be followed by `"text"', `"data"', or `"data1"'. It behaves like `.text', `.data', or `.data 1'. `.skip' This is functionally identical to the `.space' directive. `.word' On the Sparc, the `.word' directive produces 32 bit values, instead of the 16 bit values it produces on many other machines. `.xword' On the Sparc V9 processor, the `.xword' directive produces 64 bit values.  File: as.info, Node: TIC54X-Dependent, Next: TIC6X-Dependent, Prev: Sparc-Dependent, Up: Machine Dependencies 9.36 TIC54X Dependent Features ============================== * Menu: * TIC54X-Opts:: Command-line Options * TIC54X-Block:: Blocking * TIC54X-Env:: Environment Settings * TIC54X-Constants:: Constants Syntax * TIC54X-Subsyms:: String Substitution * TIC54X-Locals:: Local Label Syntax * TIC54X-Builtins:: Builtin Assembler Math Functions * TIC54X-Ext:: Extended Addressing Support * TIC54X-Directives:: Directives * TIC54X-Macros:: Macro Features * TIC54X-MMRegs:: Memory-mapped Registers  File: as.info, Node: TIC54X-Opts, Next: TIC54X-Block, Up: TIC54X-Dependent 9.36.1 Options -------------- The TMS320C54X version of `as' has a few machine-dependent options. You can use the `-mfar-mode' option to enable extended addressing mode. All addresses will be assumed to be > 16 bits, and the appropriate relocation types will be used. This option is equivalent to using the `.far_mode' directive in the assembly code. If you do not use the `-mfar-mode' option, all references will be assumed to be 16 bits. This option may be abbreviated to `-mf'. You can use the `-mcpu' option to specify a particular CPU. This option is equivalent to using the `.version' directive in the assembly code. For recognized CPU codes, see *Note `.version': TIC54X-Directives. The default CPU version is `542'. You can use the `-merrors-to-file' option to redirect error output to a file (this provided for those deficient environments which don't provide adequate output redirection). This option may be abbreviated to `-me'.  File: as.info, Node: TIC54X-Block, Next: TIC54X-Env, Prev: TIC54X-Opts, Up: TIC54X-Dependent 9.36.2 Blocking --------------- A blocked section or memory block is guaranteed not to cross the blocking boundary (usually a page, or 128 words) if it is smaller than the blocking size, or to start on a page boundary if it is larger than the blocking size.  File: as.info, Node: TIC54X-Env, Next: TIC54X-Constants, Prev: TIC54X-Block, Up: TIC54X-Dependent 9.36.3 Environment Settings --------------------------- `C54XDSP_DIR' and `A_DIR' are semicolon-separated paths which are added to the list of directories normally searched for source and include files. `C54XDSP_DIR' will override `A_DIR'.  File: as.info, Node: TIC54X-Constants, Next: TIC54X-Subsyms, Prev: TIC54X-Env, Up: TIC54X-Dependent 9.36.4 Constants Syntax ----------------------- The TIC54X version of `as' allows the following additional constant formats, using a suffix to indicate the radix: Binary `000000B, 011000b' Octal `10Q, 224q' Hexadecimal `45h, 0FH'  File: as.info, Node: TIC54X-Subsyms, Next: TIC54X-Locals, Prev: TIC54X-Constants, Up: TIC54X-Dependent 9.36.5 String Substitution -------------------------- A subset of allowable symbols (which we'll call subsyms) may be assigned arbitrary string values. This is roughly equivalent to C preprocessor #define macros. When `as' encounters one of these symbols, the symbol is replaced in the input stream by its string value. Subsym names *must* begin with a letter. Subsyms may be defined using the `.asg' and `.eval' directives (*Note `.asg': TIC54X-Directives, *Note `.eval': TIC54X-Directives. Expansion is recursive until a previously encountered symbol is seen, at which point substitution stops. In this example, x is replaced with SYM2; SYM2 is replaced with SYM1, and SYM1 is replaced with x. At this point, x has already been encountered and the substitution stops. .asg "x",SYM1 .asg "SYM1",SYM2 .asg "SYM2",x add x,a ; final code assembled is "add x, a" Macro parameters are converted to subsyms; a side effect of this is the normal `as' '\ARG' dereferencing syntax is unnecessary. Subsyms defined within a macro will have global scope, unless the `.var' directive is used to identify the subsym as a local macro variable *note `.var': TIC54X-Directives. Substitution may be forced in situations where replacement might be ambiguous by placing colons on either side of the subsym. The following code: .eval "10",x LAB:X: add #x, a When assembled becomes: LAB10 add #10, a Smaller parts of the string assigned to a subsym may be accessed with the following syntax: ``:SYMBOL(CHAR_INDEX):'' Evaluates to a single-character string, the character at CHAR_INDEX. ``:SYMBOL(START,LENGTH):'' Evaluates to a substring of SYMBOL beginning at START with length LENGTH.  File: as.info, Node: TIC54X-Locals, Next: TIC54X-Builtins, Prev: TIC54X-Subsyms, Up: TIC54X-Dependent 9.36.6 Local Labels ------------------- Local labels may be defined in two ways: * $N, where N is a decimal number between 0 and 9 * LABEL?, where LABEL is any legal symbol name. Local labels thus defined may be redefined or automatically generated. The scope of a local label is based on when it may be undefined or reset. This happens when one of the following situations is encountered: * .newblock directive *note `.newblock': TIC54X-Directives. * The current section is changed (.sect, .text, or .data) * Entering or leaving an included file * The macro scope where the label was defined is exited  File: as.info, Node: TIC54X-Builtins, Next: TIC54X-Ext, Prev: TIC54X-Locals, Up: TIC54X-Dependent 9.36.7 Math Builtins -------------------- The following built-in functions may be used to generate a floating-point value. All return a floating-point value except `$cvi', `$int', and `$sgn', which return an integer value. ``$acos(EXPR)'' Returns the floating point arccosine of EXPR. ``$asin(EXPR)'' Returns the floating point arcsine of EXPR. ``$atan(EXPR)'' Returns the floating point arctangent of EXPR. ``$atan2(EXPR1,EXPR2)'' Returns the floating point arctangent of EXPR1 / EXPR2. ``$ceil(EXPR)'' Returns the smallest integer not less than EXPR as floating point. ``$cosh(EXPR)'' Returns the floating point hyperbolic cosine of EXPR. ``$cos(EXPR)'' Returns the floating point cosine of EXPR. ``$cvf(EXPR)'' Returns the integer value EXPR converted to floating-point. ``$cvi(EXPR)'' Returns the floating point value EXPR converted to integer. ``$exp(EXPR)'' Returns the floating point value e ^ EXPR. ``$fabs(EXPR)'' Returns the floating point absolute value of EXPR. ``$floor(EXPR)'' Returns the largest integer that is not greater than EXPR as floating point. ``$fmod(EXPR1,EXPR2)'' Returns the floating point remainder of EXPR1 / EXPR2. ``$int(EXPR)'' Returns 1 if EXPR evaluates to an integer, zero otherwise. ``$ldexp(EXPR1,EXPR2)'' Returns the floating point value EXPR1 * 2 ^ EXPR2. ``$log10(EXPR)'' Returns the base 10 logarithm of EXPR. ``$log(EXPR)'' Returns the natural logarithm of EXPR. ``$max(EXPR1,EXPR2)'' Returns the floating point maximum of EXPR1 and EXPR2. ``$min(EXPR1,EXPR2)'' Returns the floating point minimum of EXPR1 and EXPR2. ``$pow(EXPR1,EXPR2)'' Returns the floating point value EXPR1 ^ EXPR2. ``$round(EXPR)'' Returns the nearest integer to EXPR as a floating point number. ``$sgn(EXPR)'' Returns -1, 0, or 1 based on the sign of EXPR. ``$sin(EXPR)'' Returns the floating point sine of EXPR. ``$sinh(EXPR)'' Returns the floating point hyperbolic sine of EXPR. ``$sqrt(EXPR)'' Returns the floating point square root of EXPR. ``$tan(EXPR)'' Returns the floating point tangent of EXPR. ``$tanh(EXPR)'' Returns the floating point hyperbolic tangent of EXPR. ``$trunc(EXPR)'' Returns the integer value of EXPR truncated towards zero as floating point.  File: as.info, Node: TIC54X-Ext, Next: TIC54X-Directives, Prev: TIC54X-Builtins, Up: TIC54X-Dependent 9.36.8 Extended Addressing -------------------------- The `LDX' pseudo-op is provided for loading the extended addressing bits of a label or address. For example, if an address `_label' resides in extended program memory, the value of `_label' may be loaded as follows: ldx #_label,16,a ; loads extended bits of _label or #_label,a ; loads lower 16 bits of _label bacc a ; full address is in accumulator A  File: as.info, Node: TIC54X-Directives, Next: TIC54X-Macros, Prev: TIC54X-Ext, Up: TIC54X-Dependent 9.36.9 Directives ----------------- `.align [SIZE]' `.even' Align the section program counter on the next boundary, based on SIZE. SIZE may be any power of 2. `.even' is equivalent to `.align' with a SIZE of 2. `1' Align SPC to word boundary `2' Align SPC to longword boundary (same as .even) `128' Align SPC to page boundary `.asg STRING, NAME' Assign NAME the string STRING. String replacement is performed on STRING before assignment. `.eval STRING, NAME' Evaluate the contents of string STRING and assign the result as a string to the subsym NAME. String replacement is performed on STRING before assignment. `.bss SYMBOL, SIZE [, [BLOCKING_FLAG] [,ALIGNMENT_FLAG]]' Reserve space for SYMBOL in the .bss section. SIZE is in words. If present, BLOCKING_FLAG indicates the allocated space should be aligned on a page boundary if it would otherwise cross a page boundary. If present, ALIGNMENT_FLAG causes the assembler to allocate SIZE on a long word boundary. `.byte VALUE [,...,VALUE_N]' `.ubyte VALUE [,...,VALUE_N]' `.char VALUE [,...,VALUE_N]' `.uchar VALUE [,...,VALUE_N]' Place one or more bytes into consecutive words of the current section. The upper 8 bits of each word is zero-filled. If a label is used, it points to the word allocated for the first byte encountered. `.clink ["SECTION_NAME"]' Set STYP_CLINK flag for this section, which indicates to the linker that if no symbols from this section are referenced, the section should not be included in the link. If SECTION_NAME is omitted, the current section is used. `.c_mode' TBD. `.copy "FILENAME" | FILENAME' `.include "FILENAME" | FILENAME' Read source statements from FILENAME. The normal include search path is used. Normally .copy will cause statements from the included file to be printed in the assembly listing and .include will not, but this distinction is not currently implemented. `.data' Begin assembling code into the .data section. `.double VALUE [,...,VALUE_N]' `.ldouble VALUE [,...,VALUE_N]' `.float VALUE [,...,VALUE_N]' `.xfloat VALUE [,...,VALUE_N]' Place an IEEE single-precision floating-point representation of one or more floating-point values into the current section. All but `.xfloat' align the result on a longword boundary. Values are stored most-significant word first. `.drlist' `.drnolist' Control printing of directives to the listing file. Ignored. `.emsg STRING' `.mmsg STRING' `.wmsg STRING' Emit a user-defined error, message, or warning, respectively. `.far_mode' Use extended addressing when assembling statements. This should appear only once per file, and is equivalent to the -mfar-mode option *note `-mfar-mode': TIC54X-Opts. `.fclist' `.fcnolist' Control printing of false conditional blocks to the listing file. `.field VALUE [,SIZE]' Initialize a bitfield of SIZE bits in the current section. If VALUE is relocatable, then SIZE must be 16. SIZE defaults to 16 bits. If VALUE does not fit into SIZE bits, the value will be truncated. Successive `.field' directives will pack starting at the current word, filling the most significant bits first, and aligning to the start of the next word if the field size does not fit into the space remaining in the current word. A `.align' directive with an operand of 1 will force the next `.field' directive to begin packing into a new word. If a label is used, it points to the word that contains the specified field. `.global SYMBOL [,...,SYMBOL_N]' `.def SYMBOL [,...,SYMBOL_N]' `.ref SYMBOL [,...,SYMBOL_N]' `.def' nominally identifies a symbol defined in the current file and available to other files. `.ref' identifies a symbol used in the current file but defined elsewhere. Both map to the standard `.global' directive. `.half VALUE [,...,VALUE_N]' `.uhalf VALUE [,...,VALUE_N]' `.short VALUE [,...,VALUE_N]' `.ushort VALUE [,...,VALUE_N]' `.int VALUE [,...,VALUE_N]' `.uint VALUE [,...,VALUE_N]' `.word VALUE [,...,VALUE_N]' `.uword VALUE [,...,VALUE_N]' Place one or more values into consecutive words of the current section. If a label is used, it points to the word allocated for the first value encountered. `.label SYMBOL' Define a special SYMBOL to refer to the load time address of the current section program counter. `.length' `.width' Set the page length and width of the output listing file. Ignored. `.list' `.nolist' Control whether the source listing is printed. Ignored. `.long VALUE [,...,VALUE_N]' `.ulong VALUE [,...,VALUE_N]' `.xlong VALUE [,...,VALUE_N]' Place one or more 32-bit values into consecutive words in the current section. The most significant word is stored first. `.long' and `.ulong' align the result on a longword boundary; `xlong' does not. `.loop [COUNT]' `.break [CONDITION]' `.endloop' Repeatedly assemble a block of code. `.loop' begins the block, and `.endloop' marks its termination. COUNT defaults to 1024, and indicates the number of times the block should be repeated. `.break' terminates the loop so that assembly begins after the `.endloop' directive. The optional CONDITION will cause the loop to terminate only if it evaluates to zero. `MACRO_NAME .macro [PARAM1][,...PARAM_N]' `[.mexit]' `.endm' See the section on macros for more explanation (*Note TIC54X-Macros::. `.mlib "FILENAME" | FILENAME' Load the macro library FILENAME. FILENAME must be an archived library (BFD ar-compatible) of text files, expected to contain only macro definitions. The standard include search path is used. `.mlist' `.mnolist' Control whether to include macro and loop block expansions in the listing output. Ignored. `.mmregs' Define global symbolic names for the 'c54x registers. Supposedly equivalent to executing `.set' directives for each register with its memory-mapped value, but in reality is provided only for compatibility and does nothing. `.newblock' This directive resets any TIC54X local labels currently defined. Normal `as' local labels are unaffected. `.option OPTION_LIST' Set listing options. Ignored. `.sblock "SECTION_NAME" | SECTION_NAME [,"NAME_N" | NAME_N]' Designate SECTION_NAME for blocking. Blocking guarantees that a section will start on a page boundary (128 words) if it would otherwise cross a page boundary. Only initialized sections may be designated with this directive. See also *Note TIC54X-Block::. `.sect "SECTION_NAME"' Define a named initialized section and make it the current section. `SYMBOL .set "VALUE"' `SYMBOL .equ "VALUE"' Equate a constant VALUE to a SYMBOL, which is placed in the symbol table. SYMBOL may not be previously defined. `.space SIZE_IN_BITS' `.bes SIZE_IN_BITS' Reserve the given number of bits in the current section and zero-fill them. If a label is used with `.space', it points to the *first* word reserved. With `.bes', the label points to the *last* word reserved. `.sslist' `.ssnolist' Controls the inclusion of subsym replacement in the listing output. Ignored. `.string "STRING" [,...,"STRING_N"]' `.pstring "STRING" [,...,"STRING_N"]' Place 8-bit characters from STRING into the current section. `.string' zero-fills the upper 8 bits of each word, while `.pstring' puts two characters into each word, filling the most-significant bits first. Unused space is zero-filled. If a label is used, it points to the first word initialized. `[STAG] .struct [OFFSET]' `[NAME_1] element [COUNT_1]' `[NAME_2] element [COUNT_2]' `[TNAME] .tag STAGX [TCOUNT]' `...' `[NAME_N] element [COUNT_N]' `[SSIZE] .endstruct' `LABEL .tag [STAG]' Assign symbolic offsets to the elements of a structure. STAG defines a symbol to use to reference the structure. OFFSET indicates a starting value to use for the first element encountered; otherwise it defaults to zero. Each element can have a named offset, NAME, which is a symbol assigned the value of the element's offset into the structure. If STAG is missing, these become global symbols. COUNT adjusts the offset that many times, as if `element' were an array. `element' may be one of `.byte', `.word', `.long', `.float', or any equivalent of those, and the structure offset is adjusted accordingly. `.field' and `.string' are also allowed; the size of `.field' is one bit, and `.string' is considered to be one word in size. Only element descriptors, structure/union tags, `.align' and conditional assembly directives are allowed within `.struct'/`.endstruct'. `.align' aligns member offsets to word boundaries only. SSIZE, if provided, will always be assigned the size of the structure. The `.tag' directive, in addition to being used to define a structure/union element within a structure, may be used to apply a structure to a symbol. Once applied to LABEL, the individual structure elements may be applied to LABEL to produce the desired offsets using LABEL as the structure base. `.tab' Set the tab size in the output listing. Ignored. `[UTAG] .union' `[NAME_1] element [COUNT_1]' `[NAME_2] element [COUNT_2]' `[TNAME] .tag UTAGX[,TCOUNT]' `...' `[NAME_N] element [COUNT_N]' `[USIZE] .endstruct' `LABEL .tag [UTAG]' Similar to `.struct', but the offset after each element is reset to zero, and the USIZE is set to the maximum of all defined elements. Starting offset for the union is always zero. `[SYMBOL] .usect "SECTION_NAME", SIZE, [,[BLOCKING_FLAG] [,ALIGNMENT_FLAG]]' Reserve space for variables in a named, uninitialized section (similar to .bss). `.usect' allows definitions sections independent of .bss. SYMBOL points to the first location reserved by this allocation. The symbol may be used as a variable name. SIZE is the allocated size in words. BLOCKING_FLAG indicates whether to block this section on a page boundary (128 words) (*note TIC54X-Block::). ALIGNMENT FLAG indicates whether the section should be longword-aligned. `.var SYM[,..., SYM_N]' Define a subsym to be a local variable within a macro. See *Note TIC54X-Macros::. `.version VERSION' Set which processor to build instructions for. Though the following values are accepted, the op is ignored. `541' `542' `543' `545' `545LP' `546LP' `548' `549'  File: as.info, Node: TIC54X-Macros, Next: TIC54X-MMRegs, Prev: TIC54X-Directives, Up: TIC54X-Dependent 9.36.10 Macros -------------- Macros do not require explicit dereferencing of arguments (i.e., \ARG). During macro expansion, the macro parameters are converted to subsyms. If the number of arguments passed the macro invocation exceeds the number of parameters defined, the last parameter is assigned the string equivalent of all remaining arguments. If fewer arguments are given than parameters, the missing parameters are assigned empty strings. To include a comma in an argument, you must enclose the argument in quotes. The following built-in subsym functions allow examination of the string value of subsyms (or ordinary strings). The arguments are strings unless otherwise indicated (subsyms passed as args will be replaced by the strings they represent). ``$symlen(STR)'' Returns the length of STR. ``$symcmp(STR1,STR2)'' Returns 0 if STR1 == STR2, non-zero otherwise. ``$firstch(STR,CH)'' Returns index of the first occurrence of character constant CH in STR. ``$lastch(STR,CH)'' Returns index of the last occurrence of character constant CH in STR. ``$isdefed(SYMBOL)'' Returns zero if the symbol SYMBOL is not in the symbol table, non-zero otherwise. ``$ismember(SYMBOL,LIST)'' Assign the first member of comma-separated string LIST to SYMBOL; LIST is reassigned the remainder of the list. Returns zero if LIST is a null string. Both arguments must be subsyms. ``$iscons(EXPR)'' Returns 1 if string EXPR is binary, 2 if octal, 3 if hexadecimal, 4 if a character, 5 if decimal, and zero if not an integer. ``$isname(NAME)'' Returns 1 if NAME is a valid symbol name, zero otherwise. ``$isreg(REG)'' Returns 1 if REG is a valid predefined register name (AR0-AR7 only). ``$structsz(STAG)'' Returns the size of the structure or union represented by STAG. ``$structacc(STAG)'' Returns the reference point of the structure or union represented by STAG. Always returns zero.  File: as.info, Node: TIC54X-MMRegs, Prev: TIC54X-Macros, Up: TIC54X-Dependent 9.36.11 Memory-mapped Registers ------------------------------- The following symbols are recognized as memory-mapped registers:  File: as.info, Node: TIC6X-Dependent, Next: V850-Dependent, Prev: TIC54X-Dependent, Up: Machine Dependencies 9.37 TIC6X Dependent Features ============================= * Menu: * TIC6X Options:: Options * TIC6X Syntax:: Syntax * TIC6X Directives:: Directives  File: as.info, Node: TIC6X Options, Next: TIC6X Syntax, Up: TIC6X-Dependent 9.37.1 TIC6X Options -------------------- `-march=ARCH' Enable (only) instructions from architecture ARCH. By default, all instructions are permitted. The following values of ARCH are accepted: `c62x', `c64x', `c64x+', `c67x', `c67x+', `c674x'. `-matomic' `-mno-atomic' Enable or disable the optional C64x+ atomic operation instructions. By default, they are enabled if no `-march' option is given, or if an architecture is specified with `-march' that implies these instructions are present (currently, there are no such architectures); they are disabled if an architecture is specified with `-march' on which the instructions are optional or not present. This option overrides such a default from the architecture, independent of the order in which the `-march' or `-matomic' or `-mno-atomic' options are passed. `-mdsbt' `-mno-dsbt' The `-mdsbt' option causes the assembler to generate the `Tag_ABI_DSBT' attribute with a value of 1, indicating that the code is using DSBT addressing. The `-mno-dsbt' option, the default, causes the tag to have a value of 0, indicating that the code does not use DSBT addressing. The linker will emit a warning if objects of different type (DSBT and non-DSBT) are linked together. `-mpid=no' `-mpid=near' `-mpid=far' The `-mpid=' option causes the assembler to generate the `Tag_ABI_PID' attribute with a value indicating the form of data addressing used by the code. `-mpid=no', the default, indicates position-dependent data addressing, `-mpid=near' indicates position-independent addressing with GOT accesses using near DP addressing, and `-mpid=far' indicates position-independent addressing with GOT accesses using far DP addressing. The linker will emit a warning if objects built with different settings of this option are linked together. `-mpic' `-mno-pic' The `-mpic' option causes the assembler to generate the `Tag_ABI_PIC' attribute with a value of 1, indicating that the code is using position-independent code addressing, The `-mno-pic' option, the default, causes the tag to have a value of 0, indicating position-dependent code addressing. The linker will emit a warning if objects of different type (position-dependent and position-independent) are linked together. `-mbig-endian' `-mlittle-endian' Generate code for the specified endianness. The default is little-endian.  File: as.info, Node: TIC6X Syntax, Next: TIC6X Directives, Prev: TIC6X Options, Up: TIC6X-Dependent 9.37.2 TIC6X Syntax ------------------- The presence of a `;' on a line indicates the start of a comment that extends to the end of the current line. If a `#' or `*' appears as the first character of a line, the whole line is treated as a comment. The `@' character can be used instead of a newline to separate statements. Instruction, register and functional unit names are case-insensitive. `as' requires fully-specified functional unit names, such as `.S1', `.L1X' or `.D1T2', on all instructions using a functional unit. For some instructions, there may be syntactic ambiguity between register or functional unit names and the names of labels or other symbols. To avoid this, enclose the ambiguous symbol name in parentheses; register and functional unit names may not be enclosed in parentheses.  File: as.info, Node: TIC6X Directives, Prev: TIC6X Syntax, Up: TIC6X-Dependent 9.37.3 TIC6X Directives ----------------------- Directives controlling the set of instructions accepted by the assembler have effect for instructions between the directive and any subsequent directive overriding it. `.arch ARCH' This has the same effect as `-march=ARCH'. `.atomic' `.noatomic' These have the same effects as `-matomic' and `-mno-atomic'. `.c6xabi_attribute TAG, VALUE' Set the C6000 EABI build attribute TAG to VALUE. The TAG is either an attribute number or one of `Tag_ISA', `Tag_ABI_wchar_t', `Tag_ABI_stack_align_needed', `Tag_ABI_stack_align_preserved', `Tag_ABI_DSBT', `Tag_ABI_PID', `Tag_ABI_PIC', `TAG_ABI_array_object_alignment', `TAG_ABI_array_object_align_expected', `Tag_ABI_compatibility' and `Tag_ABI_conformance'. The VALUE is either a `number', `"string"', or `number, "string"' depending on the tag. `.nocmp' Disallow use of C64x+ compact instructions in the current text section.  File: as.info, Node: Z80-Dependent, Next: Z8000-Dependent, Prev: Xtensa-Dependent, Up: Machine Dependencies 9.38 Z80 Dependent Features =========================== * Menu: * Z80 Options:: Options * Z80 Syntax:: Syntax * Z80 Floating Point:: Floating Point * Z80 Directives:: Z80 Machine Directives * Z80 Opcodes:: Opcodes  File: as.info, Node: Z80 Options, Next: Z80 Syntax, Up: Z80-Dependent 9.38.1 Options -------------- The Zilog Z80 and Ascii R800 version of `as' have a few machine dependent options. `-z80' Produce code for the Z80 processor. There are additional options to request warnings and error messages for undocumented instructions. `-ignore-undocumented-instructions' `-Wnud' Silently assemble undocumented Z80-instructions that have been adopted as documented R800-instructions. `-ignore-unportable-instructions' `-Wnup' Silently assemble all undocumented Z80-instructions. `-warn-undocumented-instructions' `-Wud' Issue warnings for undocumented Z80-instructions that work on R800, do not assemble other undocumented instructions without warning. `-warn-unportable-instructions' `-Wup' Issue warnings for other undocumented Z80-instructions, do not treat any undocumented instructions as errors. `-forbid-undocumented-instructions' `-Fud' Treat all undocumented z80-instructions as errors. `-forbid-unportable-instructions' `-Fup' Treat undocumented z80-instructions that do not work on R800 as errors. `-r800' Produce code for the R800 processor. The assembler does not support undocumented instructions for the R800. In line with common practice, `as' uses Z80 instruction names for the R800 processor, as far as they exist.  File: as.info, Node: Z80 Syntax, Next: Z80 Floating Point, Prev: Z80 Options, Up: Z80-Dependent 9.38.2 Syntax ------------- The assembler syntax closely follows the 'Z80 family CPU User Manual' by Zilog. In expressions a single `=' may be used as "is equal to" comparison operator. Suffices can be used to indicate the radix of integer constants; `H' or `h' for hexadecimal, `D' or `d' for decimal, `Q', `O', `q' or `o' for octal, and `B' for binary. The suffix `b' denotes a backreference to local label. * Menu: * Z80-Chars:: Special Characters * Z80-Regs:: Register Names * Z80-Case:: Case Sensitivity  File: as.info, Node: Z80-Chars, Next: Z80-Regs, Up: Z80 Syntax 9.38.2.1 Special Characters ........................... The semicolon `;' is the line comment character; The dollar sign `$' can be used as a prefix for hexadecimal numbers and as a symbol denoting the current location counter. A backslash `\' is an ordinary character for the Z80 assembler. The single quote `'' must be followed by a closing quote. If there is one character in between, it is a character constant, otherwise it is a string constant.  File: as.info, Node: Z80-Regs, Next: Z80-Case, Prev: Z80-Chars, Up: Z80 Syntax 9.38.2.2 Register Names ....................... The registers are referred to with the letters assigned to them by Zilog. In addition `as' recognizes `ixl' and `ixh' as the least and most significant octet in `ix', and similarly `iyl' and `iyh' as parts of `iy'.  File: as.info, Node: Z80-Case, Prev: Z80-Regs, Up: Z80 Syntax 9.38.2.3 Case Sensitivity ......................... Upper and lower case are equivalent in register names, opcodes, condition codes and assembler directives. The case of letters is significant in labels and symbol names. The case is also important to distinguish the suffix `b' for a backward reference to a local label from the suffix `B' for a number in binary notation.  File: as.info, Node: Z80 Floating Point, Next: Z80 Directives, Prev: Z80 Syntax, Up: Z80-Dependent 9.38.3 Floating Point --------------------- Floating-point numbers are not supported.  File: as.info, Node: Z80 Directives, Next: Z80 Opcodes, Prev: Z80 Floating Point, Up: Z80-Dependent 9.38.4 Z80 Assembler Directives ------------------------------- `as' for the Z80 supports some additional directives for compatibility with other assemblers. These are the additional directives in `as' for the Z80: `db EXPRESSION|STRING[,EXPRESSION|STRING...]' `defb EXPRESSION|STRING[,EXPRESSION|STRING...]' For each STRING the characters are copied to the object file, for each other EXPRESSION the value is stored in one byte. A warning is issued in case of an overflow. `dw EXPRESSION[,EXPRESSION...]' `defw EXPRESSION[,EXPRESSION...]' For each EXPRESSION the value is stored in two bytes, ignoring overflow. `d24 EXPRESSION[,EXPRESSION...]' `def24 EXPRESSION[,EXPRESSION...]' For each EXPRESSION the value is stored in three bytes, ignoring overflow. `d32 EXPRESSION[,EXPRESSION...]' `def32 EXPRESSION[,EXPRESSION...]' For each EXPRESSION the value is stored in four bytes, ignoring overflow. `ds COUNT[, VALUE]' `defs COUNT[, VALUE]' Fill COUNT bytes in the object file with VALUE, if VALUE is omitted it defaults to zero. `SYMBOL equ EXPRESSION' `SYMBOL defl EXPRESSION' These directives set the value of SYMBOL to EXPRESSION. If `equ' is used, it is an error if SYMBOL is already defined. Symbols defined with `equ' are not protected from redefinition. `set' This is a normal instruction on Z80, and not an assembler directive. `psect NAME' A synonym for *Note Section::, no second argument should be given.  File: as.info, Node: Z80 Opcodes, Prev: Z80 Directives, Up: Z80-Dependent 9.38.5 Opcodes -------------- In line with common practice, Z80 mnemonics are used for both the Z80 and the R800. In many instructions it is possible to use one of the half index registers (`ixl',`ixh',`iyl',`iyh') in stead of an 8-bit general purpose register. This yields instructions that are documented on the R800 and undocumented on the Z80. Similarly `in f,(c)' is documented on the R800 and undocumented on the Z80. The assembler also supports the following undocumented Z80-instructions, that have not been adopted in the R800 instruction set: `out (c),0' Sends zero to the port pointed to by register c. `sli M' Equivalent to `M = (M<<1)+1', the operand M can be any operand that is valid for `sla'. One can use `sll' as a synonym for `sli'. `OP (ix+D), R' This is equivalent to ld R, (ix+D) OPC R ld (ix+D), R The operation `OPC' may be any of `res B,', `set B,', `rl', `rlc', `rr', `rrc', `sla', `sli', `sra' and `srl', and the register `R' may be any of `a', `b', `c', `d', `e', `h' and `l'. `OPC (iy+D), R' As above, but with `iy' instead of `ix'. The web site at `http://www.z80.info' is a good starting place to find more information on programming the Z80.  File: as.info, Node: Z8000-Dependent, Next: Vax-Dependent, Prev: Z80-Dependent, Up: Machine Dependencies 9.39 Z8000 Dependent Features ============================= The Z8000 as supports both members of the Z8000 family: the unsegmented Z8002, with 16 bit addresses, and the segmented Z8001 with 24 bit addresses. When the assembler is in unsegmented mode (specified with the `unsegm' directive), an address takes up one word (16 bit) sized register. When the assembler is in segmented mode (specified with the `segm' directive), a 24-bit address takes up a long (32 bit) register. *Note Assembler Directives for the Z8000: Z8000 Directives, for a list of other Z8000 specific assembler directives. * Menu: * Z8000 Options:: Command-line options for the Z8000 * Z8000 Syntax:: Assembler syntax for the Z8000 * Z8000 Directives:: Special directives for the Z8000 * Z8000 Opcodes:: Opcodes  File: as.info, Node: Z8000 Options, Next: Z8000 Syntax, Up: Z8000-Dependent 9.39.1 Options -------------- `-z8001' Generate segmented code by default. `-z8002' Generate unsegmented code by default.  File: as.info, Node: Z8000 Syntax, Next: Z8000 Directives, Prev: Z8000 Options, Up: Z8000-Dependent 9.39.2 Syntax ------------- * Menu: * Z8000-Chars:: Special Characters * Z8000-Regs:: Register Names * Z8000-Addressing:: Addressing Modes  File: as.info, Node: Z8000-Chars, Next: Z8000-Regs, Up: Z8000 Syntax 9.39.2.1 Special Characters ........................... `!' is the line comment character. You can use `;' instead of a newline to separate statements.  File: as.info, Node: Z8000-Regs, Next: Z8000-Addressing, Prev: Z8000-Chars, Up: Z8000 Syntax 9.39.2.2 Register Names ....................... The Z8000 has sixteen 16 bit registers, numbered 0 to 15. You can refer to different sized groups of registers by register number, with the prefix `r' for 16 bit registers, `rr' for 32 bit registers and `rq' for 64 bit registers. You can also refer to the contents of the first eight (of the sixteen 16 bit registers) by bytes. They are named `rlN' and `rhN'. _byte registers_ rl0 rh0 rl1 rh1 rl2 rh2 rl3 rh3 rl4 rh4 rl5 rh5 rl6 rh6 rl7 rh7 _word registers_ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 _long word registers_ rr0 rr2 rr4 rr6 rr8 rr10 rr12 rr14 _quad word registers_ rq0 rq4 rq8 rq12  File: as.info, Node: Z8000-Addressing, Prev: Z8000-Regs, Up: Z8000 Syntax 9.39.2.3 Addressing Modes ......................... as understands the following addressing modes for the Z8000: `rlN' `rhN' `rN' `rrN' `rqN' Register direct: 8bit, 16bit, 32bit, and 64bit registers. `@rN' `@rrN' Indirect register: @rrN in segmented mode, @rN in unsegmented mode. `ADDR' Direct: the 16 bit or 24 bit address (depending on whether the assembler is in segmented or unsegmented mode) of the operand is in the instruction. `address(rN)' Indexed: the 16 or 24 bit address is added to the 16 bit register to produce the final address in memory of the operand. `rN(#IMM)' `rrN(#IMM)' Base Address: the 16 or 24 bit register is added to the 16 bit sign extended immediate displacement to produce the final address in memory of the operand. `rN(rM)' `rrN(rM)' Base Index: the 16 or 24 bit register rN or rrN is added to the sign extended 16 bit index register rM to produce the final address in memory of the operand. `#XX' Immediate data XX.  File: as.info, Node: Z8000 Directives, Next: Z8000 Opcodes, Prev: Z8000 Syntax, Up: Z8000-Dependent 9.39.3 Assembler Directives for the Z8000 ----------------------------------------- The Z8000 port of as includes additional assembler directives, for compatibility with other Z8000 assemblers. These do not begin with `.' (unlike the ordinary as directives). `segm' `.z8001' Generate code for the segmented Z8001. `unsegm' `.z8002' Generate code for the unsegmented Z8002. `name' Synonym for `.file' `global' Synonym for `.global' `wval' Synonym for `.word' `lval' Synonym for `.long' `bval' Synonym for `.byte' `sval' Assemble a string. `sval' expects one string literal, delimited by single quotes. It assembles each byte of the string into consecutive addresses. You can use the escape sequence `%XX' (where XX represents a two-digit hexadecimal number) to represent the character whose ASCII value is XX. Use this feature to describe single quote and other characters that may not appear in string literals as themselves. For example, the C statement `char *a = "he said \"it's 50% off\"";' is represented in Z8000 assembly language (shown with the assembler output in hex at the left) as 68652073 sval 'he said %22it%27s 50%25 off%22%00' 61696420 22697427 73203530 25206F66 662200 `rsect' synonym for `.section' `block' synonym for `.space' `even' special case of `.align'; aligns output to even byte boundary.  File: as.info, Node: Z8000 Opcodes, Prev: Z8000 Directives, Up: Z8000-Dependent 9.39.4 Opcodes -------------- For detailed information on the Z8000 machine instruction set, see `Z8000 Technical Manual'. The following table summarizes the opcodes and their arguments: rs 16 bit source register rd 16 bit destination register rbs 8 bit source register rbd 8 bit destination register rrs 32 bit source register rrd 32 bit destination register rqs 64 bit source register rqd 64 bit destination register addr 16/24 bit address imm immediate data adc rd,rs clrb addr cpsir @rd,@rs,rr,cc adcb rbd,rbs clrb addr(rd) cpsirb @rd,@rs,rr,cc add rd,@rs clrb rbd dab rbd add rd,addr com @rd dbjnz rbd,disp7 add rd,addr(rs) com addr dec @rd,imm4m1 add rd,imm16 com addr(rd) dec addr(rd),imm4m1 add rd,rs com rd dec addr,imm4m1 addb rbd,@rs comb @rd dec rd,imm4m1 addb rbd,addr comb addr decb @rd,imm4m1 addb rbd,addr(rs) comb addr(rd) decb addr(rd),imm4m1 addb rbd,imm8 comb rbd decb addr,imm4m1 addb rbd,rbs comflg flags decb rbd,imm4m1 addl rrd,@rs cp @rd,imm16 di i2 addl rrd,addr cp addr(rd),imm16 div rrd,@rs addl rrd,addr(rs) cp addr,imm16 div rrd,addr addl rrd,imm32 cp rd,@rs div rrd,addr(rs) addl rrd,rrs cp rd,addr div rrd,imm16 and rd,@rs cp rd,addr(rs) div rrd,rs and rd,addr cp rd,imm16 divl rqd,@rs and rd,addr(rs) cp rd,rs divl rqd,addr and rd,imm16 cpb @rd,imm8 divl rqd,addr(rs) and rd,rs cpb addr(rd),imm8 divl rqd,imm32 andb rbd,@rs cpb addr,imm8 divl rqd,rrs andb rbd,addr cpb rbd,@rs djnz rd,disp7 andb rbd,addr(rs) cpb rbd,addr ei i2 andb rbd,imm8 cpb rbd,addr(rs) ex rd,@rs andb rbd,rbs cpb rbd,imm8 ex rd,addr bit @rd,imm4 cpb rbd,rbs ex rd,addr(rs) bit addr(rd),imm4 cpd rd,@rs,rr,cc ex rd,rs bit addr,imm4 cpdb rbd,@rs,rr,cc exb rbd,@rs bit rd,imm4 cpdr rd,@rs,rr,cc exb rbd,addr bit rd,rs cpdrb rbd,@rs,rr,cc exb rbd,addr(rs) bitb @rd,imm4 cpi rd,@rs,rr,cc exb rbd,rbs bitb addr(rd),imm4 cpib rbd,@rs,rr,cc ext0e imm8 bitb addr,imm4 cpir rd,@rs,rr,cc ext0f imm8 bitb rbd,imm4 cpirb rbd,@rs,rr,cc ext8e imm8 bitb rbd,rs cpl rrd,@rs ext8f imm8 bpt cpl rrd,addr exts rrd call @rd cpl rrd,addr(rs) extsb rd call addr cpl rrd,imm32 extsl rqd call addr(rd) cpl rrd,rrs halt calr disp12 cpsd @rd,@rs,rr,cc in rd,@rs clr @rd cpsdb @rd,@rs,rr,cc in rd,imm16 clr addr cpsdr @rd,@rs,rr,cc inb rbd,@rs clr addr(rd) cpsdrb @rd,@rs,rr,cc inb rbd,imm16 clr rd cpsi @rd,@rs,rr,cc inc @rd,imm4m1 clrb @rd cpsib @rd,@rs,rr,cc inc addr(rd),imm4m1 inc addr,imm4m1 ldb rbd,rs(rx) mult rrd,addr(rs) inc rd,imm4m1 ldb rd(imm16),rbs mult rrd,imm16 incb @rd,imm4m1 ldb rd(rx),rbs mult rrd,rs incb addr(rd),imm4m1 ldctl ctrl,rs multl rqd,@rs incb addr,imm4m1 ldctl rd,ctrl multl rqd,addr incb rbd,imm4m1 ldd @rs,@rd,rr multl rqd,addr(rs) ind @rd,@rs,ra lddb @rs,@rd,rr multl rqd,imm32 indb @rd,@rs,rba lddr @rs,@rd,rr multl rqd,rrs inib @rd,@rs,ra lddrb @rs,@rd,rr neg @rd inibr @rd,@rs,ra ldi @rd,@rs,rr neg addr iret ldib @rd,@rs,rr neg addr(rd) jp cc,@rd ldir @rd,@rs,rr neg rd jp cc,addr ldirb @rd,@rs,rr negb @rd jp cc,addr(rd) ldk rd,imm4 negb addr jr cc,disp8 ldl @rd,rrs negb addr(rd) ld @rd,imm16 ldl addr(rd),rrs negb rbd ld @rd,rs ldl addr,rrs nop ld addr(rd),imm16 ldl rd(imm16),rrs or rd,@rs ld addr(rd),rs ldl rd(rx),rrs or rd,addr ld addr,imm16 ldl rrd,@rs or rd,addr(rs) ld addr,rs ldl rrd,addr or rd,imm16 ld rd(imm16),rs ldl rrd,addr(rs) or rd,rs ld rd(rx),rs ldl rrd,imm32 orb rbd,@rs ld rd,@rs ldl rrd,rrs orb rbd,addr ld rd,addr ldl rrd,rs(imm16) orb rbd,addr(rs) ld rd,addr(rs) ldl rrd,rs(rx) orb rbd,imm8 ld rd,imm16 ldm @rd,rs,n orb rbd,rbs ld rd,rs ldm addr(rd),rs,n out @rd,rs ld rd,rs(imm16) ldm addr,rs,n out imm16,rs ld rd,rs(rx) ldm rd,@rs,n outb @rd,rbs lda rd,addr ldm rd,addr(rs),n outb imm16,rbs lda rd,addr(rs) ldm rd,addr,n outd @rd,@rs,ra lda rd,rs(imm16) ldps @rs outdb @rd,@rs,rba lda rd,rs(rx) ldps addr outib @rd,@rs,ra ldar rd,disp16 ldps addr(rs) outibr @rd,@rs,ra ldb @rd,imm8 ldr disp16,rs pop @rd,@rs ldb @rd,rbs ldr rd,disp16 pop addr(rd),@rs ldb addr(rd),imm8 ldrb disp16,rbs pop addr,@rs ldb addr(rd),rbs ldrb rbd,disp16 pop rd,@rs ldb addr,imm8 ldrl disp16,rrs popl @rd,@rs ldb addr,rbs ldrl rrd,disp16 popl addr(rd),@rs ldb rbd,@rs mbit popl addr,@rs ldb rbd,addr mreq rd popl rrd,@rs ldb rbd,addr(rs) mres push @rd,@rs ldb rbd,imm8 mset push @rd,addr ldb rbd,rbs mult rrd,@rs push @rd,addr(rs) ldb rbd,rs(imm16) mult rrd,addr push @rd,imm16 push @rd,rs set addr,imm4 subl rrd,imm32 pushl @rd,@rs set rd,imm4 subl rrd,rrs pushl @rd,addr set rd,rs tcc cc,rd pushl @rd,addr(rs) setb @rd,imm4 tccb cc,rbd pushl @rd,rrs setb addr(rd),imm4 test @rd res @rd,imm4 setb addr,imm4 test addr res addr(rd),imm4 setb rbd,imm4 test addr(rd) res addr,imm4 setb rbd,rs test rd res rd,imm4 setflg imm4 testb @rd res rd,rs sinb rbd,imm16 testb addr resb @rd,imm4 sinb rd,imm16 testb addr(rd) resb addr(rd),imm4 sind @rd,@rs,ra testb rbd resb addr,imm4 sindb @rd,@rs,rba testl @rd resb rbd,imm4 sinib @rd,@rs,ra testl addr resb rbd,rs sinibr @rd,@rs,ra testl addr(rd) resflg imm4 sla rd,imm8 testl rrd ret cc slab rbd,imm8 trdb @rd,@rs,rba rl rd,imm1or2 slal rrd,imm8 trdrb @rd,@rs,rba rlb rbd,imm1or2 sll rd,imm8 trib @rd,@rs,rbr rlc rd,imm1or2 sllb rbd,imm8 trirb @rd,@rs,rbr rlcb rbd,imm1or2 slll rrd,imm8 trtdrb @ra,@rb,rbr rldb rbb,rba sout imm16,rs trtib @ra,@rb,rr rr rd,imm1or2 soutb imm16,rbs trtirb @ra,@rb,rbr rrb rbd,imm1or2 soutd @rd,@rs,ra trtrb @ra,@rb,rbr rrc rd,imm1or2 soutdb @rd,@rs,rba tset @rd rrcb rbd,imm1or2 soutib @rd,@rs,ra tset addr rrdb rbb,rba soutibr @rd,@rs,ra tset addr(rd) rsvd36 sra rd,imm8 tset rd rsvd38 srab rbd,imm8 tsetb @rd rsvd78 sral rrd,imm8 tsetb addr rsvd7e srl rd,imm8 tsetb addr(rd) rsvd9d srlb rbd,imm8 tsetb rbd rsvd9f srll rrd,imm8 xor rd,@rs rsvdb9 sub rd,@rs xor rd,addr rsvdbf sub rd,addr xor rd,addr(rs) sbc rd,rs sub rd,addr(rs) xor rd,imm16 sbcb rbd,rbs sub rd,imm16 xor rd,rs sc imm8 sub rd,rs xorb rbd,@rs sda rd,rs subb rbd,@rs xorb rbd,addr sdab rbd,rs subb rbd,addr xorb rbd,addr(rs) sdal rrd,rs subb rbd,addr(rs) xorb rbd,imm8 sdl rd,rs subb rbd,imm8 xorb rbd,rbs sdlb rbd,rs subb rbd,rbs xorb rbd,rbs sdll rrd,rs subl rrd,@rs set @rd,imm4 subl rrd,addr set addr(rd),imm4 subl rrd,addr(rs)  File: as.info, Node: Vax-Dependent, Prev: Z8000-Dependent, Up: Machine Dependencies 9.40 VAX Dependent Features =========================== * Menu: * VAX-Opts:: VAX Command-Line Options * VAX-float:: VAX Floating Point * VAX-directives:: Vax Machine Directives * VAX-opcodes:: VAX Opcodes * VAX-branch:: VAX Branch Improvement * VAX-operands:: VAX Operands * VAX-no:: Not Supported on VAX  File: as.info, Node: VAX-Opts, Next: VAX-float, Up: Vax-Dependent 9.40.1 VAX Command-Line Options ------------------------------- The Vax version of `as' accepts any of the following options, gives a warning message that the option was ignored and proceeds. These options are for compatibility with scripts designed for other people's assemblers. ``-D' (Debug)' ``-S' (Symbol Table)' ``-T' (Token Trace)' These are obsolete options used to debug old assemblers. ``-d' (Displacement size for JUMPs)' This option expects a number following the `-d'. Like options that expect filenames, the number may immediately follow the `-d' (old standard) or constitute the whole of the command line argument that follows `-d' (GNU standard). ``-V' (Virtualize Interpass Temporary File)' Some other assemblers use a temporary file. This option commanded them to keep the information in active memory rather than in a disk file. `as' always does this, so this option is redundant. ``-J' (JUMPify Longer Branches)' Many 32-bit computers permit a variety of branch instructions to do the same job. Some of these instructions are short (and fast) but have a limited range; others are long (and slow) but can branch anywhere in virtual memory. Often there are 3 flavors of branch: short, medium and long. Some other assemblers would emit short and medium branches, unless told by this option to emit short and long branches. ``-t' (Temporary File Directory)' Some other assemblers may use a temporary file, and this option takes a filename being the directory to site the temporary file. Since `as' does not use a temporary disk file, this option makes no difference. `-t' needs exactly one filename. The Vax version of the assembler accepts additional options when compiled for VMS: `-h N' External symbol or section (used for global variables) names are not case sensitive on VAX/VMS and always mapped to upper case. This is contrary to the C language definition which explicitly distinguishes upper and lower case. To implement a standard conforming C compiler, names must be changed (mapped) to preserve the case information. The default mapping is to convert all lower case characters to uppercase and adding an underscore followed by a 6 digit hex value, representing a 24 digit binary value. The one digits in the binary value represent which characters are uppercase in the original symbol name. The `-h N' option determines how we map names. This takes several values. No `-h' switch at all allows case hacking as described above. A value of zero (`-h0') implies names should be upper case, and inhibits the case hack. A value of 2 (`-h2') implies names should be all lower case, with no case hack. A value of 3 (`-h3') implies that case should be preserved. The value 1 is unused. The `-H' option directs `as' to display every mapped symbol during assembly. Symbols whose names include a dollar sign `$' are exceptions to the general name mapping. These symbols are normally only used to reference VMS library names. Such symbols are always mapped to upper case. `-+' The `-+' option causes `as' to truncate any symbol name larger than 31 characters. The `-+' option also prevents some code following the `_main' symbol normally added to make the object file compatible with Vax-11 "C". `-1' This option is ignored for backward compatibility with `as' version 1.x. `-H' The `-H' option causes `as' to print every symbol which was changed by case mapping.  File: as.info, Node: VAX-float, Next: VAX-directives, Prev: VAX-Opts, Up: Vax-Dependent 9.40.2 VAX Floating Point ------------------------- Conversion of flonums to floating point is correct, and compatible with previous assemblers. Rounding is towards zero if the remainder is exactly half the least significant bit. `D', `F', `G' and `H' floating point formats are understood. Immediate floating literals (_e.g._ `S`$6.9') are rendered correctly. Again, rounding is towards zero in the boundary case. The `.float' directive produces `f' format numbers. The `.double' directive produces `d' format numbers.  File: as.info, Node: VAX-directives, Next: VAX-opcodes, Prev: VAX-float, Up: Vax-Dependent 9.40.3 Vax Machine Directives ----------------------------- The Vax version of the assembler supports four directives for generating Vax floating point constants. They are described in the table below. `.dfloat' This expects zero or more flonums, separated by commas, and assembles Vax `d' format 64-bit floating point constants. `.ffloat' This expects zero or more flonums, separated by commas, and assembles Vax `f' format 32-bit floating point constants. `.gfloat' This expects zero or more flonums, separated by commas, and assembles Vax `g' format 64-bit floating point constants. `.hfloat' This expects zero or more flonums, separated by commas, and assembles Vax `h' format 128-bit floating point constants.  File: as.info, Node: VAX-opcodes, Next: VAX-branch, Prev: VAX-directives, Up: Vax-Dependent 9.40.4 VAX Opcodes ------------------ All DEC mnemonics are supported. Beware that `case...' instructions have exactly 3 operands. The dispatch table that follows the `case...' instruction should be made with `.word' statements. This is compatible with all unix assemblers we know of.  File: as.info, Node: VAX-branch, Next: VAX-operands, Prev: VAX-opcodes, Up: Vax-Dependent 9.40.5 VAX Branch Improvement ----------------------------- Certain pseudo opcodes are permitted. They are for branch instructions. They expand to the shortest branch instruction that reaches the target. Generally these mnemonics are made by substituting `j' for `b' at the start of a DEC mnemonic. This feature is included both for compatibility and to help compilers. If you do not need this feature, avoid these opcodes. Here are the mnemonics, and the code they can expand into. `jbsb' `Jsb' is already an instruction mnemonic, so we chose `jbsb'. (byte displacement) `bsbb ...' (word displacement) `bsbw ...' (long displacement) `jsb ...' `jbr' `jr' Unconditional branch. (byte displacement) `brb ...' (word displacement) `brw ...' (long displacement) `jmp ...' `jCOND' COND may be any one of the conditional branches `neq', `nequ', `eql', `eqlu', `gtr', `geq', `lss', `gtru', `lequ', `vc', `vs', `gequ', `cc', `lssu', `cs'. COND may also be one of the bit tests `bs', `bc', `bss', `bcs', `bsc', `bcc', `bssi', `bcci', `lbs', `lbc'. NOTCOND is the opposite condition to COND. (byte displacement) `bCOND ...' (word displacement) `bNOTCOND foo ; brw ... ; foo:' (long displacement) `bNOTCOND foo ; jmp ... ; foo:' `jacbX' X may be one of `b d f g h l w'. (word displacement) `OPCODE ...' (long displacement) OPCODE ..., foo ; brb bar ; foo: jmp ... ; bar: `jaobYYY' YYY may be one of `lss leq'. `jsobZZZ' ZZZ may be one of `geq gtr'. (byte displacement) `OPCODE ...' (word displacement) OPCODE ..., foo ; brb bar ; foo: brw DESTINATION ; bar: (long displacement) OPCODE ..., foo ; brb bar ; foo: jmp DESTINATION ; bar: `aobleq' `aoblss' `sobgeq' `sobgtr' (byte displacement) `OPCODE ...' (word displacement) OPCODE ..., foo ; brb bar ; foo: brw DESTINATION ; bar: (long displacement) OPCODE ..., foo ; brb bar ; foo: jmp DESTINATION ; bar:  File: as.info, Node: VAX-operands, Next: VAX-no, Prev: VAX-branch, Up: Vax-Dependent 9.40.6 VAX Operands ------------------- The immediate character is `$' for Unix compatibility, not `#' as DEC writes it. The indirect character is `*' for Unix compatibility, not `@' as DEC writes it. The displacement sizing character is ``' (an accent grave) for Unix compatibility, not `^' as DEC writes it. The letter preceding ``' may have either case. `G' is not understood, but all other letters (`b i l s w') are understood. Register names understood are `r0 r1 r2 ... r15 ap fp sp pc'. Upper and lower case letters are equivalent. For instance tstb *w`$4(r5) Any expression is permitted in an operand. Operands are comma separated.  File: as.info, Node: VAX-no, Prev: VAX-operands, Up: Vax-Dependent 9.40.7 Not Supported on VAX --------------------------- Vax bit fields can not be assembled with `as'. Someone can add the required code if they really need it.  File: as.info, Node: V850-Dependent, Next: Xtensa-Dependent, Prev: TIC6X-Dependent, Up: Machine Dependencies 9.41 v850 Dependent Features ============================ * Menu: * V850 Options:: Options * V850 Syntax:: Syntax * V850 Floating Point:: Floating Point * V850 Directives:: V850 Machine Directives * V850 Opcodes:: Opcodes  File: as.info, Node: V850 Options, Next: V850 Syntax, Up: V850-Dependent 9.41.1 Options -------------- `as' supports the following additional command-line options for the V850 processor family: `-wsigned_overflow' Causes warnings to be produced when signed immediate values overflow the space available for then within their opcodes. By default this option is disabled as it is possible to receive spurious warnings due to using exact bit patterns as immediate constants. `-wunsigned_overflow' Causes warnings to be produced when unsigned immediate values overflow the space available for then within their opcodes. By default this option is disabled as it is possible to receive spurious warnings due to using exact bit patterns as immediate constants. `-mv850' Specifies that the assembled code should be marked as being targeted at the V850 processor. This allows the linker to detect attempts to link such code with code assembled for other processors. `-mv850e' Specifies that the assembled code should be marked as being targeted at the V850E processor. This allows the linker to detect attempts to link such code with code assembled for other processors. `-mv850e1' Specifies that the assembled code should be marked as being targeted at the V850E1 processor. This allows the linker to detect attempts to link such code with code assembled for other processors. `-mv850any' Specifies that the assembled code should be marked as being targeted at the V850 processor but support instructions that are specific to the extended variants of the process. This allows the production of binaries that contain target specific code, but which are also intended to be used in a generic fashion. For example libgcc.a contains generic routines used by the code produced by GCC for all versions of the v850 a