Implicit Calls to Library Routines

 ==================================
 
    Here is an explanation of implicit calls to library routines.
 
 `MULSI3_LIBCALL'
      A C string constant giving the name of the function to call for
      multiplication of one signed full-word by another.  If you do not
      define this macro, the default name is used, which is `__mulsi3',
      a function defined in `libgcc.a'.
 
 `DIVSI3_LIBCALL'
      A C string constant giving the name of the function to call for
      division of one signed full-word by another.  If you do not define
      this macro, the default name is used, which is `__divsi3', a
      function defined in `libgcc.a'.
 
 `UDIVSI3_LIBCALL'
      A C string constant giving the name of the function to call for
      division of one unsigned full-word by another.  If you do not
      define this macro, the default name is used, which is `__udivsi3',
      a function defined in `libgcc.a'.
 
 `MODSI3_LIBCALL'
      A C string constant giving the name of the function to call for the
      remainder in division of one signed full-word by another.  If you
      do not define this macro, the default name is used, which is
      `__modsi3', a function defined in `libgcc.a'.
 
 `UMODSI3_LIBCALL'
      A C string constant giving the name of the function to call for the
      remainder in division of one unsigned full-word by another.  If
      you do not define this macro, the default name is used, which is
      `__umodsi3', a function defined in `libgcc.a'.
 
 `MULDI3_LIBCALL'
      A C string constant giving the name of the function to call for
      multiplication of one signed double-word by another.  If you do not
      define this macro, the default name is used, which is `__muldi3',
      a function defined in `libgcc.a'.
 
 `DIVDI3_LIBCALL'
      A C string constant giving the name of the function to call for
      division of one signed double-word by another.  If you do not
      define this macro, the default name is used, which is `__divdi3', a
      function defined in `libgcc.a'.
 
 `UDIVDI3_LIBCALL'
      A C string constant giving the name of the function to call for
      division of one unsigned full-word by another.  If you do not
      define this macro, the default name is used, which is `__udivdi3',
      a function defined in `libgcc.a'.
 
 `MODDI3_LIBCALL'
      A C string constant giving the name of the function to call for the
      remainder in division of one signed double-word by another.  If
      you do not define this macro, the default name is used, which is
      `__moddi3', a function defined in `libgcc.a'.
 
 `UMODDI3_LIBCALL'
      A C string constant giving the name of the function to call for the
      remainder in division of one unsigned full-word by another.  If
      you do not define this macro, the default name is used, which is
      `__umoddi3', a function defined in `libgcc.a'.
 
 `INIT_TARGET_OPTABS'
      Define this macro as a C statement that declares additional library
      routines renames existing ones. `init_optabs' calls this macro
      after initializing all the normal library routines.
 
 `TARGET_EDOM'
      The value of `EDOM' on the target machine, as a C integer constant
      expression.  If you don't define this macro, GNU CC does not
      attempt to deposit the value of `EDOM' into `errno' directly.
      Look in `/usr/include/errno.h' to find the value of `EDOM' on your
      system.
 
      If you do not define `TARGET_EDOM', then compiled code reports
      domain errors by calling the library function and letting it
      report the error.  If mathematical functions on your system use
      `matherr' when there is an error, then you should leave
      `TARGET_EDOM' undefined so that `matherr' is used normally.
 
 `GEN_ERRNO_RTX'
      Define this macro as a C expression to create an rtl expression
      that refers to the global "variable" `errno'.  (On certain systems,
      `errno' may not actually be a variable.)  If you don't define this
      macro, a reasonable default is used.
 
 `TARGET_MEM_FUNCTIONS'
      Define this macro if GNU CC should generate calls to the System V
      (and ANSI C) library functions `memcpy' and `memset' rather than
      the BSD functions `bcopy' and `bzero'.
 
 `LIBGCC_NEEDS_DOUBLE'
      Define this macro if only `float' arguments cannot be passed to
      library routines (so they must be converted to `double').  This
      macro affects both how library calls are generated and how the
      library routines in `libgcc1.c' accept their arguments.  It is
      useful on machines where floating and fixed point arguments are
      passed differently, such as the i860.
 
 `FLOAT_ARG_TYPE'
      Define this macro to override the type used by the library
      routines to pick up arguments of type `float'.  (By default, they
      use a union of `float' and `int'.)
 
      The obvious choice would be `float'--but that won't work with
      traditional C compilers that expect all arguments declared as
      `float' to arrive as `double'.  To avoid this conversion, the
      library routines ask for the value as some other type and then
      treat it as a `float'.
 
      On some systems, no other type will work for this.  For these
      systems, you must use `LIBGCC_NEEDS_DOUBLE' instead, to force
      conversion of the values `double' before they are passed.
 
 `FLOATIFY (PASSED-VALUE)'
      Define this macro to override the way library routines redesignate
      a `float' argument as a `float' instead of the type it was passed
      as.  The default is an expression which takes the `float' field of
      the union.
 
 `FLOAT_VALUE_TYPE'
      Define this macro to override the type used by the library
      routines to return values that ought to have type `float'.  (By
      default, they use `int'.)
 
      The obvious choice would be `float'--but that won't work with
      traditional C compilers gratuitously convert values declared as
      `float' into `double'.
 
 `INTIFY (FLOAT-VALUE)'
      Define this macro to override the way the value of a
      `float'-returning library routine should be packaged in order to
      return it.  These functions are actually declared to return type
      `FLOAT_VALUE_TYPE' (normally `int').
 
      These values can't be returned as type `float' because traditional
      C compilers would gratuitously convert the value to a `double'.
 
      A local variable named `intify' is always available when the macro
      `INTIFY' is used.  It is a union of a `float' field named `f' and
      a field named `i' whose type is `FLOAT_VALUE_TYPE' or `int'.
 
      If you don't define this macro, the default definition works by
      copying the value through that union.
 
 `nongcc_SI_type'
      Define this macro as the name of the data type corresponding to
      `SImode' in the system's own C compiler.
 
      You need not define this macro if that type is `long int', as it
      usually is.
 
 `nongcc_word_type'
      Define this macro as the name of the data type corresponding to the
      word_mode in the system's own C compiler.
 
      You need not define this macro if that type is `long int', as it
      usually is.
 
 `perform_...'
      Define these macros to supply explicit C statements to carry out
      various arithmetic operations on types `float' and `double' in the
      library routines in `libgcc1.c'.  See that file for a full list of
      these macros and their arguments.
 
      On most machines, you don't need to define any of these macros,
      because the C compiler that comes with the system takes care of
      doing them.
 
 `NEXT_OBJC_RUNTIME'
      Define this macro to generate code for Objective C message sending
      using the calling convention of the NeXT system.  This calling
      convention involves passing the object, the selector and the
      method arguments all at once to the method-lookup library function.
 
      The default calling convention passes just the object and the
      selector to the lookup function, which returns a pointer to the
      method.