### 17.13 Implicit Calls to Library Routines

Here is an explanation of implicit calls to library routines.

— Macro: DECLARE_LIBRARY_RENAMES

> This macro, if defined, should expand to a piece of C code that will get expanded when compiling functions for libgcc.a. It can be used to provide alternate names for GCC's internal library functions if there are ABI-mandated names that the compiler should provide.

— Target Hook: void TARGET_INIT_LIBFUNCS (void)

> This hook should declare additional library routines or rename existing ones, using the functions `set_optab_libfunc` and `init_one_libfunc` defined in `optabs.c`. `init_optabs` calls this macro after initializing all the normal library routines.

> The default is to do nothing. Most ports don't need to define this hook.

— Target Hook: bool TARGET_LIBFUNC_GNU_PREFIX

> If false (the default), internal library routines start with two underscores. If set to true, these routines start with `__gnu_` instead. E.g., `__muldi3` changes to `__gnu_muldi3`. This currently only affects functions defined in `libgcc2.c`. If this is set to true, the `tm.h` file must also `#define LIBGCC2_GNU_PREFIX`.

— Macro: FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, comparison)

> This macro should return `true` if the library routine that implements the floating point comparison operator comparison in mode mode will return a boolean, and false if it will return a tristate.

> GCC's own floating point libraries return tristates from the comparison operators, so the default returns false always. Most ports don't need to define this macro.

— Macro: TARGET_LIB_INT_CMP_BIASED

> This macro should evaluate to `true` if the integer comparison functions (like `__cmpdi2`) return 0 to indicate that the first operand is smaller than the second, 1 to indicate that they are equal, and 2 to indicate that the first operand is greater than the second. If this macro evaluates to `false` the comparison functions return −1, 0, and 1 instead of 0, 1, and 2. If the target uses the routines in `libgcc.a`, you do not need to define this macro.

— Macro: TARGET_EDOM

> The value of `EDOM` on the target machine, as a C integer constant expression. If you don't define this macro, GCC 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.

— Macro: 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.

— Macro: TARGET_C99_FUNCTIONS

> When this macro is nonzero, GCC will implicitly optimize `sin` calls into `sinf` and similarly for other functions defined by C99 standard. The default is zero because a number of existing systems lack support for these functions in their runtime so this macro needs to be redefined to one on systems that do support the C99 runtime.

— Macro: TARGET_HAS_SINCOS

> When this macro is nonzero, GCC will implicitly optimize calls to `sin` and `cos` with the same argument to a call to `sincos`. The default is zero. The target has to provide the following functions:

>               void sincos(double x, double *sin, double *cos);
>               void sincosf(float x, float *sin, float *cos);
>               void sincosl(long double x, long double *sin, long double *cos);

— Macro: NEXT_OBJC_RUNTIME

> Set this macro to 1 to use the "NeXT" Objective-C message sending conventions by default. This calling convention involves passing the object, the selector and the method arguments all at once to the method-lookup library function. This is the usual setting when targeting Darwin/Mac OS X systems, which have the NeXT runtime installed.

> If the macro is set to 0, the "GNU" Objective-C message sending convention will be used by default. This convention passes just the object and the selector to the method-lookup function, which returns a pointer to the method.

> In either case, it remains possible to select code-generation for the alternate scheme, by means of compiler command line switches.