ASM (character [, any-type-arg])

  Class:  Nonelemental function - Generic

  Lets you use assembler instructions in an executable program.

  The first argument is a character constant or a concatenation of
  character constants containing the assembler instructions.  The
  optional second argument can be of any type.  It can be a source or
  destination argument for the instruction, for example.

  Arguments are passed by value.  If you want to pass an argument by
  reference (for example, a whole array, a character string, or a
  record structure), you can use the %REF built-in function.

  Labels are allowed, but all references must be from within the same
  ASM function.  This lets you set up looping constructs, for
  example.  Cross-jumping between ASM functions is not permitted.

  In general, an ASM function can appear anywhere that an intrinsic
  function can be used.  Since the supplied assembly code, assembly
  directives, or assembly data is integrated into the code stream,
  the compiler may choose to use different registers, better code
  sequences, and so on, just as if the code were written in Fortran.

  You do not have absolute control over instruction sequences and
  registers, and the compiler may intersperse other code together
  with the ASM code for better performance.  Better code sequences
  may be substituted by the optimizer if it chooses to do so.

  Only register names beginning with a dollar sign ($) or percent
  sign (%) are permitted.  For more information on register name
  conventions, see the OpenVMS operating system documentation set.

    +---------+-------------------+-------------+
    | Generic | Specific          | Result Type |
    +---------+-------------------+-------------+
    |  ASM    | ASM (see Note1)   | INTEGER*8   |
    |         | FASM (see Note2)  | REAL*4      |
    |         | DASM (see Note2)  | REAL*8      |
    +---------+-------------------+-------------+

  Note1: The value must be stored in register $0 by the user code.
  Note2: The value must be stored in register $F0 by the user code.

  Example:

  Consider the following:

   ! Concatenation is recommended for clarity.
   ! Notice that ";" separates instructions.
   !
   nine=9

   type *, asm('addq %0, $17, $0;'//  ! Adds the first two arguments
    1    'ldq $22, %6;'//             !   and puts the answer in
    1    'ldq $23, %7;'//             !   register $0
    1    'ldq $24, %8;'//             !
    1    'mov $0, %fp;'//             ! Comments are not allowed in the
    1    'addq $18, %fp, $0;'//       !   constant, but are allowed here
    1     'addq $19, $0, $0;'//
    1     'addq $20, $0, $0;'//
    1     'addq $21, $0, $0;'//
    1     'addq $22, $0, $0;'//
    1     'addq $23, $0, $0;'//
    1    'addq $24, $0, $0;',
    1 1,2,3,4,5,6,7,8,nine)           ! The actual arguments to the
                                      !   ASM (usually by value)
   end

  This example shows an integer ASM function that adds up 9 values
  and returns the sum as its result.  Note that the user stores the
  function result in register $0.

  All arguments are passed by value.  The arguments not passed in
  registers can be named %6, %7, and %8, which correspond to the
  actual arguments 7, 8, and 9 (since %0 is the first argument).
  Notice that you can reference reserved registers like %fp.

  The compiler creates the appropriate argument list.  So, in this
  example, the first argument value (1) will be available in register
  $16, and the eighth argument value (8) will be available in %7,
  which is actually 8($30).