compiler-rt/lib/builtins/fp_extend.h

   1 //===-lib/fp_extend.h - low precision -> high precision conversion -*- C
   2 //-*-===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Set source and destination setting
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef FP_EXTEND_HEADER
  15 #define FP_EXTEND_HEADER
  16
  17 #include "int_lib.h"
  18
  19 #if defined SRC_SINGLE
  20 typedef float src_t;
  21 typedef uint32_t src_rep_t;
  22 #define SRC_REP_C UINT32_C
  23 static const int srcBits = sizeof(src_t) * CHAR_BIT;
  24 static const int srcSigFracBits = 23;
  25 // -1 accounts for the sign bit.
  26 // srcBits - srcSigFracBits - 1
  27 static const int srcExpBits = 8;
  28 #define src_rep_t_clz clzsi
  29
  30 #elif defined SRC_DOUBLE
  31 typedef double src_t;
  32 typedef uint64_t src_rep_t;
  33 #define SRC_REP_C UINT64_C
  34 static const int srcBits = sizeof(src_t) * CHAR_BIT;
  35 static const int srcSigFracBits = 52;
  36 // -1 accounts for the sign bit.
  37 // srcBits - srcSigFracBits - 1
  38 static const int srcExpBits = 11;
  39
  40 static inline int src_rep_t_clz_impl(src_rep_t a) {
  41 #if defined __LP64__
  42   return __builtin_clzl(a);
  43 #else
  44   if (a & REP_C(0xffffffff00000000))
  45     return clzsi(a >> 32);
  46   else
  47     return 32 + clzsi(a & REP_C(0xffffffff));
  48 #endif
  49 }
  50 #define src_rep_t_clz src_rep_t_clz_impl
  51
  52 #elif defined SRC_80
  53 typedef xf_float src_t;
  54 typedef __uint128_t src_rep_t;
  55 #define SRC_REP_C (__uint128_t)
  56 // sign bit, exponent and significand occupy the lower 80 bits.
  57 static const int srcBits = 80;
  58 static const int srcSigFracBits = 63;
  59 // -1 accounts for the sign bit.
  60 // -1 accounts for the explicitly stored integer bit.
  61 // srcBits - srcSigFracBits - 1 - 1
  62 static const int srcExpBits = 15;
  63
  64 #elif defined SRC_HALF
  65 #ifdef COMPILER_RT_HAS_FLOAT16
  66 typedef _Float16 src_t;
  67 #else
  68 typedef uint16_t src_t;
  69 #endif
  70 typedef uint16_t src_rep_t;
  71 #define SRC_REP_C UINT16_C
  72 static const int srcBits = sizeof(src_t) * CHAR_BIT;
  73 static const int srcSigFracBits = 10;
  74 // -1 accounts for the sign bit.
  75 // srcBits - srcSigFracBits - 1
  76 static const int srcExpBits = 5;
  77
  78 static inline int src_rep_t_clz_impl(src_rep_t a) {
  79   return __builtin_clz(a) - 16;
  80 }
  81
  82 #define src_rep_t_clz src_rep_t_clz_impl
  83
  84 #else
  85 #error Source should be half, single, or double precision!
  86 #endif // end source precision
  87
  88 #if defined DST_SINGLE
  89 typedef float dst_t;
  90 typedef uint32_t dst_rep_t;
  91 #define DST_REP_C UINT32_C
  92 static const int dstBits = sizeof(dst_t) * CHAR_BIT;
  93 static const int dstSigFracBits = 23;
  94 // -1 accounts for the sign bit.
  95 // dstBits - dstSigFracBits - 1
  96 static const int dstExpBits = 8;
  97
  98 #elif defined DST_DOUBLE
  99 typedef double dst_t;
 100 typedef uint64_t dst_rep_t;
 101 #define DST_REP_C UINT64_C
 102 static const int dstBits = sizeof(dst_t) * CHAR_BIT;
 103 static const int dstSigFracBits = 52;
 104 // -1 accounts for the sign bit.
 105 // dstBits - dstSigFracBits - 1
 106 static const int dstExpBits = 11;
 107
 108 #elif defined DST_QUAD
 109 typedef tf_float dst_t;
 110 typedef __uint128_t dst_rep_t;
 111 #define DST_REP_C (__uint128_t)
 112 static const int dstBits = sizeof(dst_t) * CHAR_BIT;
 113 static const int dstSigFracBits = 112;
 114 // -1 accounts for the sign bit.
 115 // dstBits - dstSigFracBits - 1
 116 static const int dstExpBits = 15;
 117
 118 #else
 119 #error Destination should be single, double, or quad precision!
 120 #endif // end destination precision
 121
 122 // End of specialization parameters.
 123
 124 // TODO: These helper routines should be placed into fp_lib.h
 125 // Currently they depend on macros/constants defined above.
 126
 127 static inline src_rep_t extract_sign_from_src(src_rep_t x) {
 128   const src_rep_t srcSignMask = SRC_REP_C(1) << (srcBits - 1);
 129   return (x & srcSignMask) >> (srcBits - 1);
 130 }
 131
 132 static inline src_rep_t extract_exp_from_src(src_rep_t x) {
 133   const int srcSigBits = srcBits - 1 - srcExpBits;
 134   const src_rep_t srcExpMask = ((SRC_REP_C(1) << srcExpBits) - 1) << srcSigBits;
 135   return (x & srcExpMask) >> srcSigBits;
 136 }
 137
 138 static inline src_rep_t extract_sig_frac_from_src(src_rep_t x) {
 139   const src_rep_t srcSigFracMask = (SRC_REP_C(1) << srcSigFracBits) - 1;
 140   return x & srcSigFracMask;
 141 }
 142
 143 #ifdef src_rep_t_clz
 144 static inline int clz_in_sig_frac(src_rep_t sigFrac) {
 145       const int skip = 1 + srcExpBits;
 146       return src_rep_t_clz(sigFrac) - skip;
 147 }
 148 #endif
 149
 150 static inline dst_rep_t construct_dst_rep(dst_rep_t sign, dst_rep_t exp, dst_rep_t sigFrac) {
 151   return (sign << (dstBits - 1)) | (exp << (dstBits - 1 - dstExpBits)) | sigFrac;
 152 }
 153
 154 // Two helper routines for conversion to and from the representation of
 155 // floating-point data as integer values follow.
 156
 157 static inline src_rep_t srcToRep(src_t x) {
 158   const union {
 159     src_t f;
 160     src_rep_t i;
 161   } rep = {.f = x};
 162   return rep.i;
 163 }
 164
 165 static inline dst_t dstFromRep(dst_rep_t x) {
 166   const union {
 167     dst_t f;
 168     dst_rep_t i;
 169   } rep = {.i = x};
 170   return rep.f;
 171 }
 172 // End helper routines.  Conversion implementation follows.
 173
 174 #endif // FP_EXTEND_HEADER