arch/arm26/nwfpe/ARM-gcc.h

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