mfbt/Casting.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* Cast operations to supplement the built-in casting operations. */
   8
   9 #ifndef mozilla_Casting_h
  10 #define mozilla_Casting_h
  11
  12 #include "mozilla/Assertions.h"
  13 #include "mozilla/TypeTraits.h"
  14
  15 #include <limits.h>
  16
  17 namespace mozilla {
  18
  19 /**
  20  * Return a value of type |To|, containing the underlying bit pattern of
  21  * |aFrom|.
  22  *
  23  * |To| and |From| must be types of the same size; be careful of cross-platform
  24  * size differences, or this might fail to compile on some but not all
  25  * platforms.
  26  */
  27 template<typename To, typename From>
  28 inline To
  29 BitwiseCast(const From aFrom)
  30 {
  31   static_assert(sizeof(From) == sizeof(To),
  32                 "To and From must have the same size");
  33   union
  34   {
  35     From mFrom;
  36     To mTo;
  37   } u;
  38   u.mFrom = aFrom;
  39   return u.mTo;
  40 }
  41
  42 namespace detail {
  43
  44 enum ToSignedness { ToIsSigned, ToIsUnsigned };
  45 enum FromSignedness { FromIsSigned, FromIsUnsigned };
  46
  47 template<typename From,
  48          typename To,
  49          FromSignedness = IsSigned<From>::value ? FromIsSigned : FromIsUnsigned,
  50          ToSignedness = IsSigned<To>::value ? ToIsSigned : ToIsUnsigned>
  51 struct BoundsCheckImpl;
  52
  53 // Implicit conversions on operands to binary operations make this all a bit
  54 // hard to verify.  Attempt to ease the pain below by *only* comparing values
  55 // that are obviously the same type (and will undergo no further conversions),
  56 // even when it's not strictly necessary, for explicitness.
  57
  58 enum UUComparison { FromIsBigger, FromIsNotBigger };
  59
  60 // Unsigned-to-unsigned range check
  61
  62 template<typename From, typename To,
  63          UUComparison = (sizeof(From) > sizeof(To))
  64                         ? FromIsBigger
  65                         : FromIsNotBigger>
  66 struct UnsignedUnsignedCheck;
  67
  68 template<typename From, typename To>
  69 struct UnsignedUnsignedCheck<From, To, FromIsBigger>
  70 {
  71 public:
  72   static bool checkBounds(const From aFrom)
  73   {
  74     return aFrom <= From(To(-1));
  75   }
  76 };
  77
  78 template<typename From, typename To>
  79 struct UnsignedUnsignedCheck<From, To, FromIsNotBigger>
  80 {
  81 public:
  82   static bool checkBounds(const From aFrom)
  83   {
  84     return true;
  85   }
  86 };
  87
  88 template<typename From, typename To>
  89 struct BoundsCheckImpl<From, To, FromIsUnsigned, ToIsUnsigned>
  90 {
  91 public:
  92   static bool checkBounds(const From aFrom)
  93   {
  94     return UnsignedUnsignedCheck<From, To>::checkBounds(aFrom);
  95   }
  96 };
  97
  98 // Signed-to-unsigned range check
  99
 100 template<typename From, typename To>
 101 struct BoundsCheckImpl<From, To, FromIsSigned, ToIsUnsigned>
 102 {
 103 public:
 104   static bool checkBounds(const From aFrom)
 105   {
 106     if (aFrom < 0) {
 107       return false;
 108     }
 109     if (sizeof(To) >= sizeof(From)) {
 110       return true;
 111     }
 112     return aFrom <= From(To(-1));
 113   }
 114 };
 115
 116 // Unsigned-to-signed range check
 117
 118 enum USComparison { FromIsSmaller, FromIsNotSmaller };
 119
 120 template<typename From, typename To,
 121          USComparison = (sizeof(From) < sizeof(To))
 122                         ? FromIsSmaller
 123                         : FromIsNotSmaller>
 124 struct UnsignedSignedCheck;
 125
 126 template<typename From, typename To>
 127 struct UnsignedSignedCheck<From, To, FromIsSmaller>
 128 {
 129 public:
 130   static bool checkBounds(const From aFrom)
 131   {
 132     return true;
 133   }
 134 };
 135
 136 template<typename From, typename To>
 137 struct UnsignedSignedCheck<From, To, FromIsNotSmaller>
 138 {
 139 public:
 140   static bool checkBounds(const From aFrom)
 141   {
 142     const To MaxValue = To((1ULL << (CHAR_BIT * sizeof(To) - 1)) - 1);
 143     return aFrom <= From(MaxValue);
 144   }
 145 };
 146
 147 template<typename From, typename To>
 148 struct BoundsCheckImpl<From, To, FromIsUnsigned, ToIsSigned>
 149 {
 150 public:
 151   static bool checkBounds(const From aFrom)
 152   {
 153     return UnsignedSignedCheck<From, To>::checkBounds(aFrom);
 154   }
 155 };
 156
 157 // Signed-to-signed range check
 158
 159 template<typename From, typename To>
 160 struct BoundsCheckImpl<From, To, FromIsSigned, ToIsSigned>
 161 {
 162 public:
 163   static bool checkBounds(const From aFrom)
 164   {
 165     if (sizeof(From) <= sizeof(To)) {
 166       return true;
 167     }
 168     const To MaxValue = To((1ULL << (CHAR_BIT * sizeof(To) - 1)) - 1);
 169     const To MinValue = -MaxValue - To(1);
 170     return From(MinValue) <= aFrom &&
 171            From(aFrom) <= From(MaxValue);
 172   }
 173 };
 174
 175 template<typename From, typename To,
 176          bool TypesAreIntegral = IsIntegral<From>::value &&
 177                                  IsIntegral<To>::value>
 178 class BoundsChecker;
 179
 180 template<typename From>
 181 class BoundsChecker<From, From, true>
 182 {
 183 public:
 184   static bool checkBounds(const From aFrom) { return true; }
 185 };
 186
 187 template<typename From, typename To>
 188 class BoundsChecker<From, To, true>
 189 {
 190 public:
 191   static bool checkBounds(const From aFrom)
 192   {
 193     return BoundsCheckImpl<From, To>::checkBounds(aFrom);
 194   }
 195 };
 196
 197 template<typename From, typename To>
 198 inline bool
 199 IsInBounds(const From aFrom)
 200 {
 201   return BoundsChecker<From, To>::checkBounds(aFrom);
 202 }
 203
 204 } // namespace detail
 205
 206 /**
 207  * Cast a value of integral type |From| to a value of integral type |To|,
 208  * asserting that the cast will be a safe cast per C++ (that is, that |to| is in
 209  * the range of values permitted for the type |From|).
 210  */
 211 template<typename To, typename From>
 212 inline To
 213 AssertedCast(const From aFrom)
 214 {
 215   MOZ_ASSERT((detail::IsInBounds<From, To>(aFrom)));
 216   return static_cast<To>(aFrom);
 217 }
 218
 219 } // namespace mozilla
 220
 221 #endif /* mozilla_Casting_h */