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   /// It should be noted that characters and bytes are distinct concepts. Bytes
  30   /// refer to addressable units of data storage on the target machine, and
  31   /// characters are members of a set of elements used for the organization,
  32   /// control, or representation of data. According to C99, bytes are allowed
  33   /// to exceed characters in size, although currently, clang only supports
  34   /// architectures where the two are the same size.
  35   ///
  36   /// For portability, never assume that a target character is 8 bits wide. Use
  37   /// CharUnit values wherever you calculate sizes, offsets, or alignments
  38   /// in character units.
  39   class CharUnits {
  40     public:
  41       typedef int64_t QuantityType;
  42
  43     private:
  44       QuantityType Quantity;
  45
  46       explicit CharUnits(QuantityType C) : Quantity(C) {}
  47
  48     public:
  49
  50       /// CharUnits - A default constructor.
  51       CharUnits() : Quantity(0) {}
  52
  53       /// Zero - Construct a CharUnits quantity of zero.
  54       static CharUnits Zero() {
  55         return CharUnits(0);
  56       }
  57
  58       /// One - Construct a CharUnits quantity of one.
  59       static CharUnits One() {
  60         return CharUnits(1);
  61       }
  62
  63       /// fromQuantity - Construct a CharUnits quantity from a raw integer type.
  64       static CharUnits fromQuantity(QuantityType Quantity) {
  65         return CharUnits(Quantity);
  66       }
  67
  68       // Compound assignment.
  69       CharUnits& operator+= (const CharUnits &Other) {
  70         Quantity += Other.Quantity;
  71         return *this;
  72       }
  73       CharUnits& operator++ () {
  74         ++Quantity;
  75         return *this;
  76       }
  77       CharUnits operator++ (int) {
  78         return CharUnits(Quantity++);
  79       }
  80       CharUnits& operator-= (const CharUnits &Other) {
  81         Quantity -= Other.Quantity;
  82         return *this;
  83       }
  84       CharUnits& operator-- () {
  85         --Quantity;
  86         return *this;
  87       }
  88       CharUnits operator-- (int) {
  89         return CharUnits(Quantity--);
  90       }
  91
  92       // Comparison operators.
  93       bool operator== (const CharUnits &Other) const {
  94         return Quantity == Other.Quantity;
  95       }
  96       bool operator!= (const CharUnits &Other) const {
  97         return Quantity != Other.Quantity;
  98       }
  99
 100       // Relational operators.
 101       bool operator<  (const CharUnits &Other) const {
 102         return Quantity <  Other.Quantity;
 103       }
 104       bool operator<= (const CharUnits &Other) const {
 105         return Quantity <= Other.Quantity;
 106       }
 107       bool operator>  (const CharUnits &Other) const {
 108         return Quantity >  Other.Quantity;
 109       }
 110       bool operator>= (const CharUnits &Other) const {
 111         return Quantity >= Other.Quantity;
 112       }
 113
 114       // Other predicates.
 115
 116       /// isZero - Test whether the quantity equals zero.
 117       bool isZero() const     { return Quantity == 0; }
 118
 119       /// isOne - Test whether the quantity equals one.
 120       bool isOne() const      { return Quantity == 1; }
 121
 122       /// isPositive - Test whether the quantity is greater than zero.
 123       bool isPositive() const { return Quantity  > 0; }
 124
 125       /// isNegative - Test whether the quantity is less than zero.
 126       bool isNegative() const { return Quantity  < 0; }
 127
 128       /// isPowerOfTwo - Test whether the quantity is a power of two.
 129       /// Zero is not a power of two.
 130       bool isPowerOfTwo() const {
 131         return (Quantity & -Quantity) == Quantity;
 132       }
 133
 134       // Arithmetic operators.
 135       CharUnits operator* (QuantityType N) const {
 136         return CharUnits(Quantity * N);
 137       }
 138       CharUnits operator/ (QuantityType N) const {
 139         return CharUnits(Quantity / N);
 140       }
 141       QuantityType operator/ (const CharUnits &Other) const {
 142         return Quantity / Other.Quantity;
 143       }
 144       CharUnits operator% (QuantityType N) const {
 145         return CharUnits(Quantity % N);
 146       }
 147       QuantityType operator% (const CharUnits &Other) const {
 148         return Quantity % Other.Quantity;
 149       }
 150       CharUnits operator+ (const CharUnits &Other) const {
 151         return CharUnits(Quantity + Other.Quantity);
 152       }
 153       CharUnits operator- (const CharUnits &Other) const {
 154         return CharUnits(Quantity - Other.Quantity);
 155       }
 156       CharUnits operator- () const {
 157         return CharUnits(-Quantity);
 158       }
 159
 160
 161       // Conversions.
 162
 163       /// getQuantity - Get the raw integer representation of this quantity.
 164       QuantityType getQuantity() const { return Quantity; }
 165
 166       /// RoundUpToAlignment - Returns the next integer (mod 2**64) that is
 167       /// greater than or equal to this quantity and is a multiple of \p Align.
 168       /// Align must be non-zero.
 169       CharUnits RoundUpToAlignment(const CharUnits &Align) {
 170         return CharUnits(llvm::RoundUpToAlignment(Quantity,
 171                                                   Align.Quantity));
 172       }
 173
 174       /// Given that this is a non-zero alignment value, what is the
 175       /// alignment at the given offset?
 176       CharUnits alignmentAtOffset(CharUnits offset) {
 177         // alignment: 0010000
 178         // offset:    1011100
 179         // lowBits:   0001011
 180         // result:    0000100
 181         QuantityType lowBits = (Quantity-1) & (offset.Quantity-1);
 182         return CharUnits((lowBits + 1) & ~lowBits);
 183       }
 184
 185
 186   }; // class CharUnit
 187 } // namespace clang
 188
 189 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
 190                                    const clang::CharUnits &CU) {
 191   return CU * Scale;
 192 }
 193
 194 namespace llvm {
 195
 196 template<> struct DenseMapInfo<clang::CharUnits> {
 197   static clang::CharUnits getEmptyKey() {
 198     clang::CharUnits::QuantityType Quantity =
 199       DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
 200
 201     return clang::CharUnits::fromQuantity(Quantity);
 202   }
 203
 204   static clang::CharUnits getTombstoneKey() {
 205     clang::CharUnits::QuantityType Quantity =
 206       DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();
 207
 208     return clang::CharUnits::fromQuantity(Quantity);
 209   }
 210
 211   static unsigned getHashValue(const clang::CharUnits &CU) {
 212     clang::CharUnits::QuantityType Quantity = CU.getQuantity();
 213     return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
 214   }
 215
 216   static bool isEqual(const clang::CharUnits &LHS,
 217                       const clang::CharUnits &RHS) {
 218     return LHS == RHS;
 219   }
 220 };
 221
 222 template <> struct isPodLike<clang::CharUnits> {
 223   static const bool value = true;
 224 };
 225
 226 } // end namespace llvm
 227
 228 #endif // LLVM_CLANG_AST_CHARUNITS_H