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 CharUnits(QuantityType C)45 explicit CharUnits(QuantityType C) : Quantity(C) {} 46 47 public: 48 49 /// CharUnits - A default constructor. CharUnits()50 CharUnits() : Quantity(0) {} 51 52 /// Zero - Construct a CharUnits quantity of zero. Zero()53 static CharUnits Zero() { 54 return CharUnits(0); 55 } 56 57 /// One - Construct a CharUnits quantity of one. One()58 static CharUnits One() { 59 return CharUnits(1); 60 } 61 62 /// fromQuantity - Construct a CharUnits quantity from a raw integer type. fromQuantity(QuantityType Quantity)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. isZero()116 bool isZero() const { return Quantity == 0; } 117 118 /// isOne - Test whether the quantity equals one. isOne()119 bool isOne() const { return Quantity == 1; } 120 121 /// isPositive - Test whether the quantity is greater than zero. isPositive()122 bool isPositive() const { return Quantity > 0; } 123 124 /// isNegative - Test whether the quantity is less than zero. isNegative()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. isPowerOfTwo()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.RoundUpToAlignment(N) will just return self. isMultipleOf(CharUnits N)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) const { 146 return CharUnits(Quantity / N); 147 } 148 QuantityType operator/ (const CharUnits &Other) const { 149 return Quantity / Other.Quantity; 150 } 151 CharUnits operator% (QuantityType N) const { 152 return CharUnits(Quantity % N); 153 } 154 QuantityType operator% (const CharUnits &Other) const { 155 return Quantity % Other.Quantity; 156 } 157 CharUnits operator+ (const CharUnits &Other) const { 158 return CharUnits(Quantity + Other.Quantity); 159 } 160 CharUnits operator- (const CharUnits &Other) const { 161 return CharUnits(Quantity - Other.Quantity); 162 } 163 CharUnits operator- () const { 164 return CharUnits(-Quantity); 165 } 166 167 168 // Conversions. 169 170 /// getQuantity - Get the raw integer representation of this quantity. getQuantity()171 QuantityType getQuantity() const { return Quantity; } 172 173 /// RoundUpToAlignment - Returns the next integer (mod 2**64) that is 174 /// greater than or equal to this quantity and is a multiple of \p Align. 175 /// Align must be non-zero. RoundUpToAlignment(const CharUnits & Align)176 CharUnits RoundUpToAlignment(const CharUnits &Align) const { 177 return CharUnits(llvm::RoundUpToAlignment(Quantity, 178 Align.Quantity)); 179 } 180 181 /// Given that this is a non-zero alignment value, what is the 182 /// alignment at the given offset? alignmentAtOffset(CharUnits offset)183 CharUnits alignmentAtOffset(CharUnits offset) const { 184 assert(Quantity != 0 && "offsetting from unknown alignment?"); 185 return CharUnits(llvm::MinAlign(Quantity, offset.Quantity)); 186 } 187 188 /// Given that this is the alignment of the first element of an 189 /// array, return the minimum alignment of any element in the array. alignmentOfArrayElement(CharUnits elementSize)190 CharUnits alignmentOfArrayElement(CharUnits elementSize) const { 191 // Since we don't track offsetted alignments, the alignment of 192 // the second element (or any odd element) will be minimally 193 // aligned. 194 return alignmentAtOffset(elementSize); 195 } 196 197 198 }; // class CharUnit 199 } // namespace clang 200 201 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale, 202 const clang::CharUnits &CU) { 203 return CU * Scale; 204 } 205 206 namespace llvm { 207 208 template<> struct DenseMapInfo<clang::CharUnits> { 209 static clang::CharUnits getEmptyKey() { 210 clang::CharUnits::QuantityType Quantity = 211 DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey(); 212 213 return clang::CharUnits::fromQuantity(Quantity); 214 } 215 216 static clang::CharUnits getTombstoneKey() { 217 clang::CharUnits::QuantityType Quantity = 218 DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey(); 219 220 return clang::CharUnits::fromQuantity(Quantity); 221 } 222 223 static unsigned getHashValue(const clang::CharUnits &CU) { 224 clang::CharUnits::QuantityType Quantity = CU.getQuantity(); 225 return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity); 226 } 227 228 static bool isEqual(const clang::CharUnits &LHS, 229 const clang::CharUnits &RHS) { 230 return LHS == RHS; 231 } 232 }; 233 234 template <> struct isPodLike<clang::CharUnits> { 235 static const bool value = true; 236 }; 237 238 } // end namespace llvm 239 240 #endif // LLVM_CLANG_AST_CHARUNITS_H 241