as Internal Sections
====================

   These sections are meant only for the internal use of `as'.  They
have no meaning at run-time.  You don't really need to know about these
sections for most purposes; but they can be mentioned in `as' warning
messages, so it might be helpful to have an idea of their meanings to
`as'.  These sections are used to permit the value of every expression
in your assembly language program to be a section-relative address.

absent
     An expression was expected and none was found.

ASSEMBLER-INTERNAL-LOGIC-ERROR!
     An internal assembler logic error has been found.  This means
     there is a bug in the assembler.

bignum/flonum
     If a number can't be written as a C `int' constant (a bignum or a
     flonum, but not an integer), it is recorded as belonging to this
     "section".  `as' has to remember that a flonum or a bignum does
     not fit into 32 bits, and cannot be an argument (
see Arguments.) in an expression: this is done by making a flonum or
     bignum be in a separate internal section.  This is purely for
     internal `as' convenience; bignum/flonum section behaves similarly
     to absolute section.

pass1 section
     The expression was impossible to evaluate in the first pass.  The
     assembler will attempt a second pass (second reading of the
     source) to evaluate the expression.  Your expression mentioned an
     undefined symbol in a way that defies the one-pass (section +
     offset in section) assembly process.  No compiler need emit such
     an expression.

          *Warning:* the second pass is currently not implemented.  `as'
          will abort with an error message if one is required.

difference section
     As an assist to the C compiler, expressions of the forms
             (UNDEFINED SYMBOL) - (EXPRESSION)
             SOMETHING - (UNDEFINED SYMBOL)
             (UNDEFINED SYMBOL) - (UNDEFINED SYMBOL)

     are permitted, and belong to the difference section.  `as'
     re-evaluates such expressions after the source file has been read
     and the symbol table built.  If by that time there are no
     undefined symbols in the expression then the expression assumes a
     new section.  The intention is to permit statements like `.word
     label - base_of_table' to be assembled in one pass where both
     `label' and `base_of_table' are undefined.  This is useful for
     compiling C and Algol switch statements, Pascal case statements,
     FORTRAN computed goto statements and the like.