1 //===--- CharUnits.h - Character units for sizes and offsets ----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file defines the CharUnits class
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_AST_CHARUNITS_H
14 #define LLVM_CLANG_AST_CHARUNITS_H
15 
16 #include "llvm/ADT/DenseMapInfo.h"
17 #include "llvm/Support/Alignment.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       /// getAsAlign - Returns Quantity as a valid llvm::Align,
182       /// Beware llvm::Align assumes power of two 8-bit bytes.
183       llvm::Align getAsAlign() const { return llvm::Align(Quantity); }
184 
185       /// getAsMaybeAlign - Returns Quantity as a valid llvm::Align or
186       /// llvm::None, Beware llvm::MaybeAlign assumes power of two 8-bit bytes.
187       llvm::MaybeAlign getAsMaybeAlign() const {
188         return llvm::MaybeAlign(Quantity);
189       }
190 
191       /// alignTo - Returns the next integer (mod 2**64) that is
192       /// greater than or equal to this quantity and is a multiple of \p Align.
193       /// Align must be non-zero.
194       CharUnits alignTo(const CharUnits &Align) const {
195         return CharUnits(llvm::alignTo(Quantity, Align.Quantity));
196       }
197 
198       /// Given that this is a non-zero alignment value, what is the
199       /// alignment at the given offset?
200       CharUnits alignmentAtOffset(CharUnits offset) const {
201         assert(Quantity != 0 && "offsetting from unknown alignment?");
202         return CharUnits(llvm::MinAlign(Quantity, offset.Quantity));
203       }
204 
205       /// Given that this is the alignment of the first element of an
206       /// array, return the minimum alignment of any element in the array.
207       CharUnits alignmentOfArrayElement(CharUnits elementSize) const {
208         // Since we don't track offsetted alignments, the alignment of
209         // the second element (or any odd element) will be minimally
210         // aligned.
211         return alignmentAtOffset(elementSize);
212       }
213 
214 
215   }; // class CharUnit
216 } // namespace clang
217 
218 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
219                                    const clang::CharUnits &CU) {
220   return CU * Scale;
221 }
222 
223 namespace llvm {
224 
225 template<> struct DenseMapInfo<clang::CharUnits> {
226   static clang::CharUnits getEmptyKey() {
227     clang::CharUnits::QuantityType Quantity =
228       DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
229 
230     return clang::CharUnits::fromQuantity(Quantity);
231   }
232 
233   static clang::CharUnits getTombstoneKey() {
234     clang::CharUnits::QuantityType Quantity =
235       DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();
236 
237     return clang::CharUnits::fromQuantity(Quantity);
238   }
239 
240   static unsigned getHashValue(const clang::CharUnits &CU) {
241     clang::CharUnits::QuantityType Quantity = CU.getQuantity();
242     return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
243   }
244 
245   static bool isEqual(const clang::CharUnits &LHS,
246                       const clang::CharUnits &RHS) {
247     return LHS == RHS;
248   }
249 };
250 
251 } // end namespace llvm
252 
253 #endif // LLVM_CLANG_AST_CHARUNITS_H
254