Using as: HPPA Directives

Next: HPPA Opcodes, Previous: HPPA Floating Point, Up: HPPA-Dependent [Contents][Index]

#### 9.13.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.

Next: HPPA Opcodes, Previous: HPPA Floating Point, Up: HPPA-Dependent [Contents][Index]