Next: HPPA Opcodes, Previous: HPPA Floating Point, Up: HPPA-Dependent

#### 8.11.5 HPPA Assembler Directives

`as` for the HPPA supports many additional directives for compatibility with the native assembler. This section describes them only briefly. For detailed information on HPPA-specific assembler directives, see HP9000 Series 800 Assembly Language Reference Manual (HP 92432-90001).

`as` does not support the following assembler directives described in the HP manual:

         .endm           .liston
         .enter          .locct
         .leave          .macro
         .listoff

Beyond those implemented for compatibility, `as` supports one additional assembler directive for the HPPA: `.param`. It conveys register argument locations for static functions. Its syntax closely follows the `.export` directive.

These are the additional directives in `as` for the HPPA:

`.block` n
`.blockz` n
  Reserve n bytes of storage, and initialize them to zero.
`.call`
  Mark the beginning of a procedure call. Only the special case with no arguments is allowed.
`.callinfo [` param`=`value`, ... ] [` flag`, ... ]`
  Specify a number of parameters and flags that define the environment for a procedure.

  param may be any of ``frame`' (frame size), ``entry_gr`' (end of general register range), ``entry_fr`' (end of float register range), ``entry_sr`' (end of space register range).

  The values for flag are ``calls`' or ``caller`' (proc has subroutines), ``no_calls`' (proc does not call subroutines), ``save_rp`' (preserve return pointer), ``save_sp`' (proc preserves stack pointer), ``no_unwind`' (do not unwind this proc), ``hpux_int`' (proc is interrupt routine).

`.code`
  Assemble into the standard section called ``$TEXT$`', subsection ``$CODE$`'.
`.copyright "`string`"`
  In the SOM object format, insert string into the object code, marked as a copyright string.
`.copyright "`string`"`
  In the ELF object format, insert string into the object code, marked as a version string.
`.enter`
  Not yet supported; the assembler rejects programs containing this directive.
`.entry`
  Mark the beginning of a procedure.
`.exit`
  Mark the end of a procedure.
`.export` name`[ ,`typ`] [ ,`param`=`r`]`
  Make a procedure name available to callers. typ, if present, must be one of ``absolute`', ``code`' (ELF only, not SOM), ``data`', ``entry`', ``data`', ``entry`', ``millicode`', ``plabel`', ``pri_prog`', or ``sec_prog`'.

  param, if present, provides either relocation information for the procedure arguments and result, or a privilege level. param may be ``argwn`' (where n ranges from `0` to `3`, and indicates one of four one-word arguments); ``rtnval`' (the procedure's result); or ``priv_lev`' (privilege level). For arguments or the result, r specifies how to relocate, and must be one of ``no`' (not relocatable), ``gr`' (argument is in general register), ``fr`' (in floating point register), or ``fu`' (upper half of float register). For ``priv_lev`', r is an integer.

`.half` n
  Define a two-byte integer constant n; synonym for the portable `as` directive `.short`.
`.import` name`[ ,`typ`]`
  Converse of `.export`; make a procedure available to call. The arguments use the same conventions as the first two arguments for `.export`.
`.label` name
  Define name as a label for the current assembly location.
`.leave`
  Not yet supported; the assembler rejects programs containing this directive.
`.origin` lc
  Advance location counter to lc. Synonym for the `as` portable directive `.org`.
`.param` name`[ ,`typ`] [ ,`param`=`r`]`
  Similar to `.export`, but used for static procedures.
`.proc`
  Use preceding the first statement of a procedure.
`.procend`
  Use following the last statement of a procedure.
label`.reg` expr
  Synonym for `.equ`; define label with the absolute expression expr as its value.
`.space` secname`[ ,`params`]`
  Switch to section secname, creating a new section by that name if necessary. You may only use params when creating a new section, not when switching to an existing one. secname may identify a section by number rather than by name.

  If specified, the list params declares attributes of the section, identified by keywords. The keywords recognized are ``spnum=exp`' (identify this section by the number exp, an absolute expression), ``sort=exp`' (order sections according to this sort key when linking; exp is an absolute expression), ``unloadable`' (section contains no loadable data), ``notdefined`' (this section defined elsewhere), and ``private`' (data in this section not available to other programs).

`.spnum` secnam
  Allocate four bytes of storage, and initialize them with the section number of the section named secnam. (You can define the section number with the HPPA `.space` directive.)

`.string "`str`"`
  Copy the characters in the string str to the object file. See Strings, for information on escape sequences you can use in `as` strings.

  Warning! The HPPA version of `.string` differs from the usual `as` definition: it does not write a zero byte after copying str.

`.stringz "`str`"`
  Like `.string`, but appends a zero byte after copying str to object file.
`.subspa` name`[ ,`params`]`
`.nsubspa` name`[ ,`params`]`
  Similar to `.space`, but selects a subsection name within the current section. You may only specify params when you create a subsection (in the first instance of `.subspa` for this name).

  If specified, the list params declares attributes of the subsection, identified by keywords. The keywords recognized are ``quad=expr`' (“quadrant” for this subsection), ``align=expr`' (alignment for beginning of this subsection; a power of two), ``access=expr`' (value for “access rights” field), ``sort=expr`' (sorting order for this subspace in link), ``code_only`' (subsection contains only code), ``unloadable`' (subsection cannot be loaded into memory), ``comdat`' (subsection is comdat), ``common`' (subsection is common block), ``dup_comm`' (subsection may have duplicate names), or ``zero`' (subsection is all zeros, do not write in object file).

  `.nsubspa` always creates a new subspace with the given name, even if one with the same name already exists.

  ``comdat`', ``common`' and ``dup_comm`' can be used to implement various flavors of one-only support when using the SOM linker. The SOM linker only supports specific combinations of these flags. The details are not documented. A brief description is provided here.

  ``comdat`' provides a form of linkonce support. It is useful for both code and data subspaces. A ``comdat`' subspace has a key symbol marked by the ``is_comdat`' flag or ``ST_COMDAT`'. Only the first subspace for any given key is selected. The key symbol becomes universal in shared links. This is similar to the behavior of ``secondary_def`' symbols.

  ``common`' provides Fortran named common support. It is only useful for data subspaces. Symbols with the flag ``is_common`' retain this flag in shared links. Referencing a ``is_common`' symbol in a shared library from outside the library doesn't work. Thus, ``is_common`' symbols must be output whenever they are needed.

  ``common`' and ``dup_comm`' together provide Cobol common support. The subspaces in this case must all be the same length. Otherwise, this support is similar to the Fortran common support.

  ``dup_comm`' by itself provides a type of one-only support for code. Only the first ``dup_comm`' subspace is selected. There is a rather complex algorithm to compare subspaces. Code symbols marked with the ``dup_common`' flag are hidden. This support was intended for "C++ duplicate inlines".

  A simplified technique is used to mark the flags of symbols based on the flags of their subspace. A symbol with the scope SS_UNIVERSAL and type ST_ENTRY, ST_CODE or ST_DATA is marked with the corresponding settings of ``comdat`', ``common`' and ``dup_comm`' from the subspace, respectively. This avoids having to introduce additional directives to mark these symbols. The HP assembler sets ``is_common`' from ``common`'. However, it doesn't set the ``dup_common`' from ``dup_comm`'. It doesn't have ``comdat`' support.

`.version "`str`"`
  Write str as version identifier in object code.