Warning: That file was not part of the compilation database. It may have many parsing errors.

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
21namespace 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
208inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
209 const clang::CharUnits &CU) {
210 return CU * Scale;
211}
212
213namespace llvm {
214
215template<> 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
241template <> struct isPodLike<clang::CharUnits> {
242 static const bool value = true;
243};
244
245} // end namespace llvm
246
247#endif // LLVM_CLANG_AST_CHARUNITS_H
248

Warning: That file was not part of the compilation database. It may have many parsing errors.