/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CGExprConstant.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// |
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 contains code to emit Constant Expr nodes as LLVM code. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #include "CGCXXABI.h" |
14 | | #include "CGObjCRuntime.h" |
15 | | #include "CGRecordLayout.h" |
16 | | #include "CodeGenFunction.h" |
17 | | #include "CodeGenModule.h" |
18 | | #include "ConstantEmitter.h" |
19 | | #include "TargetInfo.h" |
20 | | #include "clang/AST/APValue.h" |
21 | | #include "clang/AST/ASTContext.h" |
22 | | #include "clang/AST/Attr.h" |
23 | | #include "clang/AST/RecordLayout.h" |
24 | | #include "clang/AST/StmtVisitor.h" |
25 | | #include "clang/Basic/Builtins.h" |
26 | | #include "llvm/ADT/STLExtras.h" |
27 | | #include "llvm/ADT/Sequence.h" |
28 | | #include "llvm/IR/Constants.h" |
29 | | #include "llvm/IR/DataLayout.h" |
30 | | #include "llvm/IR/Function.h" |
31 | | #include "llvm/IR/GlobalVariable.h" |
32 | | using namespace clang; |
33 | | using namespace CodeGen; |
34 | | |
35 | | //===----------------------------------------------------------------------===// |
36 | | // ConstantAggregateBuilder |
37 | | //===----------------------------------------------------------------------===// |
38 | | |
39 | | namespace { |
40 | | class ConstExprEmitter; |
41 | | |
42 | | struct ConstantAggregateBuilderUtils { |
43 | | CodeGenModule &CGM; |
44 | | |
45 | 11.5k | ConstantAggregateBuilderUtils(CodeGenModule &CGM) : CGM(CGM) {} |
46 | | |
47 | 22.7k | CharUnits getAlignment(const llvm::Constant *C) const { |
48 | 22.7k | return CharUnits::fromQuantity( |
49 | 22.7k | CGM.getDataLayout().getABITypeAlignment(C->getType())); |
50 | 22.7k | } |
51 | | |
52 | 17.3k | CharUnits getSize(llvm::Type *Ty) const { |
53 | 17.3k | return CharUnits::fromQuantity(CGM.getDataLayout().getTypeAllocSize(Ty)); |
54 | 17.3k | } |
55 | | |
56 | 11.6k | CharUnits getSize(const llvm::Constant *C) const { |
57 | 11.6k | return getSize(C->getType()); |
58 | 11.6k | } |
59 | | |
60 | 456 | llvm::Constant *getPadding(CharUnits PadSize) const { |
61 | 456 | llvm::Type *Ty = CGM.CharTy; |
62 | 456 | if (PadSize > CharUnits::One()) |
63 | 417 | Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity()); |
64 | 456 | return llvm::UndefValue::get(Ty); |
65 | 456 | } |
66 | | |
67 | 8 | llvm::Constant *getZeroes(CharUnits ZeroSize) const { |
68 | 8 | llvm::Type *Ty = llvm::ArrayType::get(CGM.CharTy, ZeroSize.getQuantity()); |
69 | 8 | return llvm::ConstantAggregateZero::get(Ty); |
70 | 8 | } |
71 | | }; |
72 | | |
73 | | /// Incremental builder for an llvm::Constant* holding a struct or array |
74 | | /// constant. |
75 | | class ConstantAggregateBuilder : private ConstantAggregateBuilderUtils { |
76 | | /// The elements of the constant. These two arrays must have the same size; |
77 | | /// Offsets[i] describes the offset of Elems[i] within the constant. The |
78 | | /// elements are kept in increasing offset order, and we ensure that there |
79 | | /// is no overlap: Offsets[i+1] >= Offsets[i] + getSize(Elemes[i]). |
80 | | /// |
81 | | /// This may contain explicit padding elements (in order to create a |
82 | | /// natural layout), but need not. Gaps between elements are implicitly |
83 | | /// considered to be filled with undef. |
84 | | llvm::SmallVector<llvm::Constant*, 32> Elems; |
85 | | llvm::SmallVector<CharUnits, 32> Offsets; |
86 | | |
87 | | /// The size of the constant (the maximum end offset of any added element). |
88 | | /// May be larger than the end of Elems.back() if we split the last element |
89 | | /// and removed some trailing undefs. |
90 | | CharUnits Size = CharUnits::Zero(); |
91 | | |
92 | | /// This is true only if laying out Elems in order as the elements of a |
93 | | /// non-packed LLVM struct will give the correct layout. |
94 | | bool NaturalLayout = true; |
95 | | |
96 | | bool split(size_t Index, CharUnits Hint); |
97 | | Optional<size_t> splitAt(CharUnits Pos); |
98 | | |
99 | | static llvm::Constant *buildFrom(CodeGenModule &CGM, |
100 | | ArrayRef<llvm::Constant *> Elems, |
101 | | ArrayRef<CharUnits> Offsets, |
102 | | CharUnits StartOffset, CharUnits Size, |
103 | | bool NaturalLayout, llvm::Type *DesiredTy, |
104 | | bool AllowOversized); |
105 | | |
106 | | public: |
107 | | ConstantAggregateBuilder(CodeGenModule &CGM) |
108 | 5.78k | : ConstantAggregateBuilderUtils(CGM) {} |
109 | | |
110 | | /// Update or overwrite the value starting at \p Offset with \c C. |
111 | | /// |
112 | | /// \param AllowOverwrite If \c true, this constant might overwrite (part of) |
113 | | /// a constant that has already been added. This flag is only used to |
114 | | /// detect bugs. |
115 | | bool add(llvm::Constant *C, CharUnits Offset, bool AllowOverwrite); |
116 | | |
117 | | /// Update or overwrite the bits starting at \p OffsetInBits with \p Bits. |
118 | | bool addBits(llvm::APInt Bits, uint64_t OffsetInBits, bool AllowOverwrite); |
119 | | |
120 | | /// Attempt to condense the value starting at \p Offset to a constant of type |
121 | | /// \p DesiredTy. |
122 | | void condense(CharUnits Offset, llvm::Type *DesiredTy); |
123 | | |
124 | | /// Produce a constant representing the entire accumulated value, ideally of |
125 | | /// the specified type. If \p AllowOversized, the constant might be larger |
126 | | /// than implied by \p DesiredTy (eg, if there is a flexible array member). |
127 | | /// Otherwise, the constant will be of exactly the same size as \p DesiredTy |
128 | | /// even if we can't represent it as that type. |
129 | 5.74k | llvm::Constant *build(llvm::Type *DesiredTy, bool AllowOversized) const { |
130 | 5.74k | return buildFrom(CGM, Elems, Offsets, CharUnits::Zero(), Size, |
131 | 5.74k | NaturalLayout, DesiredTy, AllowOversized); |
132 | 5.74k | } |
133 | | }; |
134 | | |
135 | | template<typename Container, typename Range = std::initializer_list< |
136 | | typename Container::value_type>> |
137 | 318 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { |
138 | 318 | assert(BeginOff <= EndOff && "invalid replacement range"); |
139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); |
140 | 318 | } CGExprConstant.cpp:void (anonymous namespace)::replace<llvm::SmallVector<llvm::Constant*, 32u>, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_0, llvm::Constant*> > >(llvm::SmallVector<llvm::Constant*, 32u>&, unsigned long, unsigned long, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_0, llvm::Constant*> >) Line | Count | Source | 137 | 34 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { | 138 | 34 | assert(BeginOff <= EndOff && "invalid replacement range"); | 139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); | 140 | 34 | } |
CGExprConstant.cpp:void (anonymous namespace)::replace<llvm::SmallVector<clang::CharUnits, 32u>, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_1, clang::CharUnits> > >(llvm::SmallVector<clang::CharUnits, 32u>&, unsigned long, unsigned long, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_1, clang::CharUnits> >) Line | Count | Source | 137 | 2 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { | 138 | 2 | assert(BeginOff <= EndOff && "invalid replacement range"); | 139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); | 140 | 2 | } |
CGExprConstant.cpp:void (anonymous namespace)::replace<llvm::SmallVector<clang::CharUnits, 32u>, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_2, clang::CharUnits> > >(llvm::SmallVector<clang::CharUnits, 32u>&, unsigned long, unsigned long, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_2, clang::CharUnits> >) Line | Count | Source | 137 | 32 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { | 138 | 32 | assert(BeginOff <= EndOff && "invalid replacement range"); | 139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); | 140 | 32 | } |
CGExprConstant.cpp:void (anonymous namespace)::replace<llvm::SmallVector<llvm::Constant*, 32u>, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_3, llvm::Constant*> > >(llvm::SmallVector<llvm::Constant*, 32u>&, unsigned long, unsigned long, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_3, llvm::Constant*> >) Line | Count | Source | 137 | 15 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { | 138 | 15 | assert(BeginOff <= EndOff && "invalid replacement range"); | 139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); | 140 | 15 | } |
CGExprConstant.cpp:void (anonymous namespace)::replace<llvm::SmallVector<clang::CharUnits, 32u>, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_4, clang::CharUnits> > >(llvm::SmallVector<clang::CharUnits, 32u>&, unsigned long, unsigned long, llvm::iterator_range<llvm::mapped_iterator<llvm::detail::SafeIntIterator<unsigned int, false>, (anonymous namespace)::ConstantAggregateBuilder::split(unsigned long, clang::CharUnits)::$_4, clang::CharUnits> >) Line | Count | Source | 137 | 15 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { | 138 | 15 | assert(BeginOff <= EndOff && "invalid replacement range"); | 139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); | 140 | 15 | } |
CGExprConstant.cpp:void (anonymous namespace)::replace<llvm::SmallVector<llvm::Constant*, 32u>, std::initializer_list<llvm::Constant*> >(llvm::SmallVector<llvm::Constant*, 32u>&, unsigned long, unsigned long, std::initializer_list<llvm::Constant*>) Line | Count | Source | 137 | 110 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { | 138 | 110 | assert(BeginOff <= EndOff && "invalid replacement range"); | 139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); | 140 | 110 | } |
CGExprConstant.cpp:void (anonymous namespace)::replace<llvm::SmallVector<clang::CharUnits, 32u>, std::initializer_list<clang::CharUnits> >(llvm::SmallVector<clang::CharUnits, 32u>&, unsigned long, unsigned long, std::initializer_list<clang::CharUnits>) Line | Count | Source | 137 | 110 | static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) { | 138 | 110 | assert(BeginOff <= EndOff && "invalid replacement range"); | 139 | 0 | llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals); | 140 | 110 | } |
|
141 | | |
142 | | bool ConstantAggregateBuilder::add(llvm::Constant *C, CharUnits Offset, |
143 | 11.2k | bool AllowOverwrite) { |
144 | | // Common case: appending to a layout. |
145 | 11.2k | if (Offset >= Size) { |
146 | 11.1k | CharUnits Align = getAlignment(C); |
147 | 11.1k | CharUnits AlignedSize = Size.alignTo(Align); |
148 | 11.1k | if (AlignedSize > Offset || Offset.alignTo(Align) != Offset11.1k ) |
149 | 88 | NaturalLayout = false; |
150 | 11.1k | else if (AlignedSize < Offset) { |
151 | 53 | Elems.push_back(getPadding(Offset - Size)); |
152 | 53 | Offsets.push_back(Size); |
153 | 53 | } |
154 | 11.1k | Elems.push_back(C); |
155 | 11.1k | Offsets.push_back(Offset); |
156 | 11.1k | Size = Offset + getSize(C); |
157 | 11.1k | return true; |
158 | 11.1k | } |
159 | | |
160 | | // Uncommon case: constant overlaps what we've already created. |
161 | 92 | llvm::Optional<size_t> FirstElemToReplace = splitAt(Offset); |
162 | 92 | if (!FirstElemToReplace) |
163 | 0 | return false; |
164 | | |
165 | 92 | CharUnits CSize = getSize(C); |
166 | 92 | llvm::Optional<size_t> LastElemToReplace = splitAt(Offset + CSize); |
167 | 92 | if (!LastElemToReplace) |
168 | 0 | return false; |
169 | | |
170 | 92 | assert((FirstElemToReplace == LastElemToReplace || AllowOverwrite) && |
171 | 92 | "unexpectedly overwriting field"); |
172 | | |
173 | 0 | replace(Elems, *FirstElemToReplace, *LastElemToReplace, {C}); |
174 | 92 | replace(Offsets, *FirstElemToReplace, *LastElemToReplace, {Offset}); |
175 | 92 | Size = std::max(Size, Offset + CSize); |
176 | 92 | NaturalLayout = false; |
177 | 92 | return true; |
178 | 92 | } |
179 | | |
180 | | bool ConstantAggregateBuilder::addBits(llvm::APInt Bits, uint64_t OffsetInBits, |
181 | 267 | bool AllowOverwrite) { |
182 | 267 | const ASTContext &Context = CGM.getContext(); |
183 | 267 | const uint64_t CharWidth = CGM.getContext().getCharWidth(); |
184 | | |
185 | | // Offset of where we want the first bit to go within the bits of the |
186 | | // current char. |
187 | 267 | unsigned OffsetWithinChar = OffsetInBits % CharWidth; |
188 | | |
189 | | // We split bit-fields up into individual bytes. Walk over the bytes and |
190 | | // update them. |
191 | 267 | for (CharUnits OffsetInChars = |
192 | 267 | Context.toCharUnitsFromBits(OffsetInBits - OffsetWithinChar); |
193 | 491 | /**/; ++OffsetInChars224 ) { |
194 | | // Number of bits we want to fill in this char. |
195 | 491 | unsigned WantedBits = |
196 | 491 | std::min((uint64_t)Bits.getBitWidth(), CharWidth - OffsetWithinChar); |
197 | | |
198 | | // Get a char containing the bits we want in the right places. The other |
199 | | // bits have unspecified values. |
200 | 491 | llvm::APInt BitsThisChar = Bits; |
201 | 491 | if (BitsThisChar.getBitWidth() < CharWidth) |
202 | 239 | BitsThisChar = BitsThisChar.zext(CharWidth); |
203 | 491 | if (CGM.getDataLayout().isBigEndian()) { |
204 | | // Figure out how much to shift by. We may need to left-shift if we have |
205 | | // less than one byte of Bits left. |
206 | 19 | int Shift = Bits.getBitWidth() - CharWidth + OffsetWithinChar; |
207 | 19 | if (Shift > 0) |
208 | 10 | BitsThisChar.lshrInPlace(Shift); |
209 | 9 | else if (Shift < 0) |
210 | 8 | BitsThisChar = BitsThisChar.shl(-Shift); |
211 | 472 | } else { |
212 | 472 | BitsThisChar = BitsThisChar.shl(OffsetWithinChar); |
213 | 472 | } |
214 | 491 | if (BitsThisChar.getBitWidth() > CharWidth) |
215 | 221 | BitsThisChar = BitsThisChar.trunc(CharWidth); |
216 | | |
217 | 491 | if (WantedBits == CharWidth) { |
218 | | // Got a full byte: just add it directly. |
219 | 238 | add(llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar), |
220 | 238 | OffsetInChars, AllowOverwrite); |
221 | 253 | } else { |
222 | | // Partial byte: update the existing integer if there is one. If we |
223 | | // can't split out a 1-CharUnit range to update, then we can't add |
224 | | // these bits and fail the entire constant emission. |
225 | 253 | llvm::Optional<size_t> FirstElemToUpdate = splitAt(OffsetInChars); |
226 | 253 | if (!FirstElemToUpdate) |
227 | 0 | return false; |
228 | 253 | llvm::Optional<size_t> LastElemToUpdate = |
229 | 253 | splitAt(OffsetInChars + CharUnits::One()); |
230 | 253 | if (!LastElemToUpdate) |
231 | 0 | return false; |
232 | 253 | assert(*LastElemToUpdate - *FirstElemToUpdate < 2 && |
233 | 253 | "should have at most one element covering one byte"); |
234 | | |
235 | | // Figure out which bits we want and discard the rest. |
236 | 0 | llvm::APInt UpdateMask(CharWidth, 0); |
237 | 253 | if (CGM.getDataLayout().isBigEndian()) |
238 | 8 | UpdateMask.setBits(CharWidth - OffsetWithinChar - WantedBits, |
239 | 8 | CharWidth - OffsetWithinChar); |
240 | 245 | else |
241 | 245 | UpdateMask.setBits(OffsetWithinChar, OffsetWithinChar + WantedBits); |
242 | 253 | BitsThisChar &= UpdateMask; |
243 | | |
244 | 253 | if (*FirstElemToUpdate == *LastElemToUpdate || |
245 | 253 | Elems[*FirstElemToUpdate]->isNullValue()78 || |
246 | 253 | isa<llvm::UndefValue>(Elems[*FirstElemToUpdate])37 ) { |
247 | | // All existing bits are either zero or undef. |
248 | 218 | add(llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar), |
249 | 218 | OffsetInChars, /*AllowOverwrite*/ true); |
250 | 218 | } else { |
251 | 35 | llvm::Constant *&ToUpdate = Elems[*FirstElemToUpdate]; |
252 | | // In order to perform a partial update, we need the existing bitwise |
253 | | // value, which we can only extract for a constant int. |
254 | 35 | auto *CI = dyn_cast<llvm::ConstantInt>(ToUpdate); |
255 | 35 | if (!CI) |
256 | 0 | return false; |
257 | | // Because this is a 1-CharUnit range, the constant occupying it must |
258 | | // be exactly one CharUnit wide. |
259 | 35 | assert(CI->getBitWidth() == CharWidth && "splitAt failed"); |
260 | 0 | assert((!(CI->getValue() & UpdateMask) || AllowOverwrite) && |
261 | 35 | "unexpectedly overwriting bitfield"); |
262 | 0 | BitsThisChar |= (CI->getValue() & ~UpdateMask); |
263 | 35 | ToUpdate = llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar); |
264 | 35 | } |
265 | 253 | } |
266 | | |
267 | | // Stop if we've added all the bits. |
268 | 491 | if (WantedBits == Bits.getBitWidth()) |
269 | 267 | break; |
270 | | |
271 | | // Remove the consumed bits from Bits. |
272 | 224 | if (!CGM.getDataLayout().isBigEndian()) |
273 | 214 | Bits.lshrInPlace(WantedBits); |
274 | 224 | Bits = Bits.trunc(Bits.getBitWidth() - WantedBits); |
275 | | |
276 | | // The remanining bits go at the start of the following bytes. |
277 | 224 | OffsetWithinChar = 0; |
278 | 224 | } |
279 | | |
280 | 267 | return true; |
281 | 267 | } |
282 | | |
283 | | /// Returns a position within Elems and Offsets such that all elements |
284 | | /// before the returned index end before Pos and all elements at or after |
285 | | /// the returned index begin at or after Pos. Splits elements as necessary |
286 | | /// to ensure this. Returns None if we find something we can't split. |
287 | 726 | Optional<size_t> ConstantAggregateBuilder::splitAt(CharUnits Pos) { |
288 | 726 | if (Pos >= Size) |
289 | 493 | return Offsets.size(); |
290 | | |
291 | 286 | while (233 true) { |
292 | 286 | auto FirstAfterPos = llvm::upper_bound(Offsets, Pos); |
293 | 286 | if (FirstAfterPos == Offsets.begin()) |
294 | 0 | return 0; |
295 | | |
296 | | // If we already have an element starting at Pos, we're done. |
297 | 286 | size_t LastAtOrBeforePosIndex = FirstAfterPos - Offsets.begin() - 1; |
298 | 286 | if (Offsets[LastAtOrBeforePosIndex] == Pos) |
299 | 229 | return LastAtOrBeforePosIndex; |
300 | | |
301 | | // We found an element starting before Pos. Check for overlap. |
302 | 57 | if (Offsets[LastAtOrBeforePosIndex] + |
303 | 57 | getSize(Elems[LastAtOrBeforePosIndex]) <= Pos) |
304 | 4 | return LastAtOrBeforePosIndex + 1; |
305 | | |
306 | | // Try to decompose it into smaller constants. |
307 | 53 | if (!split(LastAtOrBeforePosIndex, Pos)) |
308 | 0 | return None; |
309 | 53 | } |
310 | 233 | } |
311 | | |
312 | | /// Split the constant at index Index, if possible. Return true if we did. |
313 | | /// Hint indicates the location at which we'd like to split, but may be |
314 | | /// ignored. |
315 | 53 | bool ConstantAggregateBuilder::split(size_t Index, CharUnits Hint) { |
316 | 53 | NaturalLayout = false; |
317 | 53 | llvm::Constant *C = Elems[Index]; |
318 | 53 | CharUnits Offset = Offsets[Index]; |
319 | | |
320 | 53 | if (auto *CA = dyn_cast<llvm::ConstantAggregate>(C)) { |
321 | | // Expand the sequence into its contained elements. |
322 | | // FIXME: This assumes vector elements are byte-sized. |
323 | 34 | replace(Elems, Index, Index + 1, |
324 | 34 | llvm::map_range(llvm::seq(0u, CA->getNumOperands()), |
325 | 75 | [&](unsigned Op) { return CA->getOperand(Op); })); |
326 | 34 | if (isa<llvm::ArrayType>(CA->getType()) || |
327 | 34 | isa<llvm::VectorType>(CA->getType())32 ) { |
328 | | // Array or vector. |
329 | 2 | llvm::Type *ElemTy = |
330 | 2 | llvm::GetElementPtrInst::getTypeAtIndex(CA->getType(), (uint64_t)0); |
331 | 2 | CharUnits ElemSize = getSize(ElemTy); |
332 | 2 | replace( |
333 | 2 | Offsets, Index, Index + 1, |
334 | 2 | llvm::map_range(llvm::seq(0u, CA->getNumOperands()), |
335 | 6 | [&](unsigned Op) { return Offset + Op * ElemSize; })); |
336 | 32 | } else { |
337 | | // Must be a struct. |
338 | 32 | auto *ST = cast<llvm::StructType>(CA->getType()); |
339 | 32 | const llvm::StructLayout *Layout = |
340 | 32 | CGM.getDataLayout().getStructLayout(ST); |
341 | 32 | replace(Offsets, Index, Index + 1, |
342 | 32 | llvm::map_range( |
343 | 69 | llvm::seq(0u, CA->getNumOperands()), [&](unsigned Op) { |
344 | 69 | return Offset + CharUnits::fromQuantity( |
345 | 69 | Layout->getElementOffset(Op)); |
346 | 69 | })); |
347 | 32 | } |
348 | 34 | return true; |
349 | 34 | } |
350 | | |
351 | 19 | if (auto *CDS = dyn_cast<llvm::ConstantDataSequential>(C)) { |
352 | | // Expand the sequence into its contained elements. |
353 | | // FIXME: This assumes vector elements are byte-sized. |
354 | | // FIXME: If possible, split into two ConstantDataSequentials at Hint. |
355 | 15 | CharUnits ElemSize = getSize(CDS->getElementType()); |
356 | 15 | replace(Elems, Index, Index + 1, |
357 | 15 | llvm::map_range(llvm::seq(0u, CDS->getNumElements()), |
358 | 87 | [&](unsigned Elem) { |
359 | 87 | return CDS->getElementAsConstant(Elem); |
360 | 87 | })); |
361 | 15 | replace(Offsets, Index, Index + 1, |
362 | 15 | llvm::map_range( |
363 | 15 | llvm::seq(0u, CDS->getNumElements()), |
364 | 87 | [&](unsigned Elem) { return Offset + Elem * ElemSize; })); |
365 | 15 | return true; |
366 | 15 | } |
367 | | |
368 | 4 | if (isa<llvm::ConstantAggregateZero>(C)) { |
369 | | // Split into two zeros at the hinted offset. |
370 | 4 | CharUnits ElemSize = getSize(C); |
371 | 4 | assert(Hint > Offset && Hint < Offset + ElemSize && "nothing to split"); |
372 | 0 | replace(Elems, Index, Index + 1, |
373 | 4 | {getZeroes(Hint - Offset), getZeroes(Offset + ElemSize - Hint)}); |
374 | 4 | replace(Offsets, Index, Index + 1, {Offset, Hint}); |
375 | 4 | return true; |
376 | 4 | } |
377 | | |
378 | 0 | if (isa<llvm::UndefValue>(C)) { |
379 | | // Drop undef; it doesn't contribute to the final layout. |
380 | 0 | replace(Elems, Index, Index + 1, {}); |
381 | 0 | replace(Offsets, Index, Index + 1, {}); |
382 | 0 | return true; |
383 | 0 | } |
384 | | |
385 | | // FIXME: We could split a ConstantInt if the need ever arose. |
386 | | // We don't need to do this to handle bit-fields because we always eagerly |
387 | | // split them into 1-byte chunks. |
388 | | |
389 | 0 | return false; |
390 | 0 | } |
391 | | |
392 | | static llvm::Constant * |
393 | | EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType, |
394 | | llvm::Type *CommonElementType, unsigned ArrayBound, |
395 | | SmallVectorImpl<llvm::Constant *> &Elements, |
396 | | llvm::Constant *Filler); |
397 | | |
398 | | llvm::Constant *ConstantAggregateBuilder::buildFrom( |
399 | | CodeGenModule &CGM, ArrayRef<llvm::Constant *> Elems, |
400 | | ArrayRef<CharUnits> Offsets, CharUnits StartOffset, CharUnits Size, |
401 | 5.76k | bool NaturalLayout, llvm::Type *DesiredTy, bool AllowOversized) { |
402 | 5.76k | ConstantAggregateBuilderUtils Utils(CGM); |
403 | | |
404 | 5.76k | if (Elems.empty()) |
405 | 100 | return llvm::UndefValue::get(DesiredTy); |
406 | | |
407 | 5.66k | auto Offset = [&](size_t I) { return Offsets[I] - StartOffset; }441 ; |
408 | | |
409 | | // If we want an array type, see if all the elements are the same type and |
410 | | // appropriately spaced. |
411 | 5.66k | if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(DesiredTy)) { |
412 | 21 | assert(!AllowOversized && "oversized array emission not supported"); |
413 | | |
414 | 0 | bool CanEmitArray = true; |
415 | 21 | llvm::Type *CommonType = Elems[0]->getType(); |
416 | 21 | llvm::Constant *Filler = llvm::Constant::getNullValue(CommonType); |
417 | 21 | CharUnits ElemSize = Utils.getSize(ATy->getElementType()); |
418 | 21 | SmallVector<llvm::Constant*, 32> ArrayElements; |
419 | 128 | for (size_t I = 0; I != Elems.size(); ++I107 ) { |
420 | | // Skip zeroes; we'll use a zero value as our array filler. |
421 | 109 | if (Elems[I]->isNullValue()) |
422 | 35 | continue; |
423 | | |
424 | | // All remaining elements must be the same type. |
425 | 74 | if (Elems[I]->getType() != CommonType || |
426 | 74 | Offset(I) % ElemSize != 072 ) { |
427 | 2 | CanEmitArray = false; |
428 | 2 | break; |
429 | 2 | } |
430 | 72 | ArrayElements.resize(Offset(I) / ElemSize + 1, Filler); |
431 | 72 | ArrayElements.back() = Elems[I]; |
432 | 72 | } |
433 | | |
434 | 21 | if (CanEmitArray) { |
435 | 19 | return EmitArrayConstant(CGM, ATy, CommonType, ATy->getNumElements(), |
436 | 19 | ArrayElements, Filler); |
437 | 19 | } |
438 | | |
439 | | // Can't emit as an array, carry on to emit as a struct. |
440 | 21 | } |
441 | | |
442 | | // The size of the constant we plan to generate. This is usually just |
443 | | // the size of the initialized type, but in AllowOversized mode (i.e. |
444 | | // flexible array init), it can be larger. |
445 | 5.64k | CharUnits DesiredSize = Utils.getSize(DesiredTy); |
446 | 5.64k | if (Size > DesiredSize) { |
447 | 14 | assert(AllowOversized && "Elems are oversized"); |
448 | 0 | DesiredSize = Size; |
449 | 14 | } |
450 | | |
451 | | // The natural alignment of an unpacked LLVM struct with the given elements. |
452 | 0 | CharUnits Align = CharUnits::One(); |
453 | 5.64k | for (llvm::Constant *C : Elems) |
454 | 11.2k | Align = std::max(Align, Utils.getAlignment(C)); |
455 | | |
456 | | // The natural size of an unpacked LLVM struct with the given elements. |
457 | 5.64k | CharUnits AlignedSize = Size.alignTo(Align); |
458 | | |
459 | 5.64k | bool Packed = false; |
460 | 5.64k | ArrayRef<llvm::Constant*> UnpackedElems = Elems; |
461 | 5.64k | llvm::SmallVector<llvm::Constant*, 32> UnpackedElemStorage; |
462 | 5.64k | if (DesiredSize < AlignedSize || DesiredSize.alignTo(Align) != DesiredSize5.54k ) { |
463 | | // The natural layout would be too big; force use of a packed layout. |
464 | 97 | NaturalLayout = false; |
465 | 97 | Packed = true; |
466 | 5.54k | } else if (DesiredSize > AlignedSize) { |
467 | | // The natural layout would be too small. Add padding to fix it. (This |
468 | | // is ignored if we choose a packed layout.) |
469 | 390 | UnpackedElemStorage.assign(Elems.begin(), Elems.end()); |
470 | 390 | UnpackedElemStorage.push_back(Utils.getPadding(DesiredSize - Size)); |
471 | 390 | UnpackedElems = UnpackedElemStorage; |
472 | 390 | } |
473 | | |
474 | | // If we don't have a natural layout, insert padding as necessary. |
475 | | // As we go, double-check to see if we can actually just emit Elems |
476 | | // as a non-packed struct and do so opportunistically if possible. |
477 | 5.64k | llvm::SmallVector<llvm::Constant*, 32> PackedElems; |
478 | 5.64k | if (!NaturalLayout) { |
479 | 145 | CharUnits SizeSoFar = CharUnits::Zero(); |
480 | 442 | for (size_t I = 0; I != Elems.size(); ++I297 ) { |
481 | 297 | CharUnits Align = Utils.getAlignment(Elems[I]); |
482 | 297 | CharUnits NaturalOffset = SizeSoFar.alignTo(Align); |
483 | 297 | CharUnits DesiredOffset = Offset(I); |
484 | 297 | assert(DesiredOffset >= SizeSoFar && "elements out of order"); |
485 | | |
486 | 297 | if (DesiredOffset != NaturalOffset) |
487 | 90 | Packed = true; |
488 | 297 | if (DesiredOffset != SizeSoFar) |
489 | 3 | PackedElems.push_back(Utils.getPadding(DesiredOffset - SizeSoFar)); |
490 | 297 | PackedElems.push_back(Elems[I]); |
491 | 297 | SizeSoFar = DesiredOffset + Utils.getSize(Elems[I]); |
492 | 297 | } |
493 | | // If we're using the packed layout, pad it out to the desired size if |
494 | | // necessary. |
495 | 145 | if (Packed) { |
496 | 101 | assert(SizeSoFar <= DesiredSize && |
497 | 101 | "requested size is too small for contents"); |
498 | 101 | if (SizeSoFar < DesiredSize) |
499 | 10 | PackedElems.push_back(Utils.getPadding(DesiredSize - SizeSoFar)); |
500 | 101 | } |
501 | 145 | } |
502 | | |
503 | 0 | llvm::StructType *STy = llvm::ConstantStruct::getTypeForElements( |
504 | 5.64k | CGM.getLLVMContext(), Packed ? PackedElems101 : UnpackedElems5.54k , Packed); |
505 | | |
506 | | // Pick the type to use. If the type is layout identical to the desired |
507 | | // type then use it, otherwise use whatever the builder produced for us. |
508 | 5.64k | if (llvm::StructType *DesiredSTy = dyn_cast<llvm::StructType>(DesiredTy)) { |
509 | 5.63k | if (DesiredSTy->isLayoutIdentical(STy)) |
510 | 4.71k | STy = DesiredSTy; |
511 | 5.63k | } |
512 | | |
513 | 5.64k | return llvm::ConstantStruct::get(STy, Packed ? PackedElems101 : UnpackedElems5.54k ); |
514 | 5.66k | } |
515 | | |
516 | | void ConstantAggregateBuilder::condense(CharUnits Offset, |
517 | 18 | llvm::Type *DesiredTy) { |
518 | 18 | CharUnits Size = getSize(DesiredTy); |
519 | | |
520 | 18 | llvm::Optional<size_t> FirstElemToReplace = splitAt(Offset); |
521 | 18 | if (!FirstElemToReplace) |
522 | 0 | return; |
523 | 18 | size_t First = *FirstElemToReplace; |
524 | | |
525 | 18 | llvm::Optional<size_t> LastElemToReplace = splitAt(Offset + Size); |
526 | 18 | if (!LastElemToReplace) |
527 | 0 | return; |
528 | 18 | size_t Last = *LastElemToReplace; |
529 | | |
530 | 18 | size_t Length = Last - First; |
531 | 18 | if (Length == 0) |
532 | 0 | return; |
533 | | |
534 | 18 | if (Length == 1 && Offsets[First] == Offset4 && |
535 | 18 | getSize(Elems[First]) == Size4 ) { |
536 | | // Re-wrap single element structs if necessary. Otherwise, leave any single |
537 | | // element constant of the right size alone even if it has the wrong type. |
538 | 4 | auto *STy = dyn_cast<llvm::StructType>(DesiredTy); |
539 | 4 | if (STy && STy->getNumElements() == 1 && |
540 | 4 | STy->getElementType(0) == Elems[First]->getType()) |
541 | 2 | Elems[First] = llvm::ConstantStruct::get(STy, Elems[First]); |
542 | 4 | return; |
543 | 4 | } |
544 | | |
545 | 14 | llvm::Constant *Replacement = buildFrom( |
546 | 14 | CGM, makeArrayRef(Elems).slice(First, Length), |
547 | 14 | makeArrayRef(Offsets).slice(First, Length), Offset, getSize(DesiredTy), |
548 | 14 | /*known to have natural layout=*/false, DesiredTy, false); |
549 | 14 | replace(Elems, First, Last, {Replacement}); |
550 | 14 | replace(Offsets, First, Last, {Offset}); |
551 | 14 | } |
552 | | |
553 | | //===----------------------------------------------------------------------===// |
554 | | // ConstStructBuilder |
555 | | //===----------------------------------------------------------------------===// |
556 | | |
557 | | class ConstStructBuilder { |
558 | | CodeGenModule &CGM; |
559 | | ConstantEmitter &Emitter; |
560 | | ConstantAggregateBuilder &Builder; |
561 | | CharUnits StartOffset; |
562 | | |
563 | | public: |
564 | | static llvm::Constant *BuildStruct(ConstantEmitter &Emitter, |
565 | | InitListExpr *ILE, QualType StructTy); |
566 | | static llvm::Constant *BuildStruct(ConstantEmitter &Emitter, |
567 | | const APValue &Value, QualType ValTy); |
568 | | static bool UpdateStruct(ConstantEmitter &Emitter, |
569 | | ConstantAggregateBuilder &Const, CharUnits Offset, |
570 | | InitListExpr *Updater); |
571 | | |
572 | | private: |
573 | | ConstStructBuilder(ConstantEmitter &Emitter, |
574 | | ConstantAggregateBuilder &Builder, CharUnits StartOffset) |
575 | | : CGM(Emitter.CGM), Emitter(Emitter), Builder(Builder), |
576 | 5.78k | StartOffset(StartOffset) {} |
577 | | |
578 | | bool AppendField(const FieldDecl *Field, uint64_t FieldOffset, |
579 | | llvm::Constant *InitExpr, bool AllowOverwrite = false); |
580 | | |
581 | | bool AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst, |
582 | | bool AllowOverwrite = false); |
583 | | |
584 | | bool AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, |
585 | | llvm::ConstantInt *InitExpr, bool AllowOverwrite = false); |
586 | | |
587 | | bool Build(InitListExpr *ILE, bool AllowOverwrite); |
588 | | bool Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase, |
589 | | const CXXRecordDecl *VTableClass, CharUnits BaseOffset); |
590 | | llvm::Constant *Finalize(QualType Ty); |
591 | | }; |
592 | | |
593 | | bool ConstStructBuilder::AppendField( |
594 | | const FieldDecl *Field, uint64_t FieldOffset, llvm::Constant *InitCst, |
595 | 10.4k | bool AllowOverwrite) { |
596 | 10.4k | const ASTContext &Context = CGM.getContext(); |
597 | | |
598 | 10.4k | CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset); |
599 | | |
600 | 10.4k | return AppendBytes(FieldOffsetInChars, InitCst, AllowOverwrite); |
601 | 10.4k | } |
602 | | |
603 | | bool ConstStructBuilder::AppendBytes(CharUnits FieldOffsetInChars, |
604 | | llvm::Constant *InitCst, |
605 | 10.7k | bool AllowOverwrite) { |
606 | 10.7k | return Builder.add(InitCst, StartOffset + FieldOffsetInChars, AllowOverwrite); |
607 | 10.7k | } |
608 | | |
609 | | bool ConstStructBuilder::AppendBitField( |
610 | | const FieldDecl *Field, uint64_t FieldOffset, llvm::ConstantInt *CI, |
611 | 267 | bool AllowOverwrite) { |
612 | 267 | const CGRecordLayout &RL = |
613 | 267 | CGM.getTypes().getCGRecordLayout(Field->getParent()); |
614 | 267 | const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field); |
615 | 267 | llvm::APInt FieldValue = CI->getValue(); |
616 | | |
617 | | // Promote the size of FieldValue if necessary |
618 | | // FIXME: This should never occur, but currently it can because initializer |
619 | | // constants are cast to bool, and because clang is not enforcing bitfield |
620 | | // width limits. |
621 | 267 | if (Info.Size > FieldValue.getBitWidth()) |
622 | 5 | FieldValue = FieldValue.zext(Info.Size); |
623 | | |
624 | | // Truncate the size of FieldValue to the bit field size. |
625 | 267 | if (Info.Size < FieldValue.getBitWidth()) |
626 | 250 | FieldValue = FieldValue.trunc(Info.Size); |
627 | | |
628 | 267 | return Builder.addBits(FieldValue, |
629 | 267 | CGM.getContext().toBits(StartOffset) + FieldOffset, |
630 | 267 | AllowOverwrite); |
631 | 267 | } |
632 | | |
633 | | static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter, |
634 | | ConstantAggregateBuilder &Const, |
635 | | CharUnits Offset, QualType Type, |
636 | 46 | InitListExpr *Updater) { |
637 | 46 | if (Type->isRecordType()) |
638 | 25 | return ConstStructBuilder::UpdateStruct(Emitter, Const, Offset, Updater); |
639 | | |
640 | 21 | auto CAT = Emitter.CGM.getContext().getAsConstantArrayType(Type); |
641 | 21 | if (!CAT) |
642 | 0 | return false; |
643 | 21 | QualType ElemType = CAT->getElementType(); |
644 | 21 | CharUnits ElemSize = Emitter.CGM.getContext().getTypeSizeInChars(ElemType); |
645 | 21 | llvm::Type *ElemTy = Emitter.CGM.getTypes().ConvertTypeForMem(ElemType); |
646 | | |
647 | 21 | llvm::Constant *FillC = nullptr; |
648 | 21 | if (Expr *Filler = Updater->getArrayFiller()) { |
649 | 21 | if (!isa<NoInitExpr>(Filler)) { |
650 | 3 | FillC = Emitter.tryEmitAbstractForMemory(Filler, ElemType); |
651 | 3 | if (!FillC) |
652 | 0 | return false; |
653 | 3 | } |
654 | 21 | } |
655 | | |
656 | 21 | unsigned NumElementsToUpdate = |
657 | 21 | FillC ? CAT->getSize().getZExtValue()3 : Updater->getNumInits()18 ; |
658 | 111 | for (unsigned I = 0; I != NumElementsToUpdate; ++I, Offset += ElemSize90 ) { |
659 | 90 | Expr *Init = nullptr; |
660 | 90 | if (I < Updater->getNumInits()) |
661 | 78 | Init = Updater->getInit(I); |
662 | | |
663 | 90 | if (!Init && FillC12 ) { |
664 | 12 | if (!Const.add(FillC, Offset, true)) |
665 | 0 | return false; |
666 | 78 | } else if (!Init || isa<NoInitExpr>(Init)) { |
667 | 52 | continue; |
668 | 52 | } else if (InitListExpr *26 ChildILE26 = dyn_cast<InitListExpr>(Init)) { |
669 | 4 | if (!EmitDesignatedInitUpdater(Emitter, Const, Offset, ElemType, |
670 | 4 | ChildILE)) |
671 | 0 | return false; |
672 | | // Attempt to reduce the array element to a single constant if necessary. |
673 | 4 | Const.condense(Offset, ElemTy); |
674 | 22 | } else { |
675 | 22 | llvm::Constant *Val = Emitter.tryEmitPrivateForMemory(Init, ElemType); |
676 | 22 | if (!Const.add(Val, Offset, true)) |
677 | 0 | return false; |
678 | 22 | } |
679 | 90 | } |
680 | | |
681 | 21 | return true; |
682 | 21 | } |
683 | | |
684 | 2.34k | bool ConstStructBuilder::Build(InitListExpr *ILE, bool AllowOverwrite) { |
685 | 2.34k | RecordDecl *RD = ILE->getType()->castAs<RecordType>()->getDecl(); |
686 | 2.34k | const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); |
687 | | |
688 | 2.34k | unsigned FieldNo = -1; |
689 | 2.34k | unsigned ElementNo = 0; |
690 | | |
691 | | // Bail out if we have base classes. We could support these, but they only |
692 | | // arise in C++1z where we will have already constant folded most interesting |
693 | | // cases. FIXME: There are still a few more cases we can handle this way. |
694 | 2.34k | if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) |
695 | 138 | if (CXXRD->getNumBases()) |
696 | 6 | return false; |
697 | | |
698 | 5.21k | for (FieldDecl *Field : RD->fields())2.34k { |
699 | 5.21k | ++FieldNo; |
700 | | |
701 | | // If this is a union, skip all the fields that aren't being initialized. |
702 | 5.21k | if (RD->isUnion() && |
703 | 5.21k | !declaresSameEntity(ILE->getInitializedFieldInUnion(), Field)229 ) |
704 | 107 | continue; |
705 | | |
706 | | // Don't emit anonymous bitfields or zero-sized fields. |
707 | 5.10k | if (Field->isUnnamedBitfield() || Field->isZeroSize(CGM.getContext())5.08k ) |
708 | 26 | continue; |
709 | | |
710 | | // Get the initializer. A struct can include fields without initializers, |
711 | | // we just use explicit null values for them. |
712 | 5.08k | Expr *Init = nullptr; |
713 | 5.08k | if (ElementNo < ILE->getNumInits()) |
714 | 5.03k | Init = ILE->getInit(ElementNo++); |
715 | 5.08k | if (Init && isa<NoInitExpr>(Init)5.03k ) |
716 | 15 | continue; |
717 | | |
718 | | // When emitting a DesignatedInitUpdateExpr, a nested InitListExpr |
719 | | // represents additional overwriting of our current constant value, and not |
720 | | // a new constant to emit independently. |
721 | 5.06k | if (AllowOverwrite && |
722 | 5.06k | (27 Field->getType()->isArrayType()27 || Field->getType()->isRecordType()13 )) { |
723 | 15 | if (auto *SubILE = dyn_cast<InitListExpr>(Init)) { |
724 | 14 | CharUnits Offset = CGM.getContext().toCharUnitsFromBits( |
725 | 14 | Layout.getFieldOffset(FieldNo)); |
726 | 14 | if (!EmitDesignatedInitUpdater(Emitter, Builder, StartOffset + Offset, |
727 | 14 | Field->getType(), SubILE)) |
728 | 0 | return false; |
729 | | // If we split apart the field's value, try to collapse it down to a |
730 | | // single value now. |
731 | 14 | Builder.condense(StartOffset + Offset, |
732 | 14 | CGM.getTypes().ConvertTypeForMem(Field->getType())); |
733 | 14 | continue; |
734 | 14 | } |
735 | 15 | } |
736 | | |
737 | 5.05k | llvm::Constant *EltInit = |
738 | 5.05k | Init ? Emitter.tryEmitPrivateForMemory(Init, Field->getType())5.00k |
739 | 5.05k | : Emitter.emitNullForMemory(Field->getType())46 ; |
740 | 5.05k | if (!EltInit) |
741 | 32 | return false; |
742 | | |
743 | 5.02k | if (!Field->isBitField()) { |
744 | | // Handle non-bitfield members. |
745 | 4.87k | if (!AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit, |
746 | 4.87k | AllowOverwrite)) |
747 | 0 | return false; |
748 | | // After emitting a non-empty field with [[no_unique_address]], we may |
749 | | // need to overwrite its tail padding. |
750 | 4.87k | if (Field->hasAttr<NoUniqueAddressAttr>()) |
751 | 0 | AllowOverwrite = true; |
752 | 4.87k | } else { |
753 | | // Otherwise we have a bitfield. |
754 | 144 | if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) { |
755 | 141 | if (!AppendBitField(Field, Layout.getFieldOffset(FieldNo), CI, |
756 | 141 | AllowOverwrite)) |
757 | 0 | return false; |
758 | 141 | } else { |
759 | | // We are trying to initialize a bitfield with a non-trivial constant, |
760 | | // this must require run-time code. |
761 | 3 | return false; |
762 | 3 | } |
763 | 144 | } |
764 | 5.02k | } |
765 | | |
766 | 2.30k | return true; |
767 | 2.34k | } |
768 | | |
769 | | namespace { |
770 | | struct BaseInfo { |
771 | | BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index) |
772 | 418 | : Decl(Decl), Offset(Offset), Index(Index) { |
773 | 418 | } |
774 | | |
775 | | const CXXRecordDecl *Decl; |
776 | | CharUnits Offset; |
777 | | unsigned Index; |
778 | | |
779 | 63 | bool operator<(const BaseInfo &O) const { return Offset < O.Offset; } |
780 | | }; |
781 | | } |
782 | | |
783 | | bool ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD, |
784 | | bool IsPrimaryBase, |
785 | | const CXXRecordDecl *VTableClass, |
786 | 3.85k | CharUnits Offset) { |
787 | 3.85k | const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); |
788 | | |
789 | 3.85k | if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) { |
790 | | // Add a vtable pointer, if we need one and it hasn't already been added. |
791 | 3.85k | if (Layout.hasOwnVFPtr()) { |
792 | 346 | llvm::Constant *VTableAddressPoint = |
793 | 346 | CGM.getCXXABI().getVTableAddressPointForConstExpr( |
794 | 346 | BaseSubobject(CD, Offset), VTableClass); |
795 | 346 | if (!AppendBytes(Offset, VTableAddressPoint)) |
796 | 0 | return false; |
797 | 346 | } |
798 | | |
799 | | // Accumulate and sort bases, in order to visit them in address order, which |
800 | | // may not be the same as declaration order. |
801 | 3.85k | SmallVector<BaseInfo, 8> Bases; |
802 | 3.85k | Bases.reserve(CD->getNumBases()); |
803 | 3.85k | unsigned BaseNo = 0; |
804 | 3.85k | for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(), |
805 | 4.27k | BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo418 ) { |
806 | 418 | assert(!Base->isVirtual() && "should not have virtual bases here"); |
807 | 0 | const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl(); |
808 | 418 | CharUnits BaseOffset = Layout.getBaseClassOffset(BD); |
809 | 418 | Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo)); |
810 | 418 | } |
811 | 3.85k | llvm::stable_sort(Bases); |
812 | | |
813 | 4.27k | for (unsigned I = 0, N = Bases.size(); I != N; ++I418 ) { |
814 | 418 | BaseInfo &Base = Bases[I]; |
815 | | |
816 | 418 | bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl; |
817 | 418 | Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase, |
818 | 418 | VTableClass, Offset + Base.Offset); |
819 | 418 | } |
820 | 3.85k | } |
821 | | |
822 | 3.85k | unsigned FieldNo = 0; |
823 | 3.85k | uint64_t OffsetBits = CGM.getContext().toBits(Offset); |
824 | | |
825 | 3.85k | bool AllowOverwrite = false; |
826 | 3.85k | for (RecordDecl::field_iterator Field = RD->field_begin(), |
827 | 10.0k | FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo6.14k ) { |
828 | | // If this is a union, skip all the fields that aren't being initialized. |
829 | 6.14k | if (RD->isUnion() && !declaresSameEntity(Val.getUnionField(), *Field)913 ) |
830 | 434 | continue; |
831 | | |
832 | | // Don't emit anonymous bitfields or zero-sized fields. |
833 | 5.71k | if (Field->isUnnamedBitfield() || Field->isZeroSize(CGM.getContext())5.69k ) |
834 | 39 | continue; |
835 | | |
836 | | // Emit the value of the initializer. |
837 | 5.67k | const APValue &FieldValue = |
838 | 5.67k | RD->isUnion() ? Val.getUnionValue()479 : Val.getStructField(FieldNo)5.19k ; |
839 | 5.67k | llvm::Constant *EltInit = |
840 | 5.67k | Emitter.tryEmitPrivateForMemory(FieldValue, Field->getType()); |
841 | 5.67k | if (!EltInit) |
842 | 0 | return false; |
843 | | |
844 | 5.67k | if (!Field->isBitField()) { |
845 | | // Handle non-bitfield members. |
846 | 5.54k | if (!AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, |
847 | 5.54k | EltInit, AllowOverwrite)) |
848 | 0 | return false; |
849 | | // After emitting a non-empty field with [[no_unique_address]], we may |
850 | | // need to overwrite its tail padding. |
851 | 5.54k | if (Field->hasAttr<NoUniqueAddressAttr>()) |
852 | 6 | AllowOverwrite = true; |
853 | 5.54k | } else { |
854 | | // Otherwise we have a bitfield. |
855 | 126 | if (!AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, |
856 | 126 | cast<llvm::ConstantInt>(EltInit), AllowOverwrite)) |
857 | 0 | return false; |
858 | 126 | } |
859 | 5.67k | } |
860 | | |
861 | 3.85k | return true; |
862 | 3.85k | } |
863 | | |
864 | 5.71k | llvm::Constant *ConstStructBuilder::Finalize(QualType Type) { |
865 | 5.71k | Type = Type.getNonReferenceType(); |
866 | 5.71k | RecordDecl *RD = Type->castAs<RecordType>()->getDecl(); |
867 | 5.71k | llvm::Type *ValTy = CGM.getTypes().ConvertType(Type); |
868 | 5.71k | return Builder.build(ValTy, RD->hasFlexibleArrayMember()); |
869 | 5.71k | } |
870 | | |
871 | | llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter, |
872 | | InitListExpr *ILE, |
873 | 2.32k | QualType ValTy) { |
874 | 2.32k | ConstantAggregateBuilder Const(Emitter.CGM); |
875 | 2.32k | ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero()); |
876 | | |
877 | 2.32k | if (!Builder.Build(ILE, /*AllowOverwrite*/false)) |
878 | 41 | return nullptr; |
879 | | |
880 | 2.28k | return Builder.Finalize(ValTy); |
881 | 2.32k | } |
882 | | |
883 | | llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter, |
884 | | const APValue &Val, |
885 | 3.43k | QualType ValTy) { |
886 | 3.43k | ConstantAggregateBuilder Const(Emitter.CGM); |
887 | 3.43k | ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero()); |
888 | | |
889 | 3.43k | const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl(); |
890 | 3.43k | const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD); |
891 | 3.43k | if (!Builder.Build(Val, RD, false, CD, CharUnits::Zero())) |
892 | 0 | return nullptr; |
893 | | |
894 | 3.43k | return Builder.Finalize(ValTy); |
895 | 3.43k | } |
896 | | |
897 | | bool ConstStructBuilder::UpdateStruct(ConstantEmitter &Emitter, |
898 | | ConstantAggregateBuilder &Const, |
899 | 25 | CharUnits Offset, InitListExpr *Updater) { |
900 | 25 | return ConstStructBuilder(Emitter, Const, Offset) |
901 | 25 | .Build(Updater, /*AllowOverwrite*/ true); |
902 | 25 | } |
903 | | |
904 | | //===----------------------------------------------------------------------===// |
905 | | // ConstExprEmitter |
906 | | //===----------------------------------------------------------------------===// |
907 | | |
908 | | static ConstantAddress tryEmitGlobalCompoundLiteral(CodeGenModule &CGM, |
909 | | CodeGenFunction *CGF, |
910 | 23 | const CompoundLiteralExpr *E) { |
911 | 23 | CharUnits Align = CGM.getContext().getTypeAlignInChars(E->getType()); |
912 | 23 | if (llvm::GlobalVariable *Addr = |
913 | 23 | CGM.getAddrOfConstantCompoundLiteralIfEmitted(E)) |
914 | 2 | return ConstantAddress(Addr, Addr->getValueType(), Align); |
915 | | |
916 | 21 | LangAS addressSpace = E->getType().getAddressSpace(); |
917 | | |
918 | 21 | ConstantEmitter emitter(CGM, CGF); |
919 | 21 | llvm::Constant *C = emitter.tryEmitForInitializer(E->getInitializer(), |
920 | 21 | addressSpace, E->getType()); |
921 | 21 | if (!C) { |
922 | 0 | assert(!E->isFileScope() && |
923 | 0 | "file-scope compound literal did not have constant initializer!"); |
924 | 0 | return ConstantAddress::invalid(); |
925 | 0 | } |
926 | | |
927 | 21 | auto GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), |
928 | 21 | CGM.isTypeConstant(E->getType(), true), |
929 | 21 | llvm::GlobalValue::InternalLinkage, |
930 | 21 | C, ".compoundliteral", nullptr, |
931 | 21 | llvm::GlobalVariable::NotThreadLocal, |
932 | 21 | CGM.getContext().getTargetAddressSpace(addressSpace)); |
933 | 21 | emitter.finalize(GV); |
934 | 21 | GV->setAlignment(Align.getAsAlign()); |
935 | 21 | CGM.setAddrOfConstantCompoundLiteral(E, GV); |
936 | 21 | return ConstantAddress(GV, GV->getValueType(), Align); |
937 | 21 | } |
938 | | |
939 | | static llvm::Constant * |
940 | | EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType, |
941 | | llvm::Type *CommonElementType, unsigned ArrayBound, |
942 | | SmallVectorImpl<llvm::Constant *> &Elements, |
943 | 3.82k | llvm::Constant *Filler) { |
944 | | // Figure out how long the initial prefix of non-zero elements is. |
945 | 3.82k | unsigned NonzeroLength = ArrayBound; |
946 | 3.82k | if (Elements.size() < NonzeroLength && Filler->isNullValue()839 ) |
947 | 831 | NonzeroLength = Elements.size(); |
948 | 3.82k | if (NonzeroLength == Elements.size()) { |
949 | 4.37k | while (NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue()3.73k ) |
950 | 561 | --NonzeroLength; |
951 | 3.81k | } |
952 | | |
953 | 3.82k | if (NonzeroLength == 0) |
954 | 639 | return llvm::ConstantAggregateZero::get(DesiredType); |
955 | | |
956 | | // Add a zeroinitializer array filler if we have lots of trailing zeroes. |
957 | 3.18k | unsigned TrailingZeroes = ArrayBound - NonzeroLength; |
958 | 3.18k | if (TrailingZeroes >= 8) { |
959 | 64 | assert(Elements.size() >= NonzeroLength && |
960 | 64 | "missing initializer for non-zero element"); |
961 | | |
962 | | // If all the elements had the same type up to the trailing zeroes, emit a |
963 | | // struct of two arrays (the nonzero data and the zeroinitializer). |
964 | 64 | if (CommonElementType && NonzeroLength >= 862 ) { |
965 | 18 | llvm::Constant *Initial = llvm::ConstantArray::get( |
966 | 18 | llvm::ArrayType::get(CommonElementType, NonzeroLength), |
967 | 18 | makeArrayRef(Elements).take_front(NonzeroLength)); |
968 | 18 | Elements.resize(2); |
969 | 18 | Elements[0] = Initial; |
970 | 46 | } else { |
971 | 46 | Elements.resize(NonzeroLength + 1); |
972 | 46 | } |
973 | | |
974 | 64 | auto *FillerType = |
975 | 64 | CommonElementType ? CommonElementType62 : DesiredType->getElementType()2 ; |
976 | 64 | FillerType = llvm::ArrayType::get(FillerType, TrailingZeroes); |
977 | 64 | Elements.back() = llvm::ConstantAggregateZero::get(FillerType); |
978 | 64 | CommonElementType = nullptr; |
979 | 3.11k | } else if (Elements.size() != ArrayBound) { |
980 | | // Otherwise pad to the right size with the filler if necessary. |
981 | 236 | Elements.resize(ArrayBound, Filler); |
982 | 236 | if (Filler->getType() != CommonElementType) |
983 | 8 | CommonElementType = nullptr; |
984 | 236 | } |
985 | | |
986 | | // If all elements have the same type, just emit an array constant. |
987 | 3.18k | if (CommonElementType) |
988 | 3.10k | return llvm::ConstantArray::get( |
989 | 3.10k | llvm::ArrayType::get(CommonElementType, ArrayBound), Elements); |
990 | | |
991 | | // We have mixed types. Use a packed struct. |
992 | 77 | llvm::SmallVector<llvm::Type *, 16> Types; |
993 | 77 | Types.reserve(Elements.size()); |
994 | 77 | for (llvm::Constant *Elt : Elements) |
995 | 245 | Types.push_back(Elt->getType()); |
996 | 77 | llvm::StructType *SType = |
997 | 77 | llvm::StructType::get(CGM.getLLVMContext(), Types, true); |
998 | 77 | return llvm::ConstantStruct::get(SType, Elements); |
999 | 3.18k | } |
1000 | | |
1001 | | // This class only needs to handle arrays, structs and unions. Outside C++11 |
1002 | | // mode, we don't currently constant fold those types. All other types are |
1003 | | // handled by constant folding. |
1004 | | // |
1005 | | // Constant folding is currently missing support for a few features supported |
1006 | | // here: CK_ToUnion, CK_ReinterpretMemberPointer, and DesignatedInitUpdateExpr. |
1007 | | class ConstExprEmitter : |
1008 | | public StmtVisitor<ConstExprEmitter, llvm::Constant*, QualType> { |
1009 | | CodeGenModule &CGM; |
1010 | | ConstantEmitter &Emitter; |
1011 | | llvm::LLVMContext &VMContext; |
1012 | | public: |
1013 | | ConstExprEmitter(ConstantEmitter &emitter) |
1014 | 29.6k | : CGM(emitter.CGM), Emitter(emitter), VMContext(CGM.getLLVMContext()) { |
1015 | 29.6k | } |
1016 | | |
1017 | | //===--------------------------------------------------------------------===// |
1018 | | // Visitor Methods |
1019 | | //===--------------------------------------------------------------------===// |
1020 | | |
1021 | 13.2k | llvm::Constant *VisitStmt(Stmt *S, QualType T) { |
1022 | 13.2k | return nullptr; |
1023 | 13.2k | } |
1024 | | |
1025 | 18 | llvm::Constant *VisitConstantExpr(ConstantExpr *CE, QualType T) { |
1026 | 18 | if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(CE)) |
1027 | 0 | return Result; |
1028 | 18 | return Visit(CE->getSubExpr(), T); |
1029 | 18 | } |
1030 | | |
1031 | 28 | llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) { |
1032 | 28 | return Visit(PE->getSubExpr(), T); |
1033 | 28 | } |
1034 | | |
1035 | | llvm::Constant * |
1036 | | VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE, |
1037 | 0 | QualType T) { |
1038 | 0 | return Visit(PE->getReplacement(), T); |
1039 | 0 | } |
1040 | | |
1041 | | llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE, |
1042 | 1 | QualType T) { |
1043 | 1 | return Visit(GE->getResultExpr(), T); |
1044 | 1 | } |
1045 | | |
1046 | 1 | llvm::Constant *VisitChooseExpr(ChooseExpr *CE, QualType T) { |
1047 | 1 | return Visit(CE->getChosenSubExpr(), T); |
1048 | 1 | } |
1049 | | |
1050 | 16 | llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E, QualType T) { |
1051 | 16 | return Visit(E->getInitializer(), T); |
1052 | 16 | } |
1053 | | |
1054 | 8.38k | llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) { |
1055 | 8.38k | if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E)) |
1056 | 392 | CGM.EmitExplicitCastExprType(ECE, Emitter.CGF); |
1057 | 8.38k | Expr *subExpr = E->getSubExpr(); |
1058 | | |
1059 | 8.38k | switch (E->getCastKind()) { |
1060 | 4 | case CK_ToUnion: { |
1061 | | // GCC cast to union extension |
1062 | 4 | assert(E->getType()->isUnionType() && |
1063 | 4 | "Destination type is not union type!"); |
1064 | | |
1065 | 0 | auto field = E->getTargetUnionField(); |
1066 | | |
1067 | 4 | auto C = Emitter.tryEmitPrivateForMemory(subExpr, field->getType()); |
1068 | 4 | if (!C) return nullptr0 ; |
1069 | | |
1070 | 4 | auto destTy = ConvertType(destType); |
1071 | 4 | if (C->getType() == destTy) return C0 ; |
1072 | | |
1073 | | // Build a struct with the union sub-element as the first member, |
1074 | | // and padded to the appropriate size. |
1075 | 4 | SmallVector<llvm::Constant*, 2> Elts; |
1076 | 4 | SmallVector<llvm::Type*, 2> Types; |
1077 | 4 | Elts.push_back(C); |
1078 | 4 | Types.push_back(C->getType()); |
1079 | 4 | unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType()); |
1080 | 4 | unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destTy); |
1081 | | |
1082 | 4 | assert(CurSize <= TotalSize && "Union size mismatch!"); |
1083 | 4 | if (unsigned NumPadBytes = TotalSize - CurSize) { |
1084 | 2 | llvm::Type *Ty = CGM.CharTy; |
1085 | 2 | if (NumPadBytes > 1) |
1086 | 2 | Ty = llvm::ArrayType::get(Ty, NumPadBytes); |
1087 | | |
1088 | 2 | Elts.push_back(llvm::UndefValue::get(Ty)); |
1089 | 2 | Types.push_back(Ty); |
1090 | 2 | } |
1091 | | |
1092 | 4 | llvm::StructType *STy = llvm::StructType::get(VMContext, Types, false); |
1093 | 4 | return llvm::ConstantStruct::get(STy, Elts); |
1094 | 4 | } |
1095 | | |
1096 | 0 | case CK_AddressSpaceConversion: { |
1097 | 0 | auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType()); |
1098 | 0 | if (!C) return nullptr; |
1099 | 0 | LangAS destAS = E->getType()->getPointeeType().getAddressSpace(); |
1100 | 0 | LangAS srcAS = subExpr->getType()->getPointeeType().getAddressSpace(); |
1101 | 0 | llvm::Type *destTy = ConvertType(E->getType()); |
1102 | 0 | return CGM.getTargetCodeGenInfo().performAddrSpaceCast(CGM, C, srcAS, |
1103 | 0 | destAS, destTy); |
1104 | 0 | } |
1105 | | |
1106 | 7.49k | case CK_LValueToRValue: { |
1107 | | // We don't really support doing lvalue-to-rvalue conversions here; any |
1108 | | // interesting conversions should be done in Evaluate(). But as a |
1109 | | // special case, allow compound literals to support the gcc extension |
1110 | | // allowing "struct x {int x;} x = (struct x) {};". |
1111 | 7.49k | if (auto *E = dyn_cast<CompoundLiteralExpr>(subExpr->IgnoreParens())) |
1112 | 22 | return Visit(E->getInitializer(), destType); |
1113 | 7.47k | return nullptr; |
1114 | 7.49k | } |
1115 | | |
1116 | 0 | case CK_AtomicToNonAtomic: |
1117 | 4 | case CK_NonAtomicToAtomic: |
1118 | 414 | case CK_NoOp: |
1119 | 442 | case CK_ConstructorConversion: |
1120 | 442 | return Visit(subExpr, destType); |
1121 | | |
1122 | 0 | case CK_IntToOCLSampler: |
1123 | 0 | llvm_unreachable("global sampler variables are not generated"); |
1124 | |
|
1125 | 0 | case CK_Dependent: llvm_unreachable("saw dependent cast!"); |
1126 | |
|
1127 | 0 | case CK_BuiltinFnToFnPtr: |
1128 | 0 | llvm_unreachable("builtin functions are handled elsewhere"); |
1129 | |
|
1130 | 39 | case CK_ReinterpretMemberPointer: |
1131 | 41 | case CK_DerivedToBaseMemberPointer: |
1132 | 52 | case CK_BaseToDerivedMemberPointer: { |
1133 | 52 | auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType()); |
1134 | 52 | if (!C) return nullptr0 ; |
1135 | 52 | return CGM.getCXXABI().EmitMemberPointerConversion(E, C); |
1136 | 52 | } |
1137 | | |
1138 | | // These will never be supported. |
1139 | 0 | case CK_ObjCObjectLValueCast: |
1140 | 0 | case CK_ARCProduceObject: |
1141 | 3 | case CK_ARCConsumeObject: |
1142 | 34 | case CK_ARCReclaimReturnedObject: |
1143 | 34 | case CK_ARCExtendBlockObject: |
1144 | 34 | case CK_CopyAndAutoreleaseBlockObject: |
1145 | 34 | return nullptr; |
1146 | | |
1147 | | // These don't need to be handled here because Evaluate knows how to |
1148 | | // evaluate them in the cases where they can be folded. |
1149 | 70 | case CK_BitCast: |
1150 | 70 | case CK_ToVoid: |
1151 | 70 | case CK_Dynamic: |
1152 | 70 | case CK_LValueBitCast: |
1153 | 70 | case CK_LValueToRValueBitCast: |
1154 | 71 | case CK_NullToMemberPointer: |
1155 | 120 | case CK_UserDefinedConversion: |
1156 | 123 | case CK_CPointerToObjCPointerCast: |
1157 | 123 | case CK_BlockPointerToObjCPointerCast: |
1158 | 123 | case CK_AnyPointerToBlockPointerCast: |
1159 | 125 | case CK_ArrayToPointerDecay: |
1160 | 125 | case CK_FunctionToPointerDecay: |
1161 | 125 | case CK_BaseToDerived: |
1162 | 137 | case CK_DerivedToBase: |
1163 | 137 | case CK_UncheckedDerivedToBase: |
1164 | 137 | case CK_MemberPointerToBoolean: |
1165 | 137 | case CK_VectorSplat: |
1166 | 137 | case CK_FloatingRealToComplex: |
1167 | 137 | case CK_FloatingComplexToReal: |
1168 | 137 | case CK_FloatingComplexToBoolean: |
1169 | 137 | case CK_FloatingComplexCast: |
1170 | 137 | case CK_FloatingComplexToIntegralComplex: |
1171 | 137 | case CK_IntegralRealToComplex: |
1172 | 137 | case CK_IntegralComplexToReal: |
1173 | 137 | case CK_IntegralComplexToBoolean: |
1174 | 137 | case CK_IntegralComplexCast: |
1175 | 137 | case CK_IntegralComplexToFloatingComplex: |
1176 | 142 | case CK_PointerToIntegral: |
1177 | 142 | case CK_PointerToBoolean: |
1178 | 144 | case CK_NullToPointer: |
1179 | 347 | case CK_IntegralCast: |
1180 | 347 | case CK_BooleanToSignedIntegral: |
1181 | 350 | case CK_IntegralToPointer: |
1182 | 350 | case CK_IntegralToBoolean: |
1183 | 355 | case CK_IntegralToFloating: |
1184 | 357 | case CK_FloatingToIntegral: |
1185 | 357 | case CK_FloatingToBoolean: |
1186 | 357 | case CK_FloatingCast: |
1187 | 357 | case CK_FloatingToFixedPoint: |
1188 | 357 | case CK_FixedPointToFloating: |
1189 | 357 | case CK_FixedPointCast: |
1190 | 357 | case CK_FixedPointToBoolean: |
1191 | 357 | case CK_FixedPointToIntegral: |
1192 | 357 | case CK_IntegralToFixedPoint: |
1193 | 357 | case CK_ZeroToOCLOpaqueType: |
1194 | 357 | case CK_MatrixCast: |
1195 | 357 | return nullptr; |
1196 | 8.38k | } |
1197 | 0 | llvm_unreachable("Invalid CastKind"); |
1198 | 0 | } |
1199 | | |
1200 | 4 | llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) { |
1201 | | // No need for a DefaultInitExprScope: we don't handle 'this' in a |
1202 | | // constant expression. |
1203 | 4 | return Visit(DIE->getExpr(), T); |
1204 | 4 | } |
1205 | | |
1206 | 693 | llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E, QualType T) { |
1207 | 693 | return Visit(E->getSubExpr(), T); |
1208 | 693 | } |
1209 | | |
1210 | | llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E, |
1211 | 175 | QualType T) { |
1212 | 175 | return Visit(E->getSubExpr(), T); |
1213 | 175 | } |
1214 | | |
1215 | 1.11k | llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) { |
1216 | 1.11k | auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType()); |
1217 | 1.11k | assert(CAT && "can't emit array init for non-constant-bound array"); |
1218 | 0 | unsigned NumInitElements = ILE->getNumInits(); |
1219 | 1.11k | unsigned NumElements = CAT->getSize().getZExtValue(); |
1220 | | |
1221 | | // Initialising an array requires us to automatically |
1222 | | // initialise any elements that have not been initialised explicitly |
1223 | 1.11k | unsigned NumInitableElts = std::min(NumInitElements, NumElements); |
1224 | | |
1225 | 1.11k | QualType EltType = CAT->getElementType(); |
1226 | | |
1227 | | // Initialize remaining array elements. |
1228 | 1.11k | llvm::Constant *fillC = nullptr; |
1229 | 1.11k | if (Expr *filler = ILE->getArrayFiller()) { |
1230 | 153 | fillC = Emitter.tryEmitAbstractForMemory(filler, EltType); |
1231 | 153 | if (!fillC) |
1232 | 11 | return nullptr; |
1233 | 153 | } |
1234 | | |
1235 | | // Copy initializer elements. |
1236 | 1.10k | SmallVector<llvm::Constant*, 16> Elts; |
1237 | 1.10k | if (fillC && fillC->isNullValue()142 ) |
1238 | 142 | Elts.reserve(NumInitableElts + 1); |
1239 | 960 | else |
1240 | 960 | Elts.reserve(NumElements); |
1241 | | |
1242 | 1.10k | llvm::Type *CommonElementType = nullptr; |
1243 | 6.48k | for (unsigned i = 0; i < NumInitableElts; ++i5.37k ) { |
1244 | 5.76k | Expr *Init = ILE->getInit(i); |
1245 | 5.76k | llvm::Constant *C = Emitter.tryEmitPrivateForMemory(Init, EltType); |
1246 | 5.76k | if (!C) |
1247 | 387 | return nullptr; |
1248 | 5.37k | if (i == 0) |
1249 | 697 | CommonElementType = C->getType(); |
1250 | 4.68k | else if (C->getType() != CommonElementType) |
1251 | 4 | CommonElementType = nullptr; |
1252 | 5.37k | Elts.push_back(C); |
1253 | 5.37k | } |
1254 | | |
1255 | 715 | llvm::ArrayType *Desired = |
1256 | 715 | cast<llvm::ArrayType>(CGM.getTypes().ConvertType(ILE->getType())); |
1257 | 715 | return EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts, |
1258 | 715 | fillC); |
1259 | 1.10k | } |
1260 | | |
1261 | 2.32k | llvm::Constant *EmitRecordInitialization(InitListExpr *ILE, QualType T) { |
1262 | 2.32k | return ConstStructBuilder::BuildStruct(Emitter, ILE, T); |
1263 | 2.32k | } |
1264 | | |
1265 | | llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E, |
1266 | 54 | QualType T) { |
1267 | 54 | return CGM.EmitNullConstant(T); |
1268 | 54 | } |
1269 | | |
1270 | 3.45k | llvm::Constant *VisitInitListExpr(InitListExpr *ILE, QualType T) { |
1271 | 3.45k | if (ILE->isTransparent()) |
1272 | 18 | return Visit(ILE->getInit(0), T); |
1273 | | |
1274 | 3.43k | if (ILE->getType()->isArrayType()) |
1275 | 1.11k | return EmitArrayInitialization(ILE, T); |
1276 | | |
1277 | 2.32k | if (ILE->getType()->isRecordType()) |
1278 | 2.32k | return EmitRecordInitialization(ILE, T); |
1279 | | |
1280 | 0 | return nullptr; |
1281 | 2.32k | } |
1282 | | |
1283 | | llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E, |
1284 | 28 | QualType destType) { |
1285 | 28 | auto C = Visit(E->getBase(), destType); |
1286 | 28 | if (!C) |
1287 | 0 | return nullptr; |
1288 | | |
1289 | 28 | ConstantAggregateBuilder Const(CGM); |
1290 | 28 | Const.add(C, CharUnits::Zero(), false); |
1291 | | |
1292 | 28 | if (!EmitDesignatedInitUpdater(Emitter, Const, CharUnits::Zero(), destType, |
1293 | 28 | E->getUpdater())) |
1294 | 0 | return nullptr; |
1295 | | |
1296 | 28 | llvm::Type *ValTy = CGM.getTypes().ConvertType(destType); |
1297 | 28 | bool HasFlexibleArray = false; |
1298 | 28 | if (auto *RT = destType->getAs<RecordType>()) |
1299 | 20 | HasFlexibleArray = RT->getDecl()->hasFlexibleArrayMember(); |
1300 | 28 | return Const.build(ValTy, HasFlexibleArray); |
1301 | 28 | } |
1302 | | |
1303 | 5.02k | llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E, QualType Ty) { |
1304 | 5.02k | if (!E->getConstructor()->isTrivial()) |
1305 | 4.80k | return nullptr; |
1306 | | |
1307 | | // Only default and copy/move constructors can be trivial. |
1308 | 222 | if (E->getNumArgs()) { |
1309 | 220 | assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument"); |
1310 | 0 | assert(E->getConstructor()->isCopyOrMoveConstructor() && |
1311 | 220 | "trivial ctor has argument but isn't a copy/move ctor"); |
1312 | | |
1313 | 0 | Expr *Arg = E->getArg(0); |
1314 | 220 | assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) && |
1315 | 220 | "argument to copy ctor is of wrong type"); |
1316 | | |
1317 | 0 | return Visit(Arg, Ty); |
1318 | 220 | } |
1319 | | |
1320 | 2 | return CGM.EmitNullConstant(Ty); |
1321 | 222 | } |
1322 | | |
1323 | 99 | llvm::Constant *VisitStringLiteral(StringLiteral *E, QualType T) { |
1324 | | // This is a string literal initializing an array in an initializer. |
1325 | 99 | return CGM.GetConstantArrayFromStringLiteral(E); |
1326 | 99 | } |
1327 | | |
1328 | 64 | llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E, QualType T) { |
1329 | | // This must be an @encode initializing an array in a static initializer. |
1330 | | // Don't emit it as the address of the string, emit the string data itself |
1331 | | // as an inline array. |
1332 | 64 | std::string Str; |
1333 | 64 | CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); |
1334 | 64 | const ConstantArrayType *CAT = CGM.getContext().getAsConstantArrayType(T); |
1335 | | |
1336 | | // Resize the string to the right size, adding zeros at the end, or |
1337 | | // truncating as needed. |
1338 | 64 | Str.resize(CAT->getSize().getZExtValue(), '\0'); |
1339 | 64 | return llvm::ConstantDataArray::getString(VMContext, Str, false); |
1340 | 64 | } |
1341 | | |
1342 | 1 | llvm::Constant *VisitUnaryExtension(const UnaryOperator *E, QualType T) { |
1343 | 1 | return Visit(E->getSubExpr(), T); |
1344 | 1 | } |
1345 | | |
1346 | | // Utility methods |
1347 | 4 | llvm::Type *ConvertType(QualType T) { |
1348 | 4 | return CGM.getTypes().ConvertType(T); |
1349 | 4 | } |
1350 | | }; |
1351 | | |
1352 | | } // end anonymous namespace. |
1353 | | |
1354 | | llvm::Constant *ConstantEmitter::validateAndPopAbstract(llvm::Constant *C, |
1355 | 28.7k | AbstractState saved) { |
1356 | 28.7k | Abstract = saved.OldValue; |
1357 | | |
1358 | 28.7k | assert(saved.OldPlaceholdersSize == PlaceholderAddresses.size() && |
1359 | 28.7k | "created a placeholder while doing an abstract emission?"); |
1360 | | |
1361 | | // No validation necessary for now. |
1362 | | // No cleanup to do for now. |
1363 | 0 | return C; |
1364 | 28.7k | } |
1365 | | |
1366 | | llvm::Constant * |
1367 | 19.9k | ConstantEmitter::tryEmitAbstractForInitializer(const VarDecl &D) { |
1368 | 19.9k | auto state = pushAbstract(); |
1369 | 19.9k | auto C = tryEmitPrivateForVarInit(D); |
1370 | 19.9k | return validateAndPopAbstract(C, state); |
1371 | 19.9k | } |
1372 | | |
1373 | | llvm::Constant * |
1374 | 577 | ConstantEmitter::tryEmitAbstract(const Expr *E, QualType destType) { |
1375 | 577 | auto state = pushAbstract(); |
1376 | 577 | auto C = tryEmitPrivate(E, destType); |
1377 | 577 | return validateAndPopAbstract(C, state); |
1378 | 577 | } |
1379 | | |
1380 | | llvm::Constant * |
1381 | 690 | ConstantEmitter::tryEmitAbstract(const APValue &value, QualType destType) { |
1382 | 690 | auto state = pushAbstract(); |
1383 | 690 | auto C = tryEmitPrivate(value, destType); |
1384 | 690 | return validateAndPopAbstract(C, state); |
1385 | 690 | } |
1386 | | |
1387 | 590 | llvm::Constant *ConstantEmitter::tryEmitConstantExpr(const ConstantExpr *CE) { |
1388 | 590 | if (!CE->hasAPValueResult()) |
1389 | 19 | return nullptr; |
1390 | 571 | const Expr *Inner = CE->getSubExpr()->IgnoreImplicit(); |
1391 | 571 | QualType RetType; |
1392 | 571 | if (auto *Call = dyn_cast<CallExpr>(Inner)) |
1393 | 17 | RetType = Call->getCallReturnType(CGM.getContext()); |
1394 | 554 | else if (auto *Ctor = dyn_cast<CXXConstructExpr>(Inner)) |
1395 | 1 | RetType = Ctor->getType(); |
1396 | 571 | llvm::Constant *Res = |
1397 | 571 | emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(), RetType); |
1398 | 571 | return Res; |
1399 | 590 | } |
1400 | | |
1401 | | llvm::Constant * |
1402 | 283 | ConstantEmitter::emitAbstract(const Expr *E, QualType destType) { |
1403 | 283 | auto state = pushAbstract(); |
1404 | 283 | auto C = tryEmitPrivate(E, destType); |
1405 | 283 | C = validateAndPopAbstract(C, state); |
1406 | 283 | if (!C) { |
1407 | 0 | CGM.Error(E->getExprLoc(), |
1408 | 0 | "internal error: could not emit constant value \"abstractly\""); |
1409 | 0 | C = CGM.EmitNullConstant(destType); |
1410 | 0 | } |
1411 | 283 | return C; |
1412 | 283 | } |
1413 | | |
1414 | | llvm::Constant * |
1415 | | ConstantEmitter::emitAbstract(SourceLocation loc, const APValue &value, |
1416 | 7.22k | QualType destType) { |
1417 | 7.22k | auto state = pushAbstract(); |
1418 | 7.22k | auto C = tryEmitPrivate(value, destType); |
1419 | 7.22k | C = validateAndPopAbstract(C, state); |
1420 | 7.22k | if (!C) { |
1421 | 0 | CGM.Error(loc, |
1422 | 0 | "internal error: could not emit constant value \"abstractly\""); |
1423 | 0 | C = CGM.EmitNullConstant(destType); |
1424 | 0 | } |
1425 | 7.22k | return C; |
1426 | 7.22k | } |
1427 | | |
1428 | 26.6k | llvm::Constant *ConstantEmitter::tryEmitForInitializer(const VarDecl &D) { |
1429 | 26.6k | initializeNonAbstract(D.getType().getAddressSpace()); |
1430 | 26.6k | return markIfFailed(tryEmitPrivateForVarInit(D)); |
1431 | 26.6k | } |
1432 | | |
1433 | | llvm::Constant *ConstantEmitter::tryEmitForInitializer(const Expr *E, |
1434 | | LangAS destAddrSpace, |
1435 | 108 | QualType destType) { |
1436 | 108 | initializeNonAbstract(destAddrSpace); |
1437 | 108 | return markIfFailed(tryEmitPrivateForMemory(E, destType)); |
1438 | 108 | } |
1439 | | |
1440 | | llvm::Constant *ConstantEmitter::emitForInitializer(const APValue &value, |
1441 | | LangAS destAddrSpace, |
1442 | 196 | QualType destType) { |
1443 | 196 | initializeNonAbstract(destAddrSpace); |
1444 | 196 | auto C = tryEmitPrivateForMemory(value, destType); |
1445 | 196 | assert(C && "couldn't emit constant value non-abstractly?"); |
1446 | 0 | return C; |
1447 | 196 | } |
1448 | | |
1449 | 0 | llvm::GlobalValue *ConstantEmitter::getCurrentAddrPrivate() { |
1450 | 0 | assert(!Abstract && "cannot get current address for abstract constant"); |
1451 | | |
1452 | | |
1453 | | |
1454 | | // Make an obviously ill-formed global that should blow up compilation |
1455 | | // if it survives. |
1456 | 0 | auto global = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty, true, |
1457 | 0 | llvm::GlobalValue::PrivateLinkage, |
1458 | 0 | /*init*/ nullptr, |
1459 | 0 | /*name*/ "", |
1460 | 0 | /*before*/ nullptr, |
1461 | 0 | llvm::GlobalVariable::NotThreadLocal, |
1462 | 0 | CGM.getContext().getTargetAddressSpace(DestAddressSpace)); |
1463 | |
|
1464 | 0 | PlaceholderAddresses.push_back(std::make_pair(nullptr, global)); |
1465 | |
|
1466 | 0 | return global; |
1467 | 0 | } |
1468 | | |
1469 | | void ConstantEmitter::registerCurrentAddrPrivate(llvm::Constant *signal, |
1470 | 0 | llvm::GlobalValue *placeholder) { |
1471 | 0 | assert(!PlaceholderAddresses.empty()); |
1472 | 0 | assert(PlaceholderAddresses.back().first == nullptr); |
1473 | 0 | assert(PlaceholderAddresses.back().second == placeholder); |
1474 | 0 | PlaceholderAddresses.back().first = signal; |
1475 | 0 | } |
1476 | | |
1477 | | namespace { |
1478 | | struct ReplacePlaceholders { |
1479 | | CodeGenModule &CGM; |
1480 | | |
1481 | | /// The base address of the global. |
1482 | | llvm::Constant *Base; |
1483 | | llvm::Type *BaseValueTy = nullptr; |
1484 | | |
1485 | | /// The placeholder addresses that were registered during emission. |
1486 | | llvm::DenseMap<llvm::Constant*, llvm::GlobalVariable*> PlaceholderAddresses; |
1487 | | |
1488 | | /// The locations of the placeholder signals. |
1489 | | llvm::DenseMap<llvm::GlobalVariable*, llvm::Constant*> Locations; |
1490 | | |
1491 | | /// The current index stack. We use a simple unsigned stack because |
1492 | | /// we assume that placeholders will be relatively sparse in the |
1493 | | /// initializer, but we cache the index values we find just in case. |
1494 | | llvm::SmallVector<unsigned, 8> Indices; |
1495 | | llvm::SmallVector<llvm::Constant*, 8> IndexValues; |
1496 | | |
1497 | | ReplacePlaceholders(CodeGenModule &CGM, llvm::Constant *base, |
1498 | | ArrayRef<std::pair<llvm::Constant*, |
1499 | | llvm::GlobalVariable*>> addresses) |
1500 | | : CGM(CGM), Base(base), |
1501 | 0 | PlaceholderAddresses(addresses.begin(), addresses.end()) { |
1502 | 0 | } |
1503 | | |
1504 | 0 | void replaceInInitializer(llvm::Constant *init) { |
1505 | | // Remember the type of the top-most initializer. |
1506 | 0 | BaseValueTy = init->getType(); |
1507 | | |
1508 | | // Initialize the stack. |
1509 | 0 | Indices.push_back(0); |
1510 | 0 | IndexValues.push_back(nullptr); |
1511 | | |
1512 | | // Recurse into the initializer. |
1513 | 0 | findLocations(init); |
1514 | | |
1515 | | // Check invariants. |
1516 | 0 | assert(IndexValues.size() == Indices.size() && "mismatch"); |
1517 | 0 | assert(Indices.size() == 1 && "didn't pop all indices"); |
1518 | | |
1519 | | // Do the replacement; this basically invalidates 'init'. |
1520 | 0 | assert(Locations.size() == PlaceholderAddresses.size() && |
1521 | 0 | "missed a placeholder?"); |
1522 | | |
1523 | | // We're iterating over a hashtable, so this would be a source of |
1524 | | // non-determinism in compiler output *except* that we're just |
1525 | | // messing around with llvm::Constant structures, which never itself |
1526 | | // does anything that should be visible in compiler output. |
1527 | 0 | for (auto &entry : Locations) { |
1528 | 0 | assert(entry.first->getParent() == nullptr && "not a placeholder!"); |
1529 | 0 | entry.first->replaceAllUsesWith(entry.second); |
1530 | 0 | entry.first->eraseFromParent(); |
1531 | 0 | } |
1532 | 0 | } |
1533 | | |
1534 | | private: |
1535 | 0 | void findLocations(llvm::Constant *init) { |
1536 | | // Recurse into aggregates. |
1537 | 0 | if (auto agg = dyn_cast<llvm::ConstantAggregate>(init)) { |
1538 | 0 | for (unsigned i = 0, e = agg->getNumOperands(); i != e; ++i) { |
1539 | 0 | Indices.push_back(i); |
1540 | 0 | IndexValues.push_back(nullptr); |
1541 | |
|
1542 | 0 | findLocations(agg->getOperand(i)); |
1543 | |
|
1544 | 0 | IndexValues.pop_back(); |
1545 | 0 | Indices.pop_back(); |
1546 | 0 | } |
1547 | 0 | return; |
1548 | 0 | } |
1549 | | |
1550 | | // Otherwise, check for registered constants. |
1551 | 0 | while (true) { |
1552 | 0 | auto it = PlaceholderAddresses.find(init); |
1553 | 0 | if (it != PlaceholderAddresses.end()) { |
1554 | 0 | setLocation(it->second); |
1555 | 0 | break; |
1556 | 0 | } |
1557 | | |
1558 | | // Look through bitcasts or other expressions. |
1559 | 0 | if (auto expr = dyn_cast<llvm::ConstantExpr>(init)) { |
1560 | 0 | init = expr->getOperand(0); |
1561 | 0 | } else { |
1562 | 0 | break; |
1563 | 0 | } |
1564 | 0 | } |
1565 | 0 | } |
1566 | | |
1567 | 0 | void setLocation(llvm::GlobalVariable *placeholder) { |
1568 | 0 | assert(Locations.find(placeholder) == Locations.end() && |
1569 | 0 | "already found location for placeholder!"); |
1570 | | |
1571 | | // Lazily fill in IndexValues with the values from Indices. |
1572 | | // We do this in reverse because we should always have a strict |
1573 | | // prefix of indices from the start. |
1574 | 0 | assert(Indices.size() == IndexValues.size()); |
1575 | 0 | for (size_t i = Indices.size() - 1; i != size_t(-1); --i) { |
1576 | 0 | if (IndexValues[i]) { |
1577 | 0 | #ifndef NDEBUG |
1578 | 0 | for (size_t j = 0; j != i + 1; ++j) { |
1579 | 0 | assert(IndexValues[j] && |
1580 | 0 | isa<llvm::ConstantInt>(IndexValues[j]) && |
1581 | 0 | cast<llvm::ConstantInt>(IndexValues[j])->getZExtValue() |
1582 | 0 | == Indices[j]); |
1583 | 0 | } |
1584 | 0 | #endif |
1585 | 0 | break; |
1586 | 0 | } |
1587 | | |
1588 | 0 | IndexValues[i] = llvm::ConstantInt::get(CGM.Int32Ty, Indices[i]); |
1589 | 0 | } |
1590 | | |
1591 | | // Form a GEP and then bitcast to the placeholder type so that the |
1592 | | // replacement will succeed. |
1593 | 0 | llvm::Constant *location = |
1594 | 0 | llvm::ConstantExpr::getInBoundsGetElementPtr(BaseValueTy, |
1595 | 0 | Base, IndexValues); |
1596 | 0 | location = llvm::ConstantExpr::getBitCast(location, |
1597 | 0 | placeholder->getType()); |
1598 | |
|
1599 | 0 | Locations.insert({placeholder, location}); |
1600 | 0 | } |
1601 | | }; |
1602 | | } |
1603 | | |
1604 | 18.0k | void ConstantEmitter::finalize(llvm::GlobalVariable *global) { |
1605 | 18.0k | assert(InitializedNonAbstract && |
1606 | 18.0k | "finalizing emitter that was used for abstract emission?"); |
1607 | 0 | assert(!Finalized && "finalizing emitter multiple times"); |
1608 | 0 | assert(global->getInitializer()); |
1609 | | |
1610 | | // Note that we might also be Failed. |
1611 | 0 | Finalized = true; |
1612 | | |
1613 | 18.0k | if (!PlaceholderAddresses.empty()) { |
1614 | 0 | ReplacePlaceholders(CGM, global, PlaceholderAddresses) |
1615 | 0 | .replaceInInitializer(global->getInitializer()); |
1616 | 0 | PlaceholderAddresses.clear(); // satisfy |
1617 | 0 | } |
1618 | 18.0k | } |
1619 | | |
1620 | 54.8k | ConstantEmitter::~ConstantEmitter() { |
1621 | 54.8k | assert((!InitializedNonAbstract || Finalized || Failed) && |
1622 | 54.8k | "not finalized after being initialized for non-abstract emission"); |
1623 | 0 | assert(PlaceholderAddresses.empty() && "unhandled placeholders"); |
1624 | 54.8k | } |
1625 | | |
1626 | 69.2k | static QualType getNonMemoryType(CodeGenModule &CGM, QualType type) { |
1627 | 69.2k | if (auto AT = type->getAs<AtomicType>()) { |
1628 | 101 | return CGM.getContext().getQualifiedType(AT->getValueType(), |
1629 | 101 | type.getQualifiers()); |
1630 | 101 | } |
1631 | 69.1k | return type; |
1632 | 69.2k | } |
1633 | | |
1634 | 46.5k | llvm::Constant *ConstantEmitter::tryEmitPrivateForVarInit(const VarDecl &D) { |
1635 | | // Make a quick check if variable can be default NULL initialized |
1636 | | // and avoid going through rest of code which may do, for c++11, |
1637 | | // initialization of memory to all NULLs. |
1638 | 46.5k | if (!D.hasLocalStorage()) { |
1639 | 26.6k | QualType Ty = CGM.getContext().getBaseElementType(D.getType()); |
1640 | 26.6k | if (Ty->isRecordType()) |
1641 | 7.41k | if (const CXXConstructExpr *E = |
1642 | 7.41k | dyn_cast_or_null<CXXConstructExpr>(D.getInit())) { |
1643 | 6.30k | const CXXConstructorDecl *CD = E->getConstructor(); |
1644 | 6.30k | if (CD->isTrivial() && CD->isDefaultConstructor()1.32k ) |
1645 | 1.29k | return CGM.EmitNullConstant(D.getType()); |
1646 | 6.30k | } |
1647 | 26.6k | } |
1648 | 45.3k | InConstantContext = D.hasConstantInitialization(); |
1649 | | |
1650 | 45.3k | QualType destType = D.getType(); |
1651 | | |
1652 | | // Try to emit the initializer. Note that this can allow some things that |
1653 | | // are not allowed by tryEmitPrivateForMemory alone. |
1654 | 45.3k | if (auto value = D.evaluateValue()) { |
1655 | 13.8k | return tryEmitPrivateForMemory(*value, destType); |
1656 | 13.8k | } |
1657 | | |
1658 | | // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a |
1659 | | // reference is a constant expression, and the reference binds to a temporary, |
1660 | | // then constant initialization is performed. ConstExprEmitter will |
1661 | | // incorrectly emit a prvalue constant in this case, and the calling code |
1662 | | // interprets that as the (pointer) value of the reference, rather than the |
1663 | | // desired value of the referee. |
1664 | 31.4k | if (destType->isReferenceType()) |
1665 | 3.46k | return nullptr; |
1666 | | |
1667 | 27.9k | const Expr *E = D.getInit(); |
1668 | 27.9k | assert(E && "No initializer to emit"); |
1669 | | |
1670 | 0 | auto nonMemoryDestType = getNonMemoryType(CGM, destType); |
1671 | 27.9k | auto C = |
1672 | 27.9k | ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), nonMemoryDestType); |
1673 | 27.9k | return (C ? emitForMemory(C, destType)2.19k : nullptr25.7k ); |
1674 | 31.4k | } |
1675 | | |
1676 | | llvm::Constant * |
1677 | 156 | ConstantEmitter::tryEmitAbstractForMemory(const Expr *E, QualType destType) { |
1678 | 156 | auto nonMemoryDestType = getNonMemoryType(CGM, destType); |
1679 | 156 | auto C = tryEmitAbstract(E, nonMemoryDestType); |
1680 | 156 | return (C ? emitForMemory(C, destType)145 : nullptr11 ); |
1681 | 156 | } |
1682 | | |
1683 | | llvm::Constant * |
1684 | | ConstantEmitter::tryEmitAbstractForMemory(const APValue &value, |
1685 | 690 | QualType destType) { |
1686 | 690 | auto nonMemoryDestType = getNonMemoryType(CGM, destType); |
1687 | 690 | auto C = tryEmitAbstract(value, nonMemoryDestType); |
1688 | 690 | return (C ? emitForMemory(C, destType) : nullptr0 ); |
1689 | 690 | } |
1690 | | |
1691 | | llvm::Constant *ConstantEmitter::tryEmitPrivateForMemory(const Expr *E, |
1692 | 10.9k | QualType destType) { |
1693 | 10.9k | auto nonMemoryDestType = getNonMemoryType(CGM, destType); |
1694 | 10.9k | llvm::Constant *C = tryEmitPrivate(E, nonMemoryDestType); |
1695 | 10.9k | return (C ? emitForMemory(C, destType)10.4k : nullptr473 ); |
1696 | 10.9k | } |
1697 | | |
1698 | | llvm::Constant *ConstantEmitter::tryEmitPrivateForMemory(const APValue &value, |
1699 | 29.6k | QualType destType) { |
1700 | 29.6k | auto nonMemoryDestType = getNonMemoryType(CGM, destType); |
1701 | 29.6k | auto C = tryEmitPrivate(value, nonMemoryDestType); |
1702 | 29.6k | return (C ? emitForMemory(C, destType) : nullptr0 ); |
1703 | 29.6k | } |
1704 | | |
1705 | | llvm::Constant *ConstantEmitter::emitForMemory(CodeGenModule &CGM, |
1706 | | llvm::Constant *C, |
1707 | 43.2k | QualType destType) { |
1708 | | // For an _Atomic-qualified constant, we may need to add tail padding. |
1709 | 43.2k | if (auto AT = destType->getAs<AtomicType>()) { |
1710 | 97 | QualType destValueType = AT->getValueType(); |
1711 | 97 | C = emitForMemory(CGM, C, destValueType); |
1712 | | |
1713 | 97 | uint64_t innerSize = CGM.getContext().getTypeSize(destValueType); |
1714 | 97 | uint64_t outerSize = CGM.getContext().getTypeSize(destType); |
1715 | 97 | if (innerSize == outerSize) |
1716 | 96 | return C; |
1717 | | |
1718 | 1 | assert(innerSize < outerSize && "emitted over-large constant for atomic"); |
1719 | 0 | llvm::Constant *elts[] = { |
1720 | 1 | C, |
1721 | 1 | llvm::ConstantAggregateZero::get( |
1722 | 1 | llvm::ArrayType::get(CGM.Int8Ty, (outerSize - innerSize) / 8)) |
1723 | 1 | }; |
1724 | 1 | return llvm::ConstantStruct::getAnon(elts); |
1725 | 97 | } |
1726 | | |
1727 | | // Zero-extend bool. |
1728 | 43.1k | if (C->getType()->isIntegerTy(1)) { |
1729 | 389 | llvm::Type *boolTy = CGM.getTypes().ConvertTypeForMem(destType); |
1730 | 389 | return llvm::ConstantExpr::getZExt(C, boolTy); |
1731 | 389 | } |
1732 | | |
1733 | 42.7k | return C; |
1734 | 43.1k | } |
1735 | | |
1736 | | llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E, |
1737 | 11.8k | QualType destType) { |
1738 | 11.8k | assert(!destType->isVoidType() && "can't emit a void constant"); |
1739 | | |
1740 | 0 | Expr::EvalResult Result; |
1741 | | |
1742 | 11.8k | bool Success = false; |
1743 | | |
1744 | 11.8k | if (destType->isReferenceType()) |
1745 | 11 | Success = E->EvaluateAsLValue(Result, CGM.getContext()); |
1746 | 11.8k | else |
1747 | 11.8k | Success = E->EvaluateAsRValue(Result, CGM.getContext(), InConstantContext); |
1748 | | |
1749 | 11.8k | llvm::Constant *C; |
1750 | 11.8k | if (Success && !Result.HasSideEffects10.1k ) |
1751 | 10.1k | C = tryEmitPrivate(Result.Val, destType); |
1752 | 1.70k | else |
1753 | 1.70k | C = ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), destType); |
1754 | | |
1755 | 11.8k | return C; |
1756 | 11.8k | } |
1757 | | |
1758 | 35.4k | llvm::Constant *CodeGenModule::getNullPointer(llvm::PointerType *T, QualType QT) { |
1759 | 35.4k | return getTargetCodeGenInfo().getNullPointer(*this, T, QT); |
1760 | 35.4k | } |
1761 | | |
1762 | | namespace { |
1763 | | /// A struct which can be used to peephole certain kinds of finalization |
1764 | | /// that normally happen during l-value emission. |
1765 | | struct ConstantLValue { |
1766 | | llvm::Constant *Value; |
1767 | | bool HasOffsetApplied; |
1768 | | |
1769 | | /*implicit*/ ConstantLValue(llvm::Constant *value, |
1770 | | bool hasOffsetApplied = false) |
1771 | 5.56k | : Value(value), HasOffsetApplied(hasOffsetApplied) {} |
1772 | | |
1773 | | /*implicit*/ ConstantLValue(ConstantAddress address) |
1774 | 2.09k | : ConstantLValue(address.getPointer()) {} |
1775 | | }; |
1776 | | |
1777 | | /// A helper class for emitting constant l-values. |
1778 | | class ConstantLValueEmitter : public ConstStmtVisitor<ConstantLValueEmitter, |
1779 | | ConstantLValue> { |
1780 | | CodeGenModule &CGM; |
1781 | | ConstantEmitter &Emitter; |
1782 | | const APValue &Value; |
1783 | | QualType DestType; |
1784 | | |
1785 | | // Befriend StmtVisitorBase so that we don't have to expose Visit*. |
1786 | | friend StmtVisitorBase; |
1787 | | |
1788 | | public: |
1789 | | ConstantLValueEmitter(ConstantEmitter &emitter, const APValue &value, |
1790 | | QualType destType) |
1791 | 6.25k | : CGM(emitter.CGM), Emitter(emitter), Value(value), DestType(destType) {} |
1792 | | |
1793 | | llvm::Constant *tryEmit(); |
1794 | | |
1795 | | private: |
1796 | | llvm::Constant *tryEmitAbsolute(llvm::Type *destTy); |
1797 | | ConstantLValue tryEmitBase(const APValue::LValueBase &base); |
1798 | | |
1799 | 0 | ConstantLValue VisitStmt(const Stmt *S) { return nullptr; } |
1800 | | ConstantLValue VisitConstantExpr(const ConstantExpr *E); |
1801 | | ConstantLValue VisitCompoundLiteralExpr(const CompoundLiteralExpr *E); |
1802 | | ConstantLValue VisitStringLiteral(const StringLiteral *E); |
1803 | | ConstantLValue VisitObjCBoxedExpr(const ObjCBoxedExpr *E); |
1804 | | ConstantLValue VisitObjCEncodeExpr(const ObjCEncodeExpr *E); |
1805 | | ConstantLValue VisitObjCStringLiteral(const ObjCStringLiteral *E); |
1806 | | ConstantLValue VisitPredefinedExpr(const PredefinedExpr *E); |
1807 | | ConstantLValue VisitAddrLabelExpr(const AddrLabelExpr *E); |
1808 | | ConstantLValue VisitCallExpr(const CallExpr *E); |
1809 | | ConstantLValue VisitBlockExpr(const BlockExpr *E); |
1810 | | ConstantLValue VisitCXXTypeidExpr(const CXXTypeidExpr *E); |
1811 | | ConstantLValue VisitMaterializeTemporaryExpr( |
1812 | | const MaterializeTemporaryExpr *E); |
1813 | | |
1814 | 5.56k | bool hasNonZeroOffset() const { |
1815 | 5.56k | return !Value.getLValueOffset().isZero(); |
1816 | 5.56k | } |
1817 | | |
1818 | | /// Return the value offset. |
1819 | 252 | llvm::Constant *getOffset() { |
1820 | 252 | return llvm::ConstantInt::get(CGM.Int64Ty, |
1821 | 252 | Value.getLValueOffset().getQuantity()); |
1822 | 252 | } |
1823 | | |
1824 | | /// Apply the value offset to the given constant. |
1825 | 5.56k | llvm::Constant *applyOffset(llvm::Constant *C) { |
1826 | 5.56k | if (!hasNonZeroOffset()) |
1827 | 5.50k | return C; |
1828 | | |
1829 | 56 | llvm::Type *origPtrTy = C->getType(); |
1830 | 56 | unsigned AS = origPtrTy->getPointerAddressSpace(); |
1831 | 56 | llvm::Type *charPtrTy = CGM.Int8Ty->getPointerTo(AS); |
1832 | 56 | C = llvm::ConstantExpr::getBitCast(C, charPtrTy); |
1833 | 56 | C = llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, C, getOffset()); |
1834 | 56 | C = llvm::ConstantExpr::getPointerCast(C, origPtrTy); |
1835 | 56 | return C; |
1836 | 5.56k | } |
1837 | | }; |
1838 | | |
1839 | | } |
1840 | | |
1841 | 6.25k | llvm::Constant *ConstantLValueEmitter::tryEmit() { |
1842 | 6.25k | const APValue::LValueBase &base = Value.getLValueBase(); |
1843 | | |
1844 | | // The destination type should be a pointer or reference |
1845 | | // type, but it might also be a cast thereof. |
1846 | | // |
1847 | | // FIXME: the chain of casts required should be reflected in the APValue. |
1848 | | // We need this in order to correctly handle things like a ptrtoint of a |
1849 | | // non-zero null pointer and addrspace casts that aren't trivially |
1850 | | // represented in LLVM IR. |
1851 | 6.25k | auto destTy = CGM.getTypes().ConvertTypeForMem(DestType); |
1852 | 6.25k | assert(isa<llvm::IntegerType>(destTy) || isa<llvm::PointerType>(destTy)); |
1853 | | |
1854 | | // If there's no base at all, this is a null or absolute pointer, |
1855 | | // possibly cast back to an integer type. |
1856 | 6.25k | if (!base) { |
1857 | 689 | return tryEmitAbsolute(destTy); |
1858 | 689 | } |
1859 | | |
1860 | | // Otherwise, try to emit the base. |
1861 | 5.56k | ConstantLValue result = tryEmitBase(base); |
1862 | | |
1863 | | // If that failed, we're done. |
1864 | 5.56k | llvm::Constant *value = result.Value; |
1865 | 5.56k | if (!value) return nullptr0 ; |
1866 | | |
1867 | | // Apply the offset if necessary and not already done. |
1868 | 5.56k | if (!result.HasOffsetApplied) { |
1869 | 5.56k | value = applyOffset(value); |
1870 | 5.56k | } |
1871 | | |
1872 | | // Convert to the appropriate type; this could be an lvalue for |
1873 | | // an integer. FIXME: performAddrSpaceCast |
1874 | 5.56k | if (isa<llvm::PointerType>(destTy)) |
1875 | 5.54k | return llvm::ConstantExpr::getPointerCast(value, destTy); |
1876 | | |
1877 | 19 | return llvm::ConstantExpr::getPtrToInt(value, destTy); |
1878 | 5.56k | } |
1879 | | |
1880 | | /// Try to emit an absolute l-value, such as a null pointer or an integer |
1881 | | /// bitcast to pointer type. |
1882 | | llvm::Constant * |
1883 | 689 | ConstantLValueEmitter::tryEmitAbsolute(llvm::Type *destTy) { |
1884 | | // If we're producing a pointer, this is easy. |
1885 | 689 | auto destPtrTy = cast<llvm::PointerType>(destTy); |
1886 | 689 | if (Value.isNullPointer()) { |
1887 | | // FIXME: integer offsets from non-zero null pointers. |
1888 | 493 | return CGM.getNullPointer(destPtrTy, DestType); |
1889 | 493 | } |
1890 | | |
1891 | | // Convert the integer to a pointer-sized integer before converting it |
1892 | | // to a pointer. |
1893 | | // FIXME: signedness depends on the original integer type. |
1894 | 196 | auto intptrTy = CGM.getDataLayout().getIntPtrType(destPtrTy); |
1895 | 196 | llvm::Constant *C; |
1896 | 196 | C = llvm::ConstantExpr::getIntegerCast(getOffset(), intptrTy, |
1897 | 196 | /*isSigned*/ false); |
1898 | 196 | C = llvm::ConstantExpr::getIntToPtr(C, destPtrTy); |
1899 | 196 | return C; |
1900 | 689 | } |
1901 | | |
1902 | | ConstantLValue |
1903 | 5.56k | ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) { |
1904 | | // Handle values. |
1905 | 5.56k | if (const ValueDecl *D = base.dyn_cast<const ValueDecl*>()) { |
1906 | | // The constant always points to the canonical declaration. We want to look |
1907 | | // at properties of the most recent declaration at the point of emission. |
1908 | 3.24k | D = cast<ValueDecl>(D->getMostRecentDecl()); |
1909 | | |
1910 | 3.24k | if (D->hasAttr<WeakRefAttr>()) |
1911 | 5 | return CGM.GetWeakRefReference(D).getPointer(); |
1912 | | |
1913 | 3.24k | if (auto FD = dyn_cast<FunctionDecl>(D)) |
1914 | 2.33k | return CGM.GetAddrOfFunction(FD); |
1915 | | |
1916 | 911 | if (auto VD = dyn_cast<VarDecl>(D)) { |
1917 | | // We can never refer to a variable with local storage. |
1918 | 833 | if (!VD->hasLocalStorage()) { |
1919 | 833 | if (VD->isFileVarDecl() || VD->hasExternalStorage()16 ) |
1920 | 818 | return CGM.GetAddrOfGlobalVar(VD); |
1921 | | |
1922 | 15 | if (VD->isLocalVarDecl()) { |
1923 | 15 | return CGM.getOrCreateStaticVarDecl( |
1924 | 15 | *VD, CGM.getLLVMLinkageVarDefinition(VD, /*IsConstant=*/false)); |
1925 | 15 | } |
1926 | 15 | } |
1927 | 833 | } |
1928 | | |
1929 | 78 | if (auto *GD = dyn_cast<MSGuidDecl>(D)) |
1930 | 36 | return CGM.GetAddrOfMSGuidDecl(GD); |
1931 | | |
1932 | 42 | if (auto *GCD = dyn_cast<UnnamedGlobalConstantDecl>(D)) |
1933 | 38 | return CGM.GetAddrOfUnnamedGlobalConstantDecl(GCD); |
1934 | | |
1935 | 4 | if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(D)) |
1936 | 4 | return CGM.GetAddrOfTemplateParamObject(TPO); |
1937 | | |
1938 | 0 | return nullptr; |
1939 | 4 | } |
1940 | | |
1941 | | // Handle typeid(T). |
1942 | 2.31k | if (TypeInfoLValue TI = base.dyn_cast<TypeInfoLValue>()) { |
1943 | 142 | llvm::Type *StdTypeInfoPtrTy = |
1944 | 142 | CGM.getTypes().ConvertType(base.getTypeInfoType())->getPointerTo(); |
1945 | 142 | llvm::Constant *TypeInfo = |
1946 | 142 | CGM.GetAddrOfRTTIDescriptor(QualType(TI.getType(), 0)); |
1947 | 142 | if (TypeInfo->getType() != StdTypeInfoPtrTy) |
1948 | 45 | TypeInfo = llvm::ConstantExpr::getBitCast(TypeInfo, StdTypeInfoPtrTy); |
1949 | 142 | return TypeInfo; |
1950 | 142 | } |
1951 | | |
1952 | | // Otherwise, it must be an expression. |
1953 | 2.17k | return Visit(base.get<const Expr*>()); |
1954 | 2.31k | } |
1955 | | |
1956 | | ConstantLValue |
1957 | 0 | ConstantLValueEmitter::VisitConstantExpr(const ConstantExpr *E) { |
1958 | 0 | if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(E)) |
1959 | 0 | return Result; |
1960 | 0 | return Visit(E->getSubExpr()); |
1961 | 0 | } |
1962 | | |
1963 | | ConstantLValue |
1964 | 20 | ConstantLValueEmitter::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { |
1965 | 20 | return tryEmitGlobalCompoundLiteral(CGM, Emitter.CGF, E); |
1966 | 20 | } |
1967 | | |
1968 | | ConstantLValue |
1969 | 1.15k | ConstantLValueEmitter::VisitStringLiteral(const StringLiteral *E) { |
1970 | 1.15k | return CGM.GetAddrOfConstantStringFromLiteral(E); |
1971 | 1.15k | } |
1972 | | |
1973 | | ConstantLValue |
1974 | 54 | ConstantLValueEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { |
1975 | 54 | return CGM.GetAddrOfConstantStringFromObjCEncode(E); |
1976 | 54 | } |
1977 | | |
1978 | | static ConstantLValue emitConstantObjCStringLiteral(const StringLiteral *S, |
1979 | | QualType T, |
1980 | 292 | CodeGenModule &CGM) { |
1981 | 292 | auto C = CGM.getObjCRuntime().GenerateConstantString(S); |
1982 | 292 | return C.getElementBitCast(CGM.getTypes().ConvertTypeForMem(T)); |
1983 | 292 | } |
1984 | | |
1985 | | ConstantLValue |
1986 | 289 | ConstantLValueEmitter::VisitObjCStringLiteral(const ObjCStringLiteral *E) { |
1987 | 289 | return emitConstantObjCStringLiteral(E->getString(), E->getType(), CGM); |
1988 | 289 | } |
1989 | | |
1990 | | ConstantLValue |
1991 | 3 | ConstantLValueEmitter::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) { |
1992 | 3 | assert(E->isExpressibleAsConstantInitializer() && |
1993 | 3 | "this boxed expression can't be emitted as a compile-time constant"); |
1994 | 0 | auto *SL = cast<StringLiteral>(E->getSubExpr()->IgnoreParenCasts()); |
1995 | 3 | return emitConstantObjCStringLiteral(SL, E->getType(), CGM); |
1996 | 3 | } |
1997 | | |
1998 | | ConstantLValue |
1999 | 3 | ConstantLValueEmitter::VisitPredefinedExpr(const PredefinedExpr *E) { |
2000 | 3 | return CGM.GetAddrOfConstantStringFromLiteral(E->getFunctionName()); |
2001 | 3 | } |
2002 | | |
2003 | | ConstantLValue |
2004 | 36 | ConstantLValueEmitter::VisitAddrLabelExpr(const AddrLabelExpr *E) { |
2005 | 36 | assert(Emitter.CGF && "Invalid address of label expression outside function"); |
2006 | 0 | llvm::Constant *Ptr = Emitter.CGF->GetAddrOfLabel(E->getLabel()); |
2007 | 36 | Ptr = llvm::ConstantExpr::getBitCast(Ptr, |
2008 | 36 | CGM.getTypes().ConvertType(E->getType())); |
2009 | 36 | return Ptr; |
2010 | 36 | } |
2011 | | |
2012 | | ConstantLValue |
2013 | 344 | ConstantLValueEmitter::VisitCallExpr(const CallExpr *E) { |
2014 | 344 | unsigned builtin = E->getBuiltinCallee(); |
2015 | 344 | if (builtin == Builtin::BI__builtin_function_start) |
2016 | 3 | return CGM.GetFunctionStart( |
2017 | 3 | E->getArg(0)->getAsBuiltinConstantDeclRef(CGM.getContext())); |
2018 | 341 | if (builtin != Builtin::BI__builtin___CFStringMakeConstantString && |
2019 | 341 | builtin != Builtin::BI__builtin___NSStringMakeConstantString0 ) |
2020 | 0 | return nullptr; |
2021 | | |
2022 | 341 | auto literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts()); |
2023 | 341 | if (builtin == Builtin::BI__builtin___NSStringMakeConstantString) { |
2024 | 0 | return CGM.getObjCRuntime().GenerateConstantString(literal); |
2025 | 341 | } else { |
2026 | | // FIXME: need to deal with UCN conversion issues. |
2027 | 341 | return CGM.GetAddrOfConstantCFString(literal); |
2028 | 341 | } |
2029 | 341 | } |
2030 | | |
2031 | | ConstantLValue |
2032 | 120 | ConstantLValueEmitter::VisitBlockExpr(const BlockExpr *E) { |
2033 | 120 | StringRef functionName; |
2034 | 120 | if (auto CGF = Emitter.CGF) |
2035 | 71 | functionName = CGF->CurFn->getName(); |
2036 | 49 | else |
2037 | 49 | functionName = "global"; |
2038 | | |
2039 | 120 | return CGM.GetAddrOfGlobalBlock(E, functionName); |
2040 | 120 | } |
2041 | | |
2042 | | ConstantLValue |
2043 | 0 | ConstantLValueEmitter::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { |
2044 | 0 | QualType T; |
2045 | 0 | if (E->isTypeOperand()) |
2046 | 0 | T = E->getTypeOperand(CGM.getContext()); |
2047 | 0 | else |
2048 | 0 | T = E->getExprOperand()->getType(); |
2049 | 0 | return CGM.GetAddrOfRTTIDescriptor(T); |
2050 | 0 | } |
2051 | | |
2052 | | ConstantLValue |
2053 | | ConstantLValueEmitter::VisitMaterializeTemporaryExpr( |
2054 | 148 | const MaterializeTemporaryExpr *E) { |
2055 | 148 | assert(E->getStorageDuration() == SD_Static); |
2056 | 0 | SmallVector<const Expr *, 2> CommaLHSs; |
2057 | 148 | SmallVector<SubobjectAdjustment, 2> Adjustments; |
2058 | 148 | const Expr *Inner = |
2059 | 148 | E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); |
2060 | 148 | return CGM.GetAddrOfGlobalTemporary(E, Inner); |
2061 | 148 | } |
2062 | | |
2063 | | llvm::Constant *ConstantEmitter::tryEmitPrivate(const APValue &Value, |
2064 | 47.6k | QualType DestType) { |
2065 | 47.6k | switch (Value.getKind()) { |
2066 | 0 | case APValue::None: |
2067 | 0 | case APValue::Indeterminate: |
2068 | | // Out-of-lifetime and indeterminate values can be modeled as 'undef'. |
2069 | 0 | return llvm::UndefValue::get(CGM.getTypes().ConvertType(DestType)); |
2070 | 6.25k | case APValue::LValue: |
2071 | 6.25k | return ConstantLValueEmitter(*this, Value, DestType).tryEmit(); |
2072 | 30.5k | case APValue::Int: |
2073 | 30.5k | return llvm::ConstantInt::get(CGM.getLLVMContext(), Value.getInt()); |
2074 | 344 | case APValue::FixedPoint: |
2075 | 344 | return llvm::ConstantInt::get(CGM.getLLVMContext(), |
2076 | 344 | Value.getFixedPoint().getValue()); |
2077 | 7 | case APValue::ComplexInt: { |
2078 | 7 | llvm::Constant *Complex[2]; |
2079 | | |
2080 | 7 | Complex[0] = llvm::ConstantInt::get(CGM.getLLVMContext(), |
2081 | 7 | Value.getComplexIntReal()); |
2082 | 7 | Complex[1] = llvm::ConstantInt::get(CGM.getLLVMContext(), |
2083 | 7 | Value.getComplexIntImag()); |
2084 | | |
2085 | | // FIXME: the target may want to specify that this is packed. |
2086 | 7 | llvm::StructType *STy = |
2087 | 7 | llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType()); |
2088 | 7 | return llvm::ConstantStruct::get(STy, Complex); |
2089 | 0 | } |
2090 | 2.76k | case APValue::Float: { |
2091 | 2.76k | const llvm::APFloat &Init = Value.getFloat(); |
2092 | 2.76k | if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf() && |
2093 | 2.76k | !CGM.getContext().getLangOpts().NativeHalfType67 && |
2094 | 2.76k | CGM.getContext().getTargetInfo().useFP16ConversionIntrinsics()55 ) |
2095 | 1 | return llvm::ConstantInt::get(CGM.getLLVMContext(), |
2096 | 1 | Init.bitcastToAPInt()); |
2097 | 2.76k | else |
2098 | 2.76k | return llvm::ConstantFP::get(CGM.getLLVMContext(), Init); |
2099 | 2.76k | } |
2100 | 40 | case APValue::ComplexFloat: { |
2101 | 40 | llvm::Constant *Complex[2]; |
2102 | | |
2103 | 40 | Complex[0] = llvm::ConstantFP::get(CGM.getLLVMContext(), |
2104 | 40 | Value.getComplexFloatReal()); |
2105 | 40 | Complex[1] = llvm::ConstantFP::get(CGM.getLLVMContext(), |
2106 | 40 | Value.getComplexFloatImag()); |
2107 | | |
2108 | | // FIXME: the target may want to specify that this is packed. |
2109 | 40 | llvm::StructType *STy = |
2110 | 40 | llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType()); |
2111 | 40 | return llvm::ConstantStruct::get(STy, Complex); |
2112 | 2.76k | } |
2113 | 919 | case APValue::Vector: { |
2114 | 919 | unsigned NumElts = Value.getVectorLength(); |
2115 | 919 | SmallVector<llvm::Constant *, 4> Inits(NumElts); |
2116 | | |
2117 | 6.48k | for (unsigned I = 0; I != NumElts; ++I5.57k ) { |
2118 | 5.57k | const APValue &Elt = Value.getVectorElt(I); |
2119 | 5.57k | if (Elt.isInt()) |
2120 | 4.58k | Inits[I] = llvm::ConstantInt::get(CGM.getLLVMContext(), Elt.getInt()); |
2121 | 983 | else if (Elt.isFloat()) |
2122 | 983 | Inits[I] = llvm::ConstantFP::get(CGM.getLLVMContext(), Elt.getFloat()); |
2123 | 0 | else |
2124 | 0 | llvm_unreachable("unsupported vector element type"); |
2125 | 5.57k | } |
2126 | 919 | return llvm::ConstantVector::get(Inits); |
2127 | 2.76k | } |
2128 | 5 | case APValue::AddrLabelDiff: { |
2129 | 5 | const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS(); |
2130 | 5 | const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS(); |
2131 | 5 | llvm::Constant *LHS = tryEmitPrivate(LHSExpr, LHSExpr->getType()); |
2132 | 5 | llvm::Constant *RHS = tryEmitPrivate(RHSExpr, RHSExpr->getType()); |
2133 | 5 | if (!LHS || !RHS) return nullptr0 ; |
2134 | | |
2135 | | // Compute difference |
2136 | 5 | llvm::Type *ResultType = CGM.getTypes().ConvertType(DestType); |
2137 | 5 | LHS = llvm::ConstantExpr::getPtrToInt(LHS, CGM.IntPtrTy); |
2138 | 5 | RHS = llvm::ConstantExpr::getPtrToInt(RHS, CGM.IntPtrTy); |
2139 | 5 | llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS); |
2140 | | |
2141 | | // LLVM is a bit sensitive about the exact format of the |
2142 | | // address-of-label difference; make sure to truncate after |
2143 | | // the subtraction. |
2144 | 5 | return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType); |
2145 | 5 | } |
2146 | 2.95k | case APValue::Struct: |
2147 | 3.43k | case APValue::Union: |
2148 | 3.43k | return ConstStructBuilder::BuildStruct(*this, Value, DestType); |
2149 | 3.08k | case APValue::Array: { |
2150 | 3.08k | const ArrayType *ArrayTy = CGM.getContext().getAsArrayType(DestType); |
2151 | 3.08k | unsigned NumElements = Value.getArraySize(); |
2152 | 3.08k | unsigned NumInitElts = Value.getArrayInitializedElts(); |
2153 | | |
2154 | | // Emit array filler, if there is one. |
2155 | 3.08k | llvm::Constant *Filler = nullptr; |
2156 | 3.08k | if (Value.hasArrayFiller()) { |
2157 | 690 | Filler = tryEmitAbstractForMemory(Value.getArrayFiller(), |
2158 | 690 | ArrayTy->getElementType()); |
2159 | 690 | if (!Filler) |
2160 | 0 | return nullptr; |
2161 | 690 | } |
2162 | | |
2163 | | // Emit initializer elements. |
2164 | 3.08k | SmallVector<llvm::Constant*, 16> Elts; |
2165 | 3.08k | if (Filler && Filler->isNullValue()690 ) |
2166 | 682 | Elts.reserve(NumInitElts + 1); |
2167 | 2.40k | else |
2168 | 2.40k | Elts.reserve(NumElements); |
2169 | | |
2170 | 3.08k | llvm::Type *CommonElementType = nullptr; |
2171 | 12.9k | for (unsigned I = 0; I < NumInitElts; ++I9.84k ) { |
2172 | 9.84k | llvm::Constant *C = tryEmitPrivateForMemory( |
2173 | 9.84k | Value.getArrayInitializedElt(I), ArrayTy->getElementType()); |
2174 | 9.84k | if (!C) return nullptr0 ; |
2175 | | |
2176 | 9.84k | if (I == 0) |
2177 | 2.86k | CommonElementType = C->getType(); |
2178 | 6.97k | else if (C->getType() != CommonElementType) |
2179 | 11 | CommonElementType = nullptr; |
2180 | 9.84k | Elts.push_back(C); |
2181 | 9.84k | } |
2182 | | |
2183 | 3.08k | llvm::ArrayType *Desired = |
2184 | 3.08k | cast<llvm::ArrayType>(CGM.getTypes().ConvertType(DestType)); |
2185 | 3.08k | return EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts, |
2186 | 3.08k | Filler); |
2187 | 3.08k | } |
2188 | 251 | case APValue::MemberPointer: |
2189 | 251 | return CGM.getCXXABI().EmitMemberPointer(Value, DestType); |
2190 | 47.6k | } |
2191 | 0 | llvm_unreachable("Unknown APValue kind"); |
2192 | 0 | } |
2193 | | |
2194 | | llvm::GlobalVariable *CodeGenModule::getAddrOfConstantCompoundLiteralIfEmitted( |
2195 | 23 | const CompoundLiteralExpr *E) { |
2196 | 23 | return EmittedCompoundLiterals.lookup(E); |
2197 | 23 | } |
2198 | | |
2199 | | void CodeGenModule::setAddrOfConstantCompoundLiteral( |
2200 | 21 | const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV) { |
2201 | 21 | bool Ok = EmittedCompoundLiterals.insert(std::make_pair(CLE, GV)).second; |
2202 | 21 | (void)Ok; |
2203 | 21 | assert(Ok && "CLE has already been emitted!"); |
2204 | 21 | } |
2205 | | |
2206 | | ConstantAddress |
2207 | 3 | CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) { |
2208 | 3 | assert(E->isFileScope() && "not a file-scope compound literal expr"); |
2209 | 0 | return tryEmitGlobalCompoundLiteral(*this, nullptr, E); |
2210 | 3 | } |
2211 | | |
2212 | | llvm::Constant * |
2213 | 607 | CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) { |
2214 | | // Member pointer constants always have a very particular form. |
2215 | 607 | const MemberPointerType *type = cast<MemberPointerType>(uo->getType()); |
2216 | 607 | const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl(); |
2217 | | |
2218 | | // A member function pointer. |
2219 | 607 | if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl)) |
2220 | 552 | return getCXXABI().EmitMemberFunctionPointer(method); |
2221 | | |
2222 | | // Otherwise, a member data pointer. |
2223 | 55 | uint64_t fieldOffset = getContext().getFieldOffset(decl); |
2224 | 55 | CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset); |
2225 | 55 | return getCXXABI().EmitMemberDataPointer(type, chars); |
2226 | 607 | } |
2227 | | |
2228 | | static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, |
2229 | | llvm::Type *baseType, |
2230 | | const CXXRecordDecl *base); |
2231 | | |
2232 | | static llvm::Constant *EmitNullConstant(CodeGenModule &CGM, |
2233 | | const RecordDecl *record, |
2234 | 73 | bool asCompleteObject) { |
2235 | 73 | const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record); |
2236 | 73 | llvm::StructType *structure = |
2237 | 73 | (asCompleteObject ? layout.getLLVMType()45 |
2238 | 73 | : layout.getBaseSubobjectLLVMType()28 ); |
2239 | | |
2240 | 73 | unsigned numElements = structure->getNumElements(); |
2241 | 73 | std::vector<llvm::Constant *> elements(numElements); |
2242 | | |
2243 | 73 | auto CXXR = dyn_cast<CXXRecordDecl>(record); |
2244 | | // Fill in all the bases. |
2245 | 73 | if (CXXR) { |
2246 | 57 | for (const auto &I : CXXR->bases()) { |
2247 | 26 | if (I.isVirtual()) { |
2248 | | // Ignore virtual bases; if we're laying out for a complete |
2249 | | // object, we'll lay these out later. |
2250 | 17 | continue; |
2251 | 17 | } |
2252 | | |
2253 | 9 | const CXXRecordDecl *base = |
2254 | 9 | cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl()); |
2255 | | |
2256 | | // Ignore empty bases. |
2257 | 9 | if (base->isEmpty() || |
2258 | 9 | CGM.getContext().getASTRecordLayout(base).getNonVirtualSize() |
2259 | 9 | .isZero()) |
2260 | 1 | continue; |
2261 | | |
2262 | 8 | unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base); |
2263 | 8 | llvm::Type *baseType = structure->getElementType(fieldIndex); |
2264 | 8 | elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); |
2265 | 8 | } |
2266 | 57 | } |
2267 | | |
2268 | | // Fill in all the fields. |
2269 | 144 | for (const auto *Field : record->fields()) { |
2270 | | // Fill in non-bitfields. (Bitfields always use a zero pattern, which we |
2271 | | // will fill in later.) |
2272 | 144 | if (!Field->isBitField() && !Field->isZeroSize(CGM.getContext())142 ) { |
2273 | 142 | unsigned fieldIndex = layout.getLLVMFieldNo(Field); |
2274 | 142 | elements[fieldIndex] = CGM.EmitNullConstant(Field->getType()); |
2275 | 142 | } |
2276 | | |
2277 | | // For unions, stop after the first named field. |
2278 | 144 | if (record->isUnion()) { |
2279 | 4 | if (Field->getIdentifier()) |
2280 | 3 | break; |
2281 | 1 | if (const auto *FieldRD = Field->getType()->getAsRecordDecl()) |
2282 | 1 | if (FieldRD->findFirstNamedDataMember()) |
2283 | 1 | break; |
2284 | 1 | } |
2285 | 144 | } |
2286 | | |
2287 | | // Fill in the virtual bases, if we're working with the complete object. |
2288 | 73 | if (CXXR && asCompleteObject57 ) { |
2289 | 29 | for (const auto &I : CXXR->vbases()) { |
2290 | 5 | const CXXRecordDecl *base = |
2291 | 5 | cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl()); |
2292 | | |
2293 | | // Ignore empty bases. |
2294 | 5 | if (base->isEmpty()) |
2295 | 0 | continue; |
2296 | | |
2297 | 5 | unsigned fieldIndex = layout.getVirtualBaseIndex(base); |
2298 | | |
2299 | | // We might have already laid this field out. |
2300 | 5 | if (elements[fieldIndex]) continue0 ; |
2301 | | |
2302 | 5 | llvm::Type *baseType = structure->getElementType(fieldIndex); |
2303 | 5 | elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); |
2304 | 5 | } |
2305 | 29 | } |
2306 | | |
2307 | | // Now go through all other fields and zero them out. |
2308 | 257 | for (unsigned i = 0; i != numElements; ++i184 ) { |
2309 | 184 | if (!elements[i]) |
2310 | 29 | elements[i] = llvm::Constant::getNullValue(structure->getElementType(i)); |
2311 | 184 | } |
2312 | | |
2313 | 73 | return llvm::ConstantStruct::get(structure, elements); |
2314 | 73 | } |
2315 | | |
2316 | | /// Emit the null constant for a base subobject. |
2317 | | static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, |
2318 | | llvm::Type *baseType, |
2319 | 13 | const CXXRecordDecl *base) { |
2320 | 13 | const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base); |
2321 | | |
2322 | | // Just zero out bases that don't have any pointer to data members. |
2323 | 13 | if (baseLayout.isZeroInitializableAsBase()) |
2324 | 4 | return llvm::Constant::getNullValue(baseType); |
2325 | | |
2326 | | // Otherwise, we can just use its null constant. |
2327 | 9 | return EmitNullConstant(CGM, base, /*asCompleteObject=*/false); |
2328 | 13 | } |
2329 | | |
2330 | | llvm::Constant *ConstantEmitter::emitNullForMemory(CodeGenModule &CGM, |
2331 | 57 | QualType T) { |
2332 | 57 | return emitForMemory(CGM, CGM.EmitNullConstant(T), T); |
2333 | 57 | } |
2334 | | |
2335 | 37.8k | llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { |
2336 | 37.8k | if (T->getAs<PointerType>()) |
2337 | 9.53k | return getNullPointer( |
2338 | 9.53k | cast<llvm::PointerType>(getTypes().ConvertTypeForMem(T)), T); |
2339 | | |
2340 | 28.3k | if (getTypes().isZeroInitializable(T)) |
2341 | 28.1k | return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); |
2342 | | |
2343 | 147 | if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { |
2344 | 11 | llvm::ArrayType *ATy = |
2345 | 11 | cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); |
2346 | | |
2347 | 11 | QualType ElementTy = CAT->getElementType(); |
2348 | | |
2349 | 11 | llvm::Constant *Element = |
2350 | 11 | ConstantEmitter::emitNullForMemory(*this, ElementTy); |
2351 | 11 | unsigned NumElements = CAT->getSize().getZExtValue(); |
2352 | 11 | SmallVector<llvm::Constant *, 8> Array(NumElements, Element); |
2353 | 11 | return llvm::ConstantArray::get(ATy, Array); |
2354 | 11 | } |
2355 | | |
2356 | 136 | if (const RecordType *RT = T->getAs<RecordType>()) |
2357 | 45 | return ::EmitNullConstant(*this, RT->getDecl(), /*complete object*/ true); |
2358 | | |
2359 | 91 | assert(T->isMemberDataPointerType() && |
2360 | 91 | "Should only see pointers to data members here!"); |
2361 | | |
2362 | 0 | return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>()); |
2363 | 136 | } |
2364 | | |
2365 | | llvm::Constant * |
2366 | 19 | CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) { |
2367 | 19 | return ::EmitNullConstant(*this, Record, false); |
2368 | 19 | } |