1 \input texinfo @c -*-Texinfo-*-
2 @c Copyright (c) 1991 1992 1993 1994 Free Software Foundation, Inc.
3 @c UPDATE!! On future updates--
4 @c (1) check for new machine-dep cmdline options in
5 @c md_parse_option definitions in config/tc-*.c
6 @c (2) for platform-specific directives, examine md_pseudo_op
8 @c (3) for object-format specific directives, examine obj_pseudo_op
10 @c (4) portable directives in potable[] in read.c
14 @c defaults, config file may override:
17 @include asconfig.texi
19 @c common OR combinations of conditions
36 @set abnormal-separator
40 @settitle Using @value{AS}
43 @settitle Using @value{AS} (@value{TARGET})
45 @setchapternewpage odd
50 @c WARE! Some of the machine-dependent sections contain tables of machine
51 @c instructions. Except in multi-column format, these tables look silly.
52 @c Unfortunately, Texinfo doesn't have a general-purpose multi-col format, so
53 @c the multi-col format is faked within @example sections.
55 @c Again unfortunately, the natural size that fits on a page, for these tables,
56 @c is different depending on whether or not smallbook is turned on.
57 @c This matters, because of order: text flow switches columns at each page
60 @c The format faked in this source works reasonably well for smallbook,
61 @c not well for the default large-page format. This manual expects that if you
62 @c turn on @smallbook, you will also uncomment the "@set SMALL" to enable the
63 @c tables in question. You can turn on one without the other at your
64 @c discretion, of course.
67 @c the insn tables look just as silly in info files regardless of smallbook,
68 @c might as well show 'em anyways.
74 * As: (as). The GNU assembler.
83 This file documents the GNU Assembler "@value{AS}".
85 Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
87 Permission is granted to make and distribute verbatim copies of
88 this manual provided the copyright notice and this permission notice
89 are preserved on all copies.
92 Permission is granted to process this file through Tex and print the
93 results, provided the printed document carries copying permission
94 notice identical to this one except for the removal of this paragraph
95 (this paragraph not being relevant to the printed manual).
98 Permission is granted to copy and distribute modified versions of this manual
99 under the conditions for verbatim copying, provided that the entire resulting
100 derived work is distributed under the terms of a permission notice identical to
103 Permission is granted to copy and distribute translations of this manual
104 into another language, under the above conditions for modified versions.
108 @title Using @value{AS}
109 @subtitle The GNU Assembler
111 @subtitle for the @value{TARGET} family
114 @subtitle January 1994
117 The Free Software Foundation Inc. thanks The Nice Computer
118 Company of Australia for loaning Dean Elsner to write the
119 first (Vax) version of @code{as} for Project GNU.
120 The proprietors, management and staff of TNCCA thank FSF for
121 distracting the boss while they got some work
124 @author Dean Elsner, Jay Fenlason & friends
128 \hfill {\it Using {\tt @value{AS}}}\par
129 \hfill Edited by Roland Pesch for Cygnus Support\par
131 %"boxit" macro for figures:
132 %Modified from Knuth's ``boxit'' macro from TeXbook (answer to exercise 21.3)
133 \gdef\boxit#1#2{\vbox{\hrule\hbox{\vrule\kern3pt
134 \vbox{\parindent=0pt\parskip=0pt\hsize=#1\kern3pt\strut\hfil
135 #2\hfil\strut\kern3pt}\kern3pt\vrule}\hrule}}%box with visible outline
136 \gdef\ibox#1#2{\hbox to #1{#2\hfil}\kern8pt}% invisible box
139 @vskip 0pt plus 1filll
140 Copyright @copyright{} 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
142 Permission is granted to make and distribute verbatim copies of
143 this manual provided the copyright notice and this permission notice
144 are preserved on all copies.
146 Permission is granted to copy and distribute modified versions of this manual
147 under the conditions for verbatim copying, provided that the entire resulting
148 derived work is distributed under the terms of a permission notice identical to
151 Permission is granted to copy and distribute translations of this manual
152 into another language, under the above conditions for modified versions.
157 @top Using @value{AS}
159 This file is a user guide to the @sc{gnu} assembler @code{@value{AS}}.
161 This version of the file describes @code{@value{AS}} configured to generate
162 code for @value{TARGET} architectures.
165 * Overview:: Overview
166 * Invoking:: Command-Line Options
168 * Sections:: Sections and Relocation
170 * Expressions:: Expressions
171 * Pseudo Ops:: Assembler Directives
172 * Machine Dependencies:: Machine Dependent Features
173 * Acknowledgements:: Who Did What
181 This manual is a user guide to the @sc{gnu} assembler @code{@value{AS}}.
183 This version of the manual describes @code{@value{AS}} configured to generate
184 code for @value{TARGET} architectures.
188 @cindex invocation summary
189 @cindex option summary
190 @cindex summary of options
191 Here is a brief summary of how to invoke @code{@value{AS}}. For details,
192 @pxref{Invoking,,Comand-Line Options}.
194 @c We don't use deffn and friends for the following because they seem
195 @c to be limited to one line for the header.
197 @value{AS} [ -a[dhlns] ] [ -D ] [ -f ] [ -I @var{path} ]
198 [ -K ] [ -L ] [ -o @var{objfile} ] [ -R ]
199 [ --statistics] [ -v ] [ -W ] [ -Z ]
201 @c am29k has no machine-dependent assembler options
204 @c Hitachi family chips have no machine-dependent assembler options
207 @c HPPA has no machine-dependent assembler options (yet).
210 [ -Av6 | -Av7 | -Av8 | -Asparclite | -bump ]
213 @c Z8000 has no machine-dependent assembler options
216 @c see md_parse_option in tc-i960.c
217 [ -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC ]
221 [ -l ] [ -m68000 | -m68010 | -m68020 | ... ]
224 [ -nocpp ] [ -EL ] [ -EB ] [ -G @var{num} ]
225 [ -mips1 ] [ -mips2 ] [ -mips3 ]
226 [ --trap ] [ --break ]
228 [ -- | @var{files} @dots{} ]
233 Turn on listings, in any of a variety of ways:
237 omit debugging directives from listing
240 include high-level source
252 You may combine these options; for example, use @samp{-aln} for assembly
253 listing without forms processing. By itself, @samp{-a} defaults to
254 @samp{-ahls}---that is, all listings turned on.
257 This option is accepted only for script compatibility with calls to
258 other assemblers; it has no effect on @code{@value{AS}}.
261 ``fast''---skip whitespace and comment preprocessing (assume source is
265 Add @var{path} to the search list for @code{.include} directives
268 @ifclear DIFF-TBL-KLUGE
269 This option is accepted but has no effect on the @value{TARGET} family.
271 @ifset DIFF-TBL-KLUGE
272 Issue warnings when difference tables altered for long displacements.
276 Keep (in symbol table) local symbols, starting with @samp{L}
278 @item -o @var{objfile}
279 Name the object-file output from @code{@value{AS}}
282 Fold data section into text section
285 Display maximum space (in bytes), and total time (in seconds), taken by
289 Announce @code{as} version
292 Suppress warning messages
295 Generate object file even after errors
297 @item -- | @var{files} @dots{}
298 Standard input, or source files to assemble.
303 The following options are available when @value{AS} is configured for the
304 Intel 80960 processor.
307 @item -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC
308 Specify which variant of the 960 architecture is the target.
311 Add code to collect statistics about branches taken.
314 Do not alter compare-and-branch instructions for long displacements;
321 The following options are available when @value{AS} is configured for the
322 Motorola 68000 series.
327 Shorten references to undefined symbols, to one word instead of two.
329 @item -m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040
330 @itemx | -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -mcpu32
331 Specify what processor in the 68000 family is the target. The default
332 is normally the 68020, but this can be changed at configuration time.
334 @item -m68881 | -m68882 | -mno-68881 | -mno-68882
335 The target machine does (or does not) have a floating-point coprocessor.
336 The default is to assume a coprocessor for 68020, 68030, and cpu32. Although
337 the basic 68000 is not compatible with the 68881, a combination of the
338 two can be specified, since it's possible to do emulation of the
339 coprocessor instructions with the main processor.
341 @item -m68851 | -mno-68851
342 The target machine does (or does not) have a memory-management
343 unit coprocessor. The default is to assume an MMU for 68020 and up.
349 The following options are available when @code{@value{AS}} is configured
350 for the SPARC architecture:
353 @item -Av6 | -Av7 | -Av8 | -Asparclite
354 Explicitly select a variant of the SPARC architecture.
357 Warn when the assembler switches to another architecture.
362 The following options are available when @value{AS} is configured for
367 This option sets the largest size of an object that can be referenced
368 implicitly with the @code{gp} register. It is only accepted for targets that
369 use ECOFF format, such as a DECstation running Ultrix. The default value is 8.
371 @cindex MIPS endianness
372 @cindex endianness, MIPS
373 @cindex big endian output, MIPS
375 Generate ``big endian'' format output.
377 @cindex little endian output, MIPS
379 Generate ``little endian'' format output.
385 Generate code for a particular MIPS Instruction Set Architecture level.
386 @samp{-mips1} corresponds to the @sc{r2000} and @sc{r3000} processors,
387 @samp{-mips2} to the @sc{r6000} processor, and @samp{-mips3} to the @sc{r4000}
391 @code{@value{AS}} ignores this option. It is accepted for compatibility with
398 Control how to deal with multiplication overflow and division by zero.
399 @samp{--trap} or @samp{--no-break} (which are synonyms) take a trap exception
400 (and only work for Instruction Set Architecture level 2 and higher);
401 @samp{--break} or @samp{--no-trap} (also synonyms, and the default) take a
407 * Manual:: Structure of this Manual
408 * GNU Assembler:: @value{AS}, the GNU Assembler
409 * Object Formats:: Object File Formats
410 * Command Line:: Command Line
411 * Input Files:: Input Files
412 * Object:: Output (Object) File
413 * Errors:: Error and Warning Messages
417 @section Structure of this Manual
419 @cindex manual, structure and purpose
420 This manual is intended to describe what you need to know to use
421 @sc{gnu} @code{@value{AS}}. We cover the syntax expected in source files, including
422 notation for symbols, constants, and expressions; the directives that
423 @code{@value{AS}} understands; and of course how to invoke @code{@value{AS}}.
426 We also cover special features in the @value{TARGET}
427 configuration of @code{@value{AS}}, including assembler directives.
430 This manual also describes some of the machine-dependent features of
431 various flavors of the assembler.
434 @cindex machine instructions (not covered)
435 On the other hand, this manual is @emph{not} intended as an introduction
436 to programming in assembly language---let alone programming in general!
437 In a similar vein, we make no attempt to introduce the machine
438 architecture; we do @emph{not} describe the instruction set, standard
439 mnemonics, registers or addressing modes that are standard to a
440 particular architecture.
442 You may want to consult the manufacturer's
443 machine architecture manual for this information.
447 For information on the H8/300 machine instruction set, see @cite{H8/300
448 Series Programming Manual} (Hitachi ADE--602--025). For the H8/300H,
449 see @cite{H8/300H Series Programming Manual} (Hitachi).
452 For information on the H8/500 machine instruction set, see @cite{H8/500
453 Series Programming Manual} (Hitachi M21T001).
456 For information on the Hitachi SH machine instruction set, see
457 @cite{SH-Microcomputer User's Manual} (Hitachi Micro Systems, Inc.).
460 For information on the Z8000 machine instruction set, see @cite{Z8000 CPU Technical Manual}
464 @c I think this is premature---pesch@cygnus.com, 17jan1991
466 Throughout this manual, we assume that you are running @dfn{GNU},
467 the portable operating system from the @dfn{Free Software
468 Foundation, Inc.}. This restricts our attention to certain kinds of
469 computer (in particular, the kinds of computers that @sc{gnu} can run on);
470 once this assumption is granted examples and definitions need less
473 @code{@value{AS}} is part of a team of programs that turn a high-level
474 human-readable series of instructions into a low-level
475 computer-readable series of instructions. Different versions of
476 @code{@value{AS}} are used for different kinds of computer.
479 @c There used to be a section "Terminology" here, which defined
480 @c "contents", "byte", "word", and "long". Defining "word" to any
481 @c particular size is confusing when the .word directive may generate 16
482 @c bits on one machine and 32 bits on another; in general, for the user
483 @c version of this manual, none of these terms seem essential to define.
484 @c They were used very little even in the former draft of the manual;
485 @c this draft makes an effort to avoid them (except in names of
489 @section @value{AS}, the GNU Assembler
491 @sc{gnu} @code{as} is really a family of assemblers.
493 This manual describes @code{@value{AS}}, a member of that family which is
494 configured for the @value{TARGET} architectures.
496 If you use (or have used) the @sc{gnu} assembler on one architecture, you
497 should find a fairly similar environment when you use it on another
498 architecture. Each version has much in common with the others,
499 including object file formats, most assembler directives (often called
500 @dfn{pseudo-ops}) and assembler syntax.@refill
502 @cindex purpose of @sc{gnu} @code{@value{AS}}
503 @code{@value{AS}} is primarily intended to assemble the output of the
504 @sc{gnu} C compiler @code{@value{GCC}} for use by the linker
505 @code{@value{LD}}. Nevertheless, we've tried to make @code{@value{AS}}
506 assemble correctly everything that other assemblers for the same
507 machine would assemble.
509 Any exceptions are documented explicitly (@pxref{Machine Dependencies}).
512 @c This remark should appear in generic version of manual; assumption
513 @c here is that generic version sets M680x0.
514 This doesn't mean @code{@value{AS}} always uses the same syntax as another
515 assembler for the same architecture; for example, we know of several
516 incompatible versions of 680x0 assembly language syntax.
519 Unlike older assemblers, @code{@value{AS}} is designed to assemble a source
520 program in one pass of the source file. This has a subtle impact on the
521 @kbd{.org} directive (@pxref{Org,,@code{.org}}).
524 @section Object File Formats
526 @cindex object file format
527 The @sc{gnu} assembler can be configured to produce several alternative
528 object file formats. For the most part, this does not affect how you
529 write assembly language programs; but directives for debugging symbols
530 are typically different in different file formats. @xref{Symbol
531 Attributes,,Symbol Attributes}.
534 On the @value{TARGET}, @code{@value{AS}} is configured to produce
535 @value{OBJ-NAME} format object files.
537 @c The following should exhaust all configs that set MULTI-OBJ, ideally
539 On the @value{TARGET}, @code{@value{AS}} can be configured to produce either
540 @code{a.out} or COFF format object files.
543 On the @value{TARGET}, @code{@value{AS}} can be configured to produce either
544 @code{b.out} or COFF format object files.
547 On the @value{TARGET}, @code{@value{AS}} can be configured to produce either
548 SOM or ELF format object files.
553 @section Command Line
555 @cindex command line conventions
556 After the program name @code{@value{AS}}, the command line may contain
557 options and file names. Options may appear in any order, and may be
558 before, after, or between file names. The order of file names is
561 @cindex standard input, as input file
563 @file{--} (two hyphens) by itself names the standard input file
564 explicitly, as one of the files for @code{@value{AS}} to assemble.
566 @cindex options, command line
567 Except for @samp{--} any command line argument that begins with a
568 hyphen (@samp{-}) is an option. Each option changes the behavior of
569 @code{@value{AS}}. No option changes the way another option works. An
570 option is a @samp{-} followed by one or more letters; the case of
571 the letter is important. All options are optional.
573 Some options expect exactly one file name to follow them. The file
574 name may either immediately follow the option's letter (compatible
575 with older assemblers) or it may be the next command argument (@sc{gnu}
576 standard). These two command lines are equivalent:
579 @value{AS} -o my-object-file.o mumble.s
580 @value{AS} -omy-object-file.o mumble.s
587 @cindex source program
589 We use the phrase @dfn{source program}, abbreviated @dfn{source}, to
590 describe the program input to one run of @code{@value{AS}}. The program may
591 be in one or more files; how the source is partitioned into files
592 doesn't change the meaning of the source.
594 @c I added "con" prefix to "catenation" just to prove I can overcome my
595 @c APL training... pesch@cygnus.com
596 The source program is a concatenation of the text in all the files, in the
599 Each time you run @code{@value{AS}} it assembles exactly one source
600 program. The source program is made up of one or more files.
601 (The standard input is also a file.)
603 You give @code{@value{AS}} a command line that has zero or more input file
604 names. The input files are read (from left file name to right). A
605 command line argument (in any position) that has no special meaning
606 is taken to be an input file name.
608 If you give @code{@value{AS}} no file names it attempts to read one input file
609 from the @code{@value{AS}} standard input, which is normally your terminal. You
610 may have to type @key{ctl-D} to tell @code{@value{AS}} there is no more program
613 Use @samp{--} if you need to explicitly name the standard input file
614 in your command line.
616 If the source is empty, @code{@value{AS}} produces a small, empty object
619 @subheading Filenames and Line-numbers
621 @cindex input file linenumbers
622 @cindex line numbers, in input files
623 There are two ways of locating a line in the input file (or files) and
624 either may be used in reporting error messages. One way refers to a line
625 number in a physical file; the other refers to a line number in a
626 ``logical'' file. @xref{Errors, ,Error and Warning Messages}.
628 @dfn{Physical files} are those files named in the command line given
629 to @code{@value{AS}}.
631 @dfn{Logical files} are simply names declared explicitly by assembler
632 directives; they bear no relation to physical files. Logical file names
633 help error messages reflect the original source file, when @code{@value{AS}}
634 source is itself synthesized from other files.
635 @xref{App-File,,@code{.app-file}}.
638 @section Output (Object) File
644 Every time you run @code{@value{AS}} it produces an output file, which is
645 your assembly language program translated into numbers. This file
646 is the object file. Its default name is
654 @code{b.out} when @code{@value{AS}} is configured for the Intel 80960.
656 You can give it another name by using the @code{-o} option. Conventionally,
657 object file names end with @file{.o}. The default name is used for historical
658 reasons: older assemblers were capable of assembling self-contained programs
659 directly into a runnable program. (For some formats, this isn't currently
660 possible, but it can be done for the @code{a.out} format.)
664 The object file is meant for input to the linker @code{@value{LD}}. It contains
665 assembled program code, information to help @code{@value{LD}} integrate
666 the assembled program into a runnable file, and (optionally) symbolic
667 information for the debugger.
669 @c link above to some info file(s) like the description of a.out.
670 @c don't forget to describe GNU info as well as Unix lossage.
673 @section Error and Warning Messages
675 @cindex error messsages
676 @cindex warning messages
677 @cindex messages from @code{@value{AS}}
678 @code{@value{AS}} may write warnings and error messages to the standard error
679 file (usually your terminal). This should not happen when a compiler
680 runs @code{@value{AS}} automatically. Warnings report an assumption made so
681 that @code{@value{AS}} could keep assembling a flawed program; errors report a
682 grave problem that stops the assembly.
684 @cindex format of warning messages
685 Warning messages have the format
688 file_name:@b{NNN}:Warning Message Text
692 @cindex line numbers, in warnings/errors
693 (where @b{NNN} is a line number). If a logical file name has been given
694 (@pxref{App-File,,@code{.app-file}}) it is used for the filename,
695 otherwise the name of the current input file is used. If a logical line
698 (@pxref{Line,,@code{.line}})
702 (@pxref{Line,,@code{.line}})
705 (@pxref{Ln,,@code{.ln}})
708 then it is used to calculate the number printed,
709 otherwise the actual line in the current source file is printed. The
710 message text is intended to be self explanatory (in the grand Unix
713 @cindex format of error messages
714 Error messages have the format
716 file_name:@b{NNN}:FATAL:Error Message Text
718 The file name and line number are derived as for warning
719 messages. The actual message text may be rather less explanatory
720 because many of them aren't supposed to happen.
723 @chapter Command-Line Options
725 @cindex options, all versions of @code{@value{AS}}
726 This chapter describes command-line options available in @emph{all}
727 versions of the @sc{gnu} assembler; @pxref{Machine Dependencies}, for options specific
729 to the @value{TARGET}.
732 to particular machine architectures.
735 If you are invoking @code{@value{AS}} via the @sc{gnu} C compiler (version 2), you
736 can use the @samp{-Wa} option to pass arguments through to the
737 assembler. The assembler arguments must be separated from each other
738 (and the @samp{-Wa}) by commas. For example:
741 gcc -c -g -O -Wa,-alh,-L file.c
745 emits a listing to standard output with high-level
748 Usually you do not need to use this @samp{-Wa} mechanism, since many compiler
749 command-line options are automatically passed to the assembler by the compiler.
750 (You can call the @sc{gnu} compiler driver with the @samp{-v} option to see
751 precisely what options it passes to each compilation pass, including the
755 * a:: -a[dhlns] enable listings
756 * D:: -D for compatibility
757 * f:: -f to work faster
758 * I:: -I for .include search path
759 @ifclear DIFF-TBL-KLUGE
760 * K:: -K for compatibility
762 @ifset DIFF-TBL-KLUGE
763 * K:: -K for difference tables
766 * L:: -L to retain local labels
767 * o:: -o to name the object file
768 * R:: -R to join data and text sections
769 * statistics:: --statistics to see statistics about assembly
770 * v:: -v to announce version
771 * W:: -W to suppress warnings
772 * Z:: -Z to make object file even after errors
776 @section Enable Listings: @code{-a[dhlns]}
784 @cindex listings, enabling
785 @cindex assembly listings, enabling
787 These options enable listing output from the assembler. By itself,
788 @samp{-a} requests high-level, assembly, and symbols listing.
789 You can use other letters to select specific options for the list:
790 @samp{-ah} requests a high-level language listing,
791 @samp{-al} requests an output-program assembly listing, and
792 @samp{-as} requests a symbol table listing.
793 High-level listings require that a compiler debugging option like
794 @samp{-g} be used, and that assembly listings (@samp{-al}) be requested
797 Use the @samp{-ad} option to omit debugging directives from the
800 Once you have specified one of these options, you can further control
801 listing output and its appearance using the directives @code{.list},
802 @code{.nolist}, @code{.psize}, @code{.eject}, @code{.title}, and
804 The @samp{-an} option turns off all forms processing.
805 If you do not request listing output with one of the @samp{-a} options, the
806 listing-control directives have no effect.
808 The letters after @samp{-a} may be combined into one option,
809 @emph{e.g.}, @samp{-aln}.
815 This option has no effect whatsoever, but it is accepted to make it more
816 likely that scripts written for other assemblers also work with
820 @section Work Faster: @code{-f}
823 @cindex trusted compiler
824 @cindex faster processing (@code{-f})
825 @samp{-f} should only be used when assembling programs written by a
826 (trusted) compiler. @samp{-f} stops the assembler from doing whitespace
827 and comment preprocessing on
828 the input file(s) before assembling them. @xref{Preprocessing,
832 @emph{Warning:} if you use @samp{-f} when the files actually need to be
833 preprocessed (if they contain comments, for example), @code{@value{AS}} does
838 @section @code{.include} search path: @code{-I} @var{path}
840 @kindex -I @var{path}
841 @cindex paths for @code{.include}
842 @cindex search path for @code{.include}
843 @cindex @code{include} directive search path
844 Use this option to add a @var{path} to the list of directories
845 @code{@value{AS}} searches for files specified in @code{.include}
846 directives (@pxref{Include,,@code{.include}}). You may use @code{-I} as
847 many times as necessary to include a variety of paths. The current
848 working directory is always searched first; after that, @code{@value{AS}}
849 searches any @samp{-I} directories in the same order as they were
850 specified (left to right) on the command line.
853 @section Difference Tables: @code{-K}
856 @ifclear DIFF-TBL-KLUGE
857 On the @value{TARGET} family, this option is allowed, but has no effect. It is
858 permitted for compatibility with the @sc{gnu} assembler on other platforms,
859 where it can be used to warn when the assembler alters the machine code
860 generated for @samp{.word} directives in difference tables. The @value{TARGET}
861 family does not have the addressing limitations that sometimes lead to this
862 alteration on other platforms.
865 @ifset DIFF-TBL-KLUGE
866 @cindex difference tables, warning
867 @cindex warning for altered difference tables
868 @code{@value{AS}} sometimes alters the code emitted for directives of the form
869 @samp{.word @var{sym1}-@var{sym2}}; @pxref{Word,,@code{.word}}.
870 You can use the @samp{-K} option if you want a warning issued when this
875 @section Include Local Labels: @code{-L}
878 @cindex local labels, retaining in output
879 Labels beginning with @samp{L} (upper case only) are called @dfn{local
880 labels}. @xref{Symbol Names}. Normally you do not see such labels when
881 debugging, because they are intended for the use of programs (like
882 compilers) that compose assembler programs, not for your notice.
883 Normally both @code{@value{AS}} and @code{@value{LD}} discard such labels, so you do not
884 normally debug with them.
886 This option tells @code{@value{AS}} to retain those @samp{L@dots{}} symbols
887 in the object file. Usually if you do this you also tell the linker
888 @code{@value{LD}} to preserve symbols whose names begin with @samp{L}.
890 By default, a local label is any label beginning with @samp{L}, but each
891 target is allowed to redefine the local label prefix.
893 On the HPPA local labels begin with @samp{L$}.
897 @section Name the Object File: @code{-o}
900 @cindex naming object file
901 @cindex object file name
902 There is always one object file output when you run @code{@value{AS}}. By
903 default it has the name
906 @file{a.out} (or @file{b.out}, for Intel 960 targets only).
920 You use this option (which takes exactly one filename) to give the
921 object file a different name.
923 Whatever the object file is called, @code{@value{AS}} overwrites any
924 existing file of the same name.
927 @section Join Data and Text Sections: @code{-R}
930 @cindex data and text sections, joining
931 @cindex text and data sections, joining
932 @cindex joining text and data sections
933 @cindex merging text and data sections
934 @code{-R} tells @code{@value{AS}} to write the object file as if all
935 data-section data lives in the text section. This is only done at
936 the very last moment: your binary data are the same, but data
937 section parts are relocated differently. The data section part of
938 your object file is zero bytes long because all its bytes are
939 appended to the text section. (@xref{Sections,,Sections and Relocation}.)
941 When you specify @code{-R} it would be possible to generate shorter
942 address displacements (because we do not have to cross between text and
943 data section). We refrain from doing this simply for compatibility with
944 older versions of @code{@value{AS}}. In future, @code{-R} may work this way.
947 When @code{@value{AS}} is configured for COFF output,
948 this option is only useful if you use sections named @samp{.text} and
953 @code{-R} is not supported for any of the HPPA targets. Using
954 @code{-R} generates a warning from @code{@value{AS}}.
958 @section Display Assembly Statistics: @code{--statistics}
961 @cindex statistics, about assembly
962 @cindex time, total for assembly
963 @cindex space used, maximum for assembly
964 Use @samp{--statistics} to display two statistics about the resources used by
965 @code{@value{AS}}: the maximum amount of space allocated during the assembly
966 (in bytes), and the total execution time taken for the assembly (in @sc{cpu}
970 @section Announce Version: @code{-v}
974 @cindex @code{@value{AS}} version
975 @cindex version of @code{@value{AS}}
976 You can find out what version of as is running by including the
977 option @samp{-v} (which you can also spell as @samp{-version}) on the
981 @section Suppress Warnings: @code{-W}
984 @cindex suppressing warnings
985 @cindex warnings, suppressing
986 @code{@value{AS}} should never give a warning or error message when
987 assembling compiler output. But programs written by people often
988 cause @code{@value{AS}} to give a warning that a particular assumption was
989 made. All such warnings are directed to the standard error file.
990 If you use this option, no warnings are issued. This option only
991 affects the warning messages: it does not change any particular of how
992 @code{@value{AS}} assembles your file. Errors, which stop the assembly, are
996 @section Generate Object File in Spite of Errors: @code{-Z}
997 @cindex object file, after errors
998 @cindex errors, continuing after
999 After an error message, @code{@value{AS}} normally produces no output. If for
1000 some reason you are interested in object file output even after
1001 @code{@value{AS}} gives an error message on your program, use the @samp{-Z}
1002 option. If there are any errors, @code{@value{AS}} continues anyways, and
1003 writes an object file after a final warning message of the form @samp{@var{n}
1004 errors, @var{m} warnings, generating bad object file.}
1009 @cindex machine-independent syntax
1010 @cindex syntax, machine-independent
1011 This chapter describes the machine-independent syntax allowed in a
1012 source file. @code{@value{AS}} syntax is similar to what many other
1013 assemblers use; it is inspired by the BSD 4.2
1018 assembler, except that @code{@value{AS}} does not assemble Vax bit-fields.
1022 * Preprocessing:: Preprocessing
1023 * Whitespace:: Whitespace
1024 * Comments:: Comments
1025 * Symbol Intro:: Symbols
1026 * Statements:: Statements
1027 * Constants:: Constants
1031 @section Preprocessing
1033 @cindex preprocessing
1034 The @code{@value{AS}} internal preprocessor:
1036 @cindex whitespace, removed by preprocessor
1038 adjusts and removes extra whitespace. It leaves one space or tab before
1039 the keywords on a line, and turns any other whitespace on the line into
1042 @cindex comments, removed by preprocessor
1044 removes all comments, replacing them with a single space, or an
1045 appropriate number of newlines.
1047 @cindex constants, converted by preprocessor
1049 converts character constants into the appropriate numeric values.
1052 It does not do macro processing, include file handling, or
1053 anything else you may get from your C compiler's preprocessor. You can
1054 do include file processing with the @code{.include} directive
1055 (@pxref{Include,,@code{.include}}). You can use the @sc{gnu} C compiler driver
1056 to get other ``CPP'' style preprocessing, by giving the input file a
1057 @samp{.S} suffix. @xref{Overall Options,, Options Controlling the Kind of
1058 Output, gcc.info, Using GNU CC}.
1060 Excess whitespace, comments, and character constants
1061 cannot be used in the portions of the input text that are not
1064 @cindex turning preprocessing on and off
1065 @cindex preprocessing, turning on and off
1068 If the first line of an input file is @code{#NO_APP} or if you use the
1069 @samp{-f} option, whitespace and comments are not removed from the input file.
1070 Within an input file, you can ask for whitespace and comment removal in
1071 specific portions of the by putting a line that says @code{#APP} before the
1072 text that may contain whitespace or comments, and putting a line that says
1073 @code{#NO_APP} after this text. This feature is mainly intend to support
1074 @code{asm} statements in compilers whose output is otherwise free of comments
1081 @dfn{Whitespace} is one or more blanks or tabs, in any order.
1082 Whitespace is used to separate symbols, and to make programs neater for
1083 people to read. Unless within character constants
1084 (@pxref{Characters,,Character Constants}), any whitespace means the same
1085 as exactly one space.
1091 There are two ways of rendering comments to @code{@value{AS}}. In both
1092 cases the comment is equivalent to one space.
1094 Anything from @samp{/*} through the next @samp{*/} is a comment.
1095 This means you may not nest these comments.
1099 The only way to include a newline ('\n') in a comment
1100 is to use this sort of comment.
1103 /* This sort of comment does not nest. */
1106 @cindex line comment character
1107 Anything from the @dfn{line comment} character to the next newline
1108 is considered a comment and is ignored. The line comment character is
1110 @samp{#} on the Vax;
1113 @samp{#} on the i960;
1116 @samp{!} on the SPARC;
1119 @samp{|} on the 680x0;
1122 @samp{;} for the AMD 29K family;
1125 @samp{;} for the H8/300 family;
1128 @samp{!} for the H8/500 family;
1131 @samp{;} for the HPPA;
1134 @samp{!} for the Hitachi SH;
1137 @samp{!} for the Z8000;
1139 see @ref{Machine Dependencies}. @refill
1140 @c FIXME What about i386, m88k, i860?
1143 On some machines there are two different line comment characters. One
1144 character only begins a comment if it is the first non-whitespace character on
1145 a line, while the other always begins a comment.
1149 @cindex lines starting with @code{#}
1150 @cindex logical line numbers
1151 To be compatible with past assemblers, lines that begin with @samp{#} have a
1152 special interpretation. Following the @samp{#} should be an absolute
1153 expression (@pxref{Expressions}): the logical line number of the @emph{next}
1154 line. Then a string (@pxref{Strings,, Strings}) is allowed: if present it is a
1155 new logical file name. The rest of the line, if any, should be whitespace.
1157 If the first non-whitespace characters on the line are not numeric,
1158 the line is ignored. (Just like a comment.)
1161 # This is an ordinary comment.
1162 # 42-6 "new_file_name" # New logical file name
1163 # This is logical line # 36.
1165 This feature is deprecated, and may disappear from future versions
1166 of @code{@value{AS}}.
1171 @cindex characters used in symbols
1172 @ifclear SPECIAL-SYMS
1173 A @dfn{symbol} is one or more characters chosen from the set of all
1174 letters (both upper and lower case), digits and the three characters
1180 A @dfn{symbol} is one or more characters chosen from the set of all
1181 letters (both upper and lower case), digits and the three characters
1182 @samp{._$}. (Save that, on the H8/300 only, you may not use @samp{$} in
1188 On most machines, you can also use @code{$} in symbol names; exceptions
1189 are noted in @ref{Machine Dependencies}.
1191 No symbol may begin with a digit. Case is significant.
1192 There is no length limit: all characters are significant. Symbols are
1193 delimited by characters not in that set, or by the beginning of a file
1194 (since the source program must end with a newline, the end of a file is
1195 not a possible symbol delimiter). @xref{Symbols}.
1196 @cindex length of symbols
1201 @cindex statements, structure of
1202 @cindex line separator character
1203 @cindex statement separator character
1205 @ifclear abnormal-separator
1206 A @dfn{statement} ends at a newline character (@samp{\n}) or at a
1207 semicolon (@samp{;}). The newline or semicolon is considered part of
1208 the preceding statement. Newlines and semicolons within character
1209 constants are an exception: they do not end statements.
1211 @ifset abnormal-separator
1213 A @dfn{statement} ends at a newline character (@samp{\n}) or an ``at''
1214 sign (@samp{@@}). The newline or at sign is considered part of the
1215 preceding statement. Newlines and at signs within character constants
1216 are an exception: they do not end statements.
1219 A @dfn{statement} ends at a newline character (@samp{\n}) or an exclamation
1220 point (@samp{!}). The newline or exclamation point is considered part of the
1221 preceding statement. Newlines and exclamation points within character
1222 constants are an exception: they do not end statements.
1225 A @dfn{statement} ends at a newline character (@samp{\n}); or (for the
1226 H8/300) a dollar sign (@samp{$}); or (for the
1229 (@samp{;}). The newline or separator character is considered part of
1230 the preceding statement. Newlines and separators within character
1231 constants are an exception: they do not end statements.
1236 A @dfn{statement} ends at a newline character (@samp{\n}) or line
1237 separator character. (The line separator is usually @samp{;}, unless
1238 this conflicts with the comment character; @pxref{Machine Dependencies}.) The
1239 newline or separator character is considered part of the preceding
1240 statement. Newlines and separators within character constants are an
1241 exception: they do not end statements.
1244 @cindex newline, required at file end
1245 @cindex EOF, newline must precede
1246 It is an error to end any statement with end-of-file: the last
1247 character of any input file should be a newline.@refill
1249 @cindex continuing statements
1250 @cindex multi-line statements
1251 @cindex statement on multiple lines
1252 You may write a statement on more than one line if you put a
1253 backslash (@kbd{\}) immediately in front of any newlines within the
1254 statement. When @code{@value{AS}} reads a backslashed newline both
1255 characters are ignored. You can even put backslashed newlines in
1256 the middle of symbol names without changing the meaning of your
1259 An empty statement is allowed, and may include whitespace. It is ignored.
1261 @cindex instructions and directives
1262 @cindex directives and instructions
1263 @c "key symbol" is not used elsewhere in the document; seems pedantic to
1264 @c @defn{} it in that case, as was done previously... pesch@cygnus.com,
1266 A statement begins with zero or more labels, optionally followed by a
1267 key symbol which determines what kind of statement it is. The key
1268 symbol determines the syntax of the rest of the statement. If the
1269 symbol begins with a dot @samp{.} then the statement is an assembler
1270 directive: typically valid for any computer. If the symbol begins with
1271 a letter the statement is an assembly language @dfn{instruction}: it
1272 assembles into a machine language instruction.
1274 Different versions of @code{@value{AS}} for different computers
1275 recognize different instructions. In fact, the same symbol may
1276 represent a different instruction in a different computer's assembly
1280 @cindex @code{:} (label)
1281 @cindex label (@code{:})
1282 A label is a symbol immediately followed by a colon (@code{:}).
1283 Whitespace before a label or after a colon is permitted, but you may not
1284 have whitespace between a label's symbol and its colon. @xref{Labels}.
1287 For HPPA targets, labels need not be immediately followed by a colon, but
1288 the definition of a label must begin in column zero. This also implies that
1289 only one label may be defined on each line.
1293 label: .directive followed by something
1294 another_label: # This is an empty statement.
1295 instruction operand_1, operand_2, @dots{}
1302 A constant is a number, written so that its value is known by
1303 inspection, without knowing any context. Like this:
1306 .byte 74, 0112, 092, 0x4A, 0X4a, 'J, '\J # All the same value.
1307 .ascii "Ring the bell\7" # A string constant.
1308 .octa 0x123456789abcdef0123456789ABCDEF0 # A bignum.
1309 .float 0f-314159265358979323846264338327\
1310 95028841971.693993751E-40 # - pi, a flonum.
1315 * Characters:: Character Constants
1316 * Numbers:: Number Constants
1320 @subsection Character Constants
1322 @cindex character constants
1323 @cindex constants, character
1324 There are two kinds of character constants. A @dfn{character} stands
1325 for one character in one byte and its value may be used in
1326 numeric expressions. String constants (properly called string
1327 @emph{literals}) are potentially many bytes and their values may not be
1328 used in arithmetic expressions.
1332 * Chars:: Characters
1336 @subsubsection Strings
1338 @cindex string constants
1339 @cindex constants, string
1340 A @dfn{string} is written between double-quotes. It may contain
1341 double-quotes or null characters. The way to get special characters
1342 into a string is to @dfn{escape} these characters: precede them with
1343 a backslash @samp{\} character. For example @samp{\\} represents
1344 one backslash: the first @code{\} is an escape which tells
1345 @code{@value{AS}} to interpret the second character literally as a backslash
1346 (which prevents @code{@value{AS}} from recognizing the second @code{\} as an
1347 escape character). The complete list of escapes follows.
1349 @cindex escape codes, character
1350 @cindex character escape codes
1353 @c Mnemonic for ACKnowledge; for ASCII this is octal code 007.
1356 @cindex @code{\b} (backspace character)
1357 @cindex backspace (@code{\b})
1358 Mnemonic for backspace; for ASCII this is octal code 010.
1361 @c Mnemonic for EOText; for ASCII this is octal code 004.
1364 @cindex @code{\f} (formfeed character)
1365 @cindex formfeed (@code{\f})
1366 Mnemonic for FormFeed; for ASCII this is octal code 014.
1369 @cindex @code{\n} (newline character)
1370 @cindex newline (@code{\n})
1371 Mnemonic for newline; for ASCII this is octal code 012.
1374 @c Mnemonic for prefix; for ASCII this is octal code 033, usually known as @code{escape}.
1377 @cindex @code{\r} (carriage return character)
1378 @cindex carriage return (@code{\r})
1379 Mnemonic for carriage-Return; for ASCII this is octal code 015.
1382 @c Mnemonic for space; for ASCII this is octal code 040. Included for compliance with
1383 @c other assemblers.
1386 @cindex @code{\t} (tab)
1387 @cindex tab (@code{\t})
1388 Mnemonic for horizontal Tab; for ASCII this is octal code 011.
1391 @c Mnemonic for Vertical tab; for ASCII this is octal code 013.
1392 @c @item \x @var{digit} @var{digit} @var{digit}
1393 @c A hexadecimal character code. The numeric code is 3 hexadecimal digits.
1395 @item \ @var{digit} @var{digit} @var{digit}
1396 @cindex @code{\@var{ddd}} (octal character code)
1397 @cindex octal character code (@code{\@var{ddd}})
1398 An octal character code. The numeric code is 3 octal digits.
1399 For compatibility with other Unix systems, 8 and 9 are accepted as digits:
1400 for example, @code{\008} has the value 010, and @code{\009} the value 011.
1403 @item \@code{x} @var{hex-digit} @var{hex-digit}
1404 @cindex @code{\@var{xdd}} (hex character code)
1405 @cindex hex character code (@code{\@var{xdd}})
1406 A hex character code. The numeric code is 2 hexadecimal digits. Either
1407 upper or lower case @code{x} works.
1411 @cindex @code{\\} (@samp{\} character)
1412 @cindex backslash (@code{\\})
1413 Represents one @samp{\} character.
1416 @c Represents one @samp{'} (accent acute) character.
1417 @c This is needed in single character literals
1418 @c (@xref{Characters,,Character Constants}.) to represent
1422 @cindex @code{\"} (doublequote character)
1423 @cindex doublequote (@code{\"})
1424 Represents one @samp{"} character. Needed in strings to represent
1425 this character, because an unescaped @samp{"} would end the string.
1427 @item \ @var{anything-else}
1428 Any other character when escaped by @kbd{\} gives a warning, but
1429 assembles as if the @samp{\} was not present. The idea is that if
1430 you used an escape sequence you clearly didn't want the literal
1431 interpretation of the following character. However @code{@value{AS}} has no
1432 other interpretation, so @code{@value{AS}} knows it is giving you the wrong
1433 code and warns you of the fact.
1436 Which characters are escapable, and what those escapes represent,
1437 varies widely among assemblers. The current set is what we think
1438 the BSD 4.2 assembler recognizes, and is a subset of what most C
1439 compilers recognize. If you are in doubt, do not use an escape
1443 @subsubsection Characters
1445 @cindex single character constant
1446 @cindex character, single
1447 @cindex constant, single character
1448 A single character may be written as a single quote immediately
1449 followed by that character. The same escapes apply to characters as
1450 to strings. So if you want to write the character backslash, you
1451 must write @kbd{'\\} where the first @code{\} escapes the second
1452 @code{\}. As you can see, the quote is an acute accent, not a
1453 grave accent. A newline
1455 @ifclear abnormal-separator
1456 (or semicolon @samp{;})
1458 @ifset abnormal-separator
1460 (or at sign @samp{@@})
1463 (or dollar sign @samp{$}, for the H8/300; or semicolon @samp{;} for the
1469 immediately following an acute accent is taken as a literal character
1470 and does not count as the end of a statement. The value of a character
1471 constant in a numeric expression is the machine's byte-wide code for
1472 that character. @code{@value{AS}} assumes your character code is ASCII:
1473 @kbd{'A} means 65, @kbd{'B} means 66, and so on. @refill
1476 @subsection Number Constants
1478 @cindex constants, number
1479 @cindex number constants
1480 @code{@value{AS}} distinguishes three kinds of numbers according to how they
1481 are stored in the target machine. @emph{Integers} are numbers that
1482 would fit into an @code{int} in the C language. @emph{Bignums} are
1483 integers, but they are stored in more than 32 bits. @emph{Flonums}
1484 are floating point numbers, described below.
1487 * Integers:: Integers
1492 * Bit Fields:: Bit Fields
1498 @subsubsection Integers
1500 @cindex constants, integer
1502 @cindex binary integers
1503 @cindex integers, binary
1504 A binary integer is @samp{0b} or @samp{0B} followed by zero or more of
1505 the binary digits @samp{01}.
1507 @cindex octal integers
1508 @cindex integers, octal
1509 An octal integer is @samp{0} followed by zero or more of the octal
1510 digits (@samp{01234567}).
1512 @cindex decimal integers
1513 @cindex integers, decimal
1514 A decimal integer starts with a non-zero digit followed by zero or
1515 more digits (@samp{0123456789}).
1517 @cindex hexadecimal integers
1518 @cindex integers, hexadecimal
1519 A hexadecimal integer is @samp{0x} or @samp{0X} followed by one or
1520 more hexadecimal digits chosen from @samp{0123456789abcdefABCDEF}.
1522 Integers have the usual values. To denote a negative integer, use
1523 the prefix operator @samp{-} discussed under expressions
1524 (@pxref{Prefix Ops,,Prefix Operators}).
1527 @subsubsection Bignums
1530 @cindex constants, bignum
1531 A @dfn{bignum} has the same syntax and semantics as an integer
1532 except that the number (or its negative) takes more than 32 bits to
1533 represent in binary. The distinction is made because in some places
1534 integers are permitted while bignums are not.
1537 @subsubsection Flonums
1539 @cindex floating point numbers
1540 @cindex constants, floating point
1542 @cindex precision, floating point
1543 A @dfn{flonum} represents a floating point number. The translation is
1544 indirect: a decimal floating point number from the text is converted by
1545 @code{@value{AS}} to a generic binary floating point number of more than
1546 sufficient precision. This generic floating point number is converted
1547 to a particular computer's floating point format (or formats) by a
1548 portion of @code{@value{AS}} specialized to that computer.
1550 A flonum is written by writing (in order)
1555 (@samp{0} is optional on the HPPA.)
1559 A letter, to tell @code{@value{AS}} the rest of the number is a flonum.
1561 @kbd{e} is recommended. Case is not important.
1563 @c FIXME: verify if flonum syntax really this vague for most cases
1564 (Any otherwise illegal letter works here, but that might be changed. Vax BSD
1565 4.2 assembler seems to allow any of @samp{defghDEFGH}.)
1568 On the H8/300, H8/500,
1570 and AMD 29K architectures, the letter must be
1571 one of the letters @samp{DFPRSX} (in upper or lower case).
1573 On the Intel 960 architecture, the letter must be
1574 one of the letters @samp{DFT} (in upper or lower case).
1576 On the HPPA architecture, the letter must be @samp{E} (upper case only).
1580 One of the letters @samp{DFPRSX} (in upper or lower case).
1583 One of the letters @samp{DFPRSX} (in upper or lower case).
1586 One of the letters @samp{DFT} (in upper or lower case).
1589 The letter @samp{E} (upper case only).
1594 An optional sign: either @samp{+} or @samp{-}.
1597 An optional @dfn{integer part}: zero or more decimal digits.
1600 An optional @dfn{fractional part}: @samp{.} followed by zero
1601 or more decimal digits.
1604 An optional exponent, consisting of:
1608 An @samp{E} or @samp{e}.
1609 @c I can't find a config where "EXP_CHARS" is other than 'eE', but in
1610 @c principle this can perfectly well be different on different targets.
1612 Optional sign: either @samp{+} or @samp{-}.
1614 One or more decimal digits.
1619 At least one of the integer part or the fractional part must be
1620 present. The floating point number has the usual base-10 value.
1622 @code{@value{AS}} does all processing using integers. Flonums are computed
1623 independently of any floating point hardware in the computer running
1628 @c Bit fields are written as a general facility but are also controlled
1629 @c by a conditional-compilation flag---which is as of now (21mar91)
1630 @c turned on only by the i960 config of GAS.
1632 @subsubsection Bit Fields
1635 @cindex constants, bit field
1636 You can also define numeric constants as @dfn{bit fields}.
1637 specify two numbers separated by a colon---
1639 @var{mask}:@var{value}
1642 @code{@value{AS}} applies a bitwise @sc{and} between @var{mask} and
1645 The resulting number is then packed
1647 @c this conditional paren in case bit fields turned on elsewhere than 960
1648 (in host-dependent byte order)
1650 into a field whose width depends on which assembler directive has the
1651 bit-field as its argument. Overflow (a result from the bitwise and
1652 requiring more binary digits to represent) is not an error; instead,
1653 more constants are generated, of the specified width, beginning with the
1654 least significant digits.@refill
1656 The directives @code{.byte}, @code{.hword}, @code{.int}, @code{.long},
1657 @code{.short}, and @code{.word} accept bit-field arguments.
1662 @chapter Sections and Relocation
1667 * Secs Background:: Background
1668 * Ld Sections:: @value{LD} Sections
1669 * As Sections:: @value{AS} Internal Sections
1670 * Sub-Sections:: Sub-Sections
1674 @node Secs Background
1677 Roughly, a section is a range of addresses, with no gaps; all data
1678 ``in'' those addresses is treated the same for some particular purpose.
1679 For example there may be a ``read only'' section.
1681 @cindex linker, and assembler
1682 @cindex assembler, and linker
1683 The linker @code{@value{LD}} reads many object files (partial programs) and
1684 combines their contents to form a runnable program. When @code{@value{AS}}
1685 emits an object file, the partial program is assumed to start at address 0.
1686 @code{@value{LD}} assigns the final addresses for the partial program, so that
1687 different partial programs do not overlap. This is actually an
1688 oversimplification, but it suffices to explain how @code{@value{AS}} uses
1691 @code{@value{LD}} moves blocks of bytes of your program to their run-time
1692 addresses. These blocks slide to their run-time addresses as rigid
1693 units; their length does not change and neither does the order of bytes
1694 within them. Such a rigid unit is called a @emph{section}. Assigning
1695 run-time addresses to sections is called @dfn{relocation}. It includes
1696 the task of adjusting mentions of object-file addresses so they refer to
1697 the proper run-time addresses.
1699 For the H8/300 and H8/500,
1700 and for the Hitachi SH,
1701 @code{@value{AS}} pads sections if needed to
1702 ensure they end on a word (sixteen bit) boundary.
1705 @cindex standard @code{@value{AS}} sections
1706 An object file written by @code{@value{AS}} has at least three sections, any
1707 of which may be empty. These are named @dfn{text}, @dfn{data} and
1712 When it generates COFF output,
1714 @code{@value{AS}} can also generate whatever other named sections you specify
1715 using the @samp{.section} directive (@pxref{Section,,@code{.section}}).
1716 If you do not use any directives that place output in the @samp{.text}
1717 or @samp{.data} sections, these sections still exist, but are empty.
1722 When @code{@value{AS}} generates SOM or ELF output for the HPPA,
1724 @code{@value{AS}} can also generate whatever other named sections you
1725 specify using the @samp{.space} and @samp{.subspace} directives. See
1726 @cite{HP9000 Series 800 Assembly Language Reference Manual}
1727 (HP 92432-90001) for details on the @samp{.space} and @samp{.subspace}
1728 assembler directives.
1731 Additionally, @code{@value{AS}} uses different names for the standard
1732 text, data, and bss sections when generating SOM output. Program text
1733 is placed into the @samp{$CODE$} section, data into @samp{$DATA$}, and
1734 BSS into @samp{$BSS$}.
1738 Within the object file, the text section starts at address @code{0}, the
1739 data section follows, and the bss section follows the data section.
1742 When generating either SOM or ELF output files on the HPPA, the text
1743 section starts at address @code{0}, the data section at address
1744 @code{0x4000000}, and the bss section follows the data section.
1747 To let @code{@value{LD}} know which data changes when the sections are
1748 relocated, and how to change that data, @code{@value{AS}} also writes to the
1749 object file details of the relocation needed. To perform relocation
1750 @code{@value{LD}} must know, each time an address in the object
1754 Where in the object file is the beginning of this reference to
1757 How long (in bytes) is this reference?
1759 Which section does the address refer to? What is the numeric value of
1761 (@var{address}) @minus{} (@var{start-address of section})?
1764 Is the reference to an address ``Program-Counter relative''?
1767 @cindex addresses, format of
1768 @cindex section-relative addressing
1769 In fact, every address @code{@value{AS}} ever uses is expressed as
1771 (@var{section}) + (@var{offset into section})
1774 Further, most expressions @code{@value{AS}} computes have this section-relative
1777 (For some object formats, such as SOM for the HPPA, some expressions are
1778 symbol-relative instead.)
1781 In this manual we use the notation @{@var{secname} @var{N}@} to mean ``offset
1782 @var{N} into section @var{secname}.''
1784 Apart from text, data and bss sections you need to know about the
1785 @dfn{absolute} section. When @code{@value{LD}} mixes partial programs,
1786 addresses in the absolute section remain unchanged. For example, address
1787 @code{@{absolute 0@}} is ``relocated'' to run-time address 0 by
1788 @code{@value{LD}}. Although the linker never arranges two partial programs'
1789 data sections with overlapping addresses after linking, @emph{by definition}
1790 their absolute sections must overlap. Address @code{@{absolute@ 239@}} in one
1791 part of a program is always the same address when the program is running as
1792 address @code{@{absolute@ 239@}} in any other part of the program.
1794 The idea of sections is extended to the @dfn{undefined} section. Any
1795 address whose section is unknown at assembly time is by definition
1796 rendered @{undefined @var{U}@}---where @var{U} is filled in later.
1797 Since numbers are always defined, the only way to generate an undefined
1798 address is to mention an undefined symbol. A reference to a named
1799 common block would be such a symbol: its value is unknown at assembly
1800 time so it has section @emph{undefined}.
1802 By analogy the word @emph{section} is used to describe groups of sections in
1803 the linked program. @code{@value{LD}} puts all partial programs' text
1804 sections in contiguous addresses in the linked program. It is
1805 customary to refer to the @emph{text section} of a program, meaning all
1806 the addresses of all partial programs' text sections. Likewise for
1807 data and bss sections.
1809 Some sections are manipulated by @code{@value{LD}}; others are invented for
1810 use of @code{@value{AS}} and have no meaning except during assembly.
1813 @section @value{LD} Sections
1814 @code{@value{LD}} deals with just four kinds of sections, summarized below.
1819 @cindex named sections
1820 @cindex sections, named
1821 @item named sections
1824 @cindex text section
1825 @cindex data section
1829 These sections hold your program. @code{@value{AS}} and @code{@value{LD}} treat them as
1830 separate but equal sections. Anything you can say of one section is
1833 When the program is running, however, it is
1834 customary for the text section to be unalterable. The
1835 text section is often shared among processes: it contains
1836 instructions, constants and the like. The data section of a running
1837 program is usually alterable: for example, C variables would be stored
1838 in the data section.
1843 This section contains zeroed bytes when your program begins running. It
1844 is used to hold unitialized variables or common storage. The length of
1845 each partial program's bss section is important, but because it starts
1846 out containing zeroed bytes there is no need to store explicit zero
1847 bytes in the object file. The bss section was invented to eliminate
1848 those explicit zeros from object files.
1850 @cindex absolute section
1851 @item absolute section
1852 Address 0 of this section is always ``relocated'' to runtime address 0.
1853 This is useful if you want to refer to an address that @code{@value{LD}} must
1854 not change when relocating. In this sense we speak of absolute
1855 addresses being ``unrelocatable'': they do not change during relocation.
1857 @cindex undefined section
1858 @item undefined section
1859 This ``section'' is a catch-all for address references to objects not in
1860 the preceding sections.
1861 @c FIXME: ref to some other doc on obj-file formats could go here.
1864 @cindex relocation example
1865 An idealized example of three relocatable sections follows.
1867 The example uses the traditional section names @samp{.text} and @samp{.data}.
1869 Memory addresses are on the horizontal axis.
1873 @c END TEXI2ROFF-KILL
1876 partial program # 1: |ttttt|dddd|00|
1883 partial program # 2: |TTT|DDD|000|
1886 +--+---+-----+--+----+---+-----+~~
1887 linked program: | |TTT|ttttt| |dddd|DDD|00000|
1888 +--+---+-----+--+----+---+-----+~~
1890 addresses: 0 @dots{}
1897 \line{\it Partial program \#1: \hfil}
1898 \line{\ibox{2.5cm}{\tt text}\ibox{2cm}{\tt data}\ibox{1cm}{\tt bss}\hfil}
1899 \line{\boxit{2.5cm}{\tt ttttt}\boxit{2cm}{\tt dddd}\boxit{1cm}{\tt 00}\hfil}
1901 \line{\it Partial program \#2: \hfil}
1902 \line{\ibox{1cm}{\tt text}\ibox{1.5cm}{\tt data}\ibox{1cm}{\tt bss}\hfil}
1903 \line{\boxit{1cm}{\tt TTT}\boxit{1.5cm}{\tt DDDD}\boxit{1cm}{\tt 000}\hfil}
1905 \line{\it linked program: \hfil}
1906 \line{\ibox{.5cm}{}\ibox{1cm}{\tt text}\ibox{2.5cm}{}\ibox{.75cm}{}\ibox{2cm}{\tt data}\ibox{1.5cm}{}\ibox{2cm}{\tt bss}\hfil}
1907 \line{\boxit{.5cm}{}\boxit{1cm}{\tt TTT}\boxit{2.5cm}{\tt
1908 ttttt}\boxit{.75cm}{}\boxit{2cm}{\tt dddd}\boxit{1.5cm}{\tt
1909 DDDD}\boxit{2cm}{\tt 00000}\ \dots\hfil}
1911 \line{\it addresses: \hfil}
1915 @c END TEXI2ROFF-KILL
1918 @section @value{AS} Internal Sections
1920 @cindex internal @code{@value{AS}} sections
1921 @cindex sections in messages, internal
1922 These sections are meant only for the internal use of @code{@value{AS}}. They
1923 have no meaning at run-time. You do not really need to know about these
1924 sections for most purposes; but they can be mentioned in @code{@value{AS}}
1925 warning messages, so it might be helpful to have an idea of their
1926 meanings to @code{@value{AS}}. These sections are used to permit the
1927 value of every expression in your assembly language program to be a
1928 section-relative address.
1931 @item ASSEMBLER-INTERNAL-LOGIC-ERROR!
1932 @cindex assembler internal logic error
1933 An internal assembler logic error has been found. This means there is a
1934 bug in the assembler.
1937 @cindex expr (internal section)
1938 The assembler stores complex expression internally as combinations of
1939 symbols. When it needs to represent an expression as a symbol, it puts
1940 it in the expr section.
1942 @c FIXME item transfer[t] vector preload
1943 @c FIXME item transfer[t] vector postload
1944 @c FIXME item register
1948 @section Sub-Sections
1950 @cindex numbered subsections
1951 @cindex grouping data
1957 fall into two sections: text and data.
1959 You may have separate groups of
1961 data in named sections
1965 data in named sections
1971 that you want to end up near to each other in the object file, even though they
1972 are not contiguous in the assembler source. @code{@value{AS}} allows you to
1973 use @dfn{subsections} for this purpose. Within each section, there can be
1974 numbered subsections with values from 0 to 8192. Objects assembled into the
1975 same subsection go into the object file together with other objects in the same
1976 subsection. For example, a compiler might want to store constants in the text
1977 section, but might not want to have them interspersed with the program being
1978 assembled. In this case, the compiler could issue a @samp{.text 0} before each
1979 section of code being output, and a @samp{.text 1} before each group of
1980 constants being output.
1982 Subsections are optional. If you do not use subsections, everything
1983 goes in subsection number zero.
1986 Each subsection is zero-padded up to a multiple of four bytes.
1987 (Subsections may be padded a different amount on different flavors
1988 of @code{@value{AS}}.)
1992 On the H8/300 and H8/500 platforms, each subsection is zero-padded to a word
1993 boundary (two bytes).
1994 The same is true on the Hitachi SH.
1997 @c FIXME section padding (alignment)?
1998 @c Rich Pixley says padding here depends on target obj code format; that
1999 @c doesn't seem particularly useful to say without further elaboration,
2000 @c so for now I say nothing about it. If this is a generic BFD issue,
2001 @c these paragraphs might need to vanish from this manual, and be
2002 @c discussed in BFD chapter of binutils (or some such).
2005 On the AMD 29K family, no particular padding is added to section or
2006 subsection sizes; @value{AS} forces no alignment on this platform.
2010 Subsections appear in your object file in numeric order, lowest numbered
2011 to highest. (All this to be compatible with other people's assemblers.)
2012 The object file contains no representation of subsections; @code{@value{LD}} and
2013 other programs that manipulate object files see no trace of them.
2014 They just see all your text subsections as a text section, and all your
2015 data subsections as a data section.
2017 To specify which subsection you want subsequent statements assembled
2018 into, use a numeric argument to specify it, in a @samp{.text
2019 @var{expression}} or a @samp{.data @var{expression}} statement.
2022 When generating COFF output, you
2027 can also use an extra subsection
2028 argument with arbitrary named sections: @samp{.section @var{name},
2031 @var{Expression} should be an absolute expression.
2032 (@xref{Expressions}.) If you just say @samp{.text} then @samp{.text 0}
2033 is assumed. Likewise @samp{.data} means @samp{.data 0}. Assembly
2034 begins in @code{text 0}. For instance:
2036 .text 0 # The default subsection is text 0 anyway.
2037 .ascii "This lives in the first text subsection. *"
2039 .ascii "But this lives in the second text subsection."
2041 .ascii "This lives in the data section,"
2042 .ascii "in the first data subsection."
2044 .ascii "This lives in the first text section,"
2045 .ascii "immediately following the asterisk (*)."
2048 Each section has a @dfn{location counter} incremented by one for every byte
2049 assembled into that section. Because subsections are merely a convenience
2050 restricted to @code{@value{AS}} there is no concept of a subsection location
2051 counter. There is no way to directly manipulate a location counter---but the
2052 @code{.align} directive changes it, and any label definition captures its
2053 current value. The location counter of the section where statements are being
2054 assembled is said to be the @dfn{active} location counter.
2057 @section bss Section
2060 @cindex common variable storage
2061 The bss section is used for local common variable storage.
2062 You may allocate address space in the bss section, but you may
2063 not dictate data to load into it before your program executes. When
2064 your program starts running, all the contents of the bss
2065 section are zeroed bytes.
2067 Addresses in the bss section are allocated with special directives; you
2068 may not assemble anything directly into the bss section. Hence there
2069 are no bss subsections. @xref{Comm,,@code{.comm}},
2070 @pxref{Lcomm,,@code{.lcomm}}.
2076 Symbols are a central concept: the programmer uses symbols to name
2077 things, the linker uses symbols to link, and the debugger uses symbols
2081 @cindex debuggers, and symbol order
2082 @emph{Warning:} @code{@value{AS}} does not place symbols in the object file in
2083 the same order they were declared. This may break some debuggers.
2088 * Setting Symbols:: Giving Symbols Other Values
2089 * Symbol Names:: Symbol Names
2090 * Dot:: The Special Dot Symbol
2091 * Symbol Attributes:: Symbol Attributes
2098 A @dfn{label} is written as a symbol immediately followed by a colon
2099 @samp{:}. The symbol then represents the current value of the
2100 active location counter, and is, for example, a suitable instruction
2101 operand. You are warned if you use the same symbol to represent two
2102 different locations: the first definition overrides any other
2106 On the HPPA, the usual form for a label need not be immediately followed by a
2107 colon, but instead must start in column zero. Only one label may be defined on
2108 a single line. To work around this, the HPPA version of @code{@value{AS}} also
2109 provides a special directive @code{.label} for defining labels more flexibly.
2112 @node Setting Symbols
2113 @section Giving Symbols Other Values
2115 @cindex assigning values to symbols
2116 @cindex symbol values, assigning
2117 A symbol can be given an arbitrary value by writing a symbol, followed
2118 by an equals sign @samp{=}, followed by an expression
2119 (@pxref{Expressions}). This is equivalent to using the @code{.set}
2120 directive. @xref{Set,,@code{.set}}.
2123 @section Symbol Names
2125 @cindex symbol names
2126 @cindex names, symbol
2127 @ifclear SPECIAL-SYMS
2128 Symbol names begin with a letter or with one of @samp{._}. On most
2129 machines, you can also use @code{$} in symbol names; exceptions are
2130 noted in @ref{Machine Dependencies}. That character may be followed by any
2131 string of digits, letters, dollar signs (unless otherwise noted in
2132 @ref{Machine Dependencies}), and underscores.
2135 For the AMD 29K family, @samp{?} is also allowed in the
2136 body of a symbol name, though not at its beginning.
2141 Symbol names begin with a letter or with one of @samp{._}. On the
2143 H8/500, you can also use @code{$} in symbol names. That character may
2144 be followed by any string of digits, letters, dollar signs (save on the
2145 H8/300), and underscores.
2149 Case of letters is significant: @code{foo} is a different symbol name
2152 Each symbol has exactly one name. Each name in an assembly language program
2153 refers to exactly one symbol. You may use that symbol name any number of times
2156 @subheading Local Symbol Names
2158 @cindex local symbol names
2159 @cindex symbol names, local
2160 @cindex temporary symbol names
2161 @cindex symbol names, temporary
2162 Local symbols help compilers and programmers use names temporarily.
2163 There are ten local symbol names, which are re-used throughout the
2164 program. You may refer to them using the names @samp{0} @samp{1}
2165 @dots{} @samp{9}. To define a local symbol, write a label of the form
2166 @samp{@b{N}:} (where @b{N} represents any digit). To refer to the most
2167 recent previous definition of that symbol write @samp{@b{N}b}, using the
2168 same digit as when you defined the label. To refer to the next
2169 definition of a local label, write @samp{@b{N}f}---where @b{N} gives you
2170 a choice of 10 forward references. The @samp{b} stands for
2171 ``backwards'' and the @samp{f} stands for ``forwards''.
2173 Local symbols are not emitted by the current @sc{gnu} C compiler.
2175 There is no restriction on how you can use these labels, but
2176 remember that at any point in the assembly you can refer to at most
2177 10 prior local labels and to at most 10 forward local labels.
2179 Local symbol names are only a notation device. They are immediately
2180 transformed into more conventional symbol names before the assembler
2181 uses them. The symbol names stored in the symbol table, appearing in
2182 error messages and optionally emitted to the object file have these
2187 All local labels begin with @samp{L}. Normally both @code{@value{AS}} and
2188 @code{@value{LD}} forget symbols that start with @samp{L}. These labels are
2189 used for symbols you are never intended to see. If you use the
2190 @samp{-L} option then @code{@value{AS}} retains these symbols in the
2191 object file. If you also instruct @code{@value{LD}} to retain these symbols,
2192 you may use them in debugging.
2195 If the label is written @samp{0:} then the digit is @samp{0}.
2196 If the label is written @samp{1:} then the digit is @samp{1}.
2197 And so on up through @samp{9:}.
2200 This unusual character is included so you do not accidentally invent
2201 a symbol of the same name. The character has ASCII value
2204 @item @emph{ordinal number}
2205 This is a serial number to keep the labels distinct. The first
2206 @samp{0:} gets the number @samp{1}; The 15th @samp{0:} gets the
2207 number @samp{15}; @emph{etc.}. Likewise for the other labels @samp{1:}
2211 For instance, the first @code{1:} is named @code{L1@ctrl{A}1}, the 44th
2212 @code{3:} is named @code{L3@ctrl{A}44}.
2215 @section The Special Dot Symbol
2217 @cindex dot (symbol)
2218 @cindex @code{.} (symbol)
2219 @cindex current address
2220 @cindex location counter
2221 The special symbol @samp{.} refers to the current address that
2222 @code{@value{AS}} is assembling into. Thus, the expression @samp{melvin:
2223 .long .} defines @code{melvin} to contain its own address.
2224 Assigning a value to @code{.} is treated the same as a @code{.org}
2225 directive. Thus, the expression @samp{.=.+4} is the same as saying
2226 @ifclear no-space-dir
2235 @node Symbol Attributes
2236 @section Symbol Attributes
2238 @cindex symbol attributes
2239 @cindex attributes, symbol
2240 Every symbol has, as well as its name, the attributes ``Value'' and
2241 ``Type''. Depending on output format, symbols can also have auxiliary
2244 The detailed definitions are in @file{a.out.h}.
2247 If you use a symbol without defining it, @code{@value{AS}} assumes zero for
2248 all these attributes, and probably won't warn you. This makes the
2249 symbol an externally defined symbol, which is generally what you
2253 * Symbol Value:: Value
2254 * Symbol Type:: Type
2257 * a.out Symbols:: Symbol Attributes: @code{a.out}
2261 * a.out Symbols:: Symbol Attributes: @code{a.out}
2264 * a.out Symbols:: Symbol Attributes: @code{a.out}, @code{b.out}
2269 * COFF Symbols:: Symbol Attributes for COFF
2272 * SOM Symbols:: Symbol Attributes for SOM
2279 @cindex value of a symbol
2280 @cindex symbol value
2281 The value of a symbol is (usually) 32 bits. For a symbol which labels a
2282 location in the text, data, bss or absolute sections the value is the
2283 number of addresses from the start of that section to the label.
2284 Naturally for text, data and bss sections the value of a symbol changes
2285 as @code{@value{LD}} changes section base addresses during linking. Absolute
2286 symbols' values do not change during linking: that is why they are
2289 The value of an undefined symbol is treated in a special way. If it is
2290 0 then the symbol is not defined in this assembler source file, and
2291 @code{@value{LD}} tries to determine its value from other files linked into the
2292 same program. You make this kind of symbol simply by mentioning a symbol
2293 name without defining it. A non-zero value represents a @code{.comm}
2294 common declaration. The value is how much common storage to reserve, in
2295 bytes (addresses). The symbol refers to the first address of the
2301 @cindex type of a symbol
2303 The type attribute of a symbol contains relocation (section)
2304 information, any flag settings indicating that a symbol is external, and
2305 (optionally), other information for linkers and debuggers. The exact
2306 format depends on the object-code output format in use.
2311 @c The following avoids a "widow" subsection title. @group would be
2312 @c better if it were available outside examples.
2315 @subsection Symbol Attributes: @code{a.out}, @code{b.out}
2317 @cindex @code{b.out} symbol attributes
2318 @cindex symbol attributes, @code{b.out}
2319 These symbol attributes appear only when @code{@value{AS}} is configured for
2320 one of the Berkeley-descended object output formats---@code{a.out} or
2326 @subsection Symbol Attributes: @code{a.out}
2328 @cindex @code{a.out} symbol attributes
2329 @cindex symbol attributes, @code{a.out}
2335 @subsection Symbol Attributes: @code{a.out}
2337 @cindex @code{a.out} symbol attributes
2338 @cindex symbol attributes, @code{a.out}
2342 * Symbol Desc:: Descriptor
2343 * Symbol Other:: Other
2347 @subsubsection Descriptor
2349 @cindex descriptor, of @code{a.out} symbol
2350 This is an arbitrary 16-bit value. You may establish a symbol's
2351 descriptor value by using a @code{.desc} statement
2352 (@pxref{Desc,,@code{.desc}}). A descriptor value means nothing to
2356 @subsubsection Other
2358 @cindex other attribute, of @code{a.out} symbol
2359 This is an arbitrary 8-bit value. It means nothing to @code{@value{AS}}.
2364 @subsection Symbol Attributes for COFF
2366 @cindex COFF symbol attributes
2367 @cindex symbol attributes, COFF
2369 The COFF format supports a multitude of auxiliary symbol attributes;
2370 like the primary symbol attributes, they are set between @code{.def} and
2371 @code{.endef} directives.
2373 @subsubsection Primary Attributes
2375 @cindex primary attributes, COFF symbols
2376 The symbol name is set with @code{.def}; the value and type,
2377 respectively, with @code{.val} and @code{.type}.
2379 @subsubsection Auxiliary Attributes
2381 @cindex auxiliary attributes, COFF symbols
2382 The @code{@value{AS}} directives @code{.dim}, @code{.line}, @code{.scl},
2383 @code{.size}, and @code{.tag} can generate auxiliary symbol table
2384 information for COFF.
2389 @subsection Symbol Attributes for SOM
2391 @cindex SOM symbol attributes
2392 @cindex symbol attributes, SOM
2394 The SOM format for the HPPA supports a multitude of symbol attributes set with
2395 the @code{.EXPORT} and @code{.IMPORT} directives.
2397 The attributes are described in @cite{HP9000 Series 800 Assembly
2398 Language Reference Manual} (HP 92432-90001) under the @code{IMPORT} and
2399 @code{EXPORT} assembler directive documentation.
2403 @chapter Expressions
2407 @cindex numeric values
2408 An @dfn{expression} specifies an address or numeric value.
2409 Whitespace may precede and/or follow an expression.
2411 The result of an expression must be an absolute number, or else an offset into
2412 a particular section. If an expression is not absolute, and there is not
2413 enough information when @code{@value{AS}} sees the expression to know its
2414 section, a second pass over the source program might be necessary to interpret
2415 the expression---but the second pass is currently not implemented.
2416 @code{@value{AS}} aborts with an error message in this situation.
2419 * Empty Exprs:: Empty Expressions
2420 * Integer Exprs:: Integer Expressions
2424 @section Empty Expressions
2426 @cindex empty expressions
2427 @cindex expressions, empty
2428 An empty expression has no value: it is just whitespace or null.
2429 Wherever an absolute expression is required, you may omit the
2430 expression, and @code{@value{AS}} assumes a value of (absolute) 0. This
2431 is compatible with other assemblers.
2434 @section Integer Expressions
2436 @cindex integer expressions
2437 @cindex expressions, integer
2438 An @dfn{integer expression} is one or more @emph{arguments} delimited
2439 by @emph{operators}.
2442 * Arguments:: Arguments
2443 * Operators:: Operators
2444 * Prefix Ops:: Prefix Operators
2445 * Infix Ops:: Infix Operators
2449 @subsection Arguments
2451 @cindex expression arguments
2452 @cindex arguments in expressions
2453 @cindex operands in expressions
2454 @cindex arithmetic operands
2455 @dfn{Arguments} are symbols, numbers or subexpressions. In other
2456 contexts arguments are sometimes called ``arithmetic operands''. In
2457 this manual, to avoid confusing them with the ``instruction operands'' of
2458 the machine language, we use the term ``argument'' to refer to parts of
2459 expressions only, reserving the word ``operand'' to refer only to machine
2460 instruction operands.
2462 Symbols are evaluated to yield @{@var{section} @var{NNN}@} where
2463 @var{section} is one of text, data, bss, absolute,
2464 or undefined. @var{NNN} is a signed, 2's complement 32 bit
2467 Numbers are usually integers.
2469 A number can be a flonum or bignum. In this case, you are warned
2470 that only the low order 32 bits are used, and @code{@value{AS}} pretends
2471 these 32 bits are an integer. You may write integer-manipulating
2472 instructions that act on exotic constants, compatible with other
2475 @cindex subexpressions
2476 Subexpressions are a left parenthesis @samp{(} followed by an integer
2477 expression, followed by a right parenthesis @samp{)}; or a prefix
2478 operator followed by an argument.
2481 @subsection Operators
2483 @cindex operators, in expressions
2484 @cindex arithmetic functions
2485 @cindex functions, in expressions
2486 @dfn{Operators} are arithmetic functions, like @code{+} or @code{%}. Prefix
2487 operators are followed by an argument. Infix operators appear
2488 between their arguments. Operators may be preceded and/or followed by
2492 @subsection Prefix Operator
2494 @cindex prefix operators
2495 @code{@value{AS}} has the following @dfn{prefix operators}. They each take
2496 one argument, which must be absolute.
2498 @c the tex/end tex stuff surrounding this small table is meant to make
2499 @c it align, on the printed page, with the similar table in the next
2500 @c section (which is inside an enumerate).
2502 \global\advance\leftskip by \itemindent
2507 @dfn{Negation}. Two's complement negation.
2509 @dfn{Complementation}. Bitwise not.
2513 \global\advance\leftskip by -\itemindent
2517 @subsection Infix Operators
2519 @cindex infix operators
2520 @cindex operators, permitted arguments
2521 @dfn{Infix operators} take two arguments, one on either side. Operators
2522 have precedence, but operations with equal precedence are performed left
2523 to right. Apart from @code{+} or @code{-}, both arguments must be
2524 absolute, and the result is absolute.
2527 @cindex operator precedence
2528 @cindex precedence of operators
2535 @dfn{Multiplication}.
2538 @dfn{Division}. Truncation is the same as the C operator @samp{/}
2545 @dfn{Shift Left}. Same as the C operator @samp{<<}.
2549 @dfn{Shift Right}. Same as the C operator @samp{>>}.
2553 Intermediate precedence
2558 @dfn{Bitwise Inclusive Or}.
2564 @dfn{Bitwise Exclusive Or}.
2567 @dfn{Bitwise Or Not}.
2575 @cindex addition, permitted arguments
2576 @cindex plus, permitted arguments
2577 @cindex arguments for addition
2578 @dfn{Addition}. If either argument is absolute, the result has the section of
2579 the other argument. You may not add together arguments from different
2583 @cindex subtraction, permitted arguments
2584 @cindex minus, permitted arguments
2585 @cindex arguments for subtraction
2586 @dfn{Subtraction}. If the right argument is absolute, the
2587 result has the section of the left argument.
2588 If both arguments are in the same section, the result is absolute.
2589 You may not subtract arguments from different sections.
2590 @c FIXME is there still something useful to say about undefined - undefined ?
2594 In short, it's only meaningful to add or subtract the @emph{offsets} in an
2595 address; you can only have a defined section in one of the two arguments.
2598 @chapter Assembler Directives
2600 @cindex directives, machine independent
2601 @cindex pseudo-ops, machine independent
2602 @cindex machine independent directives
2603 All assembler directives have names that begin with a period (@samp{.}).
2604 The rest of the name is letters, usually in lower case.
2606 This chapter discusses directives that are available regardless of the
2607 target machine configuration for the @sc{gnu} assembler.
2609 Some machine configurations provide additional directives.
2610 @xref{Machine Dependencies}.
2613 @ifset machine-directives
2614 @xref{Machine Dependencies} for additional directives.
2619 * Abort:: @code{.abort}
2621 * ABORT:: @code{.ABORT}
2624 * Align:: @code{.align @var{abs-expr} , @var{abs-expr}}
2625 * App-File:: @code{.app-file @var{string}}
2626 * Ascii:: @code{.ascii "@var{string}"}@dots{}
2627 * Asciz:: @code{.asciz "@var{string}"}@dots{}
2628 * Byte:: @code{.byte @var{expressions}}
2629 * Comm:: @code{.comm @var{symbol} , @var{length} }
2630 * Data:: @code{.data @var{subsection}}
2632 * Def:: @code{.def @var{name}}
2635 * Desc:: @code{.desc @var{symbol}, @var{abs-expression}}
2641 * Double:: @code{.double @var{flonums}}
2642 * Eject:: @code{.eject}
2643 * Else:: @code{.else}
2645 * Endef:: @code{.endef}
2648 * Endif:: @code{.endif}
2649 * Equ:: @code{.equ @var{symbol}, @var{expression}}
2650 * Extern:: @code{.extern}
2651 @ifclear no-file-dir
2652 * File:: @code{.file @var{string}}
2655 * Fill:: @code{.fill @var{repeat} , @var{size} , @var{value}}
2656 * Float:: @code{.float @var{flonums}}
2657 * Global:: @code{.global @var{symbol}}, @code{.globl @var{symbol}}
2658 * hword:: @code{.hword @var{expressions}}
2659 * Ident:: @code{.ident}
2660 * If:: @code{.if @var{absolute expression}}
2661 * Include:: @code{.include "@var{file}"}
2662 * Int:: @code{.int @var{expressions}}
2663 * Lcomm:: @code{.lcomm @var{symbol} , @var{length}}
2664 * Lflags:: @code{.lflags}
2665 @ifclear no-line-dir
2666 * Line:: @code{.line @var{line-number}}
2669 * Ln:: @code{.ln @var{line-number}}
2670 * List:: @code{.list}
2671 * Long:: @code{.long @var{expressions}}
2673 * Lsym:: @code{.lsym @var{symbol}, @var{expression}}
2676 * Nolist:: @code{.nolist}
2677 * Octa:: @code{.octa @var{bignums}}
2678 * Org:: @code{.org @var{new-lc} , @var{fill}}
2679 * Psize:: @code{.psize @var{lines}, @var{columns}}
2680 * Quad:: @code{.quad @var{bignums}}
2681 * Sbttl:: @code{.sbttl "@var{subheading}"}
2683 * Scl:: @code{.scl @var{class}}
2686 * Section:: @code{.section @var{name}, @var{subsection}}
2689 * Set:: @code{.set @var{symbol}, @var{expression}}
2690 * Short:: @code{.short @var{expressions}}
2691 * Single:: @code{.single @var{flonums}}
2693 * Size:: @code{.size}
2696 * Space:: @code{.space @var{size} , @var{fill}}
2698 * Stab:: @code{.stabd, .stabn, .stabs}
2701 * String:: @code{.string "@var{str}"}
2703 * Tag:: @code{.tag @var{structname}}
2706 * Text:: @code{.text @var{subsection}}
2707 * Title:: @code{.title "@var{heading}"}
2709 * Type:: @code{.type @var{int}}
2710 * Val:: @code{.val @var{addr}}
2713 * Word:: @code{.word @var{expressions}}
2714 * Deprecated:: Deprecated Directives
2718 @section @code{.abort}
2720 @cindex @code{abort} directive
2721 @cindex stopping the assembly
2722 This directive stops the assembly immediately. It is for
2723 compatibility with other assemblers. The original idea was that the
2724 assembly language source would be piped into the assembler. If the sender
2725 of the source quit, it could use this directive tells @code{@value{AS}} to
2726 quit also. One day @code{.abort} will not be supported.
2730 @section @code{.ABORT}
2732 @cindex @code{ABORT} directive
2733 When producing COFF output, @code{@value{AS}} accepts this directive as a
2734 synonym for @samp{.abort}.
2737 When producing @code{b.out} output, @code{@value{AS}} accepts this directive,
2743 @section @code{.align @var{abs-expr} , @var{abs-expr}}
2745 @cindex padding the location counter
2746 @cindex @code{align} directive
2747 Pad the location counter (in the current subsection) to a particular
2748 storage boundary. The first expression (which must be absolute) is the
2749 number of low-order zero bits the location counter must have after
2750 advancement. For example @samp{.align 3} advances the location
2751 counter until it a multiple of 8. If the location counter is already a
2752 multiple of 8, no change is needed.
2755 For the HPPA, the first expression (which must be absolute) is the
2756 alignment request in bytes. For example @samp{.align 8} advances
2757 the location counter until it is a multiple of 8. If the location counter
2758 is already a multiple of 8, no change is needed.
2761 The second expression (also absolute) gives the value to be stored in
2762 the padding bytes. It (and the comma) may be omitted. If it is
2763 omitted, the padding bytes are zero.
2766 @section @code{.app-file @var{string}}
2768 @cindex logical file name
2769 @cindex file name, logical
2770 @cindex @code{app-file} directive
2772 @ifclear no-file-dir
2773 (which may also be spelled @samp{.file})
2775 tells @code{@value{AS}} that we are about to start a new
2776 logical file. @var{string} is the new file name. In general, the
2777 filename is recognized whether or not it is surrounded by quotes @samp{"};
2778 but if you wish to specify an empty file name is permitted,
2779 you must give the quotes--@code{""}. This statement may go away in
2780 future: it is only recognized to be compatible with old @code{@value{AS}}
2784 @section @code{.ascii "@var{string}"}@dots{}
2786 @cindex @code{ascii} directive
2787 @cindex string literals
2788 @code{.ascii} expects zero or more string literals (@pxref{Strings})
2789 separated by commas. It assembles each string (with no automatic
2790 trailing zero byte) into consecutive addresses.
2793 @section @code{.asciz "@var{string}"}@dots{}
2795 @cindex @code{asciz} directive
2796 @cindex zero-terminated strings
2797 @cindex null-terminated strings
2798 @code{.asciz} is just like @code{.ascii}, but each string is followed by
2799 a zero byte. The ``z'' in @samp{.asciz} stands for ``zero''.
2802 @section @code{.byte @var{expressions}}
2804 @cindex @code{byte} directive
2805 @cindex integers, one byte
2806 @code{.byte} expects zero or more expressions, separated by commas.
2807 Each expression is assembled into the next byte.
2810 @section @code{.comm @var{symbol} , @var{length} }
2812 @cindex @code{comm} directive
2813 @cindex symbol, common
2814 @code{.comm} declares a named common area in the bss section. Normally
2815 @code{@value{LD}} reserves memory addresses for it during linking, so no partial
2816 program defines the location of the symbol. Use @code{.comm} to tell
2817 @code{@value{LD}} that it must be at least @var{length} bytes long. @code{@value{LD}}
2818 allocates space for each @code{.comm} symbol that is at least as
2819 long as the longest @code{.comm} request in any of the partial programs
2820 linked. @var{length} is an absolute expression.
2823 The syntax for @code{.comm} differs slightly on the HPPA. The syntax is
2824 @samp{@var{symbol} .comm, @var{length}}; @var{symbol} is optional.
2828 @section @code{.data @var{subsection}}
2830 @cindex @code{data} directive
2831 @code{.data} tells @code{@value{AS}} to assemble the following statements onto the
2832 end of the data subsection numbered @var{subsection} (which is an
2833 absolute expression). If @var{subsection} is omitted, it defaults
2838 @section @code{.def @var{name}}
2840 @cindex @code{def} directive
2841 @cindex COFF symbols, debugging
2842 @cindex debugging COFF symbols
2843 Begin defining debugging information for a symbol @var{name}; the
2844 definition extends until the @code{.endef} directive is encountered.
2847 This directive is only observed when @code{@value{AS}} is configured for COFF
2848 format output; when producing @code{b.out}, @samp{.def} is recognized,
2855 @section @code{.desc @var{symbol}, @var{abs-expression}}
2857 @cindex @code{desc} directive
2858 @cindex COFF symbol descriptor
2859 @cindex symbol descriptor, COFF
2860 This directive sets the descriptor of the symbol (@pxref{Symbol Attributes})
2861 to the low 16 bits of an absolute expression.
2864 The @samp{.desc} directive is not available when @code{@value{AS}} is
2865 configured for COFF output; it is only for @code{a.out} or @code{b.out}
2866 object format. For the sake of compatibility, @code{@value{AS}} accepts
2867 it, but produces no output, when configured for COFF.
2873 @section @code{.dim}
2875 @cindex @code{dim} directive
2876 @cindex COFF auxiliary symbol information
2877 @cindex auxiliary symbol information, COFF
2878 This directive is generated by compilers to include auxiliary debugging
2879 information in the symbol table. It is only permitted inside
2880 @code{.def}/@code{.endef} pairs.
2883 @samp{.dim} is only meaningful when generating COFF format output; when
2884 @code{@value{AS}} is generating @code{b.out}, it accepts this directive but
2890 @section @code{.double @var{flonums}}
2892 @cindex @code{double} directive
2893 @cindex floating point numbers (double)
2894 @code{.double} expects zero or more flonums, separated by commas. It
2895 assembles floating point numbers.
2897 The exact kind of floating point numbers emitted depends on how
2898 @code{@value{AS}} is configured. @xref{Machine Dependencies}.
2902 On the @value{TARGET} family @samp{.double} emits 64-bit floating-point numbers
2903 in @sc{ieee} format.
2908 @section @code{.eject}
2910 @cindex @code{eject} directive
2911 @cindex new page, in listings
2912 @cindex page, in listings
2913 @cindex listing control: new page
2914 Force a page break at this point, when generating assembly listings.
2917 @section @code{.else}
2919 @cindex @code{else} directive
2920 @code{.else} is part of the @code{@value{AS}} support for conditional
2921 assembly; @pxref{If,,@code{.if}}. It marks the beginning of a section
2922 of code to be assembled if the condition for the preceding @code{.if}
2926 @node End, Endef, Else, Pseudo Ops
2927 @section @code{.end}
2929 @cindex @code{end} directive
2930 This doesn't do anything---but isn't an s_ignore, so I suspect it's
2931 meant to do something eventually (which is why it isn't documented here
2932 as "for compatibility with blah").
2937 @section @code{.endef}
2939 @cindex @code{endef} directive
2940 This directive flags the end of a symbol definition begun with
2944 @samp{.endef} is only meaningful when generating COFF format output; if
2945 @code{@value{AS}} is configured to generate @code{b.out}, it accepts this
2946 directive but ignores it.
2951 @section @code{.endif}
2953 @cindex @code{endif} directive
2954 @code{.endif} is part of the @code{@value{AS}} support for conditional assembly;
2955 it marks the end of a block of code that is only assembled
2956 conditionally. @xref{If,,@code{.if}}.
2959 @section @code{.equ @var{symbol}, @var{expression}}
2961 @cindex @code{equ} directive
2962 @cindex assigning values to symbols
2963 @cindex symbols, assigning values to
2964 This directive sets the value of @var{symbol} to @var{expression}.
2965 It is synonymous with @samp{.set}; @pxref{Set,,@code{.set}}.
2968 The syntax for @code{equ} on the HPPA is
2969 @samp{@var{symbol} .equ @var{expression}}.
2973 @section @code{.extern}
2975 @cindex @code{extern} directive
2976 @code{.extern} is accepted in the source program---for compatibility
2977 with other assemblers---but it is ignored. @code{@value{AS}} treats
2978 all undefined symbols as external.
2980 @ifclear no-file-dir
2982 @section @code{.file @var{string}}
2984 @cindex @code{file} directive
2985 @cindex logical file name
2986 @cindex file name, logical
2987 @code{.file} (which may also be spelled @samp{.app-file}) tells
2988 @code{@value{AS}} that we are about to start a new logical file.
2989 @var{string} is the new file name. In general, the filename is
2990 recognized whether or not it is surrounded by quotes @samp{"}; but if
2991 you wish to specify an empty file name, you must give the
2992 quotes--@code{""}. This statement may go away in future: it is only
2993 recognized to be compatible with old @code{@value{AS}} programs.
2995 In some configurations of @code{@value{AS}}, @code{.file} has already been
2996 removed to avoid conflicts with other assemblers. @xref{Machine Dependencies}.
3001 @section @code{.fill @var{repeat} , @var{size} , @var{value}}
3003 @cindex @code{fill} directive
3004 @cindex writing patterns in memory
3005 @cindex patterns, writing in memory
3006 @var{result}, @var{size} and @var{value} are absolute expressions.
3007 This emits @var{repeat} copies of @var{size} bytes. @var{Repeat}
3008 may be zero or more. @var{Size} may be zero or more, but if it is
3009 more than 8, then it is deemed to have the value 8, compatible with
3010 other people's assemblers. The contents of each @var{repeat} bytes
3011 is taken from an 8-byte number. The highest order 4 bytes are
3012 zero. The lowest order 4 bytes are @var{value} rendered in the
3013 byte-order of an integer on the computer @code{@value{AS}} is assembling for.
3014 Each @var{size} bytes in a repetition is taken from the lowest order
3015 @var{size} bytes of this number. Again, this bizarre behavior is
3016 compatible with other people's assemblers.
3018 @var{size} and @var{value} are optional.
3019 If the second comma and @var{value} are absent, @var{value} is
3020 assumed zero. If the first comma and following tokens are absent,
3021 @var{size} is assumed to be 1.
3024 @section @code{.float @var{flonums}}
3026 @cindex floating point numbers (single)
3027 @cindex @code{float} directive
3028 This directive assembles zero or more flonums, separated by commas. It
3029 has the same effect as @code{.single}.
3031 The exact kind of floating point numbers emitted depends on how
3032 @code{@value{AS}} is configured.
3033 @xref{Machine Dependencies}.
3037 On the @value{TARGET} family, @code{.float} emits 32-bit floating point numbers
3038 in @sc{ieee} format.
3043 @section @code{.global @var{symbol}}, @code{.globl @var{symbol}}
3045 @cindex @code{global} directive
3046 @cindex symbol, making visible to linker
3047 @code{.global} makes the symbol visible to @code{@value{LD}}. If you define
3048 @var{symbol} in your partial program, its value is made available to
3049 other partial programs that are linked with it. Otherwise,
3050 @var{symbol} takes its attributes from a symbol of the same name
3051 from another file linked into the same program.
3053 Both spellings (@samp{.globl} and @samp{.global}) are accepted, for
3054 compatibility with other assemblers.
3057 On the HPPA, @code{.global} is not always enough to make it accessible to other
3058 partial programs. You may need the HPPA-only @code{.EXPORT} directive as well.
3059 @xref{HPPA Directives,, HPPA Assembler Directives}.
3063 @section @code{.hword @var{expressions}}
3065 @cindex @code{hword} directive
3066 @cindex integers, 16-bit
3067 @cindex numbers, 16-bit
3068 @cindex sixteen bit integers
3069 This expects zero or more @var{expressions}, and emits
3070 a 16 bit number for each.
3073 This directive is a synonym for @samp{.short}; depending on the target
3074 architecture, it may also be a synonym for @samp{.word}.
3078 This directive is a synonym for @samp{.short}.
3081 This directive is a synonym for both @samp{.short} and @samp{.word}.
3086 @section @code{.ident}
3088 @cindex @code{ident} directive
3089 This directive is used by some assemblers to place tags in object files.
3090 @code{@value{AS}} simply accepts the directive for source-file
3091 compatibility with such assemblers, but does not actually emit anything
3095 @section @code{.if @var{absolute expression}}
3097 @cindex conditional assembly
3098 @cindex @code{if} directive
3099 @code{.if} marks the beginning of a section of code which is only
3100 considered part of the source program being assembled if the argument
3101 (which must be an @var{absolute expression}) is non-zero. The end of
3102 the conditional section of code must be marked by @code{.endif}
3103 (@pxref{Endif,,@code{.endif}}); optionally, you may include code for the
3104 alternative condition, flagged by @code{.else} (@pxref{Else,,@code{.else}}.
3106 The following variants of @code{.if} are also supported:
3108 @item .ifdef @var{symbol}
3109 @cindex @code{ifdef} directive
3110 Assembles the following section of code if the specified @var{symbol}
3115 @cindex @code{ifeqs} directive
3116 Not yet implemented.
3119 @item .ifndef @var{symbol}
3120 @itemx ifnotdef @var{symbol}
3121 @cindex @code{ifndef} directive
3122 @cindex @code{ifnotdef} directive
3123 Assembles the following section of code if the specified @var{symbol}
3124 has not been defined. Both spelling variants are equivalent.
3128 Not yet implemented.
3133 @section @code{.include "@var{file}"}
3135 @cindex @code{include} directive
3136 @cindex supporting files, including
3137 @cindex files, including
3138 This directive provides a way to include supporting files at specified
3139 points in your source program. The code from @var{file} is assembled as
3140 if it followed the point of the @code{.include}; when the end of the
3141 included file is reached, assembly of the original file continues. You
3142 can control the search paths used with the @samp{-I} command-line option
3143 (@pxref{Invoking,,Command-Line Options}). Quotation marks are required
3147 @section @code{.int @var{expressions}}
3149 @cindex @code{int} directive
3150 @cindex integers, 32-bit
3151 Expect zero or more @var{expressions}, of any section, separated by commas.
3152 For each expression, emit a number that, at run time, is the value of that
3153 expression. The byte order and bit size of the number depends on what kind
3154 of target the assembly is for.
3158 On the H8/500 and most forms of the H8/300, @code{.int} emits 16-bit
3159 integers. On the H8/300H and the Hitachi SH, however, @code{.int} emits
3165 @section @code{.lcomm @var{symbol} , @var{length}}
3167 @cindex @code{lcomm} directive
3168 @cindex local common symbols
3169 @cindex symbols, local common
3170 Reserve @var{length} (an absolute expression) bytes for a local common
3171 denoted by @var{symbol}. The section and value of @var{symbol} are
3172 those of the new local common. The addresses are allocated in the bss
3173 section, so that at run-time the bytes start off zeroed. @var{Symbol}
3174 is not declared global (@pxref{Global,,@code{.global}}), so is normally
3175 not visible to @code{@value{LD}}.
3178 The syntax for @code{.lcomm} differs slightly on the HPPA. The syntax is
3179 @samp{@var{symbol} .lcomm, @var{length}}; @var{symbol} is optional.
3183 @section @code{.lflags}
3185 @cindex @code{lflags} directive (ignored)
3186 @code{@value{AS}} accepts this directive, for compatibility with other
3187 assemblers, but ignores it.
3189 @ifclear no-line-dir
3191 @section @code{.line @var{line-number}}
3193 @cindex @code{line} directive
3197 @section @code{.ln @var{line-number}}
3199 @cindex @code{ln} directive
3201 @cindex logical line number
3203 Change the logical line number. @var{line-number} must be an absolute
3204 expression. The next line has that logical line number. Therefore any other
3205 statements on the current line (after a statement separator character) are
3206 reported as on logical line number @var{line-number} @minus{} 1. One day
3207 @code{@value{AS}} will no longer support this directive: it is recognized only
3208 for compatibility with existing assembler programs.
3212 @emph{Warning:} In the AMD29K configuration of @value{AS}, this command is
3213 not available; use the synonym @code{.ln} in that context.
3218 @ifclear no-line-dir
3219 Even though this is a directive associated with the @code{a.out} or
3220 @code{b.out} object-code formats, @code{@value{AS}} still recognizes it
3221 when producing COFF output, and treats @samp{.line} as though it
3222 were the COFF @samp{.ln} @emph{if} it is found outside a
3223 @code{.def}/@code{.endef} pair.
3225 Inside a @code{.def}, @samp{.line} is, instead, one of the directives
3226 used by compilers to generate auxiliary symbol information for
3231 @section @code{.ln @var{line-number}}
3233 @cindex @code{ln} directive
3234 @ifclear no-line-dir
3235 @samp{.ln} is a synonym for @samp{.line}.
3238 Tell @code{@value{AS}} to change the logical line number. @var{line-number}
3239 must be an absolute expression. The next line has that logical
3240 line number, so any other statements on the current line (after a
3241 statement separator character @code{;}) are reported as on logical
3242 line number @var{line-number} @minus{} 1.
3245 This directive is accepted, but ignored, when @code{@value{AS}} is
3246 configured for @code{b.out}; its effect is only associated with COFF
3252 @section @code{.list}
3254 @cindex @code{list} directive
3255 @cindex listing control, turning on
3256 Control (in conjunction with the @code{.nolist} directive) whether or
3257 not assembly listings are generated. These two directives maintain an
3258 internal counter (which is zero initially). @code{.list} increments the
3259 counter, and @code{.nolist} decrements it. Assembly listings are
3260 generated whenever the counter is greater than zero.
3262 By default, listings are disabled. When you enable them (with the
3263 @samp{-a} command line option; @pxref{Invoking,,Command-Line Options}),
3264 the initial value of the listing counter is one.
3267 @section @code{.long @var{expressions}}
3269 @cindex @code{long} directive
3270 @code{.long} is the same as @samp{.int}, @pxref{Int,,@code{.int}}.
3273 @c no one seems to know what this is for or whether this description is
3274 @c what it really ought to do
3276 @section @code{.lsym @var{symbol}, @var{expression}}
3278 @cindex @code{lsym} directive
3279 @cindex symbol, not referenced in assembly
3280 @code{.lsym} creates a new symbol named @var{symbol}, but does not put it in
3281 the hash table, ensuring it cannot be referenced by name during the
3282 rest of the assembly. This sets the attributes of the symbol to be
3283 the same as the expression value:
3285 @var{other} = @var{descriptor} = 0
3286 @var{type} = @r{(section of @var{expression})}
3287 @var{value} = @var{expression}
3290 The new symbol is not flagged as external.
3294 @section @code{.nolist}
3296 @cindex @code{nolist} directive
3297 @cindex listing control, turning off
3298 Control (in conjunction with the @code{.list} directive) whether or
3299 not assembly listings are generated. These two directives maintain an
3300 internal counter (which is zero initially). @code{.list} increments the
3301 counter, and @code{.nolist} decrements it. Assembly listings are
3302 generated whenever the counter is greater than zero.
3305 @section @code{.octa @var{bignums}}
3307 @c FIXME: double size emitted for "octa" on i960, others? Or warn?
3308 @cindex @code{octa} directive
3309 @cindex integer, 16-byte
3310 @cindex sixteen byte integer
3311 This directive expects zero or more bignums, separated by commas. For each
3312 bignum, it emits a 16-byte integer.
3314 The term ``octa'' comes from contexts in which a ``word'' is two bytes;
3315 hence @emph{octa}-word for 16 bytes.
3318 @section @code{.org @var{new-lc} , @var{fill}}
3320 @cindex @code{org} directive
3321 @cindex location counter, advancing
3322 @cindex advancing location counter
3323 @cindex current address, advancing
3324 Advance the location counter of the current section to
3325 @var{new-lc}. @var{new-lc} is either an absolute expression or an
3326 expression with the same section as the current subsection. That is,
3327 you can't use @code{.org} to cross sections: if @var{new-lc} has the
3328 wrong section, the @code{.org} directive is ignored. To be compatible
3329 with former assemblers, if the section of @var{new-lc} is absolute,
3330 @code{@value{AS}} issues a warning, then pretends the section of @var{new-lc}
3331 is the same as the current subsection.
3333 @code{.org} may only increase the location counter, or leave it
3334 unchanged; you cannot use @code{.org} to move the location counter
3337 @c double negative used below "not undefined" because this is a specific
3338 @c reference to "undefined" (as SEG_UNKNOWN is called in this manual)
3339 @c section. pesch@cygnus.com 18feb91
3340 Because @code{@value{AS}} tries to assemble programs in one pass, @var{new-lc}
3341 may not be undefined. If you really detest this restriction we eagerly await
3342 a chance to share your improved assembler.
3344 Beware that the origin is relative to the start of the section, not
3345 to the start of the subsection. This is compatible with other
3346 people's assemblers.
3348 When the location counter (of the current subsection) is advanced, the
3349 intervening bytes are filled with @var{fill} which should be an
3350 absolute expression. If the comma and @var{fill} are omitted,
3351 @var{fill} defaults to zero.
3354 @section @code{.psize @var{lines} , @var{columns}}
3356 @cindex @code{psize} directive
3357 @cindex listing control: paper size
3358 @cindex paper size, for listings
3359 Use this directive to declare the number of lines---and, optionally, the
3360 number of columns---to use for each page, when generating listings.
3362 If you do not use @code{.psize}, listings use a default line-count
3363 of 60. You may omit the comma and @var{columns} specification; the
3364 default width is 200 columns.
3366 @code{@value{AS}} generates formfeeds whenever the specified number of
3367 lines is exceeded (or whenever you explicitly request one, using
3370 If you specify @var{lines} as @code{0}, no formfeeds are generated save
3371 those explicitly specified with @code{.eject}.
3374 @section @code{.quad @var{bignums}}
3376 @cindex @code{quad} directive
3377 @code{.quad} expects zero or more bignums, separated by commas. For
3378 each bignum, it emits
3380 an 8-byte integer. If the bignum won't fit in 8 bytes, it prints a
3381 warning message; and just takes the lowest order 8 bytes of the bignum.
3382 @cindex eight-byte integer
3383 @cindex integer, 8-byte
3385 The term ``quad'' comes from contexts in which a ``word'' is two bytes;
3386 hence @emph{quad}-word for 8 bytes.
3389 a 16-byte integer. If the bignum won't fit in 16 bytes, it prints a
3390 warning message; and just takes the lowest order 16 bytes of the bignum.
3391 @cindex sixteen-byte integer
3392 @cindex integer, 16-byte
3396 @section @code{.sbttl "@var{subheading}"}
3398 @cindex @code{sbttl} directive
3399 @cindex subtitles for listings
3400 @cindex listing control: subtitle
3401 Use @var{subheading} as the title (third line, immediately after the
3402 title line) when generating assembly listings.
3404 This directive affects subsequent pages, as well as the current page if
3405 it appears within ten lines of the top of a page.
3409 @section @code{.scl @var{class}}
3411 @cindex @code{scl} directive
3412 @cindex symbol storage class (COFF)
3413 @cindex COFF symbol storage class
3414 Set the storage-class value for a symbol. This directive may only be
3415 used inside a @code{.def}/@code{.endef} pair. Storage class may flag
3416 whether a symbol is static or external, or it may record further
3417 symbolic debugging information.
3420 The @samp{.scl} directive is primarily associated with COFF output; when
3421 configured to generate @code{b.out} output format, @code{@value{AS}}
3422 accepts this directive but ignores it.
3428 @section @code{.section @var{name}, @var{subsection}}
3430 @cindex @code{section} directive
3431 @cindex named section (COFF)
3432 @cindex COFF named section
3433 Assemble the following code into end of subsection numbered
3434 @var{subsection} in the COFF named section @var{name}. If you omit
3435 @var{subsection}, @code{@value{AS}} uses subsection number zero.
3436 @samp{.section .text} is equivalent to the @code{.text} directive;
3437 @samp{.section .data} is equivalent to the @code{.data} directive.
3439 This directive is only supported for targets that actually support arbitrarily
3440 named sections; on @code{a.out} targets, for example, it is not accepted, even
3441 with a standard @code{a.out} section name as its parameter.
3446 @section @code{.set @var{symbol}, @var{expression}}
3448 @cindex @code{set} directive
3449 @cindex symbol value, setting
3450 Set the value of @var{symbol} to @var{expression}. This
3451 changes @var{symbol}'s value and type to conform to
3452 @var{expression}. If @var{symbol} was flagged as external, it remains
3453 flagged. (@xref{Symbol Attributes}.)
3455 You may @code{.set} a symbol many times in the same assembly.
3457 If you @code{.set} a global symbol, the value stored in the object
3458 file is the last value stored into it.
3461 The syntax for @code{set} on the HPPA is
3462 @samp{@var{symbol} .set @var{expression}}.
3466 @section @code{.short @var{expressions}}
3468 @cindex @code{short} directive
3470 @code{.short} is normally the same as @samp{.word}.
3471 @xref{Word,,@code{.word}}.
3473 In some configurations, however, @code{.short} and @code{.word} generate
3474 numbers of different lengths; @pxref{Machine Dependencies}.
3478 @code{.short} is the same as @samp{.word}. @xref{Word,,@code{.word}}.
3481 This expects zero or more @var{expressions}, and emits
3482 a 16 bit number for each.
3487 @section @code{.single @var{flonums}}
3489 @cindex @code{single} directive
3490 @cindex floating point numbers (single)
3491 This directive assembles zero or more flonums, separated by commas. It
3492 has the same effect as @code{.float}.
3494 The exact kind of floating point numbers emitted depends on how
3495 @code{@value{AS}} is configured. @xref{Machine Dependencies}.
3499 On the @value{TARGET} family, @code{.single} emits 32-bit floating point
3500 numbers in @sc{ieee} format.
3506 @section @code{.size}
3508 @cindex @code{size} directive
3509 This directive is generated by compilers to include auxiliary debugging
3510 information in the symbol table. It is only permitted inside
3511 @code{.def}/@code{.endef} pairs.
3514 @samp{.size} is only meaningful when generating COFF format output; when
3515 @code{@value{AS}} is generating @code{b.out}, it accepts this directive but
3520 @ifclear no-space-dir
3522 @section @code{.space @var{size} , @var{fill}}
3524 @cindex @code{space} directive
3525 @cindex filling memory
3526 This directive emits @var{size} bytes, each of value @var{fill}. Both
3527 @var{size} and @var{fill} are absolute expressions. If the comma
3528 and @var{fill} are omitted, @var{fill} is assumed to be zero.
3532 @emph{Warning:} @code{.space} has a completely different meaning for HPPA
3533 targets; use @code{.block} as a substitute. See @cite{HP9000 Series 800
3534 Assembly Language Reference Manual} (HP 92432-90001) for the meaning of the
3535 @code{.space} directive. @xref{HPPA Directives,,HPPA Assembler Directives},
3544 @section @code{.space}
3545 @cindex @code{space} directive
3547 On the AMD 29K, this directive is ignored; it is accepted for
3548 compatibility with other AMD 29K assemblers.
3551 @emph{Warning:} In most versions of the @sc{gnu} assembler, the directive
3552 @code{.space} has the effect of @code{.block} @xref{Machine Dependencies}.
3558 @section @code{.stabd, .stabn, .stabs}
3560 @cindex symbolic debuggers, information for
3561 @cindex @code{stab@var{x}} directives
3562 There are three directives that begin @samp{.stab}.
3563 All emit symbols (@pxref{Symbols}), for use by symbolic debuggers.
3564 The symbols are not entered in the @code{@value{AS}} hash table: they
3565 cannot be referenced elsewhere in the source file.
3566 Up to five fields are required:
3570 This is the symbol's name. It may contain any character except
3571 @samp{\000}, so is more general than ordinary symbol names. Some
3572 debuggers used to code arbitrarily complex structures into symbol names
3576 An absolute expression. The symbol's type is set to the low 8 bits of
3577 this expression. Any bit pattern is permitted, but @code{@value{LD}}
3578 and debuggers choke on silly bit patterns.
3581 An absolute expression. The symbol's ``other'' attribute is set to the
3582 low 8 bits of this expression.
3585 An absolute expression. The symbol's descriptor is set to the low 16
3586 bits of this expression.
3589 An absolute expression which becomes the symbol's value.
3592 If a warning is detected while reading a @code{.stabd}, @code{.stabn},
3593 or @code{.stabs} statement, the symbol has probably already been created;
3594 you get a half-formed symbol in your object file. This is
3595 compatible with earlier assemblers!
3598 @cindex @code{stabd} directive
3599 @item .stabd @var{type} , @var{other} , @var{desc}
3601 The ``name'' of the symbol generated is not even an empty string.
3602 It is a null pointer, for compatibility. Older assemblers used a
3603 null pointer so they didn't waste space in object files with empty
3606 The symbol's value is set to the location counter,
3607 relocatably. When your program is linked, the value of this symbol
3608 is the address of the location counter when the @code{.stabd} was
3611 @item .stabn @var{type} , @var{other} , @var{desc} , @var{value}
3612 @cindex @code{stabn} directive
3613 The name of the symbol is set to the empty string @code{""}.
3615 @item .stabs @var{string} , @var{type} , @var{other} , @var{desc} , @var{value}
3616 @cindex @code{stabs} directive
3617 All five fields are specified.
3623 @section @code{.string} "@var{str}"
3625 @cindex string, copying to object file
3626 @cindex @code{string} directive
3628 Copy the characters in @var{str} to the object file. You may specify more than
3629 one string to copy, separated by commas. Unless otherwise specified for a
3630 particular machine, the assembler marks the end of each string with a 0 byte.
3631 You can use any of the escape sequences described in @ref{Strings,,Strings}.
3635 @section @code{.tag @var{structname}}
3637 @cindex COFF structure debugging
3638 @cindex structure debugging, COFF
3639 @cindex @code{tag} directive
3640 This directive is generated by compilers to include auxiliary debugging
3641 information in the symbol table. It is only permitted inside
3642 @code{.def}/@code{.endef} pairs. Tags are used to link structure
3643 definitions in the symbol table with instances of those structures.
3646 @samp{.tag} is only used when generating COFF format output; when
3647 @code{@value{AS}} is generating @code{b.out}, it accepts this directive but
3653 @section @code{.text @var{subsection}}
3655 @cindex @code{text} directive
3656 Tells @code{@value{AS}} to assemble the following statements onto the end of
3657 the text subsection numbered @var{subsection}, which is an absolute
3658 expression. If @var{subsection} is omitted, subsection number zero
3662 @section @code{.title "@var{heading}"}
3664 @cindex @code{title} directive
3665 @cindex listing control: title line
3666 Use @var{heading} as the title (second line, immediately after the
3667 source file name and pagenumber) when generating assembly listings.
3669 This directive affects subsequent pages, as well as the current page if
3670 it appears within ten lines of the top of a page.
3674 @section @code{.type @var{int}}
3676 @cindex COFF symbol type
3677 @cindex symbol type, COFF
3678 @cindex @code{type} directive
3679 This directive, permitted only within @code{.def}/@code{.endef} pairs,
3680 records the integer @var{int} as the type attribute of a symbol table entry.
3683 @samp{.type} is associated only with COFF format output; when
3684 @code{@value{AS}} is configured for @code{b.out} output, it accepts this
3685 directive but ignores it.
3691 @section @code{.val @var{addr}}
3693 @cindex @code{val} directive
3694 @cindex COFF value attribute
3695 @cindex value attribute, COFF
3696 This directive, permitted only within @code{.def}/@code{.endef} pairs,
3697 records the address @var{addr} as the value attribute of a symbol table
3701 @samp{.val} is used only for COFF output; when @code{@value{AS}} is
3702 configured for @code{b.out}, it accepts this directive but ignores it.
3707 @section @code{.word @var{expressions}}
3709 @cindex @code{word} directive
3710 This directive expects zero or more @var{expressions}, of any section,
3711 separated by commas.
3714 For each expression, @code{@value{AS}} emits a 32-bit number.
3717 For each expression, @code{@value{AS}} emits a 16-bit number.
3722 The size of the number emitted, and its byte order,
3723 depend on what target computer the assembly is for.
3726 @c on amd29k, i960, sparc the "special treatment to support compilers" doesn't
3727 @c happen---32-bit addressability, period; no long/short jumps.
3728 @ifset DIFF-TBL-KLUGE
3729 @cindex difference tables altered
3730 @cindex altered difference tables
3732 @emph{Warning: Special Treatment to support Compilers}
3736 Machines with a 32-bit address space, but that do less than 32-bit
3737 addressing, require the following special treatment. If the machine of
3738 interest to you does 32-bit addressing (or doesn't require it;
3739 @pxref{Machine Dependencies}), you can ignore this issue.
3742 In order to assemble compiler output into something that works,
3743 @code{@value{AS}} occasionlly does strange things to @samp{.word} directives.
3744 Directives of the form @samp{.word sym1-sym2} are often emitted by
3745 compilers as part of jump tables. Therefore, when @code{@value{AS}} assembles a
3746 directive of the form @samp{.word sym1-sym2}, and the difference between
3747 @code{sym1} and @code{sym2} does not fit in 16 bits, @code{@value{AS}}
3748 creates a @dfn{secondary jump table}, immediately before the next label.
3749 This secondary jump table is preceded by a short-jump to the
3750 first byte after the secondary table. This short-jump prevents the flow
3751 of control from accidentally falling into the new table. Inside the
3752 table is a long-jump to @code{sym2}. The original @samp{.word}
3753 contains @code{sym1} minus the address of the long-jump to
3756 If there were several occurrences of @samp{.word sym1-sym2} before the
3757 secondary jump table, all of them are adjusted. If there was a
3758 @samp{.word sym3-sym4}, that also did not fit in sixteen bits, a
3759 long-jump to @code{sym4} is included in the secondary jump table,
3760 and the @code{.word} directives are adjusted to contain @code{sym3}
3761 minus the address of the long-jump to @code{sym4}; and so on, for as many
3762 entries in the original jump table as necessary.
3765 @emph{This feature may be disabled by compiling @code{@value{AS}} with the
3766 @samp{-DWORKING_DOT_WORD} option.} This feature is likely to confuse
3767 assembly language programmers.
3770 @c end DIFF-TBL-KLUGE
3773 @section Deprecated Directives
3775 @cindex deprecated directives
3776 @cindex obsolescent directives
3777 One day these directives won't work.
3778 They are included for compatibility with older assemblers.
3786 @node Machine Dependencies
3787 @chapter Machine Dependent Features
3789 @cindex machine dependencies
3790 The machine instruction sets are (almost by definition) different on
3791 each machine where @code{@value{AS}} runs. Floating point representations
3792 vary as well, and @code{@value{AS}} often supports a few additional
3793 directives or command-line options for compatibility with other
3794 assemblers on a particular platform. Finally, some versions of
3795 @code{@value{AS}} support special pseudo-instructions for branch
3798 This chapter discusses most of these differences, though it does not
3799 include details on any machine's instruction set. For details on that
3800 subject, see the hardware manufacturer's manual.
3804 * Vax-Dependent:: VAX Dependent Features
3807 * AMD29K-Dependent:: AMD 29K Dependent Features
3810 * H8/300-Dependent:: Hitachi H8/300 Dependent Features
3813 * H8/500-Dependent:: Hitachi H8/500 Dependent Features
3816 * HPPA-Dependent:: HPPA Dependent Features
3819 * SH-Dependent:: Hitachi SH Dependent Features
3822 * i960-Dependent:: Intel 80960 Dependent Features
3825 * M68K-Dependent:: M680x0 Dependent Features
3828 * Sparc-Dependent:: SPARC Dependent Features
3831 * Z8000-Dependent:: Z8000 Dependent Features
3834 * MIPS-Dependent:: MIPS Dependent Features
3837 * i386-Dependent:: 80386 Dependent Features
3844 @c The following major nodes are *sections* in the GENERIC version, *chapters*
3845 @c in single-cpu versions. This is mainly achieved by @lowersections. There is a
3846 @c peculiarity: to preserve cross-references, there must be a node called
3847 @c "Machine Dependencies". Hence the conditional nodenames in each
3848 @c major node below. Node defaulting in makeinfo requires adjacency of
3849 @c node and sectioning commands; hence the repetition of @chapter BLAH
3850 @c in both conditional blocks.
3855 @chapter VAX Dependent Features
3860 @node Machine Dependencies
3861 @chapter VAX Dependent Features
3867 * Vax-Opts:: VAX Command-Line Options
3868 * VAX-float:: VAX Floating Point
3869 * VAX-directives:: Vax Machine Directives
3870 * VAX-opcodes:: VAX Opcodes
3871 * VAX-branch:: VAX Branch Improvement
3872 * VAX-operands:: VAX Operands
3873 * VAX-no:: Not Supported on VAX
3878 @section VAX Command-Line Options
3880 @cindex command-line options ignored, VAX
3881 @cindex VAX command-line options ignored
3882 The Vax version of @code{@value{AS}} accepts any of the following options,
3883 gives a warning message that the option was ignored and proceeds.
3884 These options are for compatibility with scripts designed for other
3885 people's assemblers.
3888 @item @code{-D} (Debug)
3889 @itemx @code{-S} (Symbol Table)
3890 @itemx @code{-T} (Token Trace)
3891 @cindex @code{-D}, ignored on VAX
3892 @cindex @code{-S}, ignored on VAX
3893 @cindex @code{-T}, ignored on VAX
3894 These are obsolete options used to debug old assemblers.
3896 @item @code{-d} (Displacement size for JUMPs)
3897 @cindex @code{-d}, VAX option
3898 This option expects a number following the @samp{-d}. Like options
3899 that expect filenames, the number may immediately follow the
3900 @samp{-d} (old standard) or constitute the whole of the command line
3901 argument that follows @samp{-d} (@sc{gnu} standard).
3903 @item @code{-V} (Virtualize Interpass Temporary File)
3904 @cindex @code{-V}, redundant on VAX
3905 Some other assemblers use a temporary file. This option
3906 commanded them to keep the information in active memory rather
3907 than in a disk file. @code{@value{AS}} always does this, so this
3908 option is redundant.
3910 @item @code{-J} (JUMPify Longer Branches)
3911 @cindex @code{-J}, ignored on VAX
3912 Many 32-bit computers permit a variety of branch instructions
3913 to do the same job. Some of these instructions are short (and
3914 fast) but have a limited range; others are long (and slow) but
3915 can branch anywhere in virtual memory. Often there are 3
3916 flavors of branch: short, medium and long. Some other
3917 assemblers would emit short and medium branches, unless told by
3918 this option to emit short and long branches.
3920 @item @code{-t} (Temporary File Directory)
3921 @cindex @code{-t}, ignored on VAX
3922 Some other assemblers may use a temporary file, and this option
3923 takes a filename being the directory to site the temporary
3924 file. Since @code{@value{AS}} does not use a temporary disk file, this
3925 option makes no difference. @samp{-t} needs exactly one
3929 @cindex VMS (VAX) options
3930 @cindex options for VAX/VMS
3931 @cindex VAX/VMS options
3932 @cindex @code{-h} option, VAX/VMS
3933 @cindex @code{-+} option, VAX/VMS
3934 @cindex Vax-11 C compatibility
3935 @cindex symbols with lowercase, VAX/VMS
3936 @c FIXME! look into "I think" below, correct if needed, delete.
3937 The Vax version of the assembler accepts two options when
3938 compiled for VMS. They are @samp{-h}, and @samp{-+}. The
3939 @samp{-h} option prevents @code{@value{AS}} from modifying the
3940 symbol-table entries for symbols that contain lowercase
3941 characters (I think). The @samp{-+} option causes @code{@value{AS}} to
3942 print warning messages if the FILENAME part of the object file,
3943 or any symbol name is larger than 31 characters. The @samp{-+}
3944 option also inserts some code following the @samp{_main}
3945 symbol so that the object file is compatible with Vax-11
3949 @section VAX Floating Point
3951 @cindex VAX floating point
3952 @cindex floating point, VAX
3953 Conversion of flonums to floating point is correct, and
3954 compatible with previous assemblers. Rounding is
3955 towards zero if the remainder is exactly half the least significant bit.
3957 @code{D}, @code{F}, @code{G} and @code{H} floating point formats
3960 Immediate floating literals (@emph{e.g.} @samp{S`$6.9})
3961 are rendered correctly. Again, rounding is towards zero in the
3964 @cindex @code{float} directive, VAX
3965 @cindex @code{double} directive, VAX
3966 The @code{.float} directive produces @code{f} format numbers.
3967 The @code{.double} directive produces @code{d} format numbers.
3969 @node VAX-directives
3970 @section Vax Machine Directives
3972 @cindex machine directives, VAX
3973 @cindex VAX machine directives
3974 The Vax version of the assembler supports four directives for
3975 generating Vax floating point constants. They are described in the
3978 @cindex wide floating point directives, VAX
3981 @cindex @code{dfloat} directive, VAX
3982 This expects zero or more flonums, separated by commas, and
3983 assembles Vax @code{d} format 64-bit floating point constants.
3986 @cindex @code{ffloat} directive, VAX
3987 This expects zero or more flonums, separated by commas, and
3988 assembles Vax @code{f} format 32-bit floating point constants.
3991 @cindex @code{gfloat} directive, VAX
3992 This expects zero or more flonums, separated by commas, and
3993 assembles Vax @code{g} format 64-bit floating point constants.
3996 @cindex @code{hfloat} directive, VAX
3997 This expects zero or more flonums, separated by commas, and
3998 assembles Vax @code{h} format 128-bit floating point constants.
4003 @section VAX Opcodes
4005 @cindex VAX opcode mnemonics
4006 @cindex opcode mnemonics, VAX
4007 @cindex mnemonics for opcodes, VAX
4008 All DEC mnemonics are supported. Beware that @code{case@dots{}}
4009 instructions have exactly 3 operands. The dispatch table that
4010 follows the @code{case@dots{}} instruction should be made with
4011 @code{.word} statements. This is compatible with all unix
4012 assemblers we know of.
4015 @section VAX Branch Improvement
4017 @cindex VAX branch improvement
4018 @cindex branch improvement, VAX
4019 @cindex pseudo-ops for branch, VAX
4020 Certain pseudo opcodes are permitted. They are for branch
4021 instructions. They expand to the shortest branch instruction that
4022 reaches the target. Generally these mnemonics are made by
4023 substituting @samp{j} for @samp{b} at the start of a DEC mnemonic.
4024 This feature is included both for compatibility and to help
4025 compilers. If you do not need this feature, avoid these
4026 opcodes. Here are the mnemonics, and the code they can expand into.
4030 @samp{Jsb} is already an instruction mnemonic, so we chose @samp{jbsb}.
4032 @item (byte displacement)
4034 @item (word displacement)
4036 @item (long displacement)
4041 Unconditional branch.
4043 @item (byte displacement)
4045 @item (word displacement)
4047 @item (long displacement)
4051 @var{COND} may be any one of the conditional branches
4052 @code{neq}, @code{nequ}, @code{eql}, @code{eqlu}, @code{gtr},
4053 @code{geq}, @code{lss}, @code{gtru}, @code{lequ}, @code{vc}, @code{vs},
4054 @code{gequ}, @code{cc}, @code{lssu}, @code{cs}.
4055 @var{COND} may also be one of the bit tests
4056 @code{bs}, @code{bc}, @code{bss}, @code{bcs}, @code{bsc}, @code{bcc},
4057 @code{bssi}, @code{bcci}, @code{lbs}, @code{lbc}.
4058 @var{NOTCOND} is the opposite condition to @var{COND}.
4060 @item (byte displacement)
4061 @kbd{b@var{COND} @dots{}}
4062 @item (word displacement)
4063 @kbd{b@var{NOTCOND} foo ; brw @dots{} ; foo:}
4064 @item (long displacement)
4065 @kbd{b@var{NOTCOND} foo ; jmp @dots{} ; foo:}
4068 @var{X} may be one of @code{b d f g h l w}.
4070 @item (word displacement)
4071 @kbd{@var{OPCODE} @dots{}}
4072 @item (long displacement)
4074 @var{OPCODE} @dots{}, foo ;
4081 @var{YYY} may be one of @code{lss leq}.
4083 @var{ZZZ} may be one of @code{geq gtr}.
4085 @item (byte displacement)
4086 @kbd{@var{OPCODE} @dots{}}
4087 @item (word displacement)
4089 @var{OPCODE} @dots{}, foo ;
4091 foo: brw @var{destination} ;
4094 @item (long displacement)
4096 @var{OPCODE} @dots{}, foo ;
4098 foo: jmp @var{destination} ;
4107 @item (byte displacement)
4108 @kbd{@var{OPCODE} @dots{}}
4109 @item (word displacement)
4111 @var{OPCODE} @dots{}, foo ;
4113 foo: brw @var{destination} ;
4116 @item (long displacement)
4118 @var{OPCODE} @dots{}, foo ;
4120 foo: jmp @var{destination} ;
4127 @section VAX Operands
4129 @cindex VAX operand notation
4130 @cindex operand notation, VAX
4131 @cindex immediate character, VAX
4132 @cindex VAX immediate character
4133 The immediate character is @samp{$} for Unix compatibility, not
4134 @samp{#} as DEC writes it.
4136 @cindex indirect character, VAX
4137 @cindex VAX indirect character
4138 The indirect character is @samp{*} for Unix compatibility, not
4139 @samp{@@} as DEC writes it.
4141 @cindex displacement sizing character, VAX
4142 @cindex VAX displacement sizing character
4143 The displacement sizing character is @samp{`} (an accent grave) for
4144 Unix compatibility, not @samp{^} as DEC writes it. The letter
4145 preceding @samp{`} may have either case. @samp{G} is not
4146 understood, but all other letters (@code{b i l s w}) are understood.
4148 @cindex register names, VAX
4149 @cindex VAX register names
4150 Register names understood are @code{r0 r1 r2 @dots{} r15 ap fp sp
4151 pc}. Upper and lower case letters are equivalent.
4158 Any expression is permitted in an operand. Operands are comma
4161 @c There is some bug to do with recognizing expressions
4162 @c in operands, but I forget what it is. It is
4163 @c a syntax clash because () is used as an address mode
4164 @c and to encapsulate sub-expressions.
4167 @section Not Supported on VAX
4169 @cindex VAX bitfields not supported
4170 @cindex bitfields, not supported on VAX
4171 Vax bit fields can not be assembled with @code{@value{AS}}. Someone
4172 can add the required code if they really need it.
4178 @node AMD29K-Dependent
4179 @chapter AMD 29K Dependent Features
4182 @node Machine Dependencies
4183 @chapter AMD 29K Dependent Features
4186 @cindex AMD 29K support
4189 * AMD29K Options:: Options
4190 * AMD29K Syntax:: Syntax
4191 * AMD29K Floating Point:: Floating Point
4192 * AMD29K Directives:: AMD 29K Machine Directives
4193 * AMD29K Opcodes:: Opcodes
4196 @node AMD29K Options
4198 @cindex AMD 29K options (none)
4199 @cindex options for AMD29K (none)
4200 @code{@value{AS}} has no additional command-line options for the AMD
4206 * AMD29K-Chars:: Special Characters
4207 * AMD29K-Regs:: Register Names
4211 @subsection Special Characters
4213 @cindex line comment character, AMD 29K
4214 @cindex AMD 29K line comment character
4215 @samp{;} is the line comment character.
4217 @cindex line separator, AMD 29K
4218 @cindex AMD 29K line separator
4219 @cindex statement separator, AMD 29K
4220 @cindex AMD 29K statement separator
4221 @samp{@@} can be used instead of a newline to separate statements.
4223 @cindex identifiers, AMD 29K
4224 @cindex AMD 29K identifiers
4225 The character @samp{?} is permitted in identifiers (but may not begin
4229 @subsection Register Names
4231 @cindex AMD 29K register names
4232 @cindex register names, AMD 29K
4233 General-purpose registers are represented by predefined symbols of the
4234 form @samp{GR@var{nnn}} (for global registers) or @samp{LR@var{nnn}}
4235 (for local registers), where @var{nnn} represents a number between
4236 @code{0} and @code{127}, written with no leading zeros. The leading
4237 letters may be in either upper or lower case; for example, @samp{gr13}
4238 and @samp{LR7} are both valid register names.
4240 You may also refer to general-purpose registers by specifying the
4241 register number as the result of an expression (prefixed with @samp{%%}
4242 to flag the expression as a register number):
4247 ---where @var{expression} must be an absolute expression evaluating to a
4248 number between @code{0} and @code{255}. The range [0, 127] refers to
4249 global registers, and the range [128, 255] to local registers.
4251 @cindex special purpose registers, AMD 29K
4252 @cindex AMD 29K special purpose registers
4253 @cindex protected registers, AMD 29K
4254 @cindex AMD 29K protected registers
4255 In addition, @code{@value{AS}} understands the following protected
4256 special-purpose register names for the AMD 29K family:
4266 These unprotected special-purpose register names are also recognized:
4274 @node AMD29K Floating Point
4275 @section Floating Point
4277 @cindex floating point, AMD 29K (@sc{ieee})
4278 @cindex AMD 29K floating point (@sc{ieee})
4279 The AMD 29K family uses @sc{ieee} floating-point numbers.
4281 @node AMD29K Directives
4282 @section AMD 29K Machine Directives
4284 @cindex machine directives, AMD 29K
4285 @cindex AMD 29K machine directives
4287 @item .block @var{size} , @var{fill}
4288 @cindex @code{block} directive, AMD 29K
4289 This directive emits @var{size} bytes, each of value @var{fill}. Both
4290 @var{size} and @var{fill} are absolute expressions. If the comma
4291 and @var{fill} are omitted, @var{fill} is assumed to be zero.
4293 In other versions of the @sc{gnu} assembler, this directive is called
4299 @cindex @code{cputype} directive, AMD 29K
4300 This directive is ignored; it is accepted for compatibility with other
4304 @cindex @code{file} directive, AMD 29K
4305 This directive is ignored; it is accepted for compatibility with other
4309 @emph{Warning:} in other versions of the @sc{gnu} assembler, @code{.file} is
4310 used for the directive called @code{.app-file} in the AMD 29K support.
4314 @cindex @code{line} directive, AMD 29K
4315 This directive is ignored; it is accepted for compatibility with other
4319 @c since we're ignoring .lsym...
4320 @item .reg @var{symbol}, @var{expression}
4321 @cindex @code{reg} directive, AMD 29K
4322 @code{.reg} has the same effect as @code{.lsym}; @pxref{Lsym,,@code{.lsym}}.
4326 @cindex @code{sect} directive, AMD 29K
4327 This directive is ignored; it is accepted for compatibility with other
4330 @item .use @var{section name}
4331 @cindex @code{use} directive, AMD 29K
4332 Establishes the section and subsection for the following code;
4333 @var{section name} may be one of @code{.text}, @code{.data},
4334 @code{.data1}, or @code{.lit}. With one of the first three @var{section
4335 name} options, @samp{.use} is equivalent to the machine directive
4336 @var{section name}; the remaining case, @samp{.use .lit}, is the same as
4340 @node AMD29K Opcodes
4343 @cindex AMD 29K opcodes
4344 @cindex opcodes for AMD 29K
4345 @code{@value{AS}} implements all the standard AMD 29K opcodes. No
4346 additional pseudo-instructions are needed on this family.
4348 For information on the 29K machine instruction set, see @cite{Am29000
4349 User's Manual}, Advanced Micro Devices, Inc.
4354 @node Machine Dependencies
4355 @chapter Machine Dependent Features
4357 The machine instruction sets are different on each Hitachi chip family,
4358 and there are also some syntax differences among the families. This
4359 chapter describes the specific @code{@value{AS}} features for each
4363 * H8/300-Dependent:: Hitachi H8/300 Dependent Features
4364 * H8/500-Dependent:: Hitachi H8/500 Dependent Features
4365 * SH-Dependent:: Hitachi SH Dependent Features
4375 @node H8/300-Dependent
4376 @chapter H8/300 Dependent Features
4378 @cindex H8/300 support
4380 * H8/300 Options:: Options
4381 * H8/300 Syntax:: Syntax
4382 * H8/300 Floating Point:: Floating Point
4383 * H8/300 Directives:: H8/300 Machine Directives
4384 * H8/300 Opcodes:: Opcodes
4387 @node H8/300 Options
4390 @cindex H8/300 options (none)
4391 @cindex options, H8/300 (none)
4392 @code{@value{AS}} has no additional command-line options for the Hitachi
4398 * H8/300-Chars:: Special Characters
4399 * H8/300-Regs:: Register Names
4400 * H8/300-Addressing:: Addressing Modes
4404 @subsection Special Characters
4406 @cindex line comment character, H8/300
4407 @cindex H8/300 line comment character
4408 @samp{;} is the line comment character.
4410 @cindex line separator, H8/300
4411 @cindex statement separator, H8/300
4412 @cindex H8/300 line separator
4413 @samp{$} can be used instead of a newline to separate statements.
4414 Therefore @emph{you may not use @samp{$} in symbol names} on the H8/300.
4417 @subsection Register Names
4419 @cindex H8/300 registers
4420 @cindex register names, H8/300
4421 You can use predefined symbols of the form @samp{r@var{n}h} and
4422 @samp{r@var{n}l} to refer to the H8/300 registers as sixteen 8-bit
4423 general-purpose registers. @var{n} is a digit from @samp{0} to
4424 @samp{7}); for instance, both @samp{r0h} and @samp{r7l} are valid
4427 You can also use the eight predefined symbols @samp{r@var{n}} to refer
4428 to the H8/300 registers as 16-bit registers (you must use this form for
4431 On the H8/300H, you can also use the eight predefined symbols
4432 @samp{er@var{n}} (@samp{er0} @dots{} @samp{er7}) to refer to the 32-bit
4433 general purpose registers.
4435 The two control registers are called @code{pc} (program counter; a
4436 16-bit register, except on the H8/300H where it is 24 bits) and
4437 @code{ccr} (condition code register; an 8-bit register). @code{r7} is
4438 used as the stack pointer, and can also be called @code{sp}.
4440 @node H8/300-Addressing
4441 @subsection Addressing Modes
4443 @cindex addressing modes, H8/300
4444 @cindex H8/300 addressing modes
4445 @value{AS} understands the following addressing modes for the H8/300:
4453 @item @@(@var{d}, r@var{n})
4454 @itemx @@(@var{d}:16, r@var{n})
4455 @itemx @@(@var{d}:24, r@var{n})
4456 Register indirect: 16-bit or 24-bit displacement @var{d} from register
4457 @var{n}. (24-bit displacements are only meaningful on the H8/300H.)
4460 Register indirect with post-increment
4463 Register indirect with pre-decrement
4465 @item @code{@@}@var{aa}
4466 @itemx @code{@@}@var{aa}:8
4467 @itemx @code{@@}@var{aa}:16
4468 @itemx @code{@@}@var{aa}:24
4469 Absolute address @code{aa}. (The address size @samp{:24} only makes
4470 sense on the H8/300H.)
4476 Immediate data @var{xx}. You may specify the @samp{:8}, @samp{:16}, or
4477 @samp{:32} for clarity, if you wish; but @code{@value{AS}} neither
4478 requires this nor uses it---the data size required is taken from
4481 @item @code{@@}@code{@@}@var{aa}
4482 @itemx @code{@@}@code{@@}@var{aa}:8
4483 Memory indirect. You may specify the @samp{:8} for clarity, if you
4484 wish; but @code{@value{AS}} neither requires this nor uses it.
4487 @node H8/300 Floating Point
4488 @section Floating Point
4490 @cindex floating point, H8/300 (@sc{ieee})
4491 @cindex H8/300 floating point (@sc{ieee})
4492 The H8/300 family has no hardware floating point, but the @code{.float}
4493 directive generates @sc{ieee} floating-point numbers for compatibility
4494 with other development tools.
4497 @node H8/300 Directives
4498 @section H8/300 Machine Directives
4500 @cindex H8/300 machine directives (none)
4501 @cindex machine directives, H8/300 (none)
4502 @cindex @code{word} directive, H8/300
4503 @cindex @code{int} directive, H8/300
4504 @code{@value{AS}} has only one machine-dependent directive for the
4508 @cindex H8/300H, assembling for
4510 Recognize and emit additional instructions for the H8/300H variant, and
4511 also make @code{.int} emit 32-bit numbers rather than the usual (16-bit)
4512 for the H8/300 family.
4515 On the H8/300 family (including the H8/300H) @samp{.word} directives
4516 generate 16-bit numbers.
4518 @node H8/300 Opcodes
4521 @cindex H8/300 opcode summary
4522 @cindex opcode summary, H8/300
4523 @cindex mnemonics, H8/300
4524 @cindex instruction summary, H8/300
4525 For detailed information on the H8/300 machine instruction set, see
4526 @cite{H8/300 Series Programming Manual} (Hitachi ADE--602--025). For
4527 information specific to the H8/300H, see @cite{H8/300H Series
4528 Programming Manual} (Hitachi).
4530 @code{@value{AS}} implements all the standard H8/300 opcodes. No additional
4531 pseudo-instructions are needed on this family.
4534 @c this table, due to the multi-col faking and hardcoded order, looks silly
4535 @c except in smallbook. See comments below "@set SMALL" near top of this file.
4537 The following table summarizes the H8/300 opcodes, and their arguments.
4538 Entries marked @samp{*} are opcodes used only on the H8/300H.
4541 @c Using @group seems to use the normal baselineskip, not the smallexample
4542 @c baselineskip; looks approx doublespaced.
4544 Rs @r{source register}
4545 Rd @r{destination register}
4546 abs @r{absolute address}
4547 imm @r{immediate data}
4548 disp:N @r{N-bit displacement from a register}
4549 pcrel:N @r{N-bit displacement relative to program counter}
4551 add.b #imm,rd * andc #imm,ccr
4552 add.b rs,rd band #imm,rd
4553 add.w rs,rd band #imm,@@rd
4554 * add.w #imm,rd band #imm,@@abs:8
4555 * add.l rs,rd bra pcrel:8
4556 * add.l #imm,rd * bra pcrel:16
4557 adds #imm,rd bt pcrel:8
4558 addx #imm,rd * bt pcrel:16
4559 addx rs,rd brn pcrel:8
4560 and.b #imm,rd * brn pcrel:16
4561 and.b rs,rd bf pcrel:8
4562 * and.w rs,rd * bf pcrel:16
4563 * and.w #imm,rd bhi pcrel:8
4564 * and.l #imm,rd * bhi pcrel:16
4565 * and.l rs,rd bls pcrel:8
4567 * bls pcrel:16 bld #imm,rd
4568 bcc pcrel:8 bld #imm,@@rd
4569 * bcc pcrel:16 bld #imm,@@abs:8
4570 bhs pcrel:8 bnot #imm,rd
4571 * bhs pcrel:16 bnot #imm,@@rd
4572 bcs pcrel:8 bnot #imm,@@abs:8
4573 * bcs pcrel:16 bnot rs,rd
4574 blo pcrel:8 bnot rs,@@rd
4575 * blo pcrel:16 bnot rs,@@abs:8
4576 bne pcrel:8 bor #imm,rd
4577 * bne pcrel:16 bor #imm,@@rd
4578 beq pcrel:8 bor #imm,@@abs:8
4579 * beq pcrel:16 bset #imm,rd
4580 bvc pcrel:8 bset #imm,@@rd
4581 * bvc pcrel:16 bset #imm,@@abs:8
4582 bvs pcrel:8 bset rs,rd
4583 * bvs pcrel:16 bset rs,@@rd
4584 bpl pcrel:8 bset rs,@@abs:8
4585 * bpl pcrel:16 bsr pcrel:8
4586 bmi pcrel:8 bsr pcrel:16
4587 * bmi pcrel:16 bst #imm,rd
4588 bge pcrel:8 bst #imm,@@rd
4589 * bge pcrel:16 bst #imm,@@abs:8
4590 blt pcrel:8 btst #imm,rd
4591 * blt pcrel:16 btst #imm,@@rd
4592 bgt pcrel:8 btst #imm,@@abs:8
4593 * bgt pcrel:16 btst rs,rd
4594 ble pcrel:8 btst rs,@@rd
4595 * ble pcrel:16 btst rs,@@abs:8
4596 bclr #imm,rd bxor #imm,rd
4597 bclr #imm,@@rd bxor #imm,@@rd
4598 bclr #imm,@@abs:8 bxor #imm,@@abs:8
4599 bclr rs,rd cmp.b #imm,rd
4600 bclr rs,@@rd cmp.b rs,rd
4601 bclr rs,@@abs:8 cmp.w rs,rd
4602 biand #imm,rd cmp.w rs,rd
4603 biand #imm,@@rd * cmp.w #imm,rd
4604 biand #imm,@@abs:8 * cmp.l #imm,rd
4605 bild #imm,rd * cmp.l rs,rd
4606 bild #imm,@@rd daa rs
4607 bild #imm,@@abs:8 das rs
4608 bior #imm,rd dec.b rs
4609 bior #imm,@@rd * dec.w #imm,rd
4610 bior #imm,@@abs:8 * dec.l #imm,rd
4611 bist #imm,rd divxu.b rs,rd
4612 bist #imm,@@rd * divxu.w rs,rd
4613 bist #imm,@@abs:8 * divxs.b rs,rd
4614 bixor #imm,rd * divxs.w rs,rd
4615 bixor #imm,@@rd eepmov
4616 bixor #imm,@@abs:8 * eepmovw
4618 * exts.w rd mov.w rs,@@abs:16
4619 * exts.l rd * mov.l #imm,rd
4620 * extu.w rd * mov.l rs,rd
4621 * extu.l rd * mov.l @@rs,rd
4622 inc rs * mov.l @@(disp:16,rs),rd
4623 * inc.w #imm,rd * mov.l @@(disp:24,rs),rd
4624 * inc.l #imm,rd * mov.l @@rs+,rd
4625 jmp @@rs * mov.l @@abs:16,rd
4626 jmp abs * mov.l @@abs:24,rd
4627 jmp @@@@abs:8 * mov.l rs,@@rd
4628 jsr @@rs * mov.l rs,@@(disp:16,rd)
4629 jsr abs * mov.l rs,@@(disp:24,rd)
4630 jsr @@@@abs:8 * mov.l rs,@@-rd
4631 ldc #imm,ccr * mov.l rs,@@abs:16
4632 ldc rs,ccr * mov.l rs,@@abs:24
4633 * ldc @@abs:16,ccr movfpe @@abs:16,rd
4634 * ldc @@abs:24,ccr movtpe rs,@@abs:16
4635 * ldc @@(disp:16,rs),ccr mulxu.b rs,rd
4636 * ldc @@(disp:24,rs),ccr * mulxu.w rs,rd
4637 * ldc @@rs+,ccr * mulxs.b rs,rd
4638 * ldc @@rs,ccr * mulxs.w rs,rd
4639 * mov.b @@(disp:24,rs),rd neg.b rs
4640 * mov.b rs,@@(disp:24,rd) * neg.w rs
4641 mov.b @@abs:16,rd * neg.l rs
4643 mov.b @@abs:8,rd not.b rs
4644 mov.b rs,@@abs:8 * not.w rs
4645 mov.b rs,rd * not.l rs
4646 mov.b #imm,rd or.b #imm,rd
4647 mov.b @@rs,rd or.b rs,rd
4648 mov.b @@(disp:16,rs),rd * or.w #imm,rd
4649 mov.b @@rs+,rd * or.w rs,rd
4650 mov.b @@abs:8,rd * or.l #imm,rd
4651 mov.b rs,@@rd * or.l rs,rd
4652 mov.b rs,@@(disp:16,rd) orc #imm,ccr
4653 mov.b rs,@@-rd pop.w rs
4654 mov.b rs,@@abs:8 * pop.l rs
4655 mov.w rs,@@rd push.w rs
4656 * mov.w @@(disp:24,rs),rd * push.l rs
4657 * mov.w rs,@@(disp:24,rd) rotl.b rs
4658 * mov.w @@abs:24,rd * rotl.w rs
4659 * mov.w rs,@@abs:24 * rotl.l rs
4660 mov.w rs,rd rotr.b rs
4661 mov.w #imm,rd * rotr.w rs
4662 mov.w @@rs,rd * rotr.l rs
4663 mov.w @@(disp:16,rs),rd rotxl.b rs
4664 mov.w @@rs+,rd * rotxl.w rs
4665 mov.w @@abs:16,rd * rotxl.l rs
4666 mov.w rs,@@(disp:16,rd) rotxr.b rs
4667 mov.w rs,@@-rd * rotxr.w rs
4669 * rotxr.l rs * stc ccr,@@(disp:24,rd)
4671 rte * stc ccr,@@abs:16
4672 rts * stc ccr,@@abs:24
4673 shal.b rs sub.b rs,rd
4674 * shal.w rs sub.w rs,rd
4675 * shal.l rs * sub.w #imm,rd
4676 shar.b rs * sub.l rs,rd
4677 * shar.w rs * sub.l #imm,rd
4678 * shar.l rs subs #imm,rd
4679 shll.b rs subx #imm,rd
4680 * shll.w rs subx rs,rd
4681 * shll.l rs * trapa #imm
4682 shlr.b rs xor #imm,rd
4683 * shlr.w rs xor rs,rd
4684 * shlr.l rs * xor.w #imm,rd
4686 stc ccr,rd * xor.l #imm,rd
4687 * stc ccr,@@rs * xor.l rs,rd
4688 * stc ccr,@@(disp:16,rd) xorc #imm,ccr
4692 @cindex size suffixes, H8/300
4693 @cindex H8/300 size suffixes
4694 Four H8/300 instructions (@code{add}, @code{cmp}, @code{mov},
4695 @code{sub}) are defined with variants using the suffixes @samp{.b},
4696 @samp{.w}, and @samp{.l} to specify the size of a memory operand.
4697 @code{@value{AS}} supports these suffixes, but does not require them;
4698 since one of the operands is always a register, @code{@value{AS}} can
4699 deduce the correct size.
4701 For example, since @code{r0} refers to a 16-bit register,
4704 @exdent is equivalent to
4708 If you use the size suffixes, @code{@value{AS}} issues a warning when
4709 the suffix and the register size do not match.
4714 @node H8/500-Dependent
4715 @chapter H8/500 Dependent Features
4717 @cindex H8/500 support
4719 * H8/500 Options:: Options
4720 * H8/500 Syntax:: Syntax
4721 * H8/500 Floating Point:: Floating Point
4722 * H8/500 Directives:: H8/500 Machine Directives
4723 * H8/500 Opcodes:: Opcodes
4726 @node H8/500 Options
4729 @cindex H8/500 options (none)
4730 @cindex options, H8/500 (none)
4731 @code{@value{AS}} has no additional command-line options for the Hitachi
4738 * H8/500-Chars:: Special Characters
4739 * H8/500-Regs:: Register Names
4740 * H8/500-Addressing:: Addressing Modes
4744 @subsection Special Characters
4746 @cindex line comment character, H8/500
4747 @cindex H8/500 line comment character
4748 @samp{!} is the line comment character.
4750 @cindex line separator, H8/500
4751 @cindex statement separator, H8/500
4752 @cindex H8/500 line separator
4753 @samp{;} can be used instead of a newline to separate statements.
4755 @cindex symbol names, @samp{$} in
4756 @cindex @code{$} in symbol names
4757 Since @samp{$} has no special meaning, you may use it in symbol names.
4760 @subsection Register Names
4762 @cindex H8/500 registers
4763 @cindex registers, H8/500
4764 You can use the predefined symbols @samp{r0}, @samp{r1}, @samp{r2},
4765 @samp{r3}, @samp{r4}, @samp{r5}, @samp{r6}, and @samp{r7} to refer to
4766 the H8/500 registers.
4768 The H8/500 also has these control registers:
4790 condition code register
4793 All registers are 16 bits long. To represent 32 bit numbers, use two
4794 adjacent registers; for distant memory addresses, use one of the segment
4795 pointers (@code{cp} for the program counter; @code{dp} for
4796 @code{r0}--@code{r3}; @code{ep} for @code{r4} and @code{r5}; and
4797 @code{tp} for @code{r6} and @code{r7}.
4799 @node H8/500-Addressing
4800 @subsection Addressing Modes
4802 @cindex addressing modes, H8/500
4803 @cindex H8/500 addressing modes
4804 @value{AS} understands the following addressing modes for the H8/500:
4812 @item @@(d:8, R@var{n})
4813 Register indirect with 8 bit signed displacement
4815 @item @@(d:16, R@var{n})
4816 Register indirect with 16 bit signed displacement
4819 Register indirect with pre-decrement
4822 Register indirect with post-increment
4825 8 bit absolute address
4828 16 bit absolute address
4837 @node H8/500 Floating Point
4838 @section Floating Point
4840 @cindex floating point, H8/500 (@sc{ieee})
4841 @cindex H8/500 floating point (@sc{ieee})
4842 The H8/500 family uses @sc{ieee} floating-point numbers.
4844 @node H8/500 Directives
4845 @section H8/500 Machine Directives
4847 @cindex H8/500 machine directives (none)
4848 @cindex machine directives, H8/500 (none)
4849 @cindex @code{word} directive, H8/500
4850 @cindex @code{int} directive, H8/500
4851 @code{@value{AS}} has no machine-dependent directives for the H8/500.
4852 However, on this platform the @samp{.int} and @samp{.word} directives
4853 generate 16-bit numbers.
4855 @node H8/500 Opcodes
4858 @cindex H8/500 opcode summary
4859 @cindex opcode summary, H8/500
4860 @cindex mnemonics, H8/500
4861 @cindex instruction summary, H8/500
4862 For detailed information on the H8/500 machine instruction set, see
4863 @cite{H8/500 Series Programming Manual} (Hitachi M21T001).
4865 @code{@value{AS}} implements all the standard H8/500 opcodes. No additional
4866 pseudo-instructions are needed on this family.
4869 @c this table, due to the multi-col faking and hardcoded order, looks silly
4870 @c except in smallbook. See comments below "@set SMALL" near top of this file.
4872 The following table summarizes H8/500 opcodes and their operands:
4874 @c Use @group if it ever works, instead of @page
4878 abs8 @r{8-bit absolute address}
4879 abs16 @r{16-bit absolute address}
4880 abs24 @r{24-bit absolute address}
4881 crb @r{@code{ccr}, @code{br}, @code{ep}, @code{dp}, @code{tp}, @code{dp}}
4882 disp8 @r{8-bit displacement}
4883 ea @r{@code{rn}, @code{@@rn}, @code{@@(d:8, rn)}, @code{@@(d:16, rn)},}
4884 @r{@code{@@-rn}, @code{@@rn+}, @code{@@aa:8}, @code{@@aa:16},}
4885 @r{@code{#xx:8}, @code{#xx:16}}
4886 ea_mem @r{@code{@@rn}, @code{@@(d:8, rn)}, @code{@@(d:16, rn)},}
4887 @r{@code{@@-rn}, @code{@@rn+}, @code{@@aa:8}, @code{@@aa:16}}
4888 ea_noimm @r{@code{rn}, @code{@@rn}, @code{@@(d:8, rn)}, @code{@@(d:16, rn)},}
4889 @r{@code{@@-rn}, @code{@@rn+}, @code{@@aa:8}, @code{@@aa:16}}
4891 imm4 @r{4-bit immediate data}
4892 imm8 @r{8-bit immediate data}
4893 imm16 @r{16-bit immediate data}
4894 pcrel8 @r{8-bit offset from program counter}
4895 pcrel16 @r{16-bit offset from program counter}
4896 qim @r{@code{-2}, @code{-1}, @code{1}, @code{2}}
4898 rs @r{a register distinct from rd}
4899 rlist @r{comma-separated list of registers in parentheses;}
4900 @r{register ranges @code{rd-rs} are allowed}
4901 sp @r{stack pointer (@code{r7})}
4902 sr @r{status register}
4903 sz @r{size; @samp{.b} or @samp{.w}. If omitted, default @samp{.w}}
4905 ldc[.b] ea,crb bcc[.w] pcrel16
4906 ldc[.w] ea,sr bcc[.b] pcrel8
4907 add[:q] sz qim,ea_noimm bhs[.w] pcrel16
4908 add[:g] sz ea,rd bhs[.b] pcrel8
4909 adds sz ea,rd bcs[.w] pcrel16
4910 addx sz ea,rd bcs[.b] pcrel8
4911 and sz ea,rd blo[.w] pcrel16
4912 andc[.b] imm8,crb blo[.b] pcrel8
4913 andc[.w] imm16,sr bne[.w] pcrel16
4915 bra[.w] pcrel16 beq[.w] pcrel16
4916 bra[.b] pcrel8 beq[.b] pcrel8
4917 bt[.w] pcrel16 bvc[.w] pcrel16
4918 bt[.b] pcrel8 bvc[.b] pcrel8
4919 brn[.w] pcrel16 bvs[.w] pcrel16
4920 brn[.b] pcrel8 bvs[.b] pcrel8
4921 bf[.w] pcrel16 bpl[.w] pcrel16
4922 bf[.b] pcrel8 bpl[.b] pcrel8
4923 bhi[.w] pcrel16 bmi[.w] pcrel16
4924 bhi[.b] pcrel8 bmi[.b] pcrel8
4925 bls[.w] pcrel16 bge[.w] pcrel16
4926 bls[.b] pcrel8 bge[.b] pcrel8
4928 blt[.w] pcrel16 mov[:g][.b] imm8,ea_mem
4929 blt[.b] pcrel8 mov[:g][.w] imm16,ea_mem
4930 bgt[.w] pcrel16 movfpe[.b] ea,rd
4931 bgt[.b] pcrel8 movtpe[.b] rs,ea_noimm
4932 ble[.w] pcrel16 mulxu sz ea,rd
4933 ble[.b] pcrel8 neg sz ea
4934 bclr sz imm4,ea_noimm nop
4935 bclr sz rs,ea_noimm not sz ea
4936 bnot sz imm4,ea_noimm or sz ea,rd
4937 bnot sz rs,ea_noimm orc[.b] imm8,crb
4938 bset sz imm4,ea_noimm orc[.w] imm16,sr
4939 bset sz rs,ea_noimm pjmp abs24
4940 bsr[.b] pcrel8 pjmp @@rd
4941 bsr[.w] pcrel16 pjsr abs24
4942 btst sz imm4,ea_noimm pjsr @@rd
4943 btst sz rs,ea_noimm prtd imm8
4944 clr sz ea prtd imm16
4945 cmp[:e][.b] imm8,rd prts
4946 cmp[:i][.w] imm16,rd rotl sz ea
4947 cmp[:g].b imm8,ea_noimm rotr sz ea
4948 cmp[:g][.w] imm16,ea_noimm rotxl sz ea
4949 Cmp[:g] sz ea,rd rotxr sz ea
4951 divxu sz ea,rd rtd imm16
4953 exts[.b] rd scb/f rs,pcrel8
4954 extu[.b] rd scb/ne rs,pcrel8
4955 jmp @@rd scb/eq rs,pcrel8
4956 jmp @@(imm8,rd) shal sz ea
4957 jmp @@(imm16,rd) shar sz ea
4958 jmp abs16 shll sz ea
4960 jsr @@(imm8,rd) sleep
4961 jsr @@(imm16,rd) stc[.b] crb,ea_noimm
4962 jsr abs16 stc[.w] sr,ea_noimm
4963 ldm @@sp+,(rlist) stm (rlist),@@-sp
4964 link fp,imm8 sub sz ea,rd
4965 link fp,imm16 subs sz ea,rd
4966 mov[:e][.b] imm8,rd subx sz ea,rd
4967 mov[:i][.w] imm16,rd swap[.b] rd
4968 mov[:l][.w] abs8,rd tas[.b] ea
4969 mov[:l].b abs8,rd trapa imm4
4970 mov[:s][.w] rs,abs8 trap/vs
4971 mov[:s].b rs,abs8 tst sz ea
4972 mov[:f][.w] @@(disp8,fp),rd unlk fp
4973 mov[:f][.w] rs,@@(disp8,fp) xch[.w] rs,rd
4974 mov[:f].b @@(disp8,fp),rd xor sz ea,rd
4975 mov[:f].b rs,@@(disp8,fp) xorc.b imm8,crb
4976 mov[:g] sz rs,ea_mem xorc.w imm16,sr
4984 @node HPPA-Dependent
4985 @chapter HPPA Dependent Features
4989 * HPPA Notes:: Notes
4990 * HPPA Options:: Options
4991 * HPPA Syntax:: Syntax
4992 * HPPA Floating Point:: Floating Point
4993 * HPPA Directives:: HPPA Machine Directives
4994 * HPPA Opcodes:: Opcodes
4999 As a back end for @sc{gnu} @sc{cc} @code{@value{AS}} has been throughly tested and should
5000 work extremely well. We have tested it only minimally on hand written assembly
5001 code and no one has tested it much on the assembly output from the HP
5004 The format of the debugging sections has changed since the original
5005 @code{@value{AS}} port (version 1.3X) was released; therefore,
5006 you must rebuild all HPPA objects and libraries with the new
5007 assembler so that you can debug the final executable.
5009 The HPPA @code{@value{AS}} port generates a small subset of the relocations
5010 available in the SOM and ELF object file formats. Additional relocation
5011 support will be added as it becomes necessary.
5015 @code{@value{AS}} has no machine-dependent command-line options for the HPPA.
5020 The assembler syntax closely follows the HPPA instruction set
5021 reference manual; assembler directives and general syntax closely follow the
5022 HPPA assembly language reference manual, with a few noteworthy differences.
5024 First, a colon may immediately follow a label definition. This is
5025 simply for compatibility with how most assembly language programmers
5028 Some obscure expression parsing problems may affect hand written code which
5029 uses the @code{spop} instructions, or code which makes significant
5030 use of the @code{!} line separator.
5032 @code{@value{AS}} is much less forgiving about missing arguments and other
5033 similar oversights than the HP assembler. @code{@value{AS}} notifies you
5034 of missing arguments as syntax errors; this is regarded as a feature, not a
5037 Finally, @code{@value{AS}} allows you to use an external symbol without
5038 explicitly importing the symbol. @emph{Warning:} in the future this will be
5039 an error for HPPA targets.
5041 Special characters for HPPA targets include:
5043 @samp{;} is the line comment character.
5045 @samp{!} can be used instead of a newline to separate statements.
5047 Since @samp{$} has no special meaning, you may use it in symbol names.
5049 @node HPPA Floating Point
5050 @section Floating Point
5051 @cindex floating point, HPPA (@sc{ieee})
5052 @cindex HPPA floating point (@sc{ieee})
5053 The HPPA family uses @sc{ieee} floating-point numbers.
5055 @node HPPA Directives
5056 @section HPPA Assembler Directives
5058 @code{@value{AS}} for the HPPA supports many additional directives for
5059 compatibility with the native assembler. This section describes them only
5060 briefly. For detailed information on HPPA-specific assembler directives, see
5061 @cite{HP9000 Series 800 Assembly Language Reference Manual} (HP 92432-90001).
5063 @cindex HPPA directives not supported
5064 @code{@value{AS}} does @emph{not} support the following assembler directives
5065 described in the HP manual:
5074 @cindex @code{.param} on HPPA
5075 Beyond those implemented for compatibility, @code{@value{AS}} supports one
5076 additional assembler directive for the HPPA: @code{.param}. It conveys
5077 register argument locations for static functions. Its syntax closely follows
5078 the @code{.export} directive.
5080 @cindex HPPA-only directives
5081 These are the additional directives in @code{@value{AS}} for the HPPA:
5084 @item .block @var{n}
5085 @itemx .blockz @var{n}
5086 Reserve @var{n} bytes of storage, and initialize them to zero.
5089 Mark the beginning of a procedure call. Only the special case with @emph{no
5090 arguments} is allowed.
5092 @item .callinfo [ @var{param}=@var{value}, @dots{} ] [ @var{flag}, @dots{} ]
5093 Specify a number of parameters and flags that define the environment for a
5096 @var{param} may be any of @samp{frame} (frame size), @samp{entry_gr} (end of
5097 general register range), @samp{entry_fr} (end of float register range),
5098 @samp{entry_sr} (end of space register range).
5100 The values for @var{flag} are @samp{calls} or @samp{caller} (proc has
5101 subroutines), @samp{no_calls} (proc does not call subroutines), @samp{save_rp}
5102 (preserve return pointer), @samp{save_sp} (proc preserves stack pointer),
5103 @samp{no_unwind} (do not unwind this proc), @samp{hpux_int} (proc is interrupt
5107 Assemble into the standard section called @samp{$TEXT$}, subsection
5111 @item .copyright "@var{string}"
5112 In the SOM object format, insert @var{string} into the object code, marked as a
5117 @item .copyright "@var{string}"
5118 In the ELF object format, insert @var{string} into the object code, marked as a
5123 Not yet supported; the assembler rejects programs containing this directive.
5126 Mark the beginning of a procedure.
5129 Mark the end of a procedure.
5131 @item .export @var{name} [ ,@var{typ} ] [ ,@var{param}=@var{r} ]
5132 Make a procedure @var{name} available to callers. @var{typ}, if present, must
5133 be one of @samp{absolute}, @samp{code} (ELF only, not SOM), @samp{data},
5134 @samp{entry}, @samp{data}, @samp{entry}, @samp{millicode}, @samp{plabel},
5135 @samp{pri_prog}, or @samp{sec_prog}.
5137 @var{param}, if present, provides either relocation information for the
5138 procedure arguments and result, or a privilege level. @var{param} may be
5139 @samp{argw@var{n}} (where @var{n} ranges from @code{0} to @code{3}, and
5140 indicates one of four one-word arguments); @samp{rtnval} (the procedure's
5141 result); or @samp{priv_lev} (privilege level). For arguments or the result,
5142 @var{r} specifies how to relocate, and must be one of @samp{no} (not
5143 relocatable), @samp{gr} (argument is in general register), @samp{fr} (in
5144 floating point register), or @samp{fu} (upper half of float register).
5145 For @samp{priv_lev}, @var{r} is an integer.
5148 Define a two-byte integer constant @var{n}; synonym for the portable
5149 @code{@value{AS}} directive @code{.short}.
5151 @item .import @var{name} [ ,@var{typ} ]
5152 Converse of @code{.export}; make a procedure available to call. The arguments
5153 use the same conventions as the first two arguments for @code{.export}.
5155 @item .label @var{name}
5156 Define @var{name} as a label for the current assembly location.
5159 Not yet supported; the assembler rejects programs containing this directive.
5161 @item .origin @var{lc}
5162 Advance location counter to @var{lc}. Synonym for the @code{@value{as}}
5163 portable directive @code{.org}.
5165 @item .param @var{name} [ ,@var{typ} ] [ ,@var{param}=@var{r} ]
5166 @c Not in HP manual; GNU HPPA extension
5167 Similar to @code{.export}, but used for static procedures.
5170 Use preceding the first statement of a procedure.
5173 Use following the last statement of a procedure.
5175 @item @var{label} .reg @var{expr}
5176 @c ?? Not in HP manual (Jan 1988 vn)
5177 Synonym for @code{.equ}; define @var{label} with the absolute expression
5178 @var{expr} as its value.
5180 @item .space @var{secname} [ ,@var{params} ]
5181 Switch to section @var{secname}, creating a new section by that name if
5182 necessary. You may only use @var{params} when creating a new section, not
5183 when switching to an existing one. @var{secname} may identify a section by
5184 number rather than by name.
5186 If specified, the list @var{params} declares attributes of the section,
5187 identified by keywords. The keywords recognized are @samp{spnum=@var{exp}}
5188 (identify this section by the number @var{exp}, an absolute expression),
5189 @samp{sort=@var{exp}} (order sections according to this sort key when linking;
5190 @var{exp} is an absolute expression), @samp{unloadable} (section contains no
5191 loadable data), @samp{notdefined} (this section defined elsewhere), and
5192 @samp{private} (data in this section not available to other programs).
5194 @item .spnum @var{secnam}
5195 @c ?? Not in HP manual (Jan 1988)
5196 Allocate four bytes of storage, and initialize them with the section number of
5197 the section named @var{secnam}. (You can define the section number with the
5198 HPPA @code{.space} directive.)
5200 @item .string "@var{str}"
5201 @cindex @code{string} directive on HPPA
5202 Copy the characters in the string @var{str} to the object file.
5203 @xref{Strings,,Strings}, for information on escape sequences you can use in
5204 @code{@value{AS}} strings.
5206 @emph{Warning!} The HPPA version of @code{.string} differs from the
5207 usual @code{@value{AS}} definition: it does @emph{not} write a zero byte
5208 after copying @var{str}.
5210 @item .stringz "@var{str}"
5211 Like @code{.string}, but appends a zero byte after copying @var{str} to object
5214 @item .subspa @var{name} [ ,@var{params} ]
5215 Similar to @code{.space}, but selects a subsection @var{name} within the
5216 current section. You may only specify @var{params} when you create a
5217 subsection (in the first instance of @code{.subspa} for this @var{name}).
5219 If specified, the list @var{params} declares attributes of the subsection,
5220 identified by keywords. The keywords recognized are @samp{quad=@var{expr}}
5221 (``quadrant'' for this subsection), @samp{align=@var{expr}} (alignment for
5222 beginning of this subsection; a power of two), @samp{access=@var{expr}} (value
5223 for ``access rights'' field), @samp{sort=@var{expr}} (sorting order for this
5224 subspace in link), @samp{code_only} (subsection contains only code),
5225 @samp{unloadable} (subsection cannot be loaded into memory), @samp{common}
5226 (subsection is common block), @samp{dup_comm} (initialized data may have
5227 duplicate names), or @samp{zero} (subsection is all zeros, do not write in
5230 @item .version "@var{str}"
5231 Write @var{str} as version identifier in object code.
5236 For detailed information on the HPPA machine instruction set, see
5237 @cite{PA-RISC Architecture and Instruction Set Reference Manual}
5244 @chapter Hitachi SH Dependent Features
5248 * SH Options:: Options
5249 * SH Syntax:: Syntax
5250 * SH Floating Point:: Floating Point
5251 * SH Directives:: SH Machine Directives
5252 * SH Opcodes:: Opcodes
5258 @cindex SH options (none)
5259 @cindex options, SH (none)
5260 @code{@value{AS}} has no additional command-line options for the Hitachi
5267 * SH-Chars:: Special Characters
5268 * SH-Regs:: Register Names
5269 * SH-Addressing:: Addressing Modes
5273 @subsection Special Characters
5275 @cindex line comment character, SH
5276 @cindex SH line comment character
5277 @samp{!} is the line comment character.
5279 @cindex line separator, SH
5280 @cindex statement separator, SH
5281 @cindex SH line separator
5282 You can use @samp{;} instead of a newline to separate statements.
5284 @cindex symbol names, @samp{$} in
5285 @cindex @code{$} in symbol names
5286 Since @samp{$} has no special meaning, you may use it in symbol names.
5289 @subsection Register Names
5291 @cindex SH registers
5292 @cindex registers, SH
5293 You can use the predefined symbols @samp{r0}, @samp{r1}, @samp{r2},
5294 @samp{r3}, @samp{r4}, @samp{r5}, @samp{r6}, @samp{r7}, @samp{r8},
5295 @samp{r9}, @samp{r10}, @samp{r11}, @samp{r12}, @samp{r13}, @samp{r14},
5296 and @samp{r15} to refer to the SH registers.
5298 The SH also has these control registers:
5302 procedure register (holds return address)
5309 high and low multiply accumulator registers
5315 global base register
5318 vector base register (for interrupt vectors)
5322 @subsection Addressing Modes
5324 @cindex addressing modes, SH
5325 @cindex SH addressing modes
5326 @code{@value{AS}} understands the following addressing modes for the SH.
5327 @code{R@var{n}} in the following refers to any of the numbered
5328 registers, but @emph{not} the control registers.
5338 Register indirect with pre-decrement
5341 Register indirect with post-increment
5343 @item @@(@var{disp}, R@var{n})
5344 Register indirect with displacement
5346 @item @@(R0, R@var{n})
5349 @item @@(@var{disp}, GBR)
5356 @itemx @@(@var{disp}, PC)
5357 PC relative address (for branch or for addressing memory). The
5358 @code{@value{AS}} implementation allows you to use the simpler form
5359 @var{addr} anywhere a PC relative address is called for; the alternate
5360 form is supported for compatibility with other assemblers.
5366 @node SH Floating Point
5367 @section Floating Point
5369 @cindex floating point, SH (@sc{ieee})
5370 @cindex SH floating point (@sc{ieee})
5371 The SH family uses @sc{ieee} floating-point numbers.
5374 @section SH Machine Directives
5376 @cindex SH machine directives (none)
5377 @cindex machine directives, SH (none)
5378 @cindex @code{word} directive, SH
5379 @cindex @code{int} directive, SH
5380 @code{@value{AS}} has no machine-dependent directives for the SH.
5385 @cindex SH opcode summary
5386 @cindex opcode summary, SH
5387 @cindex mnemonics, SH
5388 @cindex instruction summary, SH
5389 For detailed information on the SH machine instruction set, see
5390 @cite{SH-Microcomputer User's Manual} (Hitachi Micro Systems, Inc.).
5392 @code{@value{AS}} implements all the standard SH opcodes. No additional
5393 pseudo-instructions are needed on this family. Note, however, that
5394 because @code{@value{AS}} supports a simpler form of PC-relative
5395 addressing, you may simply write (for example)
5402 where other assemblers might require an explicit displacement to
5403 @code{bar} from the program counter:
5406 mov.l @@(@var{disp}, PC)
5410 @c this table, due to the multi-col faking and hardcoded order, looks silly
5411 @c except in smallbook. See comments below "@set SMALL" near top of this file.
5413 Here is a summary of SH opcodes:
5418 Rn @r{a numbered register}
5419 Rm @r{another numbered register}
5420 #imm @r{immediate data}
5421 disp @r{displacement}
5422 disp8 @r{8-bit displacement}
5423 disp12 @r{12-bit displacement}
5425 add #imm,Rn lds.l @@Rn+,PR
5426 add Rm,Rn mac.w @@Rm+,@@Rn+
5427 addc Rm,Rn mov #imm,Rn
5428 addv Rm,Rn mov Rm,Rn
5429 and #imm,R0 mov.b Rm,@@(R0,Rn)
5430 and Rm,Rn mov.b Rm,@@-Rn
5431 and.b #imm,@@(R0,GBR) mov.b Rm,@@Rn
5432 bf disp8 mov.b @@(disp,Rm),R0
5433 bra disp12 mov.b @@(disp,GBR),R0
5434 bsr disp12 mov.b @@(R0,Rm),Rn
5435 bt disp8 mov.b @@Rm+,Rn
5436 clrmac mov.b @@Rm,Rn
5437 clrt mov.b R0,@@(disp,Rm)
5438 cmp/eq #imm,R0 mov.b R0,@@(disp,GBR)
5439 cmp/eq Rm,Rn mov.l Rm,@@(disp,Rn)
5440 cmp/ge Rm,Rn mov.l Rm,@@(R0,Rn)
5441 cmp/gt Rm,Rn mov.l Rm,@@-Rn
5442 cmp/hi Rm,Rn mov.l Rm,@@Rn
5443 cmp/hs Rm,Rn mov.l @@(disp,Rn),Rm
5444 cmp/pl Rn mov.l @@(disp,GBR),R0
5445 cmp/pz Rn mov.l @@(disp,PC),Rn
5446 cmp/str Rm,Rn mov.l @@(R0,Rm),Rn
5447 div0s Rm,Rn mov.l @@Rm+,Rn
5449 div1 Rm,Rn mov.l R0,@@(disp,GBR)
5450 exts.b Rm,Rn mov.w Rm,@@(R0,Rn)
5451 exts.w Rm,Rn mov.w Rm,@@-Rn
5452 extu.b Rm,Rn mov.w Rm,@@Rn
5453 extu.w Rm,Rn mov.w @@(disp,Rm),R0
5454 jmp @@Rn mov.w @@(disp,GBR),R0
5455 jsr @@Rn mov.w @@(disp,PC),Rn
5456 ldc Rn,GBR mov.w @@(R0,Rm),Rn
5457 ldc Rn,SR mov.w @@Rm+,Rn
5458 ldc Rn,VBR mov.w @@Rm,Rn
5459 ldc.l @@Rn+,GBR mov.w R0,@@(disp,Rm)
5460 ldc.l @@Rn+,SR mov.w R0,@@(disp,GBR)
5461 ldc.l @@Rn+,VBR mova @@(disp,PC),R0
5463 lds Rn,MACL muls Rm,Rn
5464 lds Rn,PR mulu Rm,Rn
5465 lds.l @@Rn+,MACH neg Rm,Rn
5466 lds.l @@Rn+,MACL negc Rm,Rn
5469 not Rm,Rn stc.l GBR,@@-Rn
5470 or #imm,R0 stc.l SR,@@-Rn
5471 or Rm,Rn stc.l VBR,@@-Rn
5472 or.b #imm,@@(R0,GBR) sts MACH,Rn
5473 rotcl Rn sts MACL,Rn
5475 rotl Rn sts.l MACH,@@-Rn
5476 rotr Rn sts.l MACL,@@-Rn
5481 shar Rn swap.b Rm,Rn
5482 shll Rn swap.w Rm,Rn
5483 shll16 Rn tas.b @@Rn
5485 shll8 Rn tst #imm,R0
5487 shlr16 Rn tst.b #imm,@@(R0,GBR)
5488 shlr2 Rn xor #imm,R0
5490 sleep xor.b #imm,@@(R0,GBR)
5491 stc GBR,Rn xtrct Rm,Rn
5506 @node i960-Dependent
5507 @chapter Intel 80960 Dependent Features
5510 @node Machine Dependencies
5511 @chapter Intel 80960 Dependent Features
5514 @cindex i960 support
5516 * Options-i960:: i960 Command-line Options
5517 * Floating Point-i960:: Floating Point
5518 * Directives-i960:: i960 Machine Directives
5519 * Opcodes for i960:: i960 Opcodes
5522 @c FIXME! Add Syntax sec with discussion of bitfields here, at least so
5523 @c long as they're not turned on for other machines than 960.
5527 @section i960 Command-line Options
5529 @cindex i960 options
5530 @cindex options, i960
5533 @item -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC
5534 @cindex i960 architecture options
5535 @cindex architecture options, i960
5536 @cindex @code{-A} options, i960
5537 Select the 80960 architecture. Instructions or features not supported
5538 by the selected architecture cause fatal errors.
5540 @samp{-ACA} is equivalent to @samp{-ACA_A}; @samp{-AKC} is equivalent to
5541 @samp{-AMC}. Synonyms are provided for compatibility with other tools.
5543 If you do not specify any of these options, @code{@value{AS}} generates code
5544 for any instruction or feature that is supported by @emph{some} version of the
5545 960 (even if this means mixing architectures!). In principle,
5546 @code{@value{AS}} attempts to deduce the minimal sufficient processor type if
5547 none is specified; depending on the object code format, the processor type may
5548 be recorded in the object file. If it is critical that the @code{@value{AS}}
5549 output match a specific architecture, specify that architecture explicitly.
5552 @cindex @code{-b} option, i960
5553 @cindex branch recording, i960
5554 @cindex i960 branch recording
5555 Add code to collect information about conditional branches taken, for
5556 later optimization using branch prediction bits. (The conditional branch
5557 instructions have branch prediction bits in the CA, CB, and CC
5558 architectures.) If @var{BR} represents a conditional branch instruction,
5559 the following represents the code generated by the assembler when
5560 @samp{-b} is specified:
5563 call @var{increment routine}
5564 .word 0 # pre-counter
5566 call @var{increment routine}
5567 .word 0 # post-counter
5570 The counter following a branch records the number of times that branch
5571 was @emph{not} taken; the differenc between the two counters is the
5572 number of times the branch @emph{was} taken.
5574 @cindex @code{gbr960}, i960 postprocessor
5575 @cindex branch statistics table, i960
5576 A table of every such @code{Label} is also generated, so that the
5577 external postprocessor @code{gbr960} (supplied by Intel) can locate all
5578 the counters. This table is always labelled @samp{__BRANCH_TABLE__};
5579 this is a local symbol to permit collecting statistics for many separate
5580 object files. The table is word aligned, and begins with a two-word
5581 header. The first word, initialized to 0, is used in maintaining linked
5582 lists of branch tables. The second word is a count of the number of
5583 entries in the table, which follow immediately: each is a word, pointing
5584 to one of the labels illustrated above.
5588 @c END TEXI2ROFF-KILL
5590 +------------+------------+------------+ ... +------------+
5592 | *NEXT | COUNT: N | *BRLAB 1 | | *BRLAB N |
5594 +------------+------------+------------+ ... +------------+
5596 __BRANCH_TABLE__ layout
5603 \line{\leftskip=0pt\hskip\tableindent
5604 \boxit{2cm}{\tt *NEXT}\boxit{2cm}{\tt COUNT: \it N}\boxit{2cm}{\tt
5605 *BRLAB 1}\ibox{1cm}{\quad\dots}\boxit{2cm}{\tt *BRLAB \it N}\hfil}
5606 \centerline{\it {\tt \_\_BRANCH\_TABLE\_\_} layout}
5608 @c END TEXI2ROFF-KILL
5610 The first word of the header is used to locate multiple branch tables,
5611 since each object file may contain one. Normally the links are
5612 maintained with a call to an initialization routine, placed at the
5613 beginning of each function in the file. The @sc{gnu} C compiler
5614 generates these calls automatically when you give it a @samp{-b} option.
5615 For further details, see the documentation of @samp{gbr960}.
5618 @cindex @code{-norelax} option, i960
5619 Normally, Compare-and-Branch instructions with targets that require
5620 displacements greater than 13 bits (or that have external targets) are
5621 replaced with the corresponding compare (or @samp{chkbit}) and branch
5622 instructions. You can use the @samp{-norelax} option to specify that
5623 @code{@value{AS}} should generate errors instead, if the target displacement
5624 is larger than 13 bits.
5626 This option does not affect the Compare-and-Jump instructions; the code
5627 emitted for them is @emph{always} adjusted when necessary (depending on
5628 displacement size), regardless of whether you use @samp{-norelax}.
5631 @node Floating Point-i960
5632 @section Floating Point
5634 @cindex floating point, i960 (@sc{ieee})
5635 @cindex i960 floating point (@sc{ieee})
5636 @code{@value{AS}} generates @sc{ieee} floating-point numbers for the directives
5637 @samp{.float}, @samp{.double}, @samp{.extended}, and @samp{.single}.
5639 @node Directives-i960
5640 @section i960 Machine Directives
5642 @cindex machine directives, i960
5643 @cindex i960 machine directives
5646 @cindex @code{bss} directive, i960
5647 @item .bss @var{symbol}, @var{length}, @var{align}
5648 Reserve @var{length} bytes in the bss section for a local @var{symbol},
5649 aligned to the power of two specified by @var{align}. @var{length} and
5650 @var{align} must be positive absolute expressions. This directive
5651 differs from @samp{.lcomm} only in that it permits you to specify
5652 an alignment. @xref{Lcomm,,@code{.lcomm}}.
5656 @item .extended @var{flonums}
5657 @cindex @code{extended} directive, i960
5658 @code{.extended} expects zero or more flonums, separated by commas; for
5659 each flonum, @samp{.extended} emits an @sc{ieee} extended-format (80-bit)
5660 floating-point number.
5662 @item .leafproc @var{call-lab}, @var{bal-lab}
5663 @cindex @code{leafproc} directive, i960
5664 You can use the @samp{.leafproc} directive in conjunction with the
5665 optimized @code{callj} instruction to enable faster calls of leaf
5666 procedures. If a procedure is known to call no other procedures, you
5667 may define an entry point that skips procedure prolog code (and that does
5668 not depend on system-supplied saved context), and declare it as the
5669 @var{bal-lab} using @samp{.leafproc}. If the procedure also has an
5670 entry point that goes through the normal prolog, you can specify that
5671 entry point as @var{call-lab}.
5673 A @samp{.leafproc} declaration is meant for use in conjunction with the
5674 optimized call instruction @samp{callj}; the directive records the data
5675 needed later to choose between converting the @samp{callj} into a
5676 @code{bal} or a @code{call}.
5678 @var{call-lab} is optional; if only one argument is present, or if the
5679 two arguments are identical, the single argument is assumed to be the
5680 @code{bal} entry point.
5682 @item .sysproc @var{name}, @var{index}
5683 @cindex @code{sysproc} directive, i960
5684 The @samp{.sysproc} directive defines a name for a system procedure.
5685 After you define it using @samp{.sysproc}, you can use @var{name} to
5686 refer to the system procedure identified by @var{index} when calling
5687 procedures with the optimized call instruction @samp{callj}.
5689 Both arguments are required; @var{index} must be between 0 and 31
5693 @node Opcodes for i960
5694 @section i960 Opcodes
5696 @cindex opcodes, i960
5697 @cindex i960 opcodes
5698 All Intel 960 machine instructions are supported;
5699 @pxref{Options-i960,,i960 Command-line Options} for a discussion of
5700 selecting the instruction subset for a particular 960
5701 architecture.@refill
5703 Some opcodes are processed beyond simply emitting a single corresponding
5704 instruction: @samp{callj}, and Compare-and-Branch or Compare-and-Jump
5705 instructions with target displacements larger than 13 bits.
5708 * callj-i960:: @code{callj}
5709 * Compare-and-branch-i960:: Compare-and-Branch
5713 @subsection @code{callj}
5715 @cindex @code{callj}, i960 pseudo-opcode
5716 @cindex i960 @code{callj} pseudo-opcode
5717 You can write @code{callj} to have the assembler or the linker determine
5718 the most appropriate form of subroutine call: @samp{call},
5719 @samp{bal}, or @samp{calls}. If the assembly source contains
5720 enough information---a @samp{.leafproc} or @samp{.sysproc} directive
5721 defining the operand---then @code{@value{AS}} translates the
5722 @code{callj}; if not, it simply emits the @code{callj}, leaving it
5723 for the linker to resolve.
5725 @node Compare-and-branch-i960
5726 @subsection Compare-and-Branch
5728 @cindex i960 compare/branch instructions
5729 @cindex compare/branch instructions, i960
5730 The 960 architectures provide combined Compare-and-Branch instructions
5731 that permit you to store the branch target in the lower 13 bits of the
5732 instruction word itself. However, if you specify a branch target far
5733 enough away that its address won't fit in 13 bits, the assembler can
5734 either issue an error, or convert your Compare-and-Branch instruction
5735 into separate instructions to do the compare and the branch.
5737 @cindex compare and jump expansions, i960
5738 @cindex i960 compare and jump expansions
5739 Whether @code{@value{AS}} gives an error or expands the instruction depends
5740 on two choices you can make: whether you use the @samp{-norelax} option,
5741 and whether you use a ``Compare and Branch'' instruction or a ``Compare
5742 and Jump'' instruction. The ``Jump'' instructions are @emph{always}
5743 expanded if necessary; the ``Branch'' instructions are expanded when
5744 necessary @emph{unless} you specify @code{-norelax}---in which case
5745 @code{@value{AS}} gives an error instead.
5747 These are the Compare-and-Branch instructions, their ``Jump'' variants,
5748 and the instruction pairs they may expand into:
5752 @c END TEXI2ROFF-KILL
5755 Branch Jump Expanded to
5756 ------ ------ ------------
5759 cmpibe cmpije cmpi; be
5760 cmpibg cmpijg cmpi; bg
5761 cmpibge cmpijge cmpi; bge
5762 cmpibl cmpijl cmpi; bl
5763 cmpible cmpijle cmpi; ble
5764 cmpibno cmpijno cmpi; bno
5765 cmpibne cmpijne cmpi; bne
5766 cmpibo cmpijo cmpi; bo
5767 cmpobe cmpoje cmpo; be
5768 cmpobg cmpojg cmpo; bg
5769 cmpobge cmpojge cmpo; bge
5770 cmpobl cmpojl cmpo; bl
5771 cmpoble cmpojle cmpo; ble
5772 cmpobne cmpojne cmpo; bne
5778 \halign{\hfil {\tt #}\quad&\hfil {\tt #}\qquad&{\tt #}\hfil\cr
5779 \omit{\hfil\it Compare and\hfil}\span\omit&\cr
5780 {\it Branch}&{\it Jump}&{\it Expanded to}\cr
5781 bbc& & chkbit; bno\cr
5782 bbs& & chkbit; bo\cr
5783 cmpibe& cmpije& cmpi; be\cr
5784 cmpibg& cmpijg& cmpi; bg\cr
5785 cmpibge& cmpijge& cmpi; bge\cr
5786 cmpibl& cmpijl& cmpi; bl\cr
5787 cmpible& cmpijle& cmpi; ble\cr
5788 cmpibno& cmpijno& cmpi; bno\cr
5789 cmpibne& cmpijne& cmpi; bne\cr
5790 cmpibo& cmpijo& cmpi; bo\cr
5791 cmpobe& cmpoje& cmpo; be\cr
5792 cmpobg& cmpojg& cmpo; bg\cr
5793 cmpobge& cmpojge& cmpo; bge\cr
5794 cmpobl& cmpojl& cmpo; bl\cr
5795 cmpoble& cmpojle& cmpo; ble\cr
5796 cmpobne& cmpojne& cmpo; bne\cr}
5798 @c END TEXI2ROFF-KILL
5804 @node M68K-Dependent
5805 @chapter M680x0 Dependent Features
5808 @node Machine Dependencies
5809 @chapter M680x0 Dependent Features
5812 @cindex M680x0 support
5814 * M68K-Opts:: M680x0 Options
5815 * M68K-Syntax:: Syntax
5816 * M68K-Moto-Syntax:: Motorola Syntax
5817 * M68K-Float:: Floating Point
5818 * M68K-Directives:: 680x0 Machine Directives
5819 * M68K-opcodes:: Opcodes
5823 @section M680x0 Options
5825 @cindex options, M680x0
5826 @cindex M680x0 options
5827 The Motorola 680x0 version of @code{@value{AS}} has two machine dependent options.
5828 One shortens undefined references from 32 to 16 bits, while the
5829 other is used to tell @code{@value{AS}} what kind of machine it is
5832 @cindex @code{-l} option, M680x0
5833 You can use the @samp{-l} option to shorten the size of references to undefined
5834 symbols. If you do not use the @samp{-l} option, references to undefined
5835 symbols are wide enough for a full @code{long} (32 bits). (Since
5836 @code{@value{AS}} cannot know where these symbols end up, @code{@value{AS}} can
5837 only allocate space for the linker to fill in later. Since @code{@value{AS}}
5838 does not know how far away these symbols are, it allocates as much space as it
5839 can.) If you use this option, the references are only one word wide (16 bits).
5840 This may be useful if you want the object file to be as small as possible, and
5841 you know that the relevant symbols are always less than 17 bits away.
5843 @cindex @code{-m68000} and related options
5844 @cindex architecture options, M680x0
5845 @cindex M680x0 architecture options
5846 The 680x0 version of @code{@value{AS}} is most frequently used to assemble
5847 programs for the Motorola MC68020 microprocessor. Occasionally it is
5848 used to assemble programs for the mostly similar, but slightly different
5849 MC68000 or MC68010 microprocessors. You can give @code{@value{AS}} the options
5850 @samp{-m68000}, @samp{-mc68000}, @samp{-m68010}, @samp{-mc68010},
5851 @samp{-m68020}, and @samp{-mc68020} to tell it what processor is the
5858 This syntax for the Motorola 680x0 was developed at @sc{mit}.
5860 @cindex M680x0 syntax
5861 @cindex syntax, M680x0
5862 @cindex M680x0 size modifiers
5863 @cindex size modifiers, M680x0
5864 The 680x0 version of @code{@value{AS}} uses syntax compatible with the Sun
5865 assembler. Intervening periods are ignored; for example, @samp{movl} is
5866 equivalent to @samp{move.l}.
5869 If @code{@value{AS}} is compiled with SUN_ASM_SYNTAX defined, it
5870 also allows Sun-style local labels of the form @samp{1$} through
5874 In the following table @dfn{apc} stands for any of the address
5875 registers (@samp{a0} through @samp{a7}), nothing, (@samp{}), the
5876 Program Counter (@samp{pc}), or the zero-address relative to the
5877 program counter (@samp{zpc}).
5879 @cindex M680x0 addressing modes
5880 @cindex addressing modes, M680x0
5881 The following addressing modes are understood:
5884 @samp{#@var{digits}}
5887 @samp{d0} through @samp{d7}
5889 @item Address Register
5890 @samp{a0} through @samp{a7}@*
5891 @samp{a7} is also known as @samp{sp}, i.e. the Stack Pointer. @code{a6}
5892 is also known as @samp{fp}, the Frame Pointer.
5894 @item Address Register Indirect
5895 @samp{a0@@} through @samp{a7@@}
5897 @item Address Register Postincrement
5898 @samp{a0@@+} through @samp{a7@@+}
5900 @item Address Register Predecrement
5901 @samp{a0@@-} through @samp{a7@@-}
5903 @item Indirect Plus Offset
5904 @samp{@var{apc}@@(@var{digits})}
5907 @samp{@var{apc}@@(@var{digits},@var{register}:@var{size}:@var{scale})}
5909 or @samp{@var{apc}@@(@var{register}:@var{size}:@var{scale})}
5912 @samp{@var{apc}@@(@var{digits})@@(@var{digits},@var{register}:@var{size}:@var{scale})}
5914 or @samp{@var{apc}@@(@var{digits})@@(@var{register}:@var{size}:@var{scale})}
5917 @samp{@var{apc}@@(@var{digits},@var{register}:@var{size}:@var{scale})@@(@var{digits})}
5919 or @samp{@var{apc}@@(@var{register}:@var{size}:@var{scale})@@(@var{digits})}
5921 @item Memory Indirect
5922 @samp{@var{apc}@@(@var{digits})@@(@var{digits})}
5925 @samp{@var{symbol}}, or @samp{@var{digits}}
5927 @c pesch@cygnus.com: gnu, rich concur the following needs careful
5928 @c research before documenting.
5929 , or either of the above followed
5930 by @samp{:b}, @samp{:w}, or @samp{:l}.
5934 For some configurations, especially those where the compiler normally
5935 does not prepend an underscore to the names of user variables, the
5936 assembler requires a @samp{%} before any use of a register name. This
5937 is intended to let the assembler distinguish between user variables and
5938 registers named @samp{a0} through @samp{a7}, and so on. The @samp{%} is
5939 always accepted, but is only required for some configurations, notably
5942 @node M68K-Moto-Syntax
5943 @section Motorola Syntax
5945 @cindex Motorola syntax for the 680x0
5946 @cindex alternate syntax for the 680x0
5948 The standard Motorola syntax for this chip differs from the syntax
5949 already discussed (@pxref{M68K-Syntax,,Syntax}). @code{@value{AS}} can
5950 accept both kinds of syntax, even within a single instruction. The
5951 two kinds of syntax are fully compatible.
5953 @c FIXME! I can't figure out what this means. Surely the "always" is in some
5954 @c restricted context, for instance. It's not necessary for the preceding text
5955 @c to explain this, so just ignore it for now; re-enable someday when someone
5956 @c has time to explain it better.
5957 , because the Motorola syntax never uses
5958 the @samp{@@} character and the @sc{mit} syntax always does, except in
5959 cases where the syntaxes are identical.
5962 @cindex M680x0 syntax
5963 @cindex syntax, M680x0
5964 In particular, you may write or generate M68K assembler with the
5965 following conventions:
5967 (In the following table @dfn{apc} stands for any of the address
5968 registers (@samp{a0} through @samp{a7}), nothing, (@samp{}), the
5969 Program Counter (@samp{pc}), or the zero-address relative to the
5970 program counter (@samp{zpc}).)
5972 @cindex M680x0 addressing modes
5973 @cindex addressing modes, M680x0
5974 The following additional addressing modes are understood:
5976 @item Address Register Indirect
5977 @samp{a0} through @samp{a7}@*
5978 @samp{a7} is also known as @samp{sp}, i.e. the Stack Pointer. @code{a6}
5979 is also known as @samp{fp}, the Frame Pointer.
5981 @item Address Register Postincrement
5982 @samp{(a0)+} through @samp{(a7)+}
5984 @item Address Register Predecrement
5985 @samp{-(a0)} through @samp{-(a7)}
5987 @item Indirect Plus Offset
5988 @samp{@var{digits}(@var{apc})}
5991 @samp{@var{digits}(@var{apc},(@var{register}.@var{size}*@var{scale})}@*
5992 or @samp{(@var{apc},@var{register}.@var{size}*@var{scale})}@*
5993 In either case, @var{size} and @var{scale} are optional
5994 (@var{scale} defaults to @samp{1}, @var{size} defaults to @samp{l}).
5995 @var{scale} can be @samp{1}, @samp{2}, @samp{4}, or @samp{8}.
5996 @var{size} can be @samp{w} or @samp{l}. @var{scale} is only supported
5997 on the 68020 and greater.
6001 @section Floating Point
6003 @cindex floating point, M680x0
6004 @cindex M680x0 floating point
6005 @c FIXME is this "not too well tested" crud STILL true?
6006 The floating point code is not too well tested, and may have
6009 Packed decimal (P) format floating literals are not supported.
6010 Feel free to add the code!
6012 The floating point formats generated by directives are these.
6016 @cindex @code{float} directive, M680x0
6017 @code{Single} precision floating point constants.
6020 @cindex @code{double} directive, M680x0
6021 @code{Double} precision floating point constants.
6024 There is no directive to produce regions of memory holding
6025 extended precision numbers, however they can be used as
6026 immediate operands to floating-point instructions. Adding a
6027 directive to create extended precision numbers would not be
6028 hard, but it has not yet seemed necessary.
6030 @node M68K-Directives
6031 @section 680x0 Machine Directives
6033 @cindex M680x0 directives
6034 @cindex directives, M680x0
6035 In order to be compatible with the Sun assembler the 680x0 assembler
6036 understands the following directives.
6040 @cindex @code{data1} directive, M680x0
6041 This directive is identical to a @code{.data 1} directive.
6044 @cindex @code{data2} directive, M680x0
6045 This directive is identical to a @code{.data 2} directive.
6048 @cindex @code{even} directive, M680x0
6049 This directive is identical to a @code{.align 1} directive.
6050 @c Is this true? does it work???
6053 @cindex @code{skip} directive, M680x0
6054 This directive is identical to a @code{.space} directive.
6061 @cindex M680x0 opcodes
6062 @cindex opcodes, M680x0
6063 @cindex instruction set, M680x0
6064 @c pesch@cygnus.com: I don't see any point in the following
6065 @c paragraph. Bugs are bugs; how does saying this
6068 Danger: Several bugs have been found in the opcode table (and
6069 fixed). More bugs may exist. Be careful when using obscure
6074 * M68K-Branch:: Branch Improvement
6075 * M68K-Chars:: Special Characters
6079 @subsection Branch Improvement
6081 @cindex pseudo-opcodes, M680x0
6082 @cindex M680x0 pseudo-opcodes
6083 @cindex branch improvement, M680x0
6084 @cindex M680x0 branch improvement
6085 Certain pseudo opcodes are permitted for branch instructions.
6086 They expand to the shortest branch instruction that reach the
6087 target. Generally these mnemonics are made by substituting @samp{j} for
6088 @samp{b} at the start of a Motorola mnemonic.
6090 The following table summarizes the pseudo-operations. A @code{*} flags
6091 cases that are more fully described after the table:
6095 +-------------------------------------------------
6097 Pseudo-Op |BYTE WORD LONG LONG non-PC relative
6098 +-------------------------------------------------
6099 jbsr |bsrs bsr bsrl jsr jsr
6100 jra |bras bra bral jmp jmp
6101 * jXX |bXXs bXX bXXl bNXs;jmpl bNXs;jmp
6102 * dbXX |dbXX dbXX dbXX; bra; jmpl
6103 * fjXX |fbXXw fbXXw fbXXl fbNXw;jmp
6106 NX: negative of condition XX
6109 @center @code{*}---see full description below
6114 These are the simplest jump pseudo-operations; they always map to one
6115 particular machine instruction, depending on the displacement to the
6119 Here, @samp{j@var{XX}} stands for an entire family of pseudo-operations,
6120 where @var{XX} is a conditional branch or condition-code test. The full
6121 list of pseudo-ops in this family is:
6123 jhi jls jcc jcs jne jeq jvc
6124 jvs jpl jmi jge jlt jgt jle
6127 For the cases of non-PC relative displacements and long displacements on
6128 the 68000 or 68010, @code{@value{AS}} issues a longer code fragment in terms of
6129 @var{NX}, the opposite condition to @var{XX}. For example, for the
6130 non-PC relative case:
6142 The full family of pseudo-operations covered here is
6144 dbhi dbls dbcc dbcs dbne dbeq dbvc
6145 dbvs dbpl dbmi dbge dblt dbgt dble
6149 Other than for word and byte displacements, when the source reads
6150 @samp{db@var{XX} foo}, @code{@value{AS}} emits
6159 This family includes
6161 fjne fjeq fjge fjlt fjgt fjle fjf
6162 fjt fjgl fjgle fjnge fjngl fjngle fjngt
6163 fjnle fjnlt fjoge fjogl fjogt fjole fjolt
6164 fjor fjseq fjsf fjsne fjst fjueq fjuge
6165 fjugt fjule fjult fjun
6168 For branch targets that are not PC relative, @code{@value{AS}} emits
6174 when it encounters @samp{fj@var{XX} foo}.
6179 @subsection Special Characters
6181 @cindex special characters, M680x0
6182 @cindex M680x0 immediate character
6183 @cindex immediate character, M680x0
6184 @cindex M680x0 line comment character
6185 @cindex line comment character, M680x0
6186 @cindex comments, M680x0
6187 The immediate character is @samp{#} for Sun compatibility. The
6188 line-comment character is @samp{|}. If a @samp{#} appears at the
6189 beginning of a line, it is treated as a comment unless it looks like
6190 @samp{# line file}, in which case it is treated normally.
6194 @c FIXME! Stop ignoring when filled in.
6199 The 32x32 version of @code{@value{AS}} accepts a @samp{-m32032} option to
6200 specify thiat it is compiling for a 32032 processor, or a
6201 @samp{-m32532} to specify that it is compiling for a 32532 option.
6202 The default (if neither is specified) is chosen when the assembler
6206 I don't know anything about the 32x32 syntax assembled by
6207 @code{@value{AS}}. Someone who undersands the processor (I've never seen
6208 one) and the possible syntaxes should write this section.
6210 @section Floating Point
6211 The 32x32 uses @sc{ieee} floating point numbers, but @code{@value{AS}}
6212 only creates single or double precision values. I don't know if the
6213 32x32 understands extended precision numbers.
6215 @section 32x32 Machine Directives
6216 The 32x32 has no machine dependent directives.
6222 @node Sparc-Dependent
6223 @chapter SPARC Dependent Features
6226 @node Machine Dependencies
6227 @chapter SPARC Dependent Features
6230 @cindex SPARC support
6232 * Sparc-Opts:: Options
6233 * Sparc-Float:: Floating Point
6234 * Sparc-Directives:: Sparc Machine Directives
6240 @cindex options for SPARC
6241 @cindex SPARC options
6242 @cindex architectures, SPARC
6243 @cindex SPARC architectures
6244 The SPARC chip family includes several successive levels (or other
6245 variants) of chip, using the same core instruction set, but including
6246 a few additional instructions at each level.
6248 By default, @code{@value{AS}} assumes the core instruction set (SPARC
6249 v6), but ``bumps'' the architecture level as needed: it switches to
6250 successively higher architectures as it encounters instructions that
6251 only exist in the higher levels.
6254 @item -Av6 | -Av7 | -Av8 | -Asparclite
6259 Use one of the @samp{-A} options to select one of the SPARC
6260 architectures explicitly. If you select an architecture explicitly,
6261 @code{@value{AS}} reports a fatal error if it encounters an instruction
6262 or feature requiring a higher level.
6265 Permit the assembler to ``bump'' the architecture level as required, but
6266 warn whenever it is necessary to switch to another level.
6270 @c FIXME: (sparc) Fill in "syntax" section!
6271 @c subsection syntax
6272 I don't know anything about Sparc syntax. Someone who does
6273 will have to write this section.
6277 @section Floating Point
6279 @cindex floating point, SPARC (@sc{ieee})
6280 @cindex SPARC floating point (@sc{ieee})
6281 The Sparc uses @sc{ieee} floating-point numbers.
6283 @node Sparc-Directives
6284 @section Sparc Machine Directives
6286 @cindex SPARC machine directives
6287 @cindex machine directives, SPARC
6288 The Sparc version of @code{@value{AS}} supports the following additional
6293 @cindex @code{common} directive, SPARC
6294 This must be followed by a symbol name, a positive number, and
6295 @code{"bss"}. This behaves somewhat like @code{.comm}, but the
6296 syntax is different.
6299 @cindex @code{half} directive, SPARC
6300 This is functionally identical to @code{.short}.
6303 @cindex @code{proc} directive, SPARC
6304 This directive is ignored. Any text following it on the same
6305 line is also ignored.
6308 @cindex @code{reserve} directive, SPARC
6309 This must be followed by a symbol name, a positive number, and
6310 @code{"bss"}. This behaves somewhat like @code{.lcomm}, but the
6311 syntax is different.
6314 @cindex @code{seg} directive, SPARC
6315 This must be followed by @code{"text"}, @code{"data"}, or
6316 @code{"data1"}. It behaves like @code{.text}, @code{.data}, or
6320 @cindex @code{skip} directive, SPARC
6321 This is functionally identical to the @code{.space} directive.
6324 @cindex @code{word} directive, SPARC
6325 On the Sparc, the .word directive produces 32 bit values,
6326 instead of the 16 bit values it produces on many other machines.
6333 @node i386-Dependent
6334 @chapter 80386 Dependent Features
6337 @node Machine Dependencies
6338 @chapter 80386 Dependent Features
6341 @cindex i386 support
6342 @cindex i80306 support
6344 * i386-Options:: Options
6345 * i386-Syntax:: AT&T Syntax versus Intel Syntax
6346 * i386-Opcodes:: Opcode Naming
6347 * i386-Regs:: Register Naming
6348 * i386-prefixes:: Opcode Prefixes
6349 * i386-Memory:: Memory References
6350 * i386-jumps:: Handling of Jump Instructions
6351 * i386-Float:: Floating Point
6352 * i386-Notes:: Notes
6358 @cindex options for i386 (none)
6359 @cindex i386 options (none)
6360 The 80386 has no machine dependent options.
6363 @section AT&T Syntax versus Intel Syntax
6365 @cindex i386 syntax compatibility
6366 @cindex syntax compatibility, i386
6367 In order to maintain compatibility with the output of @code{@value{GCC}},
6368 @code{@value{AS}} supports AT&T System V/386 assembler syntax. This is quite
6369 different from Intel syntax. We mention these differences because
6370 almost all 80386 documents used only Intel syntax. Notable differences
6371 between the two syntaxes are:
6375 @cindex immediate operands, i386
6376 @cindex i386 immediate operands
6377 @cindex register operands, i386
6378 @cindex i386 register operands
6379 @cindex jump/call operands, i386
6380 @cindex i386 jump/call operands
6381 @cindex operand delimiters, i386
6382 AT&T immediate operands are preceded by @samp{$}; Intel immediate
6383 operands are undelimited (Intel @samp{push 4} is AT&T @samp{pushl $4}).
6384 AT&T register operands are preceded by @samp{%}; Intel register operands
6385 are undelimited. AT&T absolute (as opposed to PC relative) jump/call
6386 operands are prefixed by @samp{*}; they are undelimited in Intel syntax.
6389 @cindex i386 source, destination operands
6390 @cindex source, destination operands; i386
6391 AT&T and Intel syntax use the opposite order for source and destination
6392 operands. Intel @samp{add eax, 4} is @samp{addl $4, %eax}. The
6393 @samp{source, dest} convention is maintained for compatibility with
6394 previous Unix assemblers.
6397 @cindex opcode suffixes, i386
6398 @cindex sizes operands, i386
6399 @cindex i386 size suffixes
6400 In AT&T syntax the size of memory operands is determined from the last
6401 character of the opcode name. Opcode suffixes of @samp{b}, @samp{w},
6402 and @samp{l} specify byte (8-bit), word (16-bit), and long (32-bit)
6403 memory references. Intel syntax accomplishes this by prefixes memory
6404 operands (@emph{not} the opcodes themselves) with @samp{byte ptr},
6405 @samp{word ptr}, and @samp{dword ptr}. Thus, Intel @samp{mov al, byte
6406 ptr @var{foo}} is @samp{movb @var{foo}, %al} in AT&T syntax.
6409 @cindex return instructions, i386
6410 @cindex i386 jump, call, return
6411 Immediate form long jumps and calls are
6412 @samp{lcall/ljmp $@var{section}, $@var{offset}} in AT&T syntax; the
6414 @samp{call/jmp far @var{section}:@var{offset}}. Also, the far return
6416 is @samp{lret $@var{stack-adjust}} in AT&T syntax; Intel syntax is
6417 @samp{ret far @var{stack-adjust}}.
6420 @cindex sections, i386
6421 @cindex i386 sections
6422 The AT&T assembler does not provide support for multiple section
6423 programs. Unix style systems expect all programs to be single sections.
6427 @section Opcode Naming
6429 @cindex i386 opcode naming
6430 @cindex opcode naming, i386
6431 Opcode names are suffixed with one character modifiers which specify the
6432 size of operands. The letters @samp{b}, @samp{w}, and @samp{l} specify
6433 byte, word, and long operands. If no suffix is specified by an
6434 instruction and it contains no memory operands then @code{@value{AS}} tries to
6435 fill in the missing suffix based on the destination register operand
6436 (the last one by convention). Thus, @samp{mov %ax, %bx} is equivalent
6437 to @samp{movw %ax, %bx}; also, @samp{mov $1, %bx} is equivalent to
6438 @samp{movw $1, %bx}. Note that this is incompatible with the AT&T Unix
6439 assembler which assumes that a missing opcode suffix implies long
6440 operand size. (This incompatibility does not affect compiler output
6441 since compilers always explicitly specify the opcode suffix.)
6443 Almost all opcodes have the same names in AT&T and Intel format. There
6444 are a few exceptions. The sign extend and zero extend instructions need
6445 two sizes to specify them. They need a size to sign/zero extend
6446 @emph{from} and a size to zero extend @emph{to}. This is accomplished
6447 by using two opcode suffixes in AT&T syntax. Base names for sign extend
6448 and zero extend are @samp{movs@dots{}} and @samp{movz@dots{}} in AT&T
6449 syntax (@samp{movsx} and @samp{movzx} in Intel syntax). The opcode
6450 suffixes are tacked on to this base name, the @emph{from} suffix before
6451 the @emph{to} suffix. Thus, @samp{movsbl %al, %edx} is AT&T syntax for
6452 ``move sign extend @emph{from} %al @emph{to} %edx.'' Possible suffixes,
6453 thus, are @samp{bl} (from byte to long), @samp{bw} (from byte to word),
6454 and @samp{wl} (from word to long).
6456 @cindex conversion instructions, i386
6457 @cindex i386 conversion instructions
6458 The Intel-syntax conversion instructions
6462 @samp{cbw} --- sign-extend byte in @samp{%al} to word in @samp{%ax},
6465 @samp{cwde} --- sign-extend word in @samp{%ax} to long in @samp{%eax},
6468 @samp{cwd} --- sign-extend word in @samp{%ax} to long in @samp{%dx:%ax},
6471 @samp{cdq} --- sign-extend dword in @samp{%eax} to quad in @samp{%edx:%eax},
6475 are called @samp{cbtw}, @samp{cwtl}, @samp{cwtd}, and @samp{cltd} in
6476 AT&T naming. @code{@value{AS}} accepts either naming for these instructions.
6478 @cindex jump instructions, i386
6479 @cindex call instructions, i386
6480 Far call/jump instructions are @samp{lcall} and @samp{ljmp} in
6481 AT&T syntax, but are @samp{call far} and @samp{jump far} in Intel
6485 @section Register Naming
6487 @cindex i386 registers
6488 @cindex registers, i386
6489 Register operands are always prefixes with @samp{%}. The 80386 registers
6494 the 8 32-bit registers @samp{%eax} (the accumulator), @samp{%ebx},
6495 @samp{%ecx}, @samp{%edx}, @samp{%edi}, @samp{%esi}, @samp{%ebp} (the
6496 frame pointer), and @samp{%esp} (the stack pointer).
6499 the 8 16-bit low-ends of these: @samp{%ax}, @samp{%bx}, @samp{%cx},
6500 @samp{%dx}, @samp{%di}, @samp{%si}, @samp{%bp}, and @samp{%sp}.
6503 the 8 8-bit registers: @samp{%ah}, @samp{%al}, @samp{%bh},
6504 @samp{%bl}, @samp{%ch}, @samp{%cl}, @samp{%dh}, and @samp{%dl} (These
6505 are the high-bytes and low-bytes of @samp{%ax}, @samp{%bx},
6506 @samp{%cx}, and @samp{%dx})
6509 the 6 section registers @samp{%cs} (code section), @samp{%ds}
6510 (data section), @samp{%ss} (stack section), @samp{%es}, @samp{%fs},
6514 the 3 processor control registers @samp{%cr0}, @samp{%cr2}, and
6518 the 6 debug registers @samp{%db0}, @samp{%db1}, @samp{%db2},
6519 @samp{%db3}, @samp{%db6}, and @samp{%db7}.
6522 the 2 test registers @samp{%tr6} and @samp{%tr7}.
6525 the 8 floating point register stack @samp{%st} or equivalently
6526 @samp{%st(0)}, @samp{%st(1)}, @samp{%st(2)}, @samp{%st(3)},
6527 @samp{%st(4)}, @samp{%st(5)}, @samp{%st(6)}, and @samp{%st(7)}.
6531 @section Opcode Prefixes
6533 @cindex i386 opcode prefixes
6534 @cindex opcode prefixes, i386
6535 @cindex prefixes, i386
6536 Opcode prefixes are used to modify the following opcode. They are used
6537 to repeat string instructions, to provide section overrides, to perform
6538 bus lock operations, and to give operand and address size (16-bit
6539 operands are specified in an instruction by prefixing what would
6540 normally be 32-bit operands with a ``operand size'' opcode prefix).
6541 Opcode prefixes are usually given as single-line instructions with no
6542 operands, and must directly precede the instruction they act upon. For
6543 example, the @samp{scas} (scan string) instruction is repeated with:
6549 Here is a list of opcode prefixes:
6553 @cindex section override prefixes, i386
6554 Section override prefixes @samp{cs}, @samp{ds}, @samp{ss}, @samp{es},
6555 @samp{fs}, @samp{gs}. These are automatically added by specifying
6556 using the @var{section}:@var{memory-operand} form for memory references.
6559 @cindex size prefixes, i386
6560 Operand/Address size prefixes @samp{data16} and @samp{addr16}
6561 change 32-bit operands/addresses into 16-bit operands/addresses. Note
6562 that 16-bit addressing modes (i.e. 8086 and 80286 addressing modes)
6563 are not supported (yet).
6566 @cindex bus lock prefixes, i386
6567 @cindex inhibiting interrupts, i386
6568 The bus lock prefix @samp{lock} inhibits interrupts during
6569 execution of the instruction it precedes. (This is only valid with
6570 certain instructions; see a 80386 manual for details).
6573 @cindex coprocessor wait, i386
6574 The wait for coprocessor prefix @samp{wait} waits for the
6575 coprocessor to complete the current instruction. This should never be
6576 needed for the 80386/80387 combination.
6579 @cindex repeat prefixes, i386
6580 The @samp{rep}, @samp{repe}, and @samp{repne} prefixes are added
6581 to string instructions to make them repeat @samp{%ecx} times.
6585 @section Memory References
6587 @cindex i386 memory references
6588 @cindex memory references, i386
6589 An Intel syntax indirect memory reference of the form
6592 @var{section}:[@var{base} + @var{index}*@var{scale} + @var{disp}]
6596 is translated into the AT&T syntax
6599 @var{section}:@var{disp}(@var{base}, @var{index}, @var{scale})
6603 where @var{base} and @var{index} are the optional 32-bit base and
6604 index registers, @var{disp} is the optional displacement, and
6605 @var{scale}, taking the values 1, 2, 4, and 8, multiplies @var{index}
6606 to calculate the address of the operand. If no @var{scale} is
6607 specified, @var{scale} is taken to be 1. @var{section} specifies the
6608 optional section register for the memory operand, and may override the
6609 default section register (see a 80386 manual for section register
6610 defaults). Note that section overrides in AT&T syntax @emph{must} have
6611 be preceded by a @samp{%}. If you specify a section override which
6612 coincides with the default section register, @code{@value{AS}} does @emph{not}
6613 output any section register override prefixes to assemble the given
6614 instruction. Thus, section overrides can be specified to emphasize which
6615 section register is used for a given memory operand.
6617 Here are some examples of Intel and AT&T style memory references:
6620 @item AT&T: @samp{-4(%ebp)}, Intel: @samp{[ebp - 4]}
6621 @var{base} is @samp{%ebp}; @var{disp} is @samp{-4}. @var{section} is
6622 missing, and the default section is used (@samp{%ss} for addressing with
6623 @samp{%ebp} as the base register). @var{index}, @var{scale} are both missing.
6625 @item AT&T: @samp{foo(,%eax,4)}, Intel: @samp{[foo + eax*4]}
6626 @var{index} is @samp{%eax} (scaled by a @var{scale} 4); @var{disp} is
6627 @samp{foo}. All other fields are missing. The section register here
6628 defaults to @samp{%ds}.
6630 @item AT&T: @samp{foo(,1)}; Intel @samp{[foo]}
6631 This uses the value pointed to by @samp{foo} as a memory operand.
6632 Note that @var{base} and @var{index} are both missing, but there is only
6633 @emph{one} @samp{,}. This is a syntactic exception.
6635 @item AT&T: @samp{%gs:foo}; Intel @samp{gs:foo}
6636 This selects the contents of the variable @samp{foo} with section
6637 register @var{section} being @samp{%gs}.
6640 Absolute (as opposed to PC relative) call and jump operands must be
6641 prefixed with @samp{*}. If no @samp{*} is specified, @code{@value{AS}}
6642 always chooses PC relative addressing for jump/call labels.
6644 Any instruction that has a memory operand @emph{must} specify its size (byte,
6645 word, or long) with an opcode suffix (@samp{b}, @samp{w}, or @samp{l},
6649 @section Handling of Jump Instructions
6651 @cindex jump optimization, i386
6652 @cindex i386 jump optimization
6653 Jump instructions are always optimized to use the smallest possible
6654 displacements. This is accomplished by using byte (8-bit) displacement
6655 jumps whenever the target is sufficiently close. If a byte displacement
6656 is insufficient a long (32-bit) displacement is used. We do not support
6657 word (16-bit) displacement jumps (i.e. prefixing the jump instruction
6658 with the @samp{addr16} opcode prefix), since the 80386 insists upon masking
6659 @samp{%eip} to 16 bits after the word displacement is added.
6661 Note that the @samp{jcxz}, @samp{jecxz}, @samp{loop}, @samp{loopz},
6662 @samp{loope}, @samp{loopnz} and @samp{loopne} instructions only come in byte
6663 displacements, so that if you use these instructions (@code{@value{GCC}} does
6664 not use them) you may get an error message (and incorrect code). The AT&T
6665 80386 assembler tries to get around this problem by expanding @samp{jcxz foo}
6676 @section Floating Point
6678 @cindex i386 floating point
6679 @cindex floating point, i386
6680 All 80387 floating point types except packed BCD are supported.
6681 (BCD support may be added without much difficulty). These data
6682 types are 16-, 32-, and 64- bit integers, and single (32-bit),
6683 double (64-bit), and extended (80-bit) precision floating point.
6684 Each supported type has an opcode suffix and a constructor
6685 associated with it. Opcode suffixes specify operand's data
6686 types. Constructors build these data types into memory.
6690 @cindex @code{float} directive, i386
6691 @cindex @code{single} directive, i386
6692 @cindex @code{double} directive, i386
6693 @cindex @code{tfloat} directive, i386
6694 Floating point constructors are @samp{.float} or @samp{.single},
6695 @samp{.double}, and @samp{.tfloat} for 32-, 64-, and 80-bit formats.
6696 These correspond to opcode suffixes @samp{s}, @samp{l}, and @samp{t}.
6697 @samp{t} stands for temporary real, and that the 80387 only supports
6698 this format via the @samp{fldt} (load temporary real to stack top) and
6699 @samp{fstpt} (store temporary real and pop stack) instructions.
6702 @cindex @code{word} directive, i386
6703 @cindex @code{long} directive, i386
6704 @cindex @code{int} directive, i386
6705 @cindex @code{quad} directive, i386
6706 Integer constructors are @samp{.word}, @samp{.long} or @samp{.int}, and
6707 @samp{.quad} for the 16-, 32-, and 64-bit integer formats. The corresponding
6708 opcode suffixes are @samp{s} (single), @samp{l} (long), and @samp{q}
6709 (quad). As with the temporary real format the 64-bit @samp{q} format is
6710 only present in the @samp{fildq} (load quad integer to stack top) and
6711 @samp{fistpq} (store quad integer and pop stack) instructions.
6714 Register to register operations do not require opcode suffixes,
6715 so that @samp{fst %st, %st(1)} is equivalent to @samp{fstl %st, %st(1)}.
6717 @cindex i386 @code{fwait} instruction
6718 @cindex @code{fwait instruction}, i386
6719 Since the 80387 automatically synchronizes with the 80386 @samp{fwait}
6720 instructions are almost never needed (this is not the case for the
6721 80286/80287 and 8086/8087 combinations). Therefore, @code{@value{AS}} suppresses
6722 the @samp{fwait} instruction whenever it is implicitly selected by one
6723 of the @samp{fn@dots{}} instructions. For example, @samp{fsave} and
6724 @samp{fnsave} are treated identically. In general, all the @samp{fn@dots{}}
6725 instructions are made equivalent to @samp{f@dots{}} instructions. If
6726 @samp{fwait} is desired it must be explicitly coded.
6731 @cindex i386 @code{mul}, @code{imul} instructions
6732 @cindex @code{mul} instruction, i386
6733 @cindex @code{imul} instruction, i386
6734 There is some trickery concerning the @samp{mul} and @samp{imul}
6735 instructions that deserves mention. The 16-, 32-, and 64-bit expanding
6736 multiplies (base opcode @samp{0xf6}; extension 4 for @samp{mul} and 5
6737 for @samp{imul}) can be output only in the one operand form. Thus,
6738 @samp{imul %ebx, %eax} does @emph{not} select the expanding multiply;
6739 the expanding multiply would clobber the @samp{%edx} register, and this
6740 would confuse @code{@value{GCC}} output. Use @samp{imul %ebx} to get the
6741 64-bit product in @samp{%edx:%eax}.
6743 We have added a two operand form of @samp{imul} when the first operand
6744 is an immediate mode expression and the second operand is a register.
6745 This is just a shorthand, so that, multiplying @samp{%eax} by 69, for
6746 example, can be done with @samp{imul $69, %eax} rather than @samp{imul
6753 @node Z8000-Dependent
6754 @chapter Z8000 Dependent Features
6757 @node Machine Dependencies
6758 @chapter Z8000 Dependent Features
6761 @cindex Z8000 support
6762 The Z8000 @value{AS} supports both members of the Z8000 family: the
6763 unsegmented Z8002, with 16 bit addresses, and the segmented Z8001 with
6766 When the assembler is in unsegmented mode (specified with the
6767 @code{unsegm} directive), an address takes up one word (16 bit)
6768 sized register. When the assembler is in segmented mode (specified with
6769 the @code{segm} directive), a 24-bit address takes up a long (32 bit)
6770 register. @xref{Z8000 Directives,,Assembler Directives for the Z8000},
6771 for a list of other Z8000 specific assembler directives.
6774 * Z8000 Options:: No special command-line options for Z8000
6775 * Z8000 Syntax:: Assembler syntax for the Z8000
6776 * Z8000 Directives:: Special directives for the Z8000
6777 * Z8000 Opcodes:: Opcodes
6783 @cindex Z8000 options
6784 @cindex options, Z8000
6785 @code{@value{AS}} has no additional command-line options for the Zilog
6791 * Z8000-Chars:: Special Characters
6792 * Z8000-Regs:: Register Names
6793 * Z8000-Addressing:: Addressing Modes
6797 @subsection Special Characters
6799 @cindex line comment character, Z8000
6800 @cindex Z8000 line comment character
6801 @samp{!} is the line comment character.
6803 @cindex line separator, Z8000
6804 @cindex statement separator, Z8000
6805 @cindex Z8000 line separator
6806 You can use @samp{;} instead of a newline to separate statements.
6809 @subsection Register Names
6811 @cindex Z8000 registers
6812 @cindex registers, Z8000
6813 The Z8000 has sixteen 16 bit registers, numbered 0 to 15. You can refer
6814 to different sized groups of registers by register number, with the
6815 prefix @samp{r} for 16 bit registers, @samp{rr} for 32 bit registers and
6816 @samp{rq} for 64 bit registers. You can also refer to the contents of
6817 the first eight (of the sixteen 16 bit registers) by bytes. They are
6818 named @samp{r@var{n}h} and @samp{r@var{n}l}.
6821 @exdent @emph{byte registers}
6822 r0l r0h r1h r1l r2h r2l r3h r3l
6823 r4h r4l r5h r5l r6h r6l r7h r7l
6825 @exdent @emph{word registers}
6826 r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15
6828 @exdent @emph{long word registers}
6829 rr0 rr2 rr4 rr6 rr8 rr10 rr12 rr14
6831 @exdent @emph{quad word registers}
6835 @node Z8000-Addressing
6836 @subsection Addressing Modes
6838 @cindex addressing modes, Z8000
6839 @cindex Z800 addressing modes
6840 @value{AS} understands the following addressing modes for the Z8000:
6850 Direct: the 16 bit or 24 bit address (depending on whether the assembler
6851 is in segmented or unsegmented mode) of the operand is in the instruction.
6853 @item address(r@var{n})
6854 Indexed: the 16 or 24 bit address is added to the 16 bit register to produce
6855 the final address in memory of the operand.
6857 @item r@var{n}(#@var{imm})
6858 Base Address: the 16 or 24 bit register is added to the 16 bit sign
6859 extended immediate displacement to produce the final address in memory
6862 @item r@var{n}(r@var{m})
6863 Base Index: the 16 or 24 bit register r@var{n} is added to the sign
6864 extended 16 bit index register r@var{m} to produce the final address in
6865 memory of the operand.
6868 Immediate data @var{xx}.
6871 @node Z8000 Directives
6872 @section Assembler Directives for the Z8000
6874 @cindex Z8000 directives
6875 @cindex directives, Z8000
6876 The Z8000 port of @value{AS} includes these additional assembler directives,
6877 for compatibility with other Z8000 assemblers. As shown, these do not
6878 begin with @samp{.} (unlike the ordinary @value{AS} directives).
6883 Generates code for the segmented Z8001.
6887 Generates code for the unsegmented Z8002.
6891 Synonym for @code{.file}
6895 Synonum for @code{.global}
6899 Synonym for @code{.word}
6903 Synonym for @code{.long}
6907 Synonym for @code{.byte}
6911 Assemble a string. @code{sval} expects one string literal, delimited by
6912 single quotes. It assembles each byte of the string into consecutive
6913 addresses. You can use the escape sequence @samp{%@var{xx}} (where
6914 @var{xx} represents a two-digit hexadecimal number) to represent the
6915 character whose @sc{ascii} value is @var{xx}. Use this feature to
6916 describe single quote and other characters that may not appear in string
6917 literals as themselves. For example, the C statement @w{@samp{char *a =
6918 "he said \"it's 50% off\"";}} is represented in Z8000 assembly language
6919 (shown with the assembler output in hex at the left) as
6923 @let@nonarrowing=@comment
6926 68652073 sval 'he said %22it%27s 50%25 off%22%00'
6939 synonym for @code{.section}
6943 synonym for @code{.space}
6947 synonym for @code{.align 1}
6953 @cindex Z8000 opcode summary
6954 @cindex opcode summary, Z8000
6955 @cindex mnemonics, Z8000
6956 @cindex instruction summary, Z8000
6957 For detailed information on the Z8000 machine instruction set, see
6958 @cite{Z8000 Technical Manual}.
6961 @c this table, due to the multi-col faking and hardcoded order, looks silly
6962 @c except in smallbook. See comments below "@set SMALL" near top of this file.
6964 The following table summarizes the opcodes and their arguments:
6967 @let@nonarrowing=@comment
6971 rs @r{16 bit source register}
6972 rd @r{16 bit destination register}
6973 rbs @r{8 bit source register}
6974 rbd @r{8 bit destination register}
6975 rrs @r{32 bit source register}
6976 rrd @r{32 bit destination register}
6977 rqs @r{64 bit source register}
6978 rqd @r{64 bit destination register}
6979 addr @r{16/24 bit address}
6980 imm @r{immediate data}
6982 adc rd,rs clrb addr cpsir @@rd,@@rs,rr,cc
6983 adcb rbd,rbs clrb addr(rd) cpsirb @@rd,@@rs,rr,cc
6984 add rd,@@rs clrb rbd dab rbd
6985 add rd,addr com @@rd dbjnz rbd,disp7
6986 add rd,addr(rs) com addr dec @@rd,imm4m1
6987 add rd,imm16 com addr(rd) dec addr(rd),imm4m1
6988 add rd,rs com rd dec addr,imm4m1
6989 addb rbd,@@rs comb @@rd dec rd,imm4m1
6990 addb rbd,addr comb addr decb @@rd,imm4m1
6991 addb rbd,addr(rs) comb addr(rd) decb addr(rd),imm4m1
6992 addb rbd,imm8 comb rbd decb addr,imm4m1
6993 addb rbd,rbs comflg flags decb rbd,imm4m1
6994 addl rrd,@@rs cp @@rd,imm16 di i2
6995 addl rrd,addr cp addr(rd),imm16 div rrd,@@rs
6996 addl rrd,addr(rs) cp addr,imm16 div rrd,addr
6997 addl rrd,imm32 cp rd,@@rs div rrd,addr(rs)
6998 addl rrd,rrs cp rd,addr div rrd,imm16
6999 and rd,@@rs cp rd,addr(rs) div rrd,rs
7000 and rd,addr cp rd,imm16 divl rqd,@@rs
7001 and rd,addr(rs) cp rd,rs divl rqd,addr
7002 and rd,imm16 cpb @@rd,imm8 divl rqd,addr(rs)
7003 and rd,rs cpb addr(rd),imm8 divl rqd,imm32
7004 andb rbd,@@rs cpb addr,imm8 divl rqd,rrs
7005 andb rbd,addr cpb rbd,@@rs djnz rd,disp7
7006 andb rbd,addr(rs) cpb rbd,addr ei i2
7007 andb rbd,imm8 cpb rbd,addr(rs) ex rd,@@rs
7008 andb rbd,rbs cpb rbd,imm8 ex rd,addr
7009 bit @@rd,imm4 cpb rbd,rbs ex rd,addr(rs)
7010 bit addr(rd),imm4 cpd rd,@@rs,rr,cc ex rd,rs
7011 bit addr,imm4 cpdb rbd,@@rs,rr,cc exb rbd,@@rs
7012 bit rd,imm4 cpdr rd,@@rs,rr,cc exb rbd,addr
7013 bit rd,rs cpdrb rbd,@@rs,rr,cc exb rbd,addr(rs)
7014 bitb @@rd,imm4 cpi rd,@@rs,rr,cc exb rbd,rbs
7015 bitb addr(rd),imm4 cpib rbd,@@rs,rr,cc ext0e imm8
7016 bitb addr,imm4 cpir rd,@@rs,rr,cc ext0f imm8
7017 bitb rbd,imm4 cpirb rbd,@@rs,rr,cc ext8e imm8
7018 bitb rbd,rs cpl rrd,@@rs ext8f imm8
7019 bpt cpl rrd,addr exts rrd
7020 call @@rd cpl rrd,addr(rs) extsb rd
7021 call addr cpl rrd,imm32 extsl rqd
7022 call addr(rd) cpl rrd,rrs halt
7023 calr disp12 cpsd @@rd,@@rs,rr,cc in rd,@@rs
7024 clr @@rd cpsdb @@rd,@@rs,rr,cc in rd,imm16
7025 clr addr cpsdr @@rd,@@rs,rr,cc inb rbd,@@rs
7026 clr addr(rd) cpsdrb @@rd,@@rs,rr,cc inb rbd,imm16
7027 clr rd cpsi @@rd,@@rs,rr,cc inc @@rd,imm4m1
7028 clrb @@rd cpsib @@rd,@@rs,rr,cc inc addr(rd),imm4m1
7029 inc addr,imm4m1 ldb rbd,rs(rx) mult rrd,addr(rs)
7030 inc rd,imm4m1 ldb rd(imm16),rbs mult rrd,imm16
7031 incb @@rd,imm4m1 ldb rd(rx),rbs mult rrd,rs
7032 incb addr(rd),imm4m1 ldctl ctrl,rs multl rqd,@@rs
7033 incb addr,imm4m1 ldctl rd,ctrl multl rqd,addr
7034 incb rbd,imm4m1 ldd @@rs,@@rd,rr multl rqd,addr(rs)
7035 ind @@rd,@@rs,ra lddb @@rs,@@rd,rr multl rqd,imm32
7036 indb @@rd,@@rs,rba lddr @@rs,@@rd,rr multl rqd,rrs
7037 inib @@rd,@@rs,ra lddrb @@rs,@@rd,rr neg @@rd
7038 inibr @@rd,@@rs,ra ldi @@rd,@@rs,rr neg addr
7039 iret ldib @@rd,@@rs,rr neg addr(rd)
7040 jp cc,@@rd ldir @@rd,@@rs,rr neg rd
7041 jp cc,addr ldirb @@rd,@@rs,rr negb @@rd
7042 jp cc,addr(rd) ldk rd,imm4 negb addr
7043 jr cc,disp8 ldl @@rd,rrs negb addr(rd)
7044 ld @@rd,imm16 ldl addr(rd),rrs negb rbd
7045 ld @@rd,rs ldl addr,rrs nop
7046 ld addr(rd),imm16 ldl rd(imm16),rrs or rd,@@rs
7047 ld addr(rd),rs ldl rd(rx),rrs or rd,addr
7048 ld addr,imm16 ldl rrd,@@rs or rd,addr(rs)
7049 ld addr,rs ldl rrd,addr or rd,imm16
7050 ld rd(imm16),rs ldl rrd,addr(rs) or rd,rs
7051 ld rd(rx),rs ldl rrd,imm32 orb rbd,@@rs
7052 ld rd,@@rs ldl rrd,rrs orb rbd,addr
7053 ld rd,addr ldl rrd,rs(imm16) orb rbd,addr(rs)
7054 ld rd,addr(rs) ldl rrd,rs(rx) orb rbd,imm8
7055 ld rd,imm16 ldm @@rd,rs,n orb rbd,rbs
7056 ld rd,rs ldm addr(rd),rs,n out @@rd,rs
7057 ld rd,rs(imm16) ldm addr,rs,n out imm16,rs
7058 ld rd,rs(rx) ldm rd,@@rs,n outb @@rd,rbs
7059 lda rd,addr ldm rd,addr(rs),n outb imm16,rbs
7060 lda rd,addr(rs) ldm rd,addr,n outd @@rd,@@rs,ra
7061 lda rd,rs(imm16) ldps @@rs outdb @@rd,@@rs,rba
7062 lda rd,rs(rx) ldps addr outib @@rd,@@rs,ra
7063 ldar rd,disp16 ldps addr(rs) outibr @@rd,@@rs,ra
7064 ldb @@rd,imm8 ldr disp16,rs pop @@rd,@@rs
7065 ldb @@rd,rbs ldr rd,disp16 pop addr(rd),@@rs
7066 ldb addr(rd),imm8 ldrb disp16,rbs pop addr,@@rs
7067 ldb addr(rd),rbs ldrb rbd,disp16 pop rd,@@rs
7068 ldb addr,imm8 ldrl disp16,rrs popl @@rd,@@rs
7069 ldb addr,rbs ldrl rrd,disp16 popl addr(rd),@@rs
7070 ldb rbd,@@rs mbit popl addr,@@rs
7071 ldb rbd,addr mreq rd popl rrd,@@rs
7072 ldb rbd,addr(rs) mres push @@rd,@@rs
7073 ldb rbd,imm8 mset push @@rd,addr
7074 ldb rbd,rbs mult rrd,@@rs push @@rd,addr(rs)
7075 ldb rbd,rs(imm16) mult rrd,addr push @@rd,imm16
7076 push @@rd,rs set addr,imm4 subl rrd,imm32
7077 pushl @@rd,@@rs set rd,imm4 subl rrd,rrs
7078 pushl @@rd,addr set rd,rs tcc cc,rd
7079 pushl @@rd,addr(rs) setb @@rd,imm4 tccb cc,rbd
7080 pushl @@rd,rrs setb addr(rd),imm4 test @@rd
7081 res @@rd,imm4 setb addr,imm4 test addr
7082 res addr(rd),imm4 setb rbd,imm4 test addr(rd)
7083 res addr,imm4 setb rbd,rs test rd
7084 res rd,imm4 setflg imm4 testb @@rd
7085 res rd,rs sinb rbd,imm16 testb addr
7086 resb @@rd,imm4 sinb rd,imm16 testb addr(rd)
7087 resb addr(rd),imm4 sind @@rd,@@rs,ra testb rbd
7088 resb addr,imm4 sindb @@rd,@@rs,rba testl @@rd
7089 resb rbd,imm4 sinib @@rd,@@rs,ra testl addr
7090 resb rbd,rs sinibr @@rd,@@rs,ra testl addr(rd)
7091 resflg imm4 sla rd,imm8 testl rrd
7092 ret cc slab rbd,imm8 trdb @@rd,@@rs,rba
7093 rl rd,imm1or2 slal rrd,imm8 trdrb @@rd,@@rs,rba
7094 rlb rbd,imm1or2 sll rd,imm8 trib @@rd,@@rs,rbr
7095 rlc rd,imm1or2 sllb rbd,imm8 trirb @@rd,@@rs,rbr
7096 rlcb rbd,imm1or2 slll rrd,imm8 trtdrb @@ra,@@rb,rbr
7097 rldb rbb,rba sout imm16,rs trtib @@ra,@@rb,rr
7098 rr rd,imm1or2 soutb imm16,rbs trtirb @@ra,@@rb,rbr
7099 rrb rbd,imm1or2 soutd @@rd,@@rs,ra trtrb @@ra,@@rb,rbr
7100 rrc rd,imm1or2 soutdb @@rd,@@rs,rba tset @@rd
7101 rrcb rbd,imm1or2 soutib @@rd,@@rs,ra tset addr
7102 rrdb rbb,rba soutibr @@rd,@@rs,ra tset addr(rd)
7103 rsvd36 sra rd,imm8 tset rd
7104 rsvd38 srab rbd,imm8 tsetb @@rd
7105 rsvd78 sral rrd,imm8 tsetb addr
7106 rsvd7e srl rd,imm8 tsetb addr(rd)
7107 rsvd9d srlb rbd,imm8 tsetb rbd
7108 rsvd9f srll rrd,imm8 xor rd,@@rs
7109 rsvdb9 sub rd,@@rs xor rd,addr
7110 rsvdbf sub rd,addr xor rd,addr(rs)
7111 sbc rd,rs sub rd,addr(rs) xor rd,imm16
7112 sbcb rbd,rbs sub rd,imm16 xor rd,rs
7113 sc imm8 sub rd,rs xorb rbd,@@rs
7114 sda rd,rs subb rbd,@@rs xorb rbd,addr
7115 sdab rbd,rs subb rbd,addr xorb rbd,addr(rs)
7116 sdal rrd,rs subb rbd,addr(rs) xorb rbd,imm8
7117 sdl rd,rs subb rbd,imm8 xorb rbd,rbs
7118 sdlb rbd,rs subb rbd,rbs xorb rbd,rbs
7119 sdll rrd,rs subl rrd,@@rs
7120 set @@rd,imm4 subl rrd,addr
7121 set addr(rd),imm4 subl rrd,addr(rs)
7133 @node MIPS-Dependent
7134 @chapter MIPS Dependent Features
7137 @node Machine Dependencies
7138 @chapter MIPS Dependent Features
7145 @sc{gnu} @code{@value{AS}} for @sc{mips} architectures supports the @sc{mips}
7146 @sc{r2000}, @sc{r3000}, @sc{r4000} and @sc{r6000} processors. For information
7147 about the @sc{mips} instruction set, see @cite{MIPS RISC Architecture}, by Kane
7148 and Heindrich (Prentice-Hall). For an overview of @sc{mips} assembly
7149 conventions, see ``Appendix D: Assembly Language Programming'' in the same
7153 * MIPS Opts:: Assembler options
7154 * MIPS Object:: ECOFF object code
7155 * MIPS Stabs:: Directives for debugging information
7156 * MIPS ISA:: Directives to override the ISA level
7160 @section Assembler options
7162 The @sc{mips} configurations of @sc{gnu} @code{@value{AS}} support these
7166 @cindex @code{-G} option (MIPS)
7168 This option sets the largest size of an object that can be referenced
7169 implicitly with the @code{gp} register. It is only accepted for targets
7170 that use @sc{ecoff} format. The default value is 8.
7172 @cindex @code{-EB} option (MIPS)
7173 @cindex @code{-EL} option (MIPS)
7174 @cindex MIPS big-endian output
7175 @cindex MIPS little-endian output
7176 @cindex big-endian output, MIPS
7177 @cindex little-endian output, MIPS
7180 Any @sc{mips} configuration of @code{@value{AS}} can select big-endian or
7181 little-endian output at run time (unlike the other @sc{gnu} development
7182 tools, which must be configured for one or the other). Use @samp{-EB}
7183 to select big-endian output, and @samp{-EL} for little-endian.
7185 @cindex MIPS architecture options
7189 Generate code for a particular MIPS Instruction Set Architecture level.
7190 @samp{-mips1} corresponds to the @sc{r2000} and @sc{r3000} processors,
7191 @samp{-mips2} to the @sc{r6000} processor, and @samp{-mips3} to the @sc{r4000}
7192 processor. You can also switch instruction sets during the assembly; see
7193 @ref{MIPS ISA,, Directives to override the ISA level}.
7195 @cindex @code{-nocpp} ignored (MIPS)
7197 This option is ignored. It is accepted for command-line compatibility with
7198 other assemblers, which use it to turn off C style preprocessing. With
7199 @sc{gnu} @code{@value{AS}}, there is no need for @samp{-nocpp}, because the
7200 @sc{gnu} assembler itself never runs the C preprocessor.
7204 @c FIXME! (1) reflect these options (next item too) in option summaries;
7205 @c (2) stop teasing, say _which_ instructions expanded _how_.
7206 @code{@value{AS}} automatically macro expands certain division and
7207 multiplication instructions to check for overflow and division by zero. This
7208 option causes @code{@value{AS}} to generate code to take a trap exception
7209 rather than a break exception when an error is detected. The trap instructions
7210 are only supported at Instruction Set Architecture level 2 and higher.
7214 Generate code to take a break exception rather than a trap exception when an
7215 error is detected. This is the default.
7219 @section MIPS ECOFF object code
7221 @cindex ECOFF sections
7222 @cindex MIPS ECOFF sections
7223 Assembling for a @sc{mips} @sc{ecoff} target supports some additional sections
7224 besides the usual @code{.text}, @code{.data} and @code{.bss}. The
7225 additional sections are @code{.rdata}, used for read-only data,
7226 @code{.sdata}, used for small data, and @code{.sbss}, used for small
7229 @cindex small objects, MIPS ECOFF
7230 @cindex @code{gp} register, MIPS
7231 When assembling for @sc{ecoff}, the assembler uses the @code{$gp} (@code{$28})
7232 register to form the address of a ``small object''. Any object in the
7233 @code{.sdata} or @code{.sbss} sections is considered ``small'' in this sense.
7234 For external objects, or for objects in the @code{.bss} section, you can use
7235 the @code{@value{GCC}} @samp{-G} option to control the size of objects addressed via
7236 @code{$gp}; the default value is 8, meaning that a reference to any object
7237 eight bytes or smaller uses @code{$gp}. Passing @samp{-G 0} to
7238 @code{@value{AS}} prevents it from using the @code{$gp} register on the basis
7239 of object size (but the assembler uses @code{$gp} for objects in @code{.sdata}
7240 or @code{sbss} in any case). The size of an object in the @code{.bss} section
7241 is set by the @code{.comm} or @code{.lcomm} directive that defines it. The
7242 size of an external object may be set with the @code{.extern} directive. For
7243 example, @samp{.extern sym,4} declares that the object at @code{sym} is 4 bytes
7244 in length, whie leaving @code{sym} otherwise undefined.
7246 Using small @sc{ecoff} objects requires linker support, and assumes that the
7247 @code{$gp} register is correctly initialized (normally done automatically by
7248 the startup code). @sc{mips} @sc{ecoff} assembly code must not modify the
7249 @code{$gp} register.
7252 @section Directives for debugging information
7254 @cindex MIPS debugging directives
7255 @sc{mips} @sc{ecoff} @code{@value{AS}} supports several directives used for
7256 generating debugging information which are not support by traditional @sc{mips}
7257 assemblers. These are @code{.def}, @code{.endef}, @code{.dim}, @code{.file},
7258 @code{.scl}, @code{.size}, @code{.tag}, @code{.type}, @code{.val},
7259 @code{.stabd}, @code{.stabn}, and @code{.stabs}. The debugging information
7260 generated by the three @code{.stab} directives can only be read by @sc{gdb},
7261 not by traditional @sc{mips} debuggers (this enhancement is required to fully
7262 support C++ debugging). These directives are primarily used by compilers, not
7263 assembly language programmers!
7266 @section Directives to override the ISA level
7268 @cindex MIPS ISA override
7269 @kindex @code{.set mips@var{n}}
7270 @sc{gnu} @code{@value{AS}} supports an additional directive to change the
7271 @sc{mips} Instruction Set Architecture level on the fly: @code{.set
7272 mips@var{n}}. @var{n} should be a number from 0 to 3. A value from 1 to 3
7273 makes the assembler accept instructions for the corresponding @sc{isa} level,
7274 from that point on in the assembly. @code{.set mips@var{n}} affects not only
7275 which instructions are permitted, but also how certain macros are expanded.
7276 @code{.set mips0} restores the @sc{isa} level to its original level: either the
7277 level you selected with command line options, or the default for your
7278 configuration. You can use this feature to permit specific @sc{r4000}
7279 instructions while assembling in 32 bit mode. Use this directive with care!
7281 Traditional @sc{mips} assemblers do not support this directive.
7285 @c reverse effect of @down at top of generic Machine-Dep chapter
7289 @node Acknowledgements
7290 @chapter Acknowledgements
7292 If you have contributed to @code{@value{AS}} and your name isn't listed here,
7293 it is not meant as a slight. We just don't know about it. Send mail to the
7294 maintainer, and we'll correct the situation. Currently (January 1994), the
7295 maintainer is Ken Raeburn (email address @code{raeburn@@cygnus.com}).
7297 Dean Elsner wrote the original @sc{gnu} assembler for the VAX.@footnote{Any more
7300 Jay Fenlason maintained GAS for a while, adding support for GDB-specific debug
7301 information and the 68k series machines, most of the preprocessing pass, and
7302 extensive changes in @file{messages.c}, @file{input-file.c}, @file{write.c}.
7304 K. Richard Pixley maintained GAS for a while, adding various enhancements and
7305 many bug fixes, including merging support for several processors, breaking GAS
7306 up to handle multiple object file format back ends (including heavy rewrite,
7307 testing, an integration of the coff and b.out back ends), adding configuration
7308 including heavy testing and verification of cross assemblers and file splits
7309 and renaming, converted GAS to strictly ANSI C including full prototypes, added
7310 support for m680[34]0 and cpu32, did considerable work on i960 including a COFF
7311 port (including considerable amounts of reverse engineering), a SPARC opcode
7312 file rewrite, DECstation, rs6000, and hp300hpux host ports, updated ``know''
7313 assertions and made them work, much other reorganization, cleanup, and lint.
7315 Ken Raeburn wrote the high-level BFD interface code to replace most of the code
7316 in format-specific I/O modules.
7318 The original VMS support was contributed by David L. Kashtan. Eric Youngdale
7319 has done much work with it since.
7321 The Intel 80386 machine description was written by Eliot Dresselhaus.
7323 Minh Tran-Le at IntelliCorp contributed some AIX 386 support.
7325 The Motorola 88k machine description was contributed by Devon Bowen of Buffalo
7326 University and Torbjorn Granlund of the Swedish Institute of Computer Science.
7328 Keith Knowles at the Open Software Foundation wrote the original MIPS back end
7329 (@file{tc-mips.c}, @file{tc-mips.h}), and contributed Rose format support
7330 (which hasn't been merged in yet). Ralph Campbell worked with the MIPS code to
7331 support a.out format.
7333 Support for the Zilog Z8k and Hitachi H8/300 and H8/500 processors (tc-z8k,
7334 tc-h8300, tc-h8500), and IEEE 695 object file format (obj-ieee), was written by
7335 Steve Chamberlain of Cygnus Support. Steve also modified the COFF back end to
7336 use BFD for some low-level operations, for use with the H8/300 and AMD 29k
7339 John Gilmore built the AMD 29000 support, added @code{.include} support, and
7340 simplified the configuration of which versions accept which directives. He
7341 updated the 68k machine description so that Motorola's opcodes always produced
7342 fixed-size instructions (e.g. @code{jsr}), while synthetic instructions
7343 remained shrinkable (@code{jbsr}). John fixed many bugs, including true tested
7344 cross-compilation support, and one bug in relaxation that took a week and
7345 required the proverbial one-bit fix.
7347 Ian Lance Taylor of Cygnus Support merged the Motorola and MIT syntax for the
7348 68k, completed support for some COFF targets (68k, i386 SVR3, and SCO Unix),
7349 added support for MIPS ECOFF and ELF targets, and made a few other minor
7352 Steve Chamberlain made @code{@value{AS}} able to generate listings.
7354 Hewlett-Packard contributed support for the HP9000/300.
7356 Jeff Law wrote GAS and BFD support for the native HPPA object format (SOM)
7357 along with a fairly extensive HPPA testsuite (for both SOM and ELF object
7358 formats). This work was supported by both the Center for Software Science at
7359 the University of Utah and Cygnus Support.
7361 Support for ELF format files has been worked on by Mark Eichin of Cygnus
7362 Support (original, incomplete implementation for SPARC), Pete Hoogenboom and
7363 Jeff Law at the University of Utah (HPPA mainly), Michael Meissner of the Open
7364 Software Foundation (i386 mainly), and Ken Raeburn of Cygnus Support (sparc,
7365 and some initial 64-bit support).
7367 Several engineers at Cygnus Support have also provided many small bug fixes and
7368 configuration enhancements.
7370 Many others have contributed large or small bugfixes and enhancements. If
7371 you have contributed significant work and are not mentioned on this list, and
7372 want to be, let us know. Some of the history has been lost; we are not
7373 intentionally leaving anyone out.