| This is as.info, produced by makeinfo version 4.3 from as.texinfo. |
| |
| START-INFO-DIR-ENTRY |
| * As: (as). The GNU assembler. |
| * Gas: (as). The GNU assembler. |
| END-INFO-DIR-ENTRY |
| |
| This file documents the GNU Assembler "as". |
| |
| Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000, 2001, 2002 |
| Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.1 or |
| any later version published by the Free Software Foundation; with no |
| Invariant Sections, with no Front-Cover Texts, and with no Back-Cover |
| Texts. A copy of the license is included in the section entitled "GNU |
| Free Documentation License". |
| |
| |
| File: as.info, Node: SH64 Opcodes, Prev: SH64 Directives, Up: SH64-Dependent |
| |
| Opcodes |
| ------- |
| |
| For detailed information on the SH64 machine instruction set, see |
| `SuperH 64 bit RISC Series Architecture Manual' (SuperH, Inc.). |
| |
| `as' implements all the standard SH64 opcodes. In addition, the |
| following pseudo-opcodes may be expanded into one or more alternate |
| opcodes: |
| |
| `movi' |
| If the value doesn't fit into a standard `movi' opcode, `as' will |
| replace the `movi' with a sequence of `movi' and `shori' opcodes. |
| |
| `pt' |
| This expands to a sequence of `movi' and `shori' opcode, followed |
| by a `ptrel' opcode, or to a `pta' or `ptb' opcode, depending on |
| the label referenced. |
| |
| |
| File: as.info, Node: Sparc-Dependent, Next: TIC54X-Dependent, Prev: PPC-Dependent, Up: Machine Dependencies |
| |
| SPARC Dependent Features |
| ======================== |
| |
| * Menu: |
| |
| * Sparc-Opts:: Options |
| * Sparc-Aligned-Data:: Option to enforce aligned data |
| * Sparc-Float:: Floating Point |
| * Sparc-Directives:: Sparc Machine Directives |
| |
| |
| File: as.info, Node: Sparc-Opts, Next: Sparc-Aligned-Data, Up: Sparc-Dependent |
| |
| Options |
| ------- |
| |
| The SPARC chip family includes several successive levels, using the |
| same core instruction set, but including a few additional instructions |
| at each level. There are exceptions to this however. For details on |
| what instructions each variant supports, please see the chip's |
| architecture reference manual. |
| |
| By default, `as' assumes the core instruction set (SPARC v6), but |
| "bumps" the architecture level as needed: it switches to successively |
| higher architectures as it encounters instructions that only exist in |
| the higher levels. |
| |
| If not configured for SPARC v9 (`sparc64-*-*') GAS will not bump |
| passed sparclite by default, an option must be passed to enable the v9 |
| instructions. |
| |
| GAS treats sparclite as being compatible with v8, unless an |
| architecture is explicitly requested. SPARC v9 is always incompatible |
| with sparclite. |
| |
| `-Av6 | -Av7 | -Av8 | -Asparclet | -Asparclite' |
| `-Av8plus | -Av8plusa | -Av9 | -Av9a' |
| Use one of the `-A' options to select one of the SPARC |
| architectures explicitly. If you select an architecture |
| explicitly, `as' reports a fatal error if it encounters an |
| instruction or feature requiring an incompatible or higher level. |
| |
| `-Av8plus' and `-Av8plusa' select a 32 bit environment. |
| |
| `-Av9' and `-Av9a' select a 64 bit environment and are not |
| available unless GAS is explicitly configured with 64 bit |
| environment support. |
| |
| `-Av8plusa' and `-Av9a' enable the SPARC V9 instruction set with |
| UltraSPARC extensions. |
| |
| `-xarch=v8plus | -xarch=v8plusa' |
| For compatibility with the Solaris v9 assembler. These options are |
| equivalent to -Av8plus and -Av8plusa, respectively. |
| |
| `-bump' |
| Warn whenever it is necessary to switch to another level. If an |
| architecture level is explicitly requested, GAS will not issue |
| warnings until that level is reached, and will then bump the level |
| as required (except between incompatible levels). |
| |
| `-32 | -64' |
| Select the word size, either 32 bits or 64 bits. These options |
| are only available with the ELF object file format, and require |
| that the necessary BFD support has been included. |
| |
| |
| File: as.info, Node: Sparc-Aligned-Data, Next: Sparc-Float, Prev: Sparc-Opts, Up: Sparc-Dependent |
| |
| Enforcing aligned data |
| ---------------------- |
| |
| SPARC GAS normally permits data to be misaligned. For example, it |
| permits the `.long' pseudo-op to be used on a byte boundary. However, |
| the native SunOS and Solaris assemblers issue an error when they see |
| misaligned data. |
| |
| You can use the `--enforce-aligned-data' option to make SPARC GAS |
| also issue an error about misaligned data, just as the SunOS and Solaris |
| assemblers do. |
| |
| The `--enforce-aligned-data' option is not the default because gcc |
| issues misaligned data pseudo-ops when it initializes certain packed |
| data structures (structures defined using the `packed' attribute). You |
| may have to assemble with GAS in order to initialize packed data |
| structures in your own code. |
| |
| |
| File: as.info, Node: Sparc-Float, Next: Sparc-Directives, Prev: Sparc-Aligned-Data, Up: Sparc-Dependent |
| |
| Floating Point |
| -------------- |
| |
| The Sparc uses IEEE floating-point numbers. |
| |
| |
| File: as.info, Node: Sparc-Directives, Prev: Sparc-Float, Up: Sparc-Dependent |
| |
| 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: V850-Dependent, Prev: Sparc-Dependent, Up: Machine Dependencies |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 availalbe 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 |
| |
| 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 |
| |
| Memory-mapped Registers |
| ----------------------- |
| |
| The following symbols are recognized as memory-mapped registers: |
| |
| |
| File: as.info, Node: Z8000-Dependent, Next: Vax-Dependent, Prev: Xtensa-Dependent, Up: Machine Dependencies |
| |
| 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:: No special command-line options for 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 |
| |
| Options |
| ------- |
| |
| `as' has no additional command-line options for the Zilog Z8000 |
| family. |
| |
| |
| File: as.info, Node: Z8000 Syntax, Next: Z8000 Directives, Prev: Z8000 Options, Up: Z8000-Dependent |
| |
| 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 |
| |
| 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 |
| |
| 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 `rNh' |
| and `rNl'. |
| |
| _byte registers_ |
| r0l r0h r1h r1l r2h r2l r3h r3l |
| r4h r4l r5h r5l r6h r6l r7h r7l |
| |
| _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 |
| |
| Addressing Modes |
| ................ |
| |
| as understands the following addressing modes for the Z8000: |
| |
| `rN' |
| Register direct |
| |
| `@rN' |
| Indirect register |
| |
| `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)' |
| 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)' |
| Base Index: the 16 or 24 bit register rN 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 |
| |
| Assembler Directives for the Z8000 |
| ---------------------------------- |
| |
| The Z8000 port of as includes these additional assembler directives, |
| for compatibility with other Z8000 assemblers. As shown, these do not |
| begin with `.' (unlike the ordinary as directives). |
| |
| `segm' |
| Generates code for the segmented Z8001. |
| |
| `unsegm' |
| Generates 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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. |
| |
