ARM-gcc.h 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. /*
  3. -------------------------------------------------------------------------------
  4. The macro `BITS64' can be defined to indicate that 64-bit integer types are
  5. supported by the compiler.
  6. -------------------------------------------------------------------------------
  7. */
  8. #define BITS64
  9. /*
  10. -------------------------------------------------------------------------------
  11. Each of the following `typedef's defines the most convenient type that holds
  12. integers of at least as many bits as specified. For example, `uint8' should
  13. be the most convenient type that can hold unsigned integers of as many as
  14. 8 bits. The `flag' type must be able to hold either a 0 or 1. For most
  15. implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
  16. to the same as `int'.
  17. -------------------------------------------------------------------------------
  18. */
  19. typedef char flag;
  20. typedef unsigned char uint8;
  21. typedef signed char int8;
  22. typedef int uint16;
  23. typedef int int16;
  24. typedef unsigned int uint32;
  25. typedef signed int int32;
  26. #ifdef BITS64
  27. typedef unsigned long long int bits64;
  28. typedef signed long long int sbits64;
  29. #endif
  30. /*
  31. -------------------------------------------------------------------------------
  32. Each of the following `typedef's defines a type that holds integers
  33. of _exactly_ the number of bits specified. For instance, for most
  34. implementation of C, `bits16' and `sbits16' should be `typedef'ed to
  35. `unsigned short int' and `signed short int' (or `short int'), respectively.
  36. -------------------------------------------------------------------------------
  37. */
  38. typedef unsigned char bits8;
  39. typedef signed char sbits8;
  40. typedef unsigned short int bits16;
  41. typedef signed short int sbits16;
  42. typedef unsigned int bits32;
  43. typedef signed int sbits32;
  44. #ifdef BITS64
  45. typedef unsigned long long int uint64;
  46. typedef signed long long int int64;
  47. #endif
  48. #ifdef BITS64
  49. /*
  50. -------------------------------------------------------------------------------
  51. The `LIT64' macro takes as its argument a textual integer literal and if
  52. necessary ``marks'' the literal as having a 64-bit integer type. For
  53. example, the Gnu C Compiler (`gcc') requires that 64-bit literals be
  54. appended with the letters `LL' standing for `long long', which is `gcc's
  55. name for the 64-bit integer type. Some compilers may allow `LIT64' to be
  56. defined as the identity macro: `#define LIT64( a ) a'.
  57. -------------------------------------------------------------------------------
  58. */
  59. #define LIT64( a ) a##LL
  60. #endif
  61. /*
  62. -------------------------------------------------------------------------------
  63. The macro `INLINE' can be used before functions that should be inlined. If
  64. a compiler does not support explicit inlining, this macro should be defined
  65. to be `static'.
  66. -------------------------------------------------------------------------------
  67. */
  68. #define INLINE static inline
  69. /* For use as a GCC soft-float library we need some special function names. */
  70. #ifdef __LIBFLOAT__
  71. /* Some 32-bit ops can be mapped straight across by just changing the name. */
  72. #define float32_add __addsf3
  73. #define float32_sub __subsf3
  74. #define float32_mul __mulsf3
  75. #define float32_div __divsf3
  76. #define int32_to_float32 __floatsisf
  77. #define float32_to_int32_round_to_zero __fixsfsi
  78. #define float32_to_uint32_round_to_zero __fixunssfsi
  79. /* These ones go through the glue code. To avoid namespace pollution
  80. we rename the internal functions too. */
  81. #define float32_eq ___float32_eq
  82. #define float32_le ___float32_le
  83. #define float32_lt ___float32_lt
  84. /* All the 64-bit ops have to go through the glue, so we pull the same
  85. trick. */
  86. #define float64_add ___float64_add
  87. #define float64_sub ___float64_sub
  88. #define float64_mul ___float64_mul
  89. #define float64_div ___float64_div
  90. #define int32_to_float64 ___int32_to_float64
  91. #define float64_to_int32_round_to_zero ___float64_to_int32_round_to_zero
  92. #define float64_to_uint32_round_to_zero ___float64_to_uint32_round_to_zero
  93. #define float64_to_float32 ___float64_to_float32
  94. #define float32_to_float64 ___float32_to_float64
  95. #define float64_eq ___float64_eq
  96. #define float64_le ___float64_le
  97. #define float64_lt ___float64_lt
  98. #if 0
  99. #define float64_add __adddf3
  100. #define float64_sub __subdf3
  101. #define float64_mul __muldf3
  102. #define float64_div __divdf3
  103. #define int32_to_float64 __floatsidf
  104. #define float64_to_int32_round_to_zero __fixdfsi
  105. #define float64_to_uint32_round_to_zero __fixunsdfsi
  106. #define float64_to_float32 __truncdfsf2
  107. #define float32_to_float64 __extendsfdf2
  108. #endif
  109. #endif