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; 44 45 explicit CharUnits(QuantityType C) : Quantity(C) {} 46 47 public: 48 49 /// CharUnits - A default constructor. 50 CharUnits() : Quantity(0) {} 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 // Arithmetic operators. 134 CharUnits operator* (QuantityType N) const { 135 return CharUnits(Quantity * N); 136 } 137 CharUnits operator/ (QuantityType N) const { 138 return CharUnits(Quantity / N); 139 } 140 QuantityType operator/ (const CharUnits &Other) const { 141 return Quantity / Other.Quantity; 142 } 143 CharUnits operator% (QuantityType N) const { 144 return CharUnits(Quantity % N); 145 } 146 QuantityType operator% (const CharUnits &Other) const { 147 return Quantity % Other.Quantity; 148 } 149 CharUnits operator+ (const CharUnits &Other) const { 150 return CharUnits(Quantity + Other.Quantity); 151 } 152 CharUnits operator- (const CharUnits &Other) const { 153 return CharUnits(Quantity - Other.Quantity); 154 } 155 CharUnits operator- () const { 156 return CharUnits(-Quantity); 157 } 158 159 160 // Conversions. 161 162 /// getQuantity - Get the raw integer representation of this quantity. 163 QuantityType getQuantity() const { return Quantity; } 164 165 /// RoundUpToAlignment - Returns the next integer (mod 2**64) that is 166 /// greater than or equal to this quantity and is a multiple of \p Align. 167 /// Align must be non-zero. 168 CharUnits RoundUpToAlignment(const CharUnits &Align) const { 169 return CharUnits(llvm::RoundUpToAlignment(Quantity, 170 Align.Quantity)); 171 } 172 173 /// Given that this is a non-zero alignment value, what is the 174 /// alignment at the given offset? 175 CharUnits alignmentAtOffset(CharUnits offset) { 176 return CharUnits(llvm::MinAlign(Quantity, offset.Quantity)); 177 } 178 179 180 }; // class CharUnit 181 } // namespace clang 182 183 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale, 184 const clang::CharUnits &CU) { 185 return CU * Scale; 186 } 187 188 namespace llvm { 189 190 template<> struct DenseMapInfo<clang::CharUnits> { 191 static clang::CharUnits getEmptyKey() { 192 clang::CharUnits::QuantityType Quantity = 193 DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey(); 194 195 return clang::CharUnits::fromQuantity(Quantity); 196 } 197 198 static clang::CharUnits getTombstoneKey() { 199 clang::CharUnits::QuantityType Quantity = 200 DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey(); 201 202 return clang::CharUnits::fromQuantity(Quantity); 203 } 204 205 static unsigned getHashValue(const clang::CharUnits &CU) { 206 clang::CharUnits::QuantityType Quantity = CU.getQuantity(); 207 return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity); 208 } 209 210 static bool isEqual(const clang::CharUnits &LHS, 211 const clang::CharUnits &RHS) { 212 return LHS == RHS; 213 } 214 }; 215 216 template <> struct isPodLike<clang::CharUnits> { 217 static const bool value = true; 218 }; 219 220 } // end namespace llvm 221 222 #endif // LLVM_CLANG_AST_CHARUNITS_H 223
