contrib/llvm/tools/clang/include/clang/AST/CharUnits.h

   1 //===--- CharUnits.h - Character units for sizes and offsets ----*- 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 defines the CharUnits class
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_CHARUNITS_H
  15 #define LLVM_CLANG_AST_CHARUNITS_H
  16
  17 #include "llvm/ADT/DenseMapInfo.h"
  18 #include "llvm/Support/DataTypes.h"
  19 #include "llvm/Support/MathExtras.h"
  20
  21 namespace clang {
  22
  23   /// CharUnits - This is an opaque type for sizes expressed in character units.
  24   /// Instances of this type represent a quantity as a multiple of the size
  25   /// of the standard C type, char, on the target architecture. As an opaque
  26   /// type, CharUnits protects you from accidentally combining operations on
  27   /// quantities in bit units and character units.
  28   ///
  29   /// In both C and C++, an object of type 'char', 'signed char', or 'unsigned
  30   /// char' occupies exactly one byte, so 'character unit' and 'byte' refer to
  31   /// the same quantity of storage. However, we use the term 'character unit'
  32   /// rather than 'byte' to avoid an implication that a character unit is
  33   /// exactly 8 bits.
  34   ///
  35   /// For portability, never assume that a target character is 8 bits wide. Use
  36   /// CharUnit values wherever you calculate sizes, offsets, or alignments
  37   /// in character units.
  38   class CharUnits {
  39     public:
  40       typedef int64_t QuantityType;
  41
  42     private:
  43       QuantityType Quantity = 0;
  44
  45       explicit CharUnits(QuantityType C) : Quantity(C) {}
  46
  47     public:
  48
  49       /// CharUnits - A default constructor.
  50       CharUnits() = default;
  51
  52       /// Zero - Construct a CharUnits quantity of zero.
  53       static CharUnits Zero() {
  54         return CharUnits(0);
  55       }
  56
  57       /// One - Construct a CharUnits quantity of one.
  58       static CharUnits One() {
  59         return CharUnits(1);
  60       }
  61
  62       /// fromQuantity - Construct a CharUnits quantity from a raw integer type.
  63       static CharUnits fromQuantity(QuantityType Quantity) {
  64         return CharUnits(Quantity);
  65       }
  66
  67       // Compound assignment.
  68       CharUnits& operator+= (const CharUnits &Other) {
  69         Quantity += Other.Quantity;
  70         return *this;
  71       }
  72       CharUnits& operator++ () {
  73         ++Quantity;
  74         return *this;
  75       }
  76       CharUnits operator++ (int) {
  77         return CharUnits(Quantity++);
  78       }
  79       CharUnits& operator-= (const CharUnits &Other) {
  80         Quantity -= Other.Quantity;
  81         return *this;
  82       }
  83       CharUnits& operator-- () {
  84         --Quantity;
  85         return *this;
  86       }
  87       CharUnits operator-- (int) {
  88         return CharUnits(Quantity--);
  89       }
  90
  91       // Comparison operators.
  92       bool operator== (const CharUnits &Other) const {
  93         return Quantity == Other.Quantity;
  94       }
  95       bool operator!= (const CharUnits &Other) const {
  96         return Quantity != Other.Quantity;
  97       }
  98
  99       // Relational operators.
 100       bool operator<  (const CharUnits &Other) const {
 101         return Quantity <  Other.Quantity;
 102       }
 103       bool operator<= (const CharUnits &Other) const {
 104         return Quantity <= Other.Quantity;
 105       }
 106       bool operator>  (const CharUnits &Other) const {
 107         return Quantity >  Other.Quantity;
 108       }
 109       bool operator>= (const CharUnits &Other) const {
 110         return Quantity >= Other.Quantity;
 111       }
 112
 113       // Other predicates.
 114
 115       /// isZero - Test whether the quantity equals zero.
 116       bool isZero() const     { return Quantity == 0; }
 117
 118       /// isOne - Test whether the quantity equals one.
 119       bool isOne() const      { return Quantity == 1; }
 120
 121       /// isPositive - Test whether the quantity is greater than zero.
 122       bool isPositive() const { return Quantity  > 0; }
 123
 124       /// isNegative - Test whether the quantity is less than zero.
 125       bool isNegative() const { return Quantity  < 0; }
 126
 127       /// isPowerOfTwo - Test whether the quantity is a power of two.
 128       /// Zero is not a power of two.
 129       bool isPowerOfTwo() const {
 130         return (Quantity & -Quantity) == Quantity;
 131       }
 132
 133       /// Test whether this is a multiple of the other value.
 134       ///
 135       /// Among other things, this promises that
 136       /// self.alignTo(N) will just return self.
 137       bool isMultipleOf(CharUnits N) const {
 138         return (*this % N) == 0;
 139       }
 140
 141       // Arithmetic operators.
 142       CharUnits operator* (QuantityType N) const {
 143         return CharUnits(Quantity * N);
 144       }
 145       CharUnits &operator*= (QuantityType N) {
 146         Quantity *= N;
 147         return *this;
 148       }
 149       CharUnits operator/ (QuantityType N) const {
 150         return CharUnits(Quantity / N);
 151       }
 152       CharUnits &operator/= (QuantityType N) {
 153         Quantity /= N;
 154         return *this;
 155       }
 156       QuantityType operator/ (const CharUnits &Other) const {
 157         return Quantity / Other.Quantity;
 158       }
 159       CharUnits operator% (QuantityType N) const {
 160         return CharUnits(Quantity % N);
 161       }
 162       QuantityType operator% (const CharUnits &Other) const {
 163         return Quantity % Other.Quantity;
 164       }
 165       CharUnits operator+ (const CharUnits &Other) const {
 166         return CharUnits(Quantity + Other.Quantity);
 167       }
 168       CharUnits operator- (const CharUnits &Other) const {
 169         return CharUnits(Quantity - Other.Quantity);
 170       }
 171       CharUnits operator- () const {
 172         return CharUnits(-Quantity);
 173       }
 174
 175
 176       // Conversions.
 177
 178       /// getQuantity - Get the raw integer representation of this quantity.
 179       QuantityType getQuantity() const { return Quantity; }
 180
 181       /// alignTo - Returns the next integer (mod 2**64) that is
 182       /// greater than or equal to this quantity and is a multiple of \p Align.
 183       /// Align must be non-zero.
 184       CharUnits alignTo(const CharUnits &Align) const {
 185         return CharUnits(llvm::alignTo(Quantity, Align.Quantity));
 186       }
 187
 188       /// Given that this is a non-zero alignment value, what is the
 189       /// alignment at the given offset?
 190       CharUnits alignmentAtOffset(CharUnits offset) const {
 191         assert(Quantity != 0 && "offsetting from unknown alignment?");
 192         return CharUnits(llvm::MinAlign(Quantity, offset.Quantity));
 193       }
 194
 195       /// Given that this is the alignment of the first element of an
 196       /// array, return the minimum alignment of any element in the array.
 197       CharUnits alignmentOfArrayElement(CharUnits elementSize) const {
 198         // Since we don't track offsetted alignments, the alignment of
 199         // the second element (or any odd element) will be minimally
 200         // aligned.
 201         return alignmentAtOffset(elementSize);
 202       }
 203
 204
 205   }; // class CharUnit
 206 } // namespace clang
 207
 208 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
 209                                    const clang::CharUnits &CU) {
 210   return CU * Scale;
 211 }
 212
 213 namespace llvm {
 214
 215 template<> struct DenseMapInfo<clang::CharUnits> {
 216   static clang::CharUnits getEmptyKey() {
 217     clang::CharUnits::QuantityType Quantity =
 218       DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
 219
 220     return clang::CharUnits::fromQuantity(Quantity);
 221   }
 222
 223   static clang::CharUnits getTombstoneKey() {
 224     clang::CharUnits::QuantityType Quantity =
 225       DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();
 226
 227     return clang::CharUnits::fromQuantity(Quantity);
 228   }
 229
 230   static unsigned getHashValue(const clang::CharUnits &CU) {
 231     clang::CharUnits::QuantityType Quantity = CU.getQuantity();
 232     return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
 233   }
 234
 235   static bool isEqual(const clang::CharUnits &LHS,
 236                       const clang::CharUnits &RHS) {
 237     return LHS == RHS;
 238   }
 239 };
 240
 241 template <> struct isPodLike<clang::CharUnits> {
 242   static const bool value = true;
 243 };
 244
 245 } // end namespace llvm
 246
 247 #endif // LLVM_CLANG_AST_CHARUNITS_H