include/llvm/Support/ScaledNumber.h

   1 //===- llvm/Support/ScaledNumber.h - Support for scaled numbers -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains functions (and a class) useful for working with scaled
  11 // numbers -- in particular, pairs of integers where one represents digits and
  12 // another represents a scale.  The functions are helpers and live in the
  13 // namespace ScaledNumbers.  The class ScaledNumber is useful for modelling
  14 // certain cost metrics that need simple, integer-like semantics that are easy
  15 // to reason about.
  16 //
  17 // These might remind you of soft-floats.  If you want one of those, you're in
  18 // the wrong place.  Look at include/llvm/ADT/APFloat.h instead.
  19 //
  20 //===----------------------------------------------------------------------===//
  21
  22 #ifndef LLVM_SUPPORT_SCALEDNUMBER_H
  23 #define LLVM_SUPPORT_SCALEDNUMBER_H
  24
  25 #include "llvm/Support/MathExtras.h"
  26
  27 #include <cstdint>
  28 #include <limits>
  29 #include <utility>
  30
  31 namespace llvm {
  32 namespace ScaledNumbers {
  33
  34 /// \brief Get the width of a number.
  35 template <class DigitsT> inline int getWidth() { return sizeof(DigitsT) * 8; }
  36
  37 /// \brief Conditionally round up a scaled number.
  38 ///
  39 /// Given \c Digits and \c Scale, round up iff \c ShouldRound is \c true.
  40 /// Always returns \c Scale unless there's an overflow, in which case it
  41 /// returns \c 1+Scale.
  42 ///
  43 /// \pre adding 1 to \c Scale will not overflow INT16_MAX.
  44 template <class DigitsT>
  45 inline std::pair<DigitsT, int16_t> getRounded(DigitsT Digits, int16_t Scale,
  46                                               bool ShouldRound) {
  47   static_assert(!std::numeric_limits<DigitsT>::is_signed, "expected unsigned");
  48
  49   if (ShouldRound)
  50     if (!++Digits)
  51       // Overflow.
  52       return std::make_pair(DigitsT(1) << (getWidth<DigitsT>() - 1), Scale + 1);
  53   return std::make_pair(Digits, Scale);
  54 }
  55
  56 /// \brief Adjust a 64-bit scaled number down to the appropriate width.
  57 ///
  58 /// Adjust a soft float with 64-bits of digits down, keeping as much
  59 /// information as possible, and rounding up on half.
  60 ///
  61 /// \pre Adding 1 to \c Scale will not overflow INT16_MAX.
  62 template <class DigitsT>
  63 inline std::pair<DigitsT, int16_t> getAdjusted(uint64_t Digits,
  64                                                int16_t Scale = 0) {
  65   static_assert(!std::numeric_limits<DigitsT>::is_signed, "expected unsigned");
  66
  67   const int Width = getWidth<DigitsT>();
  68   if (Width == 64 || Digits <= std::numeric_limits<DigitsT>::max())
  69     return std::make_pair(Digits, Scale);
  70
  71   // Shift right and round.
  72   int Shift = 64 - Width - countLeadingZeros(Digits);
  73   return getRounded<DigitsT>(Digits >> Shift, Scale + Shift,
  74                              Digits & (UINT64_C(1) << (Shift - 1)));
  75 }
  76
  77 /// \brief Convenience helper for adjusting to 32 bits.
  78 inline std::pair<uint32_t, int16_t> getAdjusted32(uint64_t Digits,
  79                                                   int16_t Scale = 0) {
  80   return getAdjusted<uint32_t>(Digits, Scale);
  81 }
  82
  83 /// \brief Convenience helper for adjusting to 64 bits.
  84 inline std::pair<uint64_t, int16_t> getAdjusted64(uint64_t Digits,
  85                                                   int16_t Scale = 0) {
  86   return getAdjusted<uint64_t>(Digits, Scale);
  87 }
  88 }
  89 }
  90
  91 #endif
  92