| This is gccint.info, produced by makeinfo version 5.2 from gccint.texi. |
| |
| Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
| 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software |
| Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.2 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "GNU General Public License" and "Funding Free |
| Software", the Front-Cover texts being (a) (see below), and with the |
| Back-Cover Texts being (b) (see below). A copy of the license is |
| included in the section entitled "GNU Free Documentation License". |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU software. |
| Copies published by the Free Software Foundation raise funds for GNU |
| development. |
| INFO-DIR-SECTION Software development |
| START-INFO-DIR-ENTRY |
| * gccint: (gccint). Internals of the GNU Compiler Collection. |
| END-INFO-DIR-ENTRY |
| |
| This file documents the internals of the GNU compilers. |
| |
| Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
| 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software |
| Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.2 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "GNU General Public License" and "Funding Free |
| Software", the Front-Cover texts being (a) (see below), and with the |
| Back-Cover Texts being (b) (see below). A copy of the license is |
| included in the section entitled "GNU Free Documentation License". |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU software. |
| Copies published by the Free Software Foundation raise funds for GNU |
| development. |
| |
| |
| File: gccint.info, Node: Top, Next: Contributing, Up: (DIR) |
| |
| Introduction |
| ************ |
| |
| This manual documents the internals of the GNU compilers, including how |
| to port them to new targets and some information about how to write |
| front ends for new languages. It corresponds to the compilers (GCC) |
| version 4.3.3. The use of the GNU compilers is documented in a separate |
| manual. *Note Introduction: (gcc)Top. |
| |
| This manual is mainly a reference manual rather than a tutorial. It |
| discusses how to contribute to GCC (*note Contributing::), the |
| characteristics of the machines supported by GCC as hosts and targets |
| (*note Portability::), how GCC relates to the ABIs on such systems |
| (*note Interface::), and the characteristics of the languages for which |
| GCC front ends are written (*note Languages::). It then describes the |
| GCC source tree structure and build system, some of the interfaces to |
| GCC front ends, and how support for a target system is implemented in |
| GCC. |
| |
| Additional tutorial information is linked to from |
| <http://gcc.gnu.org/readings.html>. |
| |
| * Menu: |
| |
| * Contributing:: How to contribute to testing and developing GCC. |
| * Portability:: Goals of GCC's portability features. |
| * Interface:: Function-call interface of GCC output. |
| * Libgcc:: Low-level runtime library used by GCC. |
| * Languages:: Languages for which GCC front ends are written. |
| * Source Tree:: GCC source tree structure and build system. |
| * Options:: Option specification files. |
| * Passes:: Order of passes, what they do, and what each file is for. |
| * Trees:: The source representation used by the C and C++ front ends. |
| * RTL:: The intermediate representation that most passes work on. |
| * Control Flow:: Maintaining and manipulating the control flow graph. |
| * Tree SSA:: Analysis and optimization of the tree representation. |
| * Loop Analysis and Representation:: Analysis and representation of loops |
| * Machine Desc:: How to write machine description instruction patterns. |
| * Target Macros:: How to write the machine description C macros and functions. |
| * Host Config:: Writing the 'xm-MACHINE.h' file. |
| * Fragments:: Writing the 't-TARGET' and 'x-HOST' files. |
| * Collect2:: How 'collect2' works; how it finds 'ld'. |
| * Header Dirs:: Understanding the standard header file directories. |
| * Type Information:: GCC's memory management; generating type information. |
| |
| * Funding:: How to help assure funding for free software. |
| * GNU Project:: The GNU Project and GNU/Linux. |
| |
| * Copying:: GNU General Public License says |
| how you can copy and share GCC. |
| * GNU Free Documentation License:: How you can copy and share this manual. |
| * Contributors:: People who have contributed to GCC. |
| |
| * Option Index:: Index to command line options. |
| * Concept Index:: Index of concepts and symbol names. |
| |
| |
| File: gccint.info, Node: Contributing, Next: Portability, Up: Top |
| |
| 1 Contributing to GCC Development |
| ********************************* |
| |
| If you would like to help pretest GCC releases to assure they work well, |
| current development sources are available by SVN (see |
| <http://gcc.gnu.org/svn.html>). Source and binary snapshots are also |
| available for FTP; see <http://gcc.gnu.org/snapshots.html>. |
| |
| If you would like to work on improvements to GCC, please read the |
| advice at these URLs: |
| |
| <http://gcc.gnu.org/contribute.html> |
| <http://gcc.gnu.org/contributewhy.html> |
| |
| for information on how to make useful contributions and avoid |
| duplication of effort. Suggested projects are listed at |
| <http://gcc.gnu.org/projects/>. |
| |
| |
| File: gccint.info, Node: Portability, Next: Interface, Prev: Contributing, Up: Top |
| |
| 2 GCC and Portability |
| ********************* |
| |
| GCC itself aims to be portable to any machine where 'int' is at least a |
| 32-bit type. It aims to target machines with a flat (non-segmented) |
| byte addressed data address space (the code address space can be |
| separate). Target ABIs may have 8, 16, 32 or 64-bit 'int' type. 'char' |
| can be wider than 8 bits. |
| |
| GCC gets most of the information about the target machine from a |
| machine description which gives an algebraic formula for each of the |
| machine's instructions. This is a very clean way to describe the |
| target. But when the compiler needs information that is difficult to |
| express in this fashion, ad-hoc parameters have been defined for machine |
| descriptions. The purpose of portability is to reduce the total work |
| needed on the compiler; it was not of interest for its own sake. |
| |
| GCC does not contain machine dependent code, but it does contain code |
| that depends on machine parameters such as endianness (whether the most |
| significant byte has the highest or lowest address of the bytes in a |
| word) and the availability of autoincrement addressing. In the |
| RTL-generation pass, it is often necessary to have multiple strategies |
| for generating code for a particular kind of syntax tree, strategies |
| that are usable for different combinations of parameters. Often, not |
| all possible cases have been addressed, but only the common ones or only |
| the ones that have been encountered. As a result, a new target may |
| require additional strategies. You will know if this happens because |
| the compiler will call 'abort'. Fortunately, the new strategies can be |
| added in a machine-independent fashion, and will affect only the target |
| machines that need them. |
| |
| |
| File: gccint.info, Node: Interface, Next: Libgcc, Prev: Portability, Up: Top |
| |
| 3 Interfacing to GCC Output |
| *************************** |
| |
| GCC is normally configured to use the same function calling convention |
| normally in use on the target system. This is done with the |
| machine-description macros described (*note Target Macros::). |
| |
| However, returning of structure and union values is done differently on |
| some target machines. As a result, functions compiled with PCC |
| returning such types cannot be called from code compiled with GCC, and |
| vice versa. This does not cause trouble often because few Unix library |
| routines return structures or unions. |
| |
| GCC code returns structures and unions that are 1, 2, 4 or 8 bytes long |
| in the same registers used for 'int' or 'double' return values. (GCC |
| typically allocates variables of such types in registers also.) |
| Structures and unions of other sizes are returned by storing them into |
| an address passed by the caller (usually in a register). The target |
| hook 'TARGET_STRUCT_VALUE_RTX' tells GCC where to pass this address. |
| |
| By contrast, PCC on most target machines returns structures and unions |
| of any size by copying the data into an area of static storage, and then |
| returning the address of that storage as if it were a pointer value. |
| The caller must copy the data from that memory area to the place where |
| the value is wanted. This is slower than the method used by GCC, and |
| fails to be reentrant. |
| |
| On some target machines, such as RISC machines and the 80386, the |
| standard system convention is to pass to the subroutine the address of |
| where to return the value. On these machines, GCC has been configured |
| to be compatible with the standard compiler, when this method is used. |
| It may not be compatible for structures of 1, 2, 4 or 8 bytes. |
| |
| GCC uses the system's standard convention for passing arguments. On |
| some machines, the first few arguments are passed in registers; in |
| others, all are passed on the stack. It would be possible to use |
| registers for argument passing on any machine, and this would probably |
| result in a significant speedup. But the result would be complete |
| incompatibility with code that follows the standard convention. So this |
| change is practical only if you are switching to GCC as the sole C |
| compiler for the system. We may implement register argument passing on |
| certain machines once we have a complete GNU system so that we can |
| compile the libraries with GCC. |
| |
| On some machines (particularly the SPARC), certain types of arguments |
| are passed "by invisible reference". This means that the value is |
| stored in memory, and the address of the memory location is passed to |
| the subroutine. |
| |
| If you use 'longjmp', beware of automatic variables. ISO C says that |
| automatic variables that are not declared 'volatile' have undefined |
| values after a 'longjmp'. And this is all GCC promises to do, because |
| it is very difficult to restore register variables correctly, and one of |
| GCC's features is that it can put variables in registers without your |
| asking it to. |
| |
| |
| File: gccint.info, Node: Libgcc, Next: Languages, Prev: Interface, Up: Top |
| |
| 4 The GCC low-level runtime library |
| *********************************** |
| |
| GCC provides a low-level runtime library, 'libgcc.a' or 'libgcc_s.so.1' |
| on some platforms. GCC generates calls to routines in this library |
| automatically, whenever it needs to perform some operation that is too |
| complicated to emit inline code for. |
| |
| Most of the routines in 'libgcc' handle arithmetic operations that the |
| target processor cannot perform directly. This includes integer |
| multiply and divide on some machines, and all floating-point and |
| fixed-point operations on other machines. 'libgcc' also includes |
| routines for exception handling, and a handful of miscellaneous |
| operations. |
| |
| Some of these routines can be defined in mostly machine-independent C. |
| Others must be hand-written in assembly language for each processor that |
| needs them. |
| |
| GCC will also generate calls to C library routines, such as 'memcpy' |
| and 'memset', in some cases. The set of routines that GCC may possibly |
| use is documented in *note (gcc)Other Builtins::. |
| |
| These routines take arguments and return values of a specific machine |
| mode, not a specific C type. *Note Machine Modes::, for an explanation |
| of this concept. For illustrative purposes, in this chapter the |
| floating point type 'float' is assumed to correspond to 'SFmode'; |
| 'double' to 'DFmode'; and 'long double' to both 'TFmode' and 'XFmode'. |
| Similarly, the integer types 'int' and 'unsigned int' correspond to |
| 'SImode'; 'long' and 'unsigned long' to 'DImode'; and 'long long' and |
| 'unsigned long long' to 'TImode'. |
| |
| * Menu: |
| |
| * Integer library routines:: |
| * Soft float library routines:: |
| * Decimal float library routines:: |
| * Fixed-point fractional library routines:: |
| * Exception handling routines:: |
| * Miscellaneous routines:: |
| |
| |
| File: gccint.info, Node: Integer library routines, Next: Soft float library routines, Up: Libgcc |
| |
| 4.1 Routines for integer arithmetic |
| =================================== |
| |
| The integer arithmetic routines are used on platforms that don't provide |
| hardware support for arithmetic operations on some modes. |
| |
| 4.1.1 Arithmetic functions |
| -------------------------- |
| |
| -- Runtime Function: int __ashlsi3 (int A, int B) |
| -- Runtime Function: long __ashldi3 (long A, int B) |
| -- Runtime Function: long long __ashlti3 (long long A, int B) |
| These functions return the result of shifting A left by B bits. |
| |
| -- Runtime Function: int __ashrsi3 (int A, int B) |
| -- Runtime Function: long __ashrdi3 (long A, int B) |
| -- Runtime Function: long long __ashrti3 (long long A, int B) |
| These functions return the result of arithmetically shifting A |
| right by B bits. |
| |
| -- Runtime Function: int __divsi3 (int A, int B) |
| -- Runtime Function: long __divdi3 (long A, long B) |
| -- Runtime Function: long long __divti3 (long long A, long long B) |
| These functions return the quotient of the signed division of A and |
| B. |
| |
| -- Runtime Function: int __lshrsi3 (int A, int B) |
| -- Runtime Function: long __lshrdi3 (long A, int B) |
| -- Runtime Function: long long __lshrti3 (long long A, int B) |
| These functions return the result of logically shifting A right by |
| B bits. |
| |
| -- Runtime Function: int __modsi3 (int A, int B) |
| -- Runtime Function: long __moddi3 (long A, long B) |
| -- Runtime Function: long long __modti3 (long long A, long long B) |
| These functions return the remainder of the signed division of A |
| and B. |
| |
| -- Runtime Function: int __mulsi3 (int A, int B) |
| -- Runtime Function: long __muldi3 (long A, long B) |
| -- Runtime Function: long long __multi3 (long long A, long long B) |
| These functions return the product of A and B. |
| |
| -- Runtime Function: long __negdi2 (long A) |
| -- Runtime Function: long long __negti2 (long long A) |
| These functions return the negation of A. |
| |
| -- Runtime Function: unsigned int __udivsi3 (unsigned int A, unsigned |
| int B) |
| -- Runtime Function: unsigned long __udivdi3 (unsigned long A, unsigned |
| long B) |
| -- Runtime Function: unsigned long long __udivti3 (unsigned long long |
| A, unsigned long long B) |
| These functions return the quotient of the unsigned division of A |
| and B. |
| |
| -- Runtime Function: unsigned long __udivmoddi3 (unsigned long A, |
| unsigned long B, unsigned long *C) |
| -- Runtime Function: unsigned long long __udivti3 (unsigned long long |
| A, unsigned long long B, unsigned long long *C) |
| These functions calculate both the quotient and remainder of the |
| unsigned division of A and B. The return value is the quotient, |
| and the remainder is placed in variable pointed to by C. |
| |
| -- Runtime Function: unsigned int __umodsi3 (unsigned int A, unsigned |
| int B) |
| -- Runtime Function: unsigned long __umoddi3 (unsigned long A, unsigned |
| long B) |
| -- Runtime Function: unsigned long long __umodti3 (unsigned long long |
| A, unsigned long long B) |
| These functions return the remainder of the unsigned division of A |
| and B. |
| |
| 4.1.2 Comparison functions |
| -------------------------- |
| |
| The following functions implement integral comparisons. These functions |
| implement a low-level compare, upon which the higher level comparison |
| operators (such as less than and greater than or equal to) can be |
| constructed. The returned values lie in the range zero to two, to allow |
| the high-level operators to be implemented by testing the returned |
| result using either signed or unsigned comparison. |
| |
| -- Runtime Function: int __cmpdi2 (long A, long B) |
| -- Runtime Function: int __cmpti2 (long long A, long long B) |
| These functions perform a signed comparison of A and B. If A is |
| less than B, they return 0; if A is greater than B, they return 2; |
| and if A and B are equal they return 1. |
| |
| -- Runtime Function: int __ucmpdi2 (unsigned long A, unsigned long B) |
| -- Runtime Function: int __ucmpti2 (unsigned long long A, unsigned long |
| long B) |
| These functions perform an unsigned comparison of A and B. If A is |
| less than B, they return 0; if A is greater than B, they return 2; |
| and if A and B are equal they return 1. |
| |
| 4.1.3 Trapping arithmetic functions |
| ----------------------------------- |
| |
| The following functions implement trapping arithmetic. These functions |
| call the libc function 'abort' upon signed arithmetic overflow. |
| |
| -- Runtime Function: int __absvsi2 (int A) |
| -- Runtime Function: long __absvdi2 (long A) |
| These functions return the absolute value of A. |
| |
| -- Runtime Function: int __addvsi3 (int A, int B) |
| -- Runtime Function: long __addvdi3 (long A, long B) |
| These functions return the sum of A and B; that is 'A + B'. |
| |
| -- Runtime Function: int __mulvsi3 (int A, int B) |
| -- Runtime Function: long __mulvdi3 (long A, long B) |
| The functions return the product of A and B; that is 'A * B'. |
| |
| -- Runtime Function: int __negvsi2 (int A) |
| -- Runtime Function: long __negvdi2 (long A) |
| These functions return the negation of A; that is '-A'. |
| |
| -- Runtime Function: int __subvsi3 (int A, int B) |
| -- Runtime Function: long __subvdi3 (long A, long B) |
| These functions return the difference between B and A; that is 'A - |
| B'. |
| |
| 4.1.4 Bit operations |
| -------------------- |
| |
| -- Runtime Function: int __clzsi2 (int A) |
| -- Runtime Function: int __clzdi2 (long A) |
| -- Runtime Function: int __clzti2 (long long A) |
| These functions return the number of leading 0-bits in A, starting |
| at the most significant bit position. If A is zero, the result is |
| undefined. |
| |
| -- Runtime Function: int __ctzsi2 (int A) |
| -- Runtime Function: int __ctzdi2 (long A) |
| -- Runtime Function: int __ctzti2 (long long A) |
| These functions return the number of trailing 0-bits in A, starting |
| at the least significant bit position. If A is zero, the result is |
| undefined. |
| |
| -- Runtime Function: int __ffsdi2 (long A) |
| -- Runtime Function: int __ffsti2 (long long A) |
| These functions return the index of the least significant 1-bit in |
| A, or the value zero if A is zero. The least significant bit is |
| index one. |
| |
| -- Runtime Function: int __paritysi2 (int A) |
| -- Runtime Function: int __paritydi2 (long A) |
| -- Runtime Function: int __parityti2 (long long A) |
| These functions return the value zero if the number of bits set in |
| A is even, and the value one otherwise. |
| |
| -- Runtime Function: int __popcountsi2 (int A) |
| -- Runtime Function: int __popcountdi2 (long A) |
| -- Runtime Function: int __popcountti2 (long long A) |
| These functions return the number of bits set in A. |
| |
| -- Runtime Function: int32_t __bswapsi2 (int32_t A) |
| -- Runtime Function: int64_t __bswapdi2 (int64_t A) |
| These functions return the A byteswapped. |
| |
| |
| File: gccint.info, Node: Soft float library routines, Next: Decimal float library routines, Prev: Integer library routines, Up: Libgcc |
| |
| 4.2 Routines for floating point emulation |
| ========================================= |
| |
| The software floating point library is used on machines which do not |
| have hardware support for floating point. It is also used whenever |
| '-msoft-float' is used to disable generation of floating point |
| instructions. (Not all targets support this switch.) |
| |
| For compatibility with other compilers, the floating point emulation |
| routines can be renamed with the 'DECLARE_LIBRARY_RENAMES' macro (*note |
| Library Calls::). In this section, the default names are used. |
| |
| Presently the library does not support 'XFmode', which is used for |
| 'long double' on some architectures. |
| |
| 4.2.1 Arithmetic functions |
| -------------------------- |
| |
| -- Runtime Function: float __addsf3 (float A, float B) |
| -- Runtime Function: double __adddf3 (double A, double B) |
| -- Runtime Function: long double __addtf3 (long double A, long double |
| B) |
| -- Runtime Function: long double __addxf3 (long double A, long double |
| B) |
| These functions return the sum of A and B. |
| |
| -- Runtime Function: float __subsf3 (float A, float B) |
| -- Runtime Function: double __subdf3 (double A, double B) |
| -- Runtime Function: long double __subtf3 (long double A, long double |
| B) |
| -- Runtime Function: long double __subxf3 (long double A, long double |
| B) |
| These functions return the difference between B and A; that is, |
| A - B. |
| |
| -- Runtime Function: float __mulsf3 (float A, float B) |
| -- Runtime Function: double __muldf3 (double A, double B) |
| -- Runtime Function: long double __multf3 (long double A, long double |
| B) |
| -- Runtime Function: long double __mulxf3 (long double A, long double |
| B) |
| These functions return the product of A and B. |
| |
| -- Runtime Function: float __divsf3 (float A, float B) |
| -- Runtime Function: double __divdf3 (double A, double B) |
| -- Runtime Function: long double __divtf3 (long double A, long double |
| B) |
| -- Runtime Function: long double __divxf3 (long double A, long double |
| B) |
| These functions return the quotient of A and B; that is, A / B. |
| |
| -- Runtime Function: float __negsf2 (float A) |
| -- Runtime Function: double __negdf2 (double A) |
| -- Runtime Function: long double __negtf2 (long double A) |
| -- Runtime Function: long double __negxf2 (long double A) |
| These functions return the negation of A. They simply flip the |
| sign bit, so they can produce negative zero and negative NaN. |
| |
| 4.2.2 Conversion functions |
| -------------------------- |
| |
| -- Runtime Function: double __extendsfdf2 (float A) |
| -- Runtime Function: long double __extendsftf2 (float A) |
| -- Runtime Function: long double __extendsfxf2 (float A) |
| -- Runtime Function: long double __extenddftf2 (double A) |
| -- Runtime Function: long double __extenddfxf2 (double A) |
| These functions extend A to the wider mode of their return type. |
| |
| -- Runtime Function: double __truncxfdf2 (long double A) |
| -- Runtime Function: double __trunctfdf2 (long double A) |
| -- Runtime Function: float __truncxfsf2 (long double A) |
| -- Runtime Function: float __trunctfsf2 (long double A) |
| -- Runtime Function: float __truncdfsf2 (double A) |
| These functions truncate A to the narrower mode of their return |
| type, rounding toward zero. |
| |
| -- Runtime Function: int __fixsfsi (float A) |
| -- Runtime Function: int __fixdfsi (double A) |
| -- Runtime Function: int __fixtfsi (long double A) |
| -- Runtime Function: int __fixxfsi (long double A) |
| These functions convert A to a signed integer, rounding toward |
| zero. |
| |
| -- Runtime Function: long __fixsfdi (float A) |
| -- Runtime Function: long __fixdfdi (double A) |
| -- Runtime Function: long __fixtfdi (long double A) |
| -- Runtime Function: long __fixxfdi (long double A) |
| These functions convert A to a signed long, rounding toward zero. |
| |
| -- Runtime Function: long long __fixsfti (float A) |
| -- Runtime Function: long long __fixdfti (double A) |
| -- Runtime Function: long long __fixtfti (long double A) |
| -- Runtime Function: long long __fixxfti (long double A) |
| These functions convert A to a signed long long, rounding toward |
| zero. |
| |
| -- Runtime Function: unsigned int __fixunssfsi (float A) |
| -- Runtime Function: unsigned int __fixunsdfsi (double A) |
| -- Runtime Function: unsigned int __fixunstfsi (long double A) |
| -- Runtime Function: unsigned int __fixunsxfsi (long double A) |
| These functions convert A to an unsigned integer, rounding toward |
| zero. Negative values all become zero. |
| |
| -- Runtime Function: unsigned long __fixunssfdi (float A) |
| -- Runtime Function: unsigned long __fixunsdfdi (double A) |
| -- Runtime Function: unsigned long __fixunstfdi (long double A) |
| -- Runtime Function: unsigned long __fixunsxfdi (long double A) |
| These functions convert A to an unsigned long, rounding toward |
| zero. Negative values all become zero. |
| |
| -- Runtime Function: unsigned long long __fixunssfti (float A) |
| -- Runtime Function: unsigned long long __fixunsdfti (double A) |
| -- Runtime Function: unsigned long long __fixunstfti (long double A) |
| -- Runtime Function: unsigned long long __fixunsxfti (long double A) |
| These functions convert A to an unsigned long long, rounding toward |
| zero. Negative values all become zero. |
| |
| -- Runtime Function: float __floatsisf (int I) |
| -- Runtime Function: double __floatsidf (int I) |
| -- Runtime Function: long double __floatsitf (int I) |
| -- Runtime Function: long double __floatsixf (int I) |
| These functions convert I, a signed integer, to floating point. |
| |
| -- Runtime Function: float __floatdisf (long I) |
| -- Runtime Function: double __floatdidf (long I) |
| -- Runtime Function: long double __floatditf (long I) |
| -- Runtime Function: long double __floatdixf (long I) |
| These functions convert I, a signed long, to floating point. |
| |
| -- Runtime Function: float __floattisf (long long I) |
| -- Runtime Function: double __floattidf (long long I) |
| -- Runtime Function: long double __floattitf (long long I) |
| -- Runtime Function: long double __floattixf (long long I) |
| These functions convert I, a signed long long, to floating point. |
| |
| -- Runtime Function: float __floatunsisf (unsigned int I) |
| -- Runtime Function: double __floatunsidf (unsigned int I) |
| -- Runtime Function: long double __floatunsitf (unsigned int I) |
| -- Runtime Function: long double __floatunsixf (unsigned int I) |
| These functions convert I, an unsigned integer, to floating point. |
| |
| -- Runtime Function: float __floatundisf (unsigned long I) |
| -- Runtime Function: double __floatundidf (unsigned long I) |
| -- Runtime Function: long double __floatunditf (unsigned long I) |
| -- Runtime Function: long double __floatundixf (unsigned long I) |
| These functions convert I, an unsigned long, to floating point. |
| |
| -- Runtime Function: float __floatuntisf (unsigned long long I) |
| -- Runtime Function: double __floatuntidf (unsigned long long I) |
| -- Runtime Function: long double __floatuntitf (unsigned long long I) |
| -- Runtime Function: long double __floatuntixf (unsigned long long I) |
| These functions convert I, an unsigned long long, to floating |
| point. |
| |
| 4.2.3 Comparison functions |
| -------------------------- |
| |
| There are two sets of basic comparison functions. |
| |
| -- Runtime Function: int __cmpsf2 (float A, float B) |
| -- Runtime Function: int __cmpdf2 (double A, double B) |
| -- Runtime Function: int __cmptf2 (long double A, long double B) |
| These functions calculate a <=> b. That is, if A is less than B, |
| they return -1; if A is greater than B, they return 1; and if A and |
| B are equal they return 0. If either argument is NaN they return |
| 1, but you should not rely on this; if NaN is a possibility, use |
| one of the higher-level comparison functions. |
| |
| -- Runtime Function: int __unordsf2 (float A, float B) |
| -- Runtime Function: int __unorddf2 (double A, double B) |
| -- Runtime Function: int __unordtf2 (long double A, long double B) |
| These functions return a nonzero value if either argument is NaN, |
| otherwise 0. |
| |
| There is also a complete group of higher level functions which |
| correspond directly to comparison operators. They implement the ISO C |
| semantics for floating-point comparisons, taking NaN into account. Pay |
| careful attention to the return values defined for each set. Under the |
| hood, all of these routines are implemented as |
| |
| if (__unordXf2 (a, b)) |
| return E; |
| return __cmpXf2 (a, b); |
| |
| where E is a constant chosen to give the proper behavior for NaN. Thus, |
| the meaning of the return value is different for each set. Do not rely |
| on this implementation; only the semantics documented below are |
| guaranteed. |
| |
| -- Runtime Function: int __eqsf2 (float A, float B) |
| -- Runtime Function: int __eqdf2 (double A, double B) |
| -- Runtime Function: int __eqtf2 (long double A, long double B) |
| These functions return zero if neither argument is NaN, and A and B |
| are equal. |
| |
| -- Runtime Function: int __nesf2 (float A, float B) |
| -- Runtime Function: int __nedf2 (double A, double B) |
| -- Runtime Function: int __netf2 (long double A, long double B) |
| These functions return a nonzero value if either argument is NaN, |
| or if A and B are unequal. |
| |
| -- Runtime Function: int __gesf2 (float A, float B) |
| -- Runtime Function: int __gedf2 (double A, double B) |
| -- Runtime Function: int __getf2 (long double A, long double B) |
| These functions return a value greater than or equal to zero if |
| neither argument is NaN, and A is greater than or equal to B. |
| |
| -- Runtime Function: int __ltsf2 (float A, float B) |
| -- Runtime Function: int __ltdf2 (double A, double B) |
| -- Runtime Function: int __lttf2 (long double A, long double B) |
| These functions return a value less than zero if neither argument |
| is NaN, and A is strictly less than B. |
| |
| -- Runtime Function: int __lesf2 (float A, float B) |
| -- Runtime Function: int __ledf2 (double A, double B) |
| -- Runtime Function: int __letf2 (long double A, long double B) |
| These functions return a value less than or equal to zero if |
| neither argument is NaN, and A is less than or equal to B. |
| |
| -- Runtime Function: int __gtsf2 (float A, float B) |
| -- Runtime Function: int __gtdf2 (double A, double B) |
| -- Runtime Function: int __gttf2 (long double A, long double B) |
| These functions return a value greater than zero if neither |
| argument is NaN, and A is strictly greater than B. |
| |
| 4.2.4 Other floating-point functions |
| ------------------------------------ |
| |
| -- Runtime Function: float __powisf2 (float A, int B) |
| -- Runtime Function: double __powidf2 (double A, int B) |
| -- Runtime Function: long double __powitf2 (long double A, int B) |
| -- Runtime Function: long double __powixf2 (long double A, int B) |
| These functions convert raise A to the power B. |
| |
| -- Runtime Function: complex float __mulsc3 (float A, float B, float C, |
| float D) |
| -- Runtime Function: complex double __muldc3 (double A, double B, |
| double C, double D) |
| -- Runtime Function: complex long double __multc3 (long double A, long |
| double B, long double C, long double D) |
| -- Runtime Function: complex long double __mulxc3 (long double A, long |
| double B, long double C, long double D) |
| These functions return the product of A + iB and C + iD, following |
| the rules of C99 Annex G. |
| |
| -- Runtime Function: complex float __divsc3 (float A, float B, float C, |
| float D) |
| -- Runtime Function: complex double __divdc3 (double A, double B, |
| double C, double D) |
| -- Runtime Function: complex long double __divtc3 (long double A, long |
| double B, long double C, long double D) |
| -- Runtime Function: complex long double __divxc3 (long double A, long |
| double B, long double C, long double D) |
| These functions return the quotient of A + iB and C + iD (i.e., (A |
| + iB) / (C + iD)), following the rules of C99 Annex G. |
| |
| |
| File: gccint.info, Node: Decimal float library routines, Next: Fixed-point fractional library routines, Prev: Soft float library routines, Up: Libgcc |
| |
| 4.3 Routines for decimal floating point emulation |
| ================================================= |
| |
| The software decimal floating point library implements IEEE 754R decimal |
| floating point arithmetic and is only activated on selected targets. |
| |
| The software decimal floating point library supports either DPD |
| (Densely Packed Decimal) or BID (Binary Integer Decimal) encoding as |
| selected at configure time. |
| |
| 4.3.1 Arithmetic functions |
| -------------------------- |
| |
| -- Runtime Function: _Decimal32 __dpd_addsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal32 __bid_addsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal64 __dpd_adddd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal64 __bid_adddd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal128 __dpd_addtd3 (_Decimal128 A, |
| _Decimal128 B) |
| -- Runtime Function: _Decimal128 __bid_addtd3 (_Decimal128 A, |
| _Decimal128 B) |
| These functions return the sum of A and B. |
| |
| -- Runtime Function: _Decimal32 __dpd_subsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal32 __bid_subsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal64 __dpd_subdd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal64 __bid_subdd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal128 __dpd_subtd3 (_Decimal128 A, |
| _Decimal128 B) |
| -- Runtime Function: _Decimal128 __bid_subtd3 (_Decimal128 A, |
| _Decimal128 B) |
| These functions return the difference between B and A; that is, |
| A - B. |
| |
| -- Runtime Function: _Decimal32 __dpd_mulsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal32 __bid_mulsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal64 __dpd_muldd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal64 __bid_muldd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal128 __dpd_multd3 (_Decimal128 A, |
| _Decimal128 B) |
| -- Runtime Function: _Decimal128 __bid_multd3 (_Decimal128 A, |
| _Decimal128 B) |
| These functions return the product of A and B. |
| |
| -- Runtime Function: _Decimal32 __dpd_divsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal32 __bid_divsd3 (_Decimal32 A, _Decimal32 |
| B) |
| -- Runtime Function: _Decimal64 __dpd_divdd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal64 __bid_divdd3 (_Decimal64 A, _Decimal64 |
| B) |
| -- Runtime Function: _Decimal128 __dpd_divtd3 (_Decimal128 A, |
| _Decimal128 B) |
| -- Runtime Function: _Decimal128 __bid_divtd3 (_Decimal128 A, |
| _Decimal128 B) |
| These functions return the quotient of A and B; that is, A / B. |
| |
| -- Runtime Function: _Decimal32 __dpd_negsd2 (_Decimal32 A) |
| -- Runtime Function: _Decimal32 __bid_negsd2 (_Decimal32 A) |
| -- Runtime Function: _Decimal64 __dpd_negdd2 (_Decimal64 A) |
| -- Runtime Function: _Decimal64 __bid_negdd2 (_Decimal64 A) |
| -- Runtime Function: _Decimal128 __dpd_negtd2 (_Decimal128 A) |
| -- Runtime Function: _Decimal128 __bid_negtd2 (_Decimal128 A) |
| These functions return the negation of A. They simply flip the |
| sign bit, so they can produce negative zero and negative NaN. |
| |
| 4.3.2 Conversion functions |
| -------------------------- |
| |
| -- Runtime Function: _Decimal64 __dpd_extendsddd2 (_Decimal32 A) |
| -- Runtime Function: _Decimal64 __bid_extendsddd2 (_Decimal32 A) |
| -- Runtime Function: _Decimal128 __dpd_extendsdtd2 (_Decimal32 A) |
| -- Runtime Function: _Decimal128 __bid_extendsdtd2 (_Decimal32 A) |
| -- Runtime Function: _Decimal128 __dpd_extendddtd2 (_Decimal64 A) |
| -- Runtime Function: _Decimal128 __bid_extendddtd2 (_Decimal64 A) |
| -- Runtime Function: _Decimal32 __dpd_truncddsd2 (_Decimal64 A) |
| -- Runtime Function: _Decimal32 __bid_truncddsd2 (_Decimal64 A) |
| -- Runtime Function: _Decimal32 __dpd_trunctdsd2 (_Decimal128 A) |
| -- Runtime Function: _Decimal32 __bid_trunctdsd2 (_Decimal128 A) |
| -- Runtime Function: _Decimal64 __dpd_trunctddd2 (_Decimal128 A) |
| -- Runtime Function: _Decimal64 __bid_trunctddd2 (_Decimal128 A) |
| These functions convert the value A from one decimal floating type |
| to another. |
| |
| -- Runtime Function: _Decimal64 __dpd_extendsfdd (float A) |
| -- Runtime Function: _Decimal64 __bid_extendsfdd (float A) |
| -- Runtime Function: _Decimal128 __dpd_extendsftd (float A) |
| -- Runtime Function: _Decimal128 __bid_extendsftd (float A) |
| -- Runtime Function: _Decimal128 __dpd_extenddftd (double A) |
| -- Runtime Function: _Decimal128 __bid_extenddftd (double A) |
| -- Runtime Function: _Decimal128 __dpd_extendxftd (long double A) |
| -- Runtime Function: _Decimal128 __bid_extendxftd (long double A) |
| -- Runtime Function: _Decimal32 __dpd_truncdfsd (double A) |
| -- Runtime Function: _Decimal32 __bid_truncdfsd (double A) |
| -- Runtime Function: _Decimal32 __dpd_truncxfsd (long double A) |
| -- Runtime Function: _Decimal32 __bid_truncxfsd (long double A) |
| -- Runtime Function: _Decimal32 __dpd_trunctfsd (long double A) |
| -- Runtime Function: _Decimal32 __bid_trunctfsd (long double A) |
| -- Runtime Function: _Decimal64 __dpd_truncxfdd (long double A) |
| -- Runtime Function: _Decimal64 __bid_truncxfdd (long double A) |
| -- Runtime Function: _Decimal64 __dpd_trunctfdd (long double A) |
| -- Runtime Function: _Decimal64 __bid_trunctfdd (long double A) |
| These functions convert the value of A from a binary floating type |
| to a decimal floating type of a different size. |
| |
| -- Runtime Function: float __dpd_truncddsf (_Decimal64 A) |
| -- Runtime Function: float __bid_truncddsf (_Decimal64 A) |
| -- Runtime Function: float __dpd_trunctdsf (_Decimal128 A) |
| -- Runtime Function: float __bid_trunctdsf (_Decimal128 A) |
| -- Runtime Function: double __dpd_extendsddf (_Decimal32 A) |
| -- Runtime Function: double __bid_extendsddf (_Decimal32 A) |
| -- Runtime Function: double __dpd_trunctddf (_Decimal128 A) |
| -- Runtime Function: double __bid_trunctddf (_Decimal128 A) |
| -- Runtime Function: long double __dpd_extendsdxf (_Decimal32 A) |
| -- Runtime Function: long double __bid_extendsdxf (_Decimal32 A) |
| -- Runtime Function: long double __dpd_extendddxf (_Decimal64 A) |
| -- Runtime Function: long double __bid_extendddxf (_Decimal64 A) |
| -- Runtime Function: long double __dpd_trunctdxf (_Decimal128 A) |
| -- Runtime Function: long double __bid_trunctdxf (_Decimal128 A) |
| -- Runtime Function: long double __dpd_extendsdtf (_Decimal32 A) |
| -- Runtime Function: long double __bid_extendsdtf (_Decimal32 A) |
| -- Runtime Function: long double __dpd_extendddtf (_Decimal64 A) |
| -- Runtime Function: long double __bid_extendddtf (_Decimal64 A) |
| These functions convert the value of A from a decimal floating type |
| to a binary floating type of a different size. |
| |
| -- Runtime Function: _Decimal32 __dpd_extendsfsd (float A) |
| -- Runtime Function: _Decimal32 __bid_extendsfsd (float A) |
| -- Runtime Function: _Decimal64 __dpd_extenddfdd (double A) |
| -- Runtime Function: _Decimal64 __bid_extenddfdd (double A) |
| -- Runtime Function: _Decimal128 __dpd_extendtftd (long double A) |
| -- Runtime Function: _Decimal128 __bid_extendtftd (long double A) |
| -- Runtime Function: float __dpd_truncsdsf (_Decimal32 A) |
| -- Runtime Function: float __bid_truncsdsf (_Decimal32 A) |
| -- Runtime Function: double __dpd_truncdddf (_Decimal64 A) |
| -- Runtime Function: double __bid_truncdddf (_Decimal64 A) |
| -- Runtime Function: long double __dpd_trunctdtf (_Decimal128 A) |
| -- Runtime Function: long double __bid_trunctdtf (_Decimal128 A) |
| These functions convert the value of A between decimal and binary |
| floating types of the same size. |
| |
| -- Runtime Function: int __dpd_fixsdsi (_Decimal32 A) |
| -- Runtime Function: int __bid_fixsdsi (_Decimal32 A) |
| -- Runtime Function: int __dpd_fixddsi (_Decimal64 A) |
| -- Runtime Function: int __bid_fixddsi (_Decimal64 A) |
| -- Runtime Function: int __dpd_fixtdsi (_Decimal128 A) |
| -- Runtime Function: int __bid_fixtdsi (_Decimal128 A) |
| These functions convert A to a signed integer. |
| |
| -- Runtime Function: long __dpd_fixsddi (_Decimal32 A) |
| -- Runtime Function: long __bid_fixsddi (_Decimal32 A) |
| -- Runtime Function: long __dpd_fixdddi (_Decimal64 A) |
| -- Runtime Function: long __bid_fixdddi (_Decimal64 A) |
| -- Runtime Function: long __dpd_fixtddi (_Decimal128 A) |
| -- Runtime Function: long __bid_fixtddi (_Decimal128 A) |
| These functions convert A to a signed long. |
| |
| -- Runtime Function: unsigned int __dpd_fixunssdsi (_Decimal32 A) |
| -- Runtime Function: unsigned int __bid_fixunssdsi (_Decimal32 A) |
| -- Runtime Function: unsigned int __dpd_fixunsddsi (_Decimal64 A) |
| -- Runtime Function: unsigned int __bid_fixunsddsi (_Decimal64 A) |
| -- Runtime Function: unsigned int __dpd_fixunstdsi (_Decimal128 A) |
| -- Runtime Function: unsigned int __bid_fixunstdsi (_Decimal128 A) |
| These functions convert A to an unsigned integer. Negative values |
| all become zero. |
| |
| -- Runtime Function: unsigned long __dpd_fixunssddi (_Decimal32 A) |
| -- Runtime Function: unsigned long __bid_fixunssddi (_Decimal32 A) |
| -- Runtime Function: unsigned long __dpd_fixunsdddi (_Decimal64 A) |
| -- Runtime Function: unsigned long __bid_fixunsdddi (_Decimal64 A) |
| -- Runtime Function: unsigned long __dpd_fixunstddi (_Decimal128 A) |
| -- Runtime Function: unsigned long __bid_fixunstddi (_Decimal128 A) |
| These functions convert A to an unsigned long. Negative values all |
| become zero. |
| |
| -- Runtime Function: _Decimal32 __dpd_floatsisd (int I) |
| -- Runtime Function: _Decimal32 __bid_floatsisd (int I) |
| -- Runtime Function: _Decimal64 __dpd_floatsidd (int I) |
| -- Runtime Function: _Decimal64 __bid_floatsidd (int I) |
| -- Runtime Function: _Decimal128 __dpd_floatsitd (int I) |
| -- Runtime Function: _Decimal128 __bid_floatsitd (int I) |
| These functions convert I, a signed integer, to decimal floating |
| point. |
| |
| -- Runtime Function: _Decimal32 __dpd_floatdisd (long I) |
| -- Runtime Function: _Decimal32 __bid_floatdisd (long I) |
| -- Runtime Function: _Decimal64 __dpd_floatdidd (long I) |
| -- Runtime Function: _Decimal64 __bid_floatdidd (long I) |
| -- Runtime Function: _Decimal128 __dpd_floatditd (long I) |
| -- Runtime Function: _Decimal128 __bid_floatditd (long I) |
| These functions convert I, a signed long, to decimal floating |
| point. |
| |
| -- Runtime Function: _Decimal32 __dpd_floatunssisd (unsigned int I) |
| -- Runtime Function: _Decimal32 __bid_floatunssisd (unsigned int I) |
| -- Runtime Function: _Decimal64 __dpd_floatunssidd (unsigned int I) |
| -- Runtime Function: _Decimal64 __bid_floatunssidd (unsigned int I) |
| -- Runtime Function: _Decimal128 __dpd_floatunssitd (unsigned int I) |
| -- Runtime Function: _Decimal128 __bid_floatunssitd (unsigned int I) |
| These functions convert I, an unsigned integer, to decimal floating |
| point. |
| |
| -- Runtime Function: _Decimal32 __dpd_floatunsdisd (unsigned long I) |
| -- Runtime Function: _Decimal32 __bid_floatunsdisd (unsigned long I) |
| -- Runtime Function: _Decimal64 __dpd_floatunsdidd (unsigned long I) |
| -- Runtime Function: _Decimal64 __bid_floatunsdidd (unsigned long I) |
| -- Runtime Function: _Decimal128 __dpd_floatunsditd (unsigned long I) |
| -- Runtime Function: _Decimal128 __bid_floatunsditd (unsigned long I) |
| These functions convert I, an unsigned long, to decimal floating |
| point. |
| |
| 4.3.3 Comparison functions |
| -------------------------- |
| |
| -- Runtime Function: int __dpd_unordsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __bid_unordsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __dpd_unorddd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __bid_unorddd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __dpd_unordtd2 (_Decimal128 A, _Decimal128 B) |
| -- Runtime Function: int __bid_unordtd2 (_Decimal128 A, _Decimal128 B) |
| These functions return a nonzero value if either argument is NaN, |
| otherwise 0. |
| |
| There is also a complete group of higher level functions which |
| correspond directly to comparison operators. They implement the ISO C |
| semantics for floating-point comparisons, taking NaN into account. Pay |
| careful attention to the return values defined for each set. Under the |
| hood, all of these routines are implemented as |
| |
| if (__bid_unordXd2 (a, b)) |
| return E; |
| return __bid_cmpXd2 (a, b); |
| |
| where E is a constant chosen to give the proper behavior for NaN. Thus, |
| the meaning of the return value is different for each set. Do not rely |
| on this implementation; only the semantics documented below are |
| guaranteed. |
| |
| -- Runtime Function: int __dpd_eqsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __bid_eqsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __dpd_eqdd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __bid_eqdd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __dpd_eqtd2 (_Decimal128 A, _Decimal128 B) |
| -- Runtime Function: int __bid_eqtd2 (_Decimal128 A, _Decimal128 B) |
| These functions return zero if neither argument is NaN, and A and B |
| are equal. |
| |
| -- Runtime Function: int __dpd_nesd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __bid_nesd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __dpd_nedd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __bid_nedd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __dpd_netd2 (_Decimal128 A, _Decimal128 B) |
| -- Runtime Function: int __bid_netd2 (_Decimal128 A, _Decimal128 B) |
| These functions return a nonzero value if either argument is NaN, |
| or if A and B are unequal. |
| |
| -- Runtime Function: int __dpd_gesd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __bid_gesd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __dpd_gedd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __bid_gedd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __dpd_getd2 (_Decimal128 A, _Decimal128 B) |
| -- Runtime Function: int __bid_getd2 (_Decimal128 A, _Decimal128 B) |
| These functions return a value greater than or equal to zero if |
| neither argument is NaN, and A is greater than or equal to B. |
| |
| -- Runtime Function: int __dpd_ltsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __bid_ltsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __dpd_ltdd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __bid_ltdd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __dpd_lttd2 (_Decimal128 A, _Decimal128 B) |
| -- Runtime Function: int __bid_lttd2 (_Decimal128 A, _Decimal128 B) |
| These functions return a value less than zero if neither argument |
| is NaN, and A is strictly less than B. |
| |
| -- Runtime Function: int __dpd_lesd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __bid_lesd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __dpd_ledd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __bid_ledd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __dpd_letd2 (_Decimal128 A, _Decimal128 B) |
| -- Runtime Function: int __bid_letd2 (_Decimal128 A, _Decimal128 B) |
| These functions return a value less than or equal to zero if |
| neither argument is NaN, and A is less than or equal to B. |
| |
| -- Runtime Function: int __dpd_gtsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __bid_gtsd2 (_Decimal32 A, _Decimal32 B) |
| -- Runtime Function: int __dpd_gtdd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __bid_gtdd2 (_Decimal64 A, _Decimal64 B) |
| -- Runtime Function: int __dpd_gttd2 (_Decimal128 A, _Decimal128 B) |
| -- Runtime Function: int __bid_gttd2 (_Decimal128 A, _Decimal128 B) |
| These functions return a value greater than zero if neither |
| argument is NaN, and A is strictly greater than B. |
| |
| |
| File: gccint.info, Node: Fixed-point fractional library routines, Next: Exception handling routines, Prev: Decimal float library routines, Up: Libgcc |
| |
| 4.4 Routines for fixed-point fractional emulation |
| ================================================= |
| |
| The software fixed-point library implements fixed-point fractional |
| arithmetic, and is only activated on selected targets. |
| |
| For ease of comprehension 'fract' is an alias for the '_Fract' type, |
| 'accum' an alias for '_Accum', and 'sat' an alias for '_Sat'. |
| |
| For illustrative purposes, in this section the fixed-point fractional |
| type 'short fract' is assumed to correspond to machine mode 'QQmode'; |
| 'unsigned short fract' to 'UQQmode'; 'fract' to 'HQmode'; |
| 'unsigned fract' to 'UHQmode'; 'long fract' to 'SQmode'; |
| 'unsigned long fract' to 'USQmode'; 'long long fract' to 'DQmode'; and |
| 'unsigned long long fract' to 'UDQmode'. Similarly the fixed-point |
| accumulator type 'short accum' corresponds to 'HAmode'; |
| 'unsigned short accum' to 'UHAmode'; 'accum' to 'SAmode'; |
| 'unsigned accum' to 'USAmode'; 'long accum' to 'DAmode'; |
| 'unsigned long accum' to 'UDAmode'; 'long long accum' to 'TAmode'; and |
| 'unsigned long long accum' to 'UTAmode'. |
| |
| 4.4.1 Arithmetic functions |
| -------------------------- |
| |
| -- Runtime Function: short fract __addqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __addhq3 (fract A, fract B) |
| -- Runtime Function: long fract __addsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __adddq3 (long long fract A, long |
| long fract B) |
| -- Runtime Function: unsigned short fract __adduqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __adduhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __addusq3 (unsigned long fract |
| A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __addudq3 (unsigned long |
| long fract A, unsigned long long fract B) |
| -- Runtime Function: short accum __addha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __addsa3 (accum A, accum B) |
| -- Runtime Function: long accum __addda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __addta3 (long long accum A, long |
| long accum B) |
| -- Runtime Function: unsigned short accum __adduha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __addusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __adduda3 (unsigned long accum |
| A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __adduta3 (unsigned long |
| long accum A, unsigned long long accum B) |
| These functions return the sum of A and B. |
| |
| -- Runtime Function: short fract __ssaddqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __ssaddhq3 (fract A, fract B) |
| -- Runtime Function: long fract __ssaddsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __ssadddq3 (long long fract A, |
| long long fract B) |
| -- Runtime Function: short accum __ssaddha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __ssaddsa3 (accum A, accum B) |
| -- Runtime Function: long accum __ssaddda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __ssaddta3 (long long accum A, |
| long long accum B) |
| These functions return the sum of A and B with signed saturation. |
| |
| -- Runtime Function: unsigned short fract __usadduqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __usadduhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __usaddusq3 (unsigned long |
| fract A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __usaddudq3 (unsigned |
| long long fract A, unsigned long long fract B) |
| -- Runtime Function: unsigned short accum __usadduha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __usaddusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __usadduda3 (unsigned long |
| accum A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __usadduta3 (unsigned |
| long long accum A, unsigned long long accum B) |
| These functions return the sum of A and B with unsigned saturation. |
| |
| -- Runtime Function: short fract __subqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __subhq3 (fract A, fract B) |
| -- Runtime Function: long fract __subsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __subdq3 (long long fract A, long |
| long fract B) |
| -- Runtime Function: unsigned short fract __subuqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __subuhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __subusq3 (unsigned long fract |
| A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __subudq3 (unsigned long |
| long fract A, unsigned long long fract B) |
| -- Runtime Function: short accum __subha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __subsa3 (accum A, accum B) |
| -- Runtime Function: long accum __subda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __subta3 (long long accum A, long |
| long accum B) |
| -- Runtime Function: unsigned short accum __subuha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __subusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __subuda3 (unsigned long accum |
| A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __subuta3 (unsigned long |
| long accum A, unsigned long long accum B) |
| These functions return the difference of A and B; that is, 'A - B'. |
| |
| -- Runtime Function: short fract __sssubqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __sssubhq3 (fract A, fract B) |
| -- Runtime Function: long fract __sssubsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __sssubdq3 (long long fract A, |
| long long fract B) |
| -- Runtime Function: short accum __sssubha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __sssubsa3 (accum A, accum B) |
| -- Runtime Function: long accum __sssubda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __sssubta3 (long long accum A, |
| long long accum B) |
| These functions return the difference of A and B with signed |
| saturation; that is, 'A - B'. |
| |
| -- Runtime Function: unsigned short fract __ussubuqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __ussubuhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __ussubusq3 (unsigned long |
| fract A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __ussubudq3 (unsigned |
| long long fract A, unsigned long long fract B) |
| -- Runtime Function: unsigned short accum __ussubuha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __ussubusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __ussubuda3 (unsigned long |
| accum A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __ussubuta3 (unsigned |
| long long accum A, unsigned long long accum B) |
| These functions return the difference of A and B with unsigned |
| saturation; that is, 'A - B'. |
| |
| -- Runtime Function: short fract __mulqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __mulhq3 (fract A, fract B) |
| -- Runtime Function: long fract __mulsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __muldq3 (long long fract A, long |
| long fract B) |
| -- Runtime Function: unsigned short fract __muluqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __muluhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __mulusq3 (unsigned long fract |
| A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __muludq3 (unsigned long |
| long fract A, unsigned long long fract B) |
| -- Runtime Function: short accum __mulha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __mulsa3 (accum A, accum B) |
| -- Runtime Function: long accum __mulda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __multa3 (long long accum A, long |
| long accum B) |
| -- Runtime Function: unsigned short accum __muluha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __mulusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __muluda3 (unsigned long accum |
| A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __muluta3 (unsigned long |
| long accum A, unsigned long long accum B) |
| These functions return the product of A and B. |
| |
| -- Runtime Function: short fract __ssmulqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __ssmulhq3 (fract A, fract B) |
| -- Runtime Function: long fract __ssmulsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __ssmuldq3 (long long fract A, |
| long long fract B) |
| -- Runtime Function: short accum __ssmulha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __ssmulsa3 (accum A, accum B) |
| -- Runtime Function: long accum __ssmulda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __ssmulta3 (long long accum A, |
| long long accum B) |
| These functions return the product of A and B with signed |
| saturation. |
| |
| -- Runtime Function: unsigned short fract __usmuluqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __usmuluhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __usmulusq3 (unsigned long |
| fract A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __usmuludq3 (unsigned |
| long long fract A, unsigned long long fract B) |
| -- Runtime Function: unsigned short accum __usmuluha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __usmulusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __usmuluda3 (unsigned long |
| accum A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __usmuluta3 (unsigned |
| long long accum A, unsigned long long accum B) |
| These functions return the product of A and B with unsigned |
| saturation. |
| |
| -- Runtime Function: short fract __divqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __divhq3 (fract A, fract B) |
| -- Runtime Function: long fract __divsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __divdq3 (long long fract A, long |
| long fract B) |
| -- Runtime Function: short accum __divha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __divsa3 (accum A, accum B) |
| -- Runtime Function: long accum __divda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __divta3 (long long accum A, long |
| long accum B) |
| These functions return the quotient of the signed division of A and |
| B. |
| |
| -- Runtime Function: unsigned short fract __udivuqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __udivuhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __udivusq3 (unsigned long |
| fract A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __udivudq3 (unsigned long |
| long fract A, unsigned long long fract B) |
| -- Runtime Function: unsigned short accum __udivuha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __udivusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __udivuda3 (unsigned long |
| accum A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __udivuta3 (unsigned long |
| long accum A, unsigned long long accum B) |
| These functions return the quotient of the unsigned division of A |
| and B. |
| |
| -- Runtime Function: short fract __ssdivqq3 (short fract A, short fract |
| B) |
| -- Runtime Function: fract __ssdivhq3 (fract A, fract B) |
| -- Runtime Function: long fract __ssdivsq3 (long fract A, long fract B) |
| -- Runtime Function: long long fract __ssdivdq3 (long long fract A, |
| long long fract B) |
| -- Runtime Function: short accum __ssdivha3 (short accum A, short accum |
| B) |
| -- Runtime Function: accum __ssdivsa3 (accum A, accum B) |
| -- Runtime Function: long accum __ssdivda3 (long accum A, long accum B) |
| -- Runtime Function: long long accum __ssdivta3 (long long accum A, |
| long long accum B) |
| These functions return the quotient of the signed division of A and |
| B with signed saturation. |
| |
| -- Runtime Function: unsigned short fract __usdivuqq3 (unsigned short |
| fract A, unsigned short fract B) |
| -- Runtime Function: unsigned fract __usdivuhq3 (unsigned fract A, |
| unsigned fract B) |
| -- Runtime Function: unsigned long fract __usdivusq3 (unsigned long |
| fract A, unsigned long fract B) |
| -- Runtime Function: unsigned long long fract __usdivudq3 (unsigned |
| long long fract A, unsigned long long fract B) |
| -- Runtime Function: unsigned short accum __usdivuha3 (unsigned short |
| accum A, unsigned short accum B) |
| -- Runtime Function: unsigned accum __usdivusa3 (unsigned accum A, |
| unsigned accum B) |
| -- Runtime Function: unsigned long accum __usdivuda3 (unsigned long |
| accum A, unsigned long accum B) |
| -- Runtime Function: unsigned long long accum __usdivuta3 (unsigned |
| long long accum A, unsigned long long accum B) |
| These functions return the quotient of the unsigned division of A |
| and B with unsigned saturation. |
| |
| -- Runtime Function: short fract __negqq2 (short fract A) |
| -- Runtime Function: fract __neghq2 (fract A) |
| -- Runtime Function: long fract __negsq2 (long fract A) |
| -- Runtime Function: long long fract __negdq2 (long long fract A) |
| -- Runtime Function: unsigned short fract __neguqq2 (unsigned short |
| fract A) |
| -- Runtime Function: unsigned fract __neguhq2 (unsigned fract A) |
| -- Runtime Function: unsigned long fract __negusq2 (unsigned long fract |
| A) |
| -- Runtime Function: unsigned long long fract __negudq2 (unsigned long |
| long fract A) |
| -- Runtime Function: short accum __negha2 (short accum A) |
| -- Runtime Function: accum __negsa2 (accum A) |
| -- Runtime Function: long accum __negda2 (long accum A) |
| -- Runtime Function: long long accum __negta2 (long long accum A) |
| -- Runtime Function: unsigned short accum __neguha2 (unsigned short |
| accum A) |
| -- Runtime Function: unsigned accum __negusa2 (unsigned accum A) |
| -- Runtime Function: unsigned long accum __neguda2 (unsigned long accum |
| A) |
| -- Runtime Function: unsigned long long accum __neguta2 (unsigned long |
| long accum A) |
| These functions return the negation of A. |
| |
| -- Runtime Function: short fract __ssnegqq2 (short fract A) |
| -- Runtime Function: fract __ssneghq2 (fract A) |
| -- Runtime Function: long fract __ssnegsq2 (long fract A) |
| -- Runtime Function: long long fract __ssnegdq2 (long long fract A) |
| -- Runtime Function: short accum __ssnegha2 (short accum A) |
| -- Runtime Function: accum __ssnegsa2 (accum A) |
| -- Runtime Function: long accum __ssnegda2 (long accum A) |
| -- Runtime Function: long long accum __ssnegta2 (long long accum A) |
| These functions return the negation of A with signed saturation. |
| |
| -- Runtime Function: unsigned short fract __usneguqq2 (unsigned short |
| fract A) |
| -- Runtime Function: unsigned fract __usneguhq2 (unsigned fract A) |
| -- Runtime Function: unsigned long fract __usnegusq2 (unsigned long |
| fract A) |
| -- Runtime Function: unsigned long long fract __usnegudq2 (unsigned |
| long long fract A) |
| -- Runtime Function: unsigned short accum __usneguha2 (unsigned short |
| accum A) |
| -- Runtime Function: unsigned accum __usnegusa2 (unsigned accum A) |
| -- Runtime Function: unsigned long accum __usneguda2 (unsigned long |
| accum A) |
| -- Runtime Function: unsigned long long accum __usneguta2 (unsigned |
| long long accum A) |
| These functions return the negation of A with unsigned saturation. |
| |
| -- Runtime Function: short fract __ashlqq3 (short fract A, int B) |
| -- Runtime Function: fract __ashlhq3 (fract A, int B) |
| -- Runtime Function: long fract __ashlsq3 (long fract A, int B) |
| -- Runtime Function: long long fract __ashldq3 (long long fract A, int |
| B) |
| -- Runtime Function: unsigned short fract __ashluqq3 (unsigned short |
| fract A, int B) |
| -- Runtime Function: unsigned fract __ashluhq3 (unsigned fract A, int |
| B) |
| -- Runtime Function: unsigned long fract __ashlusq3 (unsigned long |
| fract A, int B) |
| -- Runtime Function: unsigned long long fract __ashludq3 (unsigned long |
| long fract A, int B) |
| -- Runtime Function: short accum __ashlha3 (short accum A, int B) |
| -- Runtime Function: accum __ashlsa3 (accum A, int B) |
| -- Runtime Function: long accum __ashlda3 (long accum A, int B) |
| -- Runtime Function: long long accum __ashlta3 (long long accum A, int |
| B) |
| -- Runtime Function: unsigned short accum __ashluha3 (unsigned short |
| accum A, int B) |
| -- Runtime Function: unsigned accum __ashlusa3 (unsigned accum A, int |
| B) |
| -- Runtime Function: unsigned long accum __ashluda3 (unsigned long |
| accum A, int B) |
| -- Runtime Function: unsigned long long accum __ashluta3 (unsigned long |
| long accum A, int B) |
| These functions return the result of shifting A left by B bits. |
| |
| -- Runtime Function: short fract __ashrqq3 (short fract A, int B) |
| -- Runtime Function: fract __ashrhq3 (fract A, int B) |
| -- Runtime Function: long fract __ashrsq3 (long fract A, int B) |
| -- Runtime Function: long long fract __ashrdq3 (long long fract A, int |
| B) |
| -- Runtime Function: short accum __ashrha3 (short accum A, int B) |
| -- Runtime Function: accum __ashrsa3 (accum A, int B) |
| -- Runtime Function: long accum __ashrda3 (long accum A, int B) |
| -- Runtime Function: long long accum __ashrta3 (long long accum A, int |
| B) |
| These functions return the result of arithmetically shifting A |
| right by B bits. |
| |
| -- Runtime Function: unsigned short fract __lshruqq3 (unsigned short |
| fract A, int B) |
| -- Runtime Function: unsigned fract __lshruhq3 (unsigned fract A, int |
| B) |
| -- Runtime Function: unsigned long fract __lshrusq3 (unsigned long |
| fract A, int B) |
| -- Runtime Function: unsigned long long fract __lshrudq3 (unsigned long |
| long fract A, int B) |
| -- Runtime Function: unsigned short accum __lshruha3 (unsigned short |
| accum A, int B) |
| -- Runtime Function: unsigned accum __lshrusa3 (unsigned accum A, int |
| B) |
| -- Runtime Function: unsigned long accum __lshruda3 (unsigned long |
| accum A, int B) |
| -- Runtime Function: unsigned long long accum __lshruta3 (unsigned long |
| long accum A, int B) |
| These functions return the result of logically shifting A right by |
| B bits. |
| |
| -- Runtime Function: fract __ssashlhq3 (fract A, int B) |
| -- Runtime Function: long fract __ssashlsq3 (long fract A, int B) |
| -- Runtime Function: long long fract __ssashldq3 (long long fract A, |
| int B) |
| -- Runtime Function: short accum __ssashlha3 (short accum A, int B) |
| -- Runtime Function: accum __ssashlsa3 (accum A, int B) |
| -- Runtime Function: long accum __ssashlda3 (long accum A, int B) |
| -- Runtime Function: long long accum __ssashlta3 (long long accum A, |
| int B) |
| These functions return the result of shifting A left by B bits with |
| signed saturation. |
| |
| -- Runtime Function: unsigned short fract __usashluqq3 (unsigned short |
| fract A, int B) |
| -- Runtime Function: unsigned fract __usashluhq3 (unsigned fract A, int |
| B) |
| -- Runtime Function: unsigned long fract __usashlusq3 (unsigned long |
| fract A, int B) |
| -- Runtime Function: unsigned long long fract __usashludq3 (unsigned |
| long long fract A, int B) |
| -- Runtime Function: unsigned short accum __usashluha3 (unsigned short |
| accum A, int B) |
| -- Runtime Function: unsigned accum __usashlusa3 (unsigned accum A, int |
| B) |
| -- Runtime Function: unsigned long accum __usashluda3 (unsigned long |
| accum A, int B) |
| -- Runtime Function: unsigned long long accum __usashluta3 (unsigned |
| long long accum A, int B) |
| These functions return the result of shifting A left by B bits with |
| unsigned saturation. |
| |
| 4.4.2 Comparison functions |
| -------------------------- |
| |
| The following functions implement fixed-point comparisons. These |
| functions implement a low-level compare, upon which the higher level |
| comparison operators (such as less than and greater than or equal to) |
| can be constructed. The returned values lie in the range zero to two, |
| to allow the high-level operators to be implemented by testing the |
| returned result using either signed or unsigned comparison. |
| |
| -- Runtime Function: int __cmpqq2 (short fract A, short fract B) |
| -- Runtime Function: int __cmphq2 (fract A, fract B) |
| -- Runtime Function: int __cmpsq2 (long fract A, long fract B) |
| -- Runtime Function: int __cmpdq2 (long long fract A, long long fract |
| B) |
| -- Runtime Function: int __cmpuqq2 (unsigned short fract A, unsigned |
| short fract B) |
| -- Runtime Function: int __cmpuhq2 (unsigned fract A, unsigned fract B) |
| -- Runtime Function: int __cmpusq2 (unsigned long fract A, unsigned |
| long fract B) |
| -- Runtime Function: int __cmpudq2 (unsigned long long fract A, |
| unsigned long long fract B) |
| -- Runtime Function: int __cmpha2 (short accum A, short accum B) |
| -- Runtime Function: int __cmpsa2 (accum A, accum B) |
| -- Runtime Function: int __cmpda2 (long accum A, long accum B) |
| -- Runtime Function: int __cmpta2 (long long accum A, long long accum |
| B) |
| -- Runtime Function: int __cmpuha2 (unsigned short accum A, unsigned |
| short accum B) |
| -- Runtime Function: int __cmpusa2 (unsigned accum A, unsigned accum B) |
| -- Runtime Function: int __cmpuda2 (unsigned long accum A, unsigned |
| long accum B) |
| -- Runtime Function: int __cmputa2 (unsigned long long accum A, |
| unsigned long long accum B) |
| These functions perform a signed or unsigned comparison of A and B |
| (depending on the selected machine mode). If A is less than B, |
| they return 0; if A is greater than B, they return 2; and if A and |
| B are equal they return 1. |
| |
| 4.4.3 Conversion functions |
| -------------------------- |
| |
| -- Runtime Function: fract __fractqqhq2 (short fract A) |
| -- Runtime Function: long fract __fractqqsq2 (short fract A) |
| -- Runtime Function: long long fract __fractqqdq2 (short fract A) |
| -- Runtime Function: short accum __fractqqha (short fract A) |
| -- Runtime Function: accum __fractqqsa (short fract A) |
| -- Runtime Function: long accum __fractqqda (short fract A) |
| -- Runtime Function: long long accum __fractqqta (short fract A) |
| -- Runtime Function: unsigned short fract __fractqquqq (short fract A) |
| -- Runtime Function: unsigned fract __fractqquhq (short fract A) |
| -- Runtime Function: unsigned long fract __fractqqusq (short fract A) |
| -- Runtime Function: unsigned long long fract __fractqqudq (short fract |
| A) |
| -- Runtime Function: unsigned short accum __fractqquha (short fract A) |
| -- Runtime Function: unsigned accum __fractqqusa (short fract A) |
| -- Runtime Function: unsigned long accum __fractqquda (short fract A) |
| -- Runtime Function: unsigned long long accum __fractqquta (short fract |
| A) |
| -- Runtime Function: signed char __fractqqqi (short fract A) |
| -- Runtime Function: short __fractqqhi (short fract A) |
| -- Runtime Function: int __fractqqsi (short fract A) |
| -- Runtime Function: long __fractqqdi (short fract A) |
| -- Runtime Function: long long __fractqqti (short fract A) |
| -- Runtime Function: float __fractqqsf (short fract A) |
| -- Runtime Function: double __fractqqdf (short fract A) |
| -- Runtime Function: short fract __fracthqqq2 (fract A) |
| -- Runtime Function: long fract __fracthqsq2 (fract A) |
| -- Runtime Function: long long fract __fracthqdq2 (fract A) |
| -- Runtime Function: short accum __fracthqha (fract A) |
| -- Runtime Function: accum __fracthqsa (fract A) |
| -- Runtime Function: long accum __fracthqda (fract A) |
| -- Runtime Function: long long accum __fracthqta (fract A) |
| -- Runtime Function: unsigned short fract __fracthquqq (fract A) |
| -- Runtime Function: unsigned fract __fracthquhq (fract A) |
| -- Runtime Function: unsigned long fract __fracthqusq (fract A) |
| -- Runtime Function: unsigned long long fract __fracthqudq (fract A) |
| -- Runtime Function: unsigned short accum __fracthquha (fract A) |
| -- Runtime Function: unsigned accum __fracthqusa (fract A) |
| -- Runtime Function: unsigned long accum __fracthquda (fract A) |
| -- Runtime Function: unsigned long long accum __fracthquta (fract A) |
| -- Runtime Function: signed char __fracthqqi (fract A) |
| -- Runtime Function: short __fracthqhi (fract A) |
| -- Runtime Function: int __fracthqsi (fract A) |
| -- Runtime Function: long __fracthqdi (fract A) |
| -- Runtime Function: long long __fracthqti (fract A) |
| -- Runtime Function: float __fracthqsf (fract A) |
| -- Runtime Function: double __fracthqdf (fract A) |
| -- Runtime Function: short fract __fractsqqq2 (long fract A) |
| -- Runtime Function: fract __fractsqhq2 (long fract A) |
| -- Runtime Function: long long fract __fractsqdq2 (long fract A) |
| -- Runtime Function: short accum __fractsqha (long fract A) |
| -- Runtime Function: accum __fractsqsa (long fract A) |
| -- Runtime Function: long accum __fractsqda (long fract A) |
| -- Runtime Function: long long accum __fractsqta (long fract A) |
| -- Runtime Function: unsigned short fract __fractsquqq (long fract A) |
| -- Runtime Function: unsigned fract __fractsquhq (long fract A) |
| -- Runtime Function: unsigned long fract __fractsqusq (long fract A) |
| -- Runtime Function: unsigned long long fract __fractsqudq (long fract |
| A) |
| -- Runtime Function: unsigned short accum __fractsquha (long fract A) |
| -- Runtime Function: unsigned accum __fractsqusa (long fract A) |
| -- Runtime Function: unsigned long accum __fractsquda (long fract A) |
| -- Runtime Function: unsigned long long accum __fractsquta (long fract |
| A) |
| -- Runtime Function: signed char __fractsqqi (long fract A) |
| -- Runtime Function: short __fractsqhi (long fract A) |
| -- Runtime Function: int __fractsqsi (long fract A) |
| -- Runtime Function: long __fractsqdi (long fract A) |
| -- Runtime Function: long long __fractsqti (long fract A) |
| -- Runtime Function: float __fractsqsf (long fract A) |
| -- Runtime Function: double __fractsqdf (long fract A) |
| -- Runtime Function: short fract __fractdqqq2 (long long fract A) |
| -- Runtime Function: fract __fractdqhq2 (long long fract A) |
| -- Runtime Function: long fract __fractdqsq2 (long long fract A) |
| -- Runtime Function: short accum __fractdqha (long long fract A) |
| -- Runtime Function: accum __fractdqsa (long long fract A) |
| -- Runtime Function: long accum __fractdqda (long long fract A) |
| -- Runtime Function: long long accum __fractdqta (long long fract A) |
| -- Runtime Function: unsigned short fract __fractdquqq (long long fract |
| A) |
| -- Runtime Function: unsigned fract __fractdquhq (long long fract A) |
| -- Runtime Function: unsigned long fract __fractdqusq (long long fract |
| A) |
| -- Runtime Function: unsigned long long fract __fractdqudq (long long |
| fract A) |
| -- Runtime Function: unsigned short accum __fractdquha (long long fract |
| A) |
| -- Runtime Function: unsigned accum __fractdqusa (long long fract A) |
| -- Runtime Function: unsigned long accum __fractdquda (long long fract |
| A) |
| -- Runtime Function: unsigned long long accum __fractdquta (long long |
| fract A) |
| -- Runtime Function: signed char __fractdqqi (long long fract A) |
| -- Runtime Function: short __fractdqhi (long long fract A) |
| -- Runtime Function: int __fractdqsi (long long fract A) |
| -- Runtime Function: long __fractdqdi (long long fract A) |
| -- Runtime Function: long long __fractdqti (long long fract A) |
| -- Runtime Function: float __fractdqsf (long long fract A) |
| -- Runtime Function: double __fractdqdf (long long fract A) |
| -- Runtime Function: short fract __fracthaqq (short accum A) |
| -- Runtime Function: fract __fracthahq (short accum A) |
| -- Runtime Function: long fract __fracthasq (short accum A) |
| -- Runtime Function: long long fract __fracthadq (short accum A) |
| -- Runtime Function: accum __fracthasa2 (short accum A) |
| -- Runtime Function: long accum __fracthada2 (short accum A) |
| -- Runtime Function: long long accum __fracthata2 (short accum A) |
| -- Runtime Function: unsigned short fract __fracthauqq (short accum A) |
| -- Runtime Function: unsigned fract __fracthauhq (short accum A) |
| -- Runtime Function: unsigned long fract __fracthausq (short accum A) |
| -- Runtime Function: unsigned long long fract __fracthaudq (short accum |
| A) |
| -- Runtime Function: unsigned short accum __fracthauha (short accum A) |
| -- Runtime Function: unsigned accum __fracthausa (short accum A) |
| -- Runtime Function: unsigned long accum __fracthauda (short accum A) |
| -- Runtime Function: unsigned long long accum __fracthauta (short accum |
| A) |
| -- Runtime Function: signed char __fracthaqi (short accum A) |
| -- Runtime Function: short __fracthahi (short accum A) |
| -- Runtime Function: int __fracthasi (short accum A) |
| -- Runtime Function: long __fracthadi (short accum A) |
| -- Runtime Function: long long __fracthati (short accum A) |
| -- Runtime Function: float __fracthasf (short accum A) |
| -- Runtime Function: double __fracthadf (short accum A) |
| -- Runtime Function: short fract __fractsaqq (accum A) |
| -- Runtime Function: fract __fractsahq (accum A) |
| -- Runtime Function: long fract __fractsasq (accum A) |
| -- Runtime Function: long long fract __fractsadq (accum A) |
| -- Runtime Function: short accum __fractsaha2 (accum A) |
| -- Runtime Function: long accum __fractsada2 (accum A) |
| -- Runtime Function: long long accum __fractsata2 (accum A) |
| -- Runtime Function: unsigned short fract __fractsauqq (accum A) |
| -- Runtime Function: unsigned fract __fractsauhq (accum A) |
| -- Runtime Function: unsigned long fract __fractsausq (accum A) |
| -- Runtime Function: unsigned long long fract __fractsaudq (accum A) |
| -- Runtime Function: unsigned short accum __fractsauha (accum A) |
| -- Runtime Function: unsigned accum __fractsausa (accum A) |
| -- Runtime Function: unsigned long accum __fractsauda (accum A) |
| -- Runtime Function: unsigned long long accum __fractsauta (accum A) |
| -- Runtime Function: signed char __fractsaqi (accum A) |
| -- Runtime Function: short __fractsahi (accum A) |
| -- Runtime Function: int __fractsasi (accum A) |
| -- Runtime Function: long __fractsadi (accum A) |
| -- Runtime Function: long long __fractsati (accum A) |
| -- Runtime Function: float __fractsasf (accum A) |
| -- Runtime Function: double __fractsadf (accum A) |
| -- Runtime Function: short fract __fractdaqq (long accum A) |
| -- Runtime Function: fract __fractdahq (long accum A) |
| -- Runtime Function: long fract __fractdasq (long accum A) |
| -- Runtime Function: long long fract __fractdadq (long accum A) |
| -- Runtime Function: short accum __fractdaha2 (long accum A) |
| -- Runtime Function: accum __fractdasa2 (long accum A) |
| -- Runtime Function: long long accum __fractdata2 (long accum A) |
| -- Runtime Function: unsigned short fract __fractdauqq (long accum A) |
| -- Runtime Function: unsigned fract __fractdauhq (long accum A) |
| -- Runtime Function: unsigned long fract __fractdausq (long accum A) |
| -- Runtime Function: unsigned long long fract __fractdaudq (long accum |
| A) |
| -- Runtime Function: unsigned short accum __fractdauha (long accum A) |
| -- Runtime Function: unsigned accum __fractdausa (long accum A) |
| -- Runtime Function: unsigned long accum __fractdauda (long accum A) |
| -- Runtime Function: unsigned long long accum __fractdauta (long accum |
| A) |
| -- Runtime Function: signed char __fractdaqi (long accum A) |
| -- Runtime Function: short __fractdahi (long accum A) |
| -- Runtime Function: int __fractdasi (long accum A) |
| -- Runtime Function: long __fractdadi (long accum A) |
| -- Runtime Function: long long __fractdati (long accum A) |
| -- Runtime Function: float __fractdasf (long accum A) |
| -- Runtime Function: double __fractdadf (long accum A) |
| -- Runtime Function: short fract __fracttaqq (long long accum A) |
| -- Runtime Function: fract __fracttahq (long long accum A) |
| -- Runtime Function: long fract __fracttasq (long long accum A) |
| -- Runtime Function: long long fract __fracttadq (long long accum A) |
| -- Runtime Function: short accum __fracttaha2 (long long accum A) |
| -- Runtime Function: accum __fracttasa2 (long long accum A) |
| -- Runtime Function: long accum __fracttada2 (long long accum A) |
| -- Runtime Function: unsigned short fract __fracttauqq (long long accum |
| A) |
| -- Runtime Function: unsigned fract __fracttauhq (long long accum A) |
| -- Runtime Function: unsigned long fract __fracttausq (long long accum |
| A) |
| -- Runtime Function: unsigned long long fract __fracttaudq (long long |
| accum A) |
| -- Runtime Function: unsigned short accum __fracttauha (long long accum |
| A) |
| -- Runtime Function: unsigned accum __fracttausa (long long accum A) |
| -- Runtime Function: unsigned long accum __fracttauda (long long accum |
| A) |
| -- Runtime Function: unsigned long long accum __fracttauta (long long |
| accum A) |
| -- Runtime Function: signed char __fracttaqi (long long accum A) |
| -- Runtime Function: short __fracttahi (long long accum A) |
| -- Runtime Function: int __fracttasi (long long accum A) |
| -- Runtime Function: long __fracttadi (long long accum A) |
| -- Runtime Function: long long __fracttati (long long accum A) |
| -- Runtime Function: float __fracttasf (long long accum A) |
| -- Runtime Function: double __fracttadf (long long accum A) |
| -- Runtime Function: short fract __fractuqqqq (unsigned short fract A) |
| -- Runtime Function: fract __fractuqqhq (unsigned short fract A) |
| -- Runtime Function: long fract __fractuqqsq (unsigned short fract A) |
| -- Runtime Function: long long fract __fractuqqdq (unsigned short fract |
| A) |
| -- Runtime Function: short accum __fractuqqha (unsigned short fract A) |
| -- Runtime Function: accum __fractuqqsa (unsigned short fract A) |
| -- Runtime Function: long accum __fractuqqda (unsigned short fract A) |
| -- Runtime Function: long long accum __fractuqqta (unsigned short fract |
| A) |
| -- Runtime Function: unsigned fract __fractuqquhq2 (unsigned short |
| fract A) |
| -- Runtime Function: unsigned long fract __fractuqqusq2 (unsigned short |
| fract A) |
| -- Runtime Function: unsigned long long fract __fractuqqudq2 (unsigned |
| short fract A) |
| -- Runtime Function: unsigned short accum __fractuqquha (unsigned short |
| fract A) |
| -- Runtime Function: unsigned accum __fractuqqusa (unsigned short fract |
| A) |
| -- Runtime Function: unsigned long accum __fractuqquda (unsigned short |
| fract A) |
| -- Runtime Function: unsigned long long accum __fractuqquta (unsigned |
| short fract A) |
| -- Runtime Function: signed char __fractuqqqi (unsigned short fract A) |
| -- Runtime Function: short __fractuqqhi (unsigned short fract A) |
| -- Runtime Function: int __fractuqqsi (unsigned short fract A) |
| -- Runtime Function: long __fractuqqdi (unsigned short fract A) |
| -- Runtime Function: long long __fractuqqti (unsigned short fract A) |
| -- Runtime Function: float __fractuqqsf (unsigned short fract A) |
| -- Runtime Function: double __fractuqqdf (unsigned short fract A) |
| -- Runtime Function: short fract __fractuhqqq (unsigned fract A) |
| -- Runtime Function: fract __fractuhqhq (unsigned fract A) |
| -- Runtime Function: long fract __fractuhqsq (unsigned fract A) |
| -- Runtime Function: long long fract __fractuhqdq (unsigned fract A) |
| -- Runtime Function: short accum __fractuhqha (unsigned fract A) |
| -- Runtime Function: accum __fractuhqsa (unsigned fract A) |
| -- Runtime Function: long accum __fractuhqda (unsigned fract A) |
| -- Runtime Function: long long accum __fractuhqta (unsigned fract A) |
| -- Runtime Function: unsigned short fract __fractuhquqq2 (unsigned |
| fract A) |
| -- Runtime Function: unsigned long fract __fractuhqusq2 (unsigned fract |
| A) |
| -- Runtime Function: unsigned long long fract __fractuhqudq2 (unsigned |
| fract A) |
| -- Runtime Function: unsigned short accum __fractuhquha (unsigned fract |
| A) |
| -- Runtime Function: unsigned accum __fractuhqusa (unsigned fract A) |
| -- Runtime Function: unsigned long accum __fractuhquda (unsigned fract |
| A) |
| -- Runtime Function: unsigned long long accum __fractuhquta (unsigned |
| fract A) |
| -- Runtime Function: signed char __fractuhqqi (unsigned fract A) |
| -- Runtime Function: short __fractuhqhi (unsigned fract A) |
| -- Runtime Function: int __fractuhqsi (unsigned fract A) |
| -- Runtime Function: long __fractuhqdi (unsigned fract A) |
| -- Runtime Function: long long __fractuhqti (unsigned fract A) |
| -- Runtime Function: float __fractuhqsf (unsigned fract A) |
| -- Runtime Function: double __fractuhqdf (unsigned fract A) |
| -- Runtime Function: short fract __fractusqqq (unsigned long fract A) |
| -- Runtime Function: fract __fractusqhq (unsigned long fract A) |
| -- Runtime Function: long fract __fractusqsq (unsigned long fract A) |
| -- Runtime Function: long long fract __fractusqdq (unsigned long fract |
| A) |
| -- Runtime Function: short accum __fractusqha (unsigned long fract A) |
| -- Runtime Function: accum __fractusqsa (unsigned long fract A) |
| -- Runtime Function: long accum __fractusqda (unsigned long fract A) |
| -- Runtime Function: long long accum __fractusqta (unsigned long fract |
| A) |
| -- Runtime Function: unsigned short fract __fractusquqq2 (unsigned long |
| fract A) |
| -- Runtime Function: unsigned fract __fractusquhq2 (unsigned long fract |
| A) |
| -- Runtime Function: unsigned long long fract __fractusqudq2 (unsigned |
| long fract A) |
| -- Runtime Function: unsigned short accum __fractusquha (unsigned long |
| fract A) |
| -- Runtime Function: unsigned accum __fractusqusa (unsigned long fract |
| A) |
| -- Runtime Function: unsigned long accum __fractusquda (unsigned long |
| fract A) |
| -- Runtime Function: unsigned long long accum __fractusquta (unsigned |
| long fract A) |
| -- Runtime Function: signed char __fractusqqi (unsigned long fract A) |
| -- Runtime Function: short __fractusqhi (unsigned long fract A) |
| -- Runtime Function: int __fractusqsi (unsigned long fract A) |
| -- Runtime Function: long __fractusqdi (unsigned long fract A) |
| -- Runtime Function: long long __fractusqti (unsigned long fract A) |
| -- Runtime Function: float __fractusqsf (unsigned long fract A) |
| -- Runtime Function: double __fractusqdf (unsigned long fract A) |
| -- Runtime Function: short fract __fractudqqq (unsigned long long fract |
| A) |
| -- Runtime Function: fract __fractudqhq (unsigned long long fract A) |
| -- Runtime Function: long fract __fractudqsq (unsigned long long fract |
| A) |
| -- Runtime Function: long long fract __fractudqdq (unsigned long long |
| fract A) |
| -- Runtime Function: short accum __fractudqha (unsigned long long fract |
| A) |
| -- Runtime Function: accum __fractudqsa (unsigned long long fract A) |
| -- Runtime Function: long accum __fractudqda (unsigned long long fract |
| A) |
| -- Runtime Function: long long accum __fractudqta (unsigned long long |
| fract A) |
| -- Runtime Function: unsigned short fract __fractudquqq2 (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned fract __fractudquhq2 (unsigned long long |
| fract A) |
| -- Runtime Function: unsigned long fract __fractudqusq2 (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned short accum __fractudquha (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned accum __fractudqusa (unsigned long long |
| fract A) |
| -- Runtime Function: unsigned long accum __fractudquda (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned long long accum __fractudquta (unsigned |
| long long fract A) |
| -- Runtime Function: signed char __fractudqqi (unsigned long long fract |
| A) |
| -- Runtime Function: short __fractudqhi (unsigned long long fract A) |
| -- Runtime Function: int __fractudqsi (unsigned long long fract A) |
| -- Runtime Function: long __fractudqdi (unsigned long long fract A) |
| -- Runtime Function: long long __fractudqti (unsigned long long fract |
| A) |
| -- Runtime Function: float __fractudqsf (unsigned long long fract A) |
| -- Runtime Function: double __fractudqdf (unsigned long long fract A) |
| -- Runtime Function: short fract __fractuhaqq (unsigned short accum A) |
| -- Runtime Function: fract __fractuhahq (unsigned short accum A) |
| -- Runtime Function: long fract __fractuhasq (unsigned short accum A) |
| -- Runtime Function: long long fract __fractuhadq (unsigned short accum |
| A) |
| -- Runtime Function: short accum __fractuhaha (unsigned short accum A) |
| -- Runtime Function: accum __fractuhasa (unsigned short accum A) |
| -- Runtime Function: long accum __fractuhada (unsigned short accum A) |
| -- Runtime Function: long long accum __fractuhata (unsigned short accum |
| A) |
| -- Runtime Function: unsigned short fract __fractuhauqq (unsigned short |
| accum A) |
| -- Runtime Function: unsigned fract __fractuhauhq (unsigned short accum |
| A) |
| -- Runtime Function: unsigned long fract __fractuhausq (unsigned short |
| accum A) |
| -- Runtime Function: unsigned long long fract __fractuhaudq (unsigned |
| short accum A) |
| -- Runtime Function: unsigned accum __fractuhausa2 (unsigned short |
| accum A) |
| -- Runtime Function: unsigned long accum __fractuhauda2 (unsigned short |
| accum A) |
| -- Runtime Function: unsigned long long accum __fractuhauta2 (unsigned |
| short accum A) |
| -- Runtime Function: signed char __fractuhaqi (unsigned short accum A) |
| -- Runtime Function: short __fractuhahi (unsigned short accum A) |
| -- Runtime Function: int __fractuhasi (unsigned short accum A) |
| -- Runtime Function: long __fractuhadi (unsigned short accum A) |
| -- Runtime Function: long long __fractuhati (unsigned short accum A) |
| -- Runtime Function: float __fractuhasf (unsigned short accum A) |
| -- Runtime Function: double __fractuhadf (unsigned short accum A) |
| -- Runtime Function: short fract __fractusaqq (unsigned accum A) |
| -- Runtime Function: fract __fractusahq (unsigned accum A) |
| -- Runtime Function: long fract __fractusasq (unsigned accum A) |
| -- Runtime Function: long long fract __fractusadq (unsigned accum A) |
| -- Runtime Function: short accum __fractusaha (unsigned accum A) |
| -- Runtime Function: accum __fractusasa (unsigned accum A) |
| -- Runtime Function: long accum __fractusada (unsigned accum A) |
| -- Runtime Function: long long accum __fractusata (unsigned accum A) |
| -- Runtime Function: unsigned short fract __fractusauqq (unsigned accum |
| A) |
| -- Runtime Function: unsigned fract __fractusauhq (unsigned accum A) |
| -- Runtime Function: unsigned long fract __fractusausq (unsigned accum |
| A) |
| -- Runtime Function: unsigned long long fract __fractusaudq (unsigned |
| accum A) |
| -- Runtime Function: unsigned short accum __fractusauha2 (unsigned |
| accum A) |
| -- Runtime Function: unsigned long accum __fractusauda2 (unsigned accum |
| A) |
| -- Runtime Function: unsigned long long accum __fractusauta2 (unsigned |
| accum A) |
| -- Runtime Function: signed char __fractusaqi (unsigned accum A) |
| -- Runtime Function: short __fractusahi (unsigned accum A) |
| -- Runtime Function: int __fractusasi (unsigned accum A) |
| -- Runtime Function: long __fractusadi (unsigned accum A) |
| -- Runtime Function: long long __fractusati (unsigned accum A) |
| -- Runtime Function: float __fractusasf (unsigned accum A) |
| -- Runtime Function: double __fractusadf (unsigned accum A) |
| -- Runtime Function: short fract __fractudaqq (unsigned long accum A) |
| -- Runtime Function: fract __fractudahq (unsigned long accum A) |
| -- Runtime Function: long fract __fractudasq (unsigned long accum A) |
| -- Runtime Function: long long fract __fractudadq (unsigned long accum |
| A) |
| -- Runtime Function: short accum __fractudaha (unsigned long accum A) |
| -- Runtime Function: accum __fractudasa (unsigned long accum A) |
| -- Runtime Function: long accum __fractudada (unsigned long accum A) |
| -- Runtime Function: long long accum __fractudata (unsigned long accum |
| A) |
| -- Runtime Function: unsigned short fract __fractudauqq (unsigned long |
| accum A) |
| -- Runtime Function: unsigned fract __fractudauhq (unsigned long accum |
| A) |
| -- Runtime Function: unsigned long fract __fractudausq (unsigned long |
| accum A) |
| -- Runtime Function: unsigned long long fract __fractudaudq (unsigned |
| long accum A) |
| -- Runtime Function: unsigned short accum __fractudauha2 (unsigned long |
| accum A) |
| -- Runtime Function: unsigned accum __fractudausa2 (unsigned long accum |
| A) |
| -- Runtime Function: unsigned long long accum __fractudauta2 (unsigned |
| long accum A) |
| -- Runtime Function: signed char __fractudaqi (unsigned long accum A) |
| -- Runtime Function: short __fractudahi (unsigned long accum A) |
| -- Runtime Function: int __fractudasi (unsigned long accum A) |
| -- Runtime Function: long __fractudadi (unsigned long accum A) |
| -- Runtime Function: long long __fractudati (unsigned long accum A) |
| -- Runtime Function: float __fractudasf (unsigned long accum A) |
| -- Runtime Function: double __fractudadf (unsigned long accum A) |
| -- Runtime Function: short fract __fractutaqq (unsigned long long accum |
| A) |
| -- Runtime Function: fract __fractutahq (unsigned long long accum A) |
| -- Runtime Function: long fract __fractutasq (unsigned long long accum |
| A) |
| -- Runtime Function: long long fract __fractutadq (unsigned long long |
| accum A) |
| -- Runtime Function: short accum __fractutaha (unsigned long long accum |
| A) |
| -- Runtime Function: accum __fractutasa (unsigned long long accum A) |
| -- Runtime Function: long accum __fractutada (unsigned long long accum |
| A) |
| -- Runtime Function: long long accum __fractutata (unsigned long long |
| accum A) |
| -- Runtime Function: unsigned short fract __fractutauqq (unsigned long |
| long accum A) |
| -- Runtime Function: unsigned fract __fractutauhq (unsigned long long |
| accum A) |
| -- Runtime Function: unsigned long fract __fractutausq (unsigned long |
| long accum A) |
| -- Runtime Function: unsigned long long fract __fractutaudq (unsigned |
| long long accum A) |
| -- Runtime Function: unsigned short accum __fractutauha2 (unsigned long |
| long accum A) |
| -- Runtime Function: unsigned accum __fractutausa2 (unsigned long long |
| accum A) |
| -- Runtime Function: unsigned long accum __fractutauda2 (unsigned long |
| long accum A) |
| -- Runtime Function: signed char __fractutaqi (unsigned long long accum |
| A) |
| -- Runtime Function: short __fractutahi (unsigned long long accum A) |
| -- Runtime Function: int __fractutasi (unsigned long long accum A) |
| -- Runtime Function: long __fractutadi (unsigned long long accum A) |
| -- Runtime Function: long long __fractutati (unsigned long long accum |
| A) |
| -- Runtime Function: float __fractutasf (unsigned long long accum A) |
| -- Runtime Function: double __fractutadf (unsigned long long accum A) |
| -- Runtime Function: short fract __fractqiqq (signed char A) |
| -- Runtime Function: fract __fractqihq (signed char A) |
| -- Runtime Function: long fract __fractqisq (signed char A) |
| -- Runtime Function: long long fract __fractqidq (signed char A) |
| -- Runtime Function: short accum __fractqiha (signed char A) |
| -- Runtime Function: accum __fractqisa (signed char A) |
| -- Runtime Function: long accum __fractqida (signed char A) |
| -- Runtime Function: long long accum __fractqita (signed char A) |
| -- Runtime Function: unsigned short fract __fractqiuqq (signed char A) |
| -- Runtime Function: unsigned fract __fractqiuhq (signed char A) |
| -- Runtime Function: unsigned long fract __fractqiusq (signed char A) |
| -- Runtime Function: unsigned long long fract __fractqiudq (signed char |
| A) |
| -- Runtime Function: unsigned short accum __fractqiuha (signed char A) |
| -- Runtime Function: unsigned accum __fractqiusa (signed char A) |
| -- Runtime Function: unsigned long accum __fractqiuda (signed char A) |
| -- Runtime Function: unsigned long long accum __fractqiuta (signed char |
| A) |
| -- Runtime Function: short fract __fracthiqq (short A) |
| -- Runtime Function: fract __fracthihq (short A) |
| -- Runtime Function: long fract __fracthisq (short A) |
| -- Runtime Function: long long fract __fracthidq (short A) |
| -- Runtime Function: short accum __fracthiha (short A) |
| -- Runtime Function: accum __fracthisa (short A) |
| -- Runtime Function: long accum __fracthida (short A) |
| -- Runtime Function: long long accum __fracthita (short A) |
| -- Runtime Function: unsigned short fract __fracthiuqq (short A) |
| -- Runtime Function: unsigned fract __fracthiuhq (short A) |
| -- Runtime Function: unsigned long fract __fracthiusq (short A) |
| -- Runtime Function: unsigned long long fract __fracthiudq (short A) |
| -- Runtime Function: unsigned short accum __fracthiuha (short A) |
| -- Runtime Function: unsigned accum __fracthiusa (short A) |
| -- Runtime Function: unsigned long accum __fracthiuda (short A) |
| -- Runtime Function: unsigned long long accum __fracthiuta (short A) |
| -- Runtime Function: short fract __fractsiqq (int A) |
| -- Runtime Function: fract __fractsihq (int A) |
| -- Runtime Function: long fract __fractsisq (int A) |
| -- Runtime Function: long long fract __fractsidq (int A) |
| -- Runtime Function: short accum __fractsiha (int A) |
| -- Runtime Function: accum __fractsisa (int A) |
| -- Runtime Function: long accum __fractsida (int A) |
| -- Runtime Function: long long accum __fractsita (int A) |
| -- Runtime Function: unsigned short fract __fractsiuqq (int A) |
| -- Runtime Function: unsigned fract __fractsiuhq (int A) |
| -- Runtime Function: unsigned long fract __fractsiusq (int A) |
| -- Runtime Function: unsigned long long fract __fractsiudq (int A) |
| -- Runtime Function: unsigned short accum __fractsiuha (int A) |
| -- Runtime Function: unsigned accum __fractsiusa (int A) |
| -- Runtime Function: unsigned long accum __fractsiuda (int A) |
| -- Runtime Function: unsigned long long accum __fractsiuta (int A) |
| -- Runtime Function: short fract __fractdiqq (long A) |
| -- Runtime Function: fract __fractdihq (long A) |
| -- Runtime Function: long fract __fractdisq (long A) |
| -- Runtime Function: long long fract __fractdidq (long A) |
| -- Runtime Function: short accum __fractdiha (long A) |
| -- Runtime Function: accum __fractdisa (long A) |
| -- Runtime Function: long accum __fractdida (long A) |
| -- Runtime Function: long long accum __fractdita (long A) |
| -- Runtime Function: unsigned short fract __fractdiuqq (long A) |
| -- Runtime Function: unsigned fract __fractdiuhq (long A) |
| -- Runtime Function: unsigned long fract __fractdiusq (long A) |
| -- Runtime Function: unsigned long long fract __fractdiudq (long A) |
| -- Runtime Function: unsigned short accum __fractdiuha (long A) |
| -- Runtime Function: unsigned accum __fractdiusa (long A) |
| -- Runtime Function: unsigned long accum __fractdiuda (long A) |
| -- Runtime Function: unsigned long long accum __fractdiuta (long A) |
| -- Runtime Function: short fract __fracttiqq (long long A) |
| -- Runtime Function: fract __fracttihq (long long A) |
| -- Runtime Function: long fract __fracttisq (long long A) |
| -- Runtime Function: long long fract __fracttidq (long long A) |
| -- Runtime Function: short accum __fracttiha (long long A) |
| -- Runtime Function: accum __fracttisa (long long A) |
| -- Runtime Function: long accum __fracttida (long long A) |
| -- Runtime Function: long long accum __fracttita (long long A) |
| -- Runtime Function: unsigned short fract __fracttiuqq (long long A) |
| -- Runtime Function: unsigned fract __fracttiuhq (long long A) |
| -- Runtime Function: unsigned long fract __fracttiusq (long long A) |
| -- Runtime Function: unsigned long long fract __fracttiudq (long long |
| A) |
| -- Runtime Function: unsigned short accum __fracttiuha (long long A) |
| -- Runtime Function: unsigned accum __fracttiusa (long long A) |
| -- Runtime Function: unsigned long accum __fracttiuda (long long A) |
| -- Runtime Function: unsigned long long accum __fracttiuta (long long |
| A) |
| -- Runtime Function: short fract __fractsfqq (float A) |
| -- Runtime Function: fract __fractsfhq (float A) |
| -- Runtime Function: long fract __fractsfsq (float A) |
| -- Runtime Function: long long fract __fractsfdq (float A) |
| -- Runtime Function: short accum __fractsfha (float A) |
| -- Runtime Function: accum __fractsfsa (float A) |
| -- Runtime Function: long accum __fractsfda (float A) |
| -- Runtime Function: long long accum __fractsfta (float A) |
| -- Runtime Function: unsigned short fract __fractsfuqq (float A) |
| -- Runtime Function: unsigned fract __fractsfuhq (float A) |
| -- Runtime Function: unsigned long fract __fractsfusq (float A) |
| -- Runtime Function: unsigned long long fract __fractsfudq (float A) |
| -- Runtime Function: unsigned short accum __fractsfuha (float A) |
| -- Runtime Function: unsigned accum __fractsfusa (float A) |
| -- Runtime Function: unsigned long accum __fractsfuda (float A) |
| -- Runtime Function: unsigned long long accum __fractsfuta (float A) |
| -- Runtime Function: short fract __fractdfqq (double A) |
| -- Runtime Function: fract __fractdfhq (double A) |
| -- Runtime Function: long fract __fractdfsq (double A) |
| -- Runtime Function: long long fract __fractdfdq (double A) |
| -- Runtime Function: short accum __fractdfha (double A) |
| -- Runtime Function: accum __fractdfsa (double A) |
| -- Runtime Function: long accum __fractdfda (double A) |
| -- Runtime Function: long long accum __fractdfta (double A) |
| -- Runtime Function: unsigned short fract __fractdfuqq (double A) |
| -- Runtime Function: unsigned fract __fractdfuhq (double A) |
| -- Runtime Function: unsigned long fract __fractdfusq (double A) |
| -- Runtime Function: unsigned long long fract __fractdfudq (double A) |
| -- Runtime Function: unsigned short accum __fractdfuha (double A) |
| -- Runtime Function: unsigned accum __fractdfusa (double A) |
| -- Runtime Function: unsigned long accum __fractdfuda (double A) |
| -- Runtime Function: unsigned long long accum __fractdfuta (double A) |
| These functions convert from fractional and signed non-fractionals |
| to fractionals and signed non-fractionals, without saturation. |
| |
| -- Runtime Function: fract __satfractqqhq2 (short fract A) |
| -- Runtime Function: long fract __satfractqqsq2 (short fract A) |
| -- Runtime Function: long long fract __satfractqqdq2 (short fract A) |
| -- Runtime Function: short accum __satfractqqha (short fract A) |
| -- Runtime Function: accum __satfractqqsa (short fract A) |
| -- Runtime Function: long accum __satfractqqda (short fract A) |
| -- Runtime Function: long long accum __satfractqqta (short fract A) |
| -- Runtime Function: unsigned short fract __satfractqquqq (short fract |
| A) |
| -- Runtime Function: unsigned fract __satfractqquhq (short fract A) |
| -- Runtime Function: unsigned long fract __satfractqqusq (short fract |
| A) |
| -- Runtime Function: unsigned long long fract __satfractqqudq (short |
| fract A) |
| -- Runtime Function: unsigned short accum __satfractqquha (short fract |
| A) |
| -- Runtime Function: unsigned accum __satfractqqusa (short fract A) |
| -- Runtime Function: unsigned long accum __satfractqquda (short fract |
| A) |
| -- Runtime Function: unsigned long long accum __satfractqquta (short |
| fract A) |
| -- Runtime Function: short fract __satfracthqqq2 (fract A) |
| -- Runtime Function: long fract __satfracthqsq2 (fract A) |
| -- Runtime Function: long long fract __satfracthqdq2 (fract A) |
| -- Runtime Function: short accum __satfracthqha (fract A) |
| -- Runtime Function: accum __satfracthqsa (fract A) |
| -- Runtime Function: long accum __satfracthqda (fract A) |
| -- Runtime Function: long long accum __satfracthqta (fract A) |
| -- Runtime Function: unsigned short fract __satfracthquqq (fract A) |
| -- Runtime Function: unsigned fract __satfracthquhq (fract A) |
| -- Runtime Function: unsigned long fract __satfracthqusq (fract A) |
| -- Runtime Function: unsigned long long fract __satfracthqudq (fract A) |
| -- Runtime Function: unsigned short accum __satfracthquha (fract A) |
| -- Runtime Function: unsigned accum __satfracthqusa (fract A) |
| -- Runtime Function: unsigned long accum __satfracthquda (fract A) |
| -- Runtime Function: unsigned long long accum __satfracthquta (fract A) |
| -- Runtime Function: short fract __satfractsqqq2 (long fract A) |
| -- Runtime Function: fract __satfractsqhq2 (long fract A) |
| -- Runtime Function: long long fract __satfractsqdq2 (long fract A) |
| -- Runtime Function: short accum __satfractsqha (long fract A) |
| -- Runtime Function: accum __satfractsqsa (long fract A) |
| -- Runtime Function: long accum __satfractsqda (long fract A) |
| -- Runtime Function: long long accum __satfractsqta (long fract A) |
| -- Runtime Function: unsigned short fract __satfractsquqq (long fract |
| A) |
| -- Runtime Function: unsigned fract __satfractsquhq (long fract A) |
| -- Runtime Function: unsigned long fract __satfractsqusq (long fract A) |
| -- Runtime Function: unsigned long long fract __satfractsqudq (long |
| fract A) |
| -- Runtime Function: unsigned short accum __satfractsquha (long fract |
| A) |
| -- Runtime Function: unsigned accum __satfractsqusa (long fract A) |
| -- Runtime Function: unsigned long accum __satfractsquda (long fract A) |
| -- Runtime Function: unsigned long long accum __satfractsquta (long |
| fract A) |
| -- Runtime Function: short fract __satfractdqqq2 (long long fract A) |
| -- Runtime Function: fract __satfractdqhq2 (long long fract A) |
| -- Runtime Function: long fract __satfractdqsq2 (long long fract A) |
| -- Runtime Function: short accum __satfractdqha (long long fract A) |
| -- Runtime Function: accum __satfractdqsa (long long fract A) |
| -- Runtime Function: long accum __satfractdqda (long long fract A) |
| -- Runtime Function: long long accum __satfractdqta (long long fract A) |
| -- Runtime Function: unsigned short fract __satfractdquqq (long long |
| fract A) |
| -- Runtime Function: unsigned fract __satfractdquhq (long long fract A) |
| -- Runtime Function: unsigned long fract __satfractdqusq (long long |
| fract A) |
| -- Runtime Function: unsigned long long fract __satfractdqudq (long |
| long fract A) |
| -- Runtime Function: unsigned short accum __satfractdquha (long long |
| fract A) |
| -- Runtime Function: unsigned accum __satfractdqusa (long long fract A) |
| -- Runtime Function: unsigned long accum __satfractdquda (long long |
| fract A) |
| -- Runtime Function: unsigned long long accum __satfractdquta (long |
| long fract A) |
| -- Runtime Function: short fract __satfracthaqq (short accum A) |
| -- Runtime Function: fract __satfracthahq (short accum A) |
| -- Runtime Function: long fract __satfracthasq (short accum A) |
| -- Runtime Function: long long fract __satfracthadq (short accum A) |
| -- Runtime Function: accum __satfracthasa2 (short accum A) |
| -- Runtime Function: long accum __satfracthada2 (short accum A) |
| -- Runtime Function: long long accum __satfracthata2 (short accum A) |
| -- Runtime Function: unsigned short fract __satfracthauqq (short accum |
| A) |
| -- Runtime Function: unsigned fract __satfracthauhq (short accum A) |
| -- Runtime Function: unsigned long fract __satfracthausq (short accum |
| A) |
| -- Runtime Function: unsigned long long fract __satfracthaudq (short |
| accum A) |
| -- Runtime Function: unsigned short accum __satfracthauha (short accum |
| A) |
| -- Runtime Function: unsigned accum __satfracthausa (short accum A) |
| -- Runtime Function: unsigned long accum __satfracthauda (short accum |
| A) |
| -- Runtime Function: unsigned long long accum __satfracthauta (short |
| accum A) |
| -- Runtime Function: short fract __satfractsaqq (accum A) |
| -- Runtime Function: fract __satfractsahq (accum A) |
| -- Runtime Function: long fract __satfractsasq (accum A) |
| -- Runtime Function: long long fract __satfractsadq (accum A) |
| -- Runtime Function: short accum __satfractsaha2 (accum A) |
| -- Runtime Function: long accum __satfractsada2 (accum A) |
| -- Runtime Function: long long accum __satfractsata2 (accum A) |
| -- Runtime Function: unsigned short fract __satfractsauqq (accum A) |
| -- Runtime Function: unsigned fract __satfractsauhq (accum A) |
| -- Runtime Function: unsigned long fract __satfractsausq (accum A) |
| -- Runtime Function: unsigned long long fract __satfractsaudq (accum A) |
| -- Runtime Function: unsigned short accum __satfractsauha (accum A) |
| -- Runtime Function: unsigned accum __satfractsausa (accum A) |
| -- Runtime Function: unsigned long accum __satfractsauda (accum A) |
| -- Runtime Function: unsigned long long accum __satfractsauta (accum A) |
| -- Runtime Function: short fract __satfractdaqq (long accum A) |
| -- Runtime Function: fract __satfractdahq (long accum A) |
| -- Runtime Function: long fract __satfractdasq (long accum A) |
| -- Runtime Function: long long fract __satfractdadq (long accum A) |
| -- Runtime Function: short accum __satfractdaha2 (long accum A) |
| -- Runtime Function: accum __satfractdasa2 (long accum A) |
| -- Runtime Function: long long accum __satfractdata2 (long accum A) |
| -- Runtime Function: unsigned short fract __satfractdauqq (long accum |
| A) |
| -- Runtime Function: unsigned fract __satfractdauhq (long accum A) |
| -- Runtime Function: unsigned long fract __satfractdausq (long accum A) |
| -- Runtime Function: unsigned long long fract __satfractdaudq (long |
| accum A) |
| -- Runtime Function: unsigned short accum __satfractdauha (long accum |
| A) |
| -- Runtime Function: unsigned accum __satfractdausa (long accum A) |
| -- Runtime Function: unsigned long accum __satfractdauda (long accum A) |
| -- Runtime Function: unsigned long long accum __satfractdauta (long |
| accum A) |
| -- Runtime Function: short fract __satfracttaqq (long long accum A) |
| -- Runtime Function: fract __satfracttahq (long long accum A) |
| -- Runtime Function: long fract __satfracttasq (long long accum A) |
| -- Runtime Function: long long fract __satfracttadq (long long accum A) |
| -- Runtime Function: short accum __satfracttaha2 (long long accum A) |
| -- Runtime Function: accum __satfracttasa2 (long long accum A) |
| -- Runtime Function: long accum __satfracttada2 (long long accum A) |
| -- Runtime Function: unsigned short fract __satfracttauqq (long long |
| accum A) |
| -- Runtime Function: unsigned fract __satfracttauhq (long long accum A) |
| -- Runtime Function: unsigned long fract __satfracttausq (long long |
| accum A) |
| -- Runtime Function: unsigned long long fract __satfracttaudq (long |
| long accum A) |
| -- Runtime Function: unsigned short accum __satfracttauha (long long |
| accum A) |
| -- Runtime Function: unsigned accum __satfracttausa (long long accum A) |
| -- Runtime Function: unsigned long accum __satfracttauda (long long |
| accum A) |
| -- Runtime Function: unsigned long long accum __satfracttauta (long |
| long accum A) |
| -- Runtime Function: short fract __satfractuqqqq (unsigned short fract |
| A) |
| -- Runtime Function: fract __satfractuqqhq (unsigned short fract A) |
| -- Runtime Function: long fract __satfractuqqsq (unsigned short fract |
| A) |
| -- Runtime Function: long long fract __satfractuqqdq (unsigned short |
| fract A) |
| -- Runtime Function: short accum __satfractuqqha (unsigned short fract |
| A) |
| -- Runtime Function: accum __satfractuqqsa (unsigned short fract A) |
| -- Runtime Function: long accum __satfractuqqda (unsigned short fract |
| A) |
| -- Runtime Function: long long accum __satfractuqqta (unsigned short |
| fract A) |
| -- Runtime Function: unsigned fract __satfractuqquhq2 (unsigned short |
| fract A) |
| -- Runtime Function: unsigned long fract __satfractuqqusq2 (unsigned |
| short fract A) |
| -- Runtime Function: unsigned long long fract __satfractuqqudq2 |
| (unsigned short fract A) |
| -- Runtime Function: unsigned short accum __satfractuqquha (unsigned |
| short fract A) |
| -- Runtime Function: unsigned accum __satfractuqqusa (unsigned short |
| fract A) |
| -- Runtime Function: unsigned long accum __satfractuqquda (unsigned |
| short fract A) |
| -- Runtime Function: unsigned long long accum __satfractuqquta |
| (unsigned short fract A) |
| -- Runtime Function: short fract __satfractuhqqq (unsigned fract A) |
| -- Runtime Function: fract __satfractuhqhq (unsigned fract A) |
| -- Runtime Function: long fract __satfractuhqsq (unsigned fract A) |
| -- Runtime Function: long long fract __satfractuhqdq (unsigned fract A) |
| -- Runtime Function: short accum __satfractuhqha (unsigned fract A) |
| -- Runtime Function: accum __satfractuhqsa (unsigned fract A) |
| -- Runtime Function: long accum __satfractuhqda (unsigned fract A) |
| -- Runtime Function: long long accum __satfractuhqta (unsigned fract A) |
| -- Runtime Function: unsigned short fract __satfractuhquqq2 (unsigned |
| fract A) |
| -- Runtime Function: unsigned long fract __satfractuhqusq2 (unsigned |
| fract A) |
| -- Runtime Function: unsigned long long fract __satfractuhqudq2 |
| (unsigned fract A) |
| -- Runtime Function: unsigned short accum __satfractuhquha (unsigned |
| fract A) |
| -- Runtime Function: unsigned accum __satfractuhqusa (unsigned fract A) |
| -- Runtime Function: unsigned long accum __satfractuhquda (unsigned |
| fract A) |
| -- Runtime Function: unsigned long long accum __satfractuhquta |
| (unsigned fract A) |
| -- Runtime Function: short fract __satfractusqqq (unsigned long fract |
| A) |
| -- Runtime Function: fract __satfractusqhq (unsigned long fract A) |
| -- Runtime Function: long fract __satfractusqsq (unsigned long fract A) |
| -- Runtime Function: long long fract __satfractusqdq (unsigned long |
| fract A) |
| -- Runtime Function: short accum __satfractusqha (unsigned long fract |
| A) |
| -- Runtime Function: accum __satfractusqsa (unsigned long fract A) |
| -- Runtime Function: long accum __satfractusqda (unsigned long fract A) |
| -- Runtime Function: long long accum __satfractusqta (unsigned long |
| fract A) |
| -- Runtime Function: unsigned short fract __satfractusquqq2 (unsigned |
| long fract A) |
| -- Runtime Function: unsigned fract __satfractusquhq2 (unsigned long |
| fract A) |
| -- Runtime Function: unsigned long long fract __satfractusqudq2 |
| (unsigned long fract A) |
| -- Runtime Function: unsigned short accum __satfractusquha (unsigned |
| long fract A) |
| -- Runtime Function: unsigned accum __satfractusqusa (unsigned long |
| fract A) |
| -- Runtime Function: unsigned long accum __satfractusquda (unsigned |
| long fract A) |
| -- Runtime Function: unsigned long long accum __satfractusquta |
| (unsigned long fract A) |
| -- Runtime Function: short fract __satfractudqqq (unsigned long long |
| fract A) |
| -- Runtime Function: fract __satfractudqhq (unsigned long long fract A) |
| -- Runtime Function: long fract __satfractudqsq (unsigned long long |
| fract A) |
| -- Runtime Function: long long fract __satfractudqdq (unsigned long |
| long fract A) |
| -- Runtime Function: short accum __satfractudqha (unsigned long long |
| fract A) |
| -- Runtime Function: accum __satfractudqsa (unsigned long long fract A) |
| -- Runtime Function: long accum __satfractudqda (unsigned long long |
| fract A) |
| -- Runtime Function: long long accum __satfractudqta (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned short fract __satfractudquqq2 (unsigned |
| long long fract A) |
| -- Runtime Function: unsigned fract __satfractudquhq2 (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned long fract __satfractudqusq2 (unsigned |
| long long fract A) |
| -- Runtime Function: unsigned short accum __satfractudquha (unsigned |
| long long fract A) |
| -- Runtime Function: unsigned accum __satfractudqusa (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned long accum __satfractudquda (unsigned |
| long long fract A) |
| -- Runtime Function: unsigned long long accum __satfractudquta |
| (unsigned long long fract A) |
| -- Runtime Function: short fract __satfractuhaqq (unsigned short accum |
| A) |
| -- Runtime Function: fract __satfractuhahq (unsigned short accum A) |
| -- Runtime Function: long fract __satfractuhasq (unsigned short accum |
| A) |
| -- Runtime Function: long long fract __satfractuhadq (unsigned short |
| accum A) |
| -- Runtime Function: short accum __satfractuhaha (unsigned short accum |
| A) |
| -- Runtime Function: accum __satfractuhasa (unsigned short accum A) |
| -- Runtime Function: long accum __satfractuhada (unsigned short accum |
| A) |
| -- Runtime Function: long long accum __satfractuhata (unsigned short |
| accum A) |
| -- Runtime Function: unsigned short fract __satfractuhauqq (unsigned |
| short accum A) |
| -- Runtime Function: unsigned fract __satfractuhauhq (unsigned short |
| accum A) |
| -- Runtime Function: unsigned long fract __satfractuhausq (unsigned |
| short accum A) |
| -- Runtime Function: unsigned long long fract __satfractuhaudq |
| (unsigned short accum A) |
| -- Runtime Function: unsigned accum __satfractuhausa2 (unsigned short |
| accum A) |
| -- Runtime Function: unsigned long accum __satfractuhauda2 (unsigned |
| short accum A) |
| -- Runtime Function: unsigned long long accum __satfractuhauta2 |
| (unsigned short accum A) |
| -- Runtime Function: short fract __satfractusaqq (unsigned accum A) |
| -- Runtime Function: fract __satfractusahq (unsigned accum A) |
| -- Runtime Function: long fract __satfractusasq (unsigned accum A) |
| -- Runtime Function: long long fract __satfractusadq (unsigned accum A) |
| -- Runtime Function: short accum __satfractusaha (unsigned accum A) |
| -- Runtime Function: accum __satfractusasa (unsigned accum A) |
| -- Runtime Function: long accum __satfractusada (unsigned accum A) |
| -- Runtime Function: long long accum __satfractusata (unsigned accum A) |
| -- Runtime Function: unsigned short fract __satfractusauqq (unsigned |
| accum A) |
| -- Runtime Function: unsigned fract __satfractusauhq (unsigned accum A) |
| -- Runtime Function: unsigned long fract __satfractusausq (unsigned |
| accum A) |
| -- Runtime Function: unsigned long long fract __satfractusaudq |
| (unsigned accum A) |
| -- Runtime Function: unsigned short accum __satfractusauha2 (unsigned |
| accum A) |
| -- Runtime Function: unsigned long accum __satfractusauda2 (unsigned |
| accum A) |
| -- Runtime Function: unsigned long long accum __satfractusauta2 |
| (unsigned accum A) |
| -- Runtime Function: short fract __satfractudaqq (unsigned long accum |
| A) |
| -- Runtime Function: fract __satfractudahq (unsigned long accum A) |
| -- Runtime Function: long fract __satfractudasq (unsigned long accum A) |
| -- Runtime Function: long long fract __satfractudadq (unsigned long |
| accum A) |
| -- Runtime Function: short accum __satfractudaha (unsigned long accum |
| A) |
| -- Runtime Function: accum __satfractudasa (unsigned long accum A) |
| -- Runtime Function: long accum __satfractudada (unsigned long accum A) |
| -- Runtime Function: long long accum __satfractudata (unsigned long |
| accum A) |
| -- Runtime Function: unsigned short fract __satfractudauqq (unsigned |
| long accum A) |
| -- Runtime Function: unsigned fract __satfractudauhq (unsigned long |
| accum A) |
| -- Runtime Function: unsigned long fract __satfractudausq (unsigned |
| long accum A) |
| -- Runtime Function: unsigned long long fract __satfractudaudq |
| (unsigned long accum A) |
| -- Runtime Function: unsigned short accum __satfractudauha2 (unsigned |
| long accum A) |
| -- Runtime Function: unsigned accum __satfractudausa2 (unsigned long |
| accum A) |
| -- Runtime Function: unsigned long long accum __satfractudauta2 |
| (unsigned long accum A) |
| -- Runtime Function: short fract __satfractutaqq (unsigned long long |
| accum A) |
| -- Runtime Function: fract __satfractutahq (unsigned long long accum A) |
| -- Runtime Function: long fract __satfractutasq (unsigned long long |
| accum A) |
| -- Runtime Function: long long fract __satfractutadq (unsigned long |
| long accum A) |
| -- Runtime Function: short accum __satfractutaha (unsigned long long |
| accum A) |
| -- Runtime Function: accum __satfractutasa (unsigned long long accum A) |
| -- Runtime Function: long accum __satfractutada (unsigned long long |
| accum A) |
| -- Runtime Function: long long accum __satfractutata (unsigned long |
| long accum A) |
| -- Runtime Function: unsigned short fract __satfractutauqq (unsigned |
| long long accum A) |
| -- Runtime Function: unsigned fract __satfractutauhq (unsigned long |
| long accum A) |
| -- Runtime Function: unsigned long fract __satfractutausq (unsigned |
| long long accum A) |
| -- Runtime Function: unsigned long long fract __satfractutaudq |
| (unsigned long long accum A) |
| -- Runtime Function: unsigned short accum __satfractutauha2 (unsigned |
| long long accum A) |
| -- Runtime Function: unsigned accum __satfractutausa2 (unsigned long |
| long accum A) |
| -- Runtime Function: unsigned long accum __satfractutauda2 (unsigned |
| long long accum A) |
| -- Runtime Function: short fract __satfractqiqq (signed char A) |
| -- Runtime Function: fract __satfractqihq (signed char A) |
| -- Runtime Function: long fract __satfractqisq (signed char A) |
| -- Runtime Function: long long fract __satfractqidq (signed char A) |
| -- Runtime Function: short accum __satfractqiha (signed char A) |
| -- Runtime Function: accum __satfractqisa (signed char A) |
| -- Runtime Function: long accum __satfractqida (signed char A) |
| -- Runtime Function: long long accum __satfractqita (signed char A) |
| -- Runtime Function: unsigned short fract __satfractqiuqq (signed char |
| A) |
| -- Runtime Function: unsigned fract __satfractqiuhq (signed char A) |
| -- Runtime Function: unsigned long fract __satfractqiusq (signed char |
| A) |
| -- Runtime Function: unsigned long long fract __satfractqiudq (signed |
| char A) |
| -- Runtime Function: unsigned short accum __satfractqiuha (signed char |
| A) |
| -- Runtime Function: unsigned accum __satfractqiusa (signed char A) |
| -- Runtime Function: unsigned long accum __satfractqiuda (signed char |
| A) |
| -- Runtime Function: unsigned long long accum __satfractqiuta (signed |
| char A) |
| -- Runtime Function: short fract __satfracthiqq (short A) |
| -- Runtime Function: fract __satfracthihq (short A) |
| -- Runtime Function: long fract __satfracthisq (short A) |
| -- Runtime Function: long long fract __satfracthidq (short A) |
| -- Runtime Function: short accum __satfracthiha (short A) |
| -- Runtime Function: accum __satfracthisa (short A) |
| -- Runtime Function: long accum __satfracthida (short A) |
| -- Runtime Function: long long accum __satfracthita (short A) |
| -- Runtime Function: unsigned short fract __satfracthiuqq (short A) |
| -- Runtime Function: unsigned fract __satfracthiuhq (short A) |
| -- Runtime Function: unsigned long fract __satfracthiusq (short A) |
| -- Runtime Function: unsigned long long fract __satfracthiudq (short A) |
| -- Runtime Function: unsigned short accum __satfracthiuha (short A) |
| -- Runtime Function: unsigned accum __satfracthiusa (short A) |
| -- Runtime Function: unsigned long accum __satfracthiuda (short A) |
| -- Runtime Function: unsigned long long accum __satfracthiuta (short A) |
| -- Runtime Function: short fract __satfractsiqq (int A) |
| -- Runtime Function: fract __satfractsihq (int A) |
| -- Runtime Function: long fract __satfractsisq (int A) |
| -- Runtime Function: long long fract __satfractsidq (int A) |
| -- Runtime Function: short accum __satfractsiha (int A) |
| -- Runtime Function: accum __satfractsisa (int A) |
| -- Runtime Function: long accum __satfractsida (int A) |
| -- Runtime Function: long long accum __satfractsita (int A) |
| -- Runtime Function: unsigned short fract __satfractsiuqq (int A) |
| -- Runtime Function: unsigned fract __satfractsiuhq (int A) |
| -- Runtime Function: unsigned long fract __satfractsiusq (int A) |
| -- Runtime Function: unsigned long long fract __satfractsiudq (int A) |
| -- Runtime Function: unsigned short accum __satfractsiuha (int A) |
| -- Runtime Function: unsigned accum __satfractsiusa (int A) |
| -- Runtime Function: unsigned long accum __satfractsiuda (int A) |
| -- Runtime Function: unsigned long long accum __satfractsiuta (int A) |
| -- Runtime Function: short fract __satfractdiqq (long A) |
| -- Runtime Function: fract __satfractdihq (long A) |
| -- Runtime Function: long fract __satfractdisq (long A) |
| -- Runtime Function: long long fract __satfractdidq (long A) |
| -- Runtime Function: short accum __satfractdiha (long A) |
| -- Runtime Function: accum __satfractdisa (long A) |
| -- Runtime Function: long accum __satfractdida (long A) |
| -- Runtime Function: long long accum __satfractdita (long A) |
| -- Runtime Function: unsigned short fract __satfractdiuqq (long A) |
| -- Runtime Function: unsigned fract __satfractdiuhq (long A) |
| -- Runtime Function: unsigned long fract __satfractdiusq (long A) |
| -- Runtime Function: unsigned long long fract __satfractdiudq (long A) |
| -- Runtime Function: unsigned short accum __satfractdiuha (long A) |
| -- Runtime Function: unsigned accum __satfractdiusa (long A) |
| -- Runtime Function: unsigned long accum __satfractdiuda (long A) |
| -- Runtime Function: unsigned long long accum __satfractdiuta (long A) |
| -- Runtime Function: short fract __satfracttiqq (long long A) |
| -- Runtime Function: fract __satfracttihq (long long A) |
| -- Runtime Function: long fract __satfracttisq (long long A) |
| -- Runtime Function: long long fract __satfracttidq (long long A) |
| -- Runtime Function: short accum __satfracttiha (long long A) |
| -- Runtime Function: accum __satfracttisa (long long A) |
| -- Runtime Function: long accum __satfracttida (long long A) |
| -- Runtime Function: long long accum __satfracttita (long long A) |
| -- Runtime Function: unsigned short fract __satfracttiuqq (long long A) |
| -- Runtime Function: unsigned fract __satfracttiuhq (long long A) |
| -- Runtime Function: unsigned long fract __satfracttiusq (long long A) |
| -- Runtime Function: unsigned long long fract __satfracttiudq (long |
| long A) |
| -- Runtime Function: unsigned short accum __satfracttiuha (long long A) |
| -- Runtime Function: unsigned accum __satfracttiusa (long long A) |
| -- Runtime Function: unsigned long accum __satfracttiuda (long long A) |
| -- Runtime Function: unsigned long long accum __satfracttiuta (long |
| long A) |
| -- Runtime Function: short fract __satfractsfqq (float A) |
| -- Runtime Function: fract __satfractsfhq (float A) |
| -- Runtime Function: long fract __satfractsfsq (float A) |
| -- Runtime Function: long long fract __satfractsfdq (float A) |
| -- Runtime Function: short accum __satfractsfha (float A) |
| -- Runtime Function: accum __satfractsfsa (float A) |
| -- Runtime Function: long accum __satfractsfda (float A) |
| -- Runtime Function: long long accum __satfractsfta (float A) |
| -- Runtime Function: unsigned short fract __satfractsfuqq (float A) |
| -- Runtime Function: unsigned fract __satfractsfuhq (float A) |
| -- Runtime Function: unsigned long fract __satfractsfusq (float A) |
| -- Runtime Function: unsigned long long fract __satfractsfudq (float A) |
| -- Runtime Function: unsigned short accum __satfractsfuha (float A) |
| -- Runtime Function: unsigned accum __satfractsfusa (float A) |
| -- Runtime Function: unsigned long accum __satfractsfuda (float A) |
| -- Runtime Function: unsigned long long accum __satfractsfuta (float A) |
| -- Runtime Function: short fract __satfractdfqq (double A) |
| -- Runtime Function: fract __satfractdfhq (double A) |
| -- Runtime Function: long fract __satfractdfsq (double A) |
| -- Runtime Function: long long fract __satfractdfdq (double A) |
| -- Runtime Function: short accum __satfractdfha (double A) |
| -- Runtime Function: accum __satfractdfsa (double A) |
| -- Runtime Function: long accum __satfractdfda (double A) |
| -- Runtime Function: long long accum __satfractdfta (double A) |
| -- Runtime Function: unsigned short fract __satfractdfuqq (double A) |
| -- Runtime Function: unsigned fract __satfractdfuhq (double A) |
| -- Runtime Function: unsigned long fract __satfractdfusq (double A) |
| -- Runtime Function: unsigned long long fract __satfractdfudq (double |
| A) |
| -- Runtime Function: unsigned short accum __satfractdfuha (double A) |
| -- Runtime Function: unsigned accum __satfractdfusa (double A) |
| -- Runtime Function: unsigned long accum __satfractdfuda (double A) |
| -- Runtime Function: unsigned long long accum __satfractdfuta (double |
| A) |
| The functions convert from fractional and signed non-fractionals to |
| fractionals, with saturation. |
| |
| -- Runtime Function: unsigned char __fractunsqqqi (short fract A) |
| -- Runtime Function: unsigned short __fractunsqqhi (short fract A) |
| -- Runtime Function: unsigned int __fractunsqqsi (short fract A) |
| -- Runtime Function: unsigned long __fractunsqqdi (short fract A) |
| -- Runtime Function: unsigned long long __fractunsqqti (short fract A) |
| -- Runtime Function: unsigned char __fractunshqqi (fract A) |
| -- Runtime Function: unsigned short __fractunshqhi (fract A) |
| -- Runtime Function: unsigned int __fractunshqsi (fract A) |
| -- Runtime Function: unsigned long __fractunshqdi (fract A) |
| -- Runtime Function: unsigned long long __fractunshqti (fract A) |
| -- Runtime Function: unsigned char __fractunssqqi (long fract A) |
| -- Runtime Function: unsigned short __fractunssqhi (long fract A) |
| -- Runtime Function: unsigned int __fractunssqsi (long fract A) |
| -- Runtime Function: unsigned long __fractunssqdi (long fract A) |
| -- Runtime Function: unsigned long long __fractunssqti (long fract A) |
| -- Runtime Function: unsigned char __fractunsdqqi (long long fract A) |
| -- Runtime Function: unsigned short __fractunsdqhi (long long fract A) |
| -- Runtime Function: unsigned int __fractunsdqsi (long long fract A) |
| -- Runtime Function: unsigned long __fractunsdqdi (long long fract A) |
| -- Runtime Function: unsigned long long __fractunsdqti (long long fract |
| A) |
| -- Runtime Function: unsigned char __fractunshaqi (short accum A) |
| -- Runtime Function: unsigned short __fractunshahi (short accum A) |
| -- Runtime Function: unsigned int __fractunshasi (short accum A) |
| -- Runtime Function: unsigned long __fractunshadi (short accum A) |
| -- Runtime Function: unsigned long long __fractunshati (short accum A) |
| -- Runtime Function: unsigned char __fractunssaqi (accum A) |
| -- Runtime Function: unsigned short __fractunssahi (accum A) |
| -- Runtime Function: unsigned int __fractunssasi (accum A) |
| -- Runtime Function: unsigned long __fractunssadi (accum A) |
| -- Runtime Function: unsigned long long __fractunssati (accum A) |
| -- Runtime Function: unsigned char __fractunsdaqi (long accum A) |
| -- Runtime Function: unsigned short __fractunsdahi (long accum A) |
| -- Runtime Function: unsigned int __fractunsdasi (long accum A) |
| -- Runtime Function: unsigned long __fractunsdadi (long accum A) |
| -- Runtime Function: unsigned long long __fractunsdati (long accum A) |
| -- Runtime Function: unsigned char __fractunstaqi (long long accum A) |
| -- Runtime Function: unsigned short __fractunstahi (long long accum A) |
| -- Runtime Function: unsigned int __fractunstasi (long long accum A) |
| -- Runtime Function: unsigned long __fractunstadi (long long accum A) |
| -- Runtime Function: unsigned long long __fractunstati (long long accum |
| A) |
| -- Runtime Function: unsigned char __fractunsuqqqi (unsigned short |
| fract A) |
| -- Runtime Function: unsigned short __fractunsuqqhi (unsigned short |
| fract A) |
| -- Runtime Function: unsigned int __fractunsuqqsi (unsigned short fract |
| A) |
| -- Runtime Function: unsigned long __fractunsuqqdi (unsigned short |
| fract A) |
| -- Runtime Function: unsigned long long __fractunsuqqti (unsigned short |
| fract A) |
| -- Runtime Function: unsigned char __fractunsuhqqi (unsigned fract A) |
| -- Runtime Function: unsigned short __fractunsuhqhi (unsigned fract A) |
| -- Runtime Function: unsigned int __fractunsuhqsi (unsigned fract A) |
| -- Runtime Function: unsigned long __fractunsuhqdi (unsigned fract A) |
| -- Runtime Function: unsigned long long __fractunsuhqti (unsigned fract |
| A) |
| -- Runtime Function: unsigned char __fractunsusqqi (unsigned long fract |
| A) |
| -- Runtime Function: unsigned short __fractunsusqhi (unsigned long |
| fract A) |
| -- Runtime Function: unsigned int __fractunsusqsi (unsigned long fract |
| A) |
| -- Runtime Function: unsigned long __fractunsusqdi (unsigned long fract |
| A) |
| -- Runtime Function: unsigned long long __fractunsusqti (unsigned long |
| fract A) |
| -- Runtime Function: unsigned char __fractunsudqqi (unsigned long long |
| fract A) |
| -- Runtime Function: unsigned short __fractunsudqhi (unsigned long long |
| fract A) |
| -- Runtime Function: unsigned int __fractunsudqsi (unsigned long long |
| fract A) |
| -- Runtime Function: unsigned long __fractunsudqdi (unsigned long long |
| fract A) |
| -- Runtime Function: unsigned long long __fractunsudqti (unsigned long |
| long fract A) |
| -- Runtime Function: unsigned char __fractunsuhaqi (unsigned short |
| accum A) |
| -- Runtime Function: unsigned short __fractunsuhahi (unsigned short |
| accum A) |
| -- Runtime Function: unsigned int __fractunsuhasi (unsigned short accum |
| A) |
| -- Runtime Function: unsigned long __fractunsuhadi (unsigned short |
| accum A) |
| -- Runtime Function: unsigned long long __fractunsuhati (unsigned short |
| accum A) |
| -- Runtime Function: unsigned char __fractunsusaqi (unsigned accum A) |
| -- Runtime Function: unsigned short __fractunsusahi (unsigned accum A) |
| -- Runtime Function: unsigned int __fractunsusasi (unsigned accum A) |
| -- Runtime Function: unsigned long __fractunsusadi (unsigned accum A) |
| -- Runtime Function: unsigned long long __fractunsusati (unsigned accum |
| A) |
| -- Runtime Function: unsigned char __fractunsudaqi (unsigned long accum |
| A) |
| -- Runtime Function: unsigned short __fractunsudahi (unsigned long |
| accum A) |
| -- Runtime Function: unsigned int __fractunsudasi (unsigned long accum |
| A) |
| -- Runtime Function: unsigned long __fractunsudadi (unsigned long accum |
| A) |
| -- Runtime Function: unsigned long long __fractunsudati (unsigned long |
| accum A) |
| -- Runtime Function: unsigned char __fractunsutaqi (unsigned long long |
| accum A) |
| -- Runtime Function: unsigned short __fractunsutahi (unsigned long long |
| accum A) |
| -- Runtime Function: unsigned int __fractunsutasi (unsigned long long |
| accum A) |
| -- Runtime Function: unsigned long __fractunsutadi (unsigned long long |
| accum A) |
| -- Runtime Function: unsigned long long __fractunsutati (unsigned long |
| long accum A) |
| -- Runtime Function: short fract __fractunsqiqq (unsigned char A) |
| -- Runtime Function: fract __fractunsqihq (unsigned char A) |
| -- Runtime Function: long fract __fractunsqisq (unsigned char A) |
| -- Runtime Function: long long fract __fractunsqidq (unsigned char A) |
| -- Runtime Function: short accum __fractunsqiha (unsigned char A) |
| -- Runtime Function: accum __fractunsqisa (unsigned char A) |
| -- Runtime Function: long accum __fractunsqida (unsigned char A) |
| -- Runtime Function: long long accum __fractunsqita (unsigned char A) |
| -- Runtime Function: unsigned short fract __fractunsqiuqq (unsigned |
| char A) |
| -- Runtime Function: unsigned fract __fractunsqiuhq (unsigned char A) |
| -- Runtime Function: unsigned long fract __fractunsqiusq (unsigned char |
| A) |
| -- Runtime Function: unsigned long long fract __fractunsqiudq (unsigned |
| char A) |
| -- Runtime Function: unsigned short accum __fractunsqiuha (unsigned |
| char A) |
| -- Runtime Function: unsigned accum __fractunsqiusa (unsigned char A) |
| -- Runtime Function: unsigned long accum __fractunsqiuda (unsigned char |
| A) |
| -- Runtime Function: unsigned long long accum __fractunsqiuta (unsigned |
| char A) |
| -- Runtime Function: short fract __fractunshiqq (unsigned short A) |
| -- Runtime Function: fract __fractunshihq (unsigned short A) |
| -- Runtime Function: long fract __fractunshisq (unsigned short A) |
| -- Runtime Function: long long fract __fractunshidq (unsigned short A) |
| -- Runtime Function: short accum __fractunshiha (unsigned short A) |
| -- Runtime Function: accum __fractunshisa (unsigned short A) |
| -- Runtime Function: long accum __fractunshida (unsigned short A) |
| -- Runtime Function: long long accum __fractunshita (unsigned short A) |
| -- Runtime Function: unsigned short fract __fractunshiuqq (unsigned |
| short A) |
| -- Runtime Function: unsigned fract __fractunshiuhq (unsigned short A) |
| -- Runtime Function: unsigned long fract __fractunshiusq (unsigned |
| short A) |
| -- Runtime Function: unsigned long long fract __fractunshiudq (unsigned |
| short A) |
| -- Runtime Function: unsigned short accum __fractunshiuha (unsigned |
| short A) |
| -- Runtime Function: unsigned accum __fractunshiusa (unsigned short A) |
| -- Runtime Function: unsigned long accum __fractunshiuda (unsigned |
| short A) |
| -- Runtime Function: unsigned long long accum __fractunshiuta (unsigned |
| short A) |
| -- Runtime Function: short fract __fractunssiqq (unsigned int A) |
| -- Runtime Function: fract __fractunssihq (unsigned int A) |
| -- Runtime Function: long fract __fractunssisq (unsigned int A) |
| -- Runtime Function: long long fract __fractunssidq (unsigned int A) |
| -- Runtime Function: short accum __fractunssiha (unsigned int A) |
| -- Runtime Function: accum __fractunssisa (unsigned int A) |
| -- Runtime Function: long accum __fractunssida (unsigned int A) |
| -- Runtime Function: long long accum __fractunssita (unsigned int A) |
| -- Runtime Function: unsigned short fract __fractunssiuqq (unsigned int |
| A) |
| -- Runtime Function: unsigned fract __fractunssiuhq (unsigned int A) |
| -- Runtime Function: unsigned long fract __fractunssiusq (unsigned int |
| A) |
| -- Runtime Function: unsigned long long fract __fractunssiudq (unsigned |
| int A) |
| -- Runtime Function: unsigned short accum __fractunssiuha (unsigned int |
| A) |
| -- Runtime Function: unsigned accum __fractunssiusa (unsigned int A) |
| -- Runtime Function: unsigned long accum __fractunssiuda (unsigned int |
| A) |
| -- Runtime Function: unsigned long long accum __fractunssiuta (unsigned |
| int A) |
| -- Runtime Function: short fract __fractunsdiqq (unsigned long A) |
| -- Runtime Function: fract __fractunsdihq (unsigned long A) |
| -- Runtime Function: long fract __fractunsdisq (unsigned long A) |
| -- Runtime Function: long long fract __fractunsdidq (unsigned long A) |
| -- Runtime Function: short accum __fractunsdiha (unsigned long A) |
| -- Runtime Function: accum __fractunsdisa (unsigned long A) |
| -- Runtime Function: long accum __fractunsdida (unsigned long A) |
| -- Runtime Function: long long accum __fractunsdita (unsigned long A) |
| -- Runtime Function: unsigned short fract __fractunsdiuqq (unsigned |
| long A) |
| -- Runtime Function: unsigned fract __fractunsdiuhq (unsigned long A) |
| -- Runtime Function: unsigned long fract __fractunsdiusq (unsigned long |
| A) |
| -- Runtime Function: unsigned long long fract __fractunsdiudq (unsigned |
| long A) |
| -- Runtime Function: unsigned short accum __fractunsdiuha (unsigned |
| long A) |
| -- Runtime Function: unsigned accum __fractunsdiusa (unsigned long A) |
| -- Runtime Function: unsigned long accum __fractunsdiuda (unsigned long |
| A) |
| -- Runtime Function: unsigned long long accum __fractunsdiuta (unsigned |
| long A) |
| -- Runtime Function: short fract __fractunstiqq (unsigned long long A) |
| -- Runtime Function: fract __fractunstihq (unsigned long long A) |
| -- Runtime Function: long fract __fractunstisq (unsigned long long A) |
| -- Runtime Function: long long fract __fractunstidq (unsigned long long |
| A) |
| -- Runtime Function: short accum __fractunstiha (unsigned long long A) |
| -- Runtime Function: accum __fractunstisa (unsigned long long A) |
| -- Runtime Function: long accum __fractunstida (unsigned long long A) |
| -- Runtime Function: long long accum __fractunstita (unsigned long long |
| A) |
| -- Runtime Function: unsigned short fract __fractunstiuqq (unsigned |
| long long A) |
| -- Runtime Function: unsigned fract __fractunstiuhq (unsigned long long |
| A) |
| -- Runtime Function: unsigned long fract __fractunstiusq (unsigned long |
| long A) |
| -- Runtime Function: unsigned long long fract __fractunstiudq (unsigned |
| long long A) |
| -- Runtime Function: unsigned short accum __fractunstiuha (unsigned |
| long long A) |
| -- Runtime Function: unsigned accum __fractunstiusa (unsigned long long |
| A) |
| -- Runtime Function: unsigned long accum __fractunstiuda (unsigned long |
| long A) |
| -- Runtime Function: unsigned long long accum __fractunstiuta (unsigned |
| long long A) |
| These functions convert from fractionals to unsigned |
| non-fractionals; and from unsigned non-fractionals to fractionals, |
| without saturation. |
| |
| -- Runtime Function: short fract __satfractunsqiqq (unsigned char A) |
| -- Runtime Function: fract __satfractunsqihq (unsigned char A) |
| -- Runtime Function: long fract __satfractunsqisq (unsigned char A) |
| -- Runtime Function: long long fract __satfractunsqidq (unsigned char |
| A) |
| -- Runtime Function: short accum __satfractunsqiha (unsigned char A) |
| -- Runtime Function: accum __satfractunsqisa (unsigned char A) |
| -- Runtime Function: long accum __satfractunsqida (unsigned char A) |
| -- Runtime Function: long long accum __satfractunsqita (unsigned char |
| A) |
| -- Runtime Function: unsigned short fract __satfractunsqiuqq (unsigned |
| char A) |
| -- Runtime Function: unsigned fract __satfractunsqiuhq (unsigned char |
| A) |
| -- Runtime Function: unsigned long fract __satfractunsqiusq (unsigned |
| char A) |
| -- Runtime Function: unsigned long long fract __satfractunsqiudq |
| (unsigned char A) |
| -- Runtime Function: unsigned short accum __satfractunsqiuha (unsigned |
| char A) |
| -- Runtime Function: unsigned accum __satfractunsqiusa (unsigned char |
| A) |
| -- Runtime Function: unsigned long accum __satfractunsqiuda (unsigned |
| char A) |
| -- Runtime Function: unsigned long long accum __satfractunsqiuta |
| (unsigned char A) |
| -- Runtime Function: short fract __satfractunshiqq (unsigned short A) |
| -- Runtime Function: fract __satfractunshihq (unsigned short A) |
| -- Runtime Function: long fract __satfractunshisq (unsigned short A) |
| -- Runtime Function: long long fract __satfractunshidq (unsigned short |
| A) |
| -- Runtime Function: short accum __satfractunshiha (unsigned short A) |
| -- Runtime Function: accum __satfractunshisa (unsigned short A) |
| -- Runtime Function: long accum __satfractunshida (unsigned short A) |
| -- Runtime Function: long long accum __satfractunshita (unsigned short |
| A) |
| -- Runtime Function: unsigned short fract __satfractunshiuqq (unsigned |
| short A) |
| -- Runtime Function: unsigned fract __satfractunshiuhq (unsigned short |
| A) |
| -- Runtime Function: unsigned long fract __satfractunshiusq (unsigned |
| short A) |
| -- Runtime Function: unsigned long long fract __satfractunshiudq |
| (unsigned short A) |
| -- Runtime Function: unsigned short accum __satfractunshiuha (unsigned |
| short A) |
| -- Runtime Function: unsigned accum __satfractunshiusa (unsigned short |
| A) |
| -- Runtime Function: unsigned long accum __satfractunshiuda (unsigned |
| short A) |
| -- Runtime Function: unsigned long long accum __satfractunshiuta |
| (unsigned short A) |
| -- Runtime Function: short fract __satfractunssiqq (unsigned int A) |
| -- Runtime Function: fract __satfractunssihq (unsigned int A) |
| -- Runtime Function: long fract __satfractunssisq (unsigned int A) |
| -- Runtime Function: long long fract __satfractunssidq (unsigned int A) |
| -- Runtime Function: short accum __satfractunssiha (unsigned int A) |
| -- Runtime Function: accum __satfractunssisa (unsigned int A) |
| -- Runtime Function: long accum __satfractunssida (unsigned int A) |
| -- Runtime Function: long long accum __satfractunssita (unsigned int A) |
| -- Runtime Function: unsigned short fract __satfractunssiuqq (unsigned |
| int A) |
| -- Runtime Function: unsigned fract __satfractunssiuhq (unsigned int A) |
| -- Runtime Function: unsigned long fract __satfractunssiusq (unsigned |
| int A) |
| -- Runtime Function: unsigned long long fract __satfractunssiudq |
| (unsigned int A) |
| -- Runtime Function: unsigned short accum __satfractunssiuha (unsigned |
| int A) |
| -- Runtime Function: unsigned accum __satfractunssiusa (unsigned int A) |
| -- Runtime Function: unsigned long accum __satfractunssiuda (unsigned |
| int A) |
| -- Runtime Function: unsigned long long accum __satfractunssiuta |
| (unsigned int A) |
| -- Runtime Function: short fract __satfractunsdiqq (unsigned long A) |
| -- Runtime Function: fract __satfractunsdihq (unsigned long A) |
| -- Runtime Function: long fract __satfractunsdisq (unsigned long A) |
| -- Runtime Function: long long fract __satfractunsdidq (unsigned long |
| A) |
| -- Runtime Function: short accum __satfractunsdiha (unsigned long A) |
| -- Runtime Function: accum __satfractunsdisa (unsigned long A) |
| -- Runtime Function: long accum __satfractunsdida (unsigned long A) |
| -- Runtime Function: long long accum __satfractunsdita (unsigned long |
| A) |
| -- Runtime Function: unsigned short fract __satfractunsdiuqq (unsigned |
| long A) |
| -- Runtime Function: unsigned fract __satfractunsdiuhq (unsigned long |
| A) |
| -- Runtime Function: unsigned long fract __satfractunsdiusq (unsigned |
| long A) |
| -- Runtime Function: unsigned long long fract __satfractunsdiudq |
| (unsigned long A) |
| -- Runtime Function: unsigned short accum __satfractunsdiuha (unsigned |
| long A) |
| -- Runtime Function: unsigned accum __satfractunsdiusa (unsigned long |
| A) |
| -- Runtime Function: unsigned long accum __satfractunsdiuda (unsigned |
| long A) |
| -- Runtime Function: unsigned long long accum __satfractunsdiuta |
| (unsigned long A) |
| -- Runtime Function: short fract __satfractunstiqq (unsigned long long |
| A) |
| -- Runtime Function: fract __satfractunstihq (unsigned long long A) |
| -- Runtime Function: long fract __satfractunstisq (unsigned long long |
| A) |
| -- Runtime Function: long long fract __satfractunstidq (unsigned long |
| long A) |
| -- Runtime Function: short accum __satfractunstiha (unsigned long long |
| A) |
| -- Runtime Function: accum __satfractunstisa (unsigned long long A) |
| -- Runtime Function: long accum __satfractunstida (unsigned long long |
| A) |
| -- Runtime Function: long long accum __satfractunstita (unsigned long |
| long A) |
| -- Runtime Function: unsigned short fract __satfractunstiuqq (unsigned |
| long long A) |
| -- Runtime Function: unsigned fract __satfractunstiuhq (unsigned long |
| long A) |
| -- Runtime Function: unsigned long fract __satfractunstiusq (unsigned |
| long long A) |
| -- Runtime Function: unsigned long long fract __satfractunstiudq |
| (unsigned long long A) |
| -- Runtime Function: unsigned short accum __satfractunstiuha (unsigned |
| long long A) |
| -- Runtime Function: unsigned accum __satfractunstiusa (unsigned long |
| long A) |
| -- Runtime Function: unsigned long accum __satfractunstiuda (unsigned |
| long long A) |
| -- Runtime Function: unsigned long long accum __satfractunstiuta |
| (unsigned long long A) |
| These functions convert from unsigned non-fractionals to |
| fractionals, with saturation. |
| |
| |
| File: gccint.info, Node: Exception handling routines, Next: Miscellaneous routines, Prev: Fixed-point fractional library routines, Up: Libgcc |
| |
| 4.5 Language-independent routines for exception handling |
| ======================================================== |
| |
| document me! |
| |
| _Unwind_DeleteException |
| _Unwind_Find_FDE |
| _Unwind_ForcedUnwind |
| _Unwind_GetGR |
| _Unwind_GetIP |
| _Unwind_GetLanguageSpecificData |
| _Unwind_GetRegionStart |
| _Unwind_GetTextRelBase |
| _Unwind_GetDataRelBase |
| _Unwind_RaiseException |
| _Unwind_Resume |
| _Unwind_SetGR |
| _Unwind_SetIP |
| _Unwind_FindEnclosingFunction |
| _Unwind_SjLj_Register |
| _Unwind_SjLj_Unregister |
| _Unwind_SjLj_RaiseException |
| _Unwind_SjLj_ForcedUnwind |
| _Unwind_SjLj_Resume |
| __deregister_frame |
| __deregister_frame_info |
| __deregister_frame_info_bases |
| __register_frame |
| __register_frame_info |
| __register_frame_info_bases |
| __register_frame_info_table |
| __register_frame_info_table_bases |
| __register_frame_table |
| |
| |
| File: gccint.info, Node: Miscellaneous routines, Prev: Exception handling routines, Up: Libgcc |
| |
| 4.6 Miscellaneous runtime library routines |
| ========================================== |
| |
| 4.6.1 Cache control functions |
| ----------------------------- |
| |
| -- Runtime Function: void __clear_cache (char *BEG, char *END) |
| This function clears the instruction cache between BEG and END. |
| |
| |
| File: gccint.info, Node: Languages, Next: Source Tree, Prev: Libgcc, Up: Top |
| |
| 5 Language Front Ends in GCC |
| **************************** |
| |
| The interface to front ends for languages in GCC, and in particular the |
| 'tree' structure (*note Trees::), was initially designed for C, and many |
| aspects of it are still somewhat biased towards C and C-like languages. |
| It is, however, reasonably well suited to other procedural languages, |
| and front ends for many such languages have been written for GCC. |
| |
| Writing a compiler as a front end for GCC, rather than compiling |
| directly to assembler or generating C code which is then compiled by |
| GCC, has several advantages: |
| |
| * GCC front ends benefit from the support for many different target |
| machines already present in GCC. |
| * GCC front ends benefit from all the optimizations in GCC. Some of |
| these, such as alias analysis, may work better when GCC is |
| compiling directly from source code then when it is compiling from |
| generated C code. |
| * Better debugging information is generated when compiling directly |
| from source code than when going via intermediate generated C code. |
| |
| Because of the advantages of writing a compiler as a GCC front end, GCC |
| front ends have also been created for languages very different from |
| those for which GCC was designed, such as the declarative |
| logic/functional language Mercury. For these reasons, it may also be |
| useful to implement compilers created for specialized purposes (for |
| example, as part of a research project) as GCC front ends. |
| |
| |
| File: gccint.info, Node: Source Tree, Next: Options, Prev: Languages, Up: Top |
| |
| 6 Source Tree Structure and Build System |
| **************************************** |
| |
| This chapter describes the structure of the GCC source tree, and how GCC |
| is built. The user documentation for building and installing GCC is in |
| a separate manual (<http://gcc.gnu.org/install/>), with which it is |
| presumed that you are familiar. |
| |
| * Menu: |
| |
| * Configure Terms:: Configuration terminology and history. |
| * Top Level:: The top level source directory. |
| * gcc Directory:: The 'gcc' subdirectory. |
| * Testsuites:: The GCC testsuites. |
| |
| |
| File: gccint.info, Node: Configure Terms, Next: Top Level, Up: Source Tree |
| |
| 6.1 Configure Terms and History |
| =============================== |
| |
| The configure and build process has a long and colorful history, and can |
| be confusing to anyone who doesn't know why things are the way they are. |
| While there are other documents which describe the configuration process |
| in detail, here are a few things that everyone working on GCC should |
| know. |
| |
| There are three system names that the build knows about: the machine |
| you are building on ("build"), the machine that you are building for |
| ("host"), and the machine that GCC will produce code for ("target"). |
| When you configure GCC, you specify these with '--build=', '--host=', |
| and '--target='. |
| |
| Specifying the host without specifying the build should be avoided, as |
| 'configure' may (and once did) assume that the host you specify is also |
| the build, which may not be true. |
| |
| If build, host, and target are all the same, this is called a "native". |
| If build and host are the same but target is different, this is called a |
| "cross". If build, host, and target are all different this is called a |
| "canadian" (for obscure reasons dealing with Canada's political party |
| and the background of the person working on the build at that time). If |
| host and target are the same, but build is different, you are using a |
| cross-compiler to build a native for a different system. Some people |
| call this a "host-x-host", "crossed native", or "cross-built native". |
| If build and target are the same, but host is different, you are using a |
| cross compiler to build a cross compiler that produces code for the |
| machine you're building on. This is rare, so there is no common way of |
| describing it. There is a proposal to call this a "crossback". |
| |
| If build and host are the same, the GCC you are building will also be |
| used to build the target libraries (like 'libstdc++'). If build and |
| host are different, you must have already built and installed a cross |
| compiler that will be used to build the target libraries (if you |
| configured with '--target=foo-bar', this compiler will be called |
| 'foo-bar-gcc'). |
| |
| In the case of target libraries, the machine you're building for is the |
| machine you specified with '--target'. So, build is the machine you're |
| building on (no change there), host is the machine you're building for |
| (the target libraries are built for the target, so host is the target |
| you specified), and target doesn't apply (because you're not building a |
| compiler, you're building libraries). The configure/make process will |
| adjust these variables as needed. It also sets '$with_cross_host' to |
| the original '--host' value in case you need it. |
| |
| The 'libiberty' support library is built up to three times: once for |
| the host, once for the target (even if they are the same), and once for |
| the build if build and host are different. This allows it to be used by |
| all programs which are generated in the course of the build process. |
| |
| |
| File: gccint.info, Node: Top Level, Next: gcc Directory, Prev: Configure Terms, Up: Source Tree |
| |
| 6.2 Top Level Source Directory |
| ============================== |
| |
| The top level source directory in a GCC distribution contains several |
| files and directories that are shared with other software distributions |
| such as that of GNU Binutils. It also contains several subdirectories |
| that contain parts of GCC and its runtime libraries: |
| |
| 'boehm-gc' |
| The Boehm conservative garbage collector, used as part of the Java |
| runtime library. |
| |
| 'contrib' |
| Contributed scripts that may be found useful in conjunction with |
| GCC. One of these, 'contrib/texi2pod.pl', is used to generate man |
| pages from Texinfo manuals as part of the GCC build process. |
| |
| 'fastjar' |
| An implementation of the 'jar' command, used with the Java front |
| end. |
| |
| 'gcc' |
| The main sources of GCC itself (except for runtime libraries), |
| including optimizers, support for different target architectures, |
| language front ends, and testsuites. *Note The 'gcc' Subdirectory: |
| gcc Directory, for details. |
| |
| 'include' |
| Headers for the 'libiberty' library. |
| |
| 'libada' |
| The Ada runtime library. |
| |
| 'libcpp' |
| The C preprocessor library. |
| |
| 'libgfortran' |
| The Fortran runtime library. |
| |
| 'libffi' |
| The 'libffi' library, used as part of the Java runtime library. |
| |
| 'libiberty' |
| The 'libiberty' library, used for portability and for some |
| generally useful data structures and algorithms. *Note |
| Introduction: (libiberty)Top, for more information about this |
| library. |
| |
| 'libjava' |
| The Java runtime library. |
| |
| 'libmudflap' |
| The 'libmudflap' library, used for instrumenting pointer and array |
| dereferencing operations. |
| |
| 'libobjc' |
| The Objective-C and Objective-C++ runtime library. |
| |
| 'libstdc++-v3' |
| The C++ runtime library. |
| |
| 'maintainer-scripts' |
| Scripts used by the 'gccadmin' account on 'gcc.gnu.org'. |
| |
| 'zlib' |
| The 'zlib' compression library, used by the Java front end and as |
| part of the Java runtime library. |
| |
| The build system in the top level directory, including how recursion |
| into subdirectories works and how building runtime libraries for |
| multilibs is handled, is documented in a separate manual, included with |
| GNU Binutils. *Note GNU configure and build system: (configure)Top, for |
| details. |
| |
| |
| File: gccint.info, Node: gcc Directory, Next: Testsuites, Prev: Top Level, Up: Source Tree |
| |
| 6.3 The 'gcc' Subdirectory |
| ========================== |
| |
| The 'gcc' directory contains many files that are part of the C sources |
| of GCC, other files used as part of the configuration and build process, |
| and subdirectories including documentation and a testsuite. The files |
| that are sources of GCC are documented in a separate chapter. *Note |
| Passes and Files of the Compiler: Passes. |
| |
| * Menu: |
| |
| * Subdirectories:: Subdirectories of 'gcc'. |
| * Configuration:: The configuration process, and the files it uses. |
| * Build:: The build system in the 'gcc' directory. |
| * Makefile:: Targets in 'gcc/Makefile'. |
| * Library Files:: Library source files and headers under 'gcc/'. |
| * Headers:: Headers installed by GCC. |
| * Documentation:: Building documentation in GCC. |
| * Front End:: Anatomy of a language front end. |
| * Back End:: Anatomy of a target back end. |
| |
| |
| File: gccint.info, Node: Subdirectories, Next: Configuration, Up: gcc Directory |
| |
| 6.3.1 Subdirectories of 'gcc' |
| ----------------------------- |
| |
| The 'gcc' directory contains the following subdirectories: |
| |
| 'LANGUAGE' |
| Subdirectories for various languages. Directories containing a |
| file 'config-lang.in' are language subdirectories. The contents of |
| the subdirectories 'cp' (for C++), 'objc' (for Objective-C) and |
| 'objcp' (for Objective-C++) are documented in this manual (*note |
| Passes and Files of the Compiler: Passes.); those for other |
| languages are not. *Note Anatomy of a Language Front End: Front |
| End, for details of the files in these directories. |
| |
| 'config' |
| Configuration files for supported architectures and operating |
| systems. *Note Anatomy of a Target Back End: Back End, for details |
| of the files in this directory. |
| |
| 'doc' |
| Texinfo documentation for GCC, together with automatically |
| generated man pages and support for converting the installation |
| manual to HTML. *Note Documentation::. |
| |
| 'fixinc' |
| The support for fixing system headers to work with GCC. See |
| 'fixinc/README' for more information. The headers fixed by this |
| mechanism are installed in 'LIBSUBDIR/include'. Along with those |
| headers, 'README-fixinc' is also installed, as |
| 'LIBSUBDIR/include/README'. |
| |
| 'ginclude' |
| System headers installed by GCC, mainly those required by the C |
| standard of freestanding implementations. *Note Headers Installed |
| by GCC: Headers, for details of when these and other headers are |
| installed. |
| |
| 'intl' |
| GNU 'libintl', from GNU 'gettext', for systems which do not include |
| it in libc. Properly, this directory should be at top level, |
| parallel to the 'gcc' directory. |
| |
| 'po' |
| Message catalogs with translations of messages produced by GCC into |
| various languages, 'LANGUAGE.po'. This directory also contains |
| 'gcc.pot', the template for these message catalogues, 'exgettext', |
| a wrapper around 'gettext' to extract the messages from the GCC |
| sources and create 'gcc.pot', which is run by 'make gcc.pot', and |
| 'EXCLUDES', a list of files from which messages should not be |
| extracted. |
| |
| 'testsuite' |
| The GCC testsuites (except for those for runtime libraries). *Note |
| Testsuites::. |
| |
| |
| File: gccint.info, Node: Configuration, Next: Build, Prev: Subdirectories, Up: gcc Directory |
| |
| 6.3.2 Configuration in the 'gcc' Directory |
| ------------------------------------------ |
| |
| The 'gcc' directory is configured with an Autoconf-generated script |
| 'configure'. The 'configure' script is generated from 'configure.ac' |
| and 'aclocal.m4'. From the files 'configure.ac' and 'acconfig.h', |
| Autoheader generates the file 'config.in'. The file 'cstamp-h.in' is |
| used as a timestamp. |
| |
| * Menu: |
| |
| * Config Fragments:: Scripts used by 'configure'. |
| * System Config:: The 'config.build', 'config.host', and |
| 'config.gcc' files. |
| * Configuration Files:: Files created by running 'configure'. |
| |
| |
| File: gccint.info, Node: Config Fragments, Next: System Config, Up: Configuration |
| |
| 6.3.2.1 Scripts Used by 'configure' |
| ................................... |
| |
| 'configure' uses some other scripts to help in its work: |
| |
| * The standard GNU 'config.sub' and 'config.guess' files, kept in the |
| top level directory, are used. FIXME: when is the 'config.guess' |
| file in the 'gcc' directory (that just calls the top level one) |
| used? |
| |
| * The file 'config.gcc' is used to handle configuration specific to |
| the particular target machine. The file 'config.build' is used to |
| handle configuration specific to the particular build machine. The |
| file 'config.host' is used to handle configuration specific to the |
| particular host machine. (In general, these should only be used |
| for features that cannot reasonably be tested in Autoconf feature |
| tests.) *Note The 'config.build'; 'config.host'; and 'config.gcc' |
| Files: System Config, for details of the contents of these files. |
| |
| * Each language subdirectory has a file 'LANGUAGE/config-lang.in' |
| that is used for front-end-specific configuration. *Note The Front |
| End 'config-lang.in' File: Front End Config, for details of this |
| file. |
| |
| * A helper script 'configure.frag' is used as part of creating the |
| output of 'configure'. |
| |
| |
| File: gccint.info, Node: System Config, Next: Configuration Files, Prev: Config Fragments, Up: Configuration |
| |
| 6.3.2.2 The 'config.build'; 'config.host'; and 'config.gcc' Files |
| ................................................................. |
| |
| The 'config.build' file contains specific rules for particular systems |
| which GCC is built on. This should be used as rarely as possible, as |
| the behavior of the build system can always be detected by autoconf. |
| |
| The 'config.host' file contains specific rules for particular systems |
| which GCC will run on. This is rarely needed. |
| |
| The 'config.gcc' file contains specific rules for particular systems |
| which GCC will generate code for. This is usually needed. |
| |
| Each file has a list of the shell variables it sets, with descriptions, |
| at the top of the file. |
| |
| FIXME: document the contents of these files, and what variables should |
| be set to control build, host and target configuration. |
| |
| |
| File: gccint.info, Node: Configuration Files, Prev: System Config, Up: Configuration |
| |
| 6.3.2.3 Files Created by 'configure' |
| .................................... |
| |
| Here we spell out what files will be set up by 'configure' in the 'gcc' |
| directory. Some other files are created as temporary files in the |
| configuration process, and are not used in the subsequent build; these |
| are not documented. |
| |
| * 'Makefile' is constructed from 'Makefile.in', together with the |
| host and target fragments (*note Makefile Fragments: Fragments.) |
| 't-TARGET' and 'x-HOST' from 'config', if any, and language |
| Makefile fragments 'LANGUAGE/Make-lang.in'. |
| * 'auto-host.h' contains information about the host machine |
| determined by 'configure'. If the host machine is different from |
| the build machine, then 'auto-build.h' is also created, containing |
| such information about the build machine. |
| * 'config.status' is a script that may be run to recreate the current |
| configuration. |
| * 'configargs.h' is a header containing details of the arguments |
| passed to 'configure' to configure GCC, and of the thread model |
| used. |
| * 'cstamp-h' is used as a timestamp. |
| * 'fixinc/Makefile' is constructed from 'fixinc/Makefile.in'. |
| * 'gccbug', a script for reporting bugs in GCC, is constructed from |
| 'gccbug.in'. |
| * 'intl/Makefile' is constructed from 'intl/Makefile.in'. |
| * If a language 'config-lang.in' file (*note The Front End |
| 'config-lang.in' File: Front End Config.) sets 'outputs', then the |
| files listed in 'outputs' there are also generated. |
| |
| The following configuration headers are created from the Makefile, |
| using 'mkconfig.sh', rather than directly by 'configure'. 'config.h', |
| 'bconfig.h' and 'tconfig.h' all contain the 'xm-MACHINE.h' header, if |
| any, appropriate to the host, build and target machines respectively, |
| the configuration headers for the target, and some definitions; for the |
| host and build machines, these include the autoconfigured headers |
| generated by 'configure'. The other configuration headers are |
| determined by 'config.gcc'. They also contain the typedefs for 'rtx', |
| 'rtvec' and 'tree'. |
| |
| * 'config.h', for use in programs that run on the host machine. |
| * 'bconfig.h', for use in programs that run on the build machine. |
| * 'tconfig.h', for use in programs and libraries for the target |
| machine. |
| * 'tm_p.h', which includes the header 'MACHINE-protos.h' that |
| contains prototypes for functions in the target '.c' file. FIXME: |
| why is such a separate header necessary? |
| |
| |
| File: gccint.info, Node: Build, Next: Makefile, Prev: Configuration, Up: gcc Directory |
| |
| 6.3.3 Build System in the 'gcc' Directory |
| ----------------------------------------- |
| |
| FIXME: describe the build system, including what is built in what |
| stages. Also list the various source files that are used in the build |
| process but aren't source files of GCC itself and so aren't documented |
| below (*note Passes::). |
| |
| |
| File: gccint.info, Node: Makefile, Next: Library Files, Prev: Build, Up: gcc Directory |
| |
| 6.3.4 Makefile Targets |
| ---------------------- |
| |
| These targets are available from the 'gcc' directory: |
| |
| 'all' |
| This is the default target. Depending on what your |
| build/host/target configuration is, it coordinates all the things |
| that need to be built. |
| |
| 'doc' |
| Produce info-formatted documentation and man pages. Essentially it |
| calls 'make man' and 'make info'. |
| |
| 'dvi' |
| Produce DVI-formatted documentation. |
| |
| 'pdf' |
| Produce PDF-formatted documentation. |
| |
| 'html' |
| Produce HTML-formatted documentation. |
| |
| 'man' |
| Generate man pages. |
| |
| 'info' |
| Generate info-formatted pages. |
| |
| 'mostlyclean' |
| Delete the files made while building the compiler. |
| |
| 'clean' |
| That, and all the other files built by 'make all'. |
| |
| 'distclean' |
| That, and all the files created by 'configure'. |
| |
| 'maintainer-clean' |
| Distclean plus any file that can be generated from other files. |
| Note that additional tools may be required beyond what is normally |
| needed to build gcc. |
| |
| 'srcextra' |
| Generates files in the source directory that do not exist in CVS |
| but should go into a release tarball. One example is |
| 'gcc/java/parse.c' which is generated from the CVS source file |
| 'gcc/java/parse.y'. |
| |
| 'srcinfo' |
| 'srcman' |
| Copies the info-formatted and manpage documentation into the source |
| directory usually for the purpose of generating a release tarball. |
| |
| 'install' |
| Installs gcc. |
| |
| 'uninstall' |
| Deletes installed files. |
| |
| 'check' |
| Run the testsuite. This creates a 'testsuite' subdirectory that |
| has various '.sum' and '.log' files containing the results of the |
| testing. You can run subsets with, for example, 'make check-gcc'. |
| You can specify specific tests by setting RUNTESTFLAGS to be the |
| name of the '.exp' file, optionally followed by (for some tests) an |
| equals and a file wildcard, like: |
| |
| make check-gcc RUNTESTFLAGS="execute.exp=19980413-*" |
| |
| Note that running the testsuite may require additional tools be |
| installed, such as TCL or dejagnu. |
| |
| The toplevel tree from which you start GCC compilation is not the GCC |
| directory, but rather a complex Makefile that coordinates the various |
| steps of the build, including bootstrapping the compiler and using the |
| new compiler to build target libraries. |
| |
| When GCC is configured for a native configuration, the default action |
| for 'make' is to do a full three-stage bootstrap. This means that GCC |
| is built three times--once with the native compiler, once with the |
| native-built compiler it just built, and once with the compiler it built |
| the second time. In theory, the last two should produce the same |
| results, which 'make compare' can check. Each stage is configured |
| separately and compiled into a separate directory, to minimize problems |
| due to ABI incompatibilities between the native compiler and GCC. |
| |
| If you do a change, rebuilding will also start from the first stage and |
| "bubble" up the change through the three stages. Each stage is taken |
| from its build directory (if it had been built previously), rebuilt, and |
| copied to its subdirectory. This will allow you to, for example, |
| continue a bootstrap after fixing a bug which causes the stage2 build to |
| crash. It does not provide as good coverage of the compiler as |
| bootstrapping from scratch, but it ensures that the new code is |
| syntactically correct (e.g., that you did not use GCC extensions by |
| mistake), and avoids spurious bootstrap comparison failures(1). |
| |
| Other targets available from the top level include: |
| |
| 'bootstrap-lean' |
| Like 'bootstrap', except that the various stages are removed once |
| they're no longer needed. This saves disk space. |
| |
| 'bootstrap2' |
| 'bootstrap2-lean' |
| Performs only the first two stages of bootstrap. Unlike a |
| three-stage bootstrap, this does not perform a comparison to test |
| that the compiler is running properly. Note that the disk space |
| required by a "lean" bootstrap is approximately independent of the |
| number of stages. |
| |
| 'stageN-bubble (N = 1...4)' |
| Rebuild all the stages up to N, with the appropriate flags, |
| "bubbling" the changes as described above. |
| |
| 'all-stageN (N = 1...4)' |
| Assuming that stage N has already been built, rebuild it with the |
| appropriate flags. This is rarely needed. |
| |
| 'cleanstrap' |
| Remove everything ('make clean') and rebuilds ('make bootstrap'). |
| |
| 'compare' |
| Compares the results of stages 2 and 3. This ensures that the |
| compiler is running properly, since it should produce the same |
| object files regardless of how it itself was compiled. |
| |
| 'profiledbootstrap' |
| Builds a compiler with profiling feedback information. For more |
| information, see *note Building with profile feedback: |
| (gccinstall)Building. |
| |
| 'restrap' |
| Restart a bootstrap, so that everything that was not built with the |
| system compiler is rebuilt. |
| |
| 'stageN-start (N = 1...4)' |
| For each package that is bootstrapped, rename directories so that, |
| for example, 'gcc' points to the stageN GCC, compiled with the |
| stageN-1 GCC(2). |
| |
| You will invoke this target if you need to test or debug the stageN |
| GCC. If you only need to execute GCC (but you need not run 'make' |
| either to rebuild it or to run test suites), you should be able to |
| work directly in the 'stageN-gcc' directory. This makes it easier |
| to debug multiple stages in parallel. |
| |
| 'stage' |
| For each package that is bootstrapped, relocate its build directory |
| to indicate its stage. For example, if the 'gcc' directory points |
| to the stage2 GCC, after invoking this target it will be renamed to |
| 'stage2-gcc'. |
| |
| If you wish to use non-default GCC flags when compiling the stage2 and |
| stage3 compilers, set 'BOOT_CFLAGS' on the command line when doing |
| 'make'. |
| |
| Usually, the first stage only builds the languages that the compiler is |
| written in: typically, C and maybe Ada. If you are debugging a |
| miscompilation of a different stage2 front-end (for example, of the |
| Fortran front-end), you may want to have front-ends for other languages |
| in the first stage as well. To do so, set 'STAGE1_LANGUAGES' on the |
| command line when doing 'make'. |
| |
| For example, in the aforementioned scenario of debugging a Fortran |
| front-end miscompilation caused by the stage1 compiler, you may need a |
| command like |
| |
| make stage2-bubble STAGE1_LANGUAGES=c,fortran |
| |
| Alternatively, you can use per-language targets to build and test |
| languages that are not enabled by default in stage1. For example, 'make |
| f951' will build a Fortran compiler even in the stage1 build directory. |
| |
| ---------- Footnotes ---------- |
| |
| (1) Except if the compiler was buggy and miscompiled some of the |
| files that were not modified. In this case, it's best to use 'make |
| restrap'. |
| |
| (2) Customarily, the system compiler is also termed the 'stage0' GCC. |
| |
| |
| File: gccint.info, Node: Library Files, Next: Headers, Prev: Makefile, Up: gcc Directory |
| |
| 6.3.5 Library Source Files and Headers under the 'gcc' Directory |
| ---------------------------------------------------------------- |
| |
| FIXME: list here, with explanation, all the C source files and headers |
| under the 'gcc' directory that aren't built into the GCC executable but |
| rather are part of runtime libraries and object files, such as |
| 'crtstuff.c' and 'unwind-dw2.c'. *Note Headers Installed by GCC: |
| Headers, for more information about the 'ginclude' directory. |
| |
| |
| File: gccint.info, Node: Headers, Next: Documentation, Prev: Library Files, Up: gcc Directory |
| |
| 6.3.6 Headers Installed by GCC |
| ------------------------------ |
| |
| In general, GCC expects the system C library to provide most of the |
| headers to be used with it. However, GCC will fix those headers if |
| necessary to make them work with GCC, and will install some headers |
| required of freestanding implementations. These headers are installed |
| in 'LIBSUBDIR/include'. Headers for non-C runtime libraries are also |
| installed by GCC; these are not documented here. (FIXME: document them |
| somewhere.) |
| |
| Several of the headers GCC installs are in the 'ginclude' directory. |
| These headers, 'iso646.h', 'stdarg.h', 'stdbool.h', and 'stddef.h', are |
| installed in 'LIBSUBDIR/include', unless the target Makefile fragment |
| (*note Target Fragment::) overrides this by setting 'USER_H'. |
| |
| In addition to these headers and those generated by fixing system |
| headers to work with GCC, some other headers may also be installed in |
| 'LIBSUBDIR/include'. 'config.gcc' may set 'extra_headers'; this |
| specifies additional headers under 'config' to be installed on some |
| systems. |
| |
| GCC installs its own version of '<float.h>', from 'ginclude/float.h'. |
| This is done to cope with command-line options that change the |
| representation of floating point numbers. |
| |
| GCC also installs its own version of '<limits.h>'; this is generated |
| from 'glimits.h', together with 'limitx.h' and 'limity.h' if the system |
| also has its own version of '<limits.h>'. (GCC provides its own header |
| because it is required of ISO C freestanding implementations, but needs |
| to include the system header from its own header as well because other |
| standards such as POSIX specify additional values to be defined in |
| '<limits.h>'.) The system's '<limits.h>' header is used via |
| 'LIBSUBDIR/include/syslimits.h', which is copied from 'gsyslimits.h' if |
| it does not need fixing to work with GCC; if it needs fixing, |
| 'syslimits.h' is the fixed copy. |
| |
| GCC can also install '<tgmath.h>'. It will do this when 'config.gcc' |
| sets 'use_gcc_tgmath' to 'yes'. |
| |
| |
| File: gccint.info, Node: Documentation, Next: Front End, Prev: Headers, Up: gcc Directory |
| |
| 6.3.7 Building Documentation |
| ---------------------------- |
| |
| The main GCC documentation is in the form of manuals in Texinfo format. |
| These are installed in Info format; DVI versions may be generated by |
| 'make dvi', PDF versions by 'make pdf', and HTML versions by 'make |
| html'. In addition, some man pages are generated from the Texinfo |
| manuals, there are some other text files with miscellaneous |
| documentation, and runtime libraries have their own documentation |
| outside the 'gcc' directory. FIXME: document the documentation for |
| runtime libraries somewhere. |
| |
| * Menu: |
| |
| * Texinfo Manuals:: GCC manuals in Texinfo format. |
| * Man Page Generation:: Generating man pages from Texinfo manuals. |
| * Miscellaneous Docs:: Miscellaneous text files with documentation. |
| |
| |
| File: gccint.info, Node: Texinfo Manuals, Next: Man Page Generation, Up: Documentation |
| |
| 6.3.7.1 Texinfo Manuals |
| ....................... |
| |
| The manuals for GCC as a whole, and the C and C++ front ends, are in |
| files 'doc/*.texi'. Other front ends have their own manuals in files |
| 'LANGUAGE/*.texi'. Common files 'doc/include/*.texi' are provided which |
| may be included in multiple manuals; the following files are in |
| 'doc/include': |
| |
| 'fdl.texi' |
| The GNU Free Documentation License. |
| 'funding.texi' |
| The section "Funding Free Software". |
| 'gcc-common.texi' |
| Common definitions for manuals. |
| 'gpl.texi' |
| 'gpl_v3.texi' |
| The GNU General Public License. |
| 'texinfo.tex' |
| A copy of 'texinfo.tex' known to work with the GCC manuals. |
| |
| DVI-formatted manuals are generated by 'make dvi', which uses |
| 'texi2dvi' (via the Makefile macro '$(TEXI2DVI)'). PDF-formatted |
| manuals are generated by 'make pdf', which uses 'texi2pdf' (via the |
| Makefile macro '$(TEXI2PDF)'). HTML formatted manuals are generated by |
| 'make html'. Info manuals are generated by 'make info' (which is run as |
| part of a bootstrap); this generates the manuals in the source |
| directory, using 'makeinfo' via the Makefile macro '$(MAKEINFO)', and |
| they are included in release distributions. |
| |
| Manuals are also provided on the GCC web site, in both HTML and |
| PostScript forms. This is done via the script |
| 'maintainer-scripts/update_web_docs'. Each manual to be provided online |
| must be listed in the definition of 'MANUALS' in that file; a file |
| 'NAME.texi' must only appear once in the source tree, and the output |
| manual must have the same name as the source file. (However, other |
| Texinfo files, included in manuals but not themselves the root files of |
| manuals, may have names that appear more than once in the source tree.) |
| The manual file 'NAME.texi' should only include other files in its own |
| directory or in 'doc/include'. HTML manuals will be generated by |
| 'makeinfo --html', PostScript manuals by 'texi2dvi' and 'dvips', and PDF |
| manuals by 'texi2pdf'. All Texinfo files that are parts of manuals must |
| be checked into SVN, even if they are generated files, for the |
| generation of online manuals to work. |
| |
| The installation manual, 'doc/install.texi', is also provided on the |
| GCC web site. The HTML version is generated by the script |
| 'doc/install.texi2html'. |
| |
| |
| File: gccint.info, Node: Man Page Generation, Next: Miscellaneous Docs, Prev: Texinfo Manuals, Up: Documentation |
| |
| 6.3.7.2 Man Page Generation |
| ........................... |
| |
| Because of user demand, in addition to full Texinfo manuals, man pages |
| are provided which contain extracts from those manuals. These man pages |
| are generated from the Texinfo manuals using 'contrib/texi2pod.pl' and |
| 'pod2man'. (The man page for 'g++', 'cp/g++.1', just contains a '.so' |
| reference to 'gcc.1', but all the other man pages are generated from |
| Texinfo manuals.) |
| |
| Because many systems may not have the necessary tools installed to |
| generate the man pages, they are only generated if the 'configure' |
| script detects that recent enough tools are installed, and the Makefiles |
| allow generating man pages to fail without aborting the build. Man |
| pages are also included in release distributions. They are generated in |
| the source directory. |
| |
| Magic comments in Texinfo files starting '@c man' control what parts of |
| a Texinfo file go into a man page. Only a subset of Texinfo is |
| supported by 'texi2pod.pl', and it may be necessary to add support for |
| more Texinfo features to this script when generating new man pages. To |
| improve the man page output, some special Texinfo macros are provided in |
| 'doc/include/gcc-common.texi' which 'texi2pod.pl' understands: |
| |
| '@gcctabopt' |
| Use in the form '@table @gcctabopt' for tables of options, where |
| for printed output the effect of '@code' is better than that of |
| '@option' but for man page output a different effect is wanted. |
| '@gccoptlist' |
| Use for summary lists of options in manuals. |
| '@gol' |
| Use at the end of each line inside '@gccoptlist'. This is |
| necessary to avoid problems with differences in how the |
| '@gccoptlist' macro is handled by different Texinfo formatters. |
| |
| FIXME: describe the 'texi2pod.pl' input language and magic comments in |
| more detail. |
| |
| |
| File: gccint.info, Node: Miscellaneous Docs, Prev: Man Page Generation, Up: Documentation |
| |
| 6.3.7.3 Miscellaneous Documentation |
| ................................... |
| |
| In addition to the formal documentation that is installed by GCC, there |
| are several other text files with miscellaneous documentation: |
| |
| 'ABOUT-GCC-NLS' |
| Notes on GCC's Native Language Support. FIXME: this should be part |
| of this manual rather than a separate file. |
| 'ABOUT-NLS' |
| Notes on the Free Translation Project. |
| 'COPYING' |
| The GNU General Public License. |
| 'COPYING.LIB' |
| The GNU Lesser General Public License. |
| '*ChangeLog*' |
| '*/ChangeLog*' |
| Change log files for various parts of GCC. |
| 'LANGUAGES' |
| Details of a few changes to the GCC front-end interface. FIXME: |
| the information in this file should be part of general |
| documentation of the front-end interface in this manual. |
| 'ONEWS' |
| Information about new features in old versions of GCC. (For recent |
| versions, the information is on the GCC web site.) |
| 'README.Portability' |
| Information about portability issues when writing code in GCC. |
| FIXME: why isn't this part of this manual or of the GCC Coding |
| Conventions? |
| |
| FIXME: document such files in subdirectories, at least 'config', 'cp', |
| 'objc', 'testsuite'. |
| |
| |
| File: gccint.info, Node: Front End, Next: Back End, Prev: Documentation, Up: gcc Directory |
| |
| 6.3.8 Anatomy of a Language Front End |
| ------------------------------------- |
| |
| A front end for a language in GCC has the following parts: |
| |
| * A directory 'LANGUAGE' under 'gcc' containing source files for that |
| front end. *Note The Front End 'LANGUAGE' Directory: Front End |
| Directory, for details. |
| * A mention of the language in the list of supported languages in |
| 'gcc/doc/install.texi'. |
| * A mention of the name under which the language's runtime library is |
| recognized by '--enable-shared=PACKAGE' in the documentation of |
| that option in 'gcc/doc/install.texi'. |
| * A mention of any special prerequisites for building the front end |
| in the documentation of prerequisites in 'gcc/doc/install.texi'. |
| * Details of contributors to that front end in |
| 'gcc/doc/contrib.texi'. If the details are in that front end's own |
| manual then there should be a link to that manual's list in |
| 'contrib.texi'. |
| * Information about support for that language in |
| 'gcc/doc/frontends.texi'. |
| * Information about standards for that language, and the front end's |
| support for them, in 'gcc/doc/standards.texi'. This may be a link |
| to such information in the front end's own manual. |
| * Details of source file suffixes for that language and '-x LANG' |
| options supported, in 'gcc/doc/invoke.texi'. |
| * Entries in 'default_compilers' in 'gcc.c' for source file suffixes |
| for that language. |
| * Preferably testsuites, which may be under 'gcc/testsuite' or |
| runtime library directories. FIXME: document somewhere how to |
| write testsuite harnesses. |
| * Probably a runtime library for the language, outside the 'gcc' |
| directory. FIXME: document this further. |
| * Details of the directories of any runtime libraries in |
| 'gcc/doc/sourcebuild.texi'. |
| |
| If the front end is added to the official GCC source repository, the |
| following are also necessary: |
| |
| * At least one Bugzilla component for bugs in that front end and |
| runtime libraries. This category needs to be mentioned in |
| 'gcc/gccbug.in', as well as being added to the Bugzilla database. |
| * Normally, one or more maintainers of that front end listed in |
| 'MAINTAINERS'. |
| * Mentions on the GCC web site in 'index.html' and 'frontends.html', |
| with any relevant links on 'readings.html'. (Front ends that are |
| not an official part of GCC may also be listed on 'frontends.html', |
| with relevant links.) |
| * A news item on 'index.html', and possibly an announcement on the |
| <gcc-announce@gcc.gnu.org> mailing list. |
| * The front end's manuals should be mentioned in |
| 'maintainer-scripts/update_web_docs' (*note Texinfo Manuals::) and |
| the online manuals should be linked to from |
| 'onlinedocs/index.html'. |
| * Any old releases or CVS repositories of the front end, before its |
| inclusion in GCC, should be made available on the GCC FTP site |
| <ftp://gcc.gnu.org/pub/gcc/old-releases/>. |
| * The release and snapshot script 'maintainer-scripts/gcc_release' |
| should be updated to generate appropriate tarballs for this front |
| end. The associated 'maintainer-scripts/snapshot-README' and |
| 'maintainer-scripts/snapshot-index.html' files should be updated to |
| list the tarballs and diffs for this front end. |
| * If this front end includes its own version files that include the |
| current date, 'maintainer-scripts/update_version' should be updated |
| accordingly. |
| |
| * Menu: |
| |
| * Front End Directory:: The front end 'LANGUAGE' directory. |
| * Front End Config:: The front end 'config-lang.in' file. |
| |
| |
| File: gccint.info, Node: Front End Directory, Next: Front End Config, Up: Front End |
| |
| 6.3.8.1 The Front End 'LANGUAGE' Directory |
| .......................................... |
| |
| A front end 'LANGUAGE' directory contains the source files of that front |
| end (but not of any runtime libraries, which should be outside the 'gcc' |
| directory). This includes documentation, and possibly some subsidiary |
| programs build alongside the front end. Certain files are special and |
| other parts of the compiler depend on their names: |
| |
| 'config-lang.in' |
| This file is required in all language subdirectories. *Note The |
| Front End 'config-lang.in' File: Front End Config, for details of |
| its contents |
| 'Make-lang.in' |
| This file is required in all language subdirectories. It contains |
| targets 'LANG.HOOK' (where 'LANG' is the setting of 'language' in |
| 'config-lang.in') for the following values of 'HOOK', and any other |
| Makefile rules required to build those targets (which may if |
| necessary use other Makefiles specified in 'outputs' in |
| 'config-lang.in', although this is deprecated). It also adds any |
| testsuite targets that can use the standard rule in |
| 'gcc/Makefile.in' to the variable 'lang_checks'. |
| |
| 'all.cross' |
| 'start.encap' |
| 'rest.encap' |
| FIXME: exactly what goes in each of these targets? |
| 'tags' |
| Build an 'etags' 'TAGS' file in the language subdirectory in |
| the source tree. |
| 'info' |
| Build info documentation for the front end, in the build |
| directory. This target is only called by 'make bootstrap' if |
| a suitable version of 'makeinfo' is available, so does not |
| need to check for this, and should fail if an error occurs. |
| 'dvi' |
| Build DVI documentation for the front end, in the build |
| directory. This should be done using '$(TEXI2DVI)', with |
| appropriate '-I' arguments pointing to directories of included |
| files. |
| 'pdf' |
| Build PDF documentation for the front end, in the build |
| directory. This should be done using '$(TEXI2PDF)', with |
| appropriate '-I' arguments pointing to directories of included |
| files. |
| 'html' |
| Build HTML documentation for the front end, in the build |
| directory. |
| 'man' |
| Build generated man pages for the front end from Texinfo |
| manuals (*note Man Page Generation::), in the build directory. |
| This target is only called if the necessary tools are |
| available, but should ignore errors so as not to stop the |
| build if errors occur; man pages are optional and the tools |
| involved may be installed in a broken way. |
| 'install-common' |
| Install everything that is part of the front end, apart from |
| the compiler executables listed in 'compilers' in |
| 'config-lang.in'. |
| 'install-info' |
| Install info documentation for the front end, if it is present |
| in the source directory. This target should have dependencies |
| on info files that should be installed. |
| 'install-man' |
| Install man pages for the front end. This target should |
| ignore errors. |
| 'srcextra' |
| Copies its dependencies into the source directory. This |
| generally should be used for generated files such as Bison |
| output files which are not present in CVS, but should be |
| included in any release tarballs. This target will be |
| executed during a bootstrap if |
| '--enable-generated-files-in-srcdir' was specified as a |
| 'configure' option. |
| 'srcinfo' |
| 'srcman' |
| Copies its dependencies into the source directory. These |
| targets will be executed during a bootstrap if |
| '--enable-generated-files-in-srcdir' was specified as a |
| 'configure' option. |
| 'uninstall' |
| Uninstall files installed by installing the compiler. This is |
| currently documented not to be supported, so the hook need not |
| do anything. |
| 'mostlyclean' |
| 'clean' |
| 'distclean' |
| 'maintainer-clean' |
| The language parts of the standard GNU '*clean' targets. |
| *Note Standard Targets for Users: (standards)Standard Targets, |
| for details of the standard targets. For GCC, |
| 'maintainer-clean' should delete all generated files in the |
| source directory that are not checked into CVS, but should not |
| delete anything checked into CVS. |
| |
| 'lang.opt' |
| This file registers the set of switches that the front end accepts |
| on the command line, and their '--help' text. *Note Options::. |
| 'lang-specs.h' |
| This file provides entries for 'default_compilers' in 'gcc.c' which |
| override the default of giving an error that a compiler for that |
| language is not installed. |
| 'LANGUAGE-tree.def' |
| This file, which need not exist, defines any language-specific tree |
| codes. |
| |
| |
| File: gccint.info, Node: Front End Config, Prev: Front End Directory, Up: Front End |
| |
| 6.3.8.2 The Front End 'config-lang.in' File |
| ........................................... |
| |
| Each language subdirectory contains a 'config-lang.in' file. In |
| addition the main directory contains 'c-config-lang.in', which contains |
| limited information for the C language. This file is a shell script |
| that may define some variables describing the language: |
| |
| 'language' |
| This definition must be present, and gives the name of the language |
| for some purposes such as arguments to '--enable-languages'. |
| 'lang_requires' |
| If defined, this variable lists (space-separated) language front |
| ends other than C that this front end requires to be enabled (with |
| the names given being their 'language' settings). For example, the |
| Java front end depends on the C++ front end, so sets |
| 'lang_requires=c++'. |
| 'subdir_requires' |
| If defined, this variable lists (space-separated) front end |
| directories other than C that this front end requires to be |
| present. For example, the Objective-C++ front end uses source |
| files from the C++ and Objective-C front ends, so sets |
| 'subdir_requires="cp objc"'. |
| 'target_libs' |
| If defined, this variable lists (space-separated) targets in the |
| top level 'Makefile' to build the runtime libraries for this |
| language, such as 'target-libobjc'. |
| 'lang_dirs' |
| If defined, this variable lists (space-separated) top level |
| directories (parallel to 'gcc'), apart from the runtime libraries, |
| that should not be configured if this front end is not built. |
| 'build_by_default' |
| If defined to 'no', this language front end is not built unless |
| enabled in a '--enable-languages' argument. Otherwise, front ends |
| are built by default, subject to any special logic in |
| 'configure.ac' (as is present to disable the Ada front end if the |
| Ada compiler is not already installed). |
| 'boot_language' |
| If defined to 'yes', this front end is built in stage 1 of the |
| bootstrap. This is only relevant to front ends written in their |
| own languages. |
| 'compilers' |
| If defined, a space-separated list of compiler executables that |
| will be run by the driver. The names here will each end with |
| '\$(exeext)'. |
| 'outputs' |
| If defined, a space-separated list of files that should be |
| generated by 'configure' substituting values in them. This |
| mechanism can be used to create a file 'LANGUAGE/Makefile' from |
| 'LANGUAGE/Makefile.in', but this is deprecated, building everything |
| from the single 'gcc/Makefile' is preferred. |
| 'gtfiles' |
| If defined, a space-separated list of files that should be scanned |
| by gengtype.c to generate the garbage collection tables and |
| routines for this language. This excludes the files that are |
| common to all front ends. *Note Type Information::. |
| |
| |
| File: gccint.info, Node: Back End, Prev: Front End, Up: gcc Directory |
| |
| 6.3.9 Anatomy of a Target Back End |
| ---------------------------------- |
| |
| A back end for a target architecture in GCC has the following parts: |
| |
| * A directory 'MACHINE' under 'gcc/config', containing a machine |
| description 'MACHINE.md' file (*note Machine Descriptions: Machine |
| Desc.), header files 'MACHINE.h' and 'MACHINE-protos.h' and a |
| source file 'MACHINE.c' (*note Target Description Macros and |
| Functions: Target Macros.), possibly a target Makefile fragment |
| 't-MACHINE' (*note The Target Makefile Fragment: Target Fragment.), |
| and maybe some other files. The names of these files may be |
| changed from the defaults given by explicit specifications in |
| 'config.gcc'. |
| * If necessary, a file 'MACHINE-modes.def' in the 'MACHINE' |
| directory, containing additional machine modes to represent |
| condition codes. *Note Condition Code::, for further details. |
| * An optional 'MACHINE.opt' file in the 'MACHINE' directory, |
| containing a list of target-specific options. You can also add |
| other option files using the 'extra_options' variable in |
| 'config.gcc'. *Note Options::. |
| * Entries in 'config.gcc' (*note The 'config.gcc' File: System |
| Config.) for the systems with this target architecture. |
| * Documentation in 'gcc/doc/invoke.texi' for any command-line options |
| supported by this target (*note Run-time Target Specification: |
| Run-time Target.). This means both entries in the summary table of |
| options and details of the individual options. |
| * Documentation in 'gcc/doc/extend.texi' for any target-specific |
| attributes supported (*note Defining target-specific uses of |
| '__attribute__': Target Attributes.), including where the same |
| attribute is already supported on some targets, which are |
| enumerated in the manual. |
| * Documentation in 'gcc/doc/extend.texi' for any target-specific |
| pragmas supported. |
| * Documentation in 'gcc/doc/extend.texi' of any target-specific |
| built-in functions supported. |
| * Documentation in 'gcc/doc/extend.texi' of any target-specific |
| format checking styles supported. |
| * Documentation in 'gcc/doc/md.texi' of any target-specific |
| constraint letters (*note Constraints for Particular Machines: |
| Machine Constraints.). |
| * A note in 'gcc/doc/contrib.texi' under the person or people who |
| contributed the target support. |
| * Entries in 'gcc/doc/install.texi' for all target triplets supported |
| with this target architecture, giving details of any special notes |
| about installation for this target, or saying that there are no |
| special notes if there are none. |
| * Possibly other support outside the 'gcc' directory for runtime |
| libraries. FIXME: reference docs for this. The libstdc++ porting |
| manual needs to be installed as info for this to work, or to be a |
| chapter of this manual. |
| |
| If the back end is added to the official GCC source repository, the |
| following are also necessary: |
| |
| * An entry for the target architecture in 'readings.html' on the GCC |
| web site, with any relevant links. |
|
