| \input texinfo @c -*-Texinfo-*- |
| @c Copyright (C) 1991-2021 Free Software Foundation, Inc. |
| @c UPDATE!! On future updates-- |
| @c (1) check for new machine-dep cmdline options in |
| @c md_parse_option definitions in config/tc-*.c |
| @c (2) for platform-specific directives, examine md_pseudo_op |
| @c in config/tc-*.c |
| @c (3) for object-format specific directives, examine obj_pseudo_op |
| @c in config/obj-*.c |
| @c (4) portable directives in potable[] in read.c |
| @c %**start of header |
| @setfilename as.info |
| @c ---config--- |
| @macro gcctabopt{body} |
| @code{\body\} |
| @end macro |
| @c defaults, config file may override: |
| @set have-stabs |
| @c --- |
| @c man begin NAME |
| @c --- |
| @include asconfig.texi |
| @include bfdver.texi |
| @c --- |
| @c man end |
| @c --- |
| @c common OR combinations of conditions |
| @ifset COFF |
| @set COFF-ELF |
| @end ifset |
| @ifset ELF |
| @set COFF-ELF |
| @end ifset |
| @ifset AOUT |
| @set aout |
| @end ifset |
| @ifset ARM/Thumb |
| @set ARM |
| @end ifset |
| @ifset Blackfin |
| @set Blackfin |
| @end ifset |
| @ifset BPF |
| @set BPF |
| @end ifset |
| @ifset H8/300 |
| @set H8 |
| @end ifset |
| @ifset SH |
| @set H8 |
| @end ifset |
| @ifset HPPA |
| @set abnormal-separator |
| @end ifset |
| @c ------------ |
| @ifset GENERIC |
| @settitle Using @value{AS} |
| @end ifset |
| @ifclear GENERIC |
| @settitle Using @value{AS} (@value{TARGET}) |
| @end ifclear |
| @setchapternewpage odd |
| @c %**end of header |
| |
| @c @smallbook |
| @c @set SMALL |
| @c WARE! Some of the machine-dependent sections contain tables of machine |
| @c instructions. Except in multi-column format, these tables look silly. |
| @c Unfortunately, Texinfo doesn't have a general-purpose multi-col format, so |
| @c the multi-col format is faked within @example sections. |
| @c |
| @c Again unfortunately, the natural size that fits on a page, for these tables, |
| @c is different depending on whether or not smallbook is turned on. |
| @c This matters, because of order: text flow switches columns at each page |
| @c break. |
| @c |
| @c The format faked in this source works reasonably well for smallbook, |
| @c not well for the default large-page format. This manual expects that if you |
| @c turn on @smallbook, you will also uncomment the "@set SMALL" to enable the |
| @c tables in question. You can turn on one without the other at your |
| @c discretion, of course. |
| @ifinfo |
| @set SMALL |
| @c the insn tables look just as silly in info files regardless of smallbook, |
| @c might as well show 'em anyways. |
| @end ifinfo |
| |
| @ifnottex |
| @dircategory Software development |
| @direntry |
| * As: (as). The GNU assembler. |
| * Gas: (as). The GNU assembler. |
| @end direntry |
| @end ifnottex |
| |
| @finalout |
| @syncodeindex ky cp |
| |
| @copying |
| This file documents the GNU Assembler "@value{AS}". |
| |
| @c man begin COPYRIGHT |
| Copyright @copyright{} 1991-2021 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 |
| or any later version published by the Free Software Foundation; |
| with no Invariant Sections, with no Front-Cover Texts, and with no |
| Back-Cover Texts. A copy of the license is included in the |
| section entitled ``GNU Free Documentation License''. |
| |
| @c man end |
| @end copying |
| |
| @titlepage |
| @title Using @value{AS} |
| @subtitle The @sc{gnu} Assembler |
| @ifclear GENERIC |
| @subtitle for the @value{TARGET} family |
| @end ifclear |
| @ifset VERSION_PACKAGE |
| @sp 1 |
| @subtitle @value{VERSION_PACKAGE} |
| @end ifset |
| @sp 1 |
| @subtitle Version @value{VERSION} |
| @sp 1 |
| @sp 13 |
| The Free Software Foundation Inc.@: thanks The Nice Computer |
| Company of Australia for loaning Dean Elsner to write the |
| first (Vax) version of @command{as} for Project @sc{gnu}. |
| The proprietors, management and staff of TNCCA thank FSF for |
| distracting the boss while they got some work |
| done. |
| @sp 3 |
| @author Dean Elsner, Jay Fenlason & friends |
| @page |
| @tex |
| {\parskip=0pt |
| \hfill {\it Using {\tt @value{AS}}}\par |
| \hfill Edited by Cygnus Support\par |
| } |
| %"boxit" macro for figures: |
| %Modified from Knuth's ``boxit'' macro from TeXbook (answer to exercise 21.3) |
| \gdef\boxit#1#2{\vbox{\hrule\hbox{\vrule\kern3pt |
| \vbox{\parindent=0pt\parskip=0pt\hsize=#1\kern3pt\strut\hfil |
| #2\hfil\strut\kern3pt}\kern3pt\vrule}\hrule}}%box with visible outline |
| \gdef\ibox#1#2{\hbox to #1{#2\hfil}\kern8pt}% invisible box |
| @end tex |
| |
| @vskip 0pt plus 1filll |
| Copyright @copyright{} 1991-2021 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 |
| or any later version published by the Free Software Foundation; |
| with no Invariant Sections, with no Front-Cover Texts, and with no |
| Back-Cover Texts. A copy of the license is included in the |
| section entitled ``GNU Free Documentation License''. |
| |
| @end titlepage |
| @contents |
| |
| @ifnottex |
| @node Top |
| @top Using @value{AS} |
| |
| This file is a user guide to the @sc{gnu} assembler @command{@value{AS}} |
| @ifset VERSION_PACKAGE |
| @value{VERSION_PACKAGE} |
| @end ifset |
| version @value{VERSION}. |
| @ifclear GENERIC |
| This version of the file describes @command{@value{AS}} configured to generate |
| code for @value{TARGET} architectures. |
| @end ifclear |
| |
| This document is distributed under the terms of the GNU Free |
| Documentation License. A copy of the license is included in the |
| section entitled ``GNU Free Documentation License''. |
| |
| @menu |
| * Overview:: Overview |
| * Invoking:: Command-Line Options |
| * Syntax:: Syntax |
| * Sections:: Sections and Relocation |
| * Symbols:: Symbols |
| * Expressions:: Expressions |
| * Pseudo Ops:: Assembler Directives |
| @ifset ELF |
| * Object Attributes:: Object Attributes |
| @end ifset |
| * Machine Dependencies:: Machine Dependent Features |
| * Reporting Bugs:: Reporting Bugs |
| * Acknowledgements:: Who Did What |
| * GNU Free Documentation License:: GNU Free Documentation License |
| * AS Index:: AS Index |
| @end menu |
| @end ifnottex |
| |
| @node Overview |
| @chapter Overview |
| @iftex |
| This manual is a user guide to the @sc{gnu} assembler @command{@value{AS}}. |
| @ifclear GENERIC |
| This version of the manual describes @command{@value{AS}} configured to generate |
| code for @value{TARGET} architectures. |
| @end ifclear |
| @end iftex |
| |
| @cindex invocation summary |
| @cindex option summary |
| @cindex summary of options |
| Here is a brief summary of how to invoke @command{@value{AS}}. For details, |
| see @ref{Invoking,,Command-Line Options}. |
| |
| @c man title AS the portable GNU assembler. |
| |
| @ignore |
| @c man begin SEEALSO |
| gcc(1), ld(1), and the Info entries for @file{binutils} and @file{ld}. |
| @c man end |
| @end ignore |
| |
| @c We don't use deffn and friends for the following because they seem |
| @c to be limited to one line for the header. |
| @smallexample |
| @c man begin SYNOPSIS |
| @value{AS} [@b{-a}[@b{cdghlns}][=@var{file}]] [@b{--alternate}] [@b{-D}] |
| [@b{--compress-debug-sections}] [@b{--nocompress-debug-sections}] |
| [@b{--debug-prefix-map} @var{old}=@var{new}] |
| [@b{--defsym} @var{sym}=@var{val}] [@b{-f}] [@b{-g}] [@b{--gstabs}] |
| [@b{--gstabs+}] [@b{--gdwarf-<N>}] [@b{--gdwarf-sections}] |
| [@b{--gdwarf-cie-version}=@var{VERSION}] |
| [@b{--help}] [@b{-I} @var{dir}] [@b{-J}] |
| [@b{-K}] [@b{-L}] [@b{--listing-lhs-width}=@var{NUM}] |
| [@b{--listing-lhs-width2}=@var{NUM}] [@b{--listing-rhs-width}=@var{NUM}] |
| [@b{--listing-cont-lines}=@var{NUM}] [@b{--keep-locals}] |
| [@b{--no-pad-sections}] |
| [@b{-o} @var{objfile}] [@b{-R}] |
| [@b{--statistics}] |
| [@b{-v}] [@b{-version}] [@b{--version}] |
| [@b{-W}] [@b{--warn}] [@b{--fatal-warnings}] [@b{-w}] [@b{-x}] |
| [@b{-Z}] [@b{@@@var{FILE}}] |
| [@b{--sectname-subst}] [@b{--size-check=[error|warning]}] |
| [@b{--elf-stt-common=[no|yes]}] |
| [@b{--generate-missing-build-notes=[no|yes]}] |
| [@b{--target-help}] [@var{target-options}] |
| [@b{--}|@var{files} @dots{}] |
| @c |
| @c man end |
| @c Target dependent options are listed below. Keep the list sorted. |
| @c Add an empty line for separation. |
| @c man begin TARGET |
| @ifset AARCH64 |
| |
| @emph{Target AArch64 options:} |
| [@b{-EB}|@b{-EL}] |
| [@b{-mabi}=@var{ABI}] |
| @end ifset |
| @ifset ALPHA |
| |
| @emph{Target Alpha options:} |
| [@b{-m@var{cpu}}] |
| [@b{-mdebug} | @b{-no-mdebug}] |
| [@b{-replace} | @b{-noreplace}] |
| [@b{-relax}] [@b{-g}] [@b{-G@var{size}}] |
| [@b{-F}] [@b{-32addr}] |
| @end ifset |
| @ifset ARC |
| |
| @emph{Target ARC options:} |
| [@b{-mcpu=@var{cpu}}] |
| [@b{-mA6}|@b{-mARC600}|@b{-mARC601}|@b{-mA7}|@b{-mARC700}|@b{-mEM}|@b{-mHS}] |
| [@b{-mcode-density}] |
| [@b{-mrelax}] |
| [@b{-EB}|@b{-EL}] |
| @end ifset |
| @ifset ARM |
| |
| @emph{Target ARM options:} |
| @c Don't document the deprecated options |
| [@b{-mcpu}=@var{processor}[+@var{extension}@dots{}]] |
| [@b{-march}=@var{architecture}[+@var{extension}@dots{}]] |
| [@b{-mfpu}=@var{floating-point-format}] |
| [@b{-mfloat-abi}=@var{abi}] |
| [@b{-meabi}=@var{ver}] |
| [@b{-mthumb}] |
| [@b{-EB}|@b{-EL}] |
| [@b{-mapcs-32}|@b{-mapcs-26}|@b{-mapcs-float}| |
| @b{-mapcs-reentrant}] |
| [@b{-mthumb-interwork}] [@b{-k}] |
| @end ifset |
| @ifset Blackfin |
| |
| @emph{Target Blackfin options:} |
| [@b{-mcpu}=@var{processor}[-@var{sirevision}]] |
| [@b{-mfdpic}] |
| [@b{-mno-fdpic}] |
| [@b{-mnopic}] |
| @end ifset |
| @ifset BPF |
| |
| @emph{Target BPF options:} |
| [@b{-EL}] [@b{-EB}] |
| @end ifset |
| @ifset CRIS |
| |
| @emph{Target CRIS options:} |
| [@b{--underscore} | @b{--no-underscore}] |
| [@b{--pic}] [@b{-N}] |
| [@b{--emulation=criself} | @b{--emulation=crisaout}] |
| [@b{--march=v0_v10} | @b{--march=v10} | @b{--march=v32} | @b{--march=common_v10_v32}] |
| @c Deprecated -- deliberately not documented. |
| @c [@b{-h}] [@b{-H}] |
| @end ifset |
| @ifset CSKY |
| |
| @emph{Target C-SKY options:} |
| [@b{-march=@var{arch}}] [@b{-mcpu=@var{cpu}}] |
| [@b{-EL}] [@b{-mlittle-endian}] [@b{-EB}] [@b{-mbig-endian}] |
| [@b{-fpic}] [@b{-pic}] |
| [@b{-mljump}] [@b{-mno-ljump}] |
| [@b{-force2bsr}] [@b{-mforce2bsr}] [@b{-no-force2bsr}] [@b{-mno-force2bsr}] |
| [@b{-jsri2bsr}] [@b{-mjsri2bsr}] [@b{-no-jsri2bsr }] [@b{-mno-jsri2bsr}] |
| [@b{-mnolrw }] [@b{-mno-lrw}] |
| [@b{-melrw}] [@b{-mno-elrw}] |
| [@b{-mlaf }] [@b{-mliterals-after-func}] |
| [@b{-mno-laf}] [@b{-mno-literals-after-func}] |
| [@b{-mlabr}] [@b{-mliterals-after-br}] |
| [@b{-mno-labr}] [@b{-mnoliterals-after-br}] |
| [@b{-mistack}] [@b{-mno-istack}] |
| [@b{-mhard-float}] [@b{-mmp}] [@b{-mcp}] [@b{-mcache}] |
| [@b{-msecurity}] [@b{-mtrust}] |
| [@b{-mdsp}] [@b{-medsp}] [@b{-mvdsp}] |
| @end ifset |
| @ifset D10V |
| |
| @emph{Target D10V options:} |
| [@b{-O}] |
| @end ifset |
| @ifset D30V |
| |
| @emph{Target D30V options:} |
| [@b{-O}|@b{-n}|@b{-N}] |
| @end ifset |
| @ifset EPIPHANY |
| |
| @emph{Target EPIPHANY options:} |
| [@b{-mepiphany}|@b{-mepiphany16}] |
| @end ifset |
| @ifset H8 |
| |
| @emph{Target H8/300 options:} |
| [-h-tick-hex] |
| @end ifset |
| @ifset HPPA |
| @c HPPA has no machine-dependent assembler options (yet). |
| @end ifset |
| @ifset I80386 |
| |
| @emph{Target i386 options:} |
| [@b{--32}|@b{--x32}|@b{--64}] [@b{-n}] |
| [@b{-march}=@var{CPU}[+@var{EXTENSION}@dots{}]] [@b{-mtune}=@var{CPU}] |
| @end ifset |
| @ifset IA64 |
| |
| @emph{Target IA-64 options:} |
| [@b{-mconstant-gp}|@b{-mauto-pic}] |
| [@b{-milp32}|@b{-milp64}|@b{-mlp64}|@b{-mp64}] |
| [@b{-mle}|@b{mbe}] |
| [@b{-mtune=itanium1}|@b{-mtune=itanium2}] |
| [@b{-munwind-check=warning}|@b{-munwind-check=error}] |
| [@b{-mhint.b=ok}|@b{-mhint.b=warning}|@b{-mhint.b=error}] |
| [@b{-x}|@b{-xexplicit}] [@b{-xauto}] [@b{-xdebug}] |
| @end ifset |
| @ifset IP2K |
| |
| @emph{Target IP2K options:} |
| [@b{-mip2022}|@b{-mip2022ext}] |
| @end ifset |
| @ifset M32C |
| |
| @emph{Target M32C options:} |
| [@b{-m32c}|@b{-m16c}] [-relax] [-h-tick-hex] |
| @end ifset |
| @ifset M32R |
| |
| @emph{Target M32R options:} |
| [@b{--m32rx}|@b{--[no-]warn-explicit-parallel-conflicts}| |
| @b{--W[n]p}] |
| @end ifset |
| @ifset M680X0 |
| |
| @emph{Target M680X0 options:} |
| [@b{-l}] [@b{-m68000}|@b{-m68010}|@b{-m68020}|@dots{}] |
| @end ifset |
| @ifset M68HC11 |
| |
| @emph{Target M68HC11 options:} |
| [@b{-m68hc11}|@b{-m68hc12}|@b{-m68hcs12}|@b{-mm9s12x}|@b{-mm9s12xg}] |
| [@b{-mshort}|@b{-mlong}] |
| [@b{-mshort-double}|@b{-mlong-double}] |
| [@b{--force-long-branches}] [@b{--short-branches}] |
| [@b{--strict-direct-mode}] [@b{--print-insn-syntax}] |
| [@b{--print-opcodes}] [@b{--generate-example}] |
| @end ifset |
| @ifset MCORE |
| |
| @emph{Target MCORE options:} |
| [@b{-jsri2bsr}] [@b{-sifilter}] [@b{-relax}] |
| [@b{-mcpu=[210|340]}] |
| @end ifset |
| @ifset METAG |
| |
| @emph{Target Meta options:} |
| [@b{-mcpu=@var{cpu}}] [@b{-mfpu=@var{cpu}}] [@b{-mdsp=@var{cpu}}] |
| @end ifset |
| @ifset MICROBLAZE |
| @emph{Target MICROBLAZE options:} |
| @c MicroBlaze has no machine-dependent assembler options. |
| @end ifset |
| @ifset MIPS |
| |
| @emph{Target MIPS options:} |
| [@b{-nocpp}] [@b{-EL}] [@b{-EB}] [@b{-O}[@var{optimization level}]] |
| [@b{-g}[@var{debug level}]] [@b{-G} @var{num}] [@b{-KPIC}] [@b{-call_shared}] |
| [@b{-non_shared}] [@b{-xgot} [@b{-mvxworks-pic}] |
| [@b{-mabi}=@var{ABI}] [@b{-32}] [@b{-n32}] [@b{-64}] [@b{-mfp32}] [@b{-mgp32}] |
| [@b{-mfp64}] [@b{-mgp64}] [@b{-mfpxx}] |
| [@b{-modd-spreg}] [@b{-mno-odd-spreg}] |
| [@b{-march}=@var{CPU}] [@b{-mtune}=@var{CPU}] [@b{-mips1}] [@b{-mips2}] |
| [@b{-mips3}] [@b{-mips4}] [@b{-mips5}] [@b{-mips32}] [@b{-mips32r2}] |
| [@b{-mips32r3}] [@b{-mips32r5}] [@b{-mips32r6}] [@b{-mips64}] [@b{-mips64r2}] |
| [@b{-mips64r3}] [@b{-mips64r5}] [@b{-mips64r6}] |
| [@b{-construct-floats}] [@b{-no-construct-floats}] |
| [@b{-mignore-branch-isa}] [@b{-mno-ignore-branch-isa}] |
| [@b{-mnan=@var{encoding}}] |
| [@b{-trap}] [@b{-no-break}] [@b{-break}] [@b{-no-trap}] |
| [@b{-mips16}] [@b{-no-mips16}] |
| [@b{-mmips16e2}] [@b{-mno-mips16e2}] |
| [@b{-mmicromips}] [@b{-mno-micromips}] |
| [@b{-msmartmips}] [@b{-mno-smartmips}] |
| [@b{-mips3d}] [@b{-no-mips3d}] |
| [@b{-mdmx}] [@b{-no-mdmx}] |
| [@b{-mdsp}] [@b{-mno-dsp}] |
| [@b{-mdspr2}] [@b{-mno-dspr2}] |
| [@b{-mdspr3}] [@b{-mno-dspr3}] |
| [@b{-mmsa}] [@b{-mno-msa}] |
| [@b{-mxpa}] [@b{-mno-xpa}] |
| [@b{-mmt}] [@b{-mno-mt}] |
| [@b{-mmcu}] [@b{-mno-mcu}] |
| [@b{-mcrc}] [@b{-mno-crc}] |
| [@b{-mginv}] [@b{-mno-ginv}] |
| [@b{-mloongson-mmi}] [@b{-mno-loongson-mmi}] |
| [@b{-mloongson-cam}] [@b{-mno-loongson-cam}] |
| [@b{-mloongson-ext}] [@b{-mno-loongson-ext}] |
| [@b{-mloongson-ext2}] [@b{-mno-loongson-ext2}] |
| [@b{-minsn32}] [@b{-mno-insn32}] |
| [@b{-mfix7000}] [@b{-mno-fix7000}] |
| [@b{-mfix-rm7000}] [@b{-mno-fix-rm7000}] |
| [@b{-mfix-vr4120}] [@b{-mno-fix-vr4120}] |
| [@b{-mfix-vr4130}] [@b{-mno-fix-vr4130}] |
| [@b{-mfix-r5900}] [@b{-mno-fix-r5900}] |
| [@b{-mdebug}] [@b{-no-mdebug}] |
| [@b{-mpdr}] [@b{-mno-pdr}] |
| @end ifset |
| @ifset MMIX |
| |
| @emph{Target MMIX options:} |
| [@b{--fixed-special-register-names}] [@b{--globalize-symbols}] |
| [@b{--gnu-syntax}] [@b{--relax}] [@b{--no-predefined-symbols}] |
| [@b{--no-expand}] [@b{--no-merge-gregs}] [@b{-x}] |
| [@b{--linker-allocated-gregs}] |
| @end ifset |
| @ifset NIOSII |
| |
| @emph{Target Nios II options:} |
| [@b{-relax-all}] [@b{-relax-section}] [@b{-no-relax}] |
| [@b{-EB}] [@b{-EL}] |
| @end ifset |
| @ifset NDS32 |
| |
| @emph{Target NDS32 options:} |
| [@b{-EL}] [@b{-EB}] [@b{-O}] [@b{-Os}] [@b{-mcpu=@var{cpu}}] |
| [@b{-misa=@var{isa}}] [@b{-mabi=@var{abi}}] [@b{-mall-ext}] |
| [@b{-m[no-]16-bit}] [@b{-m[no-]perf-ext}] [@b{-m[no-]perf2-ext}] |
| [@b{-m[no-]string-ext}] [@b{-m[no-]dsp-ext}] [@b{-m[no-]mac}] [@b{-m[no-]div}] |
| [@b{-m[no-]audio-isa-ext}] [@b{-m[no-]fpu-sp-ext}] [@b{-m[no-]fpu-dp-ext}] |
| [@b{-m[no-]fpu-fma}] [@b{-mfpu-freg=@var{FREG}}] [@b{-mreduced-regs}] |
| [@b{-mfull-regs}] [@b{-m[no-]dx-regs}] [@b{-mpic}] [@b{-mno-relax}] |
| [@b{-mb2bb}] |
| @end ifset |
| @ifset OPENRISC |
| @c OpenRISC has no machine-dependent assembler options. |
| @end ifset |
| @ifset PDP11 |
| |
| @emph{Target PDP11 options:} |
| [@b{-mpic}|@b{-mno-pic}] [@b{-mall}] [@b{-mno-extensions}] |
| [@b{-m}@var{extension}|@b{-mno-}@var{extension}] |
| [@b{-m}@var{cpu}] [@b{-m}@var{machine}] |
| @end ifset |
| @ifset PJ |
| |
| @emph{Target picoJava options:} |
| [@b{-mb}|@b{-me}] |
| @end ifset |
| @ifset PPC |
| |
| @emph{Target PowerPC options:} |
| [@b{-a32}|@b{-a64}] |
| [@b{-mpwrx}|@b{-mpwr2}|@b{-mpwr}|@b{-m601}|@b{-mppc}|@b{-mppc32}|@b{-m603}|@b{-m604}|@b{-m403}|@b{-m405}| |
| @b{-m440}|@b{-m464}|@b{-m476}|@b{-m7400}|@b{-m7410}|@b{-m7450}|@b{-m7455}|@b{-m750cl}|@b{-mgekko}| |
| @b{-mbroadway}|@b{-mppc64}|@b{-m620}|@b{-me500}|@b{-e500x2}|@b{-me500mc}|@b{-me500mc64}|@b{-me5500}| |
| @b{-me6500}|@b{-mppc64bridge}|@b{-mbooke}|@b{-mpower4}|@b{-mpwr4}|@b{-mpower5}|@b{-mpwr5}|@b{-mpwr5x}| |
| @b{-mpower6}|@b{-mpwr6}|@b{-mpower7}|@b{-mpwr7}|@b{-mpower8}|@b{-mpwr8}|@b{-mpower9}|@b{-mpwr9}@b{-ma2}| |
| @b{-mcell}|@b{-mspe}|@b{-mspe2}|@b{-mtitan}|@b{-me300}|@b{-mcom}] |
| [@b{-many}] [@b{-maltivec}|@b{-mvsx}|@b{-mhtm}|@b{-mvle}] |
| [@b{-mregnames}|@b{-mno-regnames}] |
| [@b{-mrelocatable}|@b{-mrelocatable-lib}|@b{-K PIC}] [@b{-memb}] |
| [@b{-mlittle}|@b{-mlittle-endian}|@b{-le}|@b{-mbig}|@b{-mbig-endian}|@b{-be}] |
| [@b{-msolaris}|@b{-mno-solaris}] |
| [@b{-nops=@var{count}}] |
| @end ifset |
| @ifset PRU |
| |
| @emph{Target PRU options:} |
| [@b{-link-relax}] |
| [@b{-mnolink-relax}] |
| [@b{-mno-warn-regname-label}] |
| @end ifset |
| @ifset RISCV |
| |
| @emph{Target RISC-V options:} |
| [@b{-fpic}|@b{-fPIC}|@b{-fno-pic}] |
| [@b{-march}=@var{ISA}] |
| [@b{-mabi}=@var{ABI}] |
| [@b{-mlittle-endian}|@b{-mbig-endian}] |
| @end ifset |
| @ifset RL78 |
| |
| @emph{Target RL78 options:} |
| [@b{-mg10}] |
| [@b{-m32bit-doubles}|@b{-m64bit-doubles}] |
| @end ifset |
| @ifset RX |
| |
| @emph{Target RX options:} |
| [@b{-mlittle-endian}|@b{-mbig-endian}] |
| [@b{-m32bit-doubles}|@b{-m64bit-doubles}] |
| [@b{-muse-conventional-section-names}] |
| [@b{-msmall-data-limit}] |
| [@b{-mpid}] |
| [@b{-mrelax}] |
| [@b{-mint-register=@var{number}}] |
| [@b{-mgcc-abi}|@b{-mrx-abi}] |
| @end ifset |
| @ifset S390 |
| |
| @emph{Target s390 options:} |
| [@b{-m31}|@b{-m64}] [@b{-mesa}|@b{-mzarch}] [@b{-march}=@var{CPU}] |
| [@b{-mregnames}|@b{-mno-regnames}] |
| [@b{-mwarn-areg-zero}] |
| @end ifset |
| @ifset SCORE |
| |
| @emph{Target SCORE options:} |
| [@b{-EB}][@b{-EL}][@b{-FIXDD}][@b{-NWARN}] |
| [@b{-SCORE5}][@b{-SCORE5U}][@b{-SCORE7}][@b{-SCORE3}] |
| [@b{-march=score7}][@b{-march=score3}] |
| [@b{-USE_R1}][@b{-KPIC}][@b{-O0}][@b{-G} @var{num}][@b{-V}] |
| @end ifset |
| @ifset SPARC |
| |
| @emph{Target SPARC options:} |
| @c The order here is important. See c-sparc.texi. |
| [@b{-Av6}|@b{-Av7}|@b{-Av8}|@b{-Aleon}|@b{-Asparclet}|@b{-Asparclite} |
| @b{-Av8plus}|@b{-Av8plusa}|@b{-Av8plusb}|@b{-Av8plusc}|@b{-Av8plusd} |
| @b{-Av8plusv}|@b{-Av8plusm}|@b{-Av9}|@b{-Av9a}|@b{-Av9b}|@b{-Av9c} |
| @b{-Av9d}|@b{-Av9e}|@b{-Av9v}|@b{-Av9m}|@b{-Asparc}|@b{-Asparcvis} |
| @b{-Asparcvis2}|@b{-Asparcfmaf}|@b{-Asparcima}|@b{-Asparcvis3} |
| @b{-Asparcvisr}|@b{-Asparc5}] |
| [@b{-xarch=v8plus}|@b{-xarch=v8plusa}]|@b{-xarch=v8plusb}|@b{-xarch=v8plusc} |
| @b{-xarch=v8plusd}|@b{-xarch=v8plusv}|@b{-xarch=v8plusm}|@b{-xarch=v9} |
| @b{-xarch=v9a}|@b{-xarch=v9b}|@b{-xarch=v9c}|@b{-xarch=v9d}|@b{-xarch=v9e} |
| @b{-xarch=v9v}|@b{-xarch=v9m}|@b{-xarch=sparc}|@b{-xarch=sparcvis} |
| @b{-xarch=sparcvis2}|@b{-xarch=sparcfmaf}|@b{-xarch=sparcima} |
| @b{-xarch=sparcvis3}|@b{-xarch=sparcvisr}|@b{-xarch=sparc5} |
| @b{-bump}] |
| [@b{-32}|@b{-64}] |
| [@b{--enforce-aligned-data}][@b{--dcti-couples-detect}] |
| @end ifset |
| @ifset TIC54X |
| |
| @emph{Target TIC54X options:} |
| [@b{-mcpu=54[123589]}|@b{-mcpu=54[56]lp}] [@b{-mfar-mode}|@b{-mf}] |
| [@b{-merrors-to-file} @var{<filename>}|@b{-me} @var{<filename>}] |
| @end ifset |
| @ifset TIC6X |
| |
| @emph{Target TIC6X options:} |
| [@b{-march=@var{arch}}] [@b{-mbig-endian}|@b{-mlittle-endian}] |
| [@b{-mdsbt}|@b{-mno-dsbt}] [@b{-mpid=no}|@b{-mpid=near}|@b{-mpid=far}] |
| [@b{-mpic}|@b{-mno-pic}] |
| @end ifset |
| @ifset TILEGX |
| |
| @emph{Target TILE-Gx options:} |
| [@b{-m32}|@b{-m64}][@b{-EB}][@b{-EL}] |
| @end ifset |
| @ifset TILEPRO |
| @c TILEPro has no machine-dependent assembler options |
| @end ifset |
| @ifset VISIUM |
| |
| @emph{Target Visium options:} |
| [@b{-mtune=@var{arch}}] |
| @end ifset |
| @ifset XTENSA |
| |
| @emph{Target Xtensa options:} |
| [@b{--[no-]text-section-literals}] [@b{--[no-]auto-litpools}] |
| [@b{--[no-]absolute-literals}] |
| [@b{--[no-]target-align}] [@b{--[no-]longcalls}] |
| [@b{--[no-]transform}] |
| [@b{--rename-section} @var{oldname}=@var{newname}] |
| [@b{--[no-]trampolines}] |
| [@b{--abi-windowed}|@b{--abi-call0}] |
| @end ifset |
| @ifset Z80 |
| |
| @emph{Target Z80 options:} |
| [@b{-march=@var{CPU}@var{[-EXT]}@var{[+EXT]}}] |
| [@b{-local-prefix=}@var{PREFIX}] |
| [@b{-colonless}] |
| [@b{-sdcc}] |
| [@b{-fp-s=}@var{FORMAT}] |
| [@b{-fp-d=}@var{FORMAT}] |
| @end ifset |
| @ifset Z8000 |
| |
| @c Z8000 has no machine-dependent assembler options |
| @end ifset |
| |
| @c man end |
| @end smallexample |
| |
| @c man begin OPTIONS |
| |
| @table @gcctabopt |
| @include at-file.texi |
| |
| @item -a[cdghlmns] |
| Turn on listings, in any of a variety of ways: |
| |
| @table @gcctabopt |
| @item -ac |
| omit false conditionals |
| |
| @item -ad |
| omit debugging directives |
| |
| @item -ag |
| include general information, like @value{AS} version and options passed |
| |
| @item -ah |
| include high-level source |
| |
| @item -al |
| include assembly |
| |
| @item -am |
| include macro expansions |
| |
| @item -an |
| omit forms processing |
| |
| @item -as |
| include symbols |
| |
| @item =file |
| set the name of the listing file |
| @end table |
| |
| You may combine these options; for example, use @samp{-aln} for assembly |
| listing without forms processing. The @samp{=file} option, if used, must be |
| the last one. By itself, @samp{-a} defaults to @samp{-ahls}. |
| |
| @item --alternate |
| Begin in alternate macro mode. |
| @ifclear man |
| @xref{Altmacro,,@code{.altmacro}}. |
| @end ifclear |
| |
| @item --compress-debug-sections |
| Compress DWARF debug sections using zlib with SHF_COMPRESSED from the |
| ELF ABI. The resulting object file may not be compatible with older |
| linkers and object file utilities. Note if compression would make a |
| given section @emph{larger} then it is not compressed. |
| |
| @ifset ELF |
| @cindex @samp{--compress-debug-sections=} option |
| @item --compress-debug-sections=none |
| @itemx --compress-debug-sections=zlib |
| @itemx --compress-debug-sections=zlib-gnu |
| @itemx --compress-debug-sections=zlib-gabi |
| These options control how DWARF debug sections are compressed. |
| @option{--compress-debug-sections=none} is equivalent to |
| @option{--nocompress-debug-sections}. |
| @option{--compress-debug-sections=zlib} and |
| @option{--compress-debug-sections=zlib-gabi} are equivalent to |
| @option{--compress-debug-sections}. |
| @option{--compress-debug-sections=zlib-gnu} compresses DWARF debug |
| sections using zlib. The debug sections are renamed to begin with |
| @samp{.zdebug}. Note if compression would make a given section |
| @emph{larger} then it is not compressed nor renamed. |
| |
| @end ifset |
| |
| @item --nocompress-debug-sections |
| Do not compress DWARF debug sections. This is usually the default for all |
| targets except the x86/x86_64, but a configure time option can be used to |
| override this. |
| |
| @item -D |
| Ignored. This option is accepted for script compatibility with calls to |
| other assemblers. |
| |
| @item --debug-prefix-map @var{old}=@var{new} |
| When assembling files in directory @file{@var{old}}, record debugging |
| information describing them as in @file{@var{new}} instead. |
| |
| @item --defsym @var{sym}=@var{value} |
| Define the symbol @var{sym} to be @var{value} before assembling the input file. |
| @var{value} must be an integer constant. As in C, a leading @samp{0x} |
| indicates a hexadecimal value, and a leading @samp{0} indicates an octal |
| value. The value of the symbol can be overridden inside a source file via the |
| use of a @code{.set} pseudo-op. |
| |
| @item -f |
| ``fast''---skip whitespace and comment preprocessing (assume source is |
| compiler output). |
| |
| @item -g |
| @itemx --gen-debug |
| Generate debugging information for each assembler source line using whichever |
| debug format is preferred by the target. This currently means either STABS, |
| ECOFF or DWARF2. When the debug format is DWARF then a @code{.debug_info} and |
| @code{.debug_line} section is only emitted when the assembly file doesn't |
| generate one itself. |
| |
| @item --gstabs |
| Generate stabs debugging information for each assembler line. This |
| may help debugging assembler code, if the debugger can handle it. |
| |
| @item --gstabs+ |
| Generate stabs debugging information for each assembler line, with GNU |
| extensions that probably only gdb can handle, and that could make other |
| debuggers crash or refuse to read your program. This |
| may help debugging assembler code. Currently the only GNU extension is |
| the location of the current working directory at assembling time. |
| |
| @item --gdwarf-2 |
| Generate DWARF2 debugging information for each assembler line. This |
| may help debugging assembler code, if the debugger can handle it. Note---this |
| option is only supported by some targets, not all of them. |
| |
| @item --gdwarf-3 |
| This option is the same as the @option{--gdwarf-2} option, except that it |
| allows for the possibility of the generation of extra debug information as per |
| version 3 of the DWARF specification. Note - enabling this option does not |
| guarantee the generation of any extra information, the choice to do so is on a |
| per target basis. |
| |
| @item --gdwarf-4 |
| This option is the same as the @option{--gdwarf-2} option, except that it |
| allows for the possibility of the generation of extra debug information as per |
| version 4 of the DWARF specification. Note - enabling this option does not |
| guarantee the generation of any extra information, the choice to do so is on a |
| per target basis. |
| |
| @item --gdwarf-5 |
| This option is the same as the @option{--gdwarf-2} option, except that it |
| allows for the possibility of the generation of extra debug information as per |
| version 5 of the DWARF specification. Note - enabling this option does not |
| guarantee the generation of any extra information, the choice to do so is on a |
| per target basis. |
| |
| @item --gdwarf-sections |
| Instead of creating a .debug_line section, create a series of |
| .debug_line.@var{foo} sections where @var{foo} is the name of the |
| corresponding code section. For example a code section called @var{.text.func} |
| will have its dwarf line number information placed into a section called |
| @var{.debug_line.text.func}. If the code section is just called @var{.text} |
| then debug line section will still be called just @var{.debug_line} without any |
| suffix. |
| |
| @item --gdwarf-cie-version=@var{version} |
| Control which version of DWARF Common Information Entries (CIEs) are produced. |
| When this flag is not specificed the default is version 1, though some targets |
| can modify this default. Other possible values for @var{version} are 3 or 4. |
| |
| @ifset ELF |
| @item --size-check=error |
| @itemx --size-check=warning |
| Issue an error or warning for invalid ELF .size directive. |
| |
| @item --elf-stt-common=no |
| @itemx --elf-stt-common=yes |
| These options control whether the ELF assembler should generate common |
| symbols with the @code{STT_COMMON} type. The default can be controlled |
| by a configure option @option{--enable-elf-stt-common}. |
| |
| @item --generate-missing-build-notes=yes |
| @itemx --generate-missing-build-notes=no |
| These options control whether the ELF assembler should generate GNU Build |
| attribute notes if none are present in the input sources. |
| The default can be controlled by the @option{--enable-generate-build-notes} |
| configure option. |
| |
| @end ifset |
| |
| @item --help |
| Print a summary of the command-line options and exit. |
| |
| @item --target-help |
| Print a summary of all target specific options and exit. |
| |
| @item -I @var{dir} |
| Add directory @var{dir} to the search list for @code{.include} directives. |
| |
| @item -J |
| Don't warn about signed overflow. |
| |
| @item -K |
| @ifclear DIFF-TBL-KLUGE |
| This option is accepted but has no effect on the @value{TARGET} family. |
| @end ifclear |
| @ifset DIFF-TBL-KLUGE |
| Issue warnings when difference tables altered for long displacements. |
| @end ifset |
| |
| @item -L |
| @itemx --keep-locals |
| Keep (in the symbol table) local symbols. These symbols start with |
| system-specific local label prefixes, typically @samp{.L} for ELF systems |
| or @samp{L} for traditional a.out systems. |
| @ifclear man |
| @xref{Symbol Names}. |
| @end ifclear |
| |
| @item --listing-lhs-width=@var{number} |
| Set the maximum width, in words, of the output data column for an assembler |
| listing to @var{number}. |
| |
| @item --listing-lhs-width2=@var{number} |
| Set the maximum width, in words, of the output data column for continuation |
| lines in an assembler listing to @var{number}. |
| |
| @item --listing-rhs-width=@var{number} |
| Set the maximum width of an input source line, as displayed in a listing, to |
| @var{number} bytes. |
| |
| @item --listing-cont-lines=@var{number} |
| Set the maximum number of lines printed in a listing for a single line of input |
| to @var{number} + 1. |
| |
| @item --no-pad-sections |
| Stop the assembler for padding the ends of output sections to the alignment |
| of that section. The default is to pad the sections, but this can waste space |
| which might be needed on targets which have tight memory constraints. |
| |
| @item -o @var{objfile} |
| Name the object-file output from @command{@value{AS}} @var{objfile}. |
| |
| @item -R |
| Fold the data section into the text section. |
| |
| @ifset ELF |
| @item --sectname-subst |
| Honor substitution sequences in section names. |
| @ifclear man |
| @xref{Section Name Substitutions,,@code{.section @var{name}}}. |
| @end ifclear |
| @end ifset |
| |
| @item --statistics |
| Print the maximum space (in bytes) and total time (in seconds) used by |
| assembly. |
| |
| @item --strip-local-absolute |
| Remove local absolute symbols from the outgoing symbol table. |
| |
| @item -v |
| @itemx -version |
| Print the @command{as} version. |
| |
| @item --version |
| Print the @command{as} version and exit. |
| |
| @item -W |
| @itemx --no-warn |
| Suppress warning messages. |
| |
| @item --fatal-warnings |
| Treat warnings as errors. |
| |
| @item --warn |
| Don't suppress warning messages or treat them as errors. |
| |
| @item -w |
| Ignored. |
| |
| @item -x |
| Ignored. |
| |
| @item -Z |
| Generate an object file even after errors. |
| |
| @item -- | @var{files} @dots{} |
| Standard input, or source files to assemble. |
| |
| @end table |
| @c man end |
| |
| @ifset AARCH64 |
| |
| @ifclear man |
| @xref{AArch64 Options}, for the options available when @value{AS} is configured |
| for the 64-bit mode of the ARM Architecture (AArch64). |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for the |
| 64-bit mode of the ARM Architecture (AArch64). |
| @c man end |
| @c man begin INCLUDE |
| @include c-aarch64.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset ALPHA |
| |
| @ifclear man |
| @xref{Alpha Options}, for the options available when @value{AS} is configured |
| for an Alpha processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for an Alpha |
| processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-alpha.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @c man begin OPTIONS |
| @ifset ARC |
| The following options are available when @value{AS} is configured for an ARC |
| processor. |
| |
| @table @gcctabopt |
| @item -mcpu=@var{cpu} |
| This option selects the core processor variant. |
| @item -EB | -EL |
| Select either big-endian (-EB) or little-endian (-EL) output. |
| @item -mcode-density |
| Enable Code Density extension instructions. |
| @end table |
| @end ifset |
| |
| @ifset ARM |
| The following options are available when @value{AS} is configured for the ARM |
| processor family. |
| |
| @table @gcctabopt |
| @item -mcpu=@var{processor}[+@var{extension}@dots{}] |
| Specify which ARM processor variant is the target. |
| @item -march=@var{architecture}[+@var{extension}@dots{}] |
| Specify which ARM architecture variant is used by the target. |
| @item -mfpu=@var{floating-point-format} |
| Select which Floating Point architecture is the target. |
| @item -mfloat-abi=@var{abi} |
| Select which floating point ABI is in use. |
| @item -mthumb |
| Enable Thumb only instruction decoding. |
| @item -mapcs-32 | -mapcs-26 | -mapcs-float | -mapcs-reentrant |
| Select which procedure calling convention is in use. |
| @item -EB | -EL |
| Select either big-endian (-EB) or little-endian (-EL) output. |
| @item -mthumb-interwork |
| Specify that the code has been generated with interworking between Thumb and |
| ARM code in mind. |
| @item -mccs |
| Turns on CodeComposer Studio assembly syntax compatibility mode. |
| @item -k |
| Specify that PIC code has been generated. |
| @end table |
| @end ifset |
| @c man end |
| |
| @ifset Blackfin |
| |
| @ifclear man |
| @xref{Blackfin Options}, for the options available when @value{AS} is |
| configured for the Blackfin processor family. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for |
| the Blackfin processor family. |
| @c man end |
| @c man begin INCLUDE |
| @include c-bfin.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset BPF |
| |
| @ifclear man |
| @xref{BPF Options}, for the options available when @value{AS} is |
| configured for the Linux kernel BPF processor family. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for |
| the Linux kernel BPF processor family. |
| @c man end |
| @c man begin INCLUDE |
| @include c-bpf.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @c man begin OPTIONS |
| @ifset CRIS |
| See the info pages for documentation of the CRIS-specific options. |
| @end ifset |
| |
| @ifset CSKY |
| |
| @ifclear man |
| @xref{C-SKY Options}, for the options available when @value{AS} is |
| configured for the C-SKY processor family. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for |
| the C-SKY processor family. |
| @c man end |
| @c man begin INCLUDE |
| @include c-csky.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset D10V |
| The following options are available when @value{AS} is configured for |
| a D10V processor. |
| @table @gcctabopt |
| @cindex D10V optimization |
| @cindex optimization, D10V |
| @item -O |
| Optimize output by parallelizing instructions. |
| @end table |
| @end ifset |
| |
| @ifset D30V |
| The following options are available when @value{AS} is configured for a D30V |
| processor. |
| @table @gcctabopt |
| @cindex D30V optimization |
| @cindex optimization, D30V |
| @item -O |
| Optimize output by parallelizing instructions. |
| |
| @cindex D30V nops |
| @item -n |
| Warn when nops are generated. |
| |
| @cindex D30V nops after 32-bit multiply |
| @item -N |
| Warn when a nop after a 32-bit multiply instruction is generated. |
| @end table |
| @end ifset |
| @c man end |
| |
| @ifset EPIPHANY |
| The following options are available when @value{AS} is configured for the |
| Adapteva EPIPHANY series. |
| |
| @ifclear man |
| @xref{Epiphany Options}, for the options available when @value{AS} is |
| configured for an Epiphany processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for |
| an Epiphany processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-epiphany.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset H8300 |
| |
| @ifclear man |
| @xref{H8/300 Options}, for the options available when @value{AS} is configured |
| for an H8/300 processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for an H8/300 |
| processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-h8300.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset I80386 |
| |
| @ifclear man |
| @xref{i386-Options}, for the options available when @value{AS} is |
| configured for an i386 processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for |
| an i386 processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-i386.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @c man begin OPTIONS |
| @ifset IP2K |
| The following options are available when @value{AS} is configured for the |
| Ubicom IP2K series. |
| |
| @table @gcctabopt |
| |
| @item -mip2022ext |
| Specifies that the extended IP2022 instructions are allowed. |
| |
| @item -mip2022 |
| Restores the default behaviour, which restricts the permitted instructions to |
| just the basic IP2022 ones. |
| |
| @end table |
| @end ifset |
| |
| @ifset M32C |
| The following options are available when @value{AS} is configured for the |
| Renesas M32C and M16C processors. |
| |
| @table @gcctabopt |
| |
| @item -m32c |
| Assemble M32C instructions. |
| |
| @item -m16c |
| Assemble M16C instructions (the default). |
| |
| @item -relax |
| Enable support for link-time relaxations. |
| |
| @item -h-tick-hex |
| Support H'00 style hex constants in addition to 0x00 style. |
| |
| @end table |
| @end ifset |
| |
| @ifset M32R |
| The following options are available when @value{AS} is configured for the |
| Renesas M32R (formerly Mitsubishi M32R) series. |
| |
| @table @gcctabopt |
| |
| @item --m32rx |
| Specify which processor in the M32R family is the target. The default |
| is normally the M32R, but this option changes it to the M32RX. |
| |
| @item --warn-explicit-parallel-conflicts or --Wp |
| Produce warning messages when questionable parallel constructs are |
| encountered. |
| |
| @item --no-warn-explicit-parallel-conflicts or --Wnp |
| Do not produce warning messages when questionable parallel constructs are |
| encountered. |
| |
| @end table |
| @end ifset |
| |
| @ifset M680X0 |
| The following options are available when @value{AS} is configured for the |
| Motorola 68000 series. |
| |
| @table @gcctabopt |
| |
| @item -l |
| Shorten references to undefined symbols, to one word instead of two. |
| |
| @item -m68000 | -m68008 | -m68010 | -m68020 | -m68030 |
| @itemx | -m68040 | -m68060 | -m68302 | -m68331 | -m68332 |
| @itemx | -m68333 | -m68340 | -mcpu32 | -m5200 |
| Specify what processor in the 68000 family is the target. The default |
| is normally the 68020, but this can be changed at configuration time. |
| |
| @item -m68881 | -m68882 | -mno-68881 | -mno-68882 |
| The target machine does (or does not) have a floating-point coprocessor. |
| The default is to assume a coprocessor for 68020, 68030, and cpu32. Although |
| the basic 68000 is not compatible with the 68881, a combination of the |
| two can be specified, since it's possible to do emulation of the |
| coprocessor instructions with the main processor. |
| |
| @item -m68851 | -mno-68851 |
| The target machine does (or does not) have a memory-management |
| unit coprocessor. The default is to assume an MMU for 68020 and up. |
| |
| @end table |
| @end ifset |
| |
| @ifset NIOSII |
| |
| @ifclear man |
| @xref{Nios II Options}, for the options available when @value{AS} is configured |
| for an Altera Nios II processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for an |
| Altera Nios II processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-nios2.texi |
| @c ended inside the included file |
| @end ifset |
| @end ifset |
| |
| @ifset PDP11 |
| |
| For details about the PDP-11 machine dependent features options, |
| see @ref{PDP-11-Options}. |
| |
| @table @gcctabopt |
| @item -mpic | -mno-pic |
| Generate position-independent (or position-dependent) code. The |
| default is @option{-mpic}. |
| |
| @item -mall |
| @itemx -mall-extensions |
| Enable all instruction set extensions. This is the default. |
| |
| @item -mno-extensions |
| Disable all instruction set extensions. |
| |
| @item -m@var{extension} | -mno-@var{extension} |
| Enable (or disable) a particular instruction set extension. |
| |
| @item -m@var{cpu} |
| Enable the instruction set extensions supported by a particular CPU, and |
| disable all other extensions. |
| |
| @item -m@var{machine} |
| Enable the instruction set extensions supported by a particular machine |
| model, and disable all other extensions. |
| @end table |
| |
| @end ifset |
| |
| @ifset PJ |
| The following options are available when @value{AS} is configured for |
| a picoJava processor. |
| |
| @table @gcctabopt |
| |
| @cindex PJ endianness |
| @cindex endianness, PJ |
| @cindex big endian output, PJ |
| @item -mb |
| Generate ``big endian'' format output. |
| |
| @cindex little endian output, PJ |
| @item -ml |
| Generate ``little endian'' format output. |
| |
| @end table |
| @end ifset |
| |
| @ifset PRU |
| |
| @ifclear man |
| @xref{PRU Options}, for the options available when @value{AS} is configured |
| for a PRU processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for a |
| PRU processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-pru.texi |
| @c ended inside the included file |
| @end ifset |
| @end ifset |
| |
| @ifset M68HC11 |
| The following options are available when @value{AS} is configured for the |
| Motorola 68HC11 or 68HC12 series. |
| |
| @table @gcctabopt |
| |
| @item -m68hc11 | -m68hc12 | -m68hcs12 | -mm9s12x | -mm9s12xg |
| Specify what processor is the target. The default is |
| defined by the configuration option when building the assembler. |
| |
| @item --xgate-ramoffset |
| Instruct the linker to offset RAM addresses from S12X address space into |
| XGATE address space. |
| |
| @item -mshort |
| Specify to use the 16-bit integer ABI. |
| |
| @item -mlong |
| Specify to use the 32-bit integer ABI. |
| |
| @item -mshort-double |
| Specify to use the 32-bit double ABI. |
| |
| @item -mlong-double |
| Specify to use the 64-bit double ABI. |
| |
| @item --force-long-branches |
| Relative branches are turned into absolute ones. This concerns |
| conditional branches, unconditional branches and branches to a |
| sub routine. |
| |
| @item -S | --short-branches |
| Do not turn relative branches into absolute ones |
| when the offset is out of range. |
| |
| @item --strict-direct-mode |
| Do not turn the direct addressing mode into extended addressing mode |
| when the instruction does not support direct addressing mode. |
| |
| @item --print-insn-syntax |
| Print the syntax of instruction in case of error. |
| |
| @item --print-opcodes |
| Print the list of instructions with syntax and then exit. |
| |
| @item --generate-example |
| Print an example of instruction for each possible instruction and then exit. |
| This option is only useful for testing @command{@value{AS}}. |
| |
| @end table |
| @end ifset |
| |
| @ifset SPARC |
| The following options are available when @command{@value{AS}} is configured |
| for the SPARC architecture: |
| |
| @table @gcctabopt |
| @item -Av6 | -Av7 | -Av8 | -Asparclet | -Asparclite |
| @itemx -Av8plus | -Av8plusa | -Av9 | -Av9a |
| Explicitly select a variant of the SPARC architecture. |
| |
| @samp{-Av8plus} and @samp{-Av8plusa} select a 32 bit environment. |
| @samp{-Av9} and @samp{-Av9a} select a 64 bit environment. |
| |
| @samp{-Av8plusa} and @samp{-Av9a} enable the SPARC V9 instruction set with |
| UltraSPARC extensions. |
| |
| @item -xarch=v8plus | -xarch=v8plusa |
| For compatibility with the Solaris v9 assembler. These options are |
| equivalent to -Av8plus and -Av8plusa, respectively. |
| |
| @item -bump |
| Warn when the assembler switches to another architecture. |
| @end table |
| @end ifset |
| |
| @ifset TIC54X |
| The following options are available when @value{AS} is configured for the 'c54x |
| architecture. |
| |
| @table @gcctabopt |
| @item -mfar-mode |
| Enable extended addressing mode. All addresses and relocations will assume |
| extended addressing (usually 23 bits). |
| @item -mcpu=@var{CPU_VERSION} |
| Sets the CPU version being compiled for. |
| @item -merrors-to-file @var{FILENAME} |
| Redirect error output to a file, for broken systems which don't support such |
| behaviour in the shell. |
| @end table |
| @end ifset |
| |
| @ifset MIPS |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for |
| a MIPS processor. |
| |
| @table @gcctabopt |
| @item -G @var{num} |
| This option sets the largest size of an object that can be referenced |
| implicitly with the @code{gp} register. It is only accepted for targets that |
| use ECOFF format, such as a DECstation running Ultrix. The default value is 8. |
| |
| @cindex MIPS endianness |
| @cindex endianness, MIPS |
| @cindex big endian output, MIPS |
| @item -EB |
| Generate ``big endian'' format output. |
| |
| @cindex little endian output, MIPS |
| @item -EL |
| Generate ``little endian'' format output. |
| |
| @cindex MIPS ISA |
| @item -mips1 |
| @itemx -mips2 |
| @itemx -mips3 |
| @itemx -mips4 |
| @itemx -mips5 |
| @itemx -mips32 |
| @itemx -mips32r2 |
| @itemx -mips32r3 |
| @itemx -mips32r5 |
| @itemx -mips32r6 |
| @itemx -mips64 |
| @itemx -mips64r2 |
| @itemx -mips64r3 |
| @itemx -mips64r5 |
| @itemx -mips64r6 |
| Generate code for a particular MIPS Instruction Set Architecture level. |
| @samp{-mips1} is an alias for @samp{-march=r3000}, @samp{-mips2} is an |
| alias for @samp{-march=r6000}, @samp{-mips3} is an alias for |
| @samp{-march=r4000} and @samp{-mips4} is an alias for @samp{-march=r8000}. |
| @samp{-mips5}, @samp{-mips32}, @samp{-mips32r2}, @samp{-mips32r3}, |
| @samp{-mips32r5}, @samp{-mips32r6}, @samp{-mips64}, @samp{-mips64r2}, |
| @samp{-mips64r3}, @samp{-mips64r5}, and @samp{-mips64r6} correspond to generic |
| MIPS V, MIPS32, MIPS32 Release 2, MIPS32 Release 3, MIPS32 Release 5, MIPS32 |
| Release 6, MIPS64, MIPS64 Release 2, MIPS64 Release 3, MIPS64 Release 5, and |
| MIPS64 Release 6 ISA processors, respectively. |
| |
| @item -march=@var{cpu} |
| Generate code for a particular MIPS CPU. |
| |
| @item -mtune=@var{cpu} |
| Schedule and tune for a particular MIPS CPU. |
| |
| @item -mfix7000 |
| @itemx -mno-fix7000 |
| Cause nops to be inserted if the read of the destination register |
| of an mfhi or mflo instruction occurs in the following two instructions. |
| |
| @item -mfix-rm7000 |
| @itemx -mno-fix-rm7000 |
| Cause nops to be inserted if a dmult or dmultu instruction is |
| followed by a load instruction. |
| |
| @item -mfix-r5900 |
| @itemx -mno-fix-r5900 |
| Do not attempt to schedule the preceding instruction into the delay slot |
| of a branch instruction placed at the end of a short loop of six |
| instructions or fewer and always schedule a @code{nop} instruction there |
| instead. The short loop bug under certain conditions causes loops to |
| execute only once or twice, due to a hardware bug in the R5900 chip. |
| |
| @item -mdebug |
| @itemx -no-mdebug |
| Cause stabs-style debugging output to go into an ECOFF-style .mdebug |
| section instead of the standard ELF .stabs sections. |
| |
| @item -mpdr |
| @itemx -mno-pdr |
| Control generation of @code{.pdr} sections. |
| |
| @item -mgp32 |
| @itemx -mfp32 |
| The register sizes are normally inferred from the ISA and ABI, but these |
| flags force a certain group of registers to be treated as 32 bits wide at |
| all times. @samp{-mgp32} controls the size of general-purpose registers |
| and @samp{-mfp32} controls the size of floating-point registers. |
| |
| @item -mgp64 |
| @itemx -mfp64 |
| The register sizes are normally inferred from the ISA and ABI, but these |
| flags force a certain group of registers to be treated as 64 bits wide at |
| all times. @samp{-mgp64} controls the size of general-purpose registers |
| and @samp{-mfp64} controls the size of floating-point registers. |
| |
| @item -mfpxx |
| The register sizes are normally inferred from the ISA and ABI, but using |
| this flag in combination with @samp{-mabi=32} enables an ABI variant |
| which will operate correctly with floating-point registers which are |
| 32 or 64 bits wide. |
| |
| @item -modd-spreg |
| @itemx -mno-odd-spreg |
| Enable use of floating-point operations on odd-numbered single-precision |
| registers when supported by the ISA. @samp{-mfpxx} implies |
| @samp{-mno-odd-spreg}, otherwise the default is @samp{-modd-spreg}. |
| |
| @item -mips16 |
| @itemx -no-mips16 |
| Generate code for the MIPS 16 processor. This is equivalent to putting |
| @code{.module mips16} at the start of the assembly file. @samp{-no-mips16} |
| turns off this option. |
| |
| @item -mmips16e2 |
| @itemx -mno-mips16e2 |
| Enable the use of MIPS16e2 instructions in MIPS16 mode. This is equivalent |
| to putting @code{.module mips16e2} at the start of the assembly file. |
| @samp{-mno-mips16e2} turns off this option. |
| |
| @item -mmicromips |
| @itemx -mno-micromips |
| Generate code for the microMIPS processor. This is equivalent to putting |
| @code{.module micromips} at the start of the assembly file. |
| @samp{-mno-micromips} turns off this option. This is equivalent to putting |
| @code{.module nomicromips} at the start of the assembly file. |
| |
| @item -msmartmips |
| @itemx -mno-smartmips |
| Enables the SmartMIPS extension to the MIPS32 instruction set. This is |
| equivalent to putting @code{.module smartmips} at the start of the assembly |
| file. @samp{-mno-smartmips} turns off this option. |
| |
| @item -mips3d |
| @itemx -no-mips3d |
| Generate code for the MIPS-3D Application Specific Extension. |
| This tells the assembler to accept MIPS-3D instructions. |
| @samp{-no-mips3d} turns off this option. |
| |
| @item -mdmx |
| @itemx -no-mdmx |
| Generate code for the MDMX Application Specific Extension. |
| This tells the assembler to accept MDMX instructions. |
| @samp{-no-mdmx} turns off this option. |
| |
| @item -mdsp |
| @itemx -mno-dsp |
| Generate code for the DSP Release 1 Application Specific Extension. |
| This tells the assembler to accept DSP Release 1 instructions. |
| @samp{-mno-dsp} turns off this option. |
| |
| @item -mdspr2 |
| @itemx -mno-dspr2 |
| Generate code for the DSP Release 2 Application Specific Extension. |
| This option implies @samp{-mdsp}. |
| This tells the assembler to accept DSP Release 2 instructions. |
| @samp{-mno-dspr2} turns off this option. |
| |
| @item -mdspr3 |
| @itemx -mno-dspr3 |
| Generate code for the DSP Release 3 Application Specific Extension. |
| This option implies @samp{-mdsp} and @samp{-mdspr2}. |
| This tells the assembler to accept DSP Release 3 instructions. |
| @samp{-mno-dspr3} turns off this option. |
| |
| @item -mmsa |
| @itemx -mno-msa |
| Generate code for the MIPS SIMD Architecture Extension. |
| This tells the assembler to accept MSA instructions. |
| @samp{-mno-msa} turns off this option. |
| |
| @item -mxpa |
| @itemx -mno-xpa |
| Generate code for the MIPS eXtended Physical Address (XPA) Extension. |
| This tells the assembler to accept XPA instructions. |
| @samp{-mno-xpa} turns off this option. |
| |
| @item -mmt |
| @itemx -mno-mt |
| Generate code for the MT Application Specific Extension. |
| This tells the assembler to accept MT instructions. |
| @samp{-mno-mt} turns off this option. |
| |
| @item -mmcu |
| @itemx -mno-mcu |
| Generate code for the MCU Application Specific Extension. |
| This tells the assembler to accept MCU instructions. |
| @samp{-mno-mcu} turns off this option. |
| |
| @item -mcrc |
| @itemx -mno-crc |
| Generate code for the MIPS cyclic redundancy check (CRC) Application |
| Specific Extension. This tells the assembler to accept CRC instructions. |
| @samp{-mno-crc} turns off this option. |
| |
| @item -mginv |
| @itemx -mno-ginv |
| Generate code for the Global INValidate (GINV) Application Specific |
| Extension. This tells the assembler to accept GINV instructions. |
| @samp{-mno-ginv} turns off this option. |
| |
| @item -mloongson-mmi |
| @itemx -mno-loongson-mmi |
| Generate code for the Loongson MultiMedia extensions Instructions (MMI) |
| Application Specific Extension. This tells the assembler to accept MMI |
| instructions. |
| @samp{-mno-loongson-mmi} turns off this option. |
| |
| @item -mloongson-cam |
| @itemx -mno-loongson-cam |
| Generate code for the Loongson Content Address Memory (CAM) instructions. |
| This tells the assembler to accept Loongson CAM instructions. |
| @samp{-mno-loongson-cam} turns off this option. |
| |
| @item -mloongson-ext |
| @itemx -mno-loongson-ext |
| Generate code for the Loongson EXTensions (EXT) instructions. |
| This tells the assembler to accept Loongson EXT instructions. |
| @samp{-mno-loongson-ext} turns off this option. |
| |
| @item -mloongson-ext2 |
| @itemx -mno-loongson-ext2 |
| Generate code for the Loongson EXTensions R2 (EXT2) instructions. |
| This option implies @samp{-mloongson-ext}. |
| This tells the assembler to accept Loongson EXT2 instructions. |
| @samp{-mno-loongson-ext2} turns off this option. |
| |
| @item -minsn32 |
| @itemx -mno-insn32 |
| Only use 32-bit instruction encodings when generating code for the |
| microMIPS processor. This option inhibits the use of any 16-bit |
| instructions. This is equivalent to putting @code{.set insn32} at |
| the start of the assembly file. @samp{-mno-insn32} turns off this |
| option. This is equivalent to putting @code{.set noinsn32} at the |
| start of the assembly file. By default @samp{-mno-insn32} is |
| selected, allowing all instructions to be used. |
| |
| @item --construct-floats |
| @itemx --no-construct-floats |
| The @samp{--no-construct-floats} option disables the construction of |
| double width floating point constants by loading the two halves of the |
| value into the two single width floating point registers that make up |
| the double width register. By default @samp{--construct-floats} is |
| selected, allowing construction of these floating point constants. |
| |
| @item --relax-branch |
| @itemx --no-relax-branch |
| The @samp{--relax-branch} option enables the relaxation of out-of-range |
| branches. By default @samp{--no-relax-branch} is selected, causing any |
| out-of-range branches to produce an error. |
| |
| @item -mignore-branch-isa |
| @itemx -mno-ignore-branch-isa |
| Ignore branch checks for invalid transitions between ISA modes. The |
| semantics of branches does not provide for an ISA mode switch, so in |
| most cases the ISA mode a branch has been encoded for has to be the |
| same as the ISA mode of the branch's target label. Therefore GAS has |
| checks implemented that verify in branch assembly that the two ISA |
| modes match. @samp{-mignore-branch-isa} disables these checks. By |
| default @samp{-mno-ignore-branch-isa} is selected, causing any invalid |
| branch requiring a transition between ISA modes to produce an error. |
| |
| @item -mnan=@var{encoding} |
| Select between the IEEE 754-2008 (@option{-mnan=2008}) or the legacy |
| (@option{-mnan=legacy}) NaN encoding format. The latter is the default. |
| |
| @cindex emulation |
| @item --emulation=@var{name} |
| This option was formerly used to switch between ELF and ECOFF output |
| on targets like IRIX 5 that supported both. MIPS ECOFF support was |
| removed in GAS 2.24, so the option now serves little purpose. |
| It is retained for backwards compatibility. |
| |
| The available configuration names are: @samp{mipself}, @samp{mipslelf} and |
| @samp{mipsbelf}. Choosing @samp{mipself} now has no effect, since the output |
| is always ELF. @samp{mipslelf} and @samp{mipsbelf} select little- and |
| big-endian output respectively, but @samp{-EL} and @samp{-EB} are now the |
| preferred options instead. |
| |
| @item -nocpp |
| @command{@value{AS}} ignores this option. It is accepted for compatibility with |
| the native tools. |
| |
| @item --trap |
| @itemx --no-trap |
| @itemx --break |
| @itemx --no-break |
| Control how to deal with multiplication overflow and division by zero. |
| @samp{--trap} or @samp{--no-break} (which are synonyms) take a trap exception |
| (and only work for Instruction Set Architecture level 2 and higher); |
| @samp{--break} or @samp{--no-trap} (also synonyms, and the default) take a |
| break exception. |
| |
| @item -n |
| When this option is used, @command{@value{AS}} will issue a warning every |
| time it generates a nop instruction from a macro. |
| @end table |
| @c man end |
| @end ifset |
| |
| @ifset MCORE |
| The following options are available when @value{AS} is configured for |
| an MCore processor. |
| |
| @table @gcctabopt |
| @item -jsri2bsr |
| @itemx -nojsri2bsr |
| Enable or disable the JSRI to BSR transformation. By default this is enabled. |
| The command-line option @samp{-nojsri2bsr} can be used to disable it. |
| |
| @item -sifilter |
| @itemx -nosifilter |
| Enable or disable the silicon filter behaviour. By default this is disabled. |
| The default can be overridden by the @samp{-sifilter} command-line option. |
| |
| @item -relax |
| Alter jump instructions for long displacements. |
| |
| @item -mcpu=[210|340] |
| Select the cpu type on the target hardware. This controls which instructions |
| can be assembled. |
| |
| @item -EB |
| Assemble for a big endian target. |
| |
| @item -EL |
| Assemble for a little endian target. |
| |
| @end table |
| @end ifset |
| @c man end |
| |
| @ifset METAG |
| |
| @ifclear man |
| @xref{Meta Options}, for the options available when @value{AS} is configured |
| for a Meta processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for a |
| Meta processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-metag.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @c man begin OPTIONS |
| @ifset MMIX |
| See the info pages for documentation of the MMIX-specific options. |
| @end ifset |
| |
| @ifset NDS32 |
| |
| @ifclear man |
| @xref{NDS32 Options}, for the options available when @value{AS} is configured |
| for a NDS32 processor. |
| @end ifclear |
| @c ended inside the included file |
| @end ifset |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for a |
| NDS32 processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-nds32.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @c man end |
| @ifset PPC |
| |
| @ifclear man |
| @xref{PowerPC-Opts}, for the options available when @value{AS} is configured |
| for a PowerPC processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for a |
| PowerPC processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-ppc.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset RISCV |
| |
| @ifclear man |
| @xref{RISC-V-Options}, for the options available when @value{AS} is configured |
| for a RISC-V processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for a |
| RISC-V processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-riscv.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @c man begin OPTIONS |
| @ifset RX |
| See the info pages for documentation of the RX-specific options. |
| @end ifset |
| |
| @ifset S390 |
| The following options are available when @value{AS} is configured for the s390 |
| processor family. |
| |
| @table @gcctabopt |
| @item -m31 |
| @itemx -m64 |
| Select the word size, either 31/32 bits or 64 bits. |
| @item -mesa |
| @item -mzarch |
| Select the architecture mode, either the Enterprise System |
| Architecture (esa) or the z/Architecture mode (zarch). |
| @item -march=@var{processor} |
| Specify which s390 processor variant is the target, @samp{g5} (or |
| @samp{arch3}), @samp{g6}, @samp{z900} (or @samp{arch5}), @samp{z990} (or |
| @samp{arch6}), @samp{z9-109}, @samp{z9-ec} (or @samp{arch7}), @samp{z10} (or |
| @samp{arch8}), @samp{z196} (or @samp{arch9}), @samp{zEC12} (or @samp{arch10}), |
| @samp{z13} (or @samp{arch11}), @samp{z14} (or @samp{arch12}), or @samp{z15} |
| (or @samp{arch13}). |
| @item -mregnames |
| @itemx -mno-regnames |
| Allow or disallow symbolic names for registers. |
| @item -mwarn-areg-zero |
| Warn whenever the operand for a base or index register has been specified |
| but evaluates to zero. |
| @end table |
| @end ifset |
| @c man end |
| |
| @ifset TIC6X |
| |
| @ifclear man |
| @xref{TIC6X Options}, for the options available when @value{AS} is configured |
| for a TMS320C6000 processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for a |
| TMS320C6000 processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-tic6x.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset TILEGX |
| |
| @ifclear man |
| @xref{TILE-Gx Options}, for the options available when @value{AS} is configured |
| for a TILE-Gx processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for a TILE-Gx |
| processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-tilegx.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset VISIUM |
| |
| @ifclear man |
| @xref{Visium Options}, for the options available when @value{AS} is configured |
| for a Visium processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following option is available when @value{AS} is configured for a Visium |
| processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-visium.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset XTENSA |
| |
| @ifclear man |
| @xref{Xtensa Options}, for the options available when @value{AS} is configured |
| for an Xtensa processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for an |
| Xtensa processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-xtensa.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @ifset Z80 |
| |
| @ifclear man |
| @xref{Z80 Options}, for the options available when @value{AS} is configured |
| for an Z80 processor. |
| @end ifclear |
| |
| @ifset man |
| @c man begin OPTIONS |
| The following options are available when @value{AS} is configured for an |
| Z80 processor. |
| @c man end |
| @c man begin INCLUDE |
| @include c-z80.texi |
| @c ended inside the included file |
| @end ifset |
| |
| @end ifset |
| |
| @menu |
| * Manual:: Structure of this Manual |
| * GNU Assembler:: The GNU Assembler |
| * Object Formats:: Object File Formats |
| * Command Line:: Command Line |
| * Input Files:: Input Files |
| * Object:: Output (Object) File |
| * Errors:: Error and Warning Messages |
| @end menu |
| |
| @node Manual |
| @section Structure of this Manual |
| |
| @cindex manual, structure and purpose |
| This manual is intended to describe what you need to know to use |
| @sc{gnu} @command{@value{AS}}. We cover the syntax expected in source files, including |
| notation for symbols, constants, and expressions; the directives that |
| @command{@value{AS}} understands; and of course how to invoke @command{@value{AS}}. |
| |
| @ifclear GENERIC |
| We also cover special features in the @value{TARGET} |
| configuration of @command{@value{AS}}, including assembler directives. |
| @end ifclear |
| @ifset GENERIC |
| This manual also describes some of the machine-dependent features of |
| various flavors of the assembler. |
| @end ifset |
| |
| @cindex machine instructions (not covered) |
| On the other hand, this manual is @emph{not} intended as an introduction |
| to programming in assembly language---let alone programming in general! |
| In a similar vein, we make no attempt to introduce the machine |
| architecture; we do @emph{not} describe the instruction set, standard |
| mnemonics, registers or addressing modes that are standard to a |
| particular architecture. |
| @ifset GENERIC |
| You may want to consult the manufacturer's |
| machine architecture manual for this information. |
| @end ifset |
| @ifclear GENERIC |
| @ifset H8/300 |
| For information on the H8/300 machine instruction set, see @cite{H8/300 |
| Series Programming Manual}. For the H8/300H, see @cite{H8/300H Series |
| Programming Manual} (Renesas). |
| @end ifset |
| @ifset SH |
| For information on the Renesas (formerly Hitachi) / SuperH SH machine instruction set, |
| see @cite{SH-Microcomputer User's Manual} (Renesas) or |
| @cite{SH-4 32-bit CPU Core Architecture} (SuperH) and |
| @cite{SuperH (SH) 64-Bit RISC Series} (SuperH). |
| @end ifset |
| @ifset Z8000 |
| For information on the Z8000 machine instruction set, see @cite{Z8000 CPU Technical Manual} |
| @end ifset |
| @end ifclear |
| |
| @c I think this is premature---doc@cygnus.com, 17jan1991 |
| @ignore |
| Throughout this manual, we assume that you are running @dfn{GNU}, |
| the portable operating system from the @dfn{Free Software |
| Foundation, Inc.}. This restricts our attention to certain kinds of |
| computer (in particular, the kinds of computers that @sc{gnu} can run on); |
| once this assumption is granted examples and definitions need less |
| qualification. |
| |
| @command{@value{AS}} is part of a team of programs that turn a high-level |
| human-readable series of instructions into a low-level |
| computer-readable series of instructions. Different versions of |
| @command{@value{AS}} are used for different kinds of computer. |
| @end ignore |
| |
| @c There used to be a section "Terminology" here, which defined |
| @c "contents", "byte", "word", and "long". Defining "word" to any |
| @c particular size is confusing when the .word directive may generate 16 |
| @c bits on one machine and 32 bits on another; in general, for the user |
| @c version of this manual, none of these terms seem essential to define. |
| @c They were used very little even in the former draft of the manual; |
| @c this draft makes an effort to avoid them (except in names of |
| @c directives). |
| |
| @node GNU Assembler |
| @section The GNU Assembler |
| |
| @c man begin DESCRIPTION |
| |
| @sc{gnu} @command{as} is really a family of assemblers. |
| @ifclear GENERIC |
| This manual describes @command{@value{AS}}, a member of that family which is |
| configured for the @value{TARGET} architectures. |
| @end ifclear |
| If you use (or have used) the @sc{gnu} assembler on one architecture, you |
| should find a fairly similar environment when you use it on another |
| architecture. Each version has much in common with the others, |
| including object file formats, most assembler directives (often called |
| @dfn{pseudo-ops}) and assembler syntax.@refill |
| |
| @cindex purpose of @sc{gnu} assembler |
| @command{@value{AS}} is primarily intended to assemble the output of the |
| @sc{gnu} C compiler @code{@value{GCC}} for use by the linker |
| @code{@value{LD}}. Nevertheless, we've tried to make @command{@value{AS}} |
| assemble correctly everything that other assemblers for the same |
| machine would assemble. |
| @ifset VAX |
| Any exceptions are documented explicitly (@pxref{Machine Dependencies}). |
| @end ifset |
| @ifset M680X0 |
| @c This remark should appear in generic version of manual; assumption |
| @c here is that generic version sets M680x0. |
| This doesn't mean @command{@value{AS}} always uses the same syntax as another |
| assembler for the same architecture; for example, we know of several |
| incompatible versions of 680x0 assembly language syntax. |
| @end ifset |
| |
| @c man end |
| |
| Unlike older assemblers, @command{@value{AS}} is designed to assemble a source |
| program in one pass of the source file. This has a subtle impact on the |
| @kbd{.org} directive (@pxref{Org,,@code{.org}}). |
| |
| @node Object Formats |
| @section Object File Formats |
| |
| @cindex object file format |
| The @sc{gnu} assembler can be configured to produce several alternative |
| object file formats. For the most part, this does not affect how you |
| write assembly language programs; but directives for debugging symbols |
| are typically different in different file formats. @xref{Symbol |
| Attributes,,Symbol Attributes}. |
| @ifclear GENERIC |
| @ifclear MULTI-OBJ |
| For the @value{TARGET} target, @command{@value{AS}} is configured to produce |
| @value{OBJ-NAME} format object files. |
| @end ifclear |
| @c The following should exhaust all configs that set MULTI-OBJ, ideally |
| @ifset HPPA |
| On the @value{TARGET}, @command{@value{AS}} can be configured to produce either |
| SOM or ELF format object files. |
| @end ifset |
| @end ifclear |
| |
| @node Command Line |
| @section Command Line |
| |
| @cindex command line conventions |
| |
| After the program name @command{@value{AS}}, the command line may contain |
| options and file names. Options may appear in any order, and may be |
| before, after, or between file names. The order of file names is |
| significant. |
| |
| @cindex standard input, as input file |
| @kindex -- |
| @file{--} (two hyphens) by itself names the standard input file |
| explicitly, as one of the files for @command{@value{AS}} to assemble. |
| |
| @cindex options, command line |
| Except for @samp{--} any command-line argument that begins with a |
| hyphen (@samp{-}) is an option. Each option changes the behavior of |
| @command{@value{AS}}. No option changes the way another option works. An |
| option is a @samp{-} followed by one or more letters; the case of |
| the letter is important. All options are optional. |
| |
| Some options expect exactly one file name to follow them. The file |
| name may either immediately follow the option's letter (compatible |
| with older assemblers) or it may be the next command argument (@sc{gnu} |
| standard). These two command lines are equivalent: |
| |
| @smallexample |
| @value{AS} -o my-object-file.o mumble.s |
| @value{AS} -omy-object-file.o mumble.s |
| @end smallexample |
| |
| @node Input Files |
| @section Input Files |
| |
| @cindex input |
| @cindex source program |
| @cindex files, input |
| We use the phrase @dfn{source program}, abbreviated @dfn{source}, to |
| describe the program input to one run of @command{@value{AS}}. The program may |
| be in one or more files; how the source is partitioned into files |
| doesn't change the meaning of the source. |
| |
| @c I added "con" prefix to "catenation" just to prove I can overcome my |
| @c APL training... doc@cygnus.com |
| The source program is a concatenation of the text in all the files, in the |
| order specified. |
| |
| @c man begin DESCRIPTION |
| Each time you run @command{@value{AS}} it assembles exactly one source |
| program. The source program is made up of one or more files. |
| (The standard input is also a file.) |
| |
| You give @command{@value{AS}} a command line that has zero or more input file |
| names. The input files are read (from left file name to right). A |
| command-line argument (in any position) that has no special meaning |
| is taken to be an input file name. |
| |
| If you give @command{@value{AS}} no file names it attempts to read one input file |
| from the @command{@value{AS}} standard input, which is normally your terminal. You |
| may have to type @key{ctl-D} to tell @command{@value{AS}} there is no more program |
| to assemble. |
| |
| Use @samp{--} if you need to explicitly name the standard input file |
| in your command line. |
| |
| If the source is empty, @command{@value{AS}} produces a small, empty object |
| file. |
| |
| @c man end |
| |
| @subheading Filenames and Line-numbers |
| |
| @cindex input file linenumbers |
| @cindex line numbers, in input files |
| There are two ways of locating a line in the input file (or files) and |
| either may be used in reporting error messages. One way refers to a line |
| number in a physical file; the other refers to a line number in a |
| ``logical'' file. @xref{Errors, ,Error and Warning Messages}. |
| |
| @dfn{Physical files} are those files named in the command line given |
| to @command{@value{AS}}. |
| |
| @dfn{Logical files} are simply names declared explicitly by assembler |
| directives; they bear no relation to physical files. Logical file names help |
| error messages reflect the original source file, when @command{@value{AS}} source |
| is itself synthesized from other files. @command{@value{AS}} understands the |
| @samp{#} directives emitted by the @code{@value{GCC}} preprocessor. See also |
| @ref{File,,@code{.file}}. |
| |
| @node Object |
| @section Output (Object) File |
| |
| @cindex object file |
| @cindex output file |
| @kindex a.out |
| @kindex .o |
| Every time you run @command{@value{AS}} it produces an output file, which is |
| your assembly language program translated into numbers. This file |
| is the object file. Its default name is @code{a.out}. |
| You can give it another name by using the @option{-o} option. Conventionally, |
| object file names end with @file{.o}. The default name is used for historical |
| reasons: older assemblers were capable of assembling self-contained programs |
| directly into a runnable program. (For some formats, this isn't currently |
| possible, but it can be done for the @code{a.out} format.) |
| |
| @cindex linker |
| @kindex ld |
| The object file is meant for input to the linker @code{@value{LD}}. It contains |
| assembled program code, information to help @code{@value{LD}} integrate |
| the assembled program into a runnable file, and (optionally) symbolic |
| information for the debugger. |
| |
| @c link above to some info file(s) like the description of a.out. |
| @c don't forget to describe @sc{gnu} info as well as Unix lossage. |
| |
| @node Errors |
| @section Error and Warning Messages |
| |
| @c man begin DESCRIPTION |
| |
| @cindex error messages |
| @cindex warning messages |
| @cindex messages from assembler |
| @command{@value{AS}} may write warnings and error messages to the standard error |
| file (usually your terminal). This should not happen when a compiler |
| runs @command{@value{AS}} automatically. Warnings report an assumption made so |
| that @command{@value{AS}} could keep assembling a flawed program; errors report a |
| grave problem that stops the assembly. |
| |
| @c man end |
| |
| @cindex format of warning messages |
| Warning messages have the format |
| |
| @smallexample |
| file_name:@b{NNN}:Warning Message Text |
| @end smallexample |
| |
| @noindent |
| @cindex file names and line numbers, in warnings/errors |
| (where @b{NNN} is a line number). If both a logical file name |
| (@pxref{File,,@code{.file}}) and a logical line number |
| @ifset GENERIC |
| (@pxref{Line,,@code{.line}}) |
| @end ifset |
| have been given then they will be used, otherwise the file name and line number |
| in the current assembler source file will be used. The message text is |
| intended to be self explanatory (in the grand Unix tradition). |
| |
| Note the file name must be set via the logical version of the @code{.file} |
| directive, not the DWARF2 version of the @code{.file} directive. For example: |
| |
| @smallexample |
| .file 2 "bar.c" |
| error_assembler_source |
| .file "foo.c" |
| .line 30 |
| error_c_source |
| @end smallexample |
| |
| produces this output: |
| |
| @smallexample |
| Assembler messages: |
| asm.s:2: Error: no such instruction: `error_assembler_source' |
| foo.c:31: Error: no such instruction: `error_c_source' |
| @end smallexample |
| |
| @cindex format of error messages |
| Error messages have the format |
| |
| @smallexample |
| file_name:@b{NNN}:FATAL:Error Message Text |
| @end smallexample |
| |
| The file name and line number are derived as for warning |
| messages. The actual message text may be rather less explanatory |
| because many of them aren't supposed to happen. |
| |
| @node Invoking |
| @chapter Command-Line Options |
| |
| @cindex options, all versions of assembler |
| This chapter describes command-line options available in @emph{all} |
| versions of the @sc{gnu} assembler; see @ref{Machine Dependencies}, |
| for options specific |
| @ifclear GENERIC |
| to the @value{TARGET} target. |
| @end ifclear |
| @ifset GENERIC |
| to particular machine architectures. |
| @end ifset |
| |
| @c man begin DESCRIPTION |
| |
| If you are invoking @command{@value{AS}} via the @sc{gnu} C compiler, |
| you can use the @samp{-Wa} option to pass arguments through to the assembler. |
| The assembler arguments must be separated from each other (and the @samp{-Wa}) |
| by commas. For example: |
| |
| @smallexample |
| gcc -c -g -O -Wa,-alh,-L file.c |
| @end smallexample |
| |
| @noindent |
| This passes two options to the assembler: @samp{-alh} (emit a listing to |
| standard output with high-level and assembly source) and @samp{-L} (retain |
| local symbols in the symbol table). |
| |
| Usually you do not need to use this @samp{-Wa} mechanism, since many compiler |
| command-line options are automatically passed to the assembler by the compiler. |
| (You can call the @sc{gnu} compiler driver with the @samp{-v} option to see |
| precisely what options it passes to each compilation pass, including the |
| assembler.) |
| |
| @c man end |
| |
| @menu |
| * a:: -a[cdghlns] enable listings |
| * alternate:: --alternate enable alternate macro syntax |
| * D:: -D for compatibility |
| * f:: -f to work faster |
| * I:: -I for .include search path |
| @ifclear DIFF-TBL-KLUGE |
| * K:: -K for compatibility |
| @end ifclear |
| @ifset DIFF-TBL-KLUGE |
| * K:: -K for difference tables |
| @end ifset |
| |
| * L:: -L to retain local symbols |
| * listing:: --listing-XXX to configure listing output |
| * M:: -M or --mri to assemble in MRI compatibility mode |
| * MD:: --MD for dependency tracking |
| * no-pad-sections:: --no-pad-sections to stop section padding |
| * o:: -o to name the object file |
| * R:: -R to join data and text sections |
| * statistics:: --statistics to see statistics about assembly |
| * traditional-format:: --traditional-format for compatible output |
| * v:: -v to announce version |
| * W:: -W, --no-warn, --warn, --fatal-warnings to control warnings |
| * Z:: -Z to make object file even after errors |
| @end menu |
| |
| @node a |
| @section Enable Listings: @option{-a[cdghlns]} |
| |
| @kindex -a |
| @kindex -ac |
| @kindex -ad |
| @kindex -ag |
| @kindex -ah |
| @kindex -al |
| @kindex -an |
| @kindex -as |
| @cindex listings, enabling |
| @cindex assembly listings, enabling |
| |
| These options enable listing output from the assembler. By itself, |
| @samp{-a} requests high-level, assembly, and symbols listing. |
| You can use other letters to select specific options for the list: |
| @samp{-ah} requests a high-level language listing, |
| @samp{-al} requests an output-program assembly listing, and |
| @samp{-as} requests a symbol table listing. |
| High-level listings require that a compiler debugging option like |
| @samp{-g} be used, and that assembly listings (@samp{-al}) be requested |
| also. |
| |
| Use the @samp{-ag} option to print a first section with general assembly |
| information, like @value{AS} version, switches passed, or time stamp. |
| |
| Use the @samp{-ac} option to omit false conditionals from a listing. Any lines |
| which are not assembled because of a false @code{.if} (or @code{.ifdef}, or any |
| other conditional), or a true @code{.if} followed by an @code{.else}, will be |
| omitted from the listing. |
| |
| Use the @samp{-ad} option to omit debugging directives from the |
| listing. |
| |
| Once you have specified one of these options, you can further control |
| listing output and its appearance using the directives @code{.list}, |
| @code{.nolist}, @code{.psize}, @code{.eject}, @code{.title}, and |
| @code{.sbttl}. |
| The @samp{-an} option turns off all forms processing. |
| If you do not request listing output with one of the @samp{-a} options, the |
| listing-control directives have no effect. |
| |
| The letters after @samp{-a} may be combined into one option, |
| @emph{e.g.}, @samp{-aln}. |
| |
| Note if the assembler source is coming from the standard input (e.g., |
| because it |
| is being created by @code{@value{GCC}} and the @samp{-pipe} command-line switch |
| is being used) then the listing will not contain any comments or preprocessor |
| directives. This is because the listing code buffers input source lines from |
| stdin only after they have been preprocessed by the assembler. This reduces |
| memory usage and makes the code more efficient. |
| |
| @node alternate |
| @section @option{--alternate} |
| |
| @kindex --alternate |
| Begin in alternate macro mode, see @ref{Altmacro,,@code{.altmacro}}. |
| |
| @node D |
| @section @option{-D} |
| |
| @kindex -D |
| This option has no effect whatsoever, but it is accepted to make it more |
| likely that scripts written for other assemblers also work with |
| @command{@value{AS}}. |
| |
| @node f |
| @section Work Faster: @option{-f} |
| |
| @kindex -f |
| @cindex trusted compiler |
| @cindex faster processing (@option{-f}) |
| @samp{-f} should only be used when assembling programs written by a |
| (trusted) compiler. @samp{-f} stops the assembler from doing whitespace |
| and comment preprocessing on |
| the input file(s) before assembling them. @xref{Preprocessing, |
| ,Preprocessing}. |
| |
| @quotation |
| @emph{Warning:} if you use @samp{-f} when the files actually need to be |
| preprocessed (if they contain comments, for example), @command{@value{AS}} does |
| not work correctly. |
| @end quotation |
| |
| @node I |
| @section @code{.include} Search Path: @option{-I} @var{path} |
| |
| @kindex -I @var{path} |
| @cindex paths for @code{.include} |
| @cindex search path for @code{.include} |
| @cindex @code{include} directive search path |
| Use this option to add a @var{path} to the list of directories |
| @command{@value{AS}} searches for files specified in @code{.include} |
| directives (@pxref{Include,,@code{.include}}). You may use @option{-I} as |
| many times as necessary to include a variety of paths. The current |
| working directory is always searched first; after that, @command{@value{AS}} |
| searches any @samp{-I} directories in the same order as they were |
| specified (left to right) on the command line. |
| |
| @node K |
| @section Difference Tables: @option{-K} |
| |
| @kindex -K |
| @ifclear DIFF-TBL-KLUGE |
| On the @value{TARGET} family, this option is allowed, but has no effect. It is |
| permitted for compatibility with the @sc{gnu} assembler on other platforms, |
| where it can be used to warn when the assembler alters the machine code |
| generated for @samp{.word} directives in difference tables. The @value{TARGET} |
| family does not have the addressing limitations that sometimes lead to this |
| alteration on other platforms. |
| @end ifclear |
| |
| @ifset DIFF-TBL-KLUGE |
| @cindex difference tables, warning |
| @cindex warning for altered difference tables |
| @command{@value{AS}} sometimes alters the code emitted for directives of the |
| form @samp{.word @var{sym1}-@var{sym2}}. @xref{Word,,@code{.word}}. |
| You can use the @samp{-K} option if you want a warning issued when this |
| is done. |
| @end ifset |
| |
| @node L |
| @section Include Local Symbols: @option{-L} |
| |
| @kindex -L |
| @cindex local symbols, retaining in output |
| Symbols beginning with system-specific local label prefixes, typically |
| @samp{.L} for ELF systems or @samp{L} for traditional a.out systems, are |
| called @dfn{local symbols}. @xref{Symbol Names}. Normally you do not see |
| such symbols when debugging, because they are intended for the use of |
| programs (like compilers) that compose assembler programs, not for your |
| notice. Normally both @command{@value{AS}} and @code{@value{LD}} discard |
| such symbols, so you do not normally debug with them. |
| |
| This option tells @command{@value{AS}} to retain those local symbols |
| in the object file. Usually if you do this you also tell the linker |
| @code{@value{LD}} to preserve those symbols. |
| |
| @node listing |
| @section Configuring listing output: @option{--listing} |
| |
| The listing feature of the assembler can be enabled via the command-line switch |
| @samp{-a} (@pxref{a}). This feature combines the input source file(s) with a |
| hex dump of the corresponding locations in the output object file, and displays |
| them as a listing file. The format of this listing can be controlled by |
| directives inside the assembler source (i.e., @code{.list} (@pxref{List}), |
| @code{.title} (@pxref{Title}), @code{.sbttl} (@pxref{Sbttl}), |
| @code{.psize} (@pxref{Psize}), and |
| @code{.eject} (@pxref{Eject}) and also by the following switches: |
| |
| @table @gcctabopt |
| @item --listing-lhs-width=@samp{number} |
| @kindex --listing-lhs-width |
| @cindex Width of first line disassembly output |
| Sets the maximum width, in words, of the first line of the hex byte dump. This |
| dump appears on the left hand side of the listing output. |
| |
| @item --listing-lhs-width2=@samp{number} |
| @kindex --listing-lhs-width2 |
| @cindex Width of continuation lines of disassembly output |
| Sets the maximum width, in words, of any further lines of the hex byte dump for |
| a given input source line. If this value is not specified, it defaults to being |
| the same as the value specified for @samp{--listing-lhs-width}. If neither |
| switch is used the default is to one. |
| |
| @item --listing-rhs-width=@samp{number} |
| @kindex --listing-rhs-width |
| @cindex Width of source line output |
| Sets the maximum width, in characters, of the source line that is displayed |
| alongside the hex dump. The default value for this parameter is 100. The |
| source line is displayed on the right hand side of the listing output. |
| |
| @item --listing-cont-lines=@samp{number} |
| @kindex --listing-cont-lines |
| @cindex Maximum number of continuation lines |
| Sets the maximum number of continuation lines of hex dump that will be |
| displayed for a given single line of source input. The default value is 4. |
| @end table |
| |
| @node M |
| @section Assemble in MRI Compatibility Mode: @option{-M} |
| |
| @kindex -M |
| @cindex MRI compatibility mode |
| The @option{-M} or @option{--mri} option selects MRI compatibility mode. This |
| changes the syntax and pseudo-op handling of @command{@value{AS}} to make it |
| compatible with the @code{ASM68K} assembler from Microtec Research. |
| The exact nature of the |
| MRI syntax will not be documented here; see the MRI manuals for more |
| information. Note in particular that the handling of macros and macro |
| arguments is somewhat different. The purpose of this option is to permit |
| assembling existing MRI assembler code using @command{@value{AS}}. |
| |
| The MRI compatibility is not complete. Certain operations of the MRI assembler |
| depend upon its object file format, and can not be supported using other object |
| file formats. Supporting these would require enhancing each object file format |
| individually. These are: |
| |
| @itemize @bullet |
| @item global symbols in common section |
| |
| The m68k MRI assembler supports common sections which are merged by the linker. |
| Other object file formats do not support this. @command{@value{AS}} handles |
| common sections by treating them as a single common symbol. It permits local |
| symbols to be defined within a common section, but it can not support global |
| symbols, since it has no way to describe them. |
| |
| @item complex relocations |
| |
| The MRI assemblers support relocations against a negated section address, and |
| relocations which combine the start addresses of two or more sections. These |
| are not support by other object file formats. |
| |
| @item @code{END} pseudo-op specifying start address |
| |
| The MRI @code{END} pseudo-op permits the specification of a start address. |
| This is not supported by other object file formats. The start address may |
| instead be specified using the @option{-e} option to the linker, or in a linker |
| script. |
| |
| @item @code{IDNT}, @code{.ident} and @code{NAME} pseudo-ops |
| |
| The MRI @code{IDNT}, @code{.ident} and @code{NAME} pseudo-ops assign a module |
| name to the output file. This is not supported by other object file formats. |
| |
| @item @code{ORG} pseudo-op |
| |
| The m68k MRI @code{ORG} pseudo-op begins an absolute section at a given |
| address. This differs from the usual @command{@value{AS}} @code{.org} pseudo-op, |
| which changes the location within the current section. Absolute sections are |
| not supported by other object file formats. The address of a section may be |
| assigned within a linker script. |
| @end itemize |
| |
| There are some other features of the MRI assembler which are not supported by |
| @command{@value{AS}}, typically either because they are difficult or because they |
| seem of little consequence. Some of these may be supported in future releases. |
| |
| @itemize @bullet |
| |
| @item EBCDIC strings |
| |
| EBCDIC strings are not supported. |
| |
| @item packed binary coded decimal |
| |
| Packed binary coded decimal is not supported. This means that the @code{DC.P} |
| and @code{DCB.P} pseudo-ops are not supported. |
| |
| @item @code{FEQU} pseudo-op |
| |
| The m68k @code{FEQU} pseudo-op is not supported. |
| |
| @item @code{NOOBJ} pseudo-op |
| |
| The m68k @code{NOOBJ} pseudo-op is not supported. |
| |
| @item @code{OPT} branch control options |
| |
| The m68k @code{OPT} branch control options---@code{B}, @code{BRS}, @code{BRB}, |
| @code{BRL}, and @code{BRW}---are ignored. @command{@value{AS}} automatically |
| relaxes all branches, whether forward or backward, to an appropriate size, so |
| these options serve no purpose. |
| |
| @item @code{OPT} list control options |
| |
| The following m68k @code{OPT} list control options are ignored: @code{C}, |
| @code{CEX}, @code{CL}, @code{CRE}, @code{E}, @code{G}, @code{I}, @code{M}, |
| @code{MEX}, @code{MC}, @code{MD}, @code{X}. |
| |
| @item other @code{OPT} options |
| |
| The following m68k @code{OPT} options are ignored: @code{NEST}, @code{O}, |
| @code{OLD}, @code{OP}, @code{P}, @code{PCO}, @code{PCR}, @code{PCS}, @code{R}. |
| |
| @item @code{OPT} @code{D} option is default |
| |
| The m68k @code{OPT} @code{D} option is the default, unlike the MRI assembler. |
| @code{OPT NOD} may be used to turn it off. |
| |
| @item @code{XREF} pseudo-op. |
| |
| The m68k @code{XREF} pseudo-op is ignored. |
| |
| @end itemize |
| |
| @node MD |
| @section Dependency Tracking: @option{--MD} |
| |
| @kindex --MD |
| @cindex dependency tracking |
| @cindex make rules |
| |
| @command{@value{AS}} can generate a dependency file for the file it creates. This |
| file consists of a single rule suitable for @code{make} describing the |
| dependencies of the main source file. |
| |
| The rule is written to the file named in its argument. |
| |
| This feature is used in the automatic updating of makefiles. |
| |
| @node no-pad-sections |
| @section Output Section Padding |
| @kindex --no-pad-sections |
| @cindex output section padding |
| Normally the assembler will pad the end of each output section up to its |
| alignment boundary. But this can waste space, which can be significant on |
| memory constrained targets. So the @option{--no-pad-sections} option will |
| disable this behaviour. |
| |
| @node o |
| @section Name the Object File: @option{-o} |
| |
| @kindex -o |
| @cindex naming object file |
| @cindex object file name |
| There is always one object file output when you run @command{@value{AS}}. By |
| default it has the name @file{a.out}. |
| You use this option (which takes exactly one filename) to give the |
| object file a different name. |
| |
| Whatever the object file is called, @command{@value{AS}} overwrites any |
| existing file of the same name. |
| |
| @node R |
| @section Join Data and Text Sections: @option{-R} |
| |
| @kindex -R |
| @cindex data and text sections, joining |
| @cindex text and data sections, joining |
| @cindex joining text and data sections |
| @cindex merging text and data sections |
| @option{-R} tells @command{@value{AS}} to write the object file as if all |
| data-section data lives in the text section. This is only done at |
| the very last moment: your binary data are the same, but data |
| section parts are relocated differently. The data section part of |
| your object file is zero bytes long because all its bytes are |
| appended to the text section. (@xref{Sections,,Sections and Relocation}.) |
| |
| When you specify @option{-R} it would be possible to generate shorter |
| address displacements (because we do not have to cross between text and |
| data section). We refrain from doing this simply for compatibility with |
| older versions of @command{@value{AS}}. In future, @option{-R} may work this way. |
| |
| @ifset COFF-ELF |
| When @command{@value{AS}} is configured for COFF or ELF output, |
| this option is only useful if you use sections named @samp{.text} and |
| @samp{.data}. |
| @end ifset |
| |
| @ifset HPPA |
| @option{-R} is not supported for any of the HPPA targets. Using |
| @option{-R} generates a warning from @command{@value{AS}}. |
| @end ifset |
| |
| @node statistics |
| @section Display Assembly Statistics: @option{--statistics} |
| |
| @kindex --statistics |
| @cindex statistics, about assembly |
| @cindex time, total for assembly |
| @cindex space used, maximum for assembly |
| Use @samp{--statistics} to display two statistics about the resources used by |
| @command{@value{AS}}: the maximum amount of space allocated during the assembly |
| (in bytes), and the total execution time taken for the assembly (in @sc{cpu} |
| seconds). |
| |
| @node traditional-format |
| @section Compatible Output: @option{--traditional-format} |
| |
| @kindex --traditional-format |
| For some targets, the output of @command{@value{AS}} is different in some ways |
| from the output of some existing assembler. This switch requests |
| @command{@value{AS}} to use the traditional format instead. |
| |
| For example, it disables the exception frame optimizations which |
| @command{@value{AS}} normally does by default on @code{@value{GCC}} output. |
| |
| @node v |
| @section Announce Version: @option{-v} |
| |
| @kindex -v |
| @kindex -version |
| @cindex assembler version |
| @cindex version of assembler |
| You can find out what version of as is running by including the |
| option @samp{-v} (which you can also spell as @samp{-version}) on the |
| command line. |
| |
| @node W |
| @section Control Warnings: @option{-W}, @option{--warn}, @option{--no-warn}, @option{--fatal-warnings} |
| |
| @command{@value{AS}} should never give a warning or error message when |
| assembling compiler output. But programs written by people often |
| cause @command{@value{AS}} to give a warning that a particular assumption was |
| made. All such warnings are directed to the standard error file. |
| |
| @kindex -W |
| @kindex --no-warn |
| @cindex suppressing warnings |
| @cindex warnings, suppressing |
| If you use the @option{-W} and @option{--no-warn} options, no warnings are issued. |
| This only affects the warning messages: it does not change any particular of |
| how @command{@value{AS}} assembles your file. Errors, which stop the assembly, |
| are still reported. |
| |
| @kindex --fatal-warnings |
| @cindex errors, caused by warnings |
| @cindex warnings, causing error |
| If you use the @option{--fatal-warnings} option, @command{@value{AS}} considers |
| files that generate warnings to be in error. |
| |
| @kindex --warn |
| @cindex warnings, switching on |
| You can switch these options off again by specifying @option{--warn}, which |
| causes warnings to be output as usual. |
| |
| @node Z |
| @section Generate Object File in Spite of Errors: @option{-Z} |
| @cindex object file, after errors |
| @cindex errors, continuing after |
| After an error message, @command{@value{AS}} normally produces no output. If for |
| some reason you are interested in object file output even after |
| @command{@value{AS}} gives an error message on your program, use the @samp{-Z} |
| option. If there are any errors, @command{@value{AS}} continues anyways, and |
| writes an object file after a final warning message of the form @samp{@var{n} |
| errors, @var{m} warnings, generating bad object file.} |
| |
| @node Syntax |
| @chapter Syntax |
| |
| @cindex machine-independent syntax |
| @cindex syntax, machine-independent |
| This chapter describes the machine-independent syntax allowed in a |
| source file. @command{@value{AS}} syntax is similar to what many other |
| assemblers use; it is inspired by the BSD 4.2 |
| @ifclear VAX |
| assembler. |
| @end ifclear |
| @ifset VAX |
| assembler, except that @command{@value{AS}} does not assemble Vax bit-fields. |
| @end ifset |
| |
| @menu |
| * Preprocessing:: Preprocessing |
| * Whitespace:: Whitespace |
| * Comments:: Comments |
| * Symbol Intro:: Symbols |
| * Statements:: Statements |
| * Constants:: Constants |
| @end menu |
| |
| @node Preprocessing |
| @section Preprocessing |
| |
| @cindex preprocessing |
| The @command{@value{AS}} internal preprocessor: |
| @itemize @bullet |
| @cindex whitespace, removed by preprocessor |
| @item |
| adjusts and removes extra whitespace. It leaves one space or tab before |
| the keywords on a line, and turns any other whitespace on the line into |
| a single space. |
| |
| @cindex comments, removed by preprocessor |
| @item |
| removes all comments, replacing them with a single space, or an |
| appropriate number of newlines. |
| |
| @cindex constants, converted by preprocessor |
| @item |
| converts character constants into the appropriate numeric values. |
| @end itemize |
| |
| It does not do macro processing, include file handling, or |
| anything else you may get from your C compiler's preprocessor. You can |
| do include file processing with the @code{.include} directive |
| (@pxref{Include,,@code{.include}}). You can use the @sc{gnu} C compiler driver |
| to get other ``CPP'' style preprocessing by giving the input file a |
| @samp{.S} suffix. @url{https://gcc.gnu.org/onlinedocs/gcc/Overall-Options.html#Overall-Options, |
| See the 'Options Controlling the Kind of Output' section of the GCC manual for |
| more details} |
| |
| Excess whitespace, comments, and character constants |
| cannot be used in the portions of the input text that are not |
| preprocessed. |
| |
| @cindex turning preprocessing on and off |
| @cindex preprocessing, turning on and off |
| @kindex #NO_APP |
| @kindex #APP |
| If the first line of an input file is @code{#NO_APP} or if you use the |
| @samp{-f} option, whitespace and comments are not removed from the input file. |
| Within an input file, you can ask for whitespace and comment removal in |
| specific portions of the by putting a line that says @code{#APP} before the |
| text that may contain whitespace or comments, and putting a line that says |
| @code{#NO_APP} after this text. This feature is mainly intend to support |
| @code{asm} statements in compilers whose output is otherwise free of comments |
| and whitespace. |
| |
| @node Whitespace |
| @section Whitespace |
| |
| @cindex whitespace |
| @dfn{Whitespace} is one or more blanks or tabs, in any order. |
| Whitespace is used to separate symbols, and to make programs neater for |
| people to read. Unless within character constants |
| (@pxref{Characters,,Character Constants}), any whitespace means the same |
| as exactly one space. |
| |
| @node Comments |
| @section Comments |
| |
| @cindex comments |
| There are two ways of rendering comments to @command{@value{AS}}. In both |
| cases the comment is equivalent to one space. |
| |
| Anything from @samp{/*} through the next @samp{*/} is a comment. |
| This means you may not nest these comments. |
| |
| @smallexample |
| /* |
| The only way to include a newline ('\n') in a comment |
| is to use this sort of comment. |
| */ |
| |
| /* This sort of comment does not nest. */ |
| @end smallexample |
| |
| @cindex line comment character |
| Anything from a @dfn{line comment} character up to the next newline is |
| considered a comment and is ignored. The line comment character is target |
| specific, and some targets multiple comment characters. Some targets also have |
| line comment characters that only work if they are the first character on a |
| line. Some targets use a sequence of two characters to introduce a line |
| comment. Some targets can also change their line comment characters depending |
| upon command-line options that have been used. For more details see the |
| @emph{Syntax} section in the documentation for individual targets. |
| |
| If the line comment character is the hash sign (@samp{#}) then it still has the |
| special ability to enable and disable preprocessing (@pxref{Preprocessing}) and |
| to specify logical line numbers: |
| |
| @kindex # |
| @cindex lines starting with @code{#} |
| @cindex logical line numbers |
| To be compatible with past assemblers, lines that begin with @samp{#} have a |
| special interpretation. Following the @samp{#} should be an absolute |
| expression (@pxref{Expressions}): the logical line number of the @emph{next} |
| line. Then a string (@pxref{Strings, ,Strings}) is allowed: if present it is a |
| new logical file name. The rest of the line, if any, should be whitespace. |
| |
| If the first non-whitespace characters on the line are not numeric, |
| the line is ignored. (Just like a comment.) |
| |
| @smallexample |
| # This is an ordinary comment. |
| # 42-6 "new_file_name" # New logical file name |
| # This is logical line # 36. |
| @end smallexample |
| This feature is deprecated, and may disappear from future versions |
| of @command{@value{AS}}. |
| |
| @node Symbol Intro |
| @section Symbols |
| |
| @cindex characters used in symbols |
| @ifclear SPECIAL-SYMS |
| A @dfn{symbol} is one or more characters chosen from the set of all |
| letters (both upper and lower case), digits and the three characters |
| @samp{_.$}. |
| @end ifclear |
| @ifset SPECIAL-SYMS |
| @ifclear GENERIC |
| @ifset H8 |
| A @dfn{symbol} is one or more characters chosen from the set of all |
| letters (both upper and lower case), digits and the three characters |
| @samp{._$}. (Save that, on the H8/300 only, you may not use @samp{$} in |
| symbol names.) |
| @end ifset |
| @end ifclear |
| @end ifset |
| @ifset GENERIC |
| On most machines, you can also use @code{$} in symbol names; exceptions |
| are noted in @ref{Machine Dependencies}. |
| @end ifset |
| No symbol may begin with a digit. Case is significant. |
| There is no length limit; all characters are significant. Multibyte characters |
| are supported. Symbols are delimited by characters not in that set, or by the |
| beginning of a file (since the source program must end with a newline, the end |
| of a file is not a possible symbol delimiter). @xref{Symbols}. |
| |
| Symbol names may also be enclosed in double quote @code{"} characters. In such |
| cases any characters are allowed, except for the NUL character. If a double |
| quote character is to be included in the symbol name it must be preceded by a |
| backslash @code{\} character. |
| @cindex length of symbols |
| |
| @node Statements |
| @section Statements |
| |
| @cindex statements, structure of |
| @cindex line separator character |
| @cindex statement separator character |
| |
| A @dfn{statement} ends at a newline character (@samp{\n}) or a |
| @dfn{line separator character}. The line separator character is target |
| specific and described in the @emph{Syntax} section of each |
| target's documentation. Not all targets support a line separator character. |
| The newline or line separator character is considered to be part of the |
| preceding statement. Newlines and separators within character constants are an |
| exception: they do not end statements. |
| |
| @cindex newline, required at file end |
| @cindex EOF, newline must precede |
| It is an error to end any statement with end-of-file: the last |
| character of any input file should be a newline.@refill |
| |
| An empty statement is allowed, and may include whitespace. It is ignored. |
| |
| @cindex instructions and directives |
| @cindex directives and instructions |
| @c "key symbol" is not used elsewhere in the document; seems pedantic to |
| @c @defn{} it in that case, as was done previously... doc@cygnus.com, |
| @c 13feb91. |
| A statement begins with zero or more labels, optionally followed by a |
| key symbol which determines what kind of statement it is. The key |
| symbol determines the syntax of the rest of the statement. If the |
| symbol begins with a dot @samp{.} then the statement is an assembler |
| directive: typically valid for any computer. If the symbol begins with |
| a letter the statement is an assembly language @dfn{instruction}: it |
| assembles into a machine language instruction. |
| @ifset GENERIC |
| Different versions of @command{@value{AS}} for different computers |
| recognize different instructions. In fact, the same symbol may |
| represent a different instruction in a different computer's assembly |
| language.@refill |
| @end ifset |
| |
| @cindex @code{:} (label) |
| @cindex label (@code{:}) |
| A label is a symbol immediately followed by a colon (@code{:}). |
| Whitespace before a label or after a colon is permitted, but you may not |
| have whitespace between a label's symbol and its colon. @xref{Labels}. |
| |
| @ifset HPPA |
| For HPPA targets, labels need not be immediately followed by a colon, but |
| the definition of a label must begin in column zero. This also implies that |
| only one label may be defined on each line. |
| @end ifset |
| |
| @smallexample |
| label: .directive followed by something |
| another_label: # This is an empty statement. |
| instruction operand_1, operand_2, @dots{} |
| @end smallexample |
| |
| @node Constants |
| @section Constants |
| |
| @cindex constants |
| A constant is a number, written so that its value is known by |
| inspection, without knowing any context. Like this: |
| @smallexample |
| @group |
| .byte 74, 0112, 092, 0x4A, 0X4a, 'J, '\J # All the same value. |
| .ascii "Ring the bell\7" # A string constant. |
| .octa 0x123456789abcdef0123456789ABCDEF0 # A bignum. |
| .float 0f-314159265358979323846264338327\ |
| 95028841971.693993751E-40 # - pi, a flonum. |
| @end group |
| @end smallexample |
| |
| @menu |
| * Characters:: Character Constants |
| * Numbers:: Number Constants |
| @end menu |
| |
| @node Characters |
| @subsection Character Constants |
| |
| @cindex character constants |
| @cindex constants, character |
| There are two kinds of character constants. A @dfn{character} stands |
| for one character in one byte and its value may be used in |
| numeric expressions. String constants (properly called string |
| @emph{literals}) are potentially many bytes and their values may not be |
| used in arithmetic expressions. |
| |
| @menu |
| * Strings:: Strings |
| * Chars:: Characters |
| @end menu |
| |
| @node Strings |
| @subsubsection Strings |
| |
| @cindex string constants |
| @cindex constants, string |
| A @dfn{string} is written between double-quotes. It may contain |
| double-quotes or null characters. The way to get special characters |
| into a string is to @dfn{escape} these characters: precede them with |
| a backslash @samp{\} character. For example @samp{\\} represents |
| one backslash: the first @code{\} is an escape which tells |
| @command{@value{AS}} to interpret the second character literally as a backslash |
| (which prevents @command{@value{AS}} from recognizing the second @code{\} as an |
| escape character). The complete list of escapes follows. |
| |
| @cindex escape codes, character |
| @cindex character escape codes |
| @c NOTE: Cindex entries must not start with a backlash character. |
| @c NOTE: This confuses the pdf2texi script when it is creating the |
| @c NOTE: index based upon the first character and so it generates: |
| @c NOTE: \initial {\\} |
| @c NOTE: which then results in the error message: |
| @c NOTE: Argument of \\ has an extra }. |
| @c NOTE: So in the index entries below a space character has been |
| @c NOTE: prepended to avoid this problem. |
| @table @kbd |
| @c @item \a |
| @c Mnemonic for ACKnowledge; for ASCII this is octal code 007. |
| @c |
| @cindex @code{ \b} (backspace character) |
| @cindex backspace (@code{\b}) |
| @item \b |
| Mnemonic for backspace; for ASCII this is octal code 010. |
| |
| @c @item \e |
| @c Mnemonic for EOText; for ASCII this is octal code 004. |
| @c |
| @cindex @code{ \f} (formfeed character) |
| @cindex formfeed (@code{\f}) |
| @item backslash-f |
| Mnemonic for FormFeed; for ASCII this is octal code 014. |
| |
| @cindex @code{ \n} (newline character) |
| @cindex newline (@code{\n}) |
| @item \n |
| Mnemonic for newline; for ASCII this is octal code 012. |
| |
| @c @item \p |
| @c Mnemonic for prefix; for ASCII this is octal code 033, usually known as @code{escape}. |
| @c |
| @cindex @code{ \r} (carriage return character) |
| @cindex carriage return (@code{backslash-r}) |
| @item \r |
| Mnemonic for carriage-Return; for ASCII this is octal code 015. |
| |
| @c @item \s |
| @c Mnemonic for space; for ASCII this is octal code 040. Included for compliance with |
| @c other assemblers. |
| @c |
| @cindex @code{ \t} (tab) |
| @cindex tab (@code{\t}) |
| @item \t |
| Mnemonic for horizontal Tab; for ASCII this is octal code 011. |
| |
| @c @item \v |
| @c Mnemonic for Vertical tab; for ASCII this is octal code 013. |
| @c @item \x @var{digit} @var{digit} @var{digit} |
| @c A hexadecimal character code. The numeric code is 3 hexadecimal digits. |
| @c |
| @cindex @code{ \@var{ddd}} (octal character code) |
| @cindex octal character code (@code{\@var{ddd}}) |
| @item \ @var{digit} @var{digit} @var{digit} |
| An octal character code. The numeric code is 3 octal digits. |
| For compatibility with other Unix systems, 8 and 9 are accepted as digits: |
| for example, @code{\008} has the value 010, and @code{\009} the value 011. |
| |
| @cindex @code{ \@var{xd...}} (hex character code) |
| @cindex hex character code (@code{\@var{xd...}}) |
| @item \@code{x} @var{hex-digits...} |
| A hex character code. All trailing hex digits are combined. Either upper or |
| lower case @code{x} works. |
| |
| @cindex @code{ \\} (@samp{\} character) |
| @cindex backslash (@code{\\}) |
| @item \\ |
| Represents one @samp{\} character. |
| |
| @c @item \' |
| @c Represents one @samp{'} (accent acute) character. |
| @c This is needed in single character literals |
| @c (@xref{Characters,,Character Constants}.) to represent |
| @c a @samp{'}. |
| @c |
| @cindex @code{ \"} (doublequote character) |
| @cindex doublequote (@code{\"}) |
| @item \" |
| Represents one @samp{"} character. Needed in strings to represent |
| this character, because an unescaped @samp{"} would end the string. |
| |
| @item \ @var{anything-else} |
| Any other character when escaped by @kbd{\} gives a warning, but |
| assembles as if the @samp{\} was not present. The idea is that if |
| you used an escape sequence you clearly didn't want the literal |
| interpretation of the following character. However @command{@value{AS}} has no |
| other interpretation, so @command{@value{AS}} knows it is giving you the wrong |
| code and warns you of the fact. |
| @end table |
| |
| Which characters are escapable, and what those escapes represent, |
| varies widely among assemblers. The current set is what we think |
| the BSD 4.2 assembler recognizes, and is a subset of what most C |
| compilers recognize. If you are in doubt, do not use an escape |
| sequence. |
| |
| @node Chars |
| @subsubsection Characters |
| |
| @cindex single character constant |
| @cindex character, single |
| @cindex constant, single character |
| A single character may be written as a single quote immediately followed by |
| that character. Some backslash escapes apply to characters, @code{\b}, |
| @code{\f}, @code{\n}, @code{\r}, @code{\t}, and @code{\"} with the same meaning |
| as for strings, plus @code{\'} for a single quote. So if you want to write the |
| character backslash, you must write @kbd{'\\} where the first @code{\} escapes |
| the second @code{\}. As you can see, the quote is an acute accent, not a grave |
| accent. A newline |
| @ifclear GENERIC |
| @ifclear abnormal-separator |
| (or semicolon @samp{;}) |
| @end ifclear |
| @ifset abnormal-separator |
| @ifset H8 |
| (or dollar sign @samp{$}, for the H8/300; or semicolon @samp{;} for the |
| Renesas SH) |
| @end ifset |
| @end ifset |
| @end ifclear |
| immediately following an acute accent is taken as a literal character |
| and does not count as the end of a statement. The value of a character |
| constant in a numeric expression is the machine's byte-wide code for |
| that character. @command{@value{AS}} assumes your character code is ASCII: |
| @kbd{'A} means 65, @kbd{'B} means 66, and so on. @refill |
| |
| @node Numbers |
| @subsection Number Constants |
| |
| @cindex constants, number |
| @cindex number constants |
| @command{@value{AS}} distinguishes three kinds of numbers according to how they |
| are stored in the target machine. @emph{Integers} are numbers that |
| would fit into an @code{int} in the C language. @emph{Bignums} are |
| integers, but they are stored in more than 32 bits. @emph{Flonums} |
| are floating point numbers, described below. |
| |
| @menu |
| * Integers:: Integers |
| * Bignums:: Bignums |
| * Flonums:: Flonums |
| @ifclear GENERIC |
| @end ifclear |
| @end menu |
| |
| @node Integers |
| @subsubsection Integers |
| @cindex integers |
| @cindex constants, integer |
| |
| @cindex binary integers |
| @cindex integers, binary |
| A binary integer is @samp{0b} or @samp{0B} followed by zero or more of |
| the binary digits @samp{01}. |
| |
| @cindex octal integers |
| @cindex integers, octal |
| An octal integer is @samp{0} followed by zero or more of the octal |
| digits (@samp{01234567}). |
| |
| @cindex decimal integers |
| @cindex integers, decimal |
| A decimal integer starts with a non-zero digit followed by zero or |
| more digits (@samp{0123456789}). |
| |
| @cindex hexadecimal integers |
| @cindex integers, hexadecimal |
| A hexadecimal integer is @samp{0x} or @samp{0X} followed by one or |
| more hexadecimal digits chosen from @samp{0123456789abcdefABCDEF}. |
| |
| Integers have the usual values. To denote a negative integer, use |
| the prefix operator @samp{-} discussed under expressions |
| (@pxref{Prefix Ops,,Prefix Operators}). |
| |
| @node Bignums |
| @subsubsection Bignums |
| |
| @cindex bignums |
| @cindex constants, bignum |
| A @dfn{bignum} has the same syntax and semantics as an integer |
| except that the number (or its negative) takes more than 32 bits to |
| represent in binary. The distinction is made because in some places |
| integers are permitted while bignums are not. |
| |
| @node Flonums |
| @subsubsection Flonums |
| @cindex flonums |
| @cindex floating point numbers |
| @cindex constants, floating point |
| |
| @cindex precision, floating point |
| A @dfn{flonum} represents a floating point number. The translation is |
| indirect: a decimal floating point number from the text is converted by |
| @command{@value{AS}} to a generic binary floating point number of more than |
| sufficient precision. This generic floating point number is converted |
| to a particular computer's floating point format (or formats) by a |
| portion of @command{@value{AS}} specialized to that computer. |
| |
| A flonum is written by writing (in order) |
| @itemize @bullet |
| @item |
| The digit @samp{0}. |
| @ifset HPPA |
| (@samp{0} is optional on the HPPA.) |
| @end ifset |
| |
| @item |
| A letter, to tell @command{@value{AS}} the rest of the number is a flonum. |
| @ifset GENERIC |
| @kbd{e} is recommended. Case is not important. |
| @ignore |
| @c FIXME: verify if flonum syntax really this vague for most cases |
| (Any otherwise illegal letter works here, but that might be changed. Vax BSD |
| 4.2 assembler seems to allow any of @samp{defghDEFGH}.) |
| @end ignore |
| |
| On the H8/300 and Renesas / SuperH SH architectures, the letter must be |
| one of the letters @samp{DFPRSX} (in upper or lower case). |
| |
| On the ARC, the letter must be one of the letters @samp{DFRS} |
| (in upper or lower case). |
| |
| On the HPPA architecture, the letter must be @samp{E} (upper case only). |
| @end ifset |
| @ifclear GENERIC |
| @ifset ARC |
| One of the letters @samp{DFRS} (in upper or lower case). |
| @end ifset |
| @ifset H8 |
| One of the letters @samp{DFPRSX} (in upper or lower case). |
| @end ifset |
| @ifset HPPA |
| The letter @samp{E} (upper case only). |
| @end ifset |
| @end ifclear |
| |
| @item |
| An optional sign: either @samp{+} or @samp{-}. |
| |
| @item |
| An optional @dfn{integer part}: zero or more decimal digits. |
| |
| @item |
| An optional @dfn{fractional part}: @samp{.} followed by zero |
| or more decimal digits. |
| |
| @item |
| An optional exponent, consisting of: |
| |
| @itemize @bullet |
| @item |
| An @samp{E} or @samp{e}. |
| @c I can't find a config where "EXP_CHARS" is other than 'eE', but in |
| @c principle this can perfectly well be different on different targets. |
| @item |
| Optional sign: either @samp{+} or @samp{-}. |
| @item |
| One or more decimal digits. |
| @end itemize |
| |
| @end itemize |
| |
| At least one of the integer part or the fractional part must be |
| present. The floating point number has the usual base-10 value. |
| |
| @command{@value{AS}} does all processing using integers. Flonums are computed |
| independently of any floating point hardware in the computer running |
| @command{@value{AS}}. |
| |
| @node Sections |
| @chapter Sections and Relocation |
| @cindex sections |
| @cindex relocation |
| |
| @menu |
| * Secs Background:: Background |
| * Ld Sections:: Linker Sections |
| * As Sections:: Assembler Internal Sections |
| * Sub-Sections:: Sub-Sections |
| * bss:: bss Section |
| @end menu |
| |
| @node Secs Background |
| @section Background |
| |
| Roughly, a section is a range of addresses, with no gaps; all data |
| ``in'' those addresses is treated the same for some particular purpose. |
| For example there may be a ``read only'' section. |
| |
| @cindex linker, and assembler |
| @cindex assembler, and linker |
| The linker @code{@value{LD}} reads many object files (partial programs) and |
| combines their contents to form a runnable program. When @command{@value{AS}} |
| emits an object file, the partial program is assumed to start at address 0. |
| @code{@value{LD}} assigns the final addresses for the partial program, so that |
| different partial programs do not overlap. This is actually an |
| oversimplification, but it suffices to explain how @command{@value{AS}} uses |
| sections. |
| |
| @code{@value{LD}} moves blocks of bytes of your program to their run-time |
| addresses. These blocks slide to their run-time addresses as rigid |
| units; their length does not change and neither does the order of bytes |
| within them. Such a rigid unit is called a @emph{section}. Assigning |
| run-time addresses to sections is called @dfn{relocation}. It includes |
| the task of adjusting mentions of object-file addresses so they refer to |
| the proper run-time addresses. |
| @ifset H8 |
| For the H8/300, and for the Renesas / SuperH SH, |
| @command{@value{AS}} pads sections if needed to |
| ensure they end on a word (sixteen bit) boundary. |
| @end ifset |
| |
| @cindex standard assembler sections |
| An object file written by @command{@value{AS}} has at least three sections, any |
| of which may be empty. These are named @dfn{text}, @dfn{data} and |
| @dfn{bss} sections. |
| |
| @ifset COFF-ELF |
| @ifset GENERIC |
| When it generates COFF or ELF output, |
| @end ifset |
| @command{@value{AS}} can also generate whatever other named sections you specify |
| using the @samp{.section} directive (@pxref{Section,,@code{.section}}). |
| If you do not use any directives that place output in the @samp{.text} |
| or @samp{.data} sections, these sections still exist, but are empty. |
| @end ifset |
| |
| @ifset HPPA |
| @ifset GENERIC |
| When @command{@value{AS}} generates SOM or ELF output for the HPPA, |
| @end ifset |
| @command{@value{AS}} can also generate whatever other named sections you |
| specify using the @samp{.space} and @samp{.subspace} directives. See |
| @cite{HP9000 Series 800 Assembly Language Reference Manual} |
| (HP 92432-90001) for details on the @samp{.space} and @samp{.subspace} |
| assembler directives. |
| |
| @ifset SOM |
| Additionally, @command{@value{AS}} uses different names for the standard |
| text, data, and bss sections when generating SOM output. Program text |
| is placed into the @samp{$CODE$} section, data into @samp{$DATA$}, and |
| BSS into @samp{$BSS$}. |
| @end ifset |
| @end ifset |
| |
| Within the object file, the text section starts at address @code{0}, the |
| data section follows, and the bss section follows the data section. |
| |
| @ifset HPPA |
| When generating either SOM or ELF output files on the HPPA, the text |
| section starts at address @code{0}, the data section at address |
| @code{0x4000000}, and the bss section follows the data section. |
| @end ifset |
| |
| To let @code{@value{LD}} know which data changes when the sections are |
| relocated, and how to change that data, @command{@value{AS}} also writes to the |
| object file details of the relocation needed. To perform relocation |
| @code{@value{LD}} must know, each time an address in the object |
| file is mentioned: |
| @itemize @bullet |
| @item |
| Where in the object file is the beginning of this reference to |
| an address? |
| @item |
| How long (in bytes) is this reference? |
| @item |
| Which section does the address refer to? What is the numeric value of |
| @display |
| (@var{address}) @minus{} (@var{start-address of section})? |
| @end display |
| @item |
| Is the reference to an address ``Program-Counter relative''? |
| @end itemize |
| |
| @cindex addresses, format of |
| @cindex section-relative addressing |
| In fact, every address @command{@value{AS}} ever uses is expressed as |
| @display |
| (@var{section}) + (@var{offset into section}) |
| @end display |
| @noindent |
| Further, most expressions @command{@value{AS}} computes have this section-relative |
| nature. |
| @ifset SOM |
| (For some object formats, such as SOM for the HPPA, some expressions are |
| symbol-relative instead.) |
| @end ifset |
| |
| In this manual we use the notation @{@var{secname} @var{N}@} to mean ``offset |
| @var{N} into section @var{secname}.'' |
| |
| Apart from text, data and bss sections you need to know about the |
| @dfn{absolute} section. When @code{@value{LD}} mixes partial programs, |
| addresses in the absolute section remain unchanged. For example, address |
| @code{@{absolute 0@}} is ``relocated'' to run-time address 0 by |
| @code{@value{LD}}. Although the linker never arranges two partial programs' |
| data sections with overlapping addresses after linking, @emph{by definition} |
| their absolute sections must overlap. Address @code{@{absolute@ 239@}} in one |
| part of a program is always the same address when the program is running as |
| address @code{@{absolute@ 239@}} in any other part of the program. |
| |
| The idea of sections is extended to the @dfn{undefined} section. Any |
| address whose section is unknown at assembly time is by definition |
| rendered @{undefined @var{U}@}---where @var{U} is filled in later. |
| Since numbers are always defined, the only way to generate an undefined |
| address is to mention an undefined symbol. A reference to a named |
| common block would be such a symbol: its value is unknown at assembly |
| time so it has section @emph{undefined}. |
| |
| By analogy the word @emph{section} is used to describe groups of sections in |
| the linked program. @code{@value{LD}} puts all partial programs' text |
| sections in contiguous addresses in the linked program. It is |
| customary to refer to the @emph{text section} of a program, meaning all |
| the addresses of all partial programs' text sections. Likewise for |
| data and bss sections. |
| |
| Some sections are manipulated by @code{@value{LD}}; others are invented for |
| use of @command{@value{AS}} and have no meaning except during assembly. |
| |
| @node Ld Sections |
| @section Linker Sections |
| @code{@value{LD}} deals with just four kinds of sections, summarized below. |
| |
| @table @strong |
| |
| @ifset COFF-ELF |
| @cindex named sections |
| @cindex sections, named |
| @item named sections |
| @end ifset |
| @ifset aout |
| @cindex text section |
| @cindex data section |
| @itemx text section |
| @itemx data section |
| @end ifset |
| These sections hold your program. @command{@value{AS}} and @code{@value{LD}} treat them as |
| separate but equal sections. Anything you can say of one section is |
| true of another. |
| @c @ifset aout |
| When the program is running, however, it is |
| customary for the text section to be unalterable. The |
| text section is often shared among processes: it contains |
| instructions, constants and the like. The data section of a running |
| program is usually alterable: for example, C variables would be stored |
| in the data section. |
| @c @end ifset |
| |
| @cindex bss section |
| @item bss section |
| This section contains zeroed bytes when your program begins running. It |
| is used to hold uninitialized variables or common storage. The length of |
| each partial program's bss section is important, but because it starts |
| out containing zeroed bytes there is no need to store explicit zero |
| bytes in the object file. The bss section was invented to eliminate |
| those explicit zeros from object files. |
| |
| @cindex absolute section |
| @item absolute section |
| Address 0 of this section is always ``relocated'' to runtime address 0. |
| This is useful if you want to refer to an address that @code{@value{LD}} must |
| not change when relocating. In this sense we speak of absolute |
| addresses being ``unrelocatable'': they do not change during relocation. |
| |
| @cindex undefined section |
| @item undefined section |
| This ``section'' is a catch-all for address references to objects not in |
| the preceding sections. |
| @c FIXME: ref to some other doc on obj-file formats could go here. |
| @end table |
| |
| @cindex relocation example |
| An idealized example of three relocatable sections follows. |
| @ifset COFF-ELF |
| The example uses the traditional section names @samp{.text} and @samp{.data}. |
| @end ifset |
| Memory addresses are on the horizontal axis. |
| |
| @c TEXI2ROFF-KILL |
| @ifnottex |
| @c END TEXI2ROFF-KILL |
| @smallexample |
| +-----+----+--+ |
| partial program # 1: |ttttt|dddd|00| |
| +-----+----+--+ |
| |
| text data bss |
| seg. seg. seg. |
| |
| +---+---+---+ |
| partial program # 2: |TTT|DDD|000| |
| +---+---+---+ |
| |
| +--+---+-----+--+----+---+-----+~~ |
| linked program: | |TTT|ttttt| |dddd|DDD|00000| |
| +--+---+-----+--+----+---+-----+~~ |
| |
| addresses: 0 @dots{} |
| @end smallexample |
| @c TEXI2ROFF-KILL |
| @end ifnottex |
| @need 5000 |
| @tex |
| \bigskip |
| \line{\it Partial program \#1: \hfil} |
| \line{\ibox{2.5cm}{\tt text}\ibox{2cm}{\tt data}\ibox{1cm}{\tt bss}\hfil} |
| \line{\boxit{2.5cm}{\tt ttttt}\boxit{2cm}{\tt dddd}\boxit{1cm}{\tt 00}\hfil} |
| |
| \line{\it Partial program \#2: \hfil} |
| \line{\ibox{1cm}{\tt text}\ibox{1.5cm}{\tt data}\ibox{1cm}{\tt bss}\hfil} |
| \line{\boxit{1cm}{\tt TTT}\boxit{1.5cm}{\tt DDDD}\boxit{1cm}{\tt 000}\hfil} |
| |
| \line{\it linked program: \hfil} |
| \line{\ibox{.5cm}{}\ibox{1cm}{\tt text}\ibox{2.5cm}{}\ibox{.75cm}{}\ibox{2cm}{\tt data}\ibox{1.5cm}{}\ibox{2cm}{\tt bss}\hfil} |
| \line{\boxit{.5cm}{}\boxit{1cm}{\tt TTT}\boxit{2.5cm}{\tt |
| ttttt}\boxit{.75cm}{}\boxit{2cm}{\tt dddd}\boxit{1.5cm}{\tt |
| DDDD}\boxit{2cm}{\tt 00000}\ \dots\hfil} |
| |
| \line{\it addresses: \hfil} |
| \line{0\dots\hfil} |
| |
| @end tex |
| @c END TEXI2ROFF-KILL |
| |
| @node As Sections |
| @section Assembler Internal Sections |
| |
| @cindex internal assembler sections |
| @cindex sections in messages, internal |
| These sections are meant only for the internal use of @command{@value{AS}}. They |
| have no meaning at run-time. You do not really need to know about these |
| sections for most purposes; but they can be mentioned in @command{@value{AS}} |
| warning messages, so it might be helpful to have an idea of their |
| meanings to @command{@value{AS}}. These sections are used to permit the |
| value of every expression in your assembly language program to be a |
| section-relative address. |
| |
| @table @b |
| @cindex assembler internal logic error |
| @item ASSEMBLER-INTERNAL-LOGIC-ERROR! |
| An internal assembler logic error has been found. This means there is a |
| bug in the assembler. |
| |
| @cindex expr (internal section) |
| @item expr section |
| The assembler stores complex expression internally as combinations of |
| symbols. When it needs to represent an expression as a symbol, it puts |
| it in the expr section. |
| @c FIXME item debug |
| @c FIXME item transfer[t] vector preload |
| @c FIXME item transfer[t] vector postload |
| @c FIXME item register |
| @end table |
| |
| @node Sub-Sections |
| @section Sub-Sections |
| |
| @cindex numbered subsections |
| @cindex grouping data |
| @ifset aout |
| Assembled bytes |
| @ifset COFF-ELF |
| conventionally |
| @end ifset |
| fall into two sections: text and data. |
| @end ifset |
| You may have separate groups of |
| @ifset GENERIC |
| data in named sections |
| @end ifset |
| @ifclear GENERIC |
| @ifclear aout |
| data in named sections |
| @end ifclear |
| @ifset aout |
| text or data |
| @end ifset |
| @end ifclear |
| that you want to end up near to each other in the object file, even though they |
| are not contiguous in the assembler source. @command{@value{AS}} allows you to |
| use @dfn{subsections} for this purpose. Within each section, there can be |
| numbered subsections with values from 0 to 8192. Objects assembled into the |
| same subsection go into the object file together with other objects in the same |
| subsection. For example, a compiler might want to store constants in the text |
| section, but might not want to have them interspersed with the program being |
| assembled. In this case, the compiler could issue a @samp{.text 0} before each |
| section of code being output, and a @samp{.text 1} before each group of |
| constants being output. |
| |
| Subsections are optional. If you do not use subsections, everything |
| goes in subsection number zero. |
| |
| @ifset GENERIC |
| Each subsection is zero-padded up to a multiple of four bytes. |
| (Subsections may be padded a different amount on different flavors |
| of @command{@value{AS}}.) |
| @end ifset |
| @ifclear GENERIC |
| @ifset H8 |
| On the H8/300 platform, each subsection is zero-padded to a word |
| boundary (two bytes). |
| The same is true on the Renesas SH. |
| @end ifset |
| @end ifclear |
| |
| Subsections appear in your object file in numeric order, lowest numbered |
| to highest. (All this to be compatible with other people's assemblers.) |
| The object file contains no representation of subsections; @code{@value{LD}} and |
| other programs that manipulate object files see no trace of them. |
| They just see all your text subsections as a text section, and all your |
| data subsections as a data section. |
| |
| To specify which subsection you want subsequent statements assembled |
| into, use a numeric argument to specify it, in a @samp{.text |
| @var{expression}} or a @samp{.data @var{expression}} statement. |
| @ifset COFF |
| @ifset GENERIC |
| When generating COFF output, you |
| @end ifset |
| @ifclear GENERIC |
| You |
| @end ifclear |
| can also use an extra subsection |
| argument with arbitrary named sections: @samp{.section @var{name}, |
| @var{expression}}. |
| @end ifset |
| @ifset ELF |
| @ifset GENERIC |
| When generating ELF output, you |
| @end ifset |
| @ifclear GENERIC |
| You |
| @end ifclear |
| can also use the @code{.subsection} directive (@pxref{SubSection}) |
| to specify a subsection: @samp{.subsection @var{expression}}. |
| @end ifset |
| @var{Expression} should be an absolute expression |
| (@pxref{Expressions}). If you just say @samp{.text} then @samp{.text 0} |
| is assumed. Likewise @samp{.data} means @samp{.data 0}. Assembly |
| begins in @code{text 0}. For instance: |
| @smallexample |
| .text 0 # The default subsection is text 0 anyway. |
| .ascii "This lives in the first text subsection. *" |
| .text 1 |
| .ascii "But this lives in the second text subsection." |
| .data 0 |
| .ascii "This lives in the data section," |
| .ascii "in the first data subsection." |
| .text 0 |
| .ascii "This lives in the first text section," |
| .ascii "immediately following the asterisk (*)." |
| @end smallexample |
| |
| Each section has a @dfn{location counter} incremented by one for every byte |
| assembled into that section. Because subsections are merely a convenience |
| restricted to @command{@value{AS}} there is no concept of a subsection location |
| counter. There is no way to directly manipulate a location counter---but the |
| @code{.align} directive changes it, and any label definition captures its |
| current value. The location counter of the section where statements are being |
| assembled is said to be the @dfn{active} location counter. |
| |
| @node bss |
| @section bss Section |
| |
| @cindex bss section |
| @cindex common variable storage |
| The bss section is used for local common variable storage. |
| You may allocate address space in the bss section, but you may |
| not dictate data to load into it before your program executes. When |
| your program starts running, all the contents of the bss |
| section are zeroed bytes. |
| |
| The @code{.lcomm} pseudo-op defines a symbol in the bss section; see |
| @ref{Lcomm,,@code{.lcomm}}. |
| |
| The @code{.comm} pseudo-op may be used to declare a common symbol, which is |
| another form of uninitialized symbol; see @ref{Comm,,@code{.comm}}. |
| |
| @ifset GENERIC |
| When assembling for a target which supports multiple sections, such as ELF or |
| COFF, you may switch into the @code{.bss} section and define symbols as usual; |
| see @ref{Section,,@code{.section}}. You may only assemble zero values into the |
| section. Typically the section will only contain symbol definitions and |
| @code{.skip} directives (@pxref{Skip,,@code{.skip}}). |
| @end ifset |
| |
| @node Symbols |
| @chapter Symbols |
| |
| @cindex symbols |
| Symbols are a central concept: the programmer uses symbols to name |
| things, the linker uses symbols to link, and the debugger uses symbols |
| to debug. |
| |
| @quotation |
| @cindex debuggers, and symbol order |
| @emph{Warning:} @command{@value{AS}} does not place symbols in the object file in |
| the same order they were declared. This may break some debuggers. |
| @end quotation |
| |
| @menu |
| * Labels:: Labels |
| * Setting Symbols:: Giving Symbols Other Values |
| * Symbol Names:: Symbol Names |
| * Dot:: The Special Dot Symbol |
| * Symbol Attributes:: Symbol Attributes |
| @end menu |
| |
| @node Labels |
| @section Labels |
| |
| @cindex labels |
| A @dfn{label} is written as a symbol immediately followed by a colon |
| @samp{:}. The symbol then represents the current value of the |
| active location counter, and is, for example, a suitable instruction |
| operand. You are warned if you use the same symbol to represent two |
| different locations: the first definition overrides any other |
| definitions. |
| |
| @ifset HPPA |
| On the HPPA, the usual form for a label need not be immediately followed by a |
| colon, but instead must start in column zero. Only one label may be defined on |
| a single line. To work around this, the HPPA version of @command{@value{AS}} also |
| provides a special directive @code{.label} for defining labels more flexibly. |
| @end ifset |
| |
| @node Setting Symbols |
| @section Giving Symbols Other Values |
| |
| @cindex assigning values to symbols |
| @cindex symbol values, assigning |
| A symbol can be given an arbitrary value by writing a symbol, followed |
| by an equals sign @samp{=}, followed by an expression |
| (@pxref{Expressions}). This is equivalent to using the @code{.set} |
| directive. @xref{Set,,@code{.set}}. In the same way, using a double |
| equals sign @samp{=}@samp{=} here represents an equivalent of the |
| @code{.eqv} directive. @xref{Eqv,,@code{.eqv}}. |
| |
| @ifset Blackfin |
| Blackfin does not support symbol assignment with @samp{=}. |
| @end ifset |
| |
| @node Symbol Names |
| @section Symbol Names |
| |
| @cindex symbol names |
| @cindex names, symbol |
| @ifclear SPECIAL-SYMS |
| Symbol names begin with a letter or with one of @samp{._}. On most |
| machines, you can also use @code{$} in symbol names; exceptions are |
| noted in @ref{Machine Dependencies}. That character may be followed by any |
| string of digits, letters, dollar signs (unless otherwise noted for a |
| particular target machine), and underscores. |
| @end ifclear |
| @ifset SPECIAL-SYMS |
| @ifset H8 |
| Symbol names begin with a letter or with one of @samp{._}. On the |
| Renesas SH you can also use @code{$} in symbol names. That |
| character may be followed by any string of digits, letters, dollar signs (save |
| on the H8/300), and underscores. |
| @end ifset |
| @end ifset |
| |
| Case of letters is significant: @code{foo} is a different symbol name |
| than @code{Foo}. |
| |
| Symbol names do not start with a digit. An exception to this rule is made for |
| Local Labels. See below. |
| |
| Multibyte characters are supported. To generate a symbol name containing |
| multibyte characters enclose it within double quotes and use escape codes. cf |
| @xref{Strings}. Generating a multibyte symbol name from a label is not |
| currently supported. |
| |
| Each symbol has exactly one name. Each name in an assembly language program |
| refers to exactly one symbol. You may use that symbol name any number of times |
| in a program. |
| |
| @subheading Local Symbol Names |
| |
| @cindex local symbol names |
| @cindex symbol names, local |
| A local symbol is any symbol beginning with certain local label prefixes. |
| By default, the local label prefix is @samp{.L} for ELF systems or |
| @samp{L} for traditional a.out systems, but each target may have its own |
| set of local label prefixes. |
| @ifset HPPA |
| On the HPPA local symbols begin with @samp{L$}. |
| @end ifset |
| |
| Local symbols are defined and used within the assembler, but they are |
| normally not saved in object files. Thus, they are not visible when debugging. |
| You may use the @samp{-L} option (@pxref{L, ,Include Local Symbols}) |
| to retain the local symbols in the object files. |
| |
| @subheading Local Labels |
| |
| @cindex local labels |
| @cindex temporary symbol names |
| @cindex symbol names, temporary |
| Local labels are different from local symbols. Local labels help compilers and |
| programmers use names temporarily. They create symbols which are guaranteed to |
| be unique over the entire scope of the input source code and which can be |
| referred to by a simple notation. To define a local label, write a label of |
| the form @samp{@b{N}:} (where @b{N} represents any non-negative integer). |
| To refer to the most recent previous definition of that label write |
| @samp{@b{N}b}, using the same number as when you defined the label. To refer |
| to the next definition of a local label, write @samp{@b{N}f}. The @samp{b} |
| stands for ``backwards'' and the @samp{f} stands for ``forwards''. |
| |
| There is no restriction on how you can use these labels, and you can reuse them |
| too. So that it is possible to repeatedly define the same local label (using |
| the same number @samp{@b{N}}), although you can only refer to the most recently |
| defined local label of that number (for a backwards reference) or the next |
| definition of a specific local label for a forward reference. It is also worth |
| noting that the first 10 local labels (@samp{@b{0:}}@dots{}@samp{@b{9:}}) are |
| implemented in a slightly more efficient manner than the others. |
| |
| Here is an example: |
| |
| @smallexample |
| 1: branch 1f |
| 2: branch 1b |
| 1: branch 2f |
| 2: branch 1b |
| @end smallexample |
| |
| Which is the equivalent of: |
| |
| @smallexample |
| label_1: branch label_3 |
| label_2: branch label_1 |
| label_3: branch label_4 |
| label_4: branch label_3 |
| @end smallexample |
| |
| Local label names are only a notational device. They are immediately |
| transformed into more conventional symbol names before the assembler uses them. |
| The symbol names are stored in the symbol table, appear in error messages, and |
| are optionally emitted to the object file. The names are constructed using |
| these parts: |
| |
| @table @code |
| @item @emph{local label prefix} |
| All local symbols begin with the system-specific local label prefix. |
| Normally both @command{@value{AS}} and @code{@value{LD}} forget symbols |
| that start with the local label prefix. These labels are |
| used for symbols you are never intended to see. If you use the |
| @samp{-L} option then @command{@value{AS}} retains these symbols in the |
| object file. If you also instruct @code{@value{LD}} to retain these symbols, |
| you may use them in debugging. |
| |
| @item @var{number} |
| This is the number that was used in the local label definition. So if the |
| label is written @samp{55:} then the number is @samp{55}. |
| |
| @item @kbd{C-B} |
| This unusual character is included so you do not accidentally invent a symbol |
| of the same name. The character has ASCII value of @samp{\002} (control-B). |
| |
| @item @emph{ordinal number} |
| This is a serial number to keep the labels distinct. The first definition of |
| @samp{0:} gets the number @samp{1}. The 15th definition of @samp{0:} gets the |
| number @samp{15}, and so on. Likewise the first definition of @samp{1:} gets |
| the number @samp{1} and its 15th definition gets @samp{15} as well. |
| @end table |
| |
| So for example, the first @code{1:} may be named @code{.L1@kbd{C-B}1}, and |
| the 44th @code{3:} may be named @code{.L3@kbd{C-B}44}. |
| |
| @subheading Dollar Local Labels |
| @cindex dollar local symbols |
| |
| On some targets @code{@value{AS}} also supports an even more local form of |
| local labels called dollar labels. These labels go out of scope (i.e., they |
| become undefined) as soon as a non-local label is defined. Thus they remain |
| valid for only a small region of the input source code. Normal local labels, |
| by contrast, remain in scope for the entire file, or until they are redefined |
| by another occurrence of the same local label. |
| |
| Dollar labels are defined in exactly the same way as ordinary local labels, |
| except that they have a dollar sign suffix to their numeric value, e.g., |
| @samp{@b{55$:}}. |
| |
| They can also be distinguished from ordinary local labels by their transformed |
| names which use ASCII character @samp{\001} (control-A) as the magic character |
| to distinguish them from ordinary labels. For example, the fifth definition of |
| @samp{6$} may be named @samp{.L6@kbd{C-A}5}. |
| |
| @node Dot |
| @section The Special Dot Symbol |
| |
| @cindex dot (symbol) |
| @cindex @code{.} (symbol) |
| @cindex current address |
| @cindex location counter |
| The special symbol @samp{.} refers to the current address that |
| @command{@value{AS}} is assembling into. Thus, the expression @samp{melvin: |
| .long .} defines @code{melvin} to contain its own address. |
| Assigning a value to @code{.} is treated the same as a @code{.org} |
| directive. |
| @ifclear no-space-dir |
| Thus, the expression @samp{.=.+4} is the same as saying |
| @samp{.space 4}. |
| @end ifclear |
| |
| @node Symbol Attributes |
| @section Symbol Attributes |
| |
| @cindex symbol attributes |
| @cindex attributes, symbol |
| Every symbol has, as well as its name, the attributes ``Value'' and |
| ``Type''. Depending on output format, symbols can also have auxiliary |
| attributes. |
| @ifset INTERNALS |
| The detailed definitions are in @file{a.out.h}. |
| @end ifset |
| |
| If you use a symbol without defining it, @command{@value{AS}} assumes zero for |
| all these attributes, and probably won't warn you. This makes the |
| symbol an externally defined symbol, which is generally what you |
| would want. |
| |
| @menu |
| * Symbol Value:: Value |
| * Symbol Type:: Type |
| @ifset aout |
| * a.out Symbols:: Symbol Attributes: @code{a.out} |
| @end ifset |
| @ifset COFF |
| * COFF Symbols:: Symbol Attributes for COFF |
| @end ifset |
| @ifset SOM |
| * SOM Symbols:: Symbol Attributes for SOM |
| @end ifset |
| @end menu |
| |
| @node Symbol Value |
| @subsection Value |
| |
| @cindex value of a symbol |
| @cindex symbol value |
| The value of a symbol is (usually) 32 bits. For a symbol which labels a |
| location in the text, data, bss or absolute sections the value is the |
| number of addresses from the start of that section to the label. |
| Naturally for text, data and bss sections the value of a symbol changes |
| as @code{@value{LD}} changes section base addresses during linking. Absolute |
| symbols' values do not change during linking: that is why they are |
| called absolute. |
| |
| The value of an undefined symbol is treated in a special way. If it is |
| 0 then the symbol is not defined in this assembler source file, and |
| @code{@value{LD}} tries to determine its value from other files linked into the |
| same program. You make this kind of symbol simply by mentioning a symbol |
| name without defining it. A non-zero value represents a @code{.comm} |
| common declaration. The value is how much common storage to reserve, in |
| bytes (addresses). The symbol refers to the first address of the |
| allocated storage. |
| |
| @node Symbol Type |
| @subsection Type |
| |
| @cindex type of a symbol |
| @cindex symbol type |
| The type attribute of a symbol contains relocation (section) |
| information, any flag settings indicating that a symbol is external, and |
| (optionally), other information for linkers and debuggers. The exact |
| format depends on the object-code output format in use. |
| |
| @ifset aout |
| @node a.out Symbols |
| @subsection Symbol Attributes: @code{a.out} |
| |
| @cindex @code{a.out} symbol attributes |
| @cindex symbol attributes, @code{a.out} |
| |
| @menu |
| * Symbol Desc:: Descriptor |
| * Symbol Other:: Other |
| @end menu |
| |
| @node Symbol Desc |
| @subsubsection Descriptor |
| |
| @cindex descriptor, of @code{a.out} symbol |
| This is an arbitrary 16-bit value. You may establish a symbol's |
| descriptor value by using a @code{.desc} statement |
| (@pxref{Desc,,@code{.desc}}). A descriptor value means nothing to |
| @command{@value{AS}}. |
| |
| @node Symbol Other |
| @subsubsection Other |
| |
| @cindex other attribute, of @code{a.out} symbol |
| This is an arbitrary 8-bit value. It means nothing to @command{@value{AS}}. |
| @end ifset |
| |
| @ifset COFF |
| @node COFF Symbols |
| @subsection Symbol Attributes for COFF |
| |
| @cindex COFF symbol attributes |
| @cindex symbol attributes, COFF |
| |
| The COFF format supports a multitude of auxiliary symbol attributes; |
| like the primary symbol attributes, they are set between @code{.def} and |
| @code{.endef} directives. |
| |
| @subsubsection Primary Attributes |
| |
| @cindex primary attributes, COFF symbols |
| The symbol name is set with @code{.def}; the value and type, |
| respectively, with @code{.val} and @code{.type}. |
| |
| @subsubsection Auxiliary Attributes |
| |
| @cindex auxiliary attributes, COFF symbols |
| The @command{@value{AS}} directives @code{.dim}, @code{.line}, @code{.scl}, |
| @code{.size}, @code{.tag}, and @code{.weak} can generate auxiliary symbol |
| table information for COFF. |
| @end ifset |
| |
| @ifset SOM |
| @node SOM Symbols |
| @subsection Symbol Attributes for SOM |
| |
| @cindex SOM symbol attributes |
| @cindex symbol attributes, SOM |
| |
| The SOM format for the HPPA supports a multitude of symbol attributes set with |
| the @code{.EXPORT} and @code{.IMPORT} directives. |
| |
| The attributes are described in @cite{HP9000 Series 800 Assembly |
| Language Reference Manual} (HP 92432-90001) under the @code{IMPORT} and |
| @code{EXPORT} assembler directive documentation. |
| @end ifset |
| |
| @node Expressions |
| @chapter Expressions |
| |
| @cindex expressions |
| @cindex addresses |
| @cindex numeric values |
| An @dfn{expression} specifies an address or numeric value. |
| Whitespace may precede and/or follow an expression. |
| |
| The result of an expression must be an absolute number, or else an offset into |
| a particular section. If an expression is not absolute, and there is not |
| enough information when @command{@value{AS}} sees the expression to know its |
| section, a second pass over the source program might be necessary to interpret |
| the expression---but the second pass is currently not implemented. |
| @command{@value{AS}} aborts with an error message in this situation. |
| |
| @menu |
| * Empty Exprs:: Empty Expressions |
| * Integer Exprs:: Integer Expressions |
| @end menu |
| |
| @node Empty Exprs |
| @section Empty Expressions |
| |
| @cindex empty expressions |
| @cindex expressions, empty |
| An empty expression has no value: it is just whitespace or null. |
| Wherever an absolute expression is required, you may omit the |
| expression, and @command{@value{AS}} assumes a value of (absolute) 0. This |
| is compatible with other assemblers. |
| |
| @node Integer Exprs |
| @section Integer Expressions |
| |
| @cindex integer expressions |
| @cindex expressions, integer |
| An @dfn{integer expression} is one or more @emph{arguments} delimited |
| by @emph{operators}. |
| |
| @menu |
| * Arguments:: Arguments |
| * Operators:: Operators |
| * Prefix Ops:: Prefix Operators |
| * Infix Ops:: Infix Operators |
| @end menu |
| |
| @node Arguments |
| @subsection Arguments |
| |
| @cindex expression arguments |
| @cindex arguments in expressions |
| @cindex operands in expressions |
| @cindex arithmetic operands |
| @dfn{Arguments} are symbols, numbers or subexpressions. In other |
| contexts arguments are sometimes called ``arithmetic operands''. In |
| this manual, to avoid confusing them with the ``instruction operands'' of |
| the machine language, we use the term ``argument'' to refer to parts of |
| expressions only, reserving the word ``operand'' to refer only to machine |
| instruction operands. |
| |
| Symbols are evaluated to yield @{@var{section} @var{NNN}@} where |
| @var{section} is one of text, data, bss, absolute, |
| or undefined. @var{NNN} is a signed, 2's complement 32 bit |
| integer. |
| |
| Numbers are usually integers. |
| |
| A number can be a flonum or bignum. In this case, you are warned |
| that only the low order 32 bits are used, and @command{@value{AS}} pretends |
| these 32 bits are an integer. You may write integer-manipulating |
| instructions that act on exotic constants, compatible with other |
| assemblers. |
| |
| @cindex subexpressions |
| Subexpressions are a left parenthesis @samp{(} followed by an integer |
| expression, followed by a right parenthesis @samp{)}; or a prefix |
| operator followed by an argument. |
| |
| @node Operators |
| @subsection Operators |
| |
| @cindex operators, in expressions |
| @cindex arithmetic functions |
| @cindex functions, in expressions |
| @dfn{Operators} are arithmetic functions, like @code{+} or @code{%}. Prefix |
| operators are followed by an argument. Infix operators appear |
| between their arguments. Operators may be preceded and/or followed by |
| whitespace. |
| |
| @node Prefix Ops |
| @subsection Prefix Operator |
| |
| @cindex prefix operators |
| @command{@value{AS}} has the following @dfn{prefix operators}. They each take |
| one argument, which must be absolute. |
| |
| @c the tex/end tex stuff surrounding this small table is meant to make |
| @c it align, on the printed page, with the similar table in the next |
| @c section (which is inside an enumerate). |
| @tex |
| \global\advance\leftskip by \itemindent |
| @end tex |
| |
| @table @code |
| @item - |
| @dfn{Negation}. Two's complement negation. |
| @item ~ |
| @dfn{Complementation}. Bitwise not. |
| @end table |
| |
| @tex |
| \global\advance\leftskip by -\itemindent |
| @end tex |
| |
| @node Infix Ops |
| @subsection Infix Operators |
| |
| @cindex infix operators |
| @cindex operators, permitted arguments |
| @dfn{Infix operators} take two arguments, one on either side. Operators |
| have precedence, but operations with equal precedence are performed left |
| to right. Apart from @code{+} or @option{-}, both arguments must be |
| absolute, and the result is absolute. |
| |
| @enumerate |
| @cindex operator precedence |
| @cindex precedence of operators |
| |
| @item |
| Highest Precedence |
| |
| @table @code |
| @item * |
| @dfn{Multiplication}. |
| |
| @item / |
| @dfn{Division}. Truncation is the same as the C operator @samp{/} |
| |
| @item % |
| @dfn{Remainder}. |
| |
| @item << |
| @dfn{Shift Left}. Same as the C operator @samp{<<}. |
| |
| @item >> |
| @dfn{Shift Right}. Same as the C operator @samp{>>}. |
| @end table |
| |
| @item |
| Intermediate precedence |
| |
| @table @code |
| @item | |
| |
| @dfn{Bitwise Inclusive Or}. |
| |
| @item & |
| @dfn{Bitwise And}. |
| |
| @item ^ |
| @dfn{Bitwise Exclusive Or}. |
| |
| @item ! |
| @dfn{Bitwise Or Not}. |
| @end table |
| |
| @item |
| Low Precedence |
| |
| @table @code |
| @cindex addition, permitted arguments |
| @cindex plus, permitted arguments |
| @cindex arguments for addition |
| @item + |
| @dfn{Addition}. If either argument is absolute, the result has the section of |
| the other argument. You may not add together arguments from different |
| sections. |
| |
| @cindex subtraction, permitted arguments |
| @cindex minus, permitted arguments |
| @cindex arguments for subtraction |
| @item - |
| @dfn{Subtraction}. If the right argument is absolute, the |
| result has the section of the left argument. |
| If both arguments are in the same section, the result is absolute. |
| You may not subtract arguments from different sections. |
| @c FIXME is there still something useful to say about undefined - undefined ? |
| |
| @cindex comparison expressions |
| @cindex expressions, comparison |
| @item == |
| @dfn{Is Equal To} |
| @item <> |
| @itemx != |
| @dfn{Is Not Equal To} |
| @item < |
| @dfn{Is Less Than} |
| @item > |
| @dfn{Is Greater Than} |
| @item >= |
| @dfn{Is Greater Than Or Equal To} |
| @item <= |
| @dfn{Is Less Than Or Equal To} |
| |
| The comparison operators can be used as infix operators. A true results has a |
| value of -1 whereas a false result has a value of 0. Note, these operators |
| perform signed comparisons. |
| @end table |
| |
| @item Lowest Precedence |
| |
| @table @code |
| @item && |
| @dfn{Logical And}. |
| |
| @item || |
| @dfn{Logical Or}. |
| |
| These two logical operations can be used to combine the results of sub |
| expressions. Note, unlike the comparison operators a true result returns a |
| value of 1 but a false results does still return 0. Also note that the logical |
| or operator has a slightly lower precedence than logical and. |
| |
| @end table |
| @end enumerate |
| |
| In short, it's only meaningful to add or subtract the @emph{offsets} in an |
| address; you can only have a defined section in one of the two arguments. |
| |
| @node Pseudo Ops |
| @chapter Assembler Directives |
| |
| @cindex directives, machine independent |
| @cindex pseudo-ops, machine independent |
| @cindex machine independent directives |
| All assembler directives have names that begin with a period (@samp{.}). |
| The names are case insensitive for most targets, and usually written |
| in lower case. |
| |
| This chapter discusses directives that are available regardless of the |
| target machine configuration for the @sc{gnu} assembler. |
| @ifset GENERIC |
| Some machine configurations provide additional directives. |
| @xref{Machine Dependencies}. |
| @end ifset |
| @ifclear GENERIC |
| @ifset machine-directives |
| @xref{Machine Dependencies}, for additional directives. |
| @end ifset |
| @end ifclear |
| |
| @menu |
| * Abort:: @code{.abort} |
| @ifset COFF |
| * ABORT (COFF):: @code{.ABORT} |
| @end ifset |
| |
| * Align:: @code{.align [@var{abs-expr}[, @var{abs-expr}[, @var{abs-expr}]]]} |
| * Altmacro:: @code{.altmacro} |
| * Ascii:: @code{.ascii "@var{string}"}@dots{} |
| * Asciz:: @code{.asciz "@var{string}"}@dots{} |
| * Attach_to_group:: @code{.attach_to_group @var{name}} |
| * Balign:: @code{.balign [@var{abs-expr}[, @var{abs-expr}]]} |
| * Bss:: @code{.bss @var{subsection}} |
| * Bundle directives:: @code{.bundle_align_mode @var{abs-expr}}, etc |
| * Byte:: @code{.byte @var{expressions}} |
| * CFI directives:: @code{.cfi_startproc [simple]}, @code{.cfi_endproc}, etc. |
| * Comm:: @code{.comm @var{symbol} , @var{length} } |
| * Data:: @code{.data @var{subsection}} |
| * Dc:: @code{.dc[@var{size}] @var{expressions}} |
| * Dcb:: @code{.dcb[@var{size}] @var{number} [,@var{fill}]} |
| * Ds:: @code{.ds[@var{size}] @var{number} [,@var{fill}]} |
| @ifset COFF |
| * Def:: @code{.def @var{name}} |
| @end ifset |
| @ifset aout |
| * Desc:: @code{.desc @var{symbol}, @var{abs-expression}} |
| @end ifset |
| @ifset COFF |
| * Dim:: @code{.dim} |
| @end ifset |
| |
| * Double:: @code{.double @var{flonums}} |
| * Eject:: @code{.eject} |
| * Else:: @code{.else} |
| * Elseif:: @code{.elseif} |
| * End:: @code{.end} |
| @ifset COFF |
| * Endef:: @code{.endef} |
| @end ifset |
| |
| * Endfunc:: @code{.endfunc} |
| * Endif:: @code{.endif} |
| * Equ:: @code{.equ @var{symbol}, @var{expression}} |
| * Equiv:: @code{.equiv @var{symbol}, @var{expression}} |
| * Eqv:: @code{.eqv @var{symbol}, @var{expression}} |
| * Err:: @code{.err} |
| * Error:: @code{.error @var{string}} |
| * Exitm:: @code{.exitm} |
| * Extern:: @code{.extern} |
| * Fail:: @code{.fail} |
| * File:: @code{.file} |
| * Fill:: @code{.fill @var{repeat} , @var{size} , @var{value}} |
| * Float:: @code{.float @var{flonums}} |
| * Func:: @code{.func} |
| * Global:: @code{.global @var{symbol}}, @code{.globl @var{symbol}} |
| @ifset ELF |
| * Gnu_attribute:: @code{.gnu_attribute @var{tag},@var{value}} |
| * Hidden:: @code{.hidden @var{names}} |
| @end ifset |
| |
| * hword:: @code{.hword @var{expressions}} |
| * Ident:: @code{.ident} |
| * If:: @code{.if @var{absolute expression}} |
| * Incbin:: @code{.incbin "@var{file}"[,@var{skip}[,@var{count}]]} |
| * Include:: @code{.include "@var{file}"} |
| * Int:: @code{.int @var{expressions}} |
| @ifset ELF |
| * Internal:: @code{.internal @var{names}} |
| @end ifset |
| |
| * Irp:: @code{.irp @var{symbol},@var{values}}@dots{} |
| * Irpc:: @code{.irpc @var{symbol},@var{values}}@dots{} |
| * Lcomm:: @code{.lcomm @var{symbol} , @var{length}} |
| * Lflags:: @code{.lflags} |
| @ifclear no-line-dir |
| * Line:: @code{.line @var{line-number}} |
| @end ifclear |
| |
| * Linkonce:: @code{.linkonce [@var{type}]} |
| * List:: @code{.list} |
| * Ln:: @code{.ln @var{line-number}} |
| * Loc:: @code{.loc @var{fileno} @var{lineno}} |
| * Loc_mark_labels:: @code{.loc_mark_labels @var{enable}} |
| @ifset ELF |
| * Local:: @code{.local @var{names}} |
| @end ifset |
| |
| * Long:: @code{.long @var{expressions}} |
| @ignore |
| * Lsym:: @code{.lsym @var{symbol}, @var{expression}} |
| @end ignore |
| |
| * Macro:: @code{.macro @var{name} @var{args}}@dots{} |
| * MRI:: @code{.mri @var{val}} |
| * Noaltmacro:: @code{.noaltmacro} |
| * Nolist:: @code{.nolist} |
| * Nop:: @code{.nop} |
| * Nops:: @code{.nops @var{size}[, @var{control}]} |
| * Octa:: @code{.octa @var{bignums}} |
| * Offset:: @code{.offset @var{loc}} |
| * Org:: @code{.org @var{new-lc}, @var{fill}} |
| * P2align:: @code{.p2align [@var{abs-expr}[, @var{abs-expr}[, @var{abs-expr}]]]} |
| @ifset ELF |
| * PopSection:: @code{.popsection} |
| * Previous:: @code{.previous} |
| @end ifset |
| |
| * Print:: @code{.print @var{string}} |
| @ifset ELF |
| * Protected:: @code{.protected @var{names}} |
| @end ifset |
| |
| * Psize:: @code{.psize @var{lines}, @var{columns}} |
| * Purgem:: @code{.purgem @var{name}} |
| @ifset ELF |
| * PushSection:: @code{.pushsection @var{name}} |
| @end ifset |
| |
| * Quad:: @code{.quad @var{bignums}} |
| * Reloc:: @code{.reloc @var{offset}, @var{reloc_name}[, @var{expression}]} |
| * Rept:: @code{.rept @var{count}} |
| * Sbttl:: @code{.sbttl "@var{subheading}"} |
| @ifset COFF |
| * Scl:: @code{.scl @var{class}} |
| @end ifset |
| @ifset COFF-ELF |
| * Section:: @code{.section @var{name}[, @var{flags}]} |
| @end ifset |
| |
| * Set:: @code{.set @var{symbol}, @var{expression}} |
| * Short:: @code{.short @var{expressions}} |
| * Single:: @code{.single @var{flonums}} |
| @ifset COFF-ELF |
| * Size:: @code{.size [@var{name} , @var{expression}]} |
| @end ifset |
| @ifclear no-space-dir |
| * Skip:: @code{.skip @var{size} [,@var{fill}]} |
| @end ifclear |
| |
| * Sleb128:: @code{.sleb128 @var{expressions}} |
| @ifclear no-space-dir |
| * Space:: @code{.space @var{size} [,@var{fill}]} |
| @end ifclear |
| @ifset have-stabs |
| * Stab:: @code{.stabd, .stabn, .stabs} |
| @end ifset |
| |
| * String:: @code{.string "@var{str}"}, @code{.string8 "@var{str}"}, @code{.string16 "@var{str}"}, @code{.string32 "@var{str}"}, @code{.string64 "@var{str}"} |
| * Struct:: @code{.struct @var{expression}} |
| @ifset ELF |
| * SubSection:: @code{.subsection} |
| * Symver:: @code{.symver @var{name},@var{name2@@nodename}[,@var{visibility}]} |
| @end ifset |
| |
| @ifset COFF |
| * Tag:: @code{.tag @var{structname}} |
| @end ifset |
| |
| * Text:: @code{.text @var{subsection}} |
| * Title:: @code{.title "@var{heading}"} |
| @ifset ELF |
| * Tls_common:: @code{.tls_common @var{symbol}, @var{length}[, @var{alignment}]} |
| @end ifset |
| @ifset COFF-ELF |
| * Type:: @code{.type <@var{int} | @var{name} , @var{type description}>} |
| @end ifset |
| |
| * Uleb128:: @code{.uleb128 @var{expressions}} |
| @ifset COFF |
| * Val:: @code{.val @var{addr}} |
| @end ifset |
| |
| @ifset ELF |
| * Version:: @code{.version "@var{string}"} |
| * VTableEntry:: @code{.vtable_entry @var{table}, @var{offset}} |
| * VTableInherit:: @code{.vtable_inherit @var{child}, @var{parent}} |
| @end ifset |
| |
| * Warning:: @code{.warning @var{string}} |
| * Weak:: @code{.weak @var{names}} |
| * Weakref:: @code{.weakref @var{alias}, @var{symbol}} |
| * Word:: @code{.word @var{expressions}} |
| @ifclear no-space-dir |
| * Zero:: @code{.zero @var{size}} |
| @end ifclear |
| * 2byte:: @code{.2byte @var{expressions}} |
| * 4byte:: @code{.4byte @var{expressions}} |
| * 8byte:: @code{.8byte @var{bignums}} |
| * Deprecated:: Deprecated Directives |
| @end menu |
| |
| @node Abort |
| @section @code{.abort} |
| |
| @cindex @code{abort} directive |
| @cindex stopping the assembly |
| This directive stops the assembly immediately. It is for |
| compatibility with other assemblers. The original idea was that the |
| assembly language source would be piped into the assembler. If the sender |
| of the source quit, it could use this directive tells @command{@value{AS}} to |
| quit also. One day @code{.abort} will not be supported. |
| |
| @ifset COFF |
| @node ABORT (COFF) |
| @section @code{.ABORT} (COFF) |
| |
| @cindex @code{ABORT} directive |
| When producing COFF output, @command{@value{AS}} accepts this directive as a |
| synonym for @samp{.abort}. |
| |
| @end ifset |
| |
| @node Align |
| @section @code{.align [@var{abs-expr}[, @var{abs-expr}[, @var{abs-expr}]]]} |
| |
| @cindex padding the location counter |
| @cindex @code{align} directive |
| Pad the location counter (in the current subsection) to a particular storage |
| boundary. The first expression (which must be absolute) is the alignment |
| required, as described below. If this expression is omitted then a default |
| value of 0 is used, effectively disabling alignment requirements. |
| |
| The second expression (also absolute) gives the fill value to be stored in the |
| padding bytes. It (and the comma) may be omitted. If it is omitted, the |
| padding bytes are normally zero. However, on most systems, if the section is |
| marked as containing code and the fill value is omitted, the space is filled |
| with no-op instructions. |
| |
| The third expression is also absolute, and is also optional. If it is present, |
| it is the maximum number of bytes that should be skipped by this alignment |
| directive. If doing the alignment would require skipping more bytes than the |
| specified maximum, then the alignment is not done at all. You can omit the |
| fill value (the second argument) entirely by simply using two commas after the |
| required alignment; this can be useful if you want the alignment to be filled |
| with no-op instructions when appropriate. |
| |
| The way the required alignment is specified varies from system to system. |
| For the arc, hppa, i386 using ELF, iq2000, m68k, or1k, |
| s390, sparc, tic4x and xtensa, the first expression is the |
| alignment request in bytes. For example @samp{.align 8} advances |
| the location counter until it is a multiple of 8. If the location counter |
| is already a multiple of 8, no change is needed. For the tic54x, the |
| first expression is the alignment request in words. |
| |
| For other systems, including ppc, i386 using a.out format, arm and |
| strongarm, it is the |
| number of low-order zero bits the location counter must have after |
| advancement. For example @samp{.align 3} advances the location |
| counter until it is a multiple of 8. If the location counter is already a |
| multiple of 8, no change is needed. |
| |
| This inconsistency is due to the different behaviors of the various |
| native assemblers for these systems which GAS must emulate. |
| GAS also provides @code{.balign} and @code{.p2align} directives, |
| described later, which have a consistent behavior across all |
| architectures (but are specific to GAS). |
| |
| @node Altmacro |
| @section @code{.altmacro} |
| Enable alternate macro mode, enabling: |
| |
| @ftable @code |
| @item LOCAL @var{name} [ , @dots{} ] |
| One additional directive, @code{LOCAL}, is available. It is used to |
| generate a string replacement for each of the @var{name} arguments, and |
| replace any instances of @var{name} in each macro expansion. The |
| replacement string is unique in the assembly, and different for each |
| separate macro expansion. @code{LOCAL} allows you to write macros that |
| define symbols, without fear of conflict between separate macro expansions. |
| |
| @item String delimiters |
| You can write strings delimited in these other ways besides |
| @code{"@var{string}"}: |
| |
| @table @code |
| @item '@var{string}' |
| You can delimit strings with single-quote characters. |
| |
| @item <@var{string}> |
| You can delimit strings with matching angle brackets. |
| @end table |
| |
| @item single-character string escape |
| To include any single character literally in a string (even if the |
| character would otherwise have some special meaning), you can prefix the |
| character with @samp{!} (an exclamation mark). For example, you can |
| write @samp{<4.3 !> 5.4!!>} to get the literal text @samp{4.3 > 5.4!}. |
| |
| @item Expression results as strings |
| You can write @samp{%@var{expr}} to evaluate the expression @var{expr} |
| and use the result as a string. |
| @end ftable |
| |
| @node Ascii |
| @section @code{.ascii "@var{string}"}@dots{} |
| |
| @cindex @code{ascii} directive |
| @cindex string literals |
| @code{.ascii} expects zero or more string literals (@pxref{Strings}) |
| separated by commas. It assembles each string (with no automatic |
| trailing zero byte) into consecutive addresses. |
| |
| @node Asciz |
| @section @code{.asciz "@var{string}"}@dots{} |
| |
| @cindex @code{asciz} directive |
| @cindex zero-terminated strings |
| @cindex null-terminated strings |
| @code{.asciz} is just like @code{.ascii}, but each string is followed by |
| a zero byte. The ``z'' in @samp{.asciz} stands for ``zero''. Note that |
| multiple string arguments not separated by commas will be concatenated |
| together and only one final zero byte will be stored. |
| |
| @node Attach_to_group |
| @section @code{.attach_to_group @var{name}} |
| Attaches the current section to the named group. This is like declaring |
| the section with the @code{G} attribute, but can be done after the section |
| has been created. Note if the group section does not exist at the point that |
| this directive is used then it will be created. |
| |
| @node Balign |
| @section @code{.balign[wl] [@var{abs-expr}[, @var{abs-expr}[, @var{abs-expr}]]]} |
| |
| @cindex padding the location counter given number of bytes |
| @cindex @code{balign} directive |
| Pad the location counter (in the current subsection) to a particular |
| storage boundary. The first expression (which must be absolute) is the |
| alignment request in bytes. For example @samp{.balign 8} advances |
| the location counter until it is a multiple of 8. If the location counter |
| is already a multiple of 8, no change is needed. If the expression is omitted |
| then a default value of 0 is used, effectively disabling alignment requirements. |
| |
| The second expression (also absolute) gives the fill value to be stored in the |
| padding bytes. It (and the comma) may be omitted. If it is omitted, the |
| padding bytes are normally zero. However, on most systems, if the section is |
| marked as containing code and the fill value is omitted, the space is filled |
| with no-op instructions. |
| |
| The third expression is also absolute, and is also optional. If it is present, |
| it is the maximum number of bytes that should be skipped by this alignment |
| directive. If doing the alignment would require skipping more bytes than the |
| specified maximum, then the alignment is not done at all. You can omit the |
| fill value (the second argument) entirely by simply using two commas after the |
| required alignment; this can be useful if you want the alignment to be filled |
| with no-op instructions when appropriate. |
| |
| @cindex @code{balignw} directive |
| @cindex @code{balignl} directive |
| The @code{.balignw} and @code{.balignl} directives are variants of the |
| @code{.balign} directive. The @code{.balignw} directive treats the fill |
| pattern as a two byte word value. The @code{.balignl} directives treats the |
| fill pattern as a four byte longword value. For example, @code{.balignw |
| 4,0x368d} will align to a multiple of 4. If it skips two bytes, they will be |
| filled in with the value 0x368d (the exact placement of the bytes depends upon |
| the endianness of the processor). If it skips 1 or 3 bytes, the fill value is |
| undefined. |
| |
| @node Bss |
| @section @code{.bss @var{subsection}} |
| @cindex @code{bss} directive |
| |
| @code{.bss} tells @command{@value{AS}} to assemble the following statements |
| onto the end of the bss section. |
| @ifset ELF |
| For ELF based targets an optional @var{subsection} expression (which must |
| evaluate to a positive integer) can be provided. In this case the statements |
| are appended to the end of the indicated bss subsection. |
| @end ifset |
| |
| @node Bundle directives |
| @section Bundle directives |
| @subsection @code{.bundle_align_mode @var{abs-expr}} |
| @cindex @code{bundle_align_mode} directive |
| @cindex bundle |
| @cindex instruction bundle |
| @cindex aligned instruction bundle |
| @code{.bundle_align_mode} enables or disables @dfn{aligned instruction |
| bundle} mode. In this mode, sequences of adjacent instructions are grouped |
| into fixed-sized @dfn{bundles}. If the argument is zero, this mode is |
| disabled (which is the default state). If the argument it not zero, it |
| gives the size of an instruction bundle as a power of two (as for the |
| @code{.p2align} directive, @pxref{P2align}). |
| |
| For some targets, it's an ABI requirement that no instruction may span a |
| certain aligned boundary. A @dfn{bundle} is simply a sequence of |
| instructions that starts on an aligned boundary. For example, if |
| @var{abs-expr} is @code{5} then the bundle size is 32, so each aligned |
| chunk of 32 bytes is a bundle. When aligned instruction bundle mode is in |
| effect, no single instruction may span a boundary between bundles. If an |
| instruction would start too close to the end of a bundle for the length of |
| that particular instruction to fit within the bundle, then the space at the |
| end of that bundle is filled with no-op instructions so the instruction |
| starts in the next bundle. As a corollary, it's an error if any single |
| instruction's encoding is longer than the bundle size. |
| |
| @subsection @code{.bundle_lock} and @code{.bundle_unlock} |
| @cindex @code{bundle_lock} directive |
| @cindex @code{bundle_unlock} directive |
| The @code{.bundle_lock} and directive @code{.bundle_unlock} directives |
| allow explicit control over instruction bundle padding. These directives |
| are only valid when @code{.bundle_align_mode} has been used to enable |
| aligned instruction bundle mode. It's an error if they appear when |
| @code{.bundle_align_mode} has not been used at all, or when the last |
| directive was @w{@code{.bundle_align_mode 0}}. |
| |
| @cindex bundle-locked |
| For some targets, it's an ABI requirement that certain instructions may |
| appear only as part of specified permissible sequences of multiple |
| instructions, all within the same bundle. A pair of @code{.bundle_lock} |
| and @code{.bundle_unlock} directives define a @dfn{bundle-locked} |
| instruction sequence. For purposes of aligned instruction bundle mode, a |
| sequence starting with @code{.bundle_lock} and ending with |
| @code{.bundle_unlock} is treated as a single instruction. That is, the |
| entire sequence must fit into a single bundle and may not span a bundle |
| boundary. If necessary, no-op instructions will be inserted before the |
| first instruction of the sequence so that the whole sequence starts on an |
| aligned bundle boundary. It's an error if the sequence is longer than the |
| bundle size. |
| |
| For convenience when using @code{.bundle_lock} and @code{.bundle_unlock} |
| inside assembler macros (@pxref{Macro}), bundle-locked sequences may be |
| nested. That is, a second @code{.bundle_lock} directive before the next |
| @code{.bundle_unlock} directive has no effect except that it must be |
| matched by another closing @code{.bundle_unlock} so that there is the |
| same number of @code{.bundle_lock} and @code{.bundle_unlock} directives. |
| |
| @node Byte |
| @section @code{.byte @var{expressions}} |
| |
| @cindex @code{byte} directive |
| @cindex integers, one byte |
| @code{.byte} expects zero or more expressions, separated by commas. |
| Each expression is assembled into the next byte. |
| |
| @node CFI directives |
| @section CFI directives |
| @subsection @code{.cfi_sections @var{section_list}} |
| @cindex @code{cfi_sections} directive |
| @code{.cfi_sections} may be used to specify whether CFI directives |
| should emit @code{.eh_frame} section and/or @code{.debug_frame} section. |
| If @var{section_list} is @code{.eh_frame}, @code{.eh_frame} is emitted, |
| if @var{section_list} is @code{.debug_frame}, @code{.debug_frame} is emitted. |
| To emit both use @code{.eh_frame, .debug_frame}. The default if this |
| directive is not used is @code{.cfi_sections .eh_frame}. |
| |
| On targets that support compact unwinding tables these can be generated |
| by specifying @code{.eh_frame_entry} instead of @code{.eh_frame}. |
| |
| Some targets may support an additional name, such as @code{.c6xabi.exidx} |
| which is used by the @value{TIC6X} target. |
| |
| The @code{.cfi_sections} directive can be repeated, with the same or different |
| arguments, provided that CFI generation has not yet started. Once CFI |
| generation has started however the section list is fixed and any attempts to |
| redefine it will result in an error. |
| |
| @subsection @code{.cfi_startproc [simple]} |
| @cindex @code{cfi_startproc} directive |
| @code{.cfi_startproc} is used at the beginning of each function that |
| should have an entry in @code{.eh_frame}. It initializes some internal |
| data structures. Don't forget to close the function by |
| @code{.cfi_endproc}. |
| |
| Unless @code{.cfi_startproc} is used along with parameter @code{simple} |
| it also emits some architecture dependent initial CFI instructions. |
| |
| @subsection @code{.cfi_endproc} |
| @cindex @code{cfi_endproc} directive |
| @code{.cfi_endproc} is used at the end of a function where it closes its |
| unwind entry previously opened by |
| @code{.cfi_startproc}, and emits it to @code{.eh_frame}. |
| |
| @subsection @code{.cfi_personality @var{encoding} [, @var{exp}]} |
| @cindex @code{cfi_personality} directive |
| @code{.cfi_personality} defines personality routine and its encoding. |
| @var{encoding} must be a constant determining how the personality |
| should be encoded. If it is 255 (@code{DW_EH_PE_omit}), second |
| argument is not present, otherwise second argument should be |
| a constant or a symbol name. When using indirect encodings, |
| the symbol provided should be the location where personality |
| can be loaded from, not the personality routine itself. |
| The default after @code{.cfi_startproc} is @code{.cfi_personality 0xff}, |
| no personality routine. |
| |
| @subsection @code{.cfi_personality_id @var{id}} |
| @cindex @code{cfi_personality_id} directive |
| @code{cfi_personality_id} defines a personality routine by its index as |
| defined in a compact unwinding format. |
| Only valid when generating compact EH frames (i.e. |
| with @code{.cfi_sections eh_frame_entry}. |
| |
| @subsection @code{.cfi_fde_data [@var{opcode1} [, @dots{}]]} |
| @cindex @code{cfi_fde_data} directive |
| @code{cfi_fde_data} is used to describe the compact unwind opcodes to be |
| used for the current function. These are emitted inline in the |
| @code{.eh_frame_entry} section if small enough and there is no LSDA, or |
| in the @code{.gnu.extab} section otherwise. |
| Only valid when generating compact EH frames (i.e. |
| with @code{.cfi_sections eh_frame_entry}. |
| |
| @subsection @code{.cfi_lsda @var{encoding} [, @var{exp}]} |
| @code{.cfi_lsda} defines LSDA and its encoding. |
| @var{encoding} must be a constant determining how the LSDA |
| should be encoded. If it is 255 (@code{DW_EH_PE_omit}), the second |
| argument is not present, otherwise the second argument should be a constant |
| or a symbol name. The default after @code{.cfi_startproc} is @code{.cfi_lsda 0xff}, |
| meaning that no LSDA is present. |
| |
| @subsection @code{.cfi_inline_lsda} [@var{align}] |
| @code{.cfi_inline_lsda} marks the start of a LSDA data section and |
| switches to the corresponding @code{.gnu.extab} section. |
| Must be preceded by a CFI block containing a @code{.cfi_lsda} directive. |
| Only valid when generating compact EH frames (i.e. |
| with @code{.cfi_sections eh_frame_entry}. |
| |
| The table header and unwinding opcodes will be generated at this point, |
| so that they are immediately followed by the LSDA data. The symbol |
| referenced by the @code{.cfi_lsda} directive should still be defined |
| in case a fallback FDE based encoding is used. The LSDA data is terminated |
| by a section directive. |
| |
| The optional @var{align} argument specifies the alignment required. |
| The alignment is specified as a power of two, as with the |
| @code{.p2align} directive. |
| |
| @subsection @code{.cfi_def_cfa @var{register}, @var{offset}} |
| @code{.cfi_def_cfa} defines a rule for computing CFA as: @i{take |
| address from @var{register} and add @var{offset} to it}. |
| |
| @subsection @code{.cfi_def_cfa_register @var{register}} |
| @code{.cfi_def_cfa_register} modifies a rule for computing CFA. From |
| now on @var{register} will be used instead of the old one. Offset |
| remains the same. |
| |
| @subsection @code{.cfi_def_cfa_offset @var{offset}} |
| @code{.cfi_def_cfa_offset} modifies a rule for computing CFA. Register |
| remains the same, but @var{offset} is new. Note that it is the |
| absolute offset that will be added to a defined register to compute |
| CFA address. |
| |
| @subsection @code{.cfi_adjust_cfa_offset @var{offset}} |
| Same as @code{.cfi_def_cfa_offset} but @var{offset} is a relative |
| value that is added/subtracted from the previous offset. |
| |
| @subsection @code{.cfi_offset @var{register}, @var{offset}} |
| Previous value of @var{register} is saved at offset @var{offset} from |
| CFA. |
| |
| @subsection @code{.cfi_val_offset @var{register}, @var{offset}} |
| Previous value of @var{register} is CFA + @var{offset}. |
| |
| @subsection @code{.cfi_rel_offset @var{register}, @var{offset}} |
| Previous value of @var{register} is saved at offset @var{offset} from |
| the current CFA register. This is transformed to @code{.cfi_offset} |
| using the known displacement of the CFA register from the CFA. |
| This is often easier to use, because the number will match the |
| code it's annotating. |
| |
| @subsection @code{.cfi_register @var{register1}, @var{register2}} |
| Previous value of @var{register1} is saved in register @var{register2}. |
| |
| @subsection @code{.cfi_restore @var{register}} |
| @code{.cfi_restore} says that the rule for @var{register} is now the |
| same as it was at the beginning of the function, after all initial |
| instruction added by @code{.cfi_startproc} were executed. |
| |
| @subsection @code{.cfi_undefined @var{register}} |
| From now on the previous value of @var{register} can't be restored anymore. |
| |
| @subsection @code{.cfi_same_value @var{register}} |
| Current value of @var{register} is the same like in the previous frame, |
| i.e. no restoration needed. |
| |
| @subsection @code{.cfi_remember_state} and @code{.cfi_restore_state} |
| @code{.cfi_remember_state} pushes the set of rules for every register onto an |
| implicit stack, while @code{.cfi_restore_state} pops them off the stack and |
| places them in the current row. This is useful for situations where you have |
| multiple @code{.cfi_*} directives that need to be undone due to the control |
| flow of the program. For example, we could have something like this (assuming |
| the CFA is the value of @code{rbp}): |
| |
| @smallexample |
| je label |
| popq %rbx |
| .cfi_restore %rbx |
| popq %r12 |
| .cfi_restore %r12 |
| popq %rbp |
| .cfi_restore %rbp |
| .cfi_def_cfa %rsp, 8 |
| ret |
| label: |
| /* Do something else */ |
| @end smallexample |
| |
| Here, we want the @code{.cfi} directives to affect only the rows corresponding |
| to the instructions before @code{label}. This means we'd have to add multiple |
| @code{.cfi} directives after @code{label} to recreate the original save |
| locations of the registers, as well as setting the CFA back to the value of |
| @code{rbp}. This would be clumsy, and result in a larger binary size. Instead, |
| we can write: |
| |
| @smallexample |
| je label |
| popq %rbx |
| .cfi_remember_state |
| .cfi_restore %rbx |
| popq %r12 |
| .cfi_restore %r12 |
| popq %rbp |
| .cfi_restore %rbp |
| .cfi_def_cfa %rsp, 8 |
| ret |
| label: |
| .cfi_restore_state |
| /* Do something else */ |
| @end smallexample |
| |
| That way, the rules for the instructions after @code{label} will be the same |
| as before the first @code{.cfi_restore} without having to use multiple |
| @code{.cfi} directives. |
| |
| @subsection @code{.cfi_return_column @var{register}} |
| Change return column @var{register}, i.e. the return address is either |
| directly in @var{register} or can be accessed by rules for @var{register}. |
| |
| @subsection @code{.cfi_signal_frame} |
| Mark current function as signal trampoline. |
| |
| @subsection @code{.cfi_window_save} |
| SPARC register window has been saved. |
| |
| @subsection @code{.cfi_escape} @var{expression}[, @dots{}] |
| Allows the user to add arbitrary bytes to the unwind info. One |
| might use this to add OS-specific CFI opcodes, or generic CFI |
| opcodes that GAS does not yet support. |
| |
| @subsection @code{.cfi_val_encoded_addr @var{register}, @var{encoding}, @var{label}} |
| The current value of @var{register} is @var{label}. The value of @var{label} |
| will be encoded in the output file according to @var{encoding}; see the |
| description of @code{.cfi_personality} for details on this encoding. |
| |
| The usefulness of equating a register to a fixed label is probably |
| limited to the return address register. Here, it can be useful to |
| mark a code segment that has only one return address which is reached |
| by a direct branch and no copy of the return address exists in memory |
| or another register. |
| |
| @node Comm |
| @section @code{.comm @var{symbol} , @var{length} } |
| |
| @cindex @code{comm} directive |
| @cindex symbol, common |
| @code{.comm} declares a common symbol named @var{symbol}. When linking, a |
| common symbol in one object file may be merged with a defined or common symbol |
| of the same name in another object file. If @code{@value{LD}} does not see a |
| definition for the symbol--just one or more common symbols--then it will |
| allocate @var{length} bytes of uninitialized memory. @var{length} must be an |
| absolute expression. If @code{@value{LD}} sees multiple common symbols with |
| the same name, and they do not all have the same size, it will allocate space |
| using the largest size. |
| |
| @ifset COFF-ELF |
| When using ELF or (as a GNU extension) PE, the @code{.comm} directive takes |
| an optional third argument. This is the desired alignment of the symbol, |
| specified for ELF as a byte boundary (for example, an alignment of 16 means |
| that the least significant 4 bits of the address should be zero), and for PE |
| as a power of two (for example, an alignment of 5 means aligned to a 32-byte |
| boundary). The alignment must be an absolute expression, and it must be a |
| power of two. If @code{@value{LD}} allocates uninitialized memory for the |
| common symbol, it will use the alignment when placing the symbol. If no |
| alignment is specified, @command{@value{AS}} will set the alignment to the |
| largest power of two less than or equal to the size of the symbol, up to a |
| maximum of 16 on ELF, or the default section alignment of 4 on PE@footnote{This |
| is not the same as the executable image file alignment controlled by @code{@value{LD}}'s |
| @samp{--section-alignment} option; image file sections in PE are aligned to |
| multiples of 4096, which is far too large an alignment for ordinary variables. |
| It is rather the default alignment for (non-debug) sections within object |
| (@samp{*.o}) files, which are less strictly aligned.}. |
| @end ifset |
| |
| @ifset HPPA |
| The syntax for @code{.comm} differs slightly on the HPPA. The syntax is |
| @samp{@var{symbol} .comm, @var{length}}; @var{symbol} is optional. |
| @end ifset |
| |
| @node Data |
| @section @code{.data @var{subsection}} |
| @cindex @code{data} directive |
| |
| @code{.data} tells @command{@value{AS}} to assemble the following statements onto the |
| end of the data subsection numbered @var{subsection} (which is an |
| absolute expression). If @var{subsection} is omitted, it defaults |
| to zero. |
| |
| @node Dc |
| @section @code{.dc[@var{size}] @var{expressions}} |
| @cindex @code{dc} directive |
| |
| The @code{.dc} directive expects zero or more @var{expressions} separated by |
| commas. These expressions are evaluated and their values inserted into the |
| current section. The size of the emitted value depends upon the suffix to the |
| @code{.dc} directive: |
| |
| @table @code |
| @item @samp{.a} |
| Emits N-bit values, where N is the size of an address on the target system. |
| @item @samp{.b} |
| Emits 8-bit values. |
| @item @samp{.d} |
| Emits double precision floating-point values. |
| @item @samp{.l} |
| Emits 32-bit values. |
| @item @samp{.s} |
| Emits single precision floating-point values. |
| @item @samp{.w} |
| Emits 16-bit values. |
| Note - this is true even on targets where the @code{.word} directive would emit |
| 32-bit values. |
| @item @samp{.x} |
| Emits long double precision floating-point values. |
| @end table |
| |
| If no suffix is used then @samp{.w} is assumed. |
| |
| The byte ordering is target dependent, as is the size and format of floating |
| point values. |
| |
| @node Dcb |
| @section @code{.dcb[@var{size}] @var{number} [,@var{fill}]} |
| @cindex @code{dcb} directive |
| This directive emits @var{number} copies of @var{fill}, each of @var{size} |
| bytes. Both @var{number} and @var{fill} are absolute expressions. If the |
| comma and @var{fill} are omitted, @var{fill} is assumed to be zero. The |
| @var{size} suffix, if present, must be one of: |
| |
| @table @code |
| @item @samp{.b} |
| Emits single byte values. |
| @item @samp{.d} |
| Emits double-precision floating point values. |
| @item @samp{.l} |
| Emits 4-byte values. |
| @item @samp{.s} |
| Emits single-precision floating point values. |
| @item @samp{.w} |
| Emits 2-byte values. |
| @item @samp{.x} |
| Emits long double-precision floating point values. |
| @end table |
| |
| If the @var{size} suffix is omitted then @samp{.w} is assumed. |
| |
| The byte ordering is target dependent, as is the size and format of floating |
| point values. |
| |
| @node Ds |
| @section @code{.ds[@var{size}] @var{number} [,@var{fill}]} |
| @cindex @code{ds} directive |
| This directive emits @var{number} copies of @var{fill}, each of @var{size} |
| bytes. Both @var{number} and @var{fill} are absolute expressions. If the |
| comma and @var{fill} are omitted, @var{fill} is assumed to be zero. The |
| @var{size} suffix, if present, must be one of: |
| |
| @table @code |
| @item @samp{.b} |
| Emits single byte values. |
| @item @samp{.d} |
| Emits 8-byte values. |
| @item @samp{.l} |
| Emits 4-byte values. |
| @item @samp{.p} |
| Emits values with size matching packed-decimal floating-point ones. |
| @item @samp{.s} |
| Emits 4-byte values. |
| @item @samp{.w} |
| Emits 2-byte values. |
| @item @samp{.x} |
| Emits values with size matching long double precision floating-point ones. |
| @end table |
| |
| Note - unlike the @code{.dcb} directive the @samp{.d}, @samp{.s} and @samp{.x} |
| suffixes do not indicate that floating-point values are to be inserted. |
| |
| If the @var{size} suffix is omitted then @samp{.w} is assumed. |
| |
| The byte ordering is target dependent. |
| |
| |
| @ifset COFF |
| @node Def |
| @section @code{.def @var{name}} |
| |
| @cindex @code{def} directive |
| @cindex COFF symbols, debugging |
| @cindex debugging COFF symbols |
| Begin defining debugging information for a symbol @var{name}; the |
| definition extends until the @code{.endef} directive is encountered. |
| @end ifset |
| |
| @ifset aout |
| @node Desc |
| @section @code{.desc @var{symbol}, @var{abs-expression}} |
| |
| @cindex @code{desc} directive |
| @cindex COFF symbol descriptor |
| @cindex symbol descriptor, COFF |
| This directive sets the descriptor of the symbol (@pxref{Symbol Attributes}) |
| to the low 16 bits of an absolute expression. |
| |
| @ifset COFF |
| The @samp{.desc} directive is not available when @command{@value{AS}} is |
| configured for COFF output; it is only for @code{a.out} or @code{b.out} |
| object format. For the sake of compatibility, @command{@value{AS}} accepts |
| it, but produces no output, when configured for COFF. |
| @end ifset |
| @end ifset |
| |
| @ifset COFF |
| @node Dim |
| @section @code{.dim} |
| |
| @cindex @code{dim} directive |
| @cindex COFF auxiliary symbol information |
| @cindex auxiliary symbol information, COFF |
| This directive is generated by compilers to include auxiliary debugging |
| information in the symbol table. It is only permitted inside |
| @code{.def}/@code{.endef} pairs. |
| @end ifset |
| |
| @node Double |
| @section @code{.double @var{flonums}} |
| |
| @cindex @code{double} directive |
| @cindex floating point numbers (double) |
| @code{.double} expects zero or more flonums, separated by commas. It |
| assembles floating point numbers. |
| @ifset GENERIC |
| The exact kind of floating point numbers emitted depends on how |
| @command{@value{AS}} is configured. @xref{Machine Dependencies}. |
| @end ifset |
| @ifclear GENERIC |
| @ifset IEEEFLOAT |
| On the @value{TARGET} family @samp{.double} emits 64-bit floating-point numbers |
| in @sc{ieee} format. |
| @end ifset |
| @end ifclear |
| |
| @node Eject |
| @section @code{.eject} |
| |
| @cindex @code{eject} directive |
| @cindex new page, in listings |
| @cindex page, in listings |
| @cindex listing control: new page |
| Force a page break at this point, when generating assembly listings. |
| |
| @node Else |
| @section @code{.else} |
| |
| @cindex @code{else} directive |
| @code{.else} is part of the @command{@value{AS}} support for conditional |
| assembly; see @ref{If,,@code{.if}}. It marks the beginning of a section |
| of code to be assembled if the condition for the preceding @code{.if} |
| was false. |
| |
| @node Elseif |
| @section @code{.elseif} |
| |
| @cindex @code{elseif} directive |
| @code{.elseif} is part of the @command{@value{AS}} support for conditional |
| assembly; see @ref{If,,@code{.if}}. It is shorthand for beginning a new |
| @code{.if} block that would otherwise fill the entire @code{.else} section. |
| |
| @node End |
| @section @code{.end} |
| |
| @cindex @code{end} directive |
| @code{.end} marks the end of the assembly file. @command{@value{AS}} does not |
| process anything in the file past the @code{.end} directive. |
| |
| @ifset COFF |
| @node Endef |
| @section @code{.endef} |
| |
| @cindex @code{endef} directive |
| This directive flags the end of a symbol definition begun with |
| @code{.def}. |
| @end ifset |
| |
| @node Endfunc |
| @section @code{.endfunc} |
| @cindex @code{endfunc} directive |
| @code{.endfunc} marks the end of a function specified with @code{.func}. |
| |
| @node Endif |
| @section @code{.endif} |
| |
| @cindex @code{endif} directive |
| @code{.endif} is part of the @command{@value{AS}} support for conditional assembly; |
| it marks the end of a block of code that is only assembled |
| conditionally. @xref{If,,@code{.if}}. |
| |
| @node Equ |
| @section @code{.equ @var{symbol}, @var{expression}} |
| |
| @cindex @code{equ} directive |
| @cindex assigning values to symbols |
| @cindex symbols, assigning values to |
| This directive sets the value of @var{symbol} to @var{expression}. |
| It is synonymous with @samp{.set}; see @ref{Set,,@code{.set}}. |
| |
| @ifset HPPA |
| The syntax for @code{equ} on the HPPA is |
| @samp{@var{symbol} .equ @var{expression}}. |
| @end ifset |
| |
| @ifset Z80 |
| The syntax for @code{equ} on the Z80 is |
| @samp{@var{symbol} equ @var{expression}}. |
| On the Z80 it is an error if @var{symbol} is already defined, |
| but the symbol is not protected from later redefinition. |
| Compare @ref{Equiv}. |
| @end ifset |
| |
| @node Equiv |
| @section @code{.equiv @var{symbol}, @var{expression}} |
| @cindex @code{equiv} directive |
| The @code{.equiv} directive is like @code{.equ} and @code{.set}, except that |
| the assembler will signal an error if @var{symbol} is already defined. Note a |
| symbol which has been referenced but not actually defined is considered to be |
| undefined. |
| |
| Except for the contents of the error message, this is roughly equivalent to |
| @smallexample |
| .ifdef SYM |
| .err |
| .endif |
| .equ SYM,VAL |
| @end smallexample |
| plus it protects the symbol from later redefinition. |
| |
| @node Eqv |
| @section @code{.eqv @var{symbol}, @var{expression}} |
| @cindex @code{eqv} directive |
| The @code{.eqv} directive is like @code{.equiv}, but no attempt is made to |
| evaluate the expression or any part of it immediately. Instead each time |
| the resulting symbol is used in an expression, a snapshot of its current |
| value is taken. |
| |
| @node Err |
| @section @code{.err} |
| @cindex @code{err} directive |
| If @command{@value{AS}} assembles a @code{.err} directive, it will print an error |
| message and, unless the @option{-Z} option was used, it will not generate an |
| object file. This can be used to signal an error in conditionally compiled code. |
| |
| @node Error |
| @section @code{.error "@var{string}"} |
| @cindex error directive |
| |
| Similarly to @code{.err}, this directive emits an error, but you can specify a |
| string that will be emitted as the error message. If you don't specify the |
| message, it defaults to @code{".error directive invoked in source file"}. |
| @xref{Errors, ,Error and Warning Messages}. |
| |
| @smallexample |
| .error "This code has not been assembled and tested." |
| @end smallexample |
| |
| @node Exitm |
| @section @code{.exitm} |
| Exit early from the current macro definition. @xref{Macro}. |
| |
| @node Extern |
| @section @code{.extern} |
| |
| @cindex @code{extern} directive |
| @code{.extern} is accepted in the source program---for compatibility |
| with other assemblers---but it is ignored. @command{@value{AS}} treats |
| all undefined symbols as external. |
| |
| @node Fail |
| @section @code{.fail @var{expression}} |
| |
| @cindex @code{fail} directive |
| Generates an error or a warning. If the value of the @var{expression} is 500 |
| or more, @command{@value{AS}} will print a warning message. If the value is less |
| than 500, @command{@value{AS}} will print an error message. The message will |
| include the value of @var{expression}. This can occasionally be useful inside |
| complex nested macros or conditional assembly. |
| |
| @node File |
| @section @code{.file} |
| @cindex @code{file} directive |
| |
| @ifclear no-file-dir |
| There are two different versions of the @code{.file} directive. Targets |
| that support DWARF2 line number information use the DWARF2 version of |
| @code{.file}. Other targets use the default version. |
| |
| @subheading Default Version |
| |
| @cindex logical file name |
| @cindex file name, logical |
| This version of the @code{.file} directive tells @command{@value{AS}} that we |
| are about to start a new logical file. The syntax is: |
| |
| @smallexample |
| .file @var{string} |
| @end smallexample |
| |
| @var{string} is the new file name. In general, the filename is |
| recognized whether or not it is surrounded by quotes @samp{"}; but if you wish |
| to specify an empty file name, you must give the quotes--@code{""}. This |
| statement may go away in future: it is only recognized to be compatible with |
| old @command{@value{AS}} programs. |
| |
| @subheading DWARF2 Version |
| @end ifclear |
| |
| When emitting DWARF2 line number information, @code{.file} assigns filenames |
| to the @code{.debug_line} file name table. The syntax is: |
| |
| @smallexample |
| .file @var{fileno} @var{filename} |
| @end smallexample |
| |
| The @var{fileno} operand should be a unique positive integer to use as the |
| index of the entry in the table. The @var{filename} operand is a C string |
| literal enclosed in double quotes. The @var{filename} can include directory |
| elements. If it does, then the directory will be added to the directory table |
| and the basename will be added to the file table. |
| |
| The detail of filename indices is exposed to the user because the filename |
| table is shared with the @code{.debug_info} section of the DWARF2 debugging |
| information, and thus the user must know the exact indices that table |
| entries will have. |
| |
| If DWARF-5 support has been enabled via the @option{-gdwarf-5} option then |
| an extended version of the @code{file} is also allowed: |
| |
| @smallexample |
| .file @var{fileno} [@var{dirname}] @var{filename} [md5 @var{value}] |
| @end smallexample |
| |
| With this version a separate directory name is allowed, although if this is |
| used then @var{filename} should not contain any directory components. In |
| addtion an md5 hash value of the contents of @var{filename} can be provided. |
| This will be stored in the the file table as well, and can be used by tools |
| reading the debug information to verify that the contents of the source file |
| match the contents of the compiled file. |
| |
| @node Fill |
| @section @code{.fill @var{repeat} , @var{size} , @var{value}} |
| |
| @cindex @code{fill} directive |
| @cindex writing patterns in memory |
| @cindex patterns, writing in memory |
| @var{repeat}, @var{size} and @var{value} are absolute expressions. |
| This emits @var{repeat} copies of @var{size} bytes. @var{Repeat} |
| may be zero or more. @var{Size} may be zero or more, but if it is |
| more than 8, then it is deemed to have the value 8, compatible with |
| other people's assemblers. The contents of each @var{repeat} bytes |
| is taken from an 8-byte number. The highest order 4 bytes are |
| zero. The lowest order 4 bytes are @var{value} rendered in the |
| byte-order of an integer on the computer @command{@value{AS}} is assembling for. |
| Each @var{size} bytes in a repetition is taken from the lowest order |
| @var{size} bytes of this number. Again, this bizarre behavior is |
| compatible with other people's assemblers. |
| |
| @var{size} and @var{value} are optional. |
| If the second comma and @var{value} are absent, @var{value} is |
| assumed zero. If the first comma and following tokens are absent, |
| @var{size} is assumed to be 1. |
| |
| @node Float |
| @section @code{.float @var{flonums}} |
| |
| @cindex floating point numbers (single) |
| @cindex @code{float} directive |
| This directive assembles zero or more flonums, separated by commas. It |
| has the same effect as @code{.single}. |
| @ifset GENERIC |
| The exact kind of floating point numbers emitted depends on how |
| @command{@value{AS}} is configured. |
| @xref{Machine Dependencies}. |
| @end ifset |
| @ifclear GENERIC |
| @ifset IEEEFLOAT |
| On the @value{TARGET} family, @code{.float} emits 32-bit floating point numbers |
| in @sc{ieee} format. |
| @end ifset |
| @end ifclear |
| |
| @node Func |
| @section @code{.func @var{name}[,@var{label}]} |
| @cindex @code{func} directive |
| @code{.func} emits debugging information to denote function @var{name}, and |
| is ignored unless the file is assembled with debugging enabled. |
| Only @samp{--gstabs[+]} is currently supported. |
| @var{label} is the entry point of the function and if omitted @var{name} |
| prepended with the @samp{leading char} is used. |
| @samp{leading char} is usually @code{_} or nothing, depending on the target. |
| All functions are currently defined to have @code{void} return type. |
| The function must be terminated with @code{.endfunc}. |
| |
| @node Global |
| @section @code{.global @var{symbol}}, @code{.globl @var{symbol}} |
| |
| @cindex @code{global} directive |
| @cindex symbol, making visible to linker |
| @code{.global} makes the symbol visible to @code{@value{LD}}. If you define |
| @var{symbol} in your partial program, its value is made available to |
| other partial programs that are linked with it. Otherwise, |
| @var{symbol} takes its attributes from a symbol of the same name |
| from another file linked into the same program. |
| |
| Both spellings (@samp{.globl} and @samp{.global}) are accepted, for |
| compatibility with other assemblers. |
| |
| @ifset HPPA |
| On the HPPA, @code{.global} is not always enough to make it accessible to other |
| partial programs. You may need the HPPA-only @code{.EXPORT} directive as well. |
| @xref{HPPA Directives, ,HPPA Assembler Directives}. |
| @end ifset |
| |
| @ifset ELF |
| @node Gnu_attribute |
| @section @code{.gnu_attribute @var{tag},@var{value}} |
| Record a @sc{gnu} object attribute for this file. @xref{Object Attributes}. |
| |
| @node Hidden |
| @section @code{.hidden @var{names}} |
| |
| @cindex @code{hidden} directive |
| @cindex visibility |
| This is one of the ELF visibility directives. The other two are |
| @code{.internal} (@pxref{Internal,,@code{.internal}}) and |
| @code{.protected} (@pxref{Protected,,@code{.protected}}). |
| |
| This directive overrides the named symbols default visibility (which is set by |
| their binding: local, global or weak). The directive sets the visibility to |
| @code{hidden} which means that the symbols are not visible to other components. |
| Such symbols are always considered to be @code{protected} as well. |
| @end ifset |
| |
| @node hword |
| @section @code{.hword @var{expressions}} |
| |
| @cindex @code{hword} directive |
| @cindex integers, 16-bit |
| @cindex numbers, 16-bit |
| @cindex sixteen bit integers |
| This expects zero or more @var{expressions}, and emits |
| a 16 bit number for each. |
| |
| @ifset GENERIC |
| This directive is a synonym for @samp{.short}; depending on the target |
| architecture, it may also be a synonym for @samp{.word}. |
| @end ifset |
| @ifclear GENERIC |
| @ifset W32 |
| This directive is a synonym for @samp{.short}. |
| @end ifset |
| @ifset W16 |
| This directive is a synonym for both @samp{.short} and @samp{.word}. |
| @end ifset |
| @end ifclear |
| |
| @node Ident |
| @section @code{.ident} |
| |
| @cindex @code{ident} directive |
| |
| This directive is used by some assemblers to place tags in object files. The |
| behavior of this directive varies depending on the target. When using the |
| a.out object file format, @command{@value{AS}} simply accepts the directive for |
| source-file compatibility with existing assemblers, but does not emit anything |
| for it. When using COFF, comments are emitted to the @code{.comment} or |
| @code{.rdata} section, depending on the target. When using ELF, comments are |
| emitted to the @code{.comment} section. |
| |
| @node If |
| @section @code{.if @var{absolute expression}} |
| |
| @cindex conditional assembly |
| @cindex @code{if} directive |
| @code{.if} marks the beginning of a section of code which is only |
| considered part of the source program being assembled if the argument |
| (which must be an @var{absolute expression}) is non-zero. The end of |
| the conditional section of code must be marked by @code{.endif} |
| (@pxref{Endif,,@code{.endif}}); optionally, you may include code for the |
| alternative condition, flagged by @code{.else} (@pxref{Else,,@code{.else}}). |
| If you have several conditions to check, @code{.elseif} may be used to avoid |
| nesting blocks if/else within each subsequent @code{.else} block. |
| |
| The following variants of @code{.if} are also supported: |
| @table @code |
| @cindex @code{ifdef} directive |
| @item .ifdef @var{symbol} |
| Assembles the following section of code if the specified @var{symbol} |
| has been defined. Note a symbol which has been referenced but not yet defined |
| is considered to be undefined. |
| |
| @cindex @code{ifb} directive |
| @item .ifb @var{text} |
| Assembles the following section of code if the operand is blank (empty). |
| |
| @cindex @code{ifc} directive |
| @item .ifc @var{string1},@var{string2} |
| Assembles the following section of code if the two strings are the same. The |
| strings may be optionally quoted with single quotes. If they are not quoted, |
| the first string stops at the first comma, and the second string stops at the |
| end of the line. Strings which contain whitespace should be quoted. The |
| string comparison is case sensitive. |
| |
| @cindex @code{ifeq} directive |
| @item .ifeq @var{absolute expression} |
| Assembles the following section of code if the argument is zero. |
| |
| @cindex @code{ifeqs} directive |
| @item .ifeqs @var{string1},@var{string2} |
| Another form of @code{.ifc}. The strings must be quoted using double quotes. |
| |
| @cindex @code{ifge} directive |
| @item .ifge @var{absolute expression} |
| Assembles the following section of code if the argument is greater than or |
| equal to zero. |
| |
| @cindex @code{ifgt} directive |
| @item .ifgt @var{absolute expression} |
| Assembles the following section of code if the argument is greater than zero. |
| |
| @cindex @code{ifle} directive |
| @item .ifle @var{absolute expression} |
| Assembles the following section of code if the argument is less than or equal |
| to zero. |
| |
| @cindex @code{iflt} directive |
| @item .iflt @var{absolute expression} |
| Assembles the following section of code if the argument is less than zero. |
| |
| @cindex @code{ifnb} directive |
| @item .ifnb @var{text} |
| Like @code{.ifb}, but the sense of the test is reversed: this assembles the |
| following section of code if the operand is non-blank (non-empty). |
| |
| @cindex @code{ifnc} directive |
| @item .ifnc @var{string1},@var{string2}. |
| Like @code{.ifc}, but the sense of the test is reversed: this assembles the |
| following section of code if the two strings are not the same. |
| |
| @cindex @code{ifndef} directive |
| @cindex @code{ifnotdef} directive |
| @item .ifndef @var{symbol} |
| @itemx .ifnotdef @var{symbol} |
| Assembles the following section of code if the specified @var{symbol} |
| has not been defined. Both spelling variants are equivalent. Note a symbol |
| which has been referenced but not yet defined is considered to be undefined. |
| |
| @cindex @code{ifne} directive |
| @item .ifne @var{absolute expression} |
| Assembles the following section of code if the argument is not equal to zero |
| (in other words, this is equivalent to @code{.if}). |
| |
| @cindex @code{ifnes} directive |
| @item .ifnes @var{string1},@var{string2} |
| Like @code{.ifeqs}, but the sense of the test is reversed: this assembles the |
| following section of code if the two strings are not the same. |
| @end table |
| |
| @node Incbin |
| @section @code{.incbin "@var{file}"[,@var{skip}[,@var{count}]]} |
| |
| @cindex @code{incbin} directive |
| @cindex binary files, including |
| The @code{incbin} directive includes @var{file} verbatim at the current |
| location. You can control the search paths used with the @samp{-I} command-line |
| option (@pxref{Invoking,,Command-Line Options}). Quotation marks are required |
| around @var{file}. |
| |
| The @var{skip} argument skips a number of bytes from the start of the |
| @var{file}. The @var{count} argument indicates the maximum number of bytes to |
| read. Note that the data is not aligned in any way, so it is the user's |
| responsibility to make sure that proper alignment is provided both before and |
| after the @code{incbin} directive. |
| |
| @node Include |
| @section @code{.include "@var{file}"} |
| |
| @cindex @code{include} directive |
| @cindex supporting files, including |
| @cindex files, including |
| This directive provides a way to include supporting files at specified |
| points in your source program. The code from @var{file} is assembled as |
| if it followed the point of the @code{.include}; when the end of the |
| included file is reached, assembly of the original file continues. You |
| can control the search paths used with the @samp{-I} command-line option |
| (@pxref{Invoking,,Command-Line Options}). Quotation marks are required |
| around @var{file}. |
| |
| @node Int |
| @section @code{.int @var{expressions}} |
| |
| @cindex @code{int} directive |
| @cindex integers, 32-bit |
| Expect zero or more @var{expressions}, of any section, separated by commas. |
| For each expression, emit a number that, at run time, is the value of that |
| expression. The byte order and bit size of the number depends on what kind |
| of target the assembly is for. |
| |
| @ifclear GENERIC |
| @ifset H8 |
| On most forms of the H8/300, @code{.int} emits 16-bit |
| integers. On the H8/300H and the Renesas SH, however, @code{.int} emits |
| 32-bit integers. |
| @end ifset |
| @end ifclear |
| |
| @ifset ELF |
| @node Internal |
| @section @code{.internal @var{names}} |
| |
| @cindex @code{internal} directive |
| @cindex visibility |
| This is one of the ELF visibility directives. The other two are |
| @code{.hidden} (@pxref{Hidden,,@code{.hidden}}) and |
| @code{.protected} (@pxref{Protected,,@code{.protected}}). |
| |
| This directive overrides the named symbols default visibility (which is set by |
| their binding: local, global or weak). The directive sets the visibility to |
| @code{internal} which means that the symbols are considered to be @code{hidden} |
| (i.e., not visible to other components), and that some extra, processor specific |
| processing must also be performed upon the symbols as well. |
| @end ifset |
| |
| @node Irp |
| @section @code{.irp @var{symbol},@var{values}}@dots{} |
| |
| @cindex @code{irp} directive |
| Evaluate a sequence of statements assigning different values to @var{symbol}. |
| The sequence of statements starts at the @code{.irp} directive, and is |
| terminated by an @code{.endr} directive. For each @var{value}, @var{symbol} is |
| set to @var{value}, and the sequence of statements is assembled. If no |
| @var{value} is listed, the sequence of statements is assembled once, with |
| @var{symbol} set to the null string. To refer to @var{symbol} within the |
| sequence of statements, use @var{\symbol}. |
| |
| For example, assembling |
| |
| @example |
| .irp param,1,2,3 |
| move d\param,sp@@- |
| .endr |
| @end example |
| |
| is equivalent to assembling |
| |
| @example |
| move d1,sp@@- |
| move d2,sp@@- |
| move d3,sp@@- |
| @end example |
| |
| For some caveats with the spelling of @var{symbol}, see also @ref{Macro}. |
| |
| @node Irpc |
| @section @code{.irpc @var{symbol},@var{values}}@dots{} |
| |
| @cindex @code{irpc} directive |
| Evaluate a sequence of statements assigning different values to @var{symbol}. |
| The sequence of statements starts at the @code{.irpc} directive, and is |
| terminated by an @code{.endr} directive. For each character in @var{value}, |
| @var{symbol} is set to the character, and the sequence of statements is |
| assembled. If no @var{value} is listed, the sequence of statements is |
| assembled once, with @var{symbol} set to the null string. To refer to |
| @var{symbol} within the sequence of statements, use @var{\symbol}. |
| |
| For example, assembling |
| |
| @example |
| .irpc param,123 |
| move d\param,sp@@- |
| .endr |
| @end example |
| |
| is equivalent to assembling |
| |
| @example |
| move d1,sp@@- |
| move d2,sp@@- |
| move d3,sp@@- |
| @end example |
| |
| For some caveats with the spelling of @var{symbol}, see also the discussion |
| at @xref{Macro}. |
| |
| @node Lcomm |
| @section @code{.lcomm @var{symbol} , @var{length}} |
| |
| @cindex @code{lcomm} directive |
| @cindex local common symbols |
| @cindex symbols, local common |
| Reserve @var{length} (an absolute expression) bytes for a local common |
| denoted by @var{symbol}. The section and value of @var{symbol} are |
| those of the new local common. The addresses are allocated in the bss |
| section, so that at run-time the bytes start off zeroed. @var{Symbol} |
| is not declared global (@pxref{Global,,@code{.global}}), so is normally |
| not visible to @code{@value{LD}}. |
| |
| @ifset GENERIC |
| Some targets permit a third argument to be used with @code{.lcomm}. This |
| argument specifies the desired alignment of the symbol in the bss section. |
| @end ifset |
| |
| @ifset HPPA |
| The syntax for @code{.lcomm} differs slightly on the HPPA. The syntax is |
| @samp{@var{symbol} .lcomm, @var{length}}; @var{symbol} is optional. |
| @end ifset |
| |
| @node Lflags |
| @section @code{.lflags} |
| |
| @cindex @code{lflags} directive (ignored) |
| @command{@value{AS}} accepts this directive, for compatibility with other |
| assemblers, but ignores it. |
| |
| @ifclear no-line-dir |
| @node Line |
| @section @code{.line @var{line-number}} |
| |
| @cindex @code{line} directive |
| @cindex logical line number |
| @ifset aout |
| Change the logical line number. @var{line-number} must be an absolute |
| expression. The next line has that logical line number. Therefore any other |
| statements on the current line (after a statement separator character) are |
| reported as on logical line number @var{line-number} @minus{} 1. One day |
| @command{@value{AS}} will no longer support this directive: it is recognized only |
| for compatibility with existing assembler programs. |
| @end ifset |
| |
| Even though this is a directive associated with the @code{a.out} or |
| @code{b.out} object-code formats, @command{@value{AS}} still recognizes it |
| when producing COFF output, and treats @samp{.line} as though it |
| were the COFF @samp{.ln} @emph{if} it is found outside a |
| @code{.def}/@code{.endef} pair. |
| |
| Inside a @code{.def}, @samp{.line} is, instead, one of the directives |
| used by compilers to generate auxiliary symbol information for |
| debugging. |
| @end ifclear |
| |
| @node Linkonce |
| @section @code{.linkonce [@var{type}]} |
| @cindex COMDAT |
| @cindex @code{linkonce} directive |
| @cindex common sections |
| Mark the current section so that the linker only includes a single copy of it. |
| This may be used to include the same section in several different object files, |
| but ensure that the linker will only include it once in the final output file. |
| The @code{.linkonce} pseudo-op must be used for each instance of the section. |
| Duplicate sections are detected based on the section name, so it should be |
| unique. |
| |
| This directive is only supported by a few object file formats; as of this |
| writing, the only object file format which supports it is the Portable |
| Executable format used on Windows NT. |
| |
| The @var{type} argument is optional. If specified, it must be one of the |
| following strings. For example: |
| @smallexample |
| .linkonce same_size |
| @end smallexample |
| Not all types may be supported on all object file formats. |
| |
| @table @code |
| @item discard |
| Silently discard duplicate sections. This is the default. |
| |
| @item one_only |
| Warn if there are duplicate sections, but still keep only one copy. |
| |
| @item same_size |
| Warn if any of the duplicates have different sizes. |
| |
| @item same_contents |
| Warn if any of the duplicates do not have exactly the same contents. |
| @end table |
| |
| @node List |
| @section @code{.list} |
| |
| @cindex @code{list} directive |
| @cindex listing control, turning on |
| Control (in conjunction with the @code{.nolist} directive) whether or |
| not assembly listings are generated. These two directives maintain an |
| internal counter (which is zero initially). @code{.list} increments the |
| counter, and @code{.nolist} decrements it. Assembly listings are |
| generated whenever the counter is greater than zero. |
| |
| By default, listings are disabled. When you enable them (with the |
| @samp{-a} command-line option; @pxref{Invoking,,Command-Line Options}), |
| the initial value of the listing counter is one. |
| |
| @node Ln |
| @section @code{.ln @var{line-number}} |
| |
| @cindex @code{ln} directive |
| @ifclear no-line-dir |
| @samp{.ln} is a synonym for @samp{.line}. |
| @end ifclear |
| @ifset no-line-dir |
| Tell @command{@value{AS}} to change the logical line number. @var{line-number} |
| must be an absolute expression. The next line has that logical |
| line number, so any other statements on the current line (after a |
| statement separator character @code{;}) are reported as on logical |
| line number @var{line-number} @minus{} 1. |
| @end ifset |
| |
| @node Loc |
| @section @code{.loc @var{fileno} @var{lineno} [@var{column}] [@var{options}]} |
| @cindex @code{loc} directive |
| When emitting DWARF2 line number information, |
| the @code{.loc} directive will add a row to the @code{.debug_line} line |
| number matrix corresponding to the immediately following assembly |
| instruction. The @var{fileno}, @var{lineno}, and optional @var{column} |
| arguments will be applied to the @code{.debug_line} state machine before |
| the row is added. It is an error for the input assembly file to generate |
| a non-empty @code{.debug_line} and also use @code{loc} directives. |
| |
| The @var{options} are a sequence of the following tokens in any order: |
| |
| @table @code |
| @item basic_block |
| This option will set the @code{basic_block} register in the |
| @code{.debug_line} state machine to @code{true}. |
| |
| @item prologue_end |
| This option will set the @code{prologue_end} register in the |
| @code{.debug_line} state machine to @code{true}. |
| |
| @item epilogue_begin |
| This option will set the @code{epilogue_begin} register in the |
| @code{.debug_line} state machine to @code{true}. |
| |
| @item is_stmt @var{value} |
| This option will set the @code{is_stmt} register in the |
| @code{.debug_line} state machine to @code{value}, which must be |
| either 0 or 1. |
| |
| @item isa @var{value} |
| This directive will set the @code{isa} register in the @code{.debug_line} |
| state machine to @var{value}, which must be an unsigned integer. |
| |
| @item discriminator @var{value} |
| This directive will set the @code{discriminator} register in the @code{.debug_line} |
| state machine to @var{value}, which must be an unsigned integer. |
| |
| @item view @var{value} |
| This option causes a row to be added to @code{.debug_line} in reference to the |
| current address (which might not be the same as that of the following assembly |
| instruction), and to associate @var{value} with the @code{view} register in the |
| @code{.debug_line} state machine. If @var{value} is a label, both the |
| @code{view} register and the label are set to the number of prior @code{.loc} |
| directives at the same program location. If @var{value} is the literal |
| @code{0}, the @code{view} register is set to zero, and the assembler asserts |
| that there aren't any prior @code{.loc} directives at the same program |
| location. If @var{value} is the literal @code{-0}, the assembler arrange for |
| the @code{view} register to be reset in this row, even if there are prior |
| @code{.loc} directives at the same program location. |
| |
| @end table |
| |
| @node Loc_mark_labels |
| @section @code{.loc_mark_labels @var{enable}} |
| @cindex @code{loc_mark_labels} directive |
| When emitting DWARF2 line number information, |
| the @code{.loc_mark_labels} directive makes the assembler emit an entry |
| to the @code{.debug_line} line number matrix with the @code{basic_block} |
| register in the state machine set whenever a code label is seen. |
| The @var{enable} argument should be either 1 or 0, to enable or disable |
| this function respectively. |
| |
| @ifset ELF |
| @node Local |
| @section @code{.local @var{names}} |
| |
| @cindex @code{local} directive |
| This directive, which is available for ELF targets, marks each symbol in |
| the comma-separated list of @code{names} as a local symbol so that it |
| will not be externally visible. If the symbols do not already exist, |
| they will be created. |
| |
| For targets where the @code{.lcomm} directive (@pxref{Lcomm}) does not |
| accept an alignment argument, which is the case for most ELF targets, |
| the @code{.local} directive can be used in combination with @code{.comm} |
| (@pxref{Comm}) to define aligned local common data. |
| @end ifset |
| |
| @node Long |
| @section @code{.long @var{expressions}} |
| |
| @cindex @code{long} directive |
| @code{.long} is the same as @samp{.int}. @xref{Int,,@code{.int}}. |
| |
| @ignore |
| @c no one seems to know what this is for or whether this description is |
| @c what it really ought to do |
| @node Lsym |
| @section @code{.lsym @var{symbol}, @var{expression}} |
| |
| @cindex @code{lsym} directive |
| @cindex symbol, not referenced in assembly |
| @code{.lsym} creates a new symbol named @var{symbol}, but does not put it in |
| the hash table, ensuring it cannot be referenced by name during the |
| rest of the assembly. This sets the attributes of the symbol to be |
| the same as the expression value: |
| @smallexample |
| @var{other} = @var{descriptor} = 0 |
| @var{type} = @r{(section of @var{expression})} |
| @var{value} = @var{expression} |
| @end smallexample |
| @noindent |
| The new symbol is not flagged as external. |
| @end ignore |
| |
| @node Macro |
| @section @code{.macro} |
| |
| @cindex macros |
| The commands @code{.macro} and @code{.endm} allow you to define macros that |
| generate assembly output. For example, this definition specifies a macro |
| @code{sum} that puts a sequence of numbers into memory: |
| |
| @example |
| .macro sum from=0, to=5 |
| .long \from |
| .if \to-\from |
| sum "(\from+1)",\to |
| .endif |
| .endm |
| @end example |
| |
| @noindent |
| With that definition, @samp{SUM 0,5} is equivalent to this assembly input: |
| |
| @example |
| .long 0 |
| .long 1 |
| .long 2 |
| .long 3 |
| .long 4 |
| .long 5 |
| @end example |
| |
| @ftable @code |
| @item .macro @var{macname} |
| @itemx .macro @var{macname} @var{macargs} @dots{} |
| @cindex @code{macro} directive |
| Begin the definition of a macro called @var{macname}. If your macro |
| definition requires arguments, specify their names after the macro name, |
| separated by commas or spaces. You can qualify the macro argument to |
| indicate whether all invocations must specify a non-blank value (through |
| @samp{:@code{req}}), or whether it takes all of the remaining arguments |
| (through @samp{:@code{vararg}}). You can supply a default value for any |
| macro argument by following the name with @samp{=@var{deflt}}. You |
| cannot define two macros with the same @var{macname} unless it has been |
| subject to the @code{.purgem} directive (@pxref{Purgem}) between the two |
| definitions. For example, these are all valid @code{.macro} statements: |
| |
| @table @code |
| @item .macro comm |
| Begin the definition of a macro called @code{comm}, which takes no |
| arguments. |
| |
| @item .macro plus1 p, p1 |
| @itemx .macro plus1 p p1 |
| Either statement begins the definition of a macro called @code{plus1}, |
| which takes two arguments; within the macro definition, write |
| @samp{\p} or @samp{\p1} to evaluate the arguments. |
| |
| @item .macro reserve_str p1=0 p2 |
| Begin the definition of a macro called @code{reserve_str}, with two |
| arguments. The first argument has a default value, but not the second. |
| After the definition is complete, you can call the macro either as |
| @samp{reserve_str @var{a},@var{b}} (with @samp{\p1} evaluating to |
| @var{a} and @samp{\p2} evaluating to @var{b}), or as @samp{reserve_str |
| ,@var{b}} (with @samp{\p1} evaluating as the default, in this case |
| @samp{0}, and @samp{\p2} evaluating to @var{b}). |
| |
| @item .macro m p1:req, p2=0, p3:vararg |
| Begin the definition of a macro called @code{m}, with at least three |
| arguments. The first argument must always have a value specified, but |
| not the second, which instead has a default value. The third formal |
| will get assigned all remaining arguments specified at invocation time. |
| |
| When you call a macro, you can specify the argument values either by |
| position, or by keyword. For example, @samp{sum 9,17} is equivalent to |
| @samp{sum to=17, from=9}. |
| |
| @end table |
| |
| Note that since each of the @var{macargs} can be an identifier exactly |
| as any other one permitted by the target architecture, there may be |
| occasional problems if the target hand-crafts special meanings to certain |
| characters when they occur in a special position. For example, if the colon |
| (@code{:}) is generally permitted to be part of a symbol name, but the |
| architecture specific code special-cases it when occurring as the final |
| character of a symbol (to denote a label), then the macro parameter |
| replacement code will have no way of knowing that and consider the whole |
| construct (including the colon) an identifier, and check only this |
| identifier for being the subject to parameter substitution. So for example |
| this macro definition: |
| |
| @example |
| .macro label l |
| \l: |
| .endm |
| @end example |
| |
| might not work as expected. Invoking @samp{label foo} might not create a label |
| called @samp{foo} but instead just insert the text @samp{\l:} into the |
| assembler source, probably generating an error about an unrecognised |
| identifier. |
| |
| Similarly problems might occur with the period character (@samp{.}) |
| which is often allowed inside opcode names (and hence identifier names). So |
| for example constructing a macro to build an opcode from a base name and a |
| length specifier like this: |
| |
| @example |
| .macro opcode base length |
| \base.\length |
| .endm |
| @end example |
| |
| and invoking it as @samp{opcode store l} will not create a @samp{store.l} |
| instruction but instead generate some kind of error as the assembler tries to |
| interpret the text @samp{\base.\length}. |
| |
| There are several possible ways around this problem: |
| |
| @table @code |
| @item Insert white space |
| If it is possible to use white space characters then this is the simplest |
| solution. eg: |
| |
| @example |
| .macro label l |
| \l : |
| .endm |
| @end example |
| |
| @item Use @samp{\()} |
| The string @samp{\()} can be used to separate the end of a macro argument from |
| the following text. eg: |
| |
| @example |
| .macro opcode base length |
| \base\().\length |
| .endm |
| @end example |
| |
| @item Use the alternate macro syntax mode |
| In the alternative macro syntax mode the ampersand character (@samp{&}) can be |
| used as a separator. eg: |
| |
| @example |
| .altmacro |
| .macro label l |
| l&: |
| .endm |
| @end example |
| @end table |
| |
| Note: this problem of correctly identifying string parameters to pseudo ops |
| also applies to the identifiers used in @code{.irp} (@pxref{Irp}) |
| and @code{.irpc} (@pxref{Irpc}) as well. |
| |
| @item .endm |
| @cindex @code{endm} directive |
| Mark the end of a macro definition. |
| |
| @item .exitm |
| @cindex @code{exitm} directive |
| Exit early from the current macro definition. |
| |
| @cindex number of macros executed |
| @cindex macros, count executed |
| @item \@@ |
| @command{@value{AS}} maintains a counter of how many macros it has |
| executed in this pseudo-variable; you can copy that number to your |
| output with @samp{\@@}, but @emph{only within a macro definition}. |
| |
| @item LOCAL @var{name} [ , @dots{} ] |
| @emph{Warning: @code{LOCAL} is only available if you select ``alternate |
| macro syntax'' with @samp{--alternate} or @code{.altmacro}.} |
| @xref{Altmacro,,@code{.altmacro}}. |
| @end ftable |
| |
| @node MRI |
| @section @code{.mri @var{val}} |
| |
| @cindex @code{mri} directive |
| @cindex MRI mode, temporarily |
| If @var{val} is non-zero, this tells @command{@value{AS}} to enter MRI mode. If |
| @var{val} is zero, this tells @command{@value{AS}} to exit MRI mode. This change |
| affects code assembled until the next @code{.mri} directive, or until the end |
| of the file. @xref{M, MRI mode, MRI mode}. |
| |
| @node Noaltmacro |
| @section @code{.noaltmacro} |
| Disable alternate macro mode. @xref{Altmacro}. |
| |
| @node Nolist |
| @section @code{.nolist} |
| |
| @cindex @code{nolist} directive |
| @cindex listing control, turning off |
| Control (in conjunction with the @code{.list} directive) whether or |
| not assembly listings are generated. These two directives maintain an |
| internal counter (which is zero initially). @code{.list} increments the |
| counter, and @code{.nolist} decrements it. Assembly listings are |
| generated whenever the counter is greater than zero. |
| |
| @node Nop |
| @section @code{.nop [@var{size}]} |
| |
| @cindex @code{nop} directive |
| @cindex filling memory with no-op instructions |
| This directive emits no-op instructions. It is provided on all architectures, |
| allowing the creation of architecture neutral tests involving actual code. The |
| size of the generated instruction is target specific, but if the optional |
| @var{size} argument is given and resolves to an absolute positive value at that |
| point in assembly (no forward expressions allowed) then the fewest no-op |
| instructions are emitted that equal or exceed a total @var{size} in bytes. |
| @code{.nop} does affect the generation of DWARF debug line information. |
| Some targets do not support using @code{.nop} with @var{size}. |
| |
| @node Nops |
| @section @code{.nops @var{size}[, @var{control}]} |
| |
| @cindex @code{nops} directive |
| @cindex filling memory with no-op instructions |
| This directive emits no-op instructions. It is specific to the Intel 80386 and |
| AMD x86-64 targets. It takes a @var{size} argument and generates @var{size} |
| bytes of no-op instructions. @var{size} must be absolute and positive. These |
| bytes do not affect the generation of DWARF debug line information. |
| |
| The optional @var{control} argument specifies a size limit for a single no-op |
| instruction. If not provided then a value of 0 is assumed. The valid values |
| of @var{control} are between 0 and 4 in 16-bit mode, between 0 and 7 when |
| tuning for older processors in 32-bit mode, between 0 and 11 in 64-bit mode or |
| when tuning for newer processors in 32-bit mode. When 0 is used, the no-op |
| instruction size limit is set to the maximum supported size. |
| |
| @node Octa |
| @section @code{.octa @var{bignums}} |
| |
| @c FIXME: double size emitted for "octa" on some? Or warn? |
| @cindex @code{octa} directive |
| @cindex integer, 16-byte |
| @cindex sixteen byte integer |
| This directive expects zero or more bignums, separated by commas. For each |
| bignum, it emits a 16-byte integer. |
| |
| The term ``octa'' comes from contexts in which a ``word'' is two bytes; |
| hence @emph{octa}-word for 16 bytes. |
| |
| @node Offset |
| @section @code{.offset @var{loc}} |
| |
| @cindex @code{offset} directive |
| Set the location counter to @var{loc} in the absolute section. @var{loc} must |
| be an absolute expression. This directive may be useful for defining |
| symbols with absolute values. Do not confuse it with the @code{.org} |
| directive. |
| |
| @node Org |
| @section @code{.org @var{new-lc} , @var{fill}} |
| |
| @cindex @code{org} directive |
| @cindex location counter, advancing |
| @cindex advancing location counter |
| @cindex current address, advancing |
| Advance the location counter of the current section to |
| @var{new-lc}. @var{new-lc} is either an absolute expression or an |
| expression with the same section as the current subsection. That is, |
| you can't use @code{.org} to cross sections: if @var{new-lc} has the |
| wrong section, the @code{.org} directive is ignored. To be compatible |
| with former assemblers, if the section of @var{new-lc} is absolute, |
| @command{@value{AS}} issues a warning, then pretends the section of @var{new-lc} |
| is the same as the current subsection. |
| |
| @code{.org} may only increase the location counter, or leave it |
| unchanged; you cannot use @code{.org} to move the location counter |
| backwards. |
| |
| @c double negative used below "not undefined" because this is a specific |
| @c reference to "undefined" (as SEG_UNKNOWN is called in this manual) |
| @c section. doc@cygnus.com 18feb91 |
| Because @command{@value{AS}} tries to assemble programs in one pass, @var{new-lc} |
| may not be undefined. If you really detest this restriction we eagerly await |
| a chance to share your improved assembler. |
| |
| Beware that the origin is relative to the start of the section, not |
| to the start of the subsection. This is compatible with other |
| people's assemblers. |
| |
| When the location counter (of the current subsection) is advanced, the |
| intervening bytes are filled with @var{fill} which should be an |
| absolute expression. If the comma and @var{fill} are omitted, |
| @var{fill} defaults to zero. |
| |
| @node P2align |
| @section @code{.p2align[wl] [@var{abs-expr}[, @var{abs-expr}[, @var{abs-expr}]]]} |
| |
| @cindex padding the location counter given a power of two |
| @cindex @code{p2align} directive |
| Pad the location counter (in the current subsection) to a particular |
| storage boundary. The first expression (which must be absolute) is the |
| number of low-order zero bits the location counter must have after |
| advancement. For example @samp{.p2align 3} advances the location |
| counter until it is a multiple of 8. If the location counter is already a |
| multiple of 8, no change is needed. If the expression is omitted then a |
| default value of 0 is used, effectively disabling alignment requirements. |
| |
| The second expression (also absolute) gives the fill value to be stored in the |
| padding bytes. It (and the comma) may be omitted. If it is omitted, the |
| padding bytes are normally zero. However, on most systems, if the section is |
| marked as containing code and the fill value is omitted, the space is filled |
| with no-op instructions. |
| |
| The third expression is also absolute, and is also optional. If it is present, |
| it is the maximum number of bytes that should be skipped by this alignment |
| directive. If doing the alignment would require skipping more bytes than the |
| specified maximum, then the alignment is not done at all. You can omit the |
| fill value (the second argument) entirely by simply using two commas after the |
| required alignment; this can be useful if you want the alignment to be filled |
| with no-op instructions when appropriate. |
| |
| @cindex @code{p2alignw} directive |
| @cindex @code{p2alignl} directive |
| The @code{.p2alignw} and @code{.p2alignl} directives are variants of the |
| @code{.p2align} directive. The @code{.p2alignw} directive treats the fill |
| pattern as a two byte word value. The @code{.p2alignl} directives treats the |
| fill pattern as a four byte longword value. For example, @code{.p2alignw |
| 2,0x368d} will align to a multiple of 4. If it skips two bytes, they will be |
| filled in with the value 0x368d (the exact placement of the bytes depends upon |
| the endianness of the processor). If it skips 1 or 3 bytes, the fill value is |
| undefined. |
| |
| @ifset ELF |
| @node PopSection |
| @section @code{.popsection} |
| |
| @cindex @code{popsection} directive |
| @cindex Section Stack |
| This is one of the ELF section stack manipulation directives. The others are |
| @code{.section} (@pxref{Section}), @code{.subsection} (@pxref{SubSection}), |
| @code{.pushsection} (@pxref{PushSection}), and @code{.previous} |
| (@pxref{Previous}). |
| |
| This directive replaces the current section (and subsection) with the top |
| section (and subsection) on the section stack. This section is popped off the |
| stack. |
| @end ifset |
| |
| @ifset ELF |
| @node Previous |
| @section @code{.previous} |
| |
| @cindex @code{previous} directive |
| @cindex Section Stack |
| This is one of the ELF section stack manipulation directives. The others are |
| @code{.section} (@pxref{Section}), @code{.subsection} (@pxref{SubSection}), |
| @code{.pushsection} (@pxref{PushSection}), and @code{.popsection} |
| (@pxref{PopSection}). |
| |
| This directive swaps the current section (and subsection) with most recently |
| referenced section/subsection pair prior to this one. Multiple |
| @code{.previous} directives in a row will flip between two sections (and their |
| subsections). For example: |
| |
| @smallexample |
| .section A |
| .subsection 1 |
| .word 0x1234 |
| .subsection 2 |
| .word 0x5678 |
| .previous |
| .word 0x9abc |
| @end smallexample |
| |
| Will place 0x1234 and 0x9abc into subsection 1 and 0x5678 into subsection 2 of |
| section A. Whilst: |
| |
| @smallexample |
| .section A |
| .subsection 1 |
| # Now in section A subsection 1 |
| .word 0x1234 |
| .section B |
| .subsection 0 |
| # Now in section B subsection 0 |
| .word 0x5678 |
| .subsection 1 |
| # Now in section B subsection 1 |
| .word 0x9abc |
| .previous |
| # Now in section B subsection 0 |
| .word 0xdef0 |
| @end smallexample |
| |
| Will place 0x1234 into section A, 0x5678 and 0xdef0 into subsection 0 of |
| section B and 0x9abc into subsection 1 of section B. |
| |
| In terms of the section stack, this directive swaps the current section with |
| the top section on the section stack. |
| @end ifset |
| |
| @node Print |
| @section @code{.print @var{string}} |
| |
| @cindex @code{print} directive |
| @command{@value{AS}} will print @var{string} on the standard output during |
| assembly. You must put @var{string} in double quotes. |
| |
| @ifset ELF |
| @node Protected |
| @section @code{.protected @var{names}} |
| |
| @cindex @code{protected} directive |
| @cindex visibility |
| This is one of the ELF visibility directives. The other two are |
| @code{.hidden} (@pxref{Hidden}) and @code{.internal} (@pxref{Internal}). |
| |
| This directive overrides the named symbols default visibility (which is set by |
| their binding: local, global or weak). The directive sets the visibility to |
| @code{protected} which means that any references to the symbols from within the |
| components that defines them must be resolved to the definition in that |
| component, even if a definition in another component would normally preempt |
| this. |
| @end ifset |
| |
| @node Psize |
| @section @code{.psize @var{lines} , @var{columns}} |
| |
| @cindex @code{psize} directive |
| @cindex listing control: paper size |
| @cindex paper size, for listings |
| Use this directive to declare the number of lines---and, optionally, the |
| number of columns---to use for each page, when generating listings. |
| |
| If you do not use @code{.psize}, listings use a default line-count |
| of 60. You may omit the comma and @var{columns} specification; the |
| default width is 200 columns. |
| |
| @command{@value{AS}} generates formfeeds whenever the specified number of |
| lines is exceeded (or whenever you explicitly request one, using |
| @code{.eject}). |
| |
| If you specify @var{lines} as @code{0}, no formfeeds are generated save |
| those explicitly specified with @code{.eject}. |
| |
| @node Purgem |
| @section @code{.purgem @var{name}} |
| |
| @cindex @code{purgem} directive |
| Undefine the macro @var{name}, so that later uses of the string will not be |
| expanded. @xref{Macro}. |
| |
| @ifset ELF |
| @node PushSection |
| @section @code{.pushsection @var{name} [, @var{subsection}] [, "@var{flags}"[, @@@var{type}[,@var{arguments}]]]} |
| |
| @cindex @code{pushsection} directive |
| @cindex Section Stack |
| This is one of the ELF section stack manipulation directives. The others are |
| @code{.section} (@pxref{Section}), @code{.subsection} (@pxref{SubSection}), |
| @code{.popsection} (@pxref{PopSection}), and @code{.previous} |
| (@pxref{Previous}). |
| |
| This directive pushes the current section (and subsection) onto the |
| top of the section stack, and then replaces the current section and |
| subsection with @code{name} and @code{subsection}. The optional |
| @code{flags}, @code{type} and @code{arguments} are treated the same |
| as in the @code{.section} (@pxref{Section}) directive. |
| @end ifset |
| |
| @node Quad |
| @section @code{.quad @var{bignums}} |
| |
| @cindex @code{quad} directive |
| @code{.quad} expects zero or more bignums, separated by commas. For |
| each bignum, it emits |
| @ifclear bignum-16 |
| an 8-byte integer. If the bignum won't fit in 8 bytes, it prints a |
| warning message; and just takes the lowest order 8 bytes of the bignum. |
| @cindex eight-byte integer |
| @cindex integer, 8-byte |
| |
| The term ``quad'' comes from contexts in which a ``word'' is two bytes; |
| hence @emph{quad}-word for 8 bytes. |
| @end ifclear |
| @ifset bignum-16 |
| a 16-byte integer. If the bignum won't fit in 16 bytes, it prints a |
| warning message; and just takes the lowest order 16 bytes of the bignum. |
| @cindex sixteen-byte integer |
| @cindex integer, 16-byte |
| @end ifset |
| |
| @node Reloc |
| @section @code{.reloc @var{offset}, @var{reloc_name}[, @var{expression}]} |
| |
| @cindex @code{reloc} directive |
| Generate a relocation at @var{offset} of type @var{reloc_name} with value |
| @var{expression}. If @var{offset} is a number, the relocation is generated in |
| the current section. If @var{offset} is an expression that resolves to a |
| symbol plus offset, the relocation is generated in the given symbol's section. |
| @var{expression}, if present, must resolve to a symbol plus addend or to an |
| absolute value, but note that not all targets support an addend. e.g. ELF REL |
| targets such as i386 store an addend in the section contents rather than in the |
| relocation. This low level interface does not support addends stored in the |
| section. |
| |
| @node Rept |
| @section @code{.rept @var{count}} |
| |
| @cindex @code{rept} directive |
| Repeat the sequence of lines between the @code{.rept} directive and the next |
| @code{.endr} directive @var{count} times. |
| |
| For example, assembling |
| |
| @example |
| .rept 3 |
| .long 0 |
| .endr |
| @end example |
| |
| is equivalent to assembling |
| |
| @example |
| .long 0 |
| .long 0 |
| .long 0 |
| @end example |
| |
| A count of zero is allowed, but nothing is generated. Negative counts are not |
| allowed and if encountered will be treated as if they were zero. |
| |
| @node Sbttl |
| @section @code{.sbttl "@var{subheading}"} |
| |
| @cindex @code{sbttl} directive |
| @cindex subtitles for listings |
| @cindex listing control: subtitle |
| Use @var{subheading} as the title (third line, immediately after the |
| title line) when generating assembly listings. |
| |
| This directive affects subsequent pages, as well as the current page if |
| it appears within ten lines of the top of a page. |
| |
| @ifset COFF |
| @node Scl |
| @section @code{.scl @var{class}} |
| |
| @cindex @code{scl} directive |
| @cindex symbol storage class (COFF) |
| @cindex COFF symbol storage class |
| Set the storage-class value for a symbol. This directive may only be |
| used inside a @code{.def}/@code{.endef} pair. Storage class may flag |
| whether a symbol is static or external, or it may record further |
| symbolic debugging information. |
| @end ifset |
| |
| @ifset COFF-ELF |
| @node Section |
| @section @code{.section @var{name}} |
| |
| @cindex named section |
| Use the @code{.section} directive to assemble the following code into a section |
| named @var{name}. |
| |
| This directive is only supported for targets that actually support arbitrarily |
| named sections; on @code{a.out} targets, for example, it is not accepted, even |
| with a standard @code{a.out} section name. |
| |
| @ifset COFF |
| @ifset ELF |
| @c only print the extra heading if both COFF and ELF are set |
| @subheading COFF Version |
| @end ifset |
| |
| @cindex @code{section} directive (COFF version) |
| For COFF targets, the @code{.section} directive is used in one of the following |
| ways: |
| |
| @smallexample |
| .section @var{name}[, "@var{flags}"] |
| .section @var{name}[, @var{subsection}] |
| @end smallexample |
| |
| If the optional argument is quoted, it is taken as flags to use for the |
| section. Each flag is a single character. The following flags are recognized: |
| |
| @table @code |
| @item b |
| bss section (uninitialized data) |
| @item n |
| section is not loaded |
| @item w |
| writable section |
| @item d |
| data section |
| @item e |
| exclude section from linking |
| @item r |
| read-only section |
| @item x |
| executable section |
| @item s |
| shared section (meaningful for PE targets) |
| @item a |
| ignored. (For compatibility with the ELF version) |
| @item y |
| section is not readable (meaningful for PE targets) |
| @item 0-9 |
| single-digit power-of-two section alignment (GNU extension) |
| @end table |
| |
| If no flags are specified, the default flags depend upon the section name. If |
| the section name is not recognized, the default will be for the section to be |
| loaded and writable. Note the @code{n} and @code{w} flags remove attributes |
| from the section, rather than adding them, so if they are used on their own it |
| will be as if no flags had been specified at all. |
| |
| If the optional argument to the @code{.section} directive is not quoted, it is |
| taken as a subsection number (@pxref{Sub-Sections}). |
| @end ifset |
| |
| @ifset ELF |
| @ifset COFF |
| @c only print the extra heading if both COFF and ELF are set |
| @subheading ELF Version |
| @end ifset |
| |
| @cindex Section Stack |
| This is one of the ELF section stack manipulation directives. The others are |
| @code{.subsection} (@pxref{SubSection}), @code{.pushsection} |
| (@pxref{PushSection}), @code{.popsection} (@pxref{PopSection}), and |
| @code{.previous} (@pxref{Previous}). |
| |
| @cindex @code{section} directive (ELF version) |
| For ELF targets, the @code{.section} directive is used like this: |
| |
| @smallexample |
| .section @var{name} [, "@var{flags}"[, @@@var{type}[,@var{flag_specific_arguments}]]] |
| @end smallexample |
| |
| @anchor{Section Name Substitutions} |
| @kindex --sectname-subst |
| @cindex section name substitution |
| If the @samp{--sectname-subst} command-line option is provided, the @var{name} |
| argument may contain a substitution sequence. Only @code{%S} is supported |
| at the moment, and substitutes the current section name. For example: |
| |
| @smallexample |
| .macro exception_code |
| .section %S.exception |
| [exception code here] |
| .previous |
| .endm |
| |
| .text |
| [code] |
| exception_code |
| [...] |
| |
| .section .init |
| [init code] |
| exception_code |
| [...] |
| @end smallexample |
| |
| The two @code{exception_code} invocations above would create the |
| @code{.text.exception} and @code{.init.exception} sections respectively. |
| This is useful e.g. to discriminate between ancillary sections that are |
| tied to setup code to be discarded after use from ancillary sections that |
| need to stay resident without having to define multiple @code{exception_code} |
| macros just for that purpose. |
| |
| The optional @var{flags} argument is a quoted string which may contain any |
| combination of the following characters: |
| |
| @table @code |
| @item a |
| section is allocatable |
| @item d |
| section is a GNU_MBIND section |
| @item e |
| section is excluded from executable and shared library. |
| @item o |
| section references a symbol defined in another section (the linked-to |
| section) in the same file. |
| @item w |
| section is writable |
| @item x |
| section is executable |
| @item M |
| section is mergeable |
| @item S |
| section contains zero terminated strings |
| @item G |
| section is a member of a section group |
| @item T |
| section is used for thread-local-storage |
| @item ? |
| section is a member of the previously-current section's group, if any |
| @item R |
| retained section (apply SHF_GNU_RETAIN to prevent linker garbage |
| collection, GNU ELF extension) |
| @item @code{<number>} |
| a numeric value indicating the bits to be set in the ELF section header's flags |
| field. Note - if one or more of the alphabetic characters described above is |
| also included in the flags field, their bit values will be ORed into the |
| resulting value. |
| @item @code{<target specific>} |
| some targets extend this list with their own flag characters |
| @end table |
| |
| Note - once a section's flags have been set they cannot be changed. There are |
| a few exceptions to this rule however. Processor and application specific |
| flags can be added to an already defined section. The @code{.interp}, |
| @code{.strtab} and @code{.symtab} sections can have the allocate flag |
| (@code{a}) set after they are initially defined, and the @code{.note-GNU-stack} |
| section may have the executable (@code{x}) flag added. Also note that the |
| @code{.attach_to_group} directive can be used to add a section to a group even |
| if the section was not originally declared to be part of that group. |
| |
| The optional @var{type} argument may contain one of the following constants: |
| |
| @table @code |
| @item @@progbits |
| section contains data |
| @item @@nobits |
| section does not contain data (i.e., section only occupies space) |
| @item @@note |
| section contains data which is used by things other than the program |
| @item @@init_array |
| section contains an array of pointers to init functions |
| @item @@fini_array |
| section contains an array of pointers to finish functions |
| @item @@preinit_array |
| section contains an array of pointers to pre-init functions |
| @item @@@code{<number>} |
| a numeric value to be set as the ELF section header's type field. |
| @item @@@code{<target specific>} |
| some targets extend this list with their own types |
| @end table |
| |
| Many targets only support the first three section types. The type may be |
| enclosed in double quotes if necessary. |
| |
| Note on targets where the @code{@@} character is the start of a comment (eg |
| ARM) then another character is used instead. For example the ARM port uses the |
| @code{%} character. |
| |
| Note - some sections, eg @code{.text} and @code{.data} are considered to be |
| special and have fixed types. Any attempt to declare them with a different |
| type will generate an error from the assembler. |
| |
| If @var{flags} contains the @code{M} symbol then the @var{type} argument must |
| be specified as well as an extra argument---@var{entsize}---like this: |
| |
| @smallexample |
| .section @var{name} , "@var{flags}"M, @@@var{type}, @var{entsize} |
| @end smallexample |
| |
| Sections with the @code{M} flag but not @code{S} flag must contain fixed size |
| constants, each @var{entsize} octets long. Sections with both @code{M} and |
| @code{S} must contain zero terminated strings where each character is |
| @var{entsize} bytes long. The linker may remove duplicates within sections with |
| the same name, same entity size and same flags. @var{entsize} must be an |
| absolute expression. For sections with both @code{M} and @code{S}, a string |
| which is a suffix of a larger string is considered a duplicate. Thus |
| @code{"def"} will be merged with @code{"abcdef"}; A reference to the first |
| @code{"def"} will be changed to a reference to @code{"abcdef"+3}. |
| |
| If @var{flags} contains the @code{o} flag, then the @var{type} argument |
| must be present along with an additional field like this: |
| |
| @smallexample |
| .section @var{name},"@var{flags}"o,@@@var{type},@var{SymbolName}|@var{SectionIndex} |
| @end smallexample |
| |
| The @var{SymbolName} field specifies the symbol name which the section |
| references. Alternatively a numeric @var{SectionIndex} can be provided. This |
| is not generally a good idea as section indicies are rarely known at assembly |
| time, but the facility is provided for testing purposes. An index of zero is |
| allowed. It indicates that the linked-to section has already been discarded. |
| |
| Note: If both the @var{M} and @var{o} flags are present, then the fields |
| for the Merge flag should come first, like this: |
| |
| @smallexample |
| .section @var{name},"@var{flags}"Mo,@@@var{type},@var{entsize},@var{SymbolName} |
| @end smallexample |
| |
| If @var{flags} contains the @code{G} symbol then the @var{type} argument must |
| be present along with an additional field like this: |
| |
| @smallexample |
| .section @var{name} , "@var{flags}"G, @@@var{type}, @var{GroupName}[, @var{linkage}] |
| @end smallexample |
| |
| The @var{GroupName} field specifies the name of the section group to which this |
| particular section belongs. The optional linkage field can contain: |
| |
| @table @code |
| @item comdat |
| indicates that only one copy of this section should be retained |
| @item .gnu.linkonce |
| an alias for comdat |
| @end table |
| |
| Note: if both the @var{M} and @var{G} flags are present then the fields for |
| the Merge flag should come first, like this: |
| |
| @smallexample |
| .section @var{name} , "@var{flags}"MG, @@@var{type}, @var{entsize}, @var{GroupName}[, @var{linkage}] |
| @end smallexample |
| |
| If both @code{o} flag and @code{G} flag are present, then the |
| @var{SymbolName} field for @code{o} comes first, like this: |
| |
| @smallexample |
| .section @var{name},"@var{flags}"oG,@@@var{type},@var{SymbolName},@var{GroupName}[,@var{linkage}] |
| @end smallexample |
| |
| If @var{flags} contains the @code{?} symbol then it may not also contain the |
| @code{G} symbol and the @var{GroupName} or @var{linkage} fields should not be |
| present. Instead, @code{?} says to consider the section that's current before |
| this directive. If that section used @code{G}, then the new section will use |
| @code{G} with those same @var{GroupName} and @var{linkage} fields implicitly. |
| If not, then the @code{?} symbol has no effect. |
| |
| The optional @var{unique,@code{<number>}} argument must come last. It |
| assigns @var{@code{<number>}} as a unique section ID to distinguish |
| different sections with the same section name like these: |
| |
| @smallexample |
| .section @var{name},"@var{flags}",@@@var{type},@var{unique,@code{<number>}} |
| .section @var{name},"@var{flags}"G,@@@var{type},@var{GroupName},[@var{linkage}],@var{unique,@code{<number>}} |
| .section @var{name},"@var{flags}"MG,@@@var{type},@var{entsize},@var{GroupName}[,@var{linkage}],@var{unique,@code{<number>}} |
| @end smallexample |
| |
| The valid values of @var{@code{<number>}} are between 0 and 4294967295. |
| |
| If no flags are specified, the default flags depend upon the section name. If |
| the section name is not recognized, the default will be for the section to have |
| none of the above flags: it will not be allocated in memory, nor writable, nor |
| executable. The section will contain data. |
| |
| For ELF targets, the assembler supports another type of @code{.section} |
| directive for compatibility with the Solaris assembler: |
| |
| @smallexample |
| .section "@var{name}"[, @var{flags}...] |
| @end smallexample |
| |
| Note that the section name is quoted. There may be a sequence of comma |
| separated flags: |
| |
| @table @code |
| @item #alloc |
| section is allocatable |
| @item #write |
| section is writable |
| @item #execinstr |
| section is executable |
| @item #exclude |
| section is excluded from executable and shared library. |
| @item #tls |
| section is used for thread local storage |
| @end table |
| |
| This directive replaces the current section and subsection. See the |
| contents of the gas testsuite directory @code{gas/testsuite/gas/elf} for |
| some examples of how this directive and the other section stack directives |
| work. |
| @end ifset |
| @end ifset |
| |
| @node Set |
| @section @code{.set @var{symbol}, @var{expression}} |
| |
| @cindex @code{set} directive |
| @cindex symbol value, setting |
| Set the value of @var{symbol} to @var{expression}. This |
| changes @var{symbol}'s value and type to conform to |
| @var{expression}. If @var{symbol} was flagged as external, it remains |
| flagged (@pxref{Symbol Attributes}). |
| |
| You may @code{.set} a symbol many times in the same assembly provided that the |
| values given to the symbol are constants. Values that are based on expressions |
| involving other symbols are allowed, but some targets may restrict this to only |
| being done once per assembly. This is because those targets do not set the |
| addresses of symbols at assembly time, but rather delay the assignment until a |
| final link is performed. This allows the linker a chance to change the code in |
| the files, changing the location of, and the relative distance between, various |
| different symbols. |
| |
| If you @code{.set} a global symbol, the value stored in the object |
| file is the last value stored into it. |
| |
| @ifset Z80 |
| On Z80 @code{set} is a real instruction, use @code{.set} or |
| @samp{@var{symbol} defl @var{expression}} instead. |
| @end ifset |
| |
| @node Short |
| @section @code{.short @var{expressions}} |
| |
| @cindex @code{short} directive |
| @ifset GENERIC |
| @code{.short} is normally the same as @samp{.word}. |
| @xref{Word,,@code{.word}}. |
| |
| In some configurations, however, @code{.short} and @code{.word} generate |
| numbers of different lengths. @xref{Machine Dependencies}. |
| @end ifset |
| @ifclear GENERIC |
| @ifset W16 |
| @code{.short} is the same as @samp{.word}. @xref{Word,,@code{.word}}. |
| @end ifset |
| @ifset W32 |
| This expects zero or more @var{expressions}, and emits |
| a 16 bit number for each. |
| @end ifset |
| @end ifclear |
| |
| @node Single |
| @section @code{.single @var{flonums}} |
| |
| @cindex @code{single} directive |
| @cindex floating point numbers (single) |
| This directive assembles zero or more flonums, separated by commas. It |
| has the same effect as @code{.float}. |
| @ifset GENERIC |
| The exact kind of floating point numbers emitted depends on how |
| @command{@value{AS}} is configured. @xref{Machine Dependencies}. |
| @end ifset |
| @ifclear GENERIC |
| @ifset IEEEFLOAT |
| On the @value{TARGET} family, @code{.single} emits 32-bit floating point |
| numbers in @sc{ieee} format. |
| @end ifset |
| @end ifclear |
| |
| @ifset COFF-ELF |
| @node Size |
| @section @code{.size} |
| |
| This directive is used to set the size associated with a symbol. |
| |
| @ifset COFF |
| @ifset ELF |
| @c only print the extra heading if both COFF and ELF are set |
| @subheading COFF Version |
| @end ifset |
| |
| @cindex @code{size} directive (COFF version) |
| For COFF targets, the @code{.size} directive is only permitted inside |
| @code{.def}/@code{.endef} pairs. It is used like this: |
| |
| @smallexample |
| .size @var{expression} |
| @end smallexample |
| |
| @end ifset |
| |
| @ifset ELF |
| @ifset COFF |
| @c only print the extra heading if both COFF and ELF are set |
| @subheading ELF Version |
| @end ifset |
| |
| @cindex @code{size} directive (ELF version) |
| For ELF targets, the @code{.size} directive is used like this: |
| |
| @smallexample |
| .size @var{name} , @var{expression} |
| @end smallexample |
| |
| This directive sets the size associated with a symbol @var{name}. |
| The size in bytes is computed from @var{expression} which can make use of label |
| arithmetic. This directive is typically used to set the size of function |
| symbols. |
| @end ifset |
| @end ifset |
| |
| @ifclear no-space-dir |
| @node Skip |
| @section @code{.skip @var{size} [,@var{fill}]} |
| |
| @cindex @code{skip} directive |
| @cindex filling memory |
| This directive emits @var{size} bytes, each of value @var{fill}. Both |
| @var{size} and @var{fill} are absolute expressions. If the comma and |
| @var{fill} are omitted, @var{fill} is assumed to be zero. This is the same as |
| @samp{.space}. |
| @end ifclear |
| |
| @node Sleb128 |
| @section @code{.sleb128 @var{expressions}} |
| |
| @cindex @code{sleb128} directive |
| @var{sleb128} stands for ``signed little endian base 128.'' This is a |
| compact, variable length representation of numbers used by the DWARF |
| symbolic debugging format. @xref{Uleb128, ,@code{.uleb128}}. |
| |
| @ifclear no-space-dir |
| @node Space |
| @section @code{.space @var{size} [,@var{fill}]} |
| |
| @cindex @code{space} directive |
| @cindex filling memory |
| This directive emits @var{size} bytes, each of value @var{fill}. Both |
| @var{size} and @var{fill} are absolute expressions. If the comma |
| and @var{fill} are omitted, @var{fill} is assumed to be zero. This is the same |
| as @samp{.skip}. |
| |
| @ifset HPPA |
| @quotation |
| @emph{Warning:} @code{.space} has a completely different meaning for HPPA |
| targets; use @code{.block} as a substitute. See @cite{HP9000 Series 800 |
| Assembly Language Reference Manual} (HP 92432-90001) for the meaning of the |
| @code{.space} directive. @xref{HPPA Directives,,HPPA Assembler Directives}, |
| for a summary. |
| @end quotation |
| @end ifset |
| @end ifclear |
| |
| @ifset have-stabs |
| @node Stab |
| @section @code{.stabd, .stabn, .stabs} |
| |
| @cindex symbolic debuggers, information for |
| @cindex @code{stab@var{x}} directives |
| There are three directives that begin @samp{.stab}. |
| All emit symbols (@pxref{Symbols}), for use by symbolic debuggers. |
| The symbols are not entered in the @command{@value{AS}} hash table: they |
| cannot be referenced elsewhere in the source file. |
| Up to five fields are required: |
| |
| @table @var |
| @item string |
| This is the symbol's name. It may contain any character except |
| @samp{\000}, so is more general than ordinary symbol names. Some |
| debuggers used to code arbitrarily complex structures into symbol names |
| using this field. |
| |
| @item type |
| An absolute expression. The symbol's type is set to the low 8 bits of |
| this expression. Any bit pattern is permitted, but @code{@value{LD}} |
| and debuggers choke on silly bit patterns. |
| |
| @item other |
| An absolute expression. The symbol's ``other'' attribute is set to the |
| low 8 bits of this expression. |
| |
| @item desc |
| An absolute expression. The symbol's descriptor is set to the low 16 |
| bits of this expression. |
| |
| @item value |
| An absolute expression which becomes the symbol's value. |
| @end table |
| |
| If a warning is detected while reading a @code{.stabd}, @code{.stabn}, |
| or @code{.stabs} statement, the symbol has probably already been created; |
| you get a half-formed symbol in your object file. This is |
| compatible with earlier assemblers! |
| |
| @table @code |
| @cindex @code{stabd} directive |
| @item .stabd @var{type} , @var{other} , @var{desc} |
| |
| The ``name'' of the symbol generated is not even an empty string. |
| It is a null pointer, for compatibility. Older assemblers used a |
| null pointer so they didn't waste space in object files with empty |
| strings. |
| |
| The symbol's value is set to the location counter, |
| relocatably. When your program is linked, the value of this symbol |
| is the address of the location counter when the @code{.stabd} was |
| assembled. |
| |
| @cindex @code{stabn} directive |
| @item .stabn @var{type} , @var{other} , @var{desc} , @var{value} |
| The name of the symbol is set to the empty string @code{""}. |
| |
| @cindex @code{stabs} directive |
| @item .stabs @var{string} , @var{type} , @var{other} , @var{desc} , @var{value} |
| All five fields are specified. |
| @end table |
| @end ifset |
| @c end have-stabs |
| |
| @node String |
| @section @code{.string} "@var{str}", @code{.string8} "@var{str}", @code{.string16} |
| "@var{str}", @code{.string32} "@var{str}", @code{.string64} "@var{str}" |
| |
| @cindex string, copying to object file |
| @cindex string8, copying to object file |
| @cindex string16, copying to object file |
| @cindex string32, copying to object file |
| @cindex string64, copying to object file |
| @cindex @code{string} directive |
| @cindex @code{string8} directive |
| @cindex @code{string16} directive |
| @cindex @code{string32} directive |
| @cindex @code{string64} directive |
| |
| Copy the characters in @var{str} to the object file. You may specify more than |
| one string to copy, separated by commas. Unless otherwise specified for a |
| particular machine, the assembler marks the end of each string with a 0 byte. |
| You can use any of the escape sequences described in @ref{Strings,,Strings}. |
| |
| The variants @code{string16}, @code{string32} and @code{string64} differ from |
| the @code{string} pseudo opcode in that each 8-bit character from @var{str} is |
| copied and expanded to 16, 32 or 64 bits respectively. The expanded characters |
| are stored in target endianness byte order. |
| |
| Example: |
| @smallexample |
| .string32 "BYE" |
| expands to: |
| .string "B\0\0\0Y\0\0\0E\0\0\0" /* On little endian targets. */ |
| .string "\0\0\0B\0\0\0Y\0\0\0E" /* On big endian targets. */ |
| @end smallexample |
| |
| |
| @node Struct |
| @section @code{.struct @var{expression}} |
| |
| @cindex @code{struct} directive |
| Switch to the absolute section, and set the section offset to @var{expression}, |
| which must be an absolute expression. You might use this as follows: |
| @smallexample |
| .struct 0 |
| field1: |
| .struct field1 + 4 |
| field2: |
| .struct field2 + 4 |
| field3: |
| @end smallexample |
| This would define the symbol @code{field1} to have the value 0, the symbol |
| @code{field2} to have the value 4, and the symbol @code{field3} to have the |
| value 8. Assembly would be left in the absolute section, and you would need to |
| use a @code{.section} directive of some sort to change to some other section |
| before further assembly. |
| |
| @ifset ELF |
| @node SubSection |
| @section @code{.subsection @var{name}} |
| |
| @cindex @code{subsection} directive |
| @cindex Section Stack |
| This is one of the ELF section stack manipulation directives. The others are |
| @code{.section} (@pxref{Section}), @code{.pushsection} (@pxref{PushSection}), |
| @code{.popsection} (@pxref{PopSection}), and @code{.previous} |
| (@pxref{Previous}). |
| |
| This directive replaces the current subsection with @code{name}. The current |
| section is not changed. The replaced subsection is put onto the section stack |
| in place of the then current top of stack subsection. |
| @end ifset |
| |
| @ifset ELF |
| @node Symver |
| @section @code{.symver} |
| @cindex @code{symver} directive |
| @cindex symbol versioning |
| @cindex versions of symbols |
| Use the @code{.symver} directive to bind symbols to specific version nodes |
| within a source file. This is only supported on ELF platforms, and is |
| typically used when assembling files to be linked into a shared library. |
| There are cases where it may make sense to use this in objects to be bound |
| into an application itself so as to override a versioned symbol from a |
| shared library. |
| |
| For ELF targets, the @code{.symver} directive can be used like this: |
| @smallexample |
| .symver @var{name}, @var{name2@@nodename}[ ,@var{visibility}] |
| @end smallexample |
| If the original symbol @var{name} is defined within the file |
| being assembled, the @code{.symver} directive effectively creates a symbol |
| alias with the name @var{name2@@nodename}, and in fact the main reason that we |
| just don't try and create a regular alias is that the @var{@@} character isn't |
| permitted in symbol names. The @var{name2} part of the name is the actual name |
| of the symbol by which it will be externally referenced. The name @var{name} |
| itself is merely a name of convenience that is used so that it is possible to |
| have definitions for multiple versions of a function within a single source |
| file, and so that the compiler can unambiguously know which version of a |
| function is being mentioned. The @var{nodename} portion of the alias should be |
| the name of a node specified in the version script supplied to the linker when |
| building a shared library. If you are attempting to override a versioned |
| symbol from a shared library, then @var{nodename} should correspond to the |
| nodename of the symbol you are trying to override. The optional argument |
| @var{visibility} updates the visibility of the original symbol. The valid |
| visibilities are @code{local}, @code{hidden}, and @code{remove}. The |
| @code{local} visibility makes the original symbol a local symbol |
| (@pxref{Local}). The @code{hidden} visibility sets the visibility of the |
| original symbol to @code{hidden} (@pxref{Hidden}). The @code{remove} |
| visibility removes the original symbol from the symbol table. If visibility |
| isn't specified, the original symbol is unchanged. |
| |
| If the symbol @var{name} is not defined within the file being assembled, all |
| references to @var{name} will be changed to @var{name2@@nodename}. If no |
| reference to @var{name} is made, @var{name2@@nodename} will be removed from the |
| symbol table. |
| |
| Another usage of the @code{.symver} directive is: |
| @smallexample |
| .symver @var{name}, @var{name2@@@@nodename} |
| @end smallexample |
| In this case, the symbol @var{name} must exist and be defined within |
| the file being assembled. It is similar to @var{name2@@nodename}. The |
| difference is @var{name2@@@@nodename} will also be used to resolve |
| references to @var{name2} by the linker. |
| |
| The third usage of the @code{.symver} directive is: |
| @smallexample |
| .symver @var{name}, @var{name2@@@@@@nodename} |
| @end smallexample |
| When @var{name} is not defined within the |
| file being assembled, it is treated as @var{name2@@nodename}. When |
| @var{name} is defined within the file being assembled, the symbol |
| name, @var{name}, will be changed to @var{name2@@@@nodename}. |
| @end ifset |
| |
| @ifset COFF |
| @node Tag |
| @section @code{.tag @var{structname}} |
| |
| @cindex COFF structure debugging |
| @cindex structure debugging, COFF |
| @cindex @code{tag} directive |
| This directive is generated by compilers to include auxiliary debugging |
| information in the symbol table. It is only permitted inside |
| @code{.def}/@code{.endef} pairs. Tags are used to link structure |
| definitions in the symbol table with instances of those structures. |
| @end ifset |
| |
| @node Text |
| @section @code{.text @var{subsection}} |
| |
| @cindex @code{text} directive |
| Tells @command{@value{AS}} to assemble the following statements onto the end of |
| the text subsection numbered @var{subsection}, which is an absolute |
| expression. If @var{subsection} is omitted, subsection number zero |
| is used. |
| |
| @node Title |
| @section @code{.title "@var{heading}"} |
| |
| @cindex @code{title} directive |
| @cindex listing control: title line |
| Use @var{heading} as the title (second line, immediately after the |
| source file name and pagenumber) when generating assembly listings. |
| |
| This directive affects subsequent pages, as well as the current page if |
| it appears within ten lines of the top of a page. |
| |
| @ifset ELF |
| @node Tls_common |
| @section @code{.tls_common @var{symbol}, @var{length}[, @var{alignment}]} |
| |
| @cindex @code{tls_common} directive |
| This directive behaves in the same way as the @code{.comm} directive |
| (@pxref{Comm}) except that @var{symbol} has type of STT_TLS instead of |
| STT_OBJECT. |
| @end ifset |
| |
| @ifset COFF-ELF |
| @node Type |
| @section @code{.type} |
| |
| This directive is used to set the type of a symbol. |
| |
| @ifset COFF |
| @ifset ELF |
| @c only print the extra heading if both COFF and ELF are set |
| @subheading COFF Version |
| @end ifset |
| |
| @cindex COFF symbol type |
| @cindex symbol type, COFF |
| @cindex @code{type} directive (COFF version) |
| For COFF targets, this directive is permitted only within |
| @code{.def}/@code{.endef} pairs. It is used like this: |
| |
| @smallexample |
| .type @var{int} |
| @end smallexample |
| |
| This records the integer @var{int} as the type attribute of a symbol table |
| entry. |
| |
| @end ifset |
| |
| @ifset ELF |
| @ifset COFF |
| @c only print the extra heading if both COFF and ELF are set |
| @subheading ELF Version |
| @end ifset |
| |
| @cindex ELF symbol type |
| @cindex symbol type, ELF |
| @cindex @code{type} directive (ELF version) |
| For ELF targets, the @code{.type} directive is used like this: |
| |
| @smallexample |
| .type @var{name} , @var{type description} |
| @end smallexample |
| |
| This sets the type of symbol @var{name} to be either a |
| function symbol or an object symbol. There are five different syntaxes |
| supported for the @var{type description} field, in order to provide |
| compatibility with various other assemblers. |
| |
| Because some of the characters used in these syntaxes (such as @samp{@@} and |
| @samp{#}) are comment characters for some architectures, some of the syntaxes |
| below do not work on all architectures. The first variant will be accepted by |
| the GNU assembler on all architectures so that variant should be used for |
| maximum portability, if you do not need to assemble your code with other |
| assemblers. |
| |
| The syntaxes supported are: |
| |
| @smallexample |
| .type <name> STT_<TYPE_IN_UPPER_CASE> |
| .type <name>,#<type> |
| .type <name>,@@<type> |
| .type <name>,%<type> |
| .type <name>,"<type>" |
| @end smallexample |
| |
| The types supported are: |
| |
| @table @gcctabopt |
| @item STT_FUNC |
| @itemx function |
| Mark the symbol as being a function name. |
| |
| @item STT_GNU_IFUNC |
| @itemx gnu_indirect_function |
| Mark the symbol as an indirect function when evaluated during reloc |
| processing. (This is only supported on assemblers targeting GNU systems). |
| |
| @item STT_OBJECT |
| @itemx object |
| Mark the symbol as being a data object. |
| |
| @item STT_TLS |
| @itemx tls_object |
| Mark the symbol as being a thread-local data object. |
| |
| @item STT_COMMON |
| @itemx common |
| Mark the symbol as being a common data object. |
| |
| @item STT_NOTYPE |
| @itemx notype |
| Does not mark the symbol in any way. It is supported just for completeness. |
| |
| @item gnu_unique_object |
| Marks the symbol as being a globally unique data object. The dynamic linker |
| will make sure that in the entire process there is just one symbol with this |
| name and type in use. (This is only supported on assemblers targeting GNU |
| systems). |
| |
| @end table |
| |
| Changing between incompatible types other than from/to STT_NOTYPE will |
| result in a diagnostic. An intermediate change to STT_NOTYPE will silence |
| this. |
| |
| Note: Some targets support extra types in addition to those listed above. |
| |
| @end ifset |
| @end ifset |
| |
| @node Uleb128 |
| @section @code{.uleb128 @var{expressions}} |
| |
| @cindex @code{uleb128} directive |
| @var{uleb128} stands for ``unsigned little endian base 128.'' This is a |
| compact, variable length representation of numbers used by the DWARF |
| symbolic debugging format. @xref{Sleb128, ,@code{.sleb128}}. |
| |
| @ifset COFF |
| @node Val |
| @section @code{.val @var{addr}} |
| |
| @cindex @code{val} directive |
| @cindex COFF value attribute |
| @cindex value attribute, COFF |
| This directive, permitted only within @code{.def}/@code{.endef} pairs, |
| records the address @var{addr} as the value attribute of a symbol table |
| entry. |
| @end ifset |
| |
| @ifset ELF |
| @node Version |
| @section @code{.version "@var{string}"} |
| |
| @cindex @code{version} directive |
| This directive creates a @code{.note} section and places into it an ELF |
| formatted note of type NT_VERSION. The note's name is set to @code{string}. |
| @end ifset |
| |
| @ifset ELF |
| @node VTableEntry |
| @section @code{.vtable_entry @var{table}, @var{offset}} |
| |
| @cindex @code{vtable_entry} directive |
| This directive finds or creates a symbol @code{table} and creates a |
| @code{VTABLE_ENTRY} relocation for it with an addend of @code{offset}. |
| |
| @node VTableInherit |
| @section @code{.vtable_inherit @var{child}, @var{parent}} |
| |
| @cindex @code{vtable_inherit} directive |
| This directive finds the symbol @code{child} and finds or creates the symbol |
| @code{parent} and then creates a @code{VTABLE_INHERIT} relocation for the |
| parent whose addend is the value of the child symbol. As a special case the |
| parent name of @code{0} is treated as referring to the @code{*ABS*} section. |
| @end ifset |
| |
| @node Warning |
| @section @code{.warning "@var{string}"} |
| @cindex warning directive |
| Similar to the directive @code{.error} |
| (@pxref{Error,,@code{.error "@var{string}"}}), but just emits a warning. |
| |
| @node Weak |
| @section @code{.weak @var{names}} |
| |
| @cindex @code{weak} directive |
| This directive sets the weak attribute on the comma separated list of symbol |
| @code{names}. If the symbols do not already exist, they will be created. |
| |
| On COFF targets other than PE, weak symbols are a GNU extension. This |
| directive sets the weak attribute on the comma separated list of symbol |
| @code{names}. If the symbols do not already exist, they will be created. |
| |
| On the PE target, weak symbols are supported natively as weak aliases. |
| When a weak symbol is created that is not an alias, GAS creates an |
| alternate symbol to hold the default value. |
| |
| @node Weakref |
| @section @code{.weakref @var{alias}, @var{target}} |
| |
| @cindex @code{weakref} directive |
| This directive creates an alias to the target symbol that enables the symbol to |
| be referenced with weak-symbol semantics, but without actually making it weak. |
| If direct references or definitions of the symbol are present, then the symbol |
| will not be weak, but if all references to it are through weak references, the |
| symbol will be marked as weak in the symbol table. |
| |
| The effect is equivalent to moving all references to the alias to a separate |
| assembly source file, renaming the alias to the symbol in it, declaring the |
| symbol as weak there, and running a reloadable link to merge the object files |
| resulting from the assembly of the new source file and the old source file that |
| had the references to the alias removed. |
| |
| The alias itself never makes to the symbol table, and is entirely handled |
| within the assembler. |
| |
| @node Word |
| @section @code{.word @var{expressions}} |
| |
| @cindex @code{word} directive |
| This directive expects zero or more @var{expressions}, of any section, |
| separated by commas. |
| @ifclear GENERIC |
| @ifset W32 |
| For each expression, @command{@value{AS}} emits a 32-bit number. |
| @end ifset |
| @ifset W16 |
| For each expression, @command{@value{AS}} emits a 16-bit number. |
| @end ifset |
| @end ifclear |
| @ifset GENERIC |
| |
| The size of the number emitted, and its byte order, |
| depend on what target computer the assembly is for. |
| @end ifset |
| |
| @c on sparc the "special treatment to support compilers" doesn't |
| @c happen---32-bit addressability, period; no long/short jumps. |
| @ifset DIFF-TBL-KLUGE |
| @cindex difference tables altered |
| @cindex altered difference tables |
| @quotation |
| @emph{Warning: Special Treatment to support Compilers} |
| @end quotation |
| |
| @ifset GENERIC |
| Machines with a 32-bit address space, but that do less than 32-bit |
| addressing, require the following special treatment. If the machine of |
| interest to you does 32-bit addressing (or doesn't require it; |
| @pxref{Machine Dependencies}), you can ignore this issue. |
| |
| @end ifset |
| In order to assemble compiler output into something that works, |
| @command{@value{AS}} occasionally does strange things to @samp{.word} directives. |
| Directives of the form @samp{.word sym1-sym2} are often emitted by |
| compilers as part of jump tables. Therefore, when @command{@value{AS}} assembles a |
| directive of the form @samp{.word sym1-sym2}, and the difference between |
| @code{sym1} and @code{sym2} does not fit in 16 bits, @command{@value{AS}} |
| creates a @dfn{secondary jump table}, immediately before the next label. |
| This secondary jump table is preceded by a short-jump to the |
| first byte after the secondary table. This short-jump prevents the flow |
| of control from accidentally falling into the new table. Inside the |
| table is a long-jump to @code{sym2}. The original @samp{.word} |
| contains @code{sym1} minus the address of the long-jump to |
| @code{sym2}. |
| |
| If there were several occurrences of @samp{.word sym1-sym2} before the |
| secondary jump table, all of them are adjusted. If there was a |
| @samp{.word sym3-sym4}, that also did not fit in sixteen bits, a |
| long-jump to @code{sym4} is included in the secondary jump table, |
| and the @code{.word} directives are adjusted to contain @code{sym3} |
| minus the address of the long-jump to @code{sym4}; and so on, for as many |
| entries in the original jump table as necessary. |
| |
| @ifset INTERNALS |
| @emph{This feature may be disabled by compiling @command{@value{AS}} with the |
| @samp{-DWORKING_DOT_WORD} option.} This feature is likely to confuse |
| assembly language programmers. |
| @end ifset |
| @end ifset |
| @c end DIFF-TBL-KLUGE |
| |
| @ifclear no-space-dir |
| @node Zero |
| @section @code{.zero @var{size}} |
| |
| @cindex @code{zero} directive |
| @cindex filling memory with zero bytes |
| This directive emits @var{size} 0-valued bytes. @var{size} must be an absolute |
| expression. This directive is actually an alias for the @samp{.skip} directive |
| so it can take an optional second argument of the value to store in the bytes |
| instead of zero. Using @samp{.zero} in this way would be confusing however. |
| @end ifclear |
| |
| @node 2byte |
| @section @code{.2byte @var{expression} [, @var{expression}]*} |
| @cindex @code{2byte} directive |
| @cindex two-byte integer |
| @cindex integer, 2-byte |
| |
| This directive expects zero or more expressions, separated by commas. If there |
| are no expressions then the directive does nothing. Otherwise each expression |
| is evaluated in turn and placed in the next two bytes of the current output |
| section, using the endian model of the target. If an expression will not fit |
| in two bytes, a warning message is displayed and the least significant two |
| bytes of the expression's value are used. If an expression cannot be evaluated |
| at assembly time then relocations will be generated in order to compute the |
| value at link time. |
| |
| This directive does not apply any alignment before or after inserting the |
| values. As a result of this, if relocations are generated, they may be |
| different from those used for inserting values with a guaranteed alignment. |
| |
| @node 4byte |
| @section @code{.4byte @var{expression} [, @var{expression}]*} |
| @cindex @code{4byte} directive |
| @cindex four-byte integer |
| @cindex integer, 4-byte |
| |
| Like the @option{.2byte} directive, except that it inserts unaligned, four byte |
| long values into the output. |
| |
| @node 8byte |
| @section @code{.8byte @var{expression} [, @var{expression}]*} |
| @cindex @code{8byte} directive |
| @cindex eight-byte integer |
| @cindex integer, 8-byte |
| |
| Like the @option{.2byte} directive, except that it inserts unaligned, eight |
| byte long bignum values into the output. |
| |
| @node Deprecated |
| @section Deprecated Directives |
| |
| @cindex deprecated directives |
| @cindex obsolescent directives |
| One day these directives won't work. |
| They are included for compatibility with older assemblers. |
| @table @t |
| @item .abort |
| @item .line |
| @end table |
| |
| @ifset ELF |
| @node Object Attributes |
| @chapter Object Attributes |
| @cindex object attributes |
| |
| @command{@value{AS}} assembles source files written for a specific architecture |
| into object files for that architecture. But not all object files are alike. |
| Many architectures support incompatible variations. For instance, floating |
| point arguments might be passed in floating point registers if the object file |
| requires hardware floating point support---or floating point arguments might be |
| passed in integer registers if the object file supports processors with no |
| hardware floating point unit. Or, if two objects are built for different |
| generations of the same architecture, the combination may require the |
| newer generation at run-time. |
| |
| This information is useful during and after linking. At link time, |
| @command{@value{LD}} can warn about incompatible object files. After link |
| time, tools like @command{gdb} can use it to process the linked file |
| correctly. |
| |
| Compatibility information is recorded as a series of object attributes. Each |
| attribute has a @dfn{vendor}, @dfn{tag}, and @dfn{value}. The vendor is a |
| string, and indicates who sets the meaning of the tag. The tag is an integer, |
| and indicates what property the attribute describes. The value may be a string |
| or an integer, and indicates how the property affects this object. Missing |
| attributes are the same as attributes with a zero value or empty string value. |
| |
| Object attributes were developed as part of the ABI for the ARM Architecture. |
| The file format is documented in @cite{ELF for the ARM Architecture}. |
| |
| @menu |
| * GNU Object Attributes:: @sc{gnu} Object Attributes |
| * Defining New Object Attributes:: Defining New Object Attributes |
| @end menu |
| |
| @node GNU Object Attributes |
| @section @sc{gnu} Object Attributes |
| |
| The @code{.gnu_attribute} directive records an object attribute |
| with vendor @samp{gnu}. |
| |
| Except for @samp{Tag_compatibility}, which has both an integer and a string for |
| its value, @sc{gnu} attributes have a string value if the tag number is odd and |
| an integer value if the tag number is even. The second bit (@code{@var{tag} & |
| 2} is set for architecture-independent attributes and clear for |
| architecture-dependent ones. |
| |
| @subsection Common @sc{gnu} attributes |
| |
| These attributes are valid on all architectures. |
| |
| @table @r |
| @item Tag_compatibility (32) |
| The compatibility attribute takes an integer flag value and a vendor name. If |
| the flag value is 0, the file is compatible with other toolchains. If it is 1, |
| then the file is only compatible with the named toolchain. If it is greater |
| than 1, the file can only be processed by other toolchains under some private |
| arrangement indicated by the flag value and the vendor name. |
| @end table |
| |
| @subsection M680x0 Attributes |
| |
| @table @r |
| @item Tag_GNU_M68K_ABI_FP (4) |
| The floating-point ABI used by this object file. The value will be: |
| |
| @itemize @bullet |
| @item |
| 0 for files not affected by the floating-point ABI. |
| @item |
| 1 for files using double-precision hardware floating-point ABI. |
| @item |
| 2 for files using the software floating-point ABI. |
| @end itemize |
| @end table |
| |
| @subsection MIPS Attributes |
| |
| @table @r |
| @item Tag_GNU_MIPS_ABI_FP (4) |
| The floating-point ABI used by this object file. The value will be: |
| |
| @itemize @bullet |
| @item |
| 0 for files not affected by the floating-point ABI. |
| @item |
| 1 for files using the hardware floating-point ABI with a standard |
| double-precision FPU. |
| @item |
| 2 for files using the hardware floating-point ABI with a single-precision FPU. |
| @item |
| 3 for files using the software floating-point ABI. |
| @item |
| 4 for files using the deprecated hardware floating-point ABI which used 64-bit |
| floating-point registers, 32-bit general-purpose registers and increased the |
| number of callee-saved floating-point registers. |
| @item |
| 5 for files using the hardware floating-point ABI with a double-precision FPU |
| with either 32-bit or 64-bit floating-point registers and 32-bit |
| general-purpose registers. |
| @item |
| 6 for files using the hardware floating-point ABI with 64-bit floating-point |
| registers and 32-bit general-purpose registers. |
| @item |
| 7 for files using the hardware floating-point ABI with 64-bit floating-point |
| registers, 32-bit general-purpose registers and a rule that forbids the |
| direct use of odd-numbered single-precision floating-point registers. |
| @end itemize |
| @end table |
| |
| @subsection PowerPC Attributes |
| |
| @table @r |
| @item Tag_GNU_Power_ABI_FP (4) |
| The floating-point ABI used by this object file. The value will be: |
| |
| @itemize @bullet |
| @item |
| 0 for files not affected by the floating-point ABI. |
| @item |
| 1 for files using double-precision hardware floating-point ABI. |
| @item |
| 2 for files using the software floating-point ABI. |
| @item |
| 3 for files using single-precision hardware floating-point ABI. |
| @end itemize |
| |
| @item Tag_GNU_Power_ABI_Vector (8) |
| The vector ABI used by this object file. The value will be: |
| |
| @itemize @bullet |
| @item |
| 0 for files not affected by the vector ABI. |
| @item |
| 1 for files using general purpose registers to pass vectors. |
| @item |
| 2 for files using AltiVec registers to pass vectors. |
| @item |
| 3 for files using SPE registers to pass vectors. |
| @end itemize |
| @end table |
| |
| @subsection IBM z Systems Attributes |
| |
| @table @r |
| @item Tag_GNU_S390_ABI_Vector (8) |
| The vector ABI used by this object file. The value will be: |
| |
| @itemize @bullet |
| @item |
| 0 for files not affected by the vector ABI. |
| @item |
| 1 for files using software vector ABI. |
| @item |
| 2 for files using hardware vector ABI. |
| @end itemize |
| @end table |
| |
| @subsection MSP430 Attributes |
| |
| @table @r |
| @item Tag_GNU_MSP430_Data_Region (4) |
| The data region used by this object file. The value will be: |
| |
| @itemize @bullet |
| @item |
| 0 for files not using the large memory model. |
| @item |
| 1 for files which have been compiled with the condition that all |
| data is in the lower memory region, i.e. below address 0x10000. |
| @item |
| 2 for files which allow data to be placed in the full 20-bit memory range. |
| @end itemize |
| @end table |
| |
| @node Defining New Object Attributes |
| @section Defining New Object Attributes |
| |
| If you want to define a new @sc{gnu} object attribute, here are the places you |
| will need to modify. New attributes should be discussed on the @samp{binutils} |
| mailing list. |
| |
| @itemize @bullet |
| @item |
| This manual, which is the official register of attributes. |
| @item |
| The header for your architecture @file{include/elf}, to define the tag. |
| @item |
| The @file{bfd} support file for your architecture, to merge the attribute |
| and issue any appropriate link warnings. |
| @item |
| Test cases in @file{ld/testsuite} for merging and link warnings. |
| @item |
| @file{binutils/readelf.c} to display your attribute. |
| @item |
| GCC, if you want the compiler to mark the attribute automatically. |
| @end itemize |
| |
| @end ifset |
| |
| @ifset GENERIC |
| @node Machine Dependencies |
| @chapter Machine Dependent Features |
| |
| @cindex machine dependencies |
| The machine instruction sets are (almost by definition) different on |
| each machine where @command{@value{AS}} runs. Floating point representations |
| vary as well, and @command{@value{AS}} often supports a few additional |
| directives or command-line options for compatibility with other |
| assemblers on a particular platform. Finally, some versions of |
| @command{@value{AS}} support special pseudo-instructions for branch |
| optimization. |
| |
| This chapter discusses most of these differences, though it does not |
| include details on any machine's instruction set. For details on that |
| subject, see the hardware manufacturer's manual. |
| |
| @menu |
| @ifset AARCH64 |
| * AArch64-Dependent:: AArch64 Dependent Features |
| @end ifset |
| @ifset ALPHA |
| * Alpha-Dependent:: Alpha Dependent Features |
| @end ifset |
| @ifset ARC |
| * ARC-Dependent:: ARC Dependent Features |
| @end ifset |
| @ifset ARM |
| * ARM-Dependent:: ARM Dependent Features |
| @end ifset |
| @ifset AVR |
| * AVR-Dependent:: AVR Dependent Features |
| @end ifset |
| @ifset Blackfin |
| * Blackfin-Dependent:: Blackfin Dependent Features |
| @end ifset |
| @ifset BPF |
| * BPF-Dependent:: BPF Dependent Features |
| @end ifset |
| @ifset CR16 |
| * CR16-Dependent:: CR16 Dependent Features |
| @end ifset |
| @ifset CRIS |
| * CRIS-Dependent:: CRIS Dependent Features |
| @end ifset |
| @ifset CSKY |
| * C-SKY-Dependent:: C-SKY Dependent Features |
| @end ifset |
| @ifset D10V |
| * D10V-Dependent:: D10V Dependent Features |
| @end ifset |
| @ifset D30V |
| * D30V-Dependent:: D30V Dependent Features |
| @end ifset |
| @ifset EPIPHANY |
| * Epiphany-Dependent:: EPIPHANY Dependent Features |
| @end ifset |
| @ifset H8/300 |
| * H8/300-Dependent:: Renesas H8/300 Dependent Features |
| @end ifset |
| @ifset HPPA |
| * HPPA-Dependent:: HPPA Dependent Features |
| @end ifset |
| @ifset I80386 |
| * i386-Dependent:: Intel 80386 and AMD x86-64 Dependent Features |
| @end ifset |
| @ifset IA64 |
| * IA-64-Dependent:: Intel IA-64 Dependent Features |
| @end ifset |
| @ifset IP2K |
| * IP2K-Dependent:: IP2K Dependent Features |
| @end ifset |
| @ifset LM32 |
| * LM32-Dependent:: LM32 Dependent Features |
| @end ifset |
| @ifset M32C |
| * M32C-Dependent:: M32C Dependent Features |
| @end ifset |
| @ifset M32R |
| * M32R-Dependent:: M32R Dependent Features |
| @end ifset |
| @ifset M680X0 |
| * M68K-Dependent:: M680x0 Dependent Features |
| @end ifset |
| @ifset M68HC11 |
| * M68HC11-Dependent:: M68HC11 and 68HC12 Dependent Features |
| @end ifset |
| @ifset S12Z |
| * S12Z-Dependent:: S12Z Dependent Features |
| @end ifset |
| @ifset METAG |
| * Meta-Dependent :: Meta Dependent Features |
| @end ifset |
| @ifset MICROBLAZE |
| * MicroBlaze-Dependent:: MICROBLAZE Dependent Features |
| @end ifset |
| @ifset MIPS |
| * MIPS-Dependent:: MIPS Dependent Features |
| @end ifset |
| @ifset MMIX |
| * MMIX-Dependent:: MMIX Dependent Features |
| @end ifset |
| @ifset MSP430 |
| * MSP430-Dependent:: MSP430 Dependent Features |
| @end ifset |
| @ifset NDS32 |
| * NDS32-Dependent:: Andes NDS32 Dependent Features |
| @end ifset |
| @ifset NIOSII |
| * NiosII-Dependent:: Altera Nios II Dependent Features |
| @end ifset |
| @ifset NS32K |
| * NS32K-Dependent:: NS32K Dependent Features |
| @end ifset |
| @ifset OPENRISC |
| * OpenRISC-Dependent:: OpenRISC 1000 Features |
| @end ifset |
| @ifset PDP11 |
| * PDP-11-Dependent:: PDP-11 Dependent Features |
| @end ifset |
| @ifset PJ |
| * PJ-Dependent:: picoJava Dependent Features |
| @end ifset |
| @ifset PPC |
| * PPC-Dependent:: PowerPC Dependent Features |
| @end ifset |
| @ifset PRU |
| * PRU-Dependent:: PRU Dependent Features |
| @end ifset |
| @ifset RISCV |
| * RISC-V-Dependent:: RISC-V Dependent Features |
| @end ifset |
| @ifset RL78 |
| * RL78-Dependent:: RL78 Dependent Features |
| @end ifset |
| @ifset RX |
| * RX-Dependent:: RX Dependent Features |
| @end ifset |
| @ifset S390 |
| * S/390-Dependent:: IBM S/390 Dependent Features |
| @end ifset |
| @ifset SCORE |
| * SCORE-Dependent:: SCORE Dependent Features |
| @end ifset |
| @ifset SH |
| * SH-Dependent:: Renesas / SuperH SH Dependent Features |
| @end ifset |
| @ifset SPARC |
| * Sparc-Dependent:: SPARC Dependent Features |
| @end ifset |
| @ifset TIC54X |
| * TIC54X-Dependent:: TI TMS320C54x Dependent Features |
| @end ifset |
| @ifset TIC6X |
| * TIC6X-Dependent :: TI TMS320C6x Dependent Features |
| @end ifset |
| @ifset TILEGX |
| * TILE-Gx-Dependent :: Tilera TILE-Gx Dependent Features |
| @end ifset |
| @ifset TILEPRO |
| * TILEPro-Dependent :: Tilera TILEPro Dependent Features |
| @end ifset |
| @ifset V850 |
| * V850-Dependent:: V850 Dependent Features |
| @end ifset |
| @ifset VAX |
| * Vax-Dependent:: VAX Dependent Features |
| @end ifset |
| @ifset VISIUM |
| * Visium-Dependent:: Visium Dependent Features |
| @end ifset |
| @ifset WASM32 |
| * WebAssembly-Dependent:: WebAssembly Dependent Features |
| @end ifset |
| @ifset XGATE |
| * XGATE-Dependent:: XGATE Dependent Features |
| @end ifset |
| @ifset XSTORMY16 |
| * XSTORMY16-Dependent:: XStormy16 Dependent Features |
| @end ifset |
| @ifset XTENSA |
| * Xtensa-Dependent:: Xtensa Dependent Features |
| @end ifset |
| @ifset Z80 |
| * Z80-Dependent:: Z80 Dependent Features |
| @end ifset |
| @ifset Z8000 |
| * Z8000-Dependent:: Z8000 Dependent Features |
| @end ifset |
| @end menu |
| |
| @lowersections |
| @end ifset |
| |
| @c The following major nodes are *sections* in the GENERIC version, *chapters* |
| @c in single-cpu versions. This is mainly achieved by @lowersections. There is a |
| @c peculiarity: to preserve cross-references, there must be a node called |
| @c "Machine Dependencies". Hence the conditional nodenames in each |
| @c major node below. Node defaulting in makeinfo requires adjacency of |
| @c node and sectioning commands; hence the repetition of @chapter BLAH |
| @c in both conditional blocks. |
| |
| @ifset AARCH64 |
| @include c-aarch64.texi |
| @end ifset |
| |
| @ifset ALPHA |
| @include c-alpha.texi |
| @end ifset |
| |
| @ifset ARC |
| @include c-arc.texi |
| @end ifset |
| |
| @ifset ARM |
| @include c-arm.texi |
| @end ifset |
| |
| @ifset AVR |
| @include c-avr.texi |
| @end ifset |
| |
| @ifset Blackfin |
| @include c-bfin.texi |
| @end ifset |
| |
| @ifset BPF |
| @include c-bpf.texi |
| @end ifset |
| |
| @ifset CR16 |
| @include c-cr16.texi |
| @end ifset |
| |
| @ifset CRIS |
| @include c-cris.texi |
| @end ifset |
| |
| @ifset CSKY |
| @include c-csky.texi |
| @end ifset |
| |
| @ifset Renesas-all |
| @ifclear GENERIC |
| @node Machine Dependencies |
| @chapter Machine Dependent Features |
| |
| The machine instruction sets are different on each Renesas chip family, |
| and there are also some syntax differences among the families. This |
| chapter describes the specific @command{@value{AS}} features for each |
| family. |
| |
| @menu |
| * H8/300-Dependent:: Renesas H8/300 Dependent Features |
| * SH-Dependent:: Renesas SH Dependent Features |
| @end menu |
| @lowersections |
| @end ifclear |
| @end ifset |
| |
| @ifset D10V |
| @include c-d10v.texi |
| @end ifset |
| |
| @ifset D30V |
| @include c-d30v.texi |
| @end ifset |
| |
| @ifset EPIPHANY |
| @include c-epiphany.texi |
| @end ifset |
| |
| @ifset H8/300 |
| @include c-h8300.texi |
| @end ifset |
| |
| @ifset HPPA |
| @include c-hppa.texi |
| @end ifset |
| |
| @ifset I80386 |
| @include c-i386.texi |
| @end ifset |
| |
| @ifset IA64 |
| @include c-ia64.texi |
| @end ifset |
| |
| @ifset IP2K |
| @include c-ip2k.texi |
| @end ifset |
| |
| @ifset LM32 |
| @include c-lm32.texi |
| @end ifset |
| |
| @ifset M32C |
| @include c-m32c.texi |
| @end ifset |
| |
| @ifset M32R |
| @include c-m32r.texi |
| @end ifset |
| |
| @ifset M680X0 |
| @include c-m68k.texi |
| @end ifset |
| |
| @ifset M68HC11 |
| @include c-m68hc11.texi |
| @end ifset |
| |
| @ifset S12Z |
| @include c-s12z.texi |
| @end ifset |
| |
| @ifset METAG |
| @include c-metag.texi |
| @end ifset |
| |
| @ifset MICROBLAZE |
| @include c-microblaze.texi |
| @end ifset |
| |
| @ifset MIPS |
| @include c-mips.texi |
| @end ifset |
| |
| @ifset MMIX |
| @include c-mmix.texi |
| @end ifset |
| |
| @ifset MSP430 |
| @include c-msp430.texi |
| @end ifset |
| |
| @ifset NDS32 |
| @include c-nds32.texi |
| @end ifset |
| |
| @ifset NIOSII |
| @include c-nios2.texi |
| @end ifset |
| |
| @ifset NS32K |
| @include c-ns32k.texi |
| @end ifset |
| |
| @ifset OPENRISC |
| @include c-or1k.texi |
| @end ifset |
| |
| @ifset PDP11 |
| @include c-pdp11.texi |
| @end ifset |
| |
| @ifset PJ |
| @include c-pj.texi |
| @end ifset |
| |
| @ifset PPC |
| @include c-ppc.texi |
| @end ifset |
| |
| @ifset PRU |
| @include c-pru.texi |
| @end ifset |
| |
| @ifset RISCV |
| @include c-riscv.texi |
| @end ifset |
| |
| @ifset RL78 |
| @include c-rl78.texi |
| @end ifset |
| |
| @ifset RX |
| @include c-rx.texi |
| @end ifset |
| |
| @ifset S390 |
| @include c-s390.texi |
| @end ifset |
| |
| @ifset SCORE |
| @include c-score.texi |
| @end ifset |
| |
| @ifset SH |
| @include c-sh.texi |
| @end ifset |
| |
| @ifset SPARC |
| @include c-sparc.texi |
| @end ifset |
| |
| @ifset TIC54X |
| @include c-tic54x.texi |
| @end ifset |
| |
| @ifset TIC6X |
| @include c-tic6x.texi |
| @end ifset |
| |
| @ifset TILEGX |
| @include c-tilegx.texi |
| @end ifset |
| |
| @ifset TILEPRO |
| @include c-tilepro.texi |
| @end ifset |
| |
| @ifset V850 |
| @include c-v850.texi |
| @end ifset |
| |
| @ifset VAX |
| @include c-vax.texi |
| @end ifset |
| |
| @ifset VISIUM |
| @include c-visium.texi |
| @end ifset |
| |
| @ifset WASM32 |
| @include c-wasm32.texi |
| @end ifset |
| |
| @ifset XGATE |
| @include c-xgate.texi |
| @end ifset |
| |
| @ifset XSTORMY16 |
| @include c-xstormy16.texi |
| @end ifset |
| |
| @ifset XTENSA |
| @include c-xtensa.texi |
| @end ifset |
| |
| @ifset Z80 |
| @include c-z80.texi |
| @end ifset |
| |
| @ifset Z8000 |
| @include c-z8k.texi |
| @end ifset |
| |
| @ifset GENERIC |
| @c reverse effect of @down at top of generic Machine-Dep chapter |
| @raisesections |
| @end ifset |
| |
| @node Reporting Bugs |
| @chapter Reporting Bugs |
| @cindex bugs in assembler |
| @cindex reporting bugs in assembler |
| |
| Your bug reports play an essential role in making @command{@value{AS}} reliable. |
| |
| Reporting a bug may help you by bringing a solution to your problem, or it may |
| not. But in any case the principal function of a bug report is to help the |
| entire community by making the next version of @command{@value{AS}} work better. |
| Bug reports are your contribution to the maintenance of @command{@value{AS}}. |
| |
| In order for a bug report to serve its purpose, you must include the |
| information that enables us to fix the bug. |
| |
| @menu |
| * Bug Criteria:: Have you found a bug? |
| * Bug Reporting:: How to report bugs |
| @end menu |
| |
| @node Bug Criteria |
| @section Have You Found a Bug? |
| @cindex bug criteria |
| |
| If you are not sure whether you have found a bug, here are some guidelines: |
| |
| @itemize @bullet |
| @cindex fatal signal |
| @cindex assembler crash |
| @cindex crash of assembler |
| @item |
| If the assembler gets a fatal signal, for any input whatever, that is a |
| @command{@value{AS}} bug. Reliable assemblers never crash. |
| |
| @cindex error on valid input |
| @item |
| If @command{@value{AS}} produces an error message for valid input, that is a bug. |
| |
| @cindex invalid input |
| @item |
| If @command{@value{AS}} does not produce an error message for invalid input, that |
| is a bug. However, you should note that your idea of ``invalid input'' might |
| be our idea of ``an extension'' or ``support for traditional practice''. |
| |
| @item |
| If you are an experienced user of assemblers, your suggestions for improvement |
| of @command{@value{AS}} are welcome in any case. |
| @end itemize |
| |
| @node Bug Reporting |
| @section How to Report Bugs |
| @cindex bug reports |
| @cindex assembler bugs, reporting |
| |
| A number of companies and individuals offer support for @sc{gnu} products. If |
| you obtained @command{@value{AS}} from a support organization, we recommend you |
| contact that organization first. |
| |
| You can find contact information for many support companies and |
| individuals in the file @file{etc/SERVICE} in the @sc{gnu} Emacs |
| distribution. |
| |
| @ifset BUGURL |
| In any event, we also recommend that you send bug reports for @command{@value{AS}} |
| to @value{BUGURL}. |
| @end ifset |
| |
| The fundamental principle of reporting bugs usefully is this: |
| @strong{report all the facts}. If you are not sure whether to state a |
| fact or leave it out, state it! |
| |
| Often people omit facts because they think they know what causes the problem |
| and assume that some details do not matter. Thus, you might assume that the |
| name of a symbol you use in an example does not matter. Well, probably it does |
| not, but one cannot be sure. Perhaps the bug is a stray memory reference which |
| happens to fetch from the location where that name is stored in memory; |
| perhaps, if the name were different, the contents of that location would fool |
| the assembler into doing the right thing despite the bug. Play it safe and |
| give a specific, complete example. That is the easiest thing for you to do, |
| and the most helpful. |
| |
| Keep in mind that the purpose of a bug report is to enable us to fix the bug if |
| it is new to us. Therefore, always write your bug reports on the assumption |
| that the bug has not been reported previously. |
| |
| Sometimes people give a few sketchy facts and ask, ``Does this ring a |
| bell?'' This cannot help us fix a bug, so it is basically useless. We |
| respond by asking for enough details to enable us to investigate. |
| You might as well expedite matters by sending them to begin with. |
| |
| To enable us to fix the bug, you should include all these things: |
| |
| @itemize @bullet |
| @item |
| The version of @command{@value{AS}}. @command{@value{AS}} announces it if you start |
| it with the @samp{--version} argument. |
| |
| Without this, we will not know whether there is any point in looking for |
| the bug in the current version of @command{@value{AS}}. |
| |
| @item |
| Any patches you may have applied to the @command{@value{AS}} source. |
| |
| @item |
| The type of machine you are using, and the operating system name and |
| version number. |
| |
| @item |
| What compiler (and its version) was used to compile @command{@value{AS}}---e.g. |
| ``@code{gcc-2.7}''. |
| |
| @item |
| The command arguments you gave the assembler to assemble your example and |
| observe the bug. To guarantee you will not omit something important, list them |
| all. A copy of the Makefile (or the output from make) is sufficient. |
| |
| If we were to try to guess the arguments, we would probably guess wrong |
| and then we might not encounter the bug. |
| |
| @item |
| A complete input file that will reproduce the bug. If the bug is observed when |
| the assembler is invoked via a compiler, send the assembler source, not the |
| high level language source. Most compilers will produce the assembler source |
| when run with the @samp{-S} option. If you are using @code{@value{GCC}}, use |
| the options @samp{-v --save-temps}; this will save the assembler source in a |
| file with an extension of @file{.s}, and also show you exactly how |
| @command{@value{AS}} is being run. |
| |
| @item |
| A description of what behavior you observe that you believe is |
| incorrect. For example, ``It gets a fatal signal.'' |
| |
| Of course, if the bug is that @command{@value{AS}} gets a fatal signal, then we |
| will certainly notice it. But if the bug is incorrect output, we might not |
| notice unless it is glaringly wrong. You might as well not give us a chance to |
| make a mistake. |
| |
| Even if the problem you experience is a fatal signal, you should still say so |
| explicitly. Suppose something strange is going on, such as, your copy of |
| @command{@value{AS}} is out of sync, or you have encountered a bug in the C |
| library on your system. (This has happened!) Your copy might crash and ours |
| would not. If you told us to expect a crash, then when ours fails to crash, we |
| would know that the bug was not happening for us. If you had not told us to |
| expect a crash, then we would not be able to draw any conclusion from our |
| observations. |
| |
| @item |
| If you wish to suggest changes to the @command{@value{AS}} source, send us context |
| diffs, as generated by @code{diff} with the @samp{-u}, @samp{-c}, or @samp{-p} |
| option. Always send diffs from the old file to the new file. If you even |
| discuss something in the @command{@value{AS}} source, refer to it by context, not |
| by line number. |
| |
| The line numbers in our development sources will not match those in your |
| sources. Your line numbers would convey no useful information to us. |
| @end itemize |
| |
| Here are some things that are not necessary: |
| |
| @itemize @bullet |
| @item |
| A description of the envelope of the bug. |
| |
| Often people who encounter a bug spend a lot of time investigating |
| which changes to the input file will make the bug go away and which |
| changes will not affect it. |
| |
| This is often time consuming and not very useful, because the way we |
| will find the bug is by running a single example under the debugger |
| with breakpoints, not by pure deduction from a series of examples. |
| We recommend that you save your time for something else. |
| |
| Of course, if you can find a simpler example to report @emph{instead} |
| of the original one, that is a convenience for us. Errors in the |
| output will be easier to spot, running under the debugger will take |
| less time, and so on. |
| |
| However, simplification is not vital; if you do not want to do this, |
| report the bug anyway and send us the entire test case you used. |
| |
| @item |
| A patch for the bug. |
| |
| A patch for the bug does help us if it is a good one. But do not omit |
| the necessary information, such as the test case, on the assumption that |
| a patch is all we need. We might see problems with your patch and decide |
| to fix the problem another way, or we might not understand it at all. |
| |
| Sometimes with a program as complicated as @command{@value{AS}} it is very hard to |
| construct an example that will make the program follow a certain path through |
| the code. If you do not send us the example, we will not be able to construct |
| one, so we will not be able to verify that the bug is fixed. |
| |
| And if we cannot understand what bug you are trying to fix, or why your |
| patch should be an improvement, we will not install it. A test case will |
| help us to understand. |
| |
| @item |
| A guess about what the bug is or what it depends on. |
| |
| Such guesses are usually wrong. Even we cannot guess right about such |
| things without first using the debugger to find the facts. |
| @end itemize |
| |
| @node Acknowledgements |
| @chapter Acknowledgements |
| |
| If you have contributed to GAS and your name isn't listed here, |
| it is not meant as a slight. We just don't know about it. Send mail to the |
| maintainer, and we'll correct the situation. Currently |
| @c (October 2012), |
| the maintainer is Nick Clifton (email address @code{nickc@@redhat.com}). |
| |
| Dean Elsner wrote the original @sc{gnu} assembler for the VAX.@footnote{Any |
| more details?} |
| |
| Jay Fenlason maintained GAS for a while, adding support for GDB-specific debug |
| information and the 68k series machines, most of the preprocessing pass, and |
| extensive changes in @file{messages.c}, @file{input-file.c}, @file{write.c}. |
| |
| K. Richard Pixley maintained GAS for a while, adding various enhancements and |
| many bug fixes, including merging support for several processors, breaking GAS |
| up to handle multiple object file format back ends (including heavy rewrite, |
| testing, an integration of the coff and b.out back ends), adding configuration |
| including heavy testing and verification of cross assemblers and file splits |
| and renaming, converted GAS to strictly ANSI C including full prototypes, added |
| support for m680[34]0 and cpu32, did considerable work on i960 including a COFF |
| port (including considerable amounts of reverse engineering), a SPARC opcode |
| file rewrite, DECstation, rs6000, and hp300hpux host ports, updated ``know'' |
| assertions and made them work, much other reorganization, cleanup, and lint. |
| |
| Ken Raeburn wrote the high-level BFD interface code to replace most of the code |
| in format-specific I/O modules. |
| |
| The original VMS support was contributed by David L. Kashtan. Eric Youngdale |
| has done much work with it since. |
| |
| The Intel 80386 machine description was written by Eliot Dresselhaus. |
| |
| Minh Tran-Le at IntelliCorp contributed some AIX 386 support. |
| |
| The Motorola 88k machine description was contributed by Devon Bowen of Buffalo |
| University and Torbjorn Granlund of the Swedish Institute of Computer Science. |
| |
| Keith Knowles at the Open Software Foundation wrote the original MIPS back end |
| (@file{tc-mips.c}, @file{tc-mips.h}), and contributed Rose format support |
| (which hasn't been merged in yet). Ralph Campbell worked with the MIPS code to |
| support a.out format. |
| |
| Support for the Zilog Z8k and Renesas H8/300 processors (tc-z8k, |
| tc-h8300), and IEEE 695 object file format (obj-ieee), was written by |
| Steve Chamberlain of Cygnus Support. Steve also modified the COFF back end to |
| use BFD for some low-level operations, for use with the H8/300 and AMD 29k |
| targets. |
| |
| John Gilmore built the AMD 29000 support, added @code{.include} support, and |
| simplified the configuration of which versions accept which directives. He |
| updated the 68k machine description so that Motorola's opcodes always produced |
| fixed-size instructions (e.g., @code{jsr}), while synthetic instructions |
| remained shrinkable (@code{jbsr}). John fixed many bugs, including true tested |
| cross-compilation support, and one bug in relaxation that took a week and |
| required the proverbial one-bit fix. |
| |
| Ian Lance Taylor of Cygnus Support merged the Motorola and MIT syntax for the |
| 68k, completed support for some COFF targets (68k, i386 SVR3, and SCO Unix), |
| added support for MIPS ECOFF and ELF targets, wrote the initial RS/6000 and |
| PowerPC assembler, and made a few other minor patches. |
| |
| Steve Chamberlain made GAS able to generate listings. |
| |
| Hewlett-Packard contributed support for the HP9000/300. |
| |
| Jeff Law wrote GAS and BFD support for the native HPPA object format (SOM) |
| along with a fairly extensive HPPA testsuite (for both SOM and ELF object |
| formats). This work was supported by both the Center for Software Science at |
| the University of Utah and Cygnus Support. |
| |
| Support for ELF format files has been worked on by Mark Eichin of Cygnus |
| Support (original, incomplete implementation for SPARC), Pete Hoogenboom and |
| Jeff Law at the University of Utah (HPPA mainly), Michael Meissner of the Open |
| Software Foundation (i386 mainly), and Ken Raeburn of Cygnus Support (sparc, |
| and some initial 64-bit support). |
| |
| Linas Vepstas added GAS support for the ESA/390 ``IBM 370'' architecture. |
| |
| Richard Henderson rewrote the Alpha assembler. Klaus Kaempf wrote GAS and BFD |
| support for openVMS/Alpha. |
| |
| Timothy Wall, Michael Hayes, and Greg Smart contributed to the various tic* |
| flavors. |
| |
| David Heine, Sterling Augustine, Bob Wilson and John Ruttenberg from Tensilica, |
| Inc.@: added support for Xtensa processors. |
| |
| Several engineers at Cygnus Support have also provided many small bug fixes and |
| configuration enhancements. |
| |
| Jon Beniston added support for the Lattice Mico32 architecture. |
| |
| Many others have contributed large or small bugfixes and enhancements. If |
| you have contributed significant work and are not mentioned on this list, and |
| want to be, let us know. Some of the history has been lost; we are not |
| intentionally leaving anyone out. |
| |
| @node GNU Free Documentation License |
| @appendix GNU Free Documentation License |
| @include fdl.texi |
| |
| @node AS Index |
| @unnumbered AS Index |
| |
| @printindex cp |
| |
| @bye |
| @c Local Variables: |
| @c fill-column: 79 |
| @c End: |