First cut at sanitization, doc files, &c for gas/binutils releases

6 files changed, 5807 insertions, 0 deletions

diff --git a/gas/doc/as.info b/gas/doc/as.info
new file mode 100644
index 0000000..3cf6d9a
--- /dev/null
+++ b/gas/doc/as.info
@@ -0,0 +1,241 @@
+This is Info file as.info, produced by Makeinfo-1.55 from the input
+file ./as.texinfo.
+
+START-INFO-DIR-ENTRY
+* As::                          The GNU assembler.
+END-INFO-DIR-ENTRY
+
+   This file documents the GNU Assembler "as".
+
+   Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the section entitled "GNU General Public License" is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that the section entitled "GNU General Public License"
+may be included in a translation approved by the Free Software
+Foundation instead of in the original English.
+
+
+Indirect:
+as.info-1: 1145
+as.info-2: 50499
+as.info-3: 99245
+as.info-4: 149134
+as.info-5: 184796
+as.info-6: 203973
+
+Tag Table:
+(Indirect)
+Node: Top1145
+Node: Overview1833
+Node: Manual5516
+Node: GNU Assembler6455
+Node: Object Formats7630
+Node: Command Line8077
+Node: Input Files9159
+Node: Object11067
+Node: Errors12012
+Node: Invoking13209
+Node: a14540
+Node: D15637
+Node: f15862
+Node: I16367
+Node: K16909
+Node: L17208
+Node: o17863
+Node: R18314
+Node: v19222
+Node: W19473
+Node: Syntax20045
+Node: Pre-processing20637
+Node: Whitespace22105
+Node: Comments22496
+Node: Symbol Intro24306
+Node: Statements24989
+Node: Constants27044
+Node: Characters27670
+Node: Strings28163
+Node: Chars30187
+Node: Numbers30928
+Node: Integers31459
+Node: Bignums32102
+Node: Flonums32445
+Node: Sections33977
+Node: Secs Background34340
+Node: Ld Sections38752
+Node: As Sections41141
+Node: Sub-Sections42031
+Node: bss45080
+Node: Symbols45664
+Node: Labels46311
+Node: Setting Symbols46735
+Node: Symbol Names47101
+Node: Dot50054
+Node: Symbol Attributes50499
+Node: Symbol Value51173
+Node: Symbol Type52207
+Node: a.out Symbols52586
+Node: Symbol Desc52836
+Node: Symbol Other53118
+Node: COFF Symbols53274
+Node: Expressions53883
+Node: Empty Exprs54214
+Node: Integer Exprs54559
+Node: Arguments54949
+Node: Operators56046
+Node: Prefix Ops56372
+Node: Infix Ops56691
+Node: Pseudo Ops58494
+Node: Abort61763
+Node: ABORT62164
+Node: Align62426
+Node: App-File63123
+Node: Ascii63660
+Node: Asciz63965
+Node: Byte64203
+Node: Comm64435
+Node: Data64992
+Node: Def65302
+Node: Desc65670
+Node: Dim66167
+Node: Double66558
+Node: Eject66889
+Node: Else67057
+Node: Endef67346
+Node: Endif67668
+Node: Equ67919
+Node: Extern68157
+Node: File68409
+Node: Fill69060
+Node: Float70017
+Node: Global70353
+Node: hword70895
+Node: Ident71216
+Node: If71516
+Node: Include72370
+Node: Int72910
+Node: Lcomm73288
+Node: Lflags73762
+Node: Line73949
+Node: Ln75003
+Node: List75147
+Node: Long75744
+Node: Nolist75915
+Node: Octa76332
+Node: Org76658
+Node: Psize77946
+Node: Quad78624
+Node: Sbttl79065
+Node: Scl79423
+Node: Section79922
+Node: Set80334
+Node: Short81059
+Node: Single81373
+Node: Size81710
+Node: Space82106
+Node: Stab82643
+Node: Tag84649
+Node: Text85155
+Node: Title85467
+Node: Type85839
+Node: Val86215
+Node: Word86570
+Node: Deprecated88443
+Node: Machine Dependencies88677
+Node: Vax-Dependent90020
+Node: Vax-Opts90528
+Node: VAX-float92810
+Node: VAX-directives93431
+Node: VAX-opcodes94280
+Node: VAX-branch94658
+Node: VAX-operands97159
+Node: VAX-no97895
+Node: AMD29K-Dependent98121
+Node: AMD29K Options98527
+Node: AMD29K Syntax98701
+Node: AMD29K-Chars98939
+Node: AMD29K-Regs99245
+Node: AMD29K Floating Point100509
+Node: AMD29K Directives100715
+Node: AMD29K Opcodes102123
+Node: H8/300-Dependent102459
+Node: H8/300 Options102865
+Node: H8/300 Syntax103046
+Node: H8/300-Chars103333
+Node: H8/300-Regs103617
+Node: H8/300-Addressing104521
+Node: H8/300 Floating Point105547
+Node: H8/300 Directives105863
+Node: H8/300 Opcodes106382
+Node: H8/500-Dependent114735
+Node: H8/500 Options115137
+Node: H8/500 Syntax115318
+Node: H8/500-Chars115605
+Node: H8/500-Regs115896
+Node: H8/500-Addressing116652
+Node: H8/500 Floating Point117269
+Node: H8/500 Directives117474
+Node: H8/500 Opcodes117793
+Node: SH-Dependent122906
+Node: SH Options123290
+Node: SH Syntax123455
+Node: SH-Chars123714
+Node: SH-Regs123993
+Node: SH-Addressing124592
+Node: SH Floating Point125486
+Node: SH Directives125671
+Node: SH Opcodes125876
+Node: i960-Dependent130123
+Node: Options-i960130513
+Node: Floating Point-i960134399
+Node: Directives-i960134656
+Node: Opcodes for i960136676
+Node: callj-i960137282
+Node: Compare-and-branch-i960137765
+Node: M68K-Dependent139652
+Node: M68K-Opts140107
+Node: M68K-Syntax141446
+Node: M68K-Moto-Syntax143276
+Node: M68K-Float144770
+Node: M68K-Directives145556
+Node: M68K-opcodes146094
+Node: M68K-Branch146306
+Node: M68K-Chars149134
+Node: Sparc-Dependent149489
+Node: Sparc-Opts149809
+Node: Sparc-Float150743
+Node: Sparc-Directives150925
+Node: i386-Dependent151975
+Node: i386-Options152570
+Node: i386-Syntax152714
+Node: i386-Opcodes154664
+Node: i386-Regs156783
+Node: i386-prefixes157924
+Node: i386-Memory159593
+Node: i386-jumps161871
+Node: i386-Float162987
+Node: i386-Notes164977
+Node: Z8000-Dependent165818
+Node: Z8000 Options166783
+Node: Z8000 Syntax166958
+Node: Z8000-Chars167234
+Node: Z8000-Regs167452
+Node: Z8000-Addressing168224
+Node: Z8000 Directives169167
+Node: Z8000 Opcodes170725
+Node: Acknowledgements180661
+Node: Copying184796
+Node: Index203973
+
+End Tag Table
diff --git a/gas/doc/as.info-1 b/gas/doc/as.info-1
new file mode 100644
index 0000000..115a218
--- /dev/null
+++ b/gas/doc/as.info-1
@@ -0,0 +1,1320 @@
+This is Info file as.info, produced by Makeinfo-1.55 from the input
+file ./as.texinfo.
+
+START-INFO-DIR-ENTRY
+* As::                          The GNU assembler.
+END-INFO-DIR-ENTRY
+
+   This file documents the GNU Assembler "as".
+
+   Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the section entitled "GNU General Public License" is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that the section entitled "GNU General Public License"
+may be included in a translation approved by the Free Software
+Foundation instead of in the original English.
+
+
+File: as.info,  Node: Top,  Next: Overview,  Prev: (DIR),  Up: (DIR)
+
+Using as
+********
+
+   This file is a user guide to the GNU assembler `as'.
+
+* Menu:
+
+* Overview::                    Overview
+* Invoking::                    Command-Line Options
+* Syntax::                      Syntax
+* Sections::                    Sections and Relocation
+* Symbols::                     Symbols
+* Expressions::                 Expressions
+* Pseudo Ops::                  Assembler Directives
+* Machine Dependencies::        Machine Dependent Features
+
+* Copying::                     GNU GENERAL PUBLIC LICENSE
+
+* Acknowledgements::            Who Did What
+
+* Index::                       Index
+
+
+File: as.info,  Node: Overview,  Next: Invoking,  Prev: Top,  Up: Top
+
+Overview
+********
+
+   Here is a brief summary of how to invoke `as'.  For details, *note
+Comand-Line Options: Invoking..
+
+       as [ -a[dhlns] ] [ -D ] [ -f ]
+        [ -I PATH ] [ -K ] [ -L ]
+        [ -o OBJFILE ] [ -R ] [ -v ] [ -w ]
+        [ -Av6 | -Av7 | -Av8 | -Asparclite | -bump ]
+        [ -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC ]
+        [ -b ] [ -norelax ]
+        [ -l ] [ -m68000 | -m68010 | -m68020 | ... ]
+        [ -- | FILES ... ]
+
+`-a[dhlns]'
+     Turn on listings; `-ad', omit debugging pseudo-ops from listing,
+     `-ah', include high-level source, `-al', assembly listing, `-an',
+     no forms processing, `-as', symbols.  These options may be
+     combined; *e.g.*, `-aln' for assembly listing without forms
+     processing.  By itself, `-a' defaults to `-ahls' -- that is, all
+     listings turned on.
+
+`-D'
+     This option is accepted only for script compatibility with calls to
+     other assemblers; it has no effect on `as'.
+
+`-f'
+     "fast"--skip whitespace and comment preprocessing (assume source is
+     compiler output)
+
+`-I PATH'
+     Add PATH to the search list for `.include' directives
+
+`-K'
+     Issue warnings when difference tables altered for long
+     displacements.
+
+`-L'
+     Keep (in symbol table) local symbols, starting with `L'
+
+`-o OBJFILE'
+     Name the object-file output from `as'
+
+`-R'
+     Fold data section into text section
+
+`-v'
+     Announce `as' version
+
+`-W'
+     Suppress warning messages
+
+`-- | FILES ...'
+     Standard input, or source files to assemble.
+
+   The following options are available when as is configured for the
+Intel 80960 processor.
+
+`-ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC'
+     Specify which variant of the 960 architecture is the target.
+
+`-b'
+     Add code to collect statistics about branches taken.
+
+`-norelax'
+     Do not alter compare-and-branch instructions for long
+     displacements; error if necessary.
+
+   The following options are available when as is configured for the
+Motorola 68000 series.
+
+`-l'
+     Shorten references to undefined symbols, to one word instead of
+     two.
+
+`-m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040'
+`| -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -mcpu32'
+     Specify what processor in the 68000 family is the target.  The
+     default is normally the 68020, but this can be changed at
+     configuration time.
+
+`-m68881 | -m68882 | -mno-68881 | -mno-68882'
+     The target machine does (or does not) have a floating-point
+     coprocessor.  The default is to assume a coprocessor for 68020,
+     68030, and cpu32.  Although the basic 68000 is not compatible with
+     the 68881, a combination of the two can be specified, since it's
+     possible to do emulation of the coprocessor instructions with the
+     main processor.
+
+`-m68851 | -mno-68851'
+     The target machine does (or does not) have a memory-management
+     unit coprocessor.  The default is to assume an MMU for 68020 and
+     up.
+
+   The following options are available when `as' is configured for the
+SPARC architecture:
+
+`-Av6 | -Av7 | -Av8 | -Asparclite'
+     Explicitly select a variant of the SPARC architecture.
+
+`-bump'
+     Warn when the assembler switches to another architecture.
+
+* Menu:
+
+* Manual::                      Structure of this Manual
+* GNU Assembler::               as, the GNU Assembler
+* Object Formats::              Object File Formats
+* Command Line::                Command Line
+* Input Files::                 Input Files
+* Object::                      Output (Object) File
+* Errors::                      Error and Warning Messages
+
+
+File: as.info,  Node: Manual,  Next: GNU Assembler,  Up: Overview
+
+Structure of this Manual
+========================
+
+   This manual is intended to describe what you need to know to use GNU
+`as'.  We cover the syntax expected in source files, including notation
+for symbols, constants, and expressions; the directives that `as'
+understands; and of course how to invoke `as'.
+
+   This manual also describes some of the machine-dependent features of
+various flavors of the assembler.
+
+   On the other hand, this manual is *not* intended as an introduction
+to programming in assembly language--let alone programming in general!
+In a similar vein, we make no attempt to introduce the machine
+architecture; we do *not* describe the instruction set, standard
+mnemonics, registers or addressing modes that are standard to a
+particular architecture.  You may want to consult the manufacturer's
+machine architecture manual for this information.
+
+
+File: as.info,  Node: GNU Assembler,  Next: Object Formats,  Prev: Manual,  Up: Overview
+
+as, the GNU Assembler
+=====================
+
+   GNU `as' is really a family of assemblers.  If you use (or have
+used) the GNU assembler on one architecture, you should find a fairly
+similar environment when you use it on another architecture.  Each
+version has much in common with the others, including object file
+formats, most assembler directives (often called "pseudo-ops") and
+assembler syntax.
+
+   `as' is primarily intended to assemble the output of the GNU C
+compiler `gcc' for use by the linker `ld'.  Nevertheless, we've tried
+to make `as' assemble correctly everything that other assemblers for
+the same machine would assemble.  Any exceptions are documented
+explicitly (*note Machine Dependencies::.).  This doesn't mean `as'
+always uses the same syntax as another assembler for the same
+architecture; for example, we know of several incompatible versions of
+680x0 assembly language syntax.
+
+   Unlike older assemblers, `as' is designed to assemble a source
+program in one pass of the source file.  This has a subtle impact on the
+`.org' directive (*note `.org': Org.).
+
+
+File: as.info,  Node: Object Formats,  Next: Command Line,  Prev: GNU Assembler,  Up: Overview
+
+Object File Formats
+===================
+
+   The GNU assembler can be configured to produce several alternative
+object file formats.  For the most part, this does not affect how you
+write assembly language programs; but directives for debugging symbols
+are typically different in different file formats.  *Note Symbol
+Attributes: Symbol Attributes.
+
+
+File: as.info,  Node: Command Line,  Next: Input Files,  Prev: Object Formats,  Up: Overview
+
+Command Line
+============
+
+   After the program name `as', the command line may contain options
+and file names.  Options may appear in any order, and may be before,
+after, or between file names.  The order of file names is significant.
+
+   `--' (two hyphens) by itself names the standard input file
+explicitly, as one of the files for `as' to assemble.
+
+   Except for `--' any command line argument that begins with a hyphen
+(`-') is an option.  Each option changes the behavior of `as'.  No
+option changes the way another option works.  An option is a `-'
+followed by one or more letters; the case of the letter is important.
+All options are optional.
+
+   Some options expect exactly one file name to follow them.  The file
+name may either immediately follow the option's letter (compatible with
+older assemblers) or it may be the next command argument (GNU
+standard).  These two command lines are equivalent:
+
+     as -o my-object-file.o mumble.s
+     as -omy-object-file.o mumble.s
+
+
+File: as.info,  Node: Input Files,  Next: Object,  Prev: Command Line,  Up: Overview
+
+Input Files
+===========
+
+   We use the phrase "source program", abbreviated "source", to
+describe the program input to one run of `as'.  The program may be in
+one or more files; how the source is partitioned into files doesn't
+change the meaning of the source.
+
+   The source program is a concatenation of the text in all the files,
+in the order specified.
+
+   Each time you run `as' it assembles exactly one source program.  The
+source program is made up of one or more files.  (The standard input is
+also a file.)
+
+   You give `as' a command line that has zero or more input file names.
+The input files are read (from left file name to right).  A command
+line argument (in any position) that has no special meaning is taken to
+be an input file name.
+
+   If you give `as' no file names it attempts to read one input file
+from the `as' standard input, which is normally your terminal.  You may
+have to type ctl-D to tell `as' there is no more program to assemble.
+
+   Use `--' if you need to explicitly name the standard input file in
+your command line.
+
+   If the source is empty, `as' will produce a small, empty object file.
+
+Filenames and Line-numbers
+--------------------------
+
+   There are two ways of locating a line in the input file (or files)
+and either may be used in reporting error messages.  One way refers to
+a line number in a physical file; the other refers to a line number in a
+"logical" file.  *Note Error and Warning Messages: Errors.
+
+   "Physical files" are those files named in the command line given to
+`as'.
+
+   "Logical files" are simply names declared explicitly by assembler
+directives; they bear no relation to physical files.  Logical file names
+help error messages reflect the original source file, when `as' source
+is itself synthesized from other files.  *Note `.app-file': App-File.
+
+
+File: as.info,  Node: Object,  Next: Errors,  Prev: Input Files,  Up: Overview
+
+Output (Object) File
+====================
+
+   Every time you run `as' it produces an output file, which is your
+assembly language program translated into numbers.  This file is the
+object file, named `b.out', if `as' is configured for the Intel 80960,
+or unless you tell `as' to give it another name by using the `-o'
+option.  Conventionally, object file names end with `.o'.  The default
+name of `a.out' is used for historical reasons:  older assemblers were
+capable of assembling self-contained programs directly into a runnable
+program.  (For some formats, this isn't currently possible, but it can
+be done for `a.out' format.)
+
+   The object file is meant for input to the linker `ld'.  It contains
+assembled program code, information to help `ld' integrate the
+assembled program into a runnable file, and (optionally) symbolic
+information for the debugger.
+
+
+File: as.info,  Node: Errors,  Prev: Object,  Up: Overview
+
+Error and Warning Messages
+==========================
+
+   `as' may write warnings and error messages to the standard error
+file (usually your terminal).  This should not happen when  a compiler
+runs `as' automatically.  Warnings report an assumption made so that
+`as' could keep assembling a flawed program; errors report a grave
+problem that stops the assembly.
+
+   Warning messages have the format
+
+     file_name:NNN:Warning Message Text
+
+(where NNN is a line number).  If a logical file name has been given
+(*note `.app-file': App-File.) it is used for the filename, otherwise
+the name of the current input file is used.  If a logical line number
+was given (*note `.line': Line.) then it is used to calculate the
+number printed, otherwise the actual line in the current source file is
+printed.  The message text is intended to be self explanatory (in the
+grand Unix tradition).
+
+   Error messages have the format
+     file_name:NNN:FATAL:Error Message Text
+   The file name and line number are derived as for warning messages.
+The actual message text may be rather less explanatory because many of
+them aren't supposed to happen.
+
+
+File: as.info,  Node: Invoking,  Next: Syntax,  Prev: Overview,  Up: Top
+
+Command-Line Options
+********************
+
+   This chapter describes command-line options available in *all*
+versions of the GNU assembler; *note Machine Dependencies::., for
+options specific to particular machine architectures.
+
+   If you are invoking `as' via the GNU C compiler (version 2), you can
+use the `-Wa' option to pass arguments through to the assembler.  The
+assembler arguments must be separated from each other (and the `-Wa')
+by commas.  For example:
+
+     gcc -c -g -O -Wa,-alh,-L file.c
+
+   will cause a listing to be emitted to standard output with high-level
+and assembly source.
+
+   Many compiler command-line options, such as `-R' and many
+machine-specific options, will be automatically be passed to the
+assembler by the compiler, so usually you do not need to use this `-Wa'
+mechanism.
+
+* Menu:
+
+* a::             -a[dhlns] enable listings
+* D::             -D for compatibility
+* f::             -f to work faster
+* I::             -I for .include search path
+
+* K::             -K for difference tables
+
+* L::             -L to retain local labels
+* o::             -o to name the object file
+* R::             -R to join data and text sections
+* v::             -v to announce version
+* W::             -W to suppress warnings
+
+
+File: as.info,  Node: a,  Next: D,  Up: Invoking
+
+Enable Listings: `-a[dhlns]'
+============================
+
+   These options enable listing output from the assembler.  By itself,
+`-a' requests high-level, assembly, and symbols listing.  Other letters
+may be used to select specific options for the list: `-ah' requests a
+high-level language listing, `-al' requests an output-program assembly
+listing, and `-as' requests a symbol table listing.  High-level
+listings require that a compiler debugging option like `-g' be used,
+and that assembly listings (`-al') be requested also.
+
+   The `-ad' option may be used to omit debugging pseudo-ops from the
+listing.
+
+   Once you have specified one of these options, you can further control
+listing output and its appearance using the directives `.list',
+`.nolist', `.psize', `.eject', `.title', and `.sbttl'.  The `-an'
+option turns off all forms processing.  If you do not request listing
+output with one of the `-a' options, the listing-control directives
+have no effect.
+
+   The letters after `-a' may be combined into one option, *e.g.*,
+`-aln'.
+
+
+File: as.info,  Node: D,  Next: f,  Prev: a,  Up: Invoking
+
+`-D'
+====
+
+   This option has no effect whatsoever, but it is accepted to make it
+more likely that scripts written for other assemblers will also work
+with `as'.
+
+
+File: as.info,  Node: f,  Next: I,  Prev: D,  Up: Invoking
+
+Work Faster: `-f'
+=================
+
+   `-f' should only be used when assembling programs written by a
+(trusted) compiler.  `-f' stops the assembler from doing whitespace and
+comment pre-processing on the input file(s) before assembling them.
+*Note Pre-processing: Pre-processing.
+
+     *Warning:* if the files actually need to be pre-processed (if they
+     contain comments, for example), `as' will not work correctly if
+     `-f' is used.
+
+
+File: as.info,  Node: I,  Next: K,  Prev: f,  Up: Invoking
+
+`.include' search path: `-I' PATH
+=================================
+
+   Use this option to add a PATH to the list of directories `as' will
+search for files specified in `.include' directives (*note `.include':
+Include.).  You may use `-I' as many times as necessary to include a
+variety of paths.  The current working directory is always searched
+first; after that, `as' searches any `-I' directories in the same order
+as they were specified (left to right) on the command line.
+
+
+File: as.info,  Node: K,  Next: L,  Prev: I,  Up: Invoking
+
+Difference Tables: `-K'
+=======================
+
+   `as' sometimes alters the code emitted for directives of the form
+`.word SYM1-SYM2'; *note `.word': Word..  You can use the `-K' option
+if you want a warning issued when this is done.
+
+
+File: as.info,  Node: L,  Next: o,  Prev: K,  Up: Invoking
+
+Include Local Labels: `-L'
+==========================
+
+   Labels beginning with `L' (upper case only) are called "local
+labels". *Note Symbol Names::.  Normally you don't see such labels when
+debugging, because they are intended for the use of programs (like
+compilers) that compose assembler programs, not for your notice.
+Normally both `as' and `ld' discard such labels, so you don't normally
+debug with them.
+
+   This option tells `as' to retain those `L...' symbols in the object
+file.  Usually if you do this you also tell the linker `ld' to preserve
+symbols whose names begin with `L'.
+
+
+File: as.info,  Node: o,  Next: R,  Prev: L,  Up: Invoking
+
+Name the Object File: `-o'
+==========================
+
+   There is always one object file output when you run `as'.  By
+default it has the name `a.out' (or `b.out', for Intel 960 targets
+only).  You use this option (which takes exactly one filename) to give
+the object file a different name.
+
+   Whatever the object file is called, `as' will overwrite any existing
+file of the same name.
+
+
+File: as.info,  Node: R,  Next: v,  Prev: o,  Up: Invoking
+
+Join Data and Text Sections: `-R'
+=================================
+
+   `-R' tells `as' to write the object file as if all data-section data
+lives in the text section.  This is only done at the very last moment:
+your binary data are the same, but data section parts are relocated
+differently.  The data section part of your object file is zero bytes
+long because all its bytes are appended to the text section.  (*Note
+Sections and Relocation: Sections.)
+
+   When you specify `-R' it would be possible to generate shorter
+address displacements (because we don't have to cross between text and
+data section).  We refrain from doing this simply for compatibility with
+older versions of `as'.  In future, `-R' may work this way.
+
+   When `as' is configured for COFF output, this option is only useful
+if you use sections named `.text' and `.data'.
+
+
+File: as.info,  Node: v,  Next: W,  Prev: R,  Up: Invoking
+
+Announce Version: `-v'
+======================
+
+   You can find out what version of as is running by including the
+option `-v' (which you can also spell as `-version') on the command
+line.
+
+
+File: as.info,  Node: W,  Prev: v,  Up: Invoking
+
+Suppress Warnings: `-W'
+=======================
+
+   `as' should never give a warning or error message when assembling
+compiler output.  But programs written by people often cause `as' to
+give a warning that a particular assumption was made.  All such
+warnings are directed to the standard error file.  If you use this
+option, no warnings are issued.  This option only affects the warning
+messages: it does not change any particular of how `as' assembles your
+file.  Errors, which stop the assembly, are still reported.
+
+
+File: as.info,  Node: Syntax,  Next: Sections,  Prev: Invoking,  Up: Top
+
+Syntax
+******
+
+   This chapter describes the machine-independent syntax allowed in a
+source file.  `as' syntax is similar to what many other assemblers use;
+it is inspired by the BSD 4.2 assembler, except that `as' does not
+assemble Vax bit-fields.
+
+* Menu:
+
+* Pre-processing::              Pre-processing
+* Whitespace::                  Whitespace
+* Comments::                    Comments
+* Symbol Intro::                Symbols
+* Statements::                  Statements
+* Constants::                   Constants
+
+
+File: as.info,  Node: Pre-processing,  Next: Whitespace,  Up: Syntax
+
+Pre-Processing
+==============
+
+   The `as' internal pre-processor:
+   * adjusts and removes extra whitespace.  It leaves one space or tab
+     before the keywords on a line, and turns any other whitespace on
+     the line into a single space.
+
+   * removes all comments, replacing them with a single space, or an
+     appropriate number of newlines.
+
+   * converts character constants into the appropriate numeric values.
+
+   Note that it does not do macro processing, include file handling, or
+anything else you may get from your C compiler's pre-processor.  You can
+do include file processing with the `.include' directive (*note
+`.include': Include.).  Other "CPP" style pre-processing can be done
+with the GNU C compiler, by giving the input file a `.S' suffix; see
+the compiler documentation for details.
+
+   Excess whitespace, comments, and character constants cannot be used
+in the portions of the input text that are not pre-processed.
+
+   If the first line of an input file is `#NO_APP' or the `-f' option
+is given, the input file will not be pre-processed.  Within such an
+input file, parts of the file can be pre-processed by putting a line
+that says `#APP' before the text that should be pre-processed, and
+putting a line that says `#NO_APP' after them.  This feature is mainly
+intend to support `asm' statements in compilers whose output normally
+does not need to be pre-processed.
+
+
+File: as.info,  Node: Whitespace,  Next: Comments,  Prev: Pre-processing,  Up: Syntax
+
+Whitespace
+==========
+
+   "Whitespace" is one or more blanks or tabs, in any order.
+Whitespace is used to separate symbols, and to make programs neater for
+people to read.  Unless within character constants (*note Character
+Constants: Characters.), any whitespace means the same as exactly one
+space.
+
+
+File: as.info,  Node: Comments,  Next: Symbol Intro,  Prev: Whitespace,  Up: Syntax
+
+Comments
+========
+
+   There are two ways of rendering comments to `as'.  In both cases the
+comment is equivalent to one space.
+
+   Anything from `/*' through the next `*/' is a comment.  This means
+you may not nest these comments.
+
+     /*
+       The only way to include a newline ('\n') in a comment
+       is to use this sort of comment.
+     */
+     
+     /* This sort of comment does not nest. */
+
+   Anything from the "line comment" character to the next newline is
+considered a comment and is ignored.  The line comment character is `#'
+on the Vax; `#' on the i960; `!' on the SPARC; `|' on the 680x0; `;'
+for the AMD 29K family; `;' for the H8/300 family; `!' for the H8/500
+family; `!' for the Hitachi SH; `!' for the Z8000; see *Note Machine
+Dependencies::.
+
+   On some machines there are two different line comment characters.
+One will only begin a comment if it is the first non-whitespace
+character on a line, while the other will always begin a comment.
+
+   To be compatible with past assemblers, a special interpretation is
+given to lines that begin with `#'.  Following the `#' an absolute
+expression (*note Expressions::.) is expected:  this will be the
+logical line number of the next line.  Then a string (*Note Strings::.)
+is allowed: if present it is a new logical file name.  The rest of the
+line, if any, should be whitespace.
+
+   If the first non-whitespace characters on the line are not numeric,
+the line is ignored.  (Just like a comment.)
+                               # This is an ordinary comment.
+     # 42-6 "new_file_name"    # New logical file name
+                               # This is logical line # 36.
+   This feature is deprecated, and may disappear from future versions
+of `as'.
+
+
+File: as.info,  Node: Symbol Intro,  Next: Statements,  Prev: Comments,  Up: Syntax
+
+Symbols
+=======
+
+   A "symbol" is one or more characters chosen from the set of all
+letters (both upper and lower case), digits and the three characters
+`_.$'.  On most machines, you can also use `$' in symbol names;
+exceptions are noted in *Note Machine Dependencies::.  No symbol may
+begin with a digit.  Case is significant.  There is no length limit:
+all characters are significant.  Symbols are delimited by characters
+not in that set, or by the beginning of a file (since the source
+program must end with a newline, the end of a file is not a possible
+symbol delimiter).  *Note Symbols::.
+
+
+File: as.info,  Node: Statements,  Next: Constants,  Prev: Symbol Intro,  Up: Syntax
+
+Statements
+==========
+
+   A "statement" ends at a newline character (`\n') or line separator
+character.  (The line separator is usually `;', unless this conflicts
+with the comment character; *note Machine Dependencies::..)  The
+newline or separator character is considered part of the preceding
+statement.  Newlines and separators within character constants are an
+exception: they don't end statements.
+
+   It is an error to end any statement with end-of-file:  the last
+character of any input file should be a newline.
+
+   You may write a statement on more than one line if you put a
+backslash (`\') immediately in front of any newlines within the
+statement.  When `as' reads a backslashed newline both characters are
+ignored.  You can even put backslashed newlines in the middle of symbol
+names without changing the meaning of your source program.
+
+   An empty statement is allowed, and may include whitespace.  It is
+ignored.
+
+   A statement begins with zero or more labels, optionally followed by a
+key symbol which determines what kind of statement it is.  The key
+symbol determines the syntax of the rest of the statement.  If the
+symbol begins with a dot `.' then the statement is an assembler
+directive: typically valid for any computer.  If the symbol begins with
+a letter the statement is an assembly language "instruction": it will
+assemble into a machine language instruction.  Different versions of
+`as' for different computers will recognize different instructions.  In
+fact, the same symbol may represent a different instruction in a
+different computer's assembly language.
+
+   A label is a symbol immediately followed by a colon (`:').
+Whitespace before a label or after a colon is permitted, but you may not
+have whitespace between a label's symbol and its colon. *Note Labels::.
+
+     label:     .directive    followed by something
+     another_label:           # This is an empty statement.
+                instruction   operand_1, operand_2, ...
+
+
+File: as.info,  Node: Constants,  Prev: Statements,  Up: Syntax
+
+Constants
+=========
+
+   A constant is a number, written so that its value is known by
+inspection, without knowing any context.  Like this:
+     .byte  74, 0112, 092, 0x4A, 0X4a, 'J, '\J # All the same value.
+     .ascii "Ring the bell\7"                  # A string constant.
+     .octa  0x123456789abcdef0123456789ABCDEF0 # A bignum.
+     .float 0f-314159265358979323846264338327\
+     95028841971.693993751E-40                 # - pi, a flonum.
+
+* Menu:
+
+* Characters::                  Character Constants
+* Numbers::                     Number Constants
+
+
+File: as.info,  Node: Characters,  Next: Numbers,  Up: Constants
+
+Character Constants
+-------------------
+
+   There are two kinds of character constants.  A "character" stands
+for one character in one byte and its value may be used in numeric
+expressions.  String constants (properly called string *literals*) are
+potentially many bytes and their values may not be used in arithmetic
+expressions.
+
+* Menu:
+
+* Strings::                     Strings
+* Chars::                       Characters
+
+
+File: as.info,  Node: Strings,  Next: Chars,  Up: Characters
+
+Strings
+.......
+
+   A "string" is written between double-quotes.  It may contain
+double-quotes or null characters.  The way to get special characters
+into a string is to "escape" these characters: precede them with a
+backslash `\' character.  For example `\\' represents one backslash:
+the first `\' is an escape which tells `as' to interpret the second
+character literally as a backslash (which prevents `as' from
+recognizing the second `\' as an escape character).  The complete list
+of escapes follows.
+
+`\b'
+     Mnemonic for backspace; for ASCII this is octal code 010.
+
+`\f'
+     Mnemonic for FormFeed; for ASCII this is octal code 014.
+
+`\n'
+     Mnemonic for newline; for ASCII this is octal code 012.
+
+`\r'
+     Mnemonic for carriage-Return; for ASCII this is octal code 015.
+
+`\t'
+     Mnemonic for horizontal Tab; for ASCII this is octal code 011.
+
+`\ DIGIT DIGIT DIGIT'
+     An octal character code.  The numeric code is 3 octal digits.  For
+     compatibility with other Unix systems, 8 and 9 are accepted as
+     digits: for example, `\008' has the value 010, and `\009' the
+     value 011.
+
+`\\'
+     Represents one `\' character.
+
+`\"'
+     Represents one `"' character.  Needed in strings to represent this
+     character, because an unescaped `"' would end the string.
+
+`\ ANYTHING-ELSE'
+     Any other character when escaped by `\' will give a warning, but
+     assemble as if the `\' was not present.  The idea is that if you
+     used an escape sequence you clearly didn't want the literal
+     interpretation of the following character.  However `as' has no
+     other interpretation, so `as' knows it is giving you the wrong
+     code and warns you of the fact.
+
+   Which characters are escapable, and what those escapes represent,
+varies widely among assemblers.  The current set is what we think the
+BSD 4.2 assembler recognizes, and is a subset of what most C compilers
+recognize.  If you are in doubt, don't use an escape sequence.
+
+
+File: as.info,  Node: Chars,  Prev: Strings,  Up: Characters
+
+Characters
+..........
+
+   A single character may be written as a single quote immediately
+followed by that character.  The same escapes apply to characters as to
+strings.  So if you want to write the character backslash, you must
+write `'\\' where the first `\' escapes the second `\'.  As you can
+see, the quote is an acute accent, not a grave accent.  A newline
+immediately following an acute accent is taken as a literal character
+and does not count as the end of a statement.  The value of a character
+constant in a numeric expression is the machine's byte-wide code for
+that character.  `as' assumes your character code is ASCII: `'A' means
+65, `'B' means 66, and so on.
+
+
+File: as.info,  Node: Numbers,  Prev: Characters,  Up: Constants
+
+Number Constants
+----------------
+
+   `as' distinguishes three kinds of numbers according to how they are
+stored in the target machine.  *Integers* are numbers that would fit
+into an `int' in the C language.  *Bignums* are integers, but they are
+stored in more than 32 bits.  *Flonums* are floating point numbers,
+described below.
+
+* Menu:
+
+* Integers::                    Integers
+* Bignums::                     Bignums
+* Flonums::                     Flonums
+
+
+File: as.info,  Node: Integers,  Next: Bignums,  Up: Numbers
+
+Integers
+........
+
+   A binary integer is `0b' or `0B' followed by zero or more of the
+binary digits `01'.
+
+   An octal integer is `0' followed by zero or more of the octal digits
+(`01234567').
+
+   A decimal integer starts with a non-zero digit followed by zero or
+more digits (`0123456789').
+
+   A hexadecimal integer is `0x' or `0X' followed by one or more
+hexadecimal digits chosen from `0123456789abcdefABCDEF'.
+
+   Integers have the usual values.  To denote a negative integer, use
+the prefix operator `-' discussed under expressions (*note Prefix
+Operators: Prefix Ops.).
+
+
+File: as.info,  Node: Bignums,  Next: Flonums,  Prev: Integers,  Up: Numbers
+
+Bignums
+.......
+
+   A "bignum" has the same syntax and semantics as an integer except
+that the number (or its negative) takes more than 32 bits to represent
+in binary.  The distinction is made because in some places integers are
+permitted while bignums are not.
+
+
+File: as.info,  Node: Flonums,  Prev: Bignums,  Up: Numbers
+
+Flonums
+.......
+
+   A "flonum" represents a floating point number.  The translation is
+indirect: a decimal floating point number from the text is converted by
+`as' to a generic binary floating point number of more than sufficient
+precision.  This generic floating point number is converted to a
+particular computer's floating point format (or formats) by a portion
+of `as' specialized to that computer.
+
+   A flonum is written by writing (in order)
+   * The digit `0'.
+
+   * A letter, to tell `as' the rest of the number is a flonum.  `e' is
+     recommended.  Case is not important.
+
+     On the H8/300, H8/500, Hitachi SH, and AMD 29K architectures, the
+     letter must be one of the letters `DFPRSX' (in upper or lower
+     case).
+
+     On the Intel 960 architecture, the letter must be one of the
+     letters `DFT' (in upper or lower case).
+
+   * An optional sign: either `+' or `-'.
+
+   * An optional "integer part": zero or more decimal digits.
+
+   * An optional "fractional part": `.' followed by zero or more
+     decimal digits.
+
+   * An optional exponent, consisting of:
+
+        * An `E' or `e'.
+
+        * Optional sign: either `+' or `-'.
+
+        * One or more decimal digits.
+
+   At least one of the integer part or the fractional part must be
+present.  The floating point number has the usual base-10 value.
+
+   `as' does all processing using integers.  Flonums are computed
+independently of any floating point hardware in the computer running
+`as'.
+
+
+File: as.info,  Node: Sections,  Next: Symbols,  Prev: Syntax,  Up: Top
+
+Sections and Relocation
+***********************
+
+* Menu:
+
+* Secs Background::             Background
+* Ld Sections::                 ld Sections
+* As Sections::                 as Internal Sections
+* Sub-Sections::                Sub-Sections
+* bss::                         bss Section
+
+
+File: as.info,  Node: Secs Background,  Next: Ld Sections,  Up: Sections
+
+Background
+==========
+
+   Roughly, a section is a range of addresses, with no gaps; all data
+"in" those addresses is treated the same for some particular purpose.
+For example there may be a "read only" section.
+
+   The linker `ld' reads many object files (partial programs) and
+combines their contents to form a runnable program.  When `as' emits an
+object file, the partial program is assumed to start at address 0.
+`ld' will assign the final addresses the partial program occupies, so
+that different partial programs don't overlap.  This is actually an
+over-simplification, but it will suffice to explain how `as' uses
+sections.
+
+   `ld' moves blocks of bytes of your program to their run-time
+addresses.  These blocks slide to their run-time addresses as rigid
+units; their length does not change and neither does the order of bytes
+within them.  Such a rigid unit is called a *section*.  Assigning
+run-time addresses to sections is called "relocation".  It includes the
+task of adjusting mentions of object-file addresses so they refer to
+the proper run-time addresses.  For the H8/300 and H8/500, and for the
+Hitachi SH, `as' pads sections if needed to ensure they end on a word
+(sixteen bit) boundary.
+
+   An object file written by `as' has at least three sections, any of
+which may be empty.  These are named "text", "data" and "bss" sections.
+
+   When it generates COFF output, `as' can also generate whatever other
+named sections you specify using the `.section' directive (*note
+`.section': Section.).  If you don't use any directives that place
+output in the `.text' or `.data' sections, these sections will still
+exist, but will be empty.
+
+   Within the object file, the text section starts at address `0', the
+data section follows, and the bss section follows the data section.
+
+   To let `ld' know which data will change when the sections are
+relocated, and how to change that data, `as' also writes to the object
+file details of the relocation needed.  To perform relocation `ld' must
+know, each time an address in the object file is mentioned:
+   * Where in the object file is the beginning of this reference to an
+     address?
+
+   * How long (in bytes) is this reference?
+
+   * Which section does the address refer to?  What is the numeric
+     value of
+          (ADDRESS) - (START-ADDRESS OF SECTION)?
+
+   * Is the reference to an address "Program-Counter relative"?
+
+   In fact, every address `as' ever uses is expressed as
+     (SECTION) + (OFFSET INTO SECTION)
+
+Further, every expression `as' computes is of this section-relative
+nature.  "Absolute expression" means an expression with section
+"absolute" (*note Ld Sections::.).  A "pass1 expression" means an
+expression with section "pass1" (*note as Internal Sections: As
+Sections.).  In this manual we use the notation {SECNAME N} to mean
+"offset N into section SECNAME".
+
+   Apart from text, data and bss sections you need to know about the
+"absolute" section.  When `ld' mixes partial programs, addresses in the
+absolute section remain unchanged.  For example, address `{absolute 0}'
+is "relocated" to run-time address 0 by `ld'.  Although two partial
+programs' data sections will not overlap addresses after linking, *by
+definition* their absolute sections will overlap.  Address `{absolute
+239}' in one partial program will always be the same address when the
+program is running as address `{absolute 239}' in any other partial
+program.
+
+   The idea of sections is extended to the "undefined" section.  Any
+address whose section is unknown at assembly time is by definition
+rendered {undefined U}--where U will be filled in later.  Since numbers
+are always defined, the only way to generate an undefined address is to
+mention an undefined symbol.  A reference to a named common block would
+be such a symbol: its value is unknown at assembly time so it has
+section *undefined*.
+
+   By analogy the word *section* is used to describe groups of sections
+in the linked program.  `ld' puts all partial programs' text sections
+in contiguous addresses in the linked program.  It is customary to
+refer to the *text section* of a program, meaning all the addresses of
+all partial program's text sections.  Likewise for data and bss
+sections.
+
+   Some sections are manipulated by `ld'; others are invented for use
+of `as' and have no meaning except during assembly.
+
+
+File: as.info,  Node: Ld Sections,  Next: As Sections,  Prev: Secs Background,  Up: Sections
+
+ld Sections
+===========
+
+   `ld' deals with just four kinds of sections, summarized below.
+
+*named sections*
+*text section*
+*data section*
+     These sections hold your program.  `as' and `ld' treat them as
+     separate but equal sections.  Anything you can say of one section
+     is true another.  When the program is running, however, it is
+     customary for the text section to be unalterable.  The text
+     section is often shared among processes: it will contain
+     instructions, constants and the like.  The data section of a
+     running program is usually alterable: for example, C variables
+     would be stored in the data section.
+
+*bss section*
+     This section contains zeroed bytes when your program begins
+     running.  It is used to hold unitialized variables or common
+     storage.  The length of each partial program's bss section is
+     important, but because it starts out containing zeroed bytes there
+     is no need to store explicit zero bytes in the object file.  The
+     bss section was invented to eliminate those explicit zeros from
+     object files.
+
+*absolute section*
+     Address 0 of this section is always "relocated" to runtime address
+     0.  This is useful if you want to refer to an address that `ld'
+     must not change when relocating.  In this sense we speak of
+     absolute addresses being "unrelocatable": they don't change during
+     relocation.
+
+*undefined section*
+     This "section" is a catch-all for address references to objects
+     not in the preceding sections.
+
+   An idealized example of three relocatable sections follows.  The
+example uses the traditional section names `.text' and `.data'.  Memory
+addresses are on the horizontal axis.
+
+                           +-----+----+--+
+     partial program # 1:  |ttttt|dddd|00|
+                           +-----+----+--+
+     
+                           text   data bss
+                           seg.   seg. seg.
+     
+                           +---+---+---+
+     partial program # 2:  |TTT|DDD|000|
+                           +---+---+---+
+     
+                           +--+---+-----+--+----+---+-----+~~
+     linked program:       |  |TTT|ttttt|  |dddd|DDD|00000|
+                           +--+---+-----+--+----+---+-----+~~
+     
+         addresses:        0 ...
+
+
+File: as.info,  Node: As Sections,  Next: Sub-Sections,  Prev: Ld Sections,  Up: Sections
+
+as Internal Sections
+====================
+
+   These sections are meant only for the internal use of `as'.  They
+have no meaning at run-time.  You don't really need to know about these
+sections for most purposes; but they can be mentioned in `as' warning
+messages, so it might be helpful to have an idea of their meanings to
+`as'.  These sections are used to permit the value of every expression
+in your assembly language program to be a section-relative address.
+
+ASSEMBLER-INTERNAL-LOGIC-ERROR!
+     An internal assembler logic error has been found.  This means
+     there is a bug in the assembler.
+
+expr section
+     The assembler stores complex expression internally as combinations
+     of symbols.  When it needs to represent an expression as a symbol,
+     it puts it in the expr section.
+
+
+File: as.info,  Node: Sub-Sections,  Next: bss,  Prev: As Sections,  Up: Sections
+
+Sub-Sections
+============
+
+   Assembled bytes conventionally fall into two sections: text and data.
+You may have separate groups of data in named sections that you want to
+end up near to each other in the object file, even though they are not
+contiguous in the assembler source.  `as' allows you to use
+"subsections" for this purpose.  Within each section, there can be
+numbered subsections with values from 0 to 8192.  Objects assembled
+into the same subsection will be grouped with other objects in the same
+subsection when they are all put into the object file.  For example, a
+compiler might want to store constants in the text section, but might
+not want to have them interspersed with the program being assembled.
+In this case, the compiler could issue a `.text 0' before each section
+of code being output, and a `.text 1' before each group of constants
+being output.
+
+   Subsections are optional.  If you don't use subsections, everything
+will be stored in subsection number zero.
+
+   Each subsection is zero-padded up to a multiple of four bytes.
+(Subsections may be padded a different amount on different flavors of
+`as'.)
+
+   Subsections appear in your object file in numeric order, lowest
+numbered to highest.  (All this to be compatible with other people's
+assemblers.) The object file contains no representation of subsections;
+`ld' and other programs that manipulate object files will see no trace
+of them.  They just see all your text subsections as a text section,
+and all your data subsections as a data section.
+
+   To specify which subsection you want subsequent statements assembled
+into, use a numeric argument to specify it, in a `.text EXPRESSION' or
+a `.data EXPRESSION' statement.  When generating COFF output, you can
+also use an extra subsection argument with arbitrary named sections:
+`.section NAME, EXPRESSION'.  EXPRESSION should be an absolute
+expression.  (*Note Expressions::.)  If you just say `.text' then
+`.text 0' is assumed.  Likewise `.data' means `.data 0'.  Assembly
+begins in `text 0'.  For instance:
+     .text 0     # The default subsection is text 0 anyway.
+     .ascii "This lives in the first text subsection. *"
+     .text 1
+     .ascii "But this lives in the second text subsection."
+     .data 0
+     .ascii "This lives in the data section,"
+     .ascii "in the first data subsection."
+     .text 0
+     .ascii "This lives in the first text section,"
+     .ascii "immediately following the asterisk (*)."
+
+   Each section has a "location counter" incremented by one for every
+byte assembled into that section.  Because subsections are merely a
+convenience restricted to `as' there is no concept of a subsection
+location counter.  There is no way to directly manipulate a location
+counter--but the `.align' directive will change it, and any label
+definition will capture its current value.  The location counter of the
+section that statements are being assembled into is said to be the
+"active" location counter.
+
+
+File: as.info,  Node: bss,  Prev: Sub-Sections,  Up: Sections
+
+bss Section
+===========
+
+   The bss section is used for local common variable storage.  You may
+allocate address space in the bss section, but you may not dictate data
+to load into it before your program executes.  When your program starts
+running, all the contents of the bss section are zeroed bytes.
+
+   Addresses in the bss section are allocated with special directives;
+you may not assemble anything directly into the bss section.  Hence
+there are no bss subsections. *Note `.comm': Comm, *note `.lcomm':
+Lcomm..
+
+
+File: as.info,  Node: Symbols,  Next: Expressions,  Prev: Sections,  Up: Top
+
+Symbols
+*******
+
+   Symbols are a central concept: the programmer uses symbols to name
+things, the linker uses symbols to link, and the debugger uses symbols
+to debug.
+
+     *Warning:* `as' does not place symbols in the object file in the
+     same order they were declared.  This may break some debuggers.
+
+* Menu:
+
+* Labels::                      Labels
+* Setting Symbols::             Giving Symbols Other Values
+* Symbol Names::                Symbol Names
+* Dot::                         The Special Dot Symbol
+* Symbol Attributes::           Symbol Attributes
+
+
+File: as.info,  Node: Labels,  Next: Setting Symbols,  Up: Symbols
+
+Labels
+======
+
+   A "label" is written as a symbol immediately followed by a colon
+`:'.  The symbol then represents the current value of the active
+location counter, and is, for example, a suitable instruction operand.
+You are warned if you use the same symbol to represent two different
+locations: the first definition overrides any other definitions.
+
+
+File: as.info,  Node: Setting Symbols,  Next: Symbol Names,  Prev: Labels,  Up: Symbols
+
+Giving Symbols Other Values
+===========================
+
+   A symbol can be given an arbitrary value by writing a symbol,
+followed by an equals sign `=', followed by an expression (*note
+Expressions::.).  This is equivalent to using the `.set' directive.
+*Note `.set': Set.
+
+
+File: as.info,  Node: Symbol Names,  Next: Dot,  Prev: Setting Symbols,  Up: Symbols
+
+Symbol Names
+============
+
+   Symbol names begin with a letter or with one of `._'.  On most
+machines, you can also use `$' in symbol names; exceptions are noted in
+*Note Machine Dependencies::.  That character may be followed by any
+string of digits, letters, dollar signs (unless otherwise noted in
+*Note Machine Dependencies::), and underscores.  For the AMD 29K
+family, `?' is also allowed in the body of a symbol name, though not at
+its beginning.
+
+   Case of letters is significant: `foo' is a different symbol name
+than `Foo'.
+
+   Each symbol has exactly one name. Each name in an assembly language
+program refers to exactly one symbol. You may use that symbol name any
+number of times in a program.
+
+Local Symbol Names
+------------------
+
+   Local symbols help compilers and programmers use names temporarily.
+There are ten local symbol names, which are re-used throughout the
+program.  You may refer to them using the names `0' `1' ... `9'.  To
+define a local symbol, write a label of the form `N:' (where N
+represents any digit).  To refer to the most recent previous definition
+of that symbol write `Nb', using the same digit as when you defined the
+label.  To refer to the next definition of a local label, write
+`Nf'--where N gives you a choice of 10 forward references.  The `b'
+stands for "backwards" and the `f' stands for "forwards".
+
+   Local symbols are not emitted by the current GNU C compiler.
+
+   There is no restriction on how you can use these labels, but
+remember that at any point in the assembly you can refer to at most 10
+prior local labels and to at most 10 forward local labels.
+
+   Local symbol names are only a notation device.  They are immediately
+transformed into more conventional symbol names before the assembler
+uses them.  The symbol names stored in the symbol table, appearing in
+error messages and optionally emitted to the object file have these
+parts:
+
+`L'
+     All local labels begin with `L'. Normally both `as' and `ld'
+     forget symbols that start with `L'. These labels are used for
+     symbols you are never intended to see.  If you give the `-L'
+     option then `as' will retain these symbols in the object file. If
+     you also instruct `ld' to retain these symbols, you may use them
+     in debugging.
+
+`DIGIT'
+     If the label is written `0:' then the digit is `0'.  If the label
+     is written `1:' then the digit is `1'.  And so on up through `9:'.
+
+
A'
+     This unusual character is included so you don't accidentally invent
+     a symbol of the same name.  The character has ASCII value `\001'.
+
+`*ordinal number*'
+     This is a serial number to keep the labels distinct.  The first
+     `0:' gets the number `1'; The 15th `0:' gets the number `15';
+     *etc.*.  Likewise for the other labels `1:' through `9:'.
+
+   For instance, the first `1:' is named `L
A1', the 44th `3:' is named
+`L
A44'.
+
+
+File: as.info,  Node: Dot,  Next: Symbol Attributes,  Prev: Symbol Names,  Up: Symbols
+
+The Special Dot Symbol
+======================
+
+   The special symbol `.' refers to the current address that `as' is
+assembling into.  Thus, the expression `melvin: .long .' will cause
+`melvin' to contain its own address.  Assigning a value to `.' is
+treated the same as a `.org' directive.  Thus, the expression `.=.+4'
+is the same as saying `.space 4'.
+
diff --git a/gas/doc/as.info-2 b/gas/doc/as.info-2
new file mode 100644
index 0000000..45bb197
--- /dev/null
+++ b/gas/doc/as.info-2
@@ -0,0 +1,1524 @@
+This is Info file as.info, produced by Makeinfo-1.55 from the input
+file ./as.texinfo.
+
+START-INFO-DIR-ENTRY
+* As::                          The GNU assembler.
+END-INFO-DIR-ENTRY
+
+   This file documents the GNU Assembler "as".
+
+   Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the section entitled "GNU General Public License" is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that the section entitled "GNU General Public License"
+may be included in a translation approved by the Free Software
+Foundation instead of in the original English.
+
+
+File: as.info,  Node: Symbol Attributes,  Prev: Dot,  Up: Symbols
+
+Symbol Attributes
+=================
+
+   Every symbol has, as well as its name, the attributes "Value" and
+"Type".  Depending on output format, symbols can also have auxiliary
+attributes.
+
+   If you use a symbol without defining it, `as' assumes zero for all
+these attributes, and probably won't warn you.  This makes the symbol
+an externally defined symbol, which is generally what you would want.
+
+* Menu:
+
+* Symbol Value::                Value
+* Symbol Type::                 Type
+
+
+* a.out Symbols::               Symbol Attributes: `a.out'
+
+* COFF Symbols::                Symbol Attributes for COFF
+
+
+File: as.info,  Node: Symbol Value,  Next: Symbol Type,  Up: Symbol Attributes
+
+Value
+-----
+
+   The value of a symbol is (usually) 32 bits.  For a symbol which
+labels a location in the text, data, bss or absolute sections the value
+is the number of addresses from the start of that section to the label.
+Naturally for text, data and bss sections the value of a symbol changes
+as `ld' changes section base addresses during linking.  Absolute
+symbols' values do not change during linking: that is why they are
+called absolute.
+
+   The value of an undefined symbol is treated in a special way.  If it
+is 0 then the symbol is not defined in this assembler source program,
+and `ld' will try to determine its value from other programs it is
+linked with.  You make this kind of symbol simply by mentioning a symbol
+name without defining it.  A non-zero value represents a `.comm' common
+declaration.  The value is how much common storage to reserve, in bytes
+(addresses).  The symbol refers to the first address of the allocated
+storage.
+
+
+File: as.info,  Node: Symbol Type,  Next: a.out Symbols,  Prev: Symbol Value,  Up: Symbol Attributes
+
+Type
+----
+
+   The type attribute of a symbol contains relocation (section)
+information, any flag settings indicating that a symbol is external, and
+(optionally), other information for linkers and debuggers.  The exact
+format depends on the object-code output format in use.
+
+
+File: as.info,  Node: a.out Symbols,  Next: COFF Symbols,  Prev: Symbol Type,  Up: Symbol Attributes
+
+Symbol Attributes: `a.out'
+--------------------------
+
+* Menu:
+
+* Symbol Desc::                 Descriptor
+* Symbol Other::                Other
+
+
+File: as.info,  Node: Symbol Desc,  Next: Symbol Other,  Up: a.out Symbols
+
+Descriptor
+..........
+
+   This is an arbitrary 16-bit value.  You may establish a symbol's
+descriptor value by using a `.desc' statement (*note `.desc': Desc.).
+A descriptor value means nothing to `as'.
+
+
+File: as.info,  Node: Symbol Other,  Prev: Symbol Desc,  Up: a.out Symbols
+
+Other
+.....
+
+   This is an arbitrary 8-bit value.  It means nothing to `as'.
+
+
+File: as.info,  Node: COFF Symbols,  Prev: a.out Symbols,  Up: Symbol Attributes
+
+Symbol Attributes for COFF
+--------------------------
+
+   The COFF format supports a multitude of auxiliary symbol attributes;
+like the primary symbol attributes, they are set between `.def' and
+`.endef' directives.
+
+Primary Attributes
+..................
+
+   The symbol name is set with `.def'; the value and type,
+respectively, with `.val' and `.type'.
+
+Auxiliary Attributes
+....................
+
+   The `as' directives `.dim', `.line', `.scl', `.size', and `.tag' can
+generate auxiliary symbol table information for COFF.
+
+
+File: as.info,  Node: Expressions,  Next: Pseudo Ops,  Prev: Symbols,  Up: Top
+
+Expressions
+***********
+
+   An "expression" specifies an address or numeric value.  Whitespace
+may precede and/or follow an expression.
+
+* Menu:
+
+* Empty Exprs::                 Empty Expressions
+* Integer Exprs::               Integer Expressions
+
+
+File: as.info,  Node: Empty Exprs,  Next: Integer Exprs,  Up: Expressions
+
+Empty Expressions
+=================
+
+   An empty expression has no value: it is just whitespace or null.
+Wherever an absolute expression is required, you may omit the
+expression and `as' will assume a value of (absolute) 0.  This is
+compatible with other assemblers.
+
+
+File: as.info,  Node: Integer Exprs,  Prev: Empty Exprs,  Up: Expressions
+
+Integer Expressions
+===================
+
+   An "integer expression" is one or more *arguments* delimited by
+*operators*.
+
+* Menu:
+
+* Arguments::                   Arguments
+* Operators::                   Operators
+* Prefix Ops::                  Prefix Operators
+* Infix Ops::                   Infix Operators
+
+
+File: as.info,  Node: Arguments,  Next: Operators,  Up: Integer Exprs
+
+Arguments
+---------
+
+   "Arguments" are symbols, numbers or subexpressions.  In other
+contexts arguments are sometimes called "arithmetic operands".  In this
+manual, to avoid confusing them with the "instruction operands" of the
+machine language, we use the term "argument" to refer to parts of
+expressions only, reserving the word "operand" to refer only to machine
+instruction operands.
+
+   Symbols are evaluated to yield {SECTION NNN} where SECTION is one of
+text, data, bss, absolute, or undefined.  NNN is a signed, 2's
+complement 32 bit integer.
+
+   Numbers are usually integers.
+
+   A number can be a flonum or bignum.  In this case, you are warned
+that only the low order 32 bits are used, and `as' pretends these 32
+bits are an integer.  You may write integer-manipulating instructions
+that act on exotic constants, compatible with other assemblers.
+
+   Subexpressions are a left parenthesis `(' followed by an integer
+expression, followed by a right parenthesis `)'; or a prefix operator
+followed by an argument.
+
+
+File: as.info,  Node: Operators,  Next: Prefix Ops,  Prev: Arguments,  Up: Integer Exprs
+
+Operators
+---------
+
+   "Operators" are arithmetic functions, like `+' or `%'.  Prefix
+operators are followed by an argument.  Infix operators appear between
+their arguments.  Operators may be preceded and/or followed by
+whitespace.
+
+
+File: as.info,  Node: Prefix Ops,  Next: Infix Ops,  Prev: Operators,  Up: Integer Exprs
+
+Prefix Operator
+---------------
+
+   `as' has the following "prefix operators".  They each take one
+argument, which must be absolute.
+
+`-'
+     "Negation".  Two's complement negation.
+
+`~'
+     "Complementation".  Bitwise not.
+
+
+File: as.info,  Node: Infix Ops,  Prev: Prefix Ops,  Up: Integer Exprs
+
+Infix Operators
+---------------
+
+   "Infix operators" take two arguments, one on either side.  Operators
+have precedence, but operations with equal precedence are performed left
+to right.  Apart from `+' or `-', both arguments must be absolute, and
+the result is absolute.
+
+  1. Highest Precedence
+
+    `*'
+          "Multiplication".
+
+    `/'
+          "Division".  Truncation is the same as the C operator `/'
+
+    `%'
+          "Remainder".
+
+    `<'
+    `<<'
+          "Shift Left".  Same as the C operator `<<'.
+
+    `>'
+    `>>'
+          "Shift Right".  Same as the C operator `>>'.
+
+  2. Intermediate precedence
+
+    `|'
+          "Bitwise Inclusive Or".
+
+    `&'
+          "Bitwise And".
+
+    `^'
+          "Bitwise Exclusive Or".
+
+    `!'
+          "Bitwise Or Not".
+
+  3. Lowest Precedence
+
+    `+'
+          "Addition".  If either argument is absolute, the result has
+          the section of the other argument.  If either argument is
+          pass1 or undefined, the result is pass1.  Otherwise `+' is
+          illegal.
+
+    `-'
+          "Subtraction".  If the right argument is absolute, the result
+          has the section of the left argument.  If either argument is
+          pass1 the result is pass1.  If either argument is undefined
+          the result is difference section.  If both arguments are in
+          the same section, the result is absolute--provided that
+          section is one of text, data or bss.  Otherwise subtraction
+          is illegal.
+
+   The sense of the rule for addition is that it's only meaningful to
+add the *offsets* in an address; you can only have a defined section in
+one of the two arguments.
+
+   Similarly, you can't subtract quantities from two different sections.
+
+
+File: as.info,  Node: Pseudo Ops,  Next: Machine Dependencies,  Prev: Expressions,  Up: Top
+
+Assembler Directives
+********************
+
+   All assembler directives have names that begin with a period (`.').
+The rest of the name is letters, usually in lower case.
+
+   This chapter discusses directives that are available regardless of
+the target machine configuration for the GNU assembler.  Some machine
+configurations provide additional directives.  *Note Machine
+Dependencies::.
+
+* Menu:
+
+* Abort::                       `.abort'
+
+* ABORT::                       `.ABORT'
+
+* Align::                       `.align ABS-EXPR , ABS-EXPR'
+* App-File::                    `.app-file STRING'
+* Ascii::                       `.ascii "STRING"'...
+* Asciz::                       `.asciz "STRING"'...
+* Byte::                        `.byte EXPRESSIONS'
+* Comm::                        `.comm SYMBOL , LENGTH '
+* Data::                        `.data SUBSECTION'
+
+* Def::                         `.def NAME'
+
+* Desc::                        `.desc SYMBOL, ABS-EXPRESSION'
+
+* Dim::                         `.dim'
+
+* Double::                      `.double FLONUMS'
+* Eject::                       `.eject'
+* Else::                        `.else'
+
+* Endef::                       `.endef'
+
+* Endif::                       `.endif'
+* Equ::                         `.equ SYMBOL, EXPRESSION'
+* Extern::                      `.extern'
+
+* File::                        `.file STRING'
+
+* Fill::                        `.fill REPEAT , SIZE , VALUE'
+* Float::                       `.float FLONUMS'
+* Global::                      `.global SYMBOL', `.globl SYMBOL'
+* hword::                       `.hword EXPRESSIONS'
+* Ident::                       `.ident'
+* If::                          `.if ABSOLUTE EXPRESSION'
+* Include::                     `.include "FILE"'
+* Int::                         `.int EXPRESSIONS'
+* Lcomm::                       `.lcomm SYMBOL , LENGTH'
+* Lflags::                      `.lflags'
+
+* Line::                        `.line LINE-NUMBER'
+
+* Ln::                          `.ln LINE-NUMBER'
+* List::                        `.list'
+* Long::                        `.long EXPRESSIONS'
+
+* Nolist::                      `.nolist'
+* Octa::                        `.octa BIGNUMS'
+* Org::                         `.org NEW-LC , FILL'
+* Psize::                       `.psize LINES, COLUMNS'
+* Quad::                        `.quad BIGNUMS'
+* Sbttl::                       `.sbttl "SUBHEADING"'
+
+* Scl::                         `.scl CLASS'
+
+* Section::                     `.section NAME, SUBSECTION'
+
+* Set::                         `.set SYMBOL, EXPRESSION'
+* Short::                       `.short EXPRESSIONS'
+* Single::                      `.single FLONUMS'
+
+* Size::                        `.size'
+
+* Space::                       `.space SIZE , FILL'
+
+* Stab::                        `.stabd, .stabn, .stabs'
+
+* Tag::                         `.tag STRUCTNAME'
+
+* Text::                        `.text SUBSECTION'
+* Title::                       `.title "HEADING"'
+
+* Type::                        `.type INT'
+* Val::                         `.val ADDR'
+
+* Word::                        `.word EXPRESSIONS'
+* Deprecated::                  Deprecated Directives
+
+
+File: as.info,  Node: Abort,  Next: ABORT,  Up: Pseudo Ops
+
+`.abort'
+========
+
+   This directive stops the assembly immediately.  It is for
+compatibility with other assemblers.  The original idea was that the
+assembly language source would be piped into the assembler.  If the
+sender of the source quit, it could use this directive tells `as' to
+quit also.  One day `.abort' will not be supported.
+
+
+File: as.info,  Node: ABORT,  Next: Align,  Prev: Abort,  Up: Pseudo Ops
+
+`.ABORT'
+========
+
+   When producing COFF output, `as' accepts this directive as a synonym
+for `.abort'.
+
+   When producing `b.out' output, `as' accepts this directive, but
+ignores it.
+
+
+File: as.info,  Node: Align,  Next: App-File,  Prev: ABORT,  Up: Pseudo Ops
+
+`.align ABS-EXPR , ABS-EXPR'
+============================
+
+   Pad the location counter (in the current subsection) to a particular
+storage boundary.  The first expression (which must be absolute) is the
+number of low-order zero bits the location counter will have after
+advancement.  For example `.align 3' will advance the location counter
+until it a multiple of 8.  If the location counter is already a
+multiple of 8, no change is needed.
+
+   The second expression (also absolute) gives the value to be stored in
+the padding bytes.  It (and the comma) may be omitted.  If it is
+omitted, the padding bytes are zero.
+
+
+File: as.info,  Node: App-File,  Next: Ascii,  Prev: Align,  Up: Pseudo Ops
+
+`.app-file STRING'
+==================
+
+   `.app-file' (which may also be spelled `.file') tells `as' that we
+are about to start a new logical file.  STRING is the new file name.
+In general, the filename is recognized whether or not it is surrounded
+by quotes `"'; but if you wish to specify an empty file name is
+permitted, you must give the quotes-`""'.  This statement may go away in
+future: it is only recognized to be compatible with old `as' programs.
+
+
+File: as.info,  Node: Ascii,  Next: Asciz,  Prev: App-File,  Up: Pseudo Ops
+
+`.ascii "STRING"'...
+====================
+
+   `.ascii' expects zero or more string literals (*note Strings::.)
+separated by commas.  It assembles each string (with no automatic
+trailing zero byte) into consecutive addresses.
+
+
+File: as.info,  Node: Asciz,  Next: Byte,  Prev: Ascii,  Up: Pseudo Ops
+
+`.asciz "STRING"'...
+====================
+
+   `.asciz' is just like `.ascii', but each string is followed by a
+zero byte.  The "z" in `.asciz' stands for "zero".
+
+
+File: as.info,  Node: Byte,  Next: Comm,  Prev: Asciz,  Up: Pseudo Ops
+
+`.byte EXPRESSIONS'
+===================
+
+   `.byte' expects zero or more expressions, separated by commas.  Each
+expression is assembled into the next byte.
+
+
+File: as.info,  Node: Comm,  Next: Data,  Prev: Byte,  Up: Pseudo Ops
+
+`.comm SYMBOL , LENGTH '
+========================
+
+   `.comm' declares a named common area in the bss section.  Normally
+`ld' reserves memory addresses for it during linking, so no partial
+program defines the location of the symbol.  Use `.comm' to tell `ld'
+that it must be at least LENGTH bytes long.  `ld' will allocate space
+for each `.comm' symbol that is at least as long as the longest `.comm'
+request in any of the partial programs linked.  LENGTH is an absolute
+expression.
+
+
+File: as.info,  Node: Data,  Next: Def,  Prev: Comm,  Up: Pseudo Ops
+
+`.data SUBSECTION'
+==================
+
+   `.data' tells `as' to assemble the following statements onto the end
+of the data subsection numbered SUBSECTION (which is an absolute
+expression).  If SUBSECTION is omitted, it defaults to zero.
+
+
+File: as.info,  Node: Def,  Next: Desc,  Prev: Data,  Up: Pseudo Ops
+
+`.def NAME'
+===========
+
+   Begin defining debugging information for a symbol NAME; the
+definition extends until the `.endef' directive is encountered.
+
+   This directive is only observed when `as' is configured for COFF
+format output; when producing `b.out', `.def' is recognized, but
+ignored.
+
+
+File: as.info,  Node: Desc,  Next: Dim,  Prev: Def,  Up: Pseudo Ops
+
+`.desc SYMBOL, ABS-EXPRESSION'
+==============================
+
+   This directive sets the descriptor of the symbol (*note Symbol
+Attributes::.) to the low 16 bits of an absolute expression.
+
+   The `.desc' directive is not available when `as' is configured for
+COFF output; it is only for `a.out' or `b.out' object format.  For the
+sake of compatibility, `as' will accept it, but produce no output, when
+configured for COFF.
+
+
+File: as.info,  Node: Dim,  Next: Double,  Prev: Desc,  Up: Pseudo Ops
+
+`.dim'
+======
+
+   This directive is generated by compilers to include auxiliary
+debugging information in the symbol table.  It is only permitted inside
+`.def'/`.endef' pairs.
+
+   `.dim' is only meaningful when generating COFF format output; when
+`as' is generating `b.out', it accepts this directive but ignores it.
+
+
+File: as.info,  Node: Double,  Next: Eject,  Prev: Dim,  Up: Pseudo Ops
+
+`.double FLONUMS'
+=================
+
+   `.double' expects zero or more flonums, separated by commas.  It
+assembles floating point numbers.  The exact kind of floating point
+numbers emitted depends on how `as' is configured.  *Note Machine
+Dependencies::.
+
+
+File: as.info,  Node: Eject,  Next: Else,  Prev: Double,  Up: Pseudo Ops
+
+`.eject'
+========
+
+   Force a page break at this point, when generating assembly listings.
+
+
+File: as.info,  Node: Else,  Next: Endef,  Prev: Eject,  Up: Pseudo Ops
+
+`.else'
+=======
+
+   `.else' is part of the `as' support for conditional assembly; *note
+`.if': If..  It marks the beginning of a section of code to be
+assembled if the condition for the preceding `.if' was false.
+
+
+File: as.info,  Node: Endef,  Next: Endif,  Prev: Else,  Up: Pseudo Ops
+
+`.endef'
+========
+
+   This directive flags the end of a symbol definition begun with
+`.def'.
+
+   `.endef' is only meaningful when generating COFF format output; if
+`as' is configured to generate `b.out', it accepts this directive but
+ignores it.
+
+
+File: as.info,  Node: Endif,  Next: Equ,  Prev: Endef,  Up: Pseudo Ops
+
+`.endif'
+========
+
+   `.endif' is part of the `as' support for conditional assembly; it
+marks the end of a block of code that is only assembled conditionally.
+*Note `.if': If.
+
+
+File: as.info,  Node: Equ,  Next: Extern,  Prev: Endif,  Up: Pseudo Ops
+
+`.equ SYMBOL, EXPRESSION'
+=========================
+
+   This directive sets the value of SYMBOL to EXPRESSION.  It is
+synonymous with `.set'; *note `.set': Set..
+
+
+File: as.info,  Node: Extern,  Next: File,  Prev: Equ,  Up: Pseudo Ops
+
+`.extern'
+=========
+
+   `.extern' is accepted in the source program--for compatibility with
+other assemblers--but it is ignored.  `as' treats all undefined symbols
+as external.
+
+
+File: as.info,  Node: File,  Next: Fill,  Prev: Extern,  Up: Pseudo Ops
+
+`.file STRING'
+==============
+
+   `.file' (which may also be spelled `.app-file') tells `as' that we
+are about to start a new logical file.  STRING is the new file name.
+In general, the filename is recognized whether or not it is surrounded
+by quotes `"'; but if you wish to specify an empty file name, you must
+give the quotes-`""'.  This statement may go away in future: it is only
+recognized to be compatible with old `as' programs.  In some
+configurations of `as', `.file' has already been removed to avoid
+conflicts with other assemblers.  *Note Machine Dependencies::.
+
+
+File: as.info,  Node: Fill,  Next: Float,  Prev: File,  Up: Pseudo Ops
+
+`.fill REPEAT , SIZE , VALUE'
+=============================
+
+   RESULT, SIZE and VALUE are absolute expressions.  This emits REPEAT
+copies of SIZE bytes.  REPEAT may be zero or more.  SIZE may be zero or
+more, but if it is more than 8, then it is deemed to have the value 8,
+compatible with other people's assemblers.  The contents of each REPEAT
+bytes is taken from an 8-byte number.  The highest order 4 bytes are
+zero.  The lowest order 4 bytes are VALUE rendered in the byte-order of
+an integer on the computer `as' is assembling for.  Each SIZE bytes in
+a repetition is taken from the lowest order SIZE bytes of this number.
+Again, this bizarre behavior is compatible with other people's
+assemblers.
+
+   SIZE and VALUE are optional.  If the second comma and VALUE are
+absent, VALUE is assumed zero.  If the first comma and following tokens
+are absent, SIZE is assumed to be 1.
+
+
+File: as.info,  Node: Float,  Next: Global,  Prev: Fill,  Up: Pseudo Ops
+
+`.float FLONUMS'
+================
+
+   This directive assembles zero or more flonums, separated by commas.
+It has the same effect as `.single'.  The exact kind of floating point
+numbers emitted depends on how `as' is configured.  *Note Machine
+Dependencies::.
+
+
+File: as.info,  Node: Global,  Next: hword,  Prev: Float,  Up: Pseudo Ops
+
+`.global SYMBOL', `.globl SYMBOL'
+=================================
+
+   `.global' makes the symbol visible to `ld'.  If you define SYMBOL in
+your partial program, its value is made available to other partial
+programs that are linked with it.  Otherwise, SYMBOL will take its
+attributes from a symbol of the same name from another partial program
+it is linked with.
+
+   Both spellings (`.globl' and `.global') are accepted, for
+compatibility with other assemblers.
+
+
+File: as.info,  Node: hword,  Next: Ident,  Prev: Global,  Up: Pseudo Ops
+
+`.hword EXPRESSIONS'
+====================
+
+   This expects zero or more EXPRESSIONS, and emits a 16 bit number for
+each.
+
+   This directive is a synonym for `.short'; depending on the target
+architecture, it may also be a synonym for `.word'.
+
+
+File: as.info,  Node: Ident,  Next: If,  Prev: hword,  Up: Pseudo Ops
+
+`.ident'
+========
+
+   This directive is used by some assemblers to place tags in object
+files.  `as' simply accepts the directive for source-file compatibility
+with such assemblers, but does not actually emit anything for it.
+
+
+File: as.info,  Node: If,  Next: Include,  Prev: Ident,  Up: Pseudo Ops
+
+`.if ABSOLUTE EXPRESSION'
+=========================
+
+   `.if' marks the beginning of a section of code which is only
+considered part of the source program being assembled if the argument
+(which must be an ABSOLUTE EXPRESSION) is non-zero.  The end of the
+conditional section of code must be marked by `.endif' (*note `.endif':
+Endif.); optionally, you may include code for the alternative
+condition, flagged by `.else' (*note `.else': Else..
+
+   The following variants of `.if' are also supported:
+`.ifdef SYMBOL'
+     Assembles the following section of code if the specified SYMBOL
+     has been defined.
+
+`.ifndef SYMBOL'
+`ifnotdef SYMBOL'
+     Assembles the following section of code if the specified SYMBOL
+     has not been defined.  Both spelling variants are equivalent.
+
+
+File: as.info,  Node: Include,  Next: Int,  Prev: If,  Up: Pseudo Ops
+
+`.include "FILE"'
+=================
+
+   This directive provides a way to include supporting files at
+specified points in your source program.  The code from FILE is
+assembled as if it followed the point of the `.include'; when the end
+of the included file is reached, assembly of the original file
+continues.  You can control the search paths used with the `-I'
+command-line option (*note Command-Line Options: Invoking.).  Quotation
+marks are required around FILE.
+
+
+File: as.info,  Node: Int,  Next: Lcomm,  Prev: Include,  Up: Pseudo Ops
+
+`.int EXPRESSIONS'
+==================
+
+   Expect zero or more EXPRESSIONS, of any section, separated by
+commas.  For each expression, emit a 32-bit number that will, at run
+time, be the value of that expression.  The byte order of the
+expression depends on what kind of computer will run the program.
+
+
+File: as.info,  Node: Lcomm,  Next: Lflags,  Prev: Int,  Up: Pseudo Ops
+
+`.lcomm SYMBOL , LENGTH'
+========================
+
+   Reserve LENGTH (an absolute expression) bytes for a local common
+denoted by SYMBOL.  The section and value of SYMBOL are those of the
+new local common.  The addresses are allocated in the bss section, so
+at run-time the bytes will start off zeroed.  SYMBOL is not declared
+global (*note `.global': Global.), so is normally not visible to `ld'.
+
+
+File: as.info,  Node: Lflags,  Next: Line,  Prev: Lcomm,  Up: Pseudo Ops
+
+`.lflags'
+=========
+
+   `as' accepts this directive, for compatibility with other
+assemblers, but ignores it.
+
+
+File: as.info,  Node: Line,  Next: Ln,  Prev: Lflags,  Up: Pseudo Ops
+
+`.line LINE-NUMBER'
+===================
+
+   Tell `as' to change the logical line number.  LINE-NUMBER must be an
+absolute expression.  The next line will have that logical line number.
+So any other statements on the current line (after a statement
+separator character) will be reported as on logical line number
+LINE-NUMBER - 1.  One day this directive will be unsupported: it is
+used only for compatibility with existing assembler programs.
+
+   *Warning:* In the AMD29K configuration of as, this command is only
+available with the name `.ln', rather than as either `.line' or `.ln'.
+
+   Even though this is a directive associated with the `a.out' or
+`b.out' object-code formats, `as' will still recognize it when
+producing COFF output, and will treat `.line' as though it were the
+COFF `.ln' *if* it is found outside a `.def'/`.endef' pair.
+
+   Inside a `.def', `.line' is, instead, one of the directives used by
+compilers to generate auxiliary symbol information for debugging.
+
+
+File: as.info,  Node: Ln,  Next: List,  Prev: Line,  Up: Pseudo Ops
+
+`.ln LINE-NUMBER'
+=================
+
+   `.ln' is a synonym for `.line'.
+
+
+File: as.info,  Node: List,  Next: Long,  Prev: Ln,  Up: Pseudo Ops
+
+`.list'
+=======
+
+   Control (in conjunction with the `.nolist' directive) whether or not
+assembly listings are generated.  These two directives maintain an
+internal counter (which is zero initially).   `.list' increments the
+counter, and `.nolist' decrements it.  Assembly listings are generated
+whenever the counter is greater than zero.
+
+   By default, listings are disabled.  When you enable them (with the
+`-a' command line option; *note Command-Line Options: Invoking.), the
+initial value of the listing counter is one.
+
+
+File: as.info,  Node: Long,  Next: Nolist,  Prev: List,  Up: Pseudo Ops
+
+`.long EXPRESSIONS'
+===================
+
+   `.long' is the same as `.int', *note `.int': Int..
+
+
+File: as.info,  Node: Nolist,  Next: Octa,  Prev: Long,  Up: Pseudo Ops
+
+`.nolist'
+=========
+
+   Control (in conjunction with the `.list' directive) whether or not
+assembly listings are generated.  These two directives maintain an
+internal counter (which is zero initially).   `.list' increments the
+counter, and `.nolist' decrements it.  Assembly listings are generated
+whenever the counter is greater than zero.
+
+
+File: as.info,  Node: Octa,  Next: Org,  Prev: Nolist,  Up: Pseudo Ops
+
+`.octa BIGNUMS'
+===============
+
+   This directive expects zero or more bignums, separated by commas.
+For each bignum, it emits a 16-byte integer.
+
+   The term "octa" comes from contexts in which a "word" is two bytes;
+hence *octa*-word for 16 bytes.
+
+
+File: as.info,  Node: Org,  Next: Psize,  Prev: Octa,  Up: Pseudo Ops
+
+`.org NEW-LC , FILL'
+====================
+
+   `.org' will advance the location counter of the current section to
+NEW-LC.  NEW-LC is either an absolute expression or an expression with
+the same section as the current subsection.  That is, you can't use
+`.org' to cross sections: if NEW-LC has the wrong section, the `.org'
+directive is ignored.  To be compatible with former assemblers, if the
+section of NEW-LC is absolute, `as' will issue a warning, then pretend
+the section of NEW-LC is the same as the current subsection.
+
+   `.org' may only increase the location counter, or leave it
+unchanged; you cannot use `.org' to move the location counter backwards.
+
+   Because `as' tries to assemble programs in one pass NEW-LC may not
+be undefined.  If you really detest this restriction we eagerly await a
+chance to share your improved assembler.
+
+   Beware that the origin is relative to the start of the section, not
+to the start of the subsection.  This is compatible with other people's
+assemblers.
+
+   When the location counter (of the current subsection) is advanced,
+the intervening bytes are filled with FILL which should be an absolute
+expression.  If the comma and FILL are omitted, FILL defaults to zero.
+
+
+File: as.info,  Node: Psize,  Next: Quad,  Prev: Org,  Up: Pseudo Ops
+
+`.psize LINES , COLUMNS'
+========================
+
+   Use this directive to declare the number of lines--and, optionally,
+the number of columns--to use for each page, when generating listings.
+
+   If you don't use `.psize', listings will use a default line-count of
+60.  You may omit the comma and COLUMNS specification; the default
+width is 200 columns.
+
+   `as' will generate formfeeds whenever the specified number of lines
+is exceeded (or whenever you explicitly request one, using `.eject').
+
+   If you specify LINES as `0', no formfeeds are generated save those
+explicitly specified with `.eject'.
+
+
+File: as.info,  Node: Quad,  Next: Sbttl,  Prev: Psize,  Up: Pseudo Ops
+
+`.quad BIGNUMS'
+===============
+
+   `.quad' expects zero or more bignums, separated by commas.  For each
+bignum, it emits an 8-byte integer.  If the bignum won't fit in 8
+bytes, it prints a warning message; and just takes the lowest order 8
+bytes of the bignum.
+
+   The term "quad" comes from contexts in which a "word" is two bytes;
+hence *quad*-word for 8 bytes.
+
+
+File: as.info,  Node: Sbttl,  Next: Scl,  Prev: Quad,  Up: Pseudo Ops
+
+`.sbttl "SUBHEADING"'
+=====================
+
+   Use SUBHEADING as the title (third line, immediately after the title
+line) when generating assembly listings.
+
+   This directive affects subsequent pages, as well as the current page
+if it appears within ten lines of the top of a page.
+
+
+File: as.info,  Node: Scl,  Next: Section,  Prev: Sbttl,  Up: Pseudo Ops
+
+`.scl CLASS'
+============
+
+   Set the storage-class value for a symbol.  This directive may only be
+used inside a `.def'/`.endef' pair.  Storage class may flag whether a
+symbol is static or external, or it may record further symbolic
+debugging information.
+
+   The `.scl' directive is primarily associated with COFF output; when
+configured to generate `b.out' output format, `as' will accept this
+directive but ignore it.
+
+
+File: as.info,  Node: Section,  Next: Set,  Prev: Scl,  Up: Pseudo Ops
+
+`.section NAME, SUBSECTION'
+===========================
+
+   Assemble the following code into end of subsection numbered
+SUBSECTION in the COFF named section NAME.  If you omit SUBSECTION,
+`as' uses subsection number zero.  `.section .text' is equivalent to
+the `.text' directive; `.section .data' is equivalent to the `.data'
+directive.
+
+
+File: as.info,  Node: Set,  Next: Short,  Prev: Section,  Up: Pseudo Ops
+
+`.set SYMBOL, EXPRESSION'
+=========================
+
+   This directive sets the value of SYMBOL to EXPRESSION.  This will
+change SYMBOL's value and type to conform to EXPRESSION.  If SYMBOL was
+flagged as external, it remains flagged. (*Note Symbol Attributes::.)
+
+   You may `.set' a symbol many times in the same assembly.  If the
+expression's section is unknowable during pass 1, a second pass over
+the source program will be forced.  The second pass is currently not
+implemented.  `as' will abort with an error message if one is required.
+
+   If you `.set' a global symbol, the value stored in the object file
+is the last value stored into it.
+
+
+File: as.info,  Node: Short,  Next: Single,  Prev: Set,  Up: Pseudo Ops
+
+`.short EXPRESSIONS'
+====================
+
+   `.short' is normally the same as `.word'.  *Note `.word': Word.
+
+   In some configurations, however, `.short' and `.word' generate
+numbers of different lengths; *note Machine Dependencies::..
+
+
+File: as.info,  Node: Single,  Next: Size,  Prev: Short,  Up: Pseudo Ops
+
+`.single FLONUMS'
+=================
+
+   This directive assembles zero or more flonums, separated by commas.
+It has the same effect as `.float'.  The exact kind of floating point
+numbers emitted depends on how `as' is configured.  *Note Machine
+Dependencies::.
+
+
+File: as.info,  Node: Size,  Next: Space,  Prev: Single,  Up: Pseudo Ops
+
+`.size'
+=======
+
+   This directive is generated by compilers to include auxiliary
+debugging information in the symbol table.  It is only permitted inside
+`.def'/`.endef' pairs.
+
+   `.size' is only meaningful when generating COFF format output; when
+`as' is generating `b.out', it accepts this directive but ignores it.
+
+
+File: as.info,  Node: Space,  Next: Stab,  Prev: Size,  Up: Pseudo Ops
+
+`.space SIZE , FILL'
+====================
+
+   This directive emits SIZE bytes, each of value FILL.  Both SIZE and
+FILL are absolute expressions.  If the comma and FILL are omitted, FILL
+is assumed to be zero.
+
+   On the AMD 29K, this directive is ignored; it is accepted for
+compatibility with other AMD 29K assemblers.
+
+     *Warning:* In most versions of the GNU assembler, the directive
+     `.space' has the effect of `.block'  *Note Machine Dependencies::.
+
+
+File: as.info,  Node: Stab,  Next: Tag,  Prev: Space,  Up: Pseudo Ops
+
+`.stabd, .stabn, .stabs'
+========================
+
+   There are three directives that begin `.stab'.  All emit symbols
+(*note Symbols::.), for use by symbolic debuggers.  The symbols are not
+entered in the `as' hash table: they cannot be referenced elsewhere in
+the source file.  Up to five fields are required:
+
+STRING
+     This is the symbol's name.  It may contain any character except
+     `\000', so is more general than ordinary symbol names.  Some
+     debuggers used to code arbitrarily complex structures into symbol
+     names using this field.
+
+TYPE
+     An absolute expression.  The symbol's type is set to the low 8
+     bits of this expression.  Any bit pattern is permitted, but `ld'
+     and debuggers will choke on silly bit patterns.
+
+OTHER
+     An absolute expression.  The symbol's "other" attribute is set to
+     the low 8 bits of this expression.
+
+DESC
+     An absolute expression.  The symbol's descriptor is set to the low
+     16 bits of this expression.
+
+VALUE
+     An absolute expression which becomes the symbol's value.
+
+   If a warning is detected while reading a `.stabd', `.stabn', or
+`.stabs' statement, the symbol has probably already been created and
+you will get a half-formed symbol in your object file.  This is
+compatible with earlier assemblers!
+
+`.stabd TYPE , OTHER , DESC'
+     The "name" of the symbol generated is not even an empty string.
+     It is a null pointer, for compatibility.  Older assemblers used a
+     null pointer so they didn't waste space in object files with empty
+     strings.
+
+     The symbol's value is set to the location counter, relocatably.
+     When your program is linked, the value of this symbol will be
+     where the location counter was when the `.stabd' was assembled.
+
+`.stabn TYPE , OTHER , DESC , VALUE'
+     The name of the symbol is set to the empty string `""'.
+
+`.stabs STRING ,  TYPE , OTHER , DESC , VALUE'
+     All five fields are specified.
+
+
+File: as.info,  Node: Tag,  Next: Text,  Prev: Stab,  Up: Pseudo Ops
+
+`.tag STRUCTNAME'
+=================
+
+   This directive is generated by compilers to include auxiliary
+debugging information in the symbol table.  It is only permitted inside
+`.def'/`.endef' pairs.  Tags are used to link structure definitions in
+the symbol table with instances of those structures.
+
+   `.tag' is only used when generating COFF format output; when `as' is
+generating `b.out', it accepts this directive but ignores it.
+
+
+File: as.info,  Node: Text,  Next: Title,  Prev: Tag,  Up: Pseudo Ops
+
+`.text SUBSECTION'
+==================
+
+   Tells `as' to assemble the following statements onto the end of the
+text subsection numbered SUBSECTION, which is an absolute expression.
+If SUBSECTION is omitted, subsection number zero is used.
+
+
+File: as.info,  Node: Title,  Next: Type,  Prev: Text,  Up: Pseudo Ops
+
+`.title "HEADING"'
+==================
+
+   Use HEADING as the title (second line, immediately after the source
+file name and pagenumber) when generating assembly listings.
+
+   This directive affects subsequent pages, as well as the current page
+if it appears within ten lines of the top of a page.
+
+
+File: as.info,  Node: Type,  Next: Val,  Prev: Title,  Up: Pseudo Ops
+
+`.type INT'
+===========
+
+   This directive, permitted only within `.def'/`.endef' pairs, records
+the integer INT as the type attribute of a symbol table entry.
+
+   `.type' is associated only with COFF format output; when `as' is
+configured for `b.out' output, it accepts this directive but ignores it.
+
+
+File: as.info,  Node: Val,  Next: Word,  Prev: Type,  Up: Pseudo Ops
+
+`.val ADDR'
+===========
+
+   This directive, permitted only within `.def'/`.endef' pairs, records
+the address ADDR as the value attribute of a symbol table entry.
+
+   `.val' is used only for COFF output; when `as' is configured for
+`b.out', it accepts this directive but ignores it.
+
+
+File: as.info,  Node: Word,  Next: Deprecated,  Prev: Val,  Up: Pseudo Ops
+
+`.word EXPRESSIONS'
+===================
+
+   This directive expects zero or more EXPRESSIONS, of any section,
+separated by commas.
+
+   The size of the number emitted, and its byte order, depends on what
+kind of computer will run the program.
+
+     *Warning: Special Treatment to support Compilers*
+
+   Machines with a 32-bit address space, but that do less than 32-bit
+addressing, require the following special treatment.  If the machine of
+interest to you does 32-bit addressing (or doesn't require it; *note
+Machine Dependencies::.), you can ignore this issue.
+
+   In order to assemble compiler output into something that will work,
+`as' will occasionlly do strange things to `.word' directives.
+Directives of the form `.word sym1-sym2' are often emitted by compilers
+as part of jump tables.  Therefore, when `as' assembles a directive of
+the form `.word sym1-sym2', and the difference between `sym1' and
+`sym2' does not fit in 16 bits, `as' will create a "secondary jump
+table", immediately before the next label.  This secondary jump table
+will be preceded by a short-jump to the first byte after the secondary
+table.  This short-jump prevents the flow of control from accidentally
+falling into the new table.  Inside the table will be a long-jump to
+`sym2'.  The original `.word' will contain `sym1' minus the address of
+the long-jump to `sym2'.
+
+   If there were several occurrences of `.word sym1-sym2' before the
+secondary jump table, all of them will be adjusted.  If there was a
+`.word sym3-sym4', that also did not fit in sixteen bits, a long-jump
+to `sym4' will be included in the secondary jump table, and the `.word'
+directives will be adjusted to contain `sym3' minus the address of the
+long-jump to `sym4'; and so on, for as many entries in the original
+jump table as necessary.
+
+
+File: as.info,  Node: Deprecated,  Prev: Word,  Up: Pseudo Ops
+
+Deprecated Directives
+=====================
+
+   One day these directives won't work.  They are included for
+compatibility with older assemblers.
+.abort
+.app-file
+.line
+
+File: as.info,  Node: Machine Dependencies,  Next: Copying,  Prev: Pseudo Ops,  Up: Top
+
+Machine Dependent Features
+**************************
+
+   The machine instruction sets are (almost by definition) different on
+each machine where `as' runs.  Floating point representations vary as
+well, and `as' often supports a few additional directives or
+command-line options for compatibility with other assemblers on a
+particular platform.  Finally, some versions of `as' support special
+pseudo-instructions for branch optimization.
+
+   This chapter discusses most of these differences, though it does not
+include details on any machine's instruction set.  For details on that
+subject, see the hardware manufacturer's manual.
+
+* Menu:
+
+
+* Vax-Dependent::               VAX Dependent Features
+
+* AMD29K-Dependent::            AMD 29K Dependent Features
+
+* H8/300-Dependent::            Hitachi H8/300 Dependent Features
+
+* H8/500-Dependent::            Hitachi H8/500 Dependent Features
+
+* SH-Dependent::                Hitachi SH Dependent Features
+
+* i960-Dependent::              Intel 80960 Dependent Features
+
+* M68K-Dependent::              M680x0 Dependent Features
+
+* Sparc-Dependent::             SPARC Dependent Features
+
+* Z8000-Dependent::             Z8000 Dependent Features
+
+* i386-Dependent::              80386 Dependent Features
+
+
+File: as.info,  Node: Vax-Dependent,  Next: AMD29K-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 two options when compiled
+for VMS.  They are `-h', and `-+'.  The `-h' option prevents `as' from
+modifying the symbol-table entries for symbols that contain lowercase
+characters (I think).  The `-+' option causes `as' to print warning
+messages if the FILENAME part of the object file, or any symbol name is
+larger than 31 characters.  The `-+' option also insertes some code
+following the `_main' symbol so that the object file will be compatible
+with Vax-11 "C".
+
+
+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.
+
+
+File: as.info,  Node: VAX-branch,  Next: VAX-operands,  Prev: VAX-opcodes,  Up: Vax-Dependent
+
+VAX Branch Improvement
+----------------------
+
+   Certain pseudo opcodes are permitted.  They are for branch
+instructions.  They expand to the shortest branch instruction that will
+reach 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 don't need this
+feature, don't use 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
+
+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'.  Any
+case of letters will do.
+
+   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
+
+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: AMD29K-Dependent,  Next: H8/300-Dependent,  Prev: Vax-Dependent,  Up: Machine Dependencies
+
+AMD 29K Dependent Features
+==========================
+
+* Menu:
+
+* AMD29K Options::              Options
+* AMD29K Syntax::               Syntax
+* AMD29K Floating Point::       Floating Point
+* AMD29K Directives::           AMD 29K Machine Directives
+* AMD29K Opcodes::              Opcodes
+
+
+File: as.info,  Node: AMD29K Options,  Next: AMD29K Syntax,  Up: AMD29K-Dependent
+
+Options
+-------
+
+   `as' has no additional command-line options for the AMD 29K family.
+
+
+File: as.info,  Node: AMD29K Syntax,  Next: AMD29K Floating Point,  Prev: AMD29K Options,  Up: AMD29K-Dependent
+
+Syntax
+------
+
+* Menu:
+
+* AMD29K-Chars::                Special Characters
+* AMD29K-Regs::                 Register Names
+
+
+File: as.info,  Node: AMD29K-Chars,  Next: AMD29K-Regs,  Up: AMD29K Syntax
+
+Special Characters
+..................
+
+   `;' is the line comment character.
+
+   `@' can be used instead of a newline to separate statements.
+
+   The character `?' is permitted in identifiers (but may not begin an
+identifier).
+
diff --git a/gas/doc/as.info-3 b/gas/doc/as.info-3
new file mode 100644
index 0000000..cdc5a0e
--- /dev/null
+++ b/gas/doc/as.info-3
@@ -0,0 +1,1454 @@
+This is Info file as.info, produced by Makeinfo-1.55 from the input
+file ./as.texinfo.
+
+START-INFO-DIR-ENTRY
+* As::                          The GNU assembler.
+END-INFO-DIR-ENTRY
+
+   This file documents the GNU Assembler "as".
+
+   Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the section entitled "GNU General Public License" is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that the section entitled "GNU General Public License"
+may be included in a translation approved by the Free Software
+Foundation instead of in the original English.
+
+
+File: as.info,  Node: AMD29K-Regs,  Prev: AMD29K-Chars,  Up: AMD29K Syntax
+
+Register Names
+..............
+
+   General-purpose registers are represented by predefined symbols of
+the form `GRNNN' (for global registers) or `LRNNN' (for local
+registers), where NNN represents a number between `0' and `127',
+written with no leading zeros.  The leading letters may be in either
+upper or lower case; for example, `gr13' and `LR7' are both valid
+register names.
+
+   You may also refer to general-purpose registers by specifying the
+register number as the result of an expression (prefixed with `%%' to
+flag the expression as a register number):
+     %%EXPRESSION
+
+--where EXPRESSION must be an absolute expression evaluating to a
+number between `0' and `255'.  The range [0, 127] refers to global
+registers, and the range [128, 255] to local registers.
+
+   In addition, `as' understands the following protected
+special-purpose register names for the AMD 29K family:
+
+       vab    chd    pc0
+       ops    chc    pc1
+       cps    rbp    pc2
+       cfg    tmc    mmu
+       cha    tmr    lru
+
+   These unprotected special-purpose register names are also recognized:
+       ipc    alu    fpe
+       ipa    bp     inte
+       ipb    fc     fps
+       q      cr     exop
+
+
+File: as.info,  Node: AMD29K Floating Point,  Next: AMD29K Directives,  Prev: AMD29K Syntax,  Up: AMD29K-Dependent
+
+Floating Point
+--------------
+
+   The AMD 29K family uses IEEE floating-point numbers.
+
+
+File: as.info,  Node: AMD29K Directives,  Next: AMD29K Opcodes,  Prev: AMD29K Floating Point,  Up: AMD29K-Dependent
+
+AMD 29K Machine Directives
+--------------------------
+
+`.block SIZE , FILL'
+     This directive emits SIZE bytes, each of value FILL.  Both SIZE
+     and FILL are absolute expressions.  If the comma and FILL are
+     omitted, FILL is assumed to be zero.
+
+     In other versions of the GNU assembler, this directive is called
+     `.space'.
+
+`.cputype'
+     This directive is ignored; it is accepted for compatibility with
+     other AMD 29K assemblers.
+
+`.file'
+     This directive is ignored; it is accepted for compatibility with
+     other AMD 29K assemblers.
+
+          *Warning:* in other versions of the GNU assembler, `.file' is
+          used for the directive called `.app-file' in the AMD 29K
+          support.
+
+`.line'
+     This directive is ignored; it is accepted for compatibility with
+     other AMD 29K assemblers.
+
+`.sect'
+     This directive is ignored; it is accepted for compatibility with
+     other AMD 29K assemblers.
+
+`.use SECTION NAME'
+     Establishes the section and subsection for the following code;
+     SECTION NAME may be one of `.text', `.data', `.data1', or `.lit'.
+     With one of the first three SECTION NAME options, `.use' is
+     equivalent to the machine directive SECTION NAME; the remaining
+     case, `.use .lit', is the same as `.data 200'.
+
+
+File: as.info,  Node: AMD29K Opcodes,  Prev: AMD29K Directives,  Up: AMD29K-Dependent
+
+Opcodes
+-------
+
+   `as' implements all the standard AMD 29K opcodes.  No additional
+pseudo-instructions are needed on this family.
+
+   For information on the 29K machine instruction set, see `Am29000
+User's Manual', Advanced Micro Devices, Inc.
+
+
+File: as.info,  Node: H8/300-Dependent,  Next: H8/500-Dependent,  Prev: AMD29K-Dependent,  Up: Machine Dependencies
+
+H8/300 Dependent Features
+=========================
+
+* Menu:
+
+* H8/300 Options::              Options
+* H8/300 Syntax::               Syntax
+* H8/300 Floating Point::       Floating Point
+* H8/300 Directives::           H8/300 Machine Directives
+* H8/300 Opcodes::              Opcodes
+
+
+File: as.info,  Node: H8/300 Options,  Next: H8/300 Syntax,  Up: H8/300-Dependent
+
+Options
+-------
+
+   `as' has no additional command-line options for the Hitachi H8/300
+family.
+
+
+File: as.info,  Node: H8/300 Syntax,  Next: H8/300 Floating Point,  Prev: H8/300 Options,  Up: H8/300-Dependent
+
+Syntax
+------
+
+* Menu:
+
+* H8/300-Chars::                Special Characters
+* H8/300-Regs::                 Register Names
+* H8/300-Addressing::           Addressing Modes
+
+
+File: as.info,  Node: H8/300-Chars,  Next: H8/300-Regs,  Up: H8/300 Syntax
+
+Special Characters
+..................
+
+   `;' is the line comment character.
+
+   `$' can be used instead of a newline to separate statements.
+Therefore *you may not use `$' in symbol names* on the H8/300.
+
+
+File: as.info,  Node: H8/300-Regs,  Next: H8/300-Addressing,  Prev: H8/300-Chars,  Up: H8/300 Syntax
+
+Register Names
+..............
+
+   You can use predefined symbols of the form `rNh' and `rNl' to refer
+to the H8/300 registers as sixteen 8-bit general-purpose registers.  N
+is a digit from `0' to `7'); for instance, both `r0h' and `r7l' are
+valid register names.
+
+   You can also use the eight predefined symbols `rN' to refer to the
+H8/300 registers as 16-bit registers (you must use this form for
+addressing).
+
+   On the H8/300H, you can also use the eight predefined symbols `erN'
+(`er0' ... `er7') to refer to the 32-bit general purpose registers.
+
+   The two control registers are called `pc' (program counter; a 16-bit
+register, except on the H8/300H where it is 24 bits) and `ccr'
+(condition code register; an 8-bit register).  `r7' is used as the
+stack pointer, and can also be called `sp'.
+
+
+File: as.info,  Node: H8/300-Addressing,  Prev: H8/300-Regs,  Up: H8/300 Syntax
+
+Addressing Modes
+................
+
+   as understands the following addressing modes for the H8/300:
+`rN'
+     Register direct
+
+`@rN'
+     Register indirect
+
+`@(D, rN)'
+`@(D:16, rN)'
+`@(D:24, rN)'
+     Register indirect: 16-bit or 24-bit displacement D from register
+     N.  (24-bit displacements are only meaningful on the H8/300H.)
+
+`@rN+'
+     Register indirect with post-increment
+
+`@-rN'
+     Register indirect with pre-decrement
+
+``@'AA'
+``@'AA:8'
+``@'AA:16'
+``@'AA:24'
+     Absolute address `aa'.  (The address size `:24' only makes sense
+     on the H8/300H.)
+
+`#XX'
+`#XX:8'
+`#XX:16'
+`#XX:32'
+     Immediate data XX.  You may specify the `:8', `:16', or `:32' for
+     clarity, if you wish; but `as' neither requires this nor uses
+     it--the data size required is taken from context.
+
+``@'`@'AA'
+``@'`@'AA:8'
+     Memory indirect.  You may specify the `:8' for clarity, if you
+     wish; but `as' neither requires this nor uses it.
+
+
+File: as.info,  Node: H8/300 Floating Point,  Next: H8/300 Directives,  Prev: H8/300 Syntax,  Up: H8/300-Dependent
+
+Floating Point
+--------------
+
+   The H8/300 family has no hardware floating point, but the `.float'
+directive generates IEEE floating-point numbers for compatibility with
+other development tools.
+
+
+File: as.info,  Node: H8/300 Directives,  Next: H8/300 Opcodes,  Prev: H8/300 Floating Point,  Up: H8/300-Dependent
+
+H8/300 Machine Directives
+-------------------------
+
+   `as' has only one machine-dependent directive for the H8/300:
+
+`.h300h'
+     Recognize and emit additional instructions for the H8/300H
+     variant, and also make `.int' emit 32-bit numbers rather than the
+     usual (16-bit) for the H8/300 family.
+
+   On the H8/300 family (including the H8/300H) `.word' directives
+generate 16-bit numbers.
+
+
+File: as.info,  Node: H8/300 Opcodes,  Prev: H8/300 Directives,  Up: H8/300-Dependent
+
+Opcodes
+-------
+
+   For detailed information on the H8/300 machine instruction set, see
+`H8/300 Series Programming Manual' (Hitachi ADE-602-025).  For
+information specific to the H8/300H, see `H8/300H Series Programming
+Manual' (Hitachi).
+
+   `as' implements all the standard H8/300 opcodes.  No additional
+pseudo-instructions are needed on this family.
+
+   The following table summarizes the H8/300 opcodes, and their
+arguments.  Entries marked `*' are opcodes used only on the H8/300H.
+
+              Legend:
+                 Rs   source register
+                 Rd   destination register
+                 abs  absolute address
+                 imm  immediate data
+              disp:N  N-bit displacement from a register
+             pcrel:N  N-bit displacement relative to program counter
+     
+        add.b #imm,rd              *  andc #imm,ccr
+        add.b rs,rd                   band #imm,rd
+        add.w rs,rd                   band #imm,@rd
+     *  add.w #imm,rd                 band #imm,@abs:8
+     *  add.l rs,rd                   bra  pcrel:8
+     *  add.l #imm,rd              *  bra  pcrel:16
+        adds #imm,rd                  bt   pcrel:8
+        addx #imm,rd               *  bt   pcrel:16
+        addx rs,rd                    brn  pcrel:8
+        and.b #imm,rd              *  brn  pcrel:16
+        and.b rs,rd                   bf   pcrel:8
+     *  and.w rs,rd                *  bf   pcrel:16
+     *  and.w #imm,rd                 bhi  pcrel:8
+     *  and.l #imm,rd              *  bhi  pcrel:16
+     *  and.l rs,rd                   bls  pcrel:8
+     
+     *  bls  pcrel:16                 bld  #imm,rd
+        bcc  pcrel:8                  bld  #imm,@rd
+     *  bcc  pcrel:16                 bld  #imm,@abs:8
+        bhs  pcrel:8                  bnot #imm,rd
+     *  bhs  pcrel:16                 bnot #imm,@rd
+        bcs  pcrel:8                  bnot #imm,@abs:8
+     *  bcs  pcrel:16                 bnot rs,rd
+        blo  pcrel:8                  bnot rs,@rd
+     *  blo  pcrel:16                 bnot rs,@abs:8
+        bne  pcrel:8                  bor  #imm,rd
+     *  bne  pcrel:16                 bor  #imm,@rd
+        beq  pcrel:8                  bor  #imm,@abs:8
+     *  beq  pcrel:16                 bset #imm,rd
+        bvc  pcrel:8                  bset #imm,@rd
+     *  bvc  pcrel:16                 bset #imm,@abs:8
+        bvs  pcrel:8                  bset rs,rd
+     *  bvs  pcrel:16                 bset rs,@rd
+        bpl  pcrel:8                  bset rs,@abs:8
+     *  bpl  pcrel:16                 bsr  pcrel:8
+        bmi  pcrel:8                  bsr  pcrel:16
+     *  bmi  pcrel:16                 bst  #imm,rd
+        bge  pcrel:8                  bst  #imm,@rd
+     *  bge  pcrel:16                 bst  #imm,@abs:8
+        blt  pcrel:8                  btst #imm,rd
+     *  blt  pcrel:16                 btst #imm,@rd
+        bgt  pcrel:8                  btst #imm,@abs:8
+     *  bgt  pcrel:16                 btst rs,rd
+        ble  pcrel:8                  btst rs,@rd
+     *  ble  pcrel:16                 btst rs,@abs:8
+        bclr #imm,rd                  bxor #imm,rd
+        bclr #imm,@rd                 bxor #imm,@rd
+        bclr #imm,@abs:8              bxor #imm,@abs:8
+        bclr rs,rd                    cmp.b #imm,rd
+        bclr rs,@rd                   cmp.b rs,rd
+        bclr rs,@abs:8                cmp.w rs,rd
+        biand #imm,rd                 cmp.w rs,rd
+        biand #imm,@rd             *  cmp.w #imm,rd
+        biand #imm,@abs:8          *  cmp.l #imm,rd
+        bild #imm,rd               *  cmp.l rs,rd
+        bild #imm,@rd                 daa  rs
+        bild #imm,@abs:8              das  rs
+        bior #imm,rd                  dec.b rs
+        bior #imm,@rd              *  dec.w #imm,rd
+        bior #imm,@abs:8           *  dec.l #imm,rd
+        bist #imm,rd                  divxu.b rs,rd
+        bist #imm,@rd              *  divxu.w rs,rd
+        bist #imm,@abs:8           *  divxs.b rs,rd
+        bixor #imm,rd              *  divxs.w rs,rd
+        bixor #imm,@rd                eepmov
+        bixor #imm,@abs:8          *  eepmovw
+     
+     *  exts.w rd                     mov.w rs,@abs:16
+     *  exts.l rd                  *  mov.l #imm,rd
+     *  extu.w rd                  *  mov.l rs,rd
+     *  extu.l rd                  *  mov.l @rs,rd
+        inc  rs                    *  mov.l @(disp:16,rs),rd
+     *  inc.w #imm,rd              *  mov.l @(disp:24,rs),rd
+     *  inc.l #imm,rd              *  mov.l @rs+,rd
+        jmp  @rs                   *  mov.l @abs:16,rd
+        jmp  abs                   *  mov.l @abs:24,rd
+        jmp  @@abs:8               *  mov.l rs,@rd
+        jsr  @rs                   *  mov.l rs,@(disp:16,rd)
+        jsr  abs                   *  mov.l rs,@(disp:24,rd)
+        jsr  @@abs:8               *  mov.l rs,@-rd
+        ldc  #imm,ccr              *  mov.l rs,@abs:16
+        ldc  rs,ccr                *  mov.l rs,@abs:24
+     *  ldc  @abs:16,ccr              movfpe @abs:16,rd
+     *  ldc  @abs:24,ccr              movtpe rs,@abs:16
+     *  ldc  @(disp:16,rs),ccr        mulxu.b rs,rd
+     *  ldc  @(disp:24,rs),ccr     *  mulxu.w rs,rd
+     *  ldc  @rs+,ccr              *  mulxs.b rs,rd
+     *  ldc  @rs,ccr               *  mulxs.w rs,rd
+     *  mov.b @(disp:24,rs),rd        neg.b rs
+     *  mov.b rs,@(disp:24,rd)     *  neg.w rs
+        mov.b @abs:16,rd           *  neg.l rs
+        mov.b rs,rd                   nop
+        mov.b @abs:8,rd               not.b rs
+        mov.b rs,@abs:8            *  not.w rs
+        mov.b rs,rd                *  not.l rs
+        mov.b #imm,rd                 or.b #imm,rd
+        mov.b @rs,rd                  or.b rs,rd
+        mov.b @(disp:16,rs),rd     *  or.w #imm,rd
+        mov.b @rs+,rd              *  or.w rs,rd
+        mov.b @abs:8,rd            *  or.l #imm,rd
+        mov.b rs,@rd               *  or.l rs,rd
+        mov.b rs,@(disp:16,rd)        orc  #imm,ccr
+        mov.b rs,@-rd                 pop.w rs
+        mov.b rs,@abs:8            *  pop.l rs
+        mov.w rs,@rd                  push.w rs
+     *  mov.w @(disp:24,rs),rd     *  push.l rs
+     *  mov.w rs,@(disp:24,rd)        rotl.b rs
+     *  mov.w @abs:24,rd           *  rotl.w rs
+     *  mov.w rs,@abs:24           *  rotl.l rs
+        mov.w rs,rd                   rotr.b rs
+        mov.w #imm,rd              *  rotr.w rs
+        mov.w @rs,rd               *  rotr.l rs
+        mov.w @(disp:16,rs),rd        rotxl.b rs
+        mov.w @rs+,rd              *  rotxl.w rs
+        mov.w @abs:16,rd           *  rotxl.l rs
+        mov.w rs,@(disp:16,rd)        rotxr.b rs
+        mov.w rs,@-rd              *  rotxr.w rs
+     
+     *  rotxr.l rs                 *  stc  ccr,@(disp:24,rd)
+        bpt                        *  stc  ccr,@-rd
+        rte                        *  stc  ccr,@abs:16
+        rts                        *  stc  ccr,@abs:24
+        shal.b rs                     sub.b rs,rd
+     *  shal.w rs                     sub.w rs,rd
+     *  shal.l rs                  *  sub.w #imm,rd
+        shar.b rs                  *  sub.l rs,rd
+     *  shar.w rs                  *  sub.l #imm,rd
+     *  shar.l rs                     subs #imm,rd
+        shll.b rs                     subx #imm,rd
+     *  shll.w rs                     subx rs,rd
+     *  shll.l rs                  *  trapa #imm
+        shlr.b rs                     xor  #imm,rd
+     *  shlr.w rs                     xor  rs,rd
+     *  shlr.l rs                  *  xor.w #imm,rd
+        sleep                      *  xor.w rs,rd
+        stc  ccr,rd                *  xor.l #imm,rd
+     *  stc  ccr,@rs               *  xor.l rs,rd
+     *  stc  ccr,@(disp:16,rd)        xorc #imm,ccr
+
+   Four H8/300 instructions (`add', `cmp', `mov', `sub') are defined
+with variants using the suffixes `.b', `.w', and `.l' to specify the
+size of a memory operand.  `as' supports these suffixes, but does not
+require them; since one of the operands is always a register, `as' can
+deduce the correct size.
+
+   For example, since `r0' refers to a 16-bit register,
+     mov    r0,@foo
+is equivalent to
+     mov.w  r0,@foo
+
+   If you use the size suffixes, `as' issues a warning when the suffix
+and the register size do not match.
+
+
+File: as.info,  Node: H8/500-Dependent,  Next: SH-Dependent,  Prev: H8/300-Dependent,  Up: Machine Dependencies
+
+H8/500 Dependent Features
+=========================
+
+* Menu:
+
+* H8/500 Options::              Options
+* H8/500 Syntax::               Syntax
+* H8/500 Floating Point::       Floating Point
+* H8/500 Directives::           H8/500 Machine Directives
+* H8/500 Opcodes::              Opcodes
+
+
+File: as.info,  Node: H8/500 Options,  Next: H8/500 Syntax,  Up: H8/500-Dependent
+
+Options
+-------
+
+   `as' has no additional command-line options for the Hitachi H8/500
+family.
+
+
+File: as.info,  Node: H8/500 Syntax,  Next: H8/500 Floating Point,  Prev: H8/500 Options,  Up: H8/500-Dependent
+
+Syntax
+------
+
+* Menu:
+
+* H8/500-Chars::                Special Characters
+* H8/500-Regs::                 Register Names
+* H8/500-Addressing::           Addressing Modes
+
+
+File: as.info,  Node: H8/500-Chars,  Next: H8/500-Regs,  Up: H8/500 Syntax
+
+Special Characters
+..................
+
+   `!' is the line comment character.
+
+   `;' can be used instead of a newline to separate statements.
+
+   Since `$' has no special meaning, you may use it in symbol names.
+
+
+File: as.info,  Node: H8/500-Regs,  Next: H8/500-Addressing,  Prev: H8/500-Chars,  Up: H8/500 Syntax
+
+Register Names
+..............
+
+   You can use the predefined symbols `r0', `r1', `r2', `r3', `r4',
+`r5', `r6', and `r7' to refer to the H8/500 registers.
+
+   The H8/500 also has these control registers:
+
+`cp'
+     code pointer
+
+`dp'
+     data pointer
+
+`bp'
+     base pointer
+
+`tp'
+     stack top pointer
+
+`ep'
+     extra pointer
+
+`sr'
+     status register
+
+`ccr'
+     condition code register
+
+   All registers are 16 bits long.  To represent 32 bit numbers, use two
+adjacent registers; for distant memory addresses, use one of the segment
+pointers (`cp' for the program counter; `dp' for `r0'-`r3'; `ep' for
+`r4' and `r5'; and `tp' for `r6' and `r7'.
+
+
+File: as.info,  Node: H8/500-Addressing,  Prev: H8/500-Regs,  Up: H8/500 Syntax
+
+Addressing Modes
+................
+
+   as understands the following addressing modes for the H8/500:
+`RN'
+     Register direct
+
+`@RN'
+     Register indirect
+
+`@(d:8, RN)'
+     Register indirect with 8 bit signed displacement
+
+`@(d:16, RN)'
+     Register indirect with 16 bit signed displacement
+
+`@-RN'
+     Register indirect with pre-decrement
+
+`@RN+'
+     Register indirect with post-increment
+
+`@AA:8'
+     8 bit absolute address
+
+`@AA:16'
+     16 bit absolute address
+
+`#XX:8'
+     8 bit immediate
+
+`#XX:16'
+     16 bit immediate
+
+
+File: as.info,  Node: H8/500 Floating Point,  Next: H8/500 Directives,  Prev: H8/500 Syntax,  Up: H8/500-Dependent
+
+Floating Point
+--------------
+
+   The H8/500 family uses IEEE floating-point numbers.
+
+
+File: as.info,  Node: H8/500 Directives,  Next: H8/500 Opcodes,  Prev: H8/500 Floating Point,  Up: H8/500-Dependent
+
+H8/500 Machine Directives
+-------------------------
+
+   `as' has no machine-dependent directives for the H8/500.  However,
+on this platform the `.int' and `.word' directives generate 16-bit
+numbers.
+
+
+File: as.info,  Node: H8/500 Opcodes,  Prev: H8/500 Directives,  Up: H8/500-Dependent
+
+Opcodes
+-------
+
+   For detailed information on the H8/500 machine instruction set, see
+`H8/500 Series Programming Manual' (Hitachi M21T001).
+
+   `as' implements all the standard H8/500 opcodes.  No additional
+pseudo-instructions are needed on this family.
+
+   The following table summarizes H8/500 opcodes and their operands:
+
+     Legend:
+     abs8      8-bit absolute address
+     abs16     16-bit absolute address
+     abs24     24-bit absolute address
+     crb       `ccr', `br', `ep', `dp', `tp', `dp'
+     disp8     8-bit displacement
+     ea        `rn', `@rn', `@(d:8, rn)', `@(d:16, rn)',
+               `@-rn', `@rn+', `@aa:8', `@aa:16',
+               `#xx:8', `#xx:16'
+     ea_mem    `@rn', `@(d:8, rn)', `@(d:16, rn)',
+               `@-rn', `@rn+', `@aa:8', `@aa:16'
+     ea_noimm  `rn', `@rn', `@(d:8, rn)', `@(d:16, rn)',
+               `@-rn', `@rn+', `@aa:8', `@aa:16'
+     fp        r6
+     imm4      4-bit immediate data
+     imm8      8-bit immediate data
+     imm16     16-bit immediate data
+     pcrel8    8-bit offset from program counter
+     pcrel16   16-bit offset from program counter
+     qim       `-2', `-1', `1', `2'
+     rd        any register
+     rs        a register distinct from rd
+     rlist     comma-separated list of registers in parentheses;
+               register ranges `rd-rs' are allowed
+     sp        stack pointer (`r7')
+     sr        status register
+     sz        size; `.b' or `.w'.  If omitted, default `.w'
+     
+     ldc[.b] ea,crb                 bcc[.w] pcrel16
+     ldc[.w] ea,sr                  bcc[.b] pcrel8
+     add[:q] sz qim,ea_noimm        bhs[.w] pcrel16
+     add[:g] sz ea,rd               bhs[.b] pcrel8
+     adds sz ea,rd                  bcs[.w] pcrel16
+     addx sz ea,rd                  bcs[.b] pcrel8
+     and sz ea,rd                   blo[.w] pcrel16
+     andc[.b] imm8,crb              blo[.b] pcrel8
+     andc[.w] imm16,sr              bne[.w] pcrel16
+     bpt                            bne[.b] pcrel8
+     bra[.w] pcrel16                beq[.w] pcrel16
+     bra[.b] pcrel8                 beq[.b] pcrel8
+     bt[.w] pcrel16                 bvc[.w] pcrel16
+     bt[.b] pcrel8                  bvc[.b] pcrel8
+     brn[.w] pcrel16                bvs[.w] pcrel16
+     brn[.b] pcrel8                 bvs[.b] pcrel8
+     bf[.w] pcrel16                 bpl[.w] pcrel16
+     bf[.b] pcrel8                  bpl[.b] pcrel8
+     bhi[.w] pcrel16                bmi[.w] pcrel16
+     bhi[.b] pcrel8                 bmi[.b] pcrel8
+     bls[.w] pcrel16                bge[.w] pcrel16
+     bls[.b] pcrel8                 bge[.b] pcrel8
+     
+     blt[.w] pcrel16                mov[:g][.b] imm8,ea_mem
+     blt[.b] pcrel8                 mov[:g][.w] imm16,ea_mem
+     bgt[.w] pcrel16                movfpe[.b] ea,rd
+     bgt[.b] pcrel8                 movtpe[.b] rs,ea_noimm
+     ble[.w] pcrel16                mulxu sz ea,rd
+     ble[.b] pcrel8                 neg sz ea
+     bclr sz imm4,ea_noimm          nop
+     bclr sz rs,ea_noimm            not sz ea
+     bnot sz imm4,ea_noimm          or sz ea,rd
+     bnot sz rs,ea_noimm            orc[.b] imm8,crb
+     bset sz imm4,ea_noimm          orc[.w] imm16,sr
+     bset sz rs,ea_noimm            pjmp abs24
+     bsr[.b] pcrel8                 pjmp @rd
+     bsr[.w] pcrel16                pjsr abs24
+     btst sz imm4,ea_noimm          pjsr @rd
+     btst sz rs,ea_noimm            prtd imm8
+     clr sz ea                      prtd imm16
+     cmp[:e][.b] imm8,rd            prts
+     cmp[:i][.w] imm16,rd           rotl sz ea
+     cmp[:g].b imm8,ea_noimm        rotr sz ea
+     cmp[:g][.w] imm16,ea_noimm     rotxl sz ea
+     Cmp[:g] sz ea,rd               rotxr sz ea
+     dadd rs,rd                     rtd imm8
+     divxu sz ea,rd                 rtd imm16
+     dsub rs,rd                     rts
+     exts[.b] rd                    scb/f rs,pcrel8
+     extu[.b] rd                    scb/ne rs,pcrel8
+     jmp @rd                        scb/eq rs,pcrel8
+     jmp @(imm8,rd)                 shal sz ea
+     jmp @(imm16,rd)                shar sz ea
+     jmp abs16                      shll sz ea
+     jsr @rd                        shlr sz ea
+     jsr @(imm8,rd)                 sleep
+     jsr @(imm16,rd)                stc[.b] crb,ea_noimm
+     jsr abs16                      stc[.w] sr,ea_noimm
+     ldm @sp+,(rlist)               stm (rlist),@-sp
+     link fp,imm8                   sub sz ea,rd
+     link fp,imm16                  subs sz ea,rd
+     mov[:e][.b] imm8,rd            subx sz ea,rd
+     mov[:i][.w] imm16,rd           swap[.b] rd
+     mov[:l][.w] abs8,rd            tas[.b] ea
+     mov[:l].b abs8,rd              trapa imm4
+     mov[:s][.w] rs,abs8            trap/vs
+     mov[:s].b rs,abs8              tst sz ea
+     mov[:f][.w] @(disp8,fp),rd     unlk fp
+     mov[:f][.w] rs,@(disp8,fp)     xch[.w] rs,rd
+     mov[:f].b @(disp8,fp),rd       xor sz ea,rd
+     mov[:f].b rs,@(disp8,fp)       xorc.b imm8,crb
+     mov[:g] sz rs,ea_mem           xorc.w imm16,sr
+     mov[:g] sz ea,rd
+
+
+File: as.info,  Node: SH-Dependent,  Next: i960-Dependent,  Prev: H8/500-Dependent,  Up: Machine Dependencies
+
+Hitachi SH Dependent Features
+=============================
+
+* Menu:
+
+* SH Options::              Options
+* SH Syntax::               Syntax
+* SH Floating Point::       Floating Point
+* SH Directives::           SH Machine Directives
+* SH Opcodes::              Opcodes
+
+
+File: as.info,  Node: SH Options,  Next: SH Syntax,  Up: SH-Dependent
+
+Options
+-------
+
+   `as' has no additional command-line options for the Hitachi SH
+family.
+
+
+File: as.info,  Node: SH Syntax,  Next: SH Floating Point,  Prev: SH Options,  Up: SH-Dependent
+
+Syntax
+------
+
+* Menu:
+
+* SH-Chars::                Special Characters
+* SH-Regs::                 Register Names
+* SH-Addressing::           Addressing Modes
+
+
+File: as.info,  Node: SH-Chars,  Next: SH-Regs,  Up: SH Syntax
+
+Special Characters
+..................
+
+   `!' is the line comment character.
+
+   You can use `;' instead of a newline to separate statements.
+
+   Since `$' has no special meaning, you may use it in symbol names.
+
+
+File: as.info,  Node: SH-Regs,  Next: SH-Addressing,  Prev: SH-Chars,  Up: SH Syntax
+
+Register Names
+..............
+
+   You can use the predefined symbols `r0', `r1', `r2', `r3', `r4',
+`r5', `r6', `r7', `r8', `r9', `r10', `r11', `r12', `r13', `r14', and
+`r15' to refer to the SH registers.
+
+   The SH also has these control registers:
+
+`pr'
+     procedure register (holds return address)
+
+`pc'
+     program counter
+
+`mach'
+`macl'
+     high and low multiply accumulator registers
+
+`sr'
+     status register
+
+`gbr'
+     global base register
+
+`vbr'
+     vector base register (for interrupt vectors)
+
+
+File: as.info,  Node: SH-Addressing,  Prev: SH-Regs,  Up: SH Syntax
+
+Addressing Modes
+................
+
+   `as' understands the following addressing modes for the SH.  `RN' in
+the following refers to any of the numbered registers, but *not* the
+control registers.
+
+`RN'
+     Register direct
+
+`@RN'
+     Register indirect
+
+`@-RN'
+     Register indirect with pre-decrement
+
+`@RN+'
+     Register indirect with post-increment
+
+`@(DISP, RN)'
+     Register indirect with displacement
+
+`@(R0, RN)'
+     Register indexed
+
+`@(DISP, GBR)'
+     `GBR' offset
+
+`@(R0, GBR)'
+     GBR indexed
+
+`ADDR'
+`@(DISP, PC)'
+     PC relative address (for branch or for addressing memory).  The
+     `as' implementation allows you to use the simpler form ADDR
+     anywhere a PC relative address is called for; the alternate form
+     is supported for compatibility with other assemblers.
+
+`#IMM'
+     Immediate data
+
+
+File: as.info,  Node: SH Floating Point,  Next: SH Directives,  Prev: SH Syntax,  Up: SH-Dependent
+
+Floating Point
+--------------
+
+   The SH family uses IEEE floating-point numbers.
+
+
+File: as.info,  Node: SH Directives,  Next: SH Opcodes,  Prev: SH Floating Point,  Up: SH-Dependent
+
+SH Machine Directives
+---------------------
+
+   `as' has no machine-dependent directives for the SH.
+
+
+File: as.info,  Node: SH Opcodes,  Prev: SH Directives,  Up: SH-Dependent
+
+Opcodes
+-------
+
+   For detailed information on the SH machine instruction set, see
+`SH-Microcomputer User's Manual' (Hitachi Micro Systems, Inc.).
+
+   `as' implements all the standard SH opcodes.  No additional
+pseudo-instructions are needed on this family.  Note, however, that
+because `as' supports a simpler form of PC-relative addressing, you may
+simply write (for example)
+
+     mov.l  bar,r0
+
+where other assemblers might require an explicit displacement to `bar'
+from the program counter:
+
+     mov.l  @(DISP, PC)
+
+   Here is a summary of SH opcodes:
+
+     Legend:
+     Rn        a numbered register
+     Rm        another numbered register
+     #imm      immediate data
+     disp      displacement
+     disp8     8-bit displacement
+     disp12    12-bit displacement
+     
+     add #imm,Rn                    lds.l @Rn+,PR
+     add Rm,Rn                      mac.w @Rm+,@Rn+
+     addc Rm,Rn                     mov #imm,Rn
+     addv Rm,Rn                     mov Rm,Rn
+     and #imm,R0                    mov.b Rm,@(R0,Rn)
+     and Rm,Rn                      mov.b Rm,@-Rn
+     and.b #imm,@(R0,GBR)           mov.b Rm,@Rn
+     bf disp8                       mov.b @(disp,Rm),R0
+     bra disp12                     mov.b @(disp,GBR),R0
+     bsr disp12                     mov.b @(R0,Rm),Rn
+     bt disp8                       mov.b @Rm+,Rn
+     clrm                           mov.b @Rm,Rn
+     clrt                           mov.b R0,@(disp,Rm)
+     cmp/eq #imm,R0                 mov.b R0,@(disp,GBR)
+     cmp/eq Rm,Rn                   mov.l Rm,@(disp,Rn)
+     cmp/ge Rm,Rn                   mov.l Rm,@(R0,Rn)
+     cmp/gt Rm,Rn                   mov.l Rm,@-Rn
+     cmp/hi Rm,Rn                   mov.l Rm,@Rn
+     cmp/hs Rm,Rn                   mov.l @(disp,Rn),Rm
+     cmp/pl Rn                      mov.l @(disp,GBR),R0
+     cmp/pz Rn                      mov.l @(disp,PC),Rn
+     cmp/str Rm,Rn                  mov.l @(R0,Rm),Rn
+     div0s Rm,Rn                    mov.l @Rm+,Rn
+     div0u                          mov.l @Rm,Rn
+     div1 Rm,Rn                     mov.l R0,@(disp,GBR)
+     exts.b Rm,Rn                   mov.w Rm,@(R0,Rn)
+     exts.w Rm,Rn                   mov.w Rm,@-Rn
+     extu.b Rm,Rn                   mov.w Rm,@Rn
+     extu.w Rm,Rn                   mov.w @(disp,Rm),R0
+     jmp @Rn                        mov.w @(disp,GBR),R0
+     jsr @Rn                        mov.w @(disp,PC),Rn
+     ldc Rn,GBR                     mov.w @(R0,Rm),Rn
+     ldc Rn,SR                      mov.w @Rm+,Rn
+     ldc Rn,VBR                     mov.w @Rm,Rn
+     ldc.l @Rn+,GBR                 mov.w R0,@(disp,Rm)
+     ldc.l @Rn+,SR                  mov.w R0,@(disp,GBR)
+     ldc.l @Rn+,VBR                 mova @(disp,PC),R0
+     lds Rn,MACH                    movt Rn
+     lds Rn,MACL                    muls Rm,Rn
+     lds Rn,PR                      mulu Rm,Rn
+     lds.l @Rn+,MACH                neg Rm,Rn
+     lds.l @Rn+,MACL                negc Rm,Rn
+     
+     nop                            stc VBR,Rn
+     not Rm,Rn                      stc.l GBR,@-Rn
+     or #imm,R0                     stc.l SR,@-Rn
+     or Rm,Rn                       stc.l VBR,@-Rn
+     or.b #imm,@(R0,GBR)            sts MACH,Rn
+     rotcl Rn                       sts MACL,Rn
+     rotcr Rn                       sts PR,Rn
+     rotl Rn                        sts.l MACH,@-Rn
+     rotr Rn                        sts.l MACL,@-Rn
+     rte                            sts.l PR,@-Rn
+     rts                            sub Rm,Rn
+     sett                           subc Rm,Rn
+     shal Rn                        subv Rm,Rn
+     shar Rn                        swap.b Rm,Rn
+     shll Rn                        swap.w Rm,Rn
+     shll16 Rn                      tas.b @Rn
+     shll2 Rn                       trapa #imm
+     shll8 Rn                       tst #imm,R0
+     shlr Rn                        tst Rm,Rn
+     shlr16 Rn                      tst.b #imm,@(R0,GBR)
+     shlr2 Rn                       xor #imm,R0
+     shlr8 Rn                       xor Rm,Rn
+     sleep                          xor.b #imm,@(R0,GBR)
+     stc GBR,Rn                     xtrct Rm,Rn
+     stc SR,Rn
+
+
+File: as.info,  Node: i960-Dependent,  Next: M68K-Dependent,  Prev: SH-Dependent,  Up: Machine Dependencies
+
+Intel 80960 Dependent Features
+==============================
+
+* Menu:
+
+* Options-i960::                i960 Command-line Options
+* Floating Point-i960::         Floating Point
+* Directives-i960::             i960 Machine Directives
+* Opcodes for i960::            i960 Opcodes
+
+
+File: as.info,  Node: Options-i960,  Next: Floating Point-i960,  Up: i960-Dependent
+
+i960 Command-line Options
+-------------------------
+
+`-ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC'
+     Select the 80960 architecture.  Instructions or features not
+     supported by the selected architecture cause fatal errors.
+
+     `-ACA' is equivalent to `-ACA_A'; `-AKC' is equivalent to `-AMC'.
+     Synonyms are provided for compatibility with other tools.
+
+     If none of these options is specified, `as' will generate code for
+     any instruction or feature that is supported by *some* version of
+     the 960 (even if this means mixing architectures!).  In principle,
+     `as' will attempt to deduce the minimal sufficient processor type
+     if none is specified; depending on the object code format, the
+     processor type may be recorded in the object file.  If it is
+     critical that the `as' output match a specific architecture,
+     specify that architecture explicitly.
+
+`-b'
+     Add code to collect information about conditional branches taken,
+     for later optimization using branch prediction bits.  (The
+     conditional branch instructions have branch prediction bits in the
+     CA, CB, and CC architectures.)  If BR represents a conditional
+     branch instruction, the following represents the code generated by
+     the assembler when `-b' is specified:
+
+                  call    INCREMENT ROUTINE
+                  .word   0       # pre-counter
+          Label:  BR
+                  call    INCREMENT ROUTINE
+                  .word   0       # post-counter
+
+     The counter following a branch records the number of times that
+     branch was *not* taken; the differenc between the two counters is
+     the number of times the branch *was* taken.
+
+     A table of every such `Label' is also generated, so that the
+     external postprocessor `gbr960' (supplied by Intel) can locate all
+     the counters.  This table is always labelled `__BRANCH_TABLE__';
+     this is a local symbol to permit collecting statistics for many
+     separate object files.  The table is word aligned, and begins with
+     a two-word header.  The first word, initialized to 0, is used in
+     maintaining linked lists of branch tables.  The second word is a
+     count of the number of entries in the table, which follow
+     immediately: each is a word, pointing to one of the labels
+     illustrated above.
+
+           +------------+------------+------------+ ... +------------+
+           |            |            |            |     |            |
+           |  *NEXT     |  COUNT: N  | *BRLAB 1   |     | *BRLAB N   |
+           |            |            |            |     |            |
+           +------------+------------+------------+ ... +------------+
+          
+                         __BRANCH_TABLE__ layout
+
+     The first word of the header is used to locate multiple branch
+     tables, since each object file may contain one. Normally the links
+     are maintained with a call to an initialization routine, placed at
+     the beginning of each function in the file.  The GNU C compiler
+     will generate these calls automatically when you give it a `-b'
+     option.  For further details, see the documentation of `gbr960'.
+
+`-norelax'
+     Normally, Compare-and-Branch instructions with targets that require
+     displacements greater than 13 bits (or that have external targets)
+     are replaced with the corresponding compare (or `chkbit') and
+     branch instructions.  You can use the `-norelax' option to specify
+     that `as' should generate errors instead, if the target
+     displacement is larger than 13 bits.
+
+     This option does not affect the Compare-and-Jump instructions; the
+     code emitted for them is *always* adjusted when necessary
+     (depending on displacement size), regardless of whether you use
+     `-norelax'.
+
+
+File: as.info,  Node: Floating Point-i960,  Next: Directives-i960,  Prev: Options-i960,  Up: i960-Dependent
+
+Floating Point
+--------------
+
+   `as' generates IEEE floating-point numbers for the directives
+`.float', `.double', `.extended', and `.single'.
+
+
+File: as.info,  Node: Directives-i960,  Next: Opcodes for i960,  Prev: Floating Point-i960,  Up: i960-Dependent
+
+i960 Machine Directives
+-----------------------
+
+`.bss SYMBOL, LENGTH, ALIGN'
+     Reserve LENGTH bytes in the bss section for a local SYMBOL,
+     aligned to the power of two specified by ALIGN.  LENGTH and ALIGN
+     must be positive absolute expressions.  This directive differs
+     from `.lcomm' only in that it permits you to specify an alignment.
+     *Note `.lcomm': Lcomm.
+
+`.extended FLONUMS'
+     `.extended' expects zero or more flonums, separated by commas; for
+     each flonum, `.extended' emits an IEEE extended-format (80-bit)
+     floating-point number.
+
+`.leafproc CALL-LAB, BAL-LAB'
+     You can use the `.leafproc' directive in conjunction with the
+     optimized `callj' instruction to enable faster calls of leaf
+     procedures.  If a procedure is known to call no other procedures,
+     you may define an entry point that skips procedure prolog code
+     (and that does not depend on system-supplied saved context), and
+     declare it as the BAL-LAB using `.leafproc'.  If the procedure
+     also has an entry point that goes through the normal prolog, you
+     can specify that entry point as CALL-LAB.
+
+     A `.leafproc' declaration is meant for use in conjunction with the
+     optimized call instruction `callj'; the directive records the data
+     needed later to choose between converting the `callj' into a `bal'
+     or a `call'.
+
+     CALL-LAB is optional; if only one argument is present, or if the
+     two arguments are identical, the single argument is assumed to be
+     the `bal' entry point.
+
+`.sysproc NAME, INDEX'
+     The `.sysproc' directive defines a name for a system procedure.
+     After you define it using `.sysproc', you can use NAME to refer to
+     the system procedure identified by INDEX when calling procedures
+     with the optimized call instruction `callj'.
+
+     Both arguments are required; INDEX must be between 0 and 31
+     (inclusive).
+
+
+File: as.info,  Node: Opcodes for i960,  Prev: Directives-i960,  Up: i960-Dependent
+
+i960 Opcodes
+------------
+
+   All Intel 960 machine instructions are supported; *note i960
+Command-line Options: Options-i960. for a discussion of selecting the
+instruction subset for a particular 960 architecture.
+
+   Some opcodes are processed beyond simply emitting a single
+corresponding instruction: `callj', and Compare-and-Branch or
+Compare-and-Jump instructions with target displacements larger than 13
+bits.
+
+* Menu:
+
+* callj-i960::                  `callj'
+* Compare-and-branch-i960::     Compare-and-Branch
+
+
+File: as.info,  Node: callj-i960,  Next: Compare-and-branch-i960,  Up: Opcodes for i960
+
+`callj'
+.......
+
+   You can write `callj' to have the assembler or the linker determine
+the most appropriate form of subroutine call: `call', `bal', or
+`calls'.  If the assembly source contains enough information--a
+`.leafproc' or `.sysproc' directive defining the operand--then `as'
+will translate the `callj'; if not, it will simply emit the `callj',
+leaving it for the linker to resolve.
+
+
+File: as.info,  Node: Compare-and-branch-i960,  Prev: callj-i960,  Up: Opcodes for i960
+
+Compare-and-Branch
+..................
+
+   The 960 architectures provide combined Compare-and-Branch
+instructions that permit you to store the branch target in the lower 13
+bits of the instruction word itself.  However, if you specify a branch
+target far enough away that its address won't fit in 13 bits, the
+assembler can either issue an error, or convert your Compare-and-Branch
+instruction into separate instructions to do the compare and the branch.
+
+   Whether `as' gives an error or expands the instruction depends on
+two choices you can make: whether you use the `-norelax' option, and
+whether you use a "Compare and Branch" instruction or a "Compare and
+Jump" instruction.  The "Jump" instructions are *always* expanded if
+necessary; the "Branch" instructions are expanded when necessary
+*unless* you specify `-norelax'--in which case `as' gives an error
+instead.
+
+   These are the Compare-and-Branch instructions, their "Jump" variants,
+and the instruction pairs they may expand into:
+
+             Compare and
+          Branch      Jump       Expanded to
+          ------    ------       ------------
+             bbc                 chkbit; bno
+             bbs                 chkbit; bo
+          cmpibe    cmpije       cmpi; be
+          cmpibg    cmpijg       cmpi; bg
+         cmpibge   cmpijge       cmpi; bge
+          cmpibl    cmpijl       cmpi; bl
+         cmpible   cmpijle       cmpi; ble
+         cmpibno   cmpijno       cmpi; bno
+         cmpibne   cmpijne       cmpi; bne
+          cmpibo    cmpijo       cmpi; bo
+          cmpobe    cmpoje       cmpo; be
+          cmpobg    cmpojg       cmpo; bg
+         cmpobge   cmpojge       cmpo; bge
+          cmpobl    cmpojl       cmpo; bl
+         cmpoble   cmpojle       cmpo; ble
+         cmpobne   cmpojne       cmpo; bne
+
+
+File: as.info,  Node: M68K-Dependent,  Next: Sparc-Dependent,  Prev: i960-Dependent,  Up: Machine Dependencies
+
+M680x0 Dependent Features
+=========================
+
+* Menu:
+
+* M68K-Opts::                   M680x0 Options
+* M68K-Syntax::                 Syntax
+* M68K-Moto-Syntax::            Motorola Syntax
+* M68K-Float::                  Floating Point
+* M68K-Directives::             680x0 Machine Directives
+* M68K-opcodes::                Opcodes
+
+
+File: as.info,  Node: M68K-Opts,  Next: M68K-Syntax,  Up: M68K-Dependent
+
+M680x0 Options
+--------------
+
+   The Motorola 680x0 version of `as' has two machine dependent options.
+One shortens undefined references from 32 to 16 bits, while the other
+is used to tell `as' what kind of machine it is assembling for.
+
+   You can use the `-l' option to shorten the size of references to
+undefined symbols.  If the `-l' option is not given, references to
+undefined symbols will be a full long (32 bits) wide.  (Since `as'
+cannot know where these symbols will end up, `as' can only allocate
+space for the linker to fill in later.  Since `as' doesn't know how far
+away these symbols will be, it allocates as much space as it can.) If
+this option is given, the references will only be one word wide (16
+bits).  This may be useful if you want the object file to be as small as
+possible, and you know that the relevant symbols will be less than 17
+bits away.
+
+   The 680x0 version of `as' is most frequently used to assemble
+programs for the Motorola MC68020 microprocessor.  Occasionally it is
+used to assemble programs for the mostly similar, but slightly different
+MC68000 or MC68010 microprocessors.  You can give `as' the options
+`-m68000', `-mc68000', `-m68010', `-mc68010', `-m68020', and `-mc68020'
+to tell it what processor is the target.
+
+
+File: as.info,  Node: M68K-Syntax,  Next: M68K-Moto-Syntax,  Prev: M68K-Opts,  Up: M68K-Dependent
+
+Syntax
+------
+
+   This syntax for the Motorola 680x0 was developed at MIT.
+
+   The 680x0 version of `as' uses syntax similar to the Sun assembler.
+Intervening periods are now ignored; for example, `movl' is equivalent
+to `move.l'.
+
+   In the following table "apc" stands for any of the address registers
+(`a0' through `a7'), nothing, (`'), the Program Counter (`pc'), or the
+zero-address relative to the program counter (`zpc').
+
+   The following addressing modes are understood:
+"Immediate"
+     `#DIGITS'
+
+"Data Register"
+     `d0' through `d7'
+
+"Address Register"
+     `a0' through `a7'
+
+"Address Register Indirect"
+     `a0@' through `a7@'
+     `a7' is also known as `sp', i.e. the Stack Pointer.  `a6' is also
+     known as `fp', the Frame Pointer.
+
+"Address Register Postincrement"
+     `a0@+' through `a7@+'
+
+"Address Register Predecrement"
+     `a0@-' through `a7@-'
+
+"Indirect Plus Offset"
+     `APC@(DIGITS)'
+
+"Index"
+     `APC@(DIGITS,REGISTER:SIZE:SCALE)'
+
+     or `APC@(REGISTER:SIZE:SCALE)'
+
+"Postindex"
+     `APC@(DIGITS)@(DIGITS,REGISTER:SIZE:SCALE)'
+
+     or `APC@(DIGITS)@(REGISTER:SIZE:SCALE)'
+
+"Preindex"
+     `APC@(DIGITS,REGISTER:SIZE:SCALE)@(DIGITS)'
+
+     or `APC@(REGISTER:SIZE:SCALE)@(DIGITS)'
+
+"Memory Indirect"
+     `APC@(DIGITS)@(DIGITS)'
+
+"Absolute"
+     `SYMBOL', or `DIGITS'
+
+   For some configurations, especially those where the compiler normally
+does not prepend an underscore to the names of user variables, the
+assembler requires a `%' before any use of a register name.  This is
+intended to let the assembler distinguish between user variables and
+registers named `a0' through `a7', et cetera.  The `%' is always
+accepted, but is only required for some configurations, notably
+`m68k-coff'.
+
+
+File: as.info,  Node: M68K-Moto-Syntax,  Next: M68K-Float,  Prev: M68K-Syntax,  Up: M68K-Dependent
+
+Motorola Syntax
+---------------
+
+   The standard Motorola syntax for this chip differs from the syntax
+already discussed (*note Syntax: M68K-Syntax.).  `as' can accept both
+kinds of syntax, even within a single instruction.  The syntaxes are
+fully compatible, because the Motorola syntax never uses the `@'
+character and the MIT syntax always does, except in cases where the
+syntaxes are identical.
+
+   In particular, you may write or generate M68K assembler with the
+following conventions:
+
+   (In the following table "apc" stands for any of the address
+registers (`a0' through `a7'), nothing, (`'), the Program Counter
+(`pc'), or the zero-address relative to the program counter (`zpc').)
+
+   The following additional addressing modes are understood:
+"Address Register Indirect"
+     `a0' through `a7'
+     `a7' is also known as `sp', i.e. the Stack Pointer.  `a6' is also
+     known as `fp', the Frame Pointer.
+
+"Address Register Postincrement"
+     `(a0)+' through `(a7)+'
+
+"Address Register Predecrement"
+     `-(a0)' through `-(a7)'
+
+"Indirect Plus Offset"
+     `DIGITS(APC)'
+
+"Index"
+     `DIGITS(APC,(REGISTER.SIZE*SCALE)'
+     or `(APC,REGISTER.SIZE*SCALE)'
+     In either case, SIZE and SCALE are optional (SCALE defaults to
+     `1', SIZE defaults to `l').   SCALE can be `1', `2', `4', or `8'.
+     SIZE can be `w' or `l'.  SCALE is only supported on the 68020 and
+     greater.
+
+
+File: as.info,  Node: M68K-Float,  Next: M68K-Directives,  Prev: M68K-Moto-Syntax,  Up: M68K-Dependent
+
+Floating Point
+--------------
+
+   The floating point code is not too well tested, and may have subtle
+bugs in it.
+
+   Packed decimal (P) format floating literals are not supported.  Feel
+free to add the code!
+
+   The floating point formats generated by directives are these.
+
+`.float'
+     `Single' precision floating point constants.
+
+`.double'
+     `Double' precision floating point constants.
+
+   There is no directive to produce regions of memory holding extended
+precision numbers, however they can be used as immediate operands to
+floating-point instructions.  Adding a directive to create extended
+precision numbers would not be hard, but it has not yet seemed
+necessary.
+
+
+File: as.info,  Node: M68K-Directives,  Next: M68K-opcodes,  Prev: M68K-Float,  Up: M68K-Dependent
+
+680x0 Machine Directives
+------------------------
+
+   In order to be compatible with the Sun assembler the 680x0 assembler
+understands the following directives.
+
+`.data1'
+     This directive is identical to a `.data 1' directive.
+
+`.data2'
+     This directive is identical to a `.data 2' directive.
+
+`.even'
+     This directive is identical to a `.align 1' directive.
+
+`.skip'
+     This directive is identical to a `.space' directive.
+
+
+File: as.info,  Node: M68K-opcodes,  Prev: M68K-Directives,  Up: M68K-Dependent
+
+Opcodes
+-------
+
+* Menu:
+
+* M68K-Branch::                 Branch Improvement
+* M68K-Chars::                  Special Characters
+
+
+File: as.info,  Node: M68K-Branch,  Next: M68K-Chars,  Up: M68K-opcodes
+
+Branch Improvement
+..................
+
+   Certain pseudo opcodes are permitted for branch instructions.  They
+expand to the shortest branch instruction that will reach the target.
+Generally these mnemonics are made by substituting `j' for `b' at the
+start of a Motorola mnemonic.
+
+   The following table summarizes the pseudo-operations.  A `*' flags
+cases that are more fully described after the table:
+
+               Displacement
+               +-------------------------------------------------
+               |                68020   68000/10
+     Pseudo-Op |BYTE    WORD    LONG    LONG      non-PC relative
+               +-------------------------------------------------
+          jbsr |bsrs    bsr     bsrl    jsr       jsr
+           jra |bras    bra     bral    jmp       jmp
+     *     jXX |bXXs    bXX     bXXl    bNXs;jmpl bNXs;jmp
+     *    dbXX |dbXX    dbXX        dbXX; bra; jmpl
+     *    fjXX |fbXXw   fbXXw   fbXXl             fbNXw;jmp
+     
+     XX: condition
+     NX: negative of condition XX
+
+                    `*'--see full description below
+
+`jbsr'
+`jra'
+     These are the simplest jump pseudo-operations; they always map to
+     one particular machine instruction, depending on the displacement
+     to the branch target.
+
+`jXX'
+     Here, `jXX' stands for an entire family of pseudo-operations,
+     where XX is a conditional branch or condition-code test.  The full
+     list of pseudo-ops in this family is:
+           jhi   jls   jcc   jcs   jne   jeq   jvc
+           jvs   jpl   jmi   jge   jlt   jgt   jle
+
+     For the cases of non-PC relative displacements and long
+     displacements on the 68000 or 68010, `as' will issue a longer code
+     fragment in terms of NX, the opposite condition to XX.  For
+     example, for the non-PC relative case:
+              jXX foo
+     gives
+               bNXs oof
+               jmp foo
+           oof:
+
+`dbXX'
+     The full family of pseudo-operations covered here is
+           dbhi   dbls   dbcc   dbcs   dbne   dbeq   dbvc
+           dbvs   dbpl   dbmi   dbge   dblt   dbgt   dble
+           dbf    dbra   dbt
+
+     Other than for word and byte displacements, when the source reads
+     `dbXX foo', `as' will emit
+               dbXX oo1
+               bra oo2
+           oo1:jmpl foo
+           oo2:
+
+`fjXX'
+     This family includes
+           fjne   fjeq   fjge   fjlt   fjgt   fjle   fjf
+           fjt    fjgl   fjgle  fjnge  fjngl  fjngle fjngt
+           fjnle  fjnlt  fjoge  fjogl  fjogt  fjole  fjolt
+           fjor   fjseq  fjsf   fjsne  fjst   fjueq  fjuge
+           fjugt  fjule  fjult  fjun
+
+     For branch targets that are not PC relative, `as' emits
+               fbNX oof
+               jmp foo
+           oof:
+     when it encounters `fjXX foo'.
+
diff --git a/gas/doc/as.info-4 b/gas/doc/as.info-4
new file mode 100644
index 0000000..4571cf8
--- /dev/null
+++ b/gas/doc/as.info-4
@@ -0,0 +1,874 @@
+This is Info file as.info, produced by Makeinfo-1.55 from the input
+file ./as.texinfo.
+
+START-INFO-DIR-ENTRY
+* As::                          The GNU assembler.
+END-INFO-DIR-ENTRY
+
+   This file documents the GNU Assembler "as".
+
+   Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the section entitled "GNU General Public License" is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that the section entitled "GNU General Public License"
+may be included in a translation approved by the Free Software
+Foundation instead of in the original English.
+
+
+File: as.info,  Node: M68K-Chars,  Prev: M68K-Branch,  Up: M68K-opcodes
+
+Special Characters
+..................
+
+   The immediate character is `#' for Sun compatibility.  The
+line-comment character is `|'.  If a `#' appears at the beginning of a
+line, it is treated as a comment unless it looks like `# line file', in
+which case it is treated normally.
+
+
+File: as.info,  Node: Sparc-Dependent,  Next: Z8000-Dependent,  Prev: M68K-Dependent,  Up: Machine Dependencies
+
+SPARC Dependent Features
+========================
+
+* Menu:
+
+* Sparc-Opts::                  Options
+* Sparc-Float::                 Floating Point
+* Sparc-Directives::            Sparc Machine Directives
+
+
+File: as.info,  Node: Sparc-Opts,  Next: Sparc-Float,  Up: Sparc-Dependent
+
+Options
+-------
+
+   The SPARC chip family includes several successive levels (or other
+variants) of chip, using the same core instruction set, but including a
+few additional instructions at each level.
+
+   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.
+
+`-Av6 | -Av7 | -Av8 | -Asparclite'
+     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 a higher level.
+
+`-bump'
+     Permit the assembler to "bump" the architecture level as required,
+     but warn whenever it is necessary to switch to another level.
+
+
+File: as.info,  Node: Sparc-Float,  Next: Sparc-Directives,  Prev: Sparc-Opts,  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:
+
+`.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'.
+
+`.proc'
+     This directive is ignored.  Any text following it on the same line
+     is also ignored.
+
+`.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.
+
+
+File: as.info,  Node: i386-Dependent,  Prev: Z8000-Dependent,  Up: Machine Dependencies
+
+80386 Dependent Features
+========================
+
+* Menu:
+
+* i386-Options::                Options
+* i386-Syntax::                 AT&T Syntax versus Intel Syntax
+* i386-Opcodes::                Opcode Naming
+* i386-Regs::                   Register Naming
+* i386-prefixes::               Opcode Prefixes
+* i386-Memory::                 Memory References
+* i386-jumps::                  Handling of Jump Instructions
+* i386-Float::                  Floating Point
+* i386-Notes::                  Notes
+
+
+File: as.info,  Node: i386-Options,  Next: i386-Syntax,  Up: i386-Dependent
+
+Options
+-------
+
+   The 80386 has no machine dependent options.
+
+
+File: as.info,  Node: i386-Syntax,  Next: i386-Opcodes,  Prev: i386-Options,  Up: i386-Dependent
+
+AT&T Syntax versus Intel Syntax
+-------------------------------
+
+   In order to maintain compatibility with the output of `gcc', `as'
+supports AT&T System V/386 assembler syntax.  This is quite different
+from Intel syntax.  We mention these differences because almost all
+80386 documents used only Intel syntax.  Notable differences between
+the two syntaxes are:
+
+   * AT&T immediate operands are preceded by `$'; Intel immediate
+     operands are undelimited (Intel `push 4' is AT&T `pushl $4').
+     AT&T register operands are preceded by `%'; Intel register operands
+     are undelimited.  AT&T absolute (as opposed to PC relative)
+     jump/call operands are prefixed by `*'; they are undelimited in
+     Intel syntax.
+
+   * AT&T and Intel syntax use the opposite order for source and
+     destination operands.  Intel `add eax, 4' is `addl $4, %eax'.  The
+     `source, dest' convention is maintained for compatibility with
+     previous Unix assemblers.
+
+   * In AT&T syntax the size of memory operands is determined from the
+     last character of the opcode name.  Opcode suffixes of `b', `w',
+     and `l' specify byte (8-bit), word (16-bit), and long (32-bit)
+     memory references.  Intel syntax accomplishes this by prefixes
+     memory operands (*not* the opcodes themselves) with `byte ptr',
+     `word ptr', and `dword ptr'.  Thus, Intel `mov al, byte ptr FOO'
+     is `movb FOO, %al' in AT&T syntax.
+
+   * Immediate form long jumps and calls are `lcall/ljmp $SECTION,
+     $OFFSET' in AT&T syntax; the Intel syntax is `call/jmp far
+     SECTION:OFFSET'.  Also, the far return instruction is `lret
+     $STACK-ADJUST' in AT&T syntax; Intel syntax is `ret far
+     STACK-ADJUST'.
+
+   * The AT&T assembler does not provide support for multiple section
+     programs.  Unix style systems expect all programs to be single
+     sections.
+
+
+File: as.info,  Node: i386-Opcodes,  Next: i386-Regs,  Prev: i386-Syntax,  Up: i386-Dependent
+
+Opcode Naming
+-------------
+
+   Opcode names are suffixed with one character modifiers which specify
+the size of operands.  The letters `b', `w', and `l' specify byte,
+word, and long operands.  If no suffix is specified by an instruction
+and it contains no memory operands then `as' tries to fill in the
+missing suffix based on the destination register operand (the last one
+by convention).  Thus, `mov %ax, %bx' is equivalent to `movw %ax, %bx';
+also, `mov $1, %bx' is equivalent to `movw $1, %bx'.  Note that this is
+incompatible with the AT&T Unix assembler which assumes that a missing
+opcode suffix implies long operand size.  (This incompatibility does
+not affect compiler output since compilers always explicitly specify
+the opcode suffix.)
+
+   Almost all opcodes have the same names in AT&T and Intel format.
+There are a few exceptions.  The sign extend and zero extend
+instructions need two sizes to specify them.  They need a size to
+sign/zero extend *from* and a size to zero extend *to*.  This is
+accomplished by using two opcode suffixes in AT&T syntax.  Base names
+for sign extend and zero extend are `movs...' and `movz...' in AT&T
+syntax (`movsx' and `movzx' in Intel syntax).  The opcode suffixes are
+tacked on to this base name, the *from* suffix before the *to* suffix.
+Thus, `movsbl %al, %edx' is AT&T syntax for "move sign extend *from*
+%al *to* %edx."  Possible suffixes, thus, are `bl' (from byte to long),
+`bw' (from byte to word), and `wl' (from word to long).
+
+   The Intel-syntax conversion instructions
+
+   * `cbw' -- sign-extend byte in `%al' to word in `%ax',
+
+   * `cwde' -- sign-extend word in `%ax' to long in `%eax',
+
+   * `cwd' -- sign-extend word in `%ax' to long in `%dx:%ax',
+
+   * `cdq' -- sign-extend dword in `%eax' to quad in `%edx:%eax',
+
+are called `cbtw', `cwtl', `cwtd', and `cltd' in AT&T naming.  `as'
+accepts either naming for these instructions.
+
+   Far call/jump instructions are `lcall' and `ljmp' in AT&T syntax,
+but are `call far' and `jump far' in Intel convention.
+
+
+File: as.info,  Node: i386-Regs,  Next: i386-prefixes,  Prev: i386-Opcodes,  Up: i386-Dependent
+
+Register Naming
+---------------
+
+   Register operands are always prefixes with `%'.  The 80386 registers
+consist of
+
+   * the 8 32-bit registers `%eax' (the accumulator), `%ebx', `%ecx',
+     `%edx', `%edi', `%esi', `%ebp' (the frame pointer), and `%esp'
+     (the stack pointer).
+
+   * the 8 16-bit low-ends of these: `%ax', `%bx', `%cx', `%dx', `%di',
+     `%si', `%bp', and `%sp'.
+
+   * the 8 8-bit registers: `%ah', `%al', `%bh', `%bl', `%ch', `%cl',
+     `%dh', and `%dl' (These are the high-bytes and low-bytes of `%ax',
+     `%bx', `%cx', and `%dx')
+
+   * the 6 section registers `%cs' (code section), `%ds' (data
+     section), `%ss' (stack section), `%es', `%fs', and `%gs'.
+
+   * the 3 processor control registers `%cr0', `%cr2', and `%cr3'.
+
+   * the 6 debug registers `%db0', `%db1', `%db2', `%db3', `%db6', and
+     `%db7'.
+
+   * the 2 test registers `%tr6' and `%tr7'.
+
+   * the 8 floating point register stack `%st' or equivalently
+     `%st(0)', `%st(1)', `%st(2)', `%st(3)', `%st(4)', `%st(5)',
+     `%st(6)', and `%st(7)'.
+
+
+File: as.info,  Node: i386-prefixes,  Next: i386-Memory,  Prev: i386-Regs,  Up: i386-Dependent
+
+Opcode Prefixes
+---------------
+
+   Opcode prefixes are used to modify the following opcode.  They are
+used to repeat string instructions, to provide section overrides, to
+perform bus lock operations, and to give operand and address size
+(16-bit operands are specified in an instruction by prefixing what would
+normally be 32-bit operands with a "operand size" opcode prefix).
+Opcode prefixes are usually given as single-line instructions with no
+operands, and must directly precede the instruction they act upon.  For
+example, the `scas' (scan string) instruction is repeated with:
+             repne
+             scas
+
+   Here is a list of opcode prefixes:
+
+   * Section override prefixes `cs', `ds', `ss', `es', `fs', `gs'.
+     These are automatically added by specifying using the
+     SECTION:MEMORY-OPERAND form for memory references.
+
+   * Operand/Address size prefixes `data16' and `addr16' change 32-bit
+     operands/addresses into 16-bit operands/addresses.  Note that
+     16-bit addressing modes (i.e. 8086 and 80286 addressing modes) are
+     not supported (yet).
+
+   * The bus lock prefix `lock' inhibits interrupts during execution of
+     the instruction it precedes.  (This is only valid with certain
+     instructions; see a 80386 manual for details).
+
+   * The wait for coprocessor prefix `wait' waits for the coprocessor
+     to complete the current instruction.  This should never be needed
+     for the 80386/80387 combination.
+
+   * The `rep', `repe', and `repne' prefixes are added to string
+     instructions to make them repeat `%ecx' times.
+
+
+File: as.info,  Node: i386-Memory,  Next: i386-jumps,  Prev: i386-prefixes,  Up: i386-Dependent
+
+Memory References
+-----------------
+
+   An Intel syntax indirect memory reference of the form
+
+     SECTION:[BASE + INDEX*SCALE + DISP]
+
+is translated into the AT&T syntax
+
+     SECTION:DISP(BASE, INDEX, SCALE)
+
+where BASE and INDEX are the optional 32-bit base and index registers,
+DISP is the optional displacement, and SCALE, taking the values 1, 2,
+4, and 8, multiplies INDEX to calculate the address of the operand.  If
+no SCALE is specified, SCALE is taken to be 1.  SECTION specifies the
+optional section register for the memory operand, and may override the
+default section register (see a 80386 manual for section register
+defaults). Note that section overrides in AT&T syntax *must* have be
+preceded by a `%'.  If you specify a section override which coincides
+with the default section register, `as' will *not* output any section
+register override prefixes to assemble the given instruction.  Thus,
+section overrides can be specified to emphasize which section register
+is used for a given memory operand.
+
+   Here are some examples of Intel and AT&T style memory references:
+
+AT&T: `-4(%ebp)', Intel:  `[ebp - 4]'
+     BASE is `%ebp'; DISP is `-4'. SECTION is missing, and the default
+     section is used (`%ss' for addressing with `%ebp' as the base
+     register).  INDEX, SCALE are both missing.
+
+AT&T: `foo(,%eax,4)', Intel: `[foo + eax*4]'
+     INDEX is `%eax' (scaled by a SCALE 4); DISP is `foo'.  All other
+     fields are missing.  The section register here defaults to `%ds'.
+
+AT&T: `foo(,1)'; Intel `[foo]'
+     This uses the value pointed to by `foo' as a memory operand.  Note
+     that BASE and INDEX are both missing, but there is only *one* `,'.
+     This is a syntactic exception.
+
+AT&T: `%gs:foo'; Intel `gs:foo'
+     This selects the contents of the variable `foo' with section
+     register SECTION being `%gs'.
+
+   Absolute (as opposed to PC relative) call and jump operands must be
+prefixed with `*'.  If no `*' is specified, `as' will always choose PC
+relative addressing for jump/call labels.
+
+   Any instruction that has a memory operand *must* specify its size
+(byte, word, or long) with an opcode suffix (`b', `w', or `l',
+respectively).
+
+
+File: as.info,  Node: i386-jumps,  Next: i386-Float,  Prev: i386-Memory,  Up: i386-Dependent
+
+Handling of Jump Instructions
+-----------------------------
+
+   Jump instructions are always optimized to use the smallest possible
+displacements.  This is accomplished by using byte (8-bit) displacement
+jumps whenever the target is sufficiently close.  If a byte displacement
+is insufficient a long (32-bit) displacement is used.  We do not support
+word (16-bit) displacement jumps (i.e. prefixing the jump instruction
+with the `addr16' opcode prefix), since the 80386 insists upon masking
+`%eip' to 16 bits after the word displacement is added.
+
+   Note that the `jcxz', `jecxz', `loop', `loopz', `loope', `loopnz'
+and `loopne' instructions only come in byte displacements, so that it
+is possible that use of these instructions (`gcc' does not use them)
+will cause the assembler to print an error message (and generate
+incorrect code).  The AT&T 80386 assembler tries to get around this
+problem by expanding `jcxz foo' to
+              jcxz cx_zero
+              jmp cx_nonzero
+     cx_zero: jmp foo
+     cx_nonzero:
+
+
+File: as.info,  Node: i386-Float,  Next: i386-Notes,  Prev: i386-jumps,  Up: i386-Dependent
+
+Floating Point
+--------------
+
+   All 80387 floating point types except packed BCD are supported.
+(BCD support may be added without much difficulty).  These data types
+are 16-, 32-, and 64- bit integers, and single (32-bit), double
+(64-bit), and extended (80-bit) precision floating point.  Each
+supported type has an opcode suffix and a constructor associated with
+it.  Opcode suffixes specify operand's data types.  Constructors build
+these data types into memory.
+
+   * Floating point constructors are `.float' or `.single', `.double',
+     and `.tfloat' for 32-, 64-, and 80-bit formats.  These correspond
+     to opcode suffixes `s', `l', and `t'.  `t' stands for temporary
+     real, and that the 80387 only supports this format via the `fldt'
+     (load temporary real to stack top) and `fstpt' (store temporary
+     real and pop stack) instructions.
+
+   * Integer constructors are `.word', `.long' or `.int', and `.quad'
+     for the 16-, 32-, and 64-bit integer formats.  The corresponding
+     opcode suffixes are `s' (single), `l' (long), and `q' (quad).  As
+     with the temporary real format the 64-bit `q' format is only
+     present in the `fildq' (load quad integer to stack top) and
+     `fistpq' (store quad integer and pop stack) instructions.
+
+   Register to register operations do not require opcode suffixes, so
+that `fst %st, %st(1)' is equivalent to `fstl %st, %st(1)'.
+
+   Since the 80387 automatically synchronizes with the 80386 `fwait'
+instructions are almost never needed (this is not the case for the
+80286/80287 and 8086/8087 combinations).  Therefore, `as' suppresses
+the `fwait' instruction whenever it is implicitly selected by one of
+the `fn...' instructions.  For example, `fsave' and `fnsave' are
+treated identically.  In general, all the `fn...' instructions are made
+equivalent to `f...' instructions.  If `fwait' is desired it must be
+explicitly coded.
+
+
+File: as.info,  Node: i386-Notes,  Prev: i386-Float,  Up: i386-Dependent
+
+Notes
+-----
+
+   There is some trickery concerning the `mul' and `imul' instructions
+that deserves mention.  The 16-, 32-, and 64-bit expanding multiplies
+(base opcode `0xf6'; extension 4 for `mul' and 5 for `imul') can be
+output only in the one operand form.  Thus, `imul %ebx, %eax' does
+*not* select the expanding multiply; the expanding multiply would
+clobber the `%edx' register, and this would confuse `gcc' output.  Use
+`imul %ebx' to get the 64-bit product in `%edx:%eax'.
+
+   We have added a two operand form of `imul' when the first operand is
+an immediate mode expression and the second operand is a register.
+This is just a shorthand, so that, multiplying `%eax' by 69, for
+example, can be done with `imul $69, %eax' rather than `imul $69, %eax,
+%eax'.
+
+
+File: as.info,  Node: Z8000-Dependent,  Next: i386-Dependent,  Prev: Sparc-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 will take 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'
+     Synonum 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'
+     synonym for `.align 1'
+
+
+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: Acknowledgements,  Next: Index,  Prev: Copying,  Up: Top
+
+Acknowledgements
+****************
+
+   If you've contributed to `as' and your name isn't listed here, it is
+not meant as a slight.  We just don't know about it.  Send mail to the
+maintainer, and we'll correct the situation.  Currently (June 1993), the
+maintainer is Ken Raeburn (email address `raeburn@cygnus.com').
+
+   Dean Elsner wrote the original GNU assembler for the VAX.(1)
+
+   Jay Fenlason maintained GAS for a while, adding support for
+gdb-specific debug information and the 68k series machines, most of the
+preprocessing pass, and extensive changes in messages.c, input-file.c,
+write.c.
+
+   K. Richard Pixley maintained GAS for a while, adding various
+enhancements and many bug fixes, including merging support for several
+processors, breaking GAS up to handle multiple object file format
+backends (including heavy rewrite, testing, an integration of the coff
+and b.out backends), adding configuration including heavy testing and
+verification of cross assemblers and file splits and renaming,
+converted GAS to strictly ansi C including full prototypes, added
+support for m680[34]0 & cpu32, considerable work on i960 including a
+COFF port (including considerable amounts of reverse engineering), a
+SPARC opcode file rewrite, DECstation, rs6000, and hp300hpux host
+ports, updated "know" assertions and made them work, much other
+reorganization, cleanup, and lint.
+
+   Ken Raeburn wrote the high-level BFD interface code to replace most
+of the code in format-specific I/O modules.
+
+   The original VMS support was contributed by David L. Kashtan.  Eric
+Youngdale has done much work with it since.
+
+   The Intel 80386 machine description was written by Eliot Dresselhaus.
+
+   Minh Tran-Le at IntelliCorp contributed some AIX 386 support.
+
+   The Motorola 88k machine description was contributed by Devon Bowen
+of Buffalo University and Torbjorn Granlund of the Swedish Institute of
+Computer Science.
+
+   Keith Knowles at the Open Software Foundation wrote the original
+MIPS back end (tc-mips.c, tc-mips.h), and contributed Rose format
+support (which hasn't been merged in yet).  Ralph Campbell worked with
+the MIPS code to support a.out format.
+
+   Support for the Zilog Z8k and Hitachi H8/300 and H8/500 processors
+(tc-z8k, tc-h8300, tc-h8500), and IEEE 695 object file format
+(obj-ieee), was written by Steve Chamberlain of Cygnus Support.  Steve
+also modified the COFF back end to use BFD for some low-level
+operations, for use with the H8/300 and AMD 29k targets.
+
+   John Gilmore built the AMD 29000 support, added .include support, and
+simplified the configuration of which versions accept which pseudo-ops.
+He updated the 68k machine description so that Motorola's opcodes
+always produced fixed-size instructions (e.g. jsr), while synthetic
+instructions remained shrinkable (jbsr).  John fixed many bugs,
+including true tested cross-compilation support, and one bug in
+relaxation that took a week and required the apocryphal one-bit fix.
+
+   Ian Lance Taylor of Cygnus Support merged the Motorola and MIT
+syntaxes for the 68k, completed support for some COFF targets (68k,
+i386 SVR3, and SCO Unix), and made a few other minor patches.
+
+   Steve Chamberlain made `as' able to generate listings.
+
+   Support for the HP9000/300 was contributed by Hewlett-Packard.
+
+   Support for ELF format files has been worked on by Mark Eichin of
+Cygnus Support (original, incomplete implementation for SPARC), Pete
+Hoogenboom and Jeff Law at the University of Utah (HPPA mainly),
+Michael Meissner of the Open Software Foundation (i386 mainly), and Ken
+Raeburn of Cygnus Support (sparc, and some initial 64-bit support).
+
+   Several engineers at Cygnus Support have also provided many small
+bug fixes and configuration enhancements.
+
+   Many others have contributed large or small bugfixes and
+enhancements.  If you've contributed significant work and are not
+mentioned on this list, and want to be, let us know.  Some of the
+history has been lost; we aren't intentionally leaving anyone out.
+
+   ---------- Footnotes ----------
+
+   (1)  Any more details?
+
diff --git a/gas/doc/as.info-5 b/gas/doc/as.info-5
new file mode 100644
index 0000000..97bcad3
--- /dev/null
+++ b/gas/doc/as.info-5
@@ -0,0 +1,394 @@
+This is Info file as.info, produced by Makeinfo-1.55 from the input
+file ./as.texinfo.
+
+START-INFO-DIR-ENTRY
+* As::                          The GNU assembler.
+END-INFO-DIR-ENTRY
+
+   This file documents the GNU Assembler "as".
+
+   Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the section entitled "GNU General Public License" is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that the section entitled "GNU General Public License"
+may be included in a translation approved by the Free Software
+Foundation instead of in the original English.
+
+
+File: as.info,  Node: Copying,  Next: Acknowledgements,  Prev: Machine Dependencies,  Up: Top
+
+
+
+GNU GENERAL PUBLIC LICENSE
+**************************
+
+                         Version 2, June 1991
+
+     Copyright (C) 1989, 1991 Free Software Foundation, Inc.  675
+     Mass Ave, Cambridge, MA 02139, USA
+     
+     Everyone is permitted to copy and distribute verbatim copies
+     of this license document, but changing it is not allowed.
+
+Preamble
+========
+
+   The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+   When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it in
+new free programs; and that you know you can do these things.
+
+   To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+   For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+   We protect your rights with two steps: (1) copyright the software,
+and (2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+   Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+   Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+   The precise terms and conditions for copying, distribution and
+modification follow.
+
+    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  1. This License applies to any program or other work which contains a
+     notice placed by the copyright holder saying it may be distributed
+     under the terms of this General Public License.  The "Program",
+     below, refers to any such program or work, and a "work based on
+     the Program" means either the Program or any derivative work under
+     copyright law: that is to say, a work containing the Program or a
+     portion of it, either verbatim or with modifications and/or
+     translated into another language.  (Hereinafter, translation is
+     included without limitation in the term "modification".)  Each
+     licensee is addressed as "you".
+
+     Activities other than copying, distribution and modification are
+     not covered by this License; they are outside its scope.  The act
+     of running the Program is not restricted, and the output from the
+     Program is covered only if its contents constitute a work based on
+     the Program (independent of having been made by running the
+     Program).  Whether that is true depends on what the Program does.
+
+  2. You may copy and distribute verbatim copies of the Program's
+     source code as you receive it, in any medium, provided that you
+     conspicuously and appropriately publish on each copy an appropriate
+     copyright notice and disclaimer of warranty; keep intact all the
+     notices that refer to this License and to the absence of any
+     warranty; and give any other recipients of the Program a copy of
+     this License along with the Program.
+
+     You may charge a fee for the physical act of transferring a copy,
+     and you may at your option offer warranty protection in exchange
+     for a fee.
+
+  3. You may modify your copy or copies of the Program or any portion
+     of it, thus forming a work based on the Program, and copy and
+     distribute such modifications or work under the terms of Section 1
+     above, provided that you also meet all of these conditions:
+
+       a. You must cause the modified files to carry prominent notices
+          stating that you changed the files and the date of any change.
+
+       b. You must cause any work that you distribute or publish, that
+          in whole or in part contains or is derived from the Program
+          or any part thereof, to be licensed as a whole at no charge
+          to all third parties under the terms of this License.
+
+       c. If the modified program normally reads commands interactively
+          when run, you must cause it, when started running for such
+          interactive use in the most ordinary way, to print or display
+          an announcement including an appropriate copyright notice and
+          a notice that there is no warranty (or else, saying that you
+          provide a warranty) and that users may redistribute the
+          program under these conditions, and telling the user how to
+          view a copy of this License.  (Exception: if the Program
+          itself is interactive but does not normally print such an
+          announcement, your work based on the Program is not required
+          to print an announcement.)
+
+     These requirements apply to the modified work as a whole.  If
+     identifiable sections of that work are not derived from the
+     Program, and can be reasonably considered independent and separate
+     works in themselves, then this License, and its terms, do not
+     apply to those sections when you distribute them as separate
+     works.  But when you distribute the same sections as part of a
+     whole which is a work based on the Program, the distribution of
+     the whole must be on the terms of this License, whose permissions
+     for other licensees extend to the entire whole, and thus to each
+     and every part regardless of who wrote it.
+
+     Thus, it is not the intent of this section to claim rights or
+     contest your rights to work written entirely by you; rather, the
+     intent is to exercise the right to control the distribution of
+     derivative or collective works based on the Program.
+
+     In addition, mere aggregation of another work not based on the
+     Program with the Program (or with a work based on the Program) on
+     a volume of a storage or distribution medium does not bring the
+     other work under the scope of this License.
+
+  4. You may copy and distribute the Program (or a work based on it,
+     under Section 2) in object code or executable form under the terms
+     of Sections 1 and 2 above provided that you also do one of the
+     following:
+
+       a. Accompany it with the complete corresponding machine-readable
+          source code, which must be distributed under the terms of
+          Sections 1 and 2 above on a medium customarily used for
+          software interchange; or,
+
+       b. Accompany it with a written offer, valid for at least three
+          years, to give any third party, for a charge no more than your
+          cost of physically performing source distribution, a complete
+          machine-readable copy of the corresponding source code, to be
+          distributed under the terms of Sections 1 and 2 above on a
+          medium customarily used for software interchange; or,
+
+       c. Accompany it with the information you received as to the offer
+          to distribute corresponding source code.  (This alternative is
+          allowed only for noncommercial distribution and only if you
+          received the program in object code or executable form with
+          such an offer, in accord with Subsection b above.)
+
+     The source code for a work means the preferred form of the work for
+     making modifications to it.  For an executable work, complete
+     source code means all the source code for all modules it contains,
+     plus any associated interface definition files, plus the scripts
+     used to control compilation and installation of the executable.
+     However, as a special exception, the source code distributed need
+     not include anything that is normally distributed (in either
+     source or binary form) with the major components (compiler,
+     kernel, and so on) of the operating system on which the executable
+     runs, unless that component itself accompanies the executable.
+
+     If distribution of executable or object code is made by offering
+     access to copy from a designated place, then offering equivalent
+     access to copy the source code from the same place counts as
+     distribution of the source code, even though third parties are not
+     compelled to copy the source along with the object code.
+
+  5. You may not copy, modify, sublicense, or distribute the Program
+     except as expressly provided under this License.  Any attempt
+     otherwise to copy, modify, sublicense or distribute the Program is
+     void, and will automatically terminate your rights under this
+     License.  However, parties who have received copies, or rights,
+     from you under this License will not have their licenses
+     terminated so long as such parties remain in full compliance.
+
+  6. You are not required to accept this License, since you have not
+     signed it.  However, nothing else grants you permission to modify
+     or distribute the Program or its derivative works.  These actions
+     are prohibited by law if you do not accept this License.
+     Therefore, by modifying or distributing the Program (or any work
+     based on the Program), you indicate your acceptance of this
+     License to do so, and all its terms and conditions for copying,
+     distributing or modifying the Program or works based on it.
+
+  7. Each time you redistribute the Program (or any work based on the
+     Program), the recipient automatically receives a license from the
+     original licensor to copy, distribute or modify the Program
+     subject to these terms and conditions.  You may not impose any
+     further restrictions on the recipients' exercise of the rights
+     granted herein.  You are not responsible for enforcing compliance
+     by third parties to this License.
+
+  8. If, as a consequence of a court judgment or allegation of patent
+     infringement or for any other reason (not limited to patent
+     issues), conditions are imposed on you (whether by court order,
+     agreement or otherwise) that contradict the conditions of this
+     License, they do not excuse you from the conditions of this
+     License.  If you cannot distribute so as to satisfy simultaneously
+     your obligations under this License and any other pertinent
+     obligations, then as a consequence you may not distribute the
+     Program at all.  For example, if a patent license would not permit
+     royalty-free redistribution of the Program by all those who
+     receive copies directly or indirectly through you, then the only
+     way you could satisfy both it and this License would be to refrain
+     entirely from distribution of the Program.
+
+     If any portion of this section is held invalid or unenforceable
+     under any particular circumstance, the balance of the section is
+     intended to apply and the section as a whole is intended to apply
+     in other circumstances.
+
+     It is not the purpose of this section to induce you to infringe any
+     patents or other property right claims or to contest validity of
+     any such claims; this section has the sole purpose of protecting
+     the integrity of the free software distribution system, which is
+     implemented by public license practices.  Many people have made
+     generous contributions to the wide range of software distributed
+     through that system in reliance on consistent application of that
+     system; it is up to the author/donor to decide if he or she is
+     willing to distribute software through any other system and a
+     licensee cannot impose that choice.
+
+     This section is intended to make thoroughly clear what is believed
+     to be a consequence of the rest of this License.
+
+  9. If the distribution and/or use of the Program is restricted in
+     certain countries either by patents or by copyrighted interfaces,
+     the original copyright holder who places the Program under this
+     License may add an explicit geographical distribution limitation
+     excluding those countries, so that distribution is permitted only
+     in or among countries not thus excluded.  In such case, this
+     License incorporates the limitation as if written in the body of
+     this License.
+
+ 10. The Free Software Foundation may publish revised and/or new
+     versions of the General Public License from time to time.  Such
+     new versions will be similar in spirit to the present version, but
+     may differ in detail to address new problems or concerns.
+
+     Each version is given a distinguishing version number.  If the
+     Program specifies a version number of this License which applies
+     to it and "any later version", you have the option of following
+     the terms and conditions either of that version or of any later
+     version published by the Free Software Foundation.  If the Program
+     does not specify a version number of this License, you may choose
+     any version ever published by the Free Software Foundation.
+
+ 11. If you wish to incorporate parts of the Program into other free
+     programs whose distribution conditions are different, write to the
+     author to ask for permission.  For software which is copyrighted
+     by the Free Software Foundation, write to the Free Software
+     Foundation; we sometimes make exceptions for this.  Our decision
+     will be guided by the two goals of preserving the free status of
+     all derivatives of our free software and of promoting the sharing
+     and reuse of software generally.
+
+                                NO WARRANTY
+
+ 12. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
+     WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
+     LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+     HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
+     WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
+     NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+     FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE
+     QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+     PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
+     SERVICING, REPAIR OR CORRECTION.
+
+ 13. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+     WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
+     MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE
+     LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
+     INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
+     INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+     DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
+     OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY
+     OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+                      END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+=============================================
+
+   If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+   To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+     ONE LINE TO GIVE THE PROGRAM'S NAME AND AN IDEA OF WHAT IT DOES.
+     Copyright (C) 19YY  NAME OF AUTHOR
+     
+     This program is free software; you can redistribute it and/or
+     modify it under the terms of the GNU General Public License
+     as published by the Free Software Foundation; either version 2
+     of the License, or (at your option) any later version.
+     
+     This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+     
+     You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   Also add information on how to contact you by electronic and paper
+mail.
+
+   If the program is interactive, make it output a short notice like
+this when it starts in an interactive mode:
+
+     Gnomovision version 69, Copyright (C) 19YY NAME OF AUTHOR
+     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
+     type `show w'.  This is free software, and you are welcome
+     to redistribute it under certain conditions; type `show c'
+     for details.
+
+   The hypothetical commands `show w' and `show c' should show the
+appropriate parts of the General Public License.  Of course, the
+commands you use may be called something other than `show w' and `show
+c'; they could even be mouse-clicks or menu items--whatever suits your
+program.
+
+   You should also get your employer (if you work as a programmer) or
+your school, if any, to sign a "copyright disclaimer" for the program,
+if necessary.  Here is a sample; alter the names:
+
+     Yoyodyne, Inc., hereby disclaims all copyright
+     interest in the program `Gnomovision'
+     (which makes passes at compilers) written
+     by James Hacker.
+     
+     SIGNATURE OF TY COON, 1 April 1989
+     Ty Coon, President of Vice
+
+   This General Public License does not permit incorporating your
+program into proprietary programs.  If your program is a subroutine
+library, you may consider it more useful to permit linking proprietary
+applications with the library.  If this is what you want to do, use the
+GNU Library General Public License instead of this License.
+