clang  16.0.0git
CGExprConstant.cpp
Go to the documentation of this file.
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  ConstantAggregateBuilderUtils(CodeGenModule &CGM) : CGM(CGM) {}
46 
47  CharUnits getAlignment(const llvm::Constant *C) const {
49  CGM.getDataLayout().getABITypeAlignment(C->getType()));
50  }
51 
52  CharUnits getSize(llvm::Type *Ty) const {
53  return CharUnits::fromQuantity(CGM.getDataLayout().getTypeAllocSize(Ty));
54  }
55 
56  CharUnits getSize(const llvm::Constant *C) const {
57  return getSize(C->getType());
58  }
59 
60  llvm::Constant *getPadding(CharUnits PadSize) const {
61  llvm::Type *Ty = CGM.CharTy;
62  if (PadSize > CharUnits::One())
63  Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity());
64  return llvm::UndefValue::get(Ty);
65  }
66 
67  llvm::Constant *getZeroes(CharUnits ZeroSize) const {
68  llvm::Type *Ty = llvm::ArrayType::get(CGM.CharTy, ZeroSize.getQuantity());
69  return llvm::ConstantAggregateZero::get(Ty);
70  }
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.
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.
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,
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  : 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  llvm::Constant *build(llvm::Type *DesiredTy, bool AllowOversized) const {
130  return buildFrom(CGM, Elems, Offsets, CharUnits::Zero(), Size,
131  NaturalLayout, DesiredTy, AllowOversized);
132  }
133 };
134 
135 template<typename Container, typename Range = std::initializer_list<
136  typename Container::value_type>>
137 static void replace(Container &C, size_t BeginOff, size_t EndOff, Range Vals) {
138  assert(BeginOff <= EndOff && "invalid replacement range");
139  llvm::replace(C, C.begin() + BeginOff, C.begin() + EndOff, Vals);
140 }
141 
142 bool ConstantAggregateBuilder::add(llvm::Constant *C, CharUnits Offset,
143  bool AllowOverwrite) {
144  // Common case: appending to a layout.
145  if (Offset >= Size) {
146  CharUnits Align = getAlignment(C);
147  CharUnits AlignedSize = Size.alignTo(Align);
148  if (AlignedSize > Offset || Offset.alignTo(Align) != Offset)
149  NaturalLayout = false;
150  else if (AlignedSize < Offset) {
151  Elems.push_back(getPadding(Offset - Size));
152  Offsets.push_back(Size);
153  }
154  Elems.push_back(C);
155  Offsets.push_back(Offset);
156  Size = Offset + getSize(C);
157  return true;
158  }
159 
160  // Uncommon case: constant overlaps what we've already created.
161  llvm::Optional<size_t> FirstElemToReplace = splitAt(Offset);
162  if (!FirstElemToReplace)
163  return false;
164 
165  CharUnits CSize = getSize(C);
166  llvm::Optional<size_t> LastElemToReplace = splitAt(Offset + CSize);
167  if (!LastElemToReplace)
168  return false;
169 
170  assert((FirstElemToReplace == LastElemToReplace || AllowOverwrite) &&
171  "unexpectedly overwriting field");
172 
173  replace(Elems, *FirstElemToReplace, *LastElemToReplace, {C});
174  replace(Offsets, *FirstElemToReplace, *LastElemToReplace, {Offset});
175  Size = std::max(Size, Offset + CSize);
176  NaturalLayout = false;
177  return true;
178 }
179 
180 bool ConstantAggregateBuilder::addBits(llvm::APInt Bits, uint64_t OffsetInBits,
181  bool AllowOverwrite) {
182  const ASTContext &Context = CGM.getContext();
183  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  unsigned OffsetWithinChar = OffsetInBits % CharWidth;
188 
189  // We split bit-fields up into individual bytes. Walk over the bytes and
190  // update them.
191  for (CharUnits OffsetInChars =
192  Context.toCharUnitsFromBits(OffsetInBits - OffsetWithinChar);
193  /**/; ++OffsetInChars) {
194  // Number of bits we want to fill in this char.
195  unsigned WantedBits =
196  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  llvm::APInt BitsThisChar = Bits;
201  if (BitsThisChar.getBitWidth() < CharWidth)
202  BitsThisChar = BitsThisChar.zext(CharWidth);
203  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  int Shift = Bits.getBitWidth() - CharWidth + OffsetWithinChar;
207  if (Shift > 0)
208  BitsThisChar.lshrInPlace(Shift);
209  else if (Shift < 0)
210  BitsThisChar = BitsThisChar.shl(-Shift);
211  } else {
212  BitsThisChar = BitsThisChar.shl(OffsetWithinChar);
213  }
214  if (BitsThisChar.getBitWidth() > CharWidth)
215  BitsThisChar = BitsThisChar.trunc(CharWidth);
216 
217  if (WantedBits == CharWidth) {
218  // Got a full byte: just add it directly.
219  add(llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar),
220  OffsetInChars, AllowOverwrite);
221  } 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  llvm::Optional<size_t> FirstElemToUpdate = splitAt(OffsetInChars);
226  if (!FirstElemToUpdate)
227  return false;
228  llvm::Optional<size_t> LastElemToUpdate =
229  splitAt(OffsetInChars + CharUnits::One());
230  if (!LastElemToUpdate)
231  return false;
232  assert(*LastElemToUpdate - *FirstElemToUpdate < 2 &&
233  "should have at most one element covering one byte");
234 
235  // Figure out which bits we want and discard the rest.
236  llvm::APInt UpdateMask(CharWidth, 0);
237  if (CGM.getDataLayout().isBigEndian())
238  UpdateMask.setBits(CharWidth - OffsetWithinChar - WantedBits,
239  CharWidth - OffsetWithinChar);
240  else
241  UpdateMask.setBits(OffsetWithinChar, OffsetWithinChar + WantedBits);
242  BitsThisChar &= UpdateMask;
243 
244  if (*FirstElemToUpdate == *LastElemToUpdate ||
245  Elems[*FirstElemToUpdate]->isNullValue() ||
246  isa<llvm::UndefValue>(Elems[*FirstElemToUpdate])) {
247  // All existing bits are either zero or undef.
248  add(llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar),
249  OffsetInChars, /*AllowOverwrite*/ true);
250  } else {
251  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  auto *CI = dyn_cast<llvm::ConstantInt>(ToUpdate);
255  if (!CI)
256  return false;
257  // Because this is a 1-CharUnit range, the constant occupying it must
258  // be exactly one CharUnit wide.
259  assert(CI->getBitWidth() == CharWidth && "splitAt failed");
260  assert((!(CI->getValue() & UpdateMask) || AllowOverwrite) &&
261  "unexpectedly overwriting bitfield");
262  BitsThisChar |= (CI->getValue() & ~UpdateMask);
263  ToUpdate = llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar);
264  }
265  }
266 
267  // Stop if we've added all the bits.
268  if (WantedBits == Bits.getBitWidth())
269  break;
270 
271  // Remove the consumed bits from Bits.
272  if (!CGM.getDataLayout().isBigEndian())
273  Bits.lshrInPlace(WantedBits);
274  Bits = Bits.trunc(Bits.getBitWidth() - WantedBits);
275 
276  // The remanining bits go at the start of the following bytes.
277  OffsetWithinChar = 0;
278  }
279 
280  return true;
281 }
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 Optional<size_t> ConstantAggregateBuilder::splitAt(CharUnits Pos) {
288  if (Pos >= Size)
289  return Offsets.size();
290 
291  while (true) {
292  auto FirstAfterPos = llvm::upper_bound(Offsets, Pos);
293  if (FirstAfterPos == Offsets.begin())
294  return 0;
295 
296  // If we already have an element starting at Pos, we're done.
297  size_t LastAtOrBeforePosIndex = FirstAfterPos - Offsets.begin() - 1;
298  if (Offsets[LastAtOrBeforePosIndex] == Pos)
299  return LastAtOrBeforePosIndex;
300 
301  // We found an element starting before Pos. Check for overlap.
302  if (Offsets[LastAtOrBeforePosIndex] +
303  getSize(Elems[LastAtOrBeforePosIndex]) <= Pos)
304  return LastAtOrBeforePosIndex + 1;
305 
306  // Try to decompose it into smaller constants.
307  if (!split(LastAtOrBeforePosIndex, Pos))
308  return std::nullopt;
309  }
310 }
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 bool ConstantAggregateBuilder::split(size_t Index, CharUnits Hint) {
316  NaturalLayout = false;
317  llvm::Constant *C = Elems[Index];
318  CharUnits Offset = Offsets[Index];
319 
320  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  replace(Elems, Index, Index + 1,
324  llvm::map_range(llvm::seq(0u, CA->getNumOperands()),
325  [&](unsigned Op) { return CA->getOperand(Op); }));
326  if (isa<llvm::ArrayType>(CA->getType()) ||
327  isa<llvm::VectorType>(CA->getType())) {
328  // Array or vector.
329  llvm::Type *ElemTy =
330  llvm::GetElementPtrInst::getTypeAtIndex(CA->getType(), (uint64_t)0);
331  CharUnits ElemSize = getSize(ElemTy);
332  replace(
333  Offsets, Index, Index + 1,
334  llvm::map_range(llvm::seq(0u, CA->getNumOperands()),
335  [&](unsigned Op) { return Offset + Op * ElemSize; }));
336  } else {
337  // Must be a struct.
338  auto *ST = cast<llvm::StructType>(CA->getType());
339  const llvm::StructLayout *Layout =
340  CGM.getDataLayout().getStructLayout(ST);
341  replace(Offsets, Index, Index + 1,
342  llvm::map_range(
343  llvm::seq(0u, CA->getNumOperands()), [&](unsigned Op) {
344  return Offset + CharUnits::fromQuantity(
345  Layout->getElementOffset(Op));
346  }));
347  }
348  return true;
349  }
350 
351  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  CharUnits ElemSize = getSize(CDS->getElementType());
356  replace(Elems, Index, Index + 1,
357  llvm::map_range(llvm::seq(0u, CDS->getNumElements()),
358  [&](unsigned Elem) {
359  return CDS->getElementAsConstant(Elem);
360  }));
361  replace(Offsets, Index, Index + 1,
362  llvm::map_range(
363  llvm::seq(0u, CDS->getNumElements()),
364  [&](unsigned Elem) { return Offset + Elem * ElemSize; }));
365  return true;
366  }
367 
368  if (isa<llvm::ConstantAggregateZero>(C)) {
369  // Split into two zeros at the hinted offset.
370  CharUnits ElemSize = getSize(C);
371  assert(Hint > Offset && Hint < Offset + ElemSize && "nothing to split");
372  replace(Elems, Index, Index + 1,
373  {getZeroes(Hint - Offset), getZeroes(Offset + ElemSize - Hint)});
374  replace(Offsets, Index, Index + 1, {Offset, Hint});
375  return true;
376  }
377 
378  if (isa<llvm::UndefValue>(C)) {
379  // Drop undef; it doesn't contribute to the final layout.
380  replace(Elems, Index, Index + 1, {});
381  replace(Offsets, Index, Index + 1, {});
382  return true;
383  }
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  return false;
390 }
391 
392 static llvm::Constant *
393 EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType,
394  llvm::Type *CommonElementType, unsigned ArrayBound,
396  llvm::Constant *Filler);
397 
398 llvm::Constant *ConstantAggregateBuilder::buildFrom(
400  ArrayRef<CharUnits> Offsets, CharUnits StartOffset, CharUnits Size,
401  bool NaturalLayout, llvm::Type *DesiredTy, bool AllowOversized) {
402  ConstantAggregateBuilderUtils Utils(CGM);
403 
404  if (Elems.empty())
405  return llvm::UndefValue::get(DesiredTy);
406 
407  auto Offset = [&](size_t I) { return Offsets[I] - StartOffset; };
408 
409  // If we want an array type, see if all the elements are the same type and
410  // appropriately spaced.
411  if (llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(DesiredTy)) {
412  assert(!AllowOversized && "oversized array emission not supported");
413 
414  bool CanEmitArray = true;
415  llvm::Type *CommonType = Elems[0]->getType();
416  llvm::Constant *Filler = llvm::Constant::getNullValue(CommonType);
417  CharUnits ElemSize = Utils.getSize(ATy->getElementType());
418  SmallVector<llvm::Constant*, 32> ArrayElements;
419  for (size_t I = 0; I != Elems.size(); ++I) {
420  // Skip zeroes; we'll use a zero value as our array filler.
421  if (Elems[I]->isNullValue())
422  continue;
423 
424  // All remaining elements must be the same type.
425  if (Elems[I]->getType() != CommonType ||
426  Offset(I) % ElemSize != 0) {
427  CanEmitArray = false;
428  break;
429  }
430  ArrayElements.resize(Offset(I) / ElemSize + 1, Filler);
431  ArrayElements.back() = Elems[I];
432  }
433 
434  if (CanEmitArray) {
435  return EmitArrayConstant(CGM, ATy, CommonType, ATy->getNumElements(),
436  ArrayElements, Filler);
437  }
438 
439  // Can't emit as an array, carry on to emit as a struct.
440  }
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  CharUnits DesiredSize = Utils.getSize(DesiredTy);
446  if (Size > DesiredSize) {
447  assert(AllowOversized && "Elems are oversized");
448  DesiredSize = Size;
449  }
450 
451  // The natural alignment of an unpacked LLVM struct with the given elements.
452  CharUnits Align = CharUnits::One();
453  for (llvm::Constant *C : Elems)
454  Align = std::max(Align, Utils.getAlignment(C));
455 
456  // The natural size of an unpacked LLVM struct with the given elements.
457  CharUnits AlignedSize = Size.alignTo(Align);
458 
459  bool Packed = false;
460  ArrayRef<llvm::Constant*> UnpackedElems = Elems;
461  llvm::SmallVector<llvm::Constant*, 32> UnpackedElemStorage;
462  if (DesiredSize < AlignedSize || DesiredSize.alignTo(Align) != DesiredSize) {
463  // The natural layout would be too big; force use of a packed layout.
464  NaturalLayout = false;
465  Packed = true;
466  } 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  UnpackedElemStorage.assign(Elems.begin(), Elems.end());
470  UnpackedElemStorage.push_back(Utils.getPadding(DesiredSize - Size));
471  UnpackedElems = UnpackedElemStorage;
472  }
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.
478  if (!NaturalLayout) {
479  CharUnits SizeSoFar = CharUnits::Zero();
480  for (size_t I = 0; I != Elems.size(); ++I) {
481  CharUnits Align = Utils.getAlignment(Elems[I]);
482  CharUnits NaturalOffset = SizeSoFar.alignTo(Align);
483  CharUnits DesiredOffset = Offset(I);
484  assert(DesiredOffset >= SizeSoFar && "elements out of order");
485 
486  if (DesiredOffset != NaturalOffset)
487  Packed = true;
488  if (DesiredOffset != SizeSoFar)
489  PackedElems.push_back(Utils.getPadding(DesiredOffset - SizeSoFar));
490  PackedElems.push_back(Elems[I]);
491  SizeSoFar = DesiredOffset + Utils.getSize(Elems[I]);
492  }
493  // If we're using the packed layout, pad it out to the desired size if
494  // necessary.
495  if (Packed) {
496  assert(SizeSoFar <= DesiredSize &&
497  "requested size is too small for contents");
498  if (SizeSoFar < DesiredSize)
499  PackedElems.push_back(Utils.getPadding(DesiredSize - SizeSoFar));
500  }
501  }
502 
503  llvm::StructType *STy = llvm::ConstantStruct::getTypeForElements(
504  CGM.getLLVMContext(), Packed ? PackedElems : UnpackedElems, 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  if (llvm::StructType *DesiredSTy = dyn_cast<llvm::StructType>(DesiredTy)) {
509  if (DesiredSTy->isLayoutIdentical(STy))
510  STy = DesiredSTy;
511  }
512 
513  return llvm::ConstantStruct::get(STy, Packed ? PackedElems : UnpackedElems);
514 }
515 
516 void ConstantAggregateBuilder::condense(CharUnits Offset,
517  llvm::Type *DesiredTy) {
518  CharUnits Size = getSize(DesiredTy);
519 
520  llvm::Optional<size_t> FirstElemToReplace = splitAt(Offset);
521  if (!FirstElemToReplace)
522  return;
523  size_t First = *FirstElemToReplace;
524 
525  llvm::Optional<size_t> LastElemToReplace = splitAt(Offset + Size);
526  if (!LastElemToReplace)
527  return;
528  size_t Last = *LastElemToReplace;
529 
530  size_t Length = Last - First;
531  if (Length == 0)
532  return;
533 
534  if (Length == 1 && Offsets[First] == Offset &&
535  getSize(Elems[First]) == Size) {
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  auto *STy = dyn_cast<llvm::StructType>(DesiredTy);
539  if (STy && STy->getNumElements() == 1 &&
540  STy->getElementType(0) == Elems[First]->getType())
541  Elems[First] = llvm::ConstantStruct::get(STy, Elems[First]);
542  return;
543  }
544 
545  llvm::Constant *Replacement = buildFrom(
546  CGM, makeArrayRef(Elems).slice(First, Length),
547  makeArrayRef(Offsets).slice(First, Length), Offset, getSize(DesiredTy),
548  /*known to have natural layout=*/false, DesiredTy, false);
549  replace(Elems, First, Last, {Replacement});
550  replace(Offsets, First, Last, {Offset});
551 }
552 
553 //===----------------------------------------------------------------------===//
554 // ConstStructBuilder
555 //===----------------------------------------------------------------------===//
556 
557 class ConstStructBuilder {
558  CodeGenModule &CGM;
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  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  bool AllowOverwrite) {
596  const ASTContext &Context = CGM.getContext();
597 
598  CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
599 
600  return AppendBytes(FieldOffsetInChars, InitCst, AllowOverwrite);
601 }
602 
603 bool ConstStructBuilder::AppendBytes(CharUnits FieldOffsetInChars,
604  llvm::Constant *InitCst,
605  bool AllowOverwrite) {
606  return Builder.add(InitCst, StartOffset + FieldOffsetInChars, AllowOverwrite);
607 }
608 
609 bool ConstStructBuilder::AppendBitField(
610  const FieldDecl *Field, uint64_t FieldOffset, llvm::ConstantInt *CI,
611  bool AllowOverwrite) {
612  const CGRecordLayout &RL =
613  CGM.getTypes().getCGRecordLayout(Field->getParent());
614  const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
615  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  if (Info.Size > FieldValue.getBitWidth())
622  FieldValue = FieldValue.zext(Info.Size);
623 
624  // Truncate the size of FieldValue to the bit field size.
625  if (Info.Size < FieldValue.getBitWidth())
626  FieldValue = FieldValue.trunc(Info.Size);
627 
628  return Builder.addBits(FieldValue,
629  CGM.getContext().toBits(StartOffset) + FieldOffset,
630  AllowOverwrite);
631 }
632 
633 static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter,
634  ConstantAggregateBuilder &Const,
636  InitListExpr *Updater) {
637  if (Type->isRecordType())
638  return ConstStructBuilder::UpdateStruct(Emitter, Const, Offset, Updater);
639 
640  auto CAT = Emitter.CGM.getContext().getAsConstantArrayType(Type);
641  if (!CAT)
642  return false;
643  QualType ElemType = CAT->getElementType();
644  CharUnits ElemSize = Emitter.CGM.getContext().getTypeSizeInChars(ElemType);
645  llvm::Type *ElemTy = Emitter.CGM.getTypes().ConvertTypeForMem(ElemType);
646 
647  llvm::Constant *FillC = nullptr;
648  if (Expr *Filler = Updater->getArrayFiller()) {
649  if (!isa<NoInitExpr>(Filler)) {
650  FillC = Emitter.tryEmitAbstractForMemory(Filler, ElemType);
651  if (!FillC)
652  return false;
653  }
654  }
655 
656  unsigned NumElementsToUpdate =
657  FillC ? CAT->getSize().getZExtValue() : Updater->getNumInits();
658  for (unsigned I = 0; I != NumElementsToUpdate; ++I, Offset += ElemSize) {
659  Expr *Init = nullptr;
660  if (I < Updater->getNumInits())
661  Init = Updater->getInit(I);
662 
663  if (!Init && FillC) {
664  if (!Const.add(FillC, Offset, true))
665  return false;
666  } else if (!Init || isa<NoInitExpr>(Init)) {
667  continue;
668  } else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init)) {
669  if (!EmitDesignatedInitUpdater(Emitter, Const, Offset, ElemType,
670  ChildILE))
671  return false;
672  // Attempt to reduce the array element to a single constant if necessary.
673  Const.condense(Offset, ElemTy);
674  } else {
675  llvm::Constant *Val = Emitter.tryEmitPrivateForMemory(Init, ElemType);
676  if (!Const.add(Val, Offset, true))
677  return false;
678  }
679  }
680 
681  return true;
682 }
683 
684 bool ConstStructBuilder::Build(InitListExpr *ILE, bool AllowOverwrite) {
685  RecordDecl *RD = ILE->getType()->castAs<RecordType>()->getDecl();
686  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
687 
688  unsigned FieldNo = -1;
689  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  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
695  if (CXXRD->getNumBases())
696  return false;
697 
698  for (FieldDecl *Field : RD->fields()) {
699  ++FieldNo;
700 
701  // If this is a union, skip all the fields that aren't being initialized.
702  if (RD->isUnion() &&
704  continue;
705 
706  // Don't emit anonymous bitfields.
707  if (Field->isUnnamedBitfield())
708  continue;
709 
710  // Get the initializer. A struct can include fields without initializers,
711  // we just use explicit null values for them.
712  Expr *Init = nullptr;
713  if (ElementNo < ILE->getNumInits())
714  Init = ILE->getInit(ElementNo++);
715  if (Init && isa<NoInitExpr>(Init))
716  continue;
717 
718  // Zero-sized fields are not emitted, but their initializers may still
719  // prevent emission of this struct as a constant.
720  if (Field->isZeroSize(CGM.getContext())) {
721  if (Init->HasSideEffects(CGM.getContext()))
722  return false;
723  continue;
724  }
725 
726  // When emitting a DesignatedInitUpdateExpr, a nested InitListExpr
727  // represents additional overwriting of our current constant value, and not
728  // a new constant to emit independently.
729  if (AllowOverwrite &&
730  (Field->getType()->isArrayType() || Field->getType()->isRecordType())) {
731  if (auto *SubILE = dyn_cast<InitListExpr>(Init)) {
733  Layout.getFieldOffset(FieldNo));
734  if (!EmitDesignatedInitUpdater(Emitter, Builder, StartOffset + Offset,
735  Field->getType(), SubILE))
736  return false;
737  // If we split apart the field's value, try to collapse it down to a
738  // single value now.
739  Builder.condense(StartOffset + Offset,
740  CGM.getTypes().ConvertTypeForMem(Field->getType()));
741  continue;
742  }
743  }
744 
745  llvm::Constant *EltInit =
746  Init ? Emitter.tryEmitPrivateForMemory(Init, Field->getType())
747  : Emitter.emitNullForMemory(Field->getType());
748  if (!EltInit)
749  return false;
750 
751  if (!Field->isBitField()) {
752  // Handle non-bitfield members.
753  if (!AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit,
754  AllowOverwrite))
755  return false;
756  // After emitting a non-empty field with [[no_unique_address]], we may
757  // need to overwrite its tail padding.
758  if (Field->hasAttr<NoUniqueAddressAttr>())
759  AllowOverwrite = true;
760  } else {
761  // Otherwise we have a bitfield.
762  if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) {
763  if (!AppendBitField(Field, Layout.getFieldOffset(FieldNo), CI,
764  AllowOverwrite))
765  return false;
766  } else {
767  // We are trying to initialize a bitfield with a non-trivial constant,
768  // this must require run-time code.
769  return false;
770  }
771  }
772  }
773 
774  return true;
775 }
776 
777 namespace {
778 struct BaseInfo {
779  BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
780  : Decl(Decl), Offset(Offset), Index(Index) {
781  }
782 
783  const CXXRecordDecl *Decl;
785  unsigned Index;
786 
787  bool operator<(const BaseInfo &O) const { return Offset < O.Offset; }
788 };
789 }
790 
791 bool ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
792  bool IsPrimaryBase,
793  const CXXRecordDecl *VTableClass,
794  CharUnits Offset) {
795  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
796 
797  if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
798  // Add a vtable pointer, if we need one and it hasn't already been added.
799  if (Layout.hasOwnVFPtr()) {
800  llvm::Constant *VTableAddressPoint =
802  BaseSubobject(CD, Offset), VTableClass);
803  if (!AppendBytes(Offset, VTableAddressPoint))
804  return false;
805  }
806 
807  // Accumulate and sort bases, in order to visit them in address order, which
808  // may not be the same as declaration order.
810  Bases.reserve(CD->getNumBases());
811  unsigned BaseNo = 0;
812  for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
813  BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
814  assert(!Base->isVirtual() && "should not have virtual bases here");
815  const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
816  CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
817  Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));
818  }
819  llvm::stable_sort(Bases);
820 
821  for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
822  BaseInfo &Base = Bases[I];
823 
824  bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
825  Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
826  VTableClass, Offset + Base.Offset);
827  }
828  }
829 
830  unsigned FieldNo = 0;
831  uint64_t OffsetBits = CGM.getContext().toBits(Offset);
832 
833  bool AllowOverwrite = false;
834  for (RecordDecl::field_iterator Field = RD->field_begin(),
835  FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
836  // If this is a union, skip all the fields that aren't being initialized.
837  if (RD->isUnion() && !declaresSameEntity(Val.getUnionField(), *Field))
838  continue;
839 
840  // Don't emit anonymous bitfields or zero-sized fields.
841  if (Field->isUnnamedBitfield() || Field->isZeroSize(CGM.getContext()))
842  continue;
843 
844  // Emit the value of the initializer.
845  const APValue &FieldValue =
846  RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo);
847  llvm::Constant *EltInit =
848  Emitter.tryEmitPrivateForMemory(FieldValue, Field->getType());
849  if (!EltInit)
850  return false;
851 
852  if (!Field->isBitField()) {
853  // Handle non-bitfield members.
854  if (!AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
855  EltInit, AllowOverwrite))
856  return false;
857  // After emitting a non-empty field with [[no_unique_address]], we may
858  // need to overwrite its tail padding.
859  if (Field->hasAttr<NoUniqueAddressAttr>())
860  AllowOverwrite = true;
861  } else {
862  // Otherwise we have a bitfield.
863  if (!AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
864  cast<llvm::ConstantInt>(EltInit), AllowOverwrite))
865  return false;
866  }
867  }
868 
869  return true;
870 }
871 
872 llvm::Constant *ConstStructBuilder::Finalize(QualType Type) {
873  Type = Type.getNonReferenceType();
874  RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
875  llvm::Type *ValTy = CGM.getTypes().ConvertType(Type);
876  return Builder.build(ValTy, RD->hasFlexibleArrayMember());
877 }
878 
879 llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
880  InitListExpr *ILE,
881  QualType ValTy) {
882  ConstantAggregateBuilder Const(Emitter.CGM);
883  ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero());
884 
885  if (!Builder.Build(ILE, /*AllowOverwrite*/false))
886  return nullptr;
887 
888  return Builder.Finalize(ValTy);
889 }
890 
891 llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
892  const APValue &Val,
893  QualType ValTy) {
894  ConstantAggregateBuilder Const(Emitter.CGM);
895  ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero());
896 
897  const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl();
898  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
899  if (!Builder.Build(Val, RD, false, CD, CharUnits::Zero()))
900  return nullptr;
901 
902  return Builder.Finalize(ValTy);
903 }
904 
905 bool ConstStructBuilder::UpdateStruct(ConstantEmitter &Emitter,
906  ConstantAggregateBuilder &Const,
907  CharUnits Offset, InitListExpr *Updater) {
908  return ConstStructBuilder(Emitter, Const, Offset)
909  .Build(Updater, /*AllowOverwrite*/ true);
910 }
911 
912 //===----------------------------------------------------------------------===//
913 // ConstExprEmitter
914 //===----------------------------------------------------------------------===//
915 
916 static ConstantAddress
917 tryEmitGlobalCompoundLiteral(ConstantEmitter &emitter,
918  const CompoundLiteralExpr *E) {
919  CodeGenModule &CGM = emitter.CGM;
920  CharUnits Align = CGM.getContext().getTypeAlignInChars(E->getType());
921  if (llvm::GlobalVariable *Addr =
923  return ConstantAddress(Addr, Addr->getValueType(), Align);
924 
925  LangAS addressSpace = E->getType().getAddressSpace();
926  llvm::Constant *C = emitter.tryEmitForInitializer(E->getInitializer(),
927  addressSpace, E->getType());
928  if (!C) {
929  assert(!E->isFileScope() &&
930  "file-scope compound literal did not have constant initializer!");
931  return ConstantAddress::invalid();
932  }
933 
934  auto GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
935  CGM.isTypeConstant(E->getType(), true),
937  C, ".compoundliteral", nullptr,
938  llvm::GlobalVariable::NotThreadLocal,
939  CGM.getContext().getTargetAddressSpace(addressSpace));
940  emitter.finalize(GV);
941  GV->setAlignment(Align.getAsAlign());
943  return ConstantAddress(GV, GV->getValueType(), Align);
944 }
945 
946 static llvm::Constant *
947 EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType,
948  llvm::Type *CommonElementType, unsigned ArrayBound,
950  llvm::Constant *Filler) {
951  // Figure out how long the initial prefix of non-zero elements is.
952  unsigned NonzeroLength = ArrayBound;
953  if (Elements.size() < NonzeroLength && Filler->isNullValue())
954  NonzeroLength = Elements.size();
955  if (NonzeroLength == Elements.size()) {
956  while (NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue())
957  --NonzeroLength;
958  }
959 
960  if (NonzeroLength == 0)
961  return llvm::ConstantAggregateZero::get(DesiredType);
962 
963  // Add a zeroinitializer array filler if we have lots of trailing zeroes.
964  unsigned TrailingZeroes = ArrayBound - NonzeroLength;
965  if (TrailingZeroes >= 8) {
966  assert(Elements.size() >= NonzeroLength &&
967  "missing initializer for non-zero element");
968 
969  // If all the elements had the same type up to the trailing zeroes, emit a
970  // struct of two arrays (the nonzero data and the zeroinitializer).
971  if (CommonElementType && NonzeroLength >= 8) {
972  llvm::Constant *Initial = llvm::ConstantArray::get(
973  llvm::ArrayType::get(CommonElementType, NonzeroLength),
974  makeArrayRef(Elements).take_front(NonzeroLength));
975  Elements.resize(2);
976  Elements[0] = Initial;
977  } else {
978  Elements.resize(NonzeroLength + 1);
979  }
980 
981  auto *FillerType =
982  CommonElementType ? CommonElementType : DesiredType->getElementType();
983  FillerType = llvm::ArrayType::get(FillerType, TrailingZeroes);
984  Elements.back() = llvm::ConstantAggregateZero::get(FillerType);
985  CommonElementType = nullptr;
986  } else if (Elements.size() != ArrayBound) {
987  // Otherwise pad to the right size with the filler if necessary.
988  Elements.resize(ArrayBound, Filler);
989  if (Filler->getType() != CommonElementType)
990  CommonElementType = nullptr;
991  }
992 
993  // If all elements have the same type, just emit an array constant.
994  if (CommonElementType)
995  return llvm::ConstantArray::get(
996  llvm::ArrayType::get(CommonElementType, ArrayBound), Elements);
997 
998  // We have mixed types. Use a packed struct.
1000  Types.reserve(Elements.size());
1001  for (llvm::Constant *Elt : Elements)
1002  Types.push_back(Elt->getType());
1003  llvm::StructType *SType =
1004  llvm::StructType::get(CGM.getLLVMContext(), Types, true);
1005  return llvm::ConstantStruct::get(SType, Elements);
1006 }
1007 
1008 // This class only needs to handle arrays, structs and unions. Outside C++11
1009 // mode, we don't currently constant fold those types. All other types are
1010 // handled by constant folding.
1011 //
1012 // Constant folding is currently missing support for a few features supported
1013 // here: CK_ToUnion, CK_ReinterpretMemberPointer, and DesignatedInitUpdateExpr.
1014 class ConstExprEmitter :
1015  public StmtVisitor<ConstExprEmitter, llvm::Constant*, QualType> {
1016  CodeGenModule &CGM;
1018  llvm::LLVMContext &VMContext;
1019 public:
1020  ConstExprEmitter(ConstantEmitter &emitter)
1021  : CGM(emitter.CGM), Emitter(emitter), VMContext(CGM.getLLVMContext()) {
1022  }
1023 
1024  //===--------------------------------------------------------------------===//
1025  // Visitor Methods
1026  //===--------------------------------------------------------------------===//
1027 
1028  llvm::Constant *VisitStmt(Stmt *S, QualType T) {
1029  return nullptr;
1030  }
1031 
1032  llvm::Constant *VisitConstantExpr(ConstantExpr *CE, QualType T) {
1033  if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(CE))
1034  return Result;
1035  return Visit(CE->getSubExpr(), T);
1036  }
1037 
1038  llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) {
1039  return Visit(PE->getSubExpr(), T);
1040  }
1041 
1042  llvm::Constant *
1043  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE,
1044  QualType T) {
1045  return Visit(PE->getReplacement(), T);
1046  }
1047 
1048  llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE,
1049  QualType T) {
1050  return Visit(GE->getResultExpr(), T);
1051  }
1052 
1053  llvm::Constant *VisitChooseExpr(ChooseExpr *CE, QualType T) {
1054  return Visit(CE->getChosenSubExpr(), T);
1055  }
1056 
1057  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E, QualType T) {
1058  return Visit(E->getInitializer(), T);
1059  }
1060 
1061  llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
1062  if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
1063  CGM.EmitExplicitCastExprType(ECE, Emitter.CGF);
1064  Expr *subExpr = E->getSubExpr();
1065 
1066  switch (E->getCastKind()) {
1067  case CK_ToUnion: {
1068  // GCC cast to union extension
1069  assert(E->getType()->isUnionType() &&
1070  "Destination type is not union type!");
1071 
1072  auto field = E->getTargetUnionField();
1073 
1074  auto C = Emitter.tryEmitPrivateForMemory(subExpr, field->getType());
1075  if (!C) return nullptr;
1076 
1077  auto destTy = ConvertType(destType);
1078  if (C->getType() == destTy) return C;
1079 
1080  // Build a struct with the union sub-element as the first member,
1081  // and padded to the appropriate size.
1084  Elts.push_back(C);
1085  Types.push_back(C->getType());
1086  unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType());
1087  unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destTy);
1088 
1089  assert(CurSize <= TotalSize && "Union size mismatch!");
1090  if (unsigned NumPadBytes = TotalSize - CurSize) {
1091  llvm::Type *Ty = CGM.CharTy;
1092  if (NumPadBytes > 1)
1093  Ty = llvm::ArrayType::get(Ty, NumPadBytes);
1094 
1095  Elts.push_back(llvm::UndefValue::get(Ty));
1096  Types.push_back(Ty);
1097  }
1098 
1099  llvm::StructType *STy = llvm::StructType::get(VMContext, Types, false);
1100  return llvm::ConstantStruct::get(STy, Elts);
1101  }
1102 
1103  case CK_AddressSpaceConversion: {
1104  auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType());
1105  if (!C) return nullptr;
1106  LangAS destAS = E->getType()->getPointeeType().getAddressSpace();
1107  LangAS srcAS = subExpr->getType()->getPointeeType().getAddressSpace();
1108  llvm::Type *destTy = ConvertType(E->getType());
1109  return CGM.getTargetCodeGenInfo().performAddrSpaceCast(CGM, C, srcAS,
1110  destAS, destTy);
1111  }
1112 
1113  case CK_LValueToRValue: {
1114  // We don't really support doing lvalue-to-rvalue conversions here; any
1115  // interesting conversions should be done in Evaluate(). But as a
1116  // special case, allow compound literals to support the gcc extension
1117  // allowing "struct x {int x;} x = (struct x) {};".
1118  if (auto *E = dyn_cast<CompoundLiteralExpr>(subExpr->IgnoreParens()))
1119  return Visit(E->getInitializer(), destType);
1120  return nullptr;
1121  }
1122 
1123  case CK_AtomicToNonAtomic:
1124  case CK_NonAtomicToAtomic:
1125  case CK_NoOp:
1126  case CK_ConstructorConversion:
1127  return Visit(subExpr, destType);
1128 
1129  case CK_IntToOCLSampler:
1130  llvm_unreachable("global sampler variables are not generated");
1131 
1132  case CK_Dependent: llvm_unreachable("saw dependent cast!");
1133 
1134  case CK_BuiltinFnToFnPtr:
1135  llvm_unreachable("builtin functions are handled elsewhere");
1136 
1137  case CK_ReinterpretMemberPointer:
1138  case CK_DerivedToBaseMemberPointer:
1139  case CK_BaseToDerivedMemberPointer: {
1140  auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType());
1141  if (!C) return nullptr;
1142  return CGM.getCXXABI().EmitMemberPointerConversion(E, C);
1143  }
1144 
1145  // These will never be supported.
1146  case CK_ObjCObjectLValueCast:
1147  case CK_ARCProduceObject:
1148  case CK_ARCConsumeObject:
1149  case CK_ARCReclaimReturnedObject:
1150  case CK_ARCExtendBlockObject:
1151  case CK_CopyAndAutoreleaseBlockObject:
1152  return nullptr;
1153 
1154  // These don't need to be handled here because Evaluate knows how to
1155  // evaluate them in the cases where they can be folded.
1156  case CK_BitCast:
1157  case CK_ToVoid:
1158  case CK_Dynamic:
1159  case CK_LValueBitCast:
1160  case CK_LValueToRValueBitCast:
1161  case CK_NullToMemberPointer:
1162  case CK_UserDefinedConversion:
1163  case CK_CPointerToObjCPointerCast:
1164  case CK_BlockPointerToObjCPointerCast:
1165  case CK_AnyPointerToBlockPointerCast:
1166  case CK_ArrayToPointerDecay:
1167  case CK_FunctionToPointerDecay:
1168  case CK_BaseToDerived:
1169  case CK_DerivedToBase:
1170  case CK_UncheckedDerivedToBase:
1171  case CK_MemberPointerToBoolean:
1172  case CK_VectorSplat:
1173  case CK_FloatingRealToComplex:
1174  case CK_FloatingComplexToReal:
1175  case CK_FloatingComplexToBoolean:
1176  case CK_FloatingComplexCast:
1177  case CK_FloatingComplexToIntegralComplex:
1178  case CK_IntegralRealToComplex:
1179  case CK_IntegralComplexToReal:
1180  case CK_IntegralComplexToBoolean:
1181  case CK_IntegralComplexCast:
1182  case CK_IntegralComplexToFloatingComplex:
1183  case CK_PointerToIntegral:
1184  case CK_PointerToBoolean:
1185  case CK_NullToPointer:
1186  case CK_IntegralCast:
1187  case CK_BooleanToSignedIntegral:
1188  case CK_IntegralToPointer:
1189  case CK_IntegralToBoolean:
1190  case CK_IntegralToFloating:
1191  case CK_FloatingToIntegral:
1192  case CK_FloatingToBoolean:
1193  case CK_FloatingCast:
1194  case CK_FloatingToFixedPoint:
1195  case CK_FixedPointToFloating:
1196  case CK_FixedPointCast:
1197  case CK_FixedPointToBoolean:
1198  case CK_FixedPointToIntegral:
1199  case CK_IntegralToFixedPoint:
1200  case CK_ZeroToOCLOpaqueType:
1201  case CK_MatrixCast:
1202  return nullptr;
1203  }
1204  llvm_unreachable("Invalid CastKind");
1205  }
1206 
1207  llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) {
1208  // No need for a DefaultInitExprScope: we don't handle 'this' in a
1209  // constant expression.
1210  return Visit(DIE->getExpr(), T);
1211  }
1212 
1213  llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E, QualType T) {
1214  return Visit(E->getSubExpr(), T);
1215  }
1216 
1217  llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E,
1218  QualType T) {
1219  return Visit(E->getSubExpr(), T);
1220  }
1221 
1222  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) {
1223  auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType());
1224  assert(CAT && "can't emit array init for non-constant-bound array");
1225  unsigned NumInitElements = ILE->getNumInits();
1226  unsigned NumElements = CAT->getSize().getZExtValue();
1227 
1228  // Initialising an array requires us to automatically
1229  // initialise any elements that have not been initialised explicitly
1230  unsigned NumInitableElts = std::min(NumInitElements, NumElements);
1231 
1232  QualType EltType = CAT->getElementType();
1233 
1234  // Initialize remaining array elements.
1235  llvm::Constant *fillC = nullptr;
1236  if (Expr *filler = ILE->getArrayFiller()) {
1237  fillC = Emitter.tryEmitAbstractForMemory(filler, EltType);
1238  if (!fillC)
1239  return nullptr;
1240  }
1241 
1242  // Copy initializer elements.
1244  if (fillC && fillC->isNullValue())
1245  Elts.reserve(NumInitableElts + 1);
1246  else
1247  Elts.reserve(NumElements);
1248 
1249  llvm::Type *CommonElementType = nullptr;
1250  for (unsigned i = 0; i < NumInitableElts; ++i) {
1251  Expr *Init = ILE->getInit(i);
1252  llvm::Constant *C = Emitter.tryEmitPrivateForMemory(Init, EltType);
1253  if (!C)
1254  return nullptr;
1255  if (i == 0)
1256  CommonElementType = C->getType();
1257  else if (C->getType() != CommonElementType)
1258  CommonElementType = nullptr;
1259  Elts.push_back(C);
1260  }
1261 
1262  llvm::ArrayType *Desired =
1263  cast<llvm::ArrayType>(CGM.getTypes().ConvertType(ILE->getType()));
1264  return EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts,
1265  fillC);
1266  }
1267 
1268  llvm::Constant *EmitRecordInitialization(InitListExpr *ILE, QualType T) {
1269  return ConstStructBuilder::BuildStruct(Emitter, ILE, T);
1270  }
1271 
1272  llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E,
1273  QualType T) {
1274  return CGM.EmitNullConstant(T);
1275  }
1276 
1277  llvm::Constant *VisitInitListExpr(InitListExpr *ILE, QualType T) {
1278  if (ILE->isTransparent())
1279  return Visit(ILE->getInit(0), T);
1280 
1281  if (ILE->getType()->isArrayType())
1282  return EmitArrayInitialization(ILE, T);
1283 
1284  if (ILE->getType()->isRecordType())
1285  return EmitRecordInitialization(ILE, T);
1286 
1287  return nullptr;
1288  }
1289 
1290  llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E,
1291  QualType destType) {
1292  auto C = Visit(E->getBase(), destType);
1293  if (!C)
1294  return nullptr;
1295 
1296  ConstantAggregateBuilder Const(CGM);
1297  Const.add(C, CharUnits::Zero(), false);
1298 
1299  if (!EmitDesignatedInitUpdater(Emitter, Const, CharUnits::Zero(), destType,
1300  E->getUpdater()))
1301  return nullptr;
1302 
1303  llvm::Type *ValTy = CGM.getTypes().ConvertType(destType);
1304  bool HasFlexibleArray = false;
1305  if (auto *RT = destType->getAs<RecordType>())
1306  HasFlexibleArray = RT->getDecl()->hasFlexibleArrayMember();
1307  return Const.build(ValTy, HasFlexibleArray);
1308  }
1309 
1310  llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E, QualType Ty) {
1311  if (!E->getConstructor()->isTrivial())
1312  return nullptr;
1313 
1314  // Only default and copy/move constructors can be trivial.
1315  if (E->getNumArgs()) {
1316  assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
1317  assert(E->getConstructor()->isCopyOrMoveConstructor() &&
1318  "trivial ctor has argument but isn't a copy/move ctor");
1319 
1320  Expr *Arg = E->getArg(0);
1321  assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
1322  "argument to copy ctor is of wrong type");
1323 
1324  return Visit(Arg, Ty);
1325  }
1326 
1327  return CGM.EmitNullConstant(Ty);
1328  }
1329 
1330  llvm::Constant *VisitStringLiteral(StringLiteral *E, QualType T) {
1331  // This is a string literal initializing an array in an initializer.
1332  return CGM.GetConstantArrayFromStringLiteral(E);
1333  }
1334 
1335  llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E, QualType T) {
1336  // This must be an @encode initializing an array in a static initializer.
1337  // Don't emit it as the address of the string, emit the string data itself
1338  // as an inline array.
1339  std::string Str;
1341  const ConstantArrayType *CAT = CGM.getContext().getAsConstantArrayType(T);
1342 
1343  // Resize the string to the right size, adding zeros at the end, or
1344  // truncating as needed.
1345  Str.resize(CAT->getSize().getZExtValue(), '\0');
1346  return llvm::ConstantDataArray::getString(VMContext, Str, false);
1347  }
1348 
1349  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E, QualType T) {
1350  return Visit(E->getSubExpr(), T);
1351  }
1352 
1353  // Utility methods
1354  llvm::Type *ConvertType(QualType T) {
1355  return CGM.getTypes().ConvertType(T);
1356  }
1357 };
1358 
1359 } // end anonymous namespace.
1360 
1361 llvm::Constant *ConstantEmitter::validateAndPopAbstract(llvm::Constant *C,
1362  AbstractState saved) {
1363  Abstract = saved.OldValue;
1364 
1365  assert(saved.OldPlaceholdersSize == PlaceholderAddresses.size() &&
1366  "created a placeholder while doing an abstract emission?");
1367 
1368  // No validation necessary for now.
1369  // No cleanup to do for now.
1370  return C;
1371 }
1372 
1373 llvm::Constant *
1375  auto state = pushAbstract();
1376  auto C = tryEmitPrivateForVarInit(D);
1377  return validateAndPopAbstract(C, state);
1378 }
1379 
1380 llvm::Constant *
1382  auto state = pushAbstract();
1383  auto C = tryEmitPrivate(E, destType);
1384  return validateAndPopAbstract(C, state);
1385 }
1386 
1387 llvm::Constant *
1389  auto state = pushAbstract();
1390  auto C = tryEmitPrivate(value, destType);
1391  return validateAndPopAbstract(C, state);
1392 }
1393 
1395  if (!CE->hasAPValueResult())
1396  return nullptr;
1397 
1398  QualType RetType = CE->getType();
1399  if (CE->isGLValue())
1400  RetType = CGM.getContext().getLValueReferenceType(RetType);
1401 
1402  return emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(), RetType);
1403 }
1404 
1405 llvm::Constant *
1407  auto state = pushAbstract();
1408  auto C = tryEmitPrivate(E, destType);
1409  C = validateAndPopAbstract(C, state);
1410  if (!C) {
1411  CGM.Error(E->getExprLoc(),
1412  "internal error: could not emit constant value \"abstractly\"");
1413  C = CGM.EmitNullConstant(destType);
1414  }
1415  return C;
1416 }
1417 
1418 llvm::Constant *
1420  QualType destType) {
1421  auto state = pushAbstract();
1422  auto C = tryEmitPrivate(value, destType);
1423  C = validateAndPopAbstract(C, state);
1424  if (!C) {
1425  CGM.Error(loc,
1426  "internal error: could not emit constant value \"abstractly\"");
1427  C = CGM.EmitNullConstant(destType);
1428  }
1429  return C;
1430 }
1431 
1433  initializeNonAbstract(D.getType().getAddressSpace());
1434  return markIfFailed(tryEmitPrivateForVarInit(D));
1435 }
1436 
1438  LangAS destAddrSpace,
1439  QualType destType) {
1440  initializeNonAbstract(destAddrSpace);
1441  return markIfFailed(tryEmitPrivateForMemory(E, destType));
1442 }
1443 
1444 llvm::Constant *ConstantEmitter::emitForInitializer(const APValue &value,
1445  LangAS destAddrSpace,
1446  QualType destType) {
1447  initializeNonAbstract(destAddrSpace);
1448  auto C = tryEmitPrivateForMemory(value, destType);
1449  assert(C && "couldn't emit constant value non-abstractly?");
1450  return C;
1451 }
1452 
1454  assert(!Abstract && "cannot get current address for abstract constant");
1455 
1456 
1457 
1458  // Make an obviously ill-formed global that should blow up compilation
1459  // if it survives.
1460  auto global = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty, true,
1461  llvm::GlobalValue::PrivateLinkage,
1462  /*init*/ nullptr,
1463  /*name*/ "",
1464  /*before*/ nullptr,
1465  llvm::GlobalVariable::NotThreadLocal,
1466  CGM.getContext().getTargetAddressSpace(DestAddressSpace));
1467 
1468  PlaceholderAddresses.push_back(std::make_pair(nullptr, global));
1469 
1470  return global;
1471 }
1472 
1474  llvm::GlobalValue *placeholder) {
1475  assert(!PlaceholderAddresses.empty());
1476  assert(PlaceholderAddresses.back().first == nullptr);
1477  assert(PlaceholderAddresses.back().second == placeholder);
1478  PlaceholderAddresses.back().first = signal;
1479 }
1480 
1481 namespace {
1482  struct ReplacePlaceholders {
1483  CodeGenModule &CGM;
1484 
1485  /// The base address of the global.
1486  llvm::Constant *Base;
1487  llvm::Type *BaseValueTy = nullptr;
1488 
1489  /// The placeholder addresses that were registered during emission.
1490  llvm::DenseMap<llvm::Constant*, llvm::GlobalVariable*> PlaceholderAddresses;
1491 
1492  /// The locations of the placeholder signals.
1493  llvm::DenseMap<llvm::GlobalVariable*, llvm::Constant*> Locations;
1494 
1495  /// The current index stack. We use a simple unsigned stack because
1496  /// we assume that placeholders will be relatively sparse in the
1497  /// initializer, but we cache the index values we find just in case.
1500 
1501  ReplacePlaceholders(CodeGenModule &CGM, llvm::Constant *base,
1502  ArrayRef<std::pair<llvm::Constant*,
1503  llvm::GlobalVariable*>> addresses)
1504  : CGM(CGM), Base(base),
1505  PlaceholderAddresses(addresses.begin(), addresses.end()) {
1506  }
1507 
1508  void replaceInInitializer(llvm::Constant *init) {
1509  // Remember the type of the top-most initializer.
1510  BaseValueTy = init->getType();
1511 
1512  // Initialize the stack.
1513  Indices.push_back(0);
1514  IndexValues.push_back(nullptr);
1515 
1516  // Recurse into the initializer.
1517  findLocations(init);
1518 
1519  // Check invariants.
1520  assert(IndexValues.size() == Indices.size() && "mismatch");
1521  assert(Indices.size() == 1 && "didn't pop all indices");
1522 
1523  // Do the replacement; this basically invalidates 'init'.
1524  assert(Locations.size() == PlaceholderAddresses.size() &&
1525  "missed a placeholder?");
1526 
1527  // We're iterating over a hashtable, so this would be a source of
1528  // non-determinism in compiler output *except* that we're just
1529  // messing around with llvm::Constant structures, which never itself
1530  // does anything that should be visible in compiler output.
1531  for (auto &entry : Locations) {
1532  assert(entry.first->getParent() == nullptr && "not a placeholder!");
1533  entry.first->replaceAllUsesWith(entry.second);
1534  entry.first->eraseFromParent();
1535  }
1536  }
1537 
1538  private:
1539  void findLocations(llvm::Constant *init) {
1540  // Recurse into aggregates.
1541  if (auto agg = dyn_cast<llvm::ConstantAggregate>(init)) {
1542  for (unsigned i = 0, e = agg->getNumOperands(); i != e; ++i) {
1543  Indices.push_back(i);
1544  IndexValues.push_back(nullptr);
1545 
1546  findLocations(agg->getOperand(i));
1547 
1548  IndexValues.pop_back();
1549  Indices.pop_back();
1550  }
1551  return;
1552  }
1553 
1554  // Otherwise, check for registered constants.
1555  while (true) {
1556  auto it = PlaceholderAddresses.find(init);
1557  if (it != PlaceholderAddresses.end()) {
1558  setLocation(it->second);
1559  break;
1560  }
1561 
1562  // Look through bitcasts or other expressions.
1563  if (auto expr = dyn_cast<llvm::ConstantExpr>(init)) {
1564  init = expr->getOperand(0);
1565  } else {
1566  break;
1567  }
1568  }
1569  }
1570 
1571  void setLocation(llvm::GlobalVariable *placeholder) {
1572  assert(Locations.find(placeholder) == Locations.end() &&
1573  "already found location for placeholder!");
1574 
1575  // Lazily fill in IndexValues with the values from Indices.
1576  // We do this in reverse because we should always have a strict
1577  // prefix of indices from the start.
1578  assert(Indices.size() == IndexValues.size());
1579  for (size_t i = Indices.size() - 1; i != size_t(-1); --i) {
1580  if (IndexValues[i]) {
1581 #ifndef NDEBUG
1582  for (size_t j = 0; j != i + 1; ++j) {
1583  assert(IndexValues[j] &&
1584  isa<llvm::ConstantInt>(IndexValues[j]) &&
1585  cast<llvm::ConstantInt>(IndexValues[j])->getZExtValue()
1586  == Indices[j]);
1587  }
1588 #endif
1589  break;
1590  }
1591 
1592  IndexValues[i] = llvm::ConstantInt::get(CGM.Int32Ty, Indices[i]);
1593  }
1594 
1595  // Form a GEP and then bitcast to the placeholder type so that the
1596  // replacement will succeed.
1597  llvm::Constant *location =
1598  llvm::ConstantExpr::getInBoundsGetElementPtr(BaseValueTy,
1599  Base, IndexValues);
1600  location = llvm::ConstantExpr::getBitCast(location,
1601  placeholder->getType());
1602 
1603  Locations.insert({placeholder, location});
1604  }
1605  };
1606 }
1607 
1608 void ConstantEmitter::finalize(llvm::GlobalVariable *global) {
1609  assert(InitializedNonAbstract &&
1610  "finalizing emitter that was used for abstract emission?");
1611  assert(!Finalized && "finalizing emitter multiple times");
1612  assert(global->getInitializer());
1613 
1614  // Note that we might also be Failed.
1615  Finalized = true;
1616 
1617  if (!PlaceholderAddresses.empty()) {
1618  ReplacePlaceholders(CGM, global, PlaceholderAddresses)
1619  .replaceInInitializer(global->getInitializer());
1620  PlaceholderAddresses.clear(); // satisfy
1621  }
1622 }
1623 
1625  assert((!InitializedNonAbstract || Finalized || Failed) &&
1626  "not finalized after being initialized for non-abstract emission");
1627  assert(PlaceholderAddresses.empty() && "unhandled placeholders");
1628 }
1629 
1631  if (auto AT = type->getAs<AtomicType>()) {
1632  return CGM.getContext().getQualifiedType(AT->getValueType(),
1633  type.getQualifiers());
1634  }
1635  return type;
1636 }
1637 
1639  // Make a quick check if variable can be default NULL initialized
1640  // and avoid going through rest of code which may do, for c++11,
1641  // initialization of memory to all NULLs.
1642  if (!D.hasLocalStorage()) {
1644  if (Ty->isRecordType())
1645  if (const CXXConstructExpr *E =
1646  dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
1647  const CXXConstructorDecl *CD = E->getConstructor();
1648  if (CD->isTrivial() && CD->isDefaultConstructor())
1649  return CGM.EmitNullConstant(D.getType());
1650  }
1651  }
1652  InConstantContext = D.hasConstantInitialization();
1653 
1654  QualType destType = D.getType();
1655 
1656  // Try to emit the initializer. Note that this can allow some things that
1657  // are not allowed by tryEmitPrivateForMemory alone.
1658  if (auto value = D.evaluateValue()) {
1659  return tryEmitPrivateForMemory(*value, destType);
1660  }
1661 
1662  // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
1663  // reference is a constant expression, and the reference binds to a temporary,
1664  // then constant initialization is performed. ConstExprEmitter will
1665  // incorrectly emit a prvalue constant in this case, and the calling code
1666  // interprets that as the (pointer) value of the reference, rather than the
1667  // desired value of the referee.
1668  if (destType->isReferenceType())
1669  return nullptr;
1670 
1671  const Expr *E = D.getInit();
1672  assert(E && "No initializer to emit");
1673 
1674  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1675  auto C =
1676  ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), nonMemoryDestType);
1677  return (C ? emitForMemory(C, destType) : nullptr);
1678 }
1679 
1680 llvm::Constant *
1682  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1683  auto C = tryEmitAbstract(E, nonMemoryDestType);
1684  return (C ? emitForMemory(C, destType) : nullptr);
1685 }
1686 
1687 llvm::Constant *
1689  QualType destType) {
1690  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1691  auto C = tryEmitAbstract(value, nonMemoryDestType);
1692  return (C ? emitForMemory(C, destType) : nullptr);
1693 }
1694 
1696  QualType destType) {
1697  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1698  llvm::Constant *C = tryEmitPrivate(E, nonMemoryDestType);
1699  return (C ? emitForMemory(C, destType) : nullptr);
1700 }
1701 
1703  QualType destType) {
1704  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1705  auto C = tryEmitPrivate(value, nonMemoryDestType);
1706  return (C ? emitForMemory(C, destType) : nullptr);
1707 }
1708 
1710  llvm::Constant *C,
1711  QualType destType) {
1712  // For an _Atomic-qualified constant, we may need to add tail padding.
1713  if (auto AT = destType->getAs<AtomicType>()) {
1714  QualType destValueType = AT->getValueType();
1715  C = emitForMemory(CGM, C, destValueType);
1716 
1717  uint64_t innerSize = CGM.getContext().getTypeSize(destValueType);
1718  uint64_t outerSize = CGM.getContext().getTypeSize(destType);
1719  if (innerSize == outerSize)
1720  return C;
1721 
1722  assert(innerSize < outerSize && "emitted over-large constant for atomic");
1723  llvm::Constant *elts[] = {
1724  C,
1725  llvm::ConstantAggregateZero::get(
1726  llvm::ArrayType::get(CGM.Int8Ty, (outerSize - innerSize) / 8))
1727  };
1728  return llvm::ConstantStruct::getAnon(elts);
1729  }
1730 
1731  // Zero-extend bool.
1732  if (C->getType()->isIntegerTy(1)) {
1733  llvm::Type *boolTy = CGM.getTypes().ConvertTypeForMem(destType);
1734  return llvm::ConstantExpr::getZExt(C, boolTy);
1735  }
1736 
1737  return C;
1738 }
1739 
1740 llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E,
1741  QualType destType) {
1742  assert(!destType->isVoidType() && "can't emit a void constant");
1743 
1744  Expr::EvalResult Result;
1745 
1746  bool Success = false;
1747 
1748  if (destType->isReferenceType())
1749  Success = E->EvaluateAsLValue(Result, CGM.getContext());
1750  else
1751  Success = E->EvaluateAsRValue(Result, CGM.getContext(), InConstantContext);
1752 
1753  llvm::Constant *C;
1754  if (Success && !Result.HasSideEffects)
1755  C = tryEmitPrivate(Result.Val, destType);
1756  else
1757  C = ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), destType);
1758 
1759  return C;
1760 }
1761 
1762 llvm::Constant *CodeGenModule::getNullPointer(llvm::PointerType *T, QualType QT) {
1763  return getTargetCodeGenInfo().getNullPointer(*this, T, QT);
1764 }
1765 
1766 namespace {
1767 /// A struct which can be used to peephole certain kinds of finalization
1768 /// that normally happen during l-value emission.
1769 struct ConstantLValue {
1770  llvm::Constant *Value;
1771  bool HasOffsetApplied;
1772 
1773  /*implicit*/ ConstantLValue(llvm::Constant *value,
1774  bool hasOffsetApplied = false)
1775  : Value(value), HasOffsetApplied(hasOffsetApplied) {}
1776 
1777  /*implicit*/ ConstantLValue(ConstantAddress address)
1778  : ConstantLValue(address.getPointer()) {}
1779 };
1780 
1781 /// A helper class for emitting constant l-values.
1782 class ConstantLValueEmitter : public ConstStmtVisitor<ConstantLValueEmitter,
1783  ConstantLValue> {
1784  CodeGenModule &CGM;
1786  const APValue &Value;
1787  QualType DestType;
1788 
1789  // Befriend StmtVisitorBase so that we don't have to expose Visit*.
1790  friend StmtVisitorBase;
1791 
1792 public:
1793  ConstantLValueEmitter(ConstantEmitter &emitter, const APValue &value,
1794  QualType destType)
1795  : CGM(emitter.CGM), Emitter(emitter), Value(value), DestType(destType) {}
1796 
1797  llvm::Constant *tryEmit();
1798 
1799 private:
1800  llvm::Constant *tryEmitAbsolute(llvm::Type *destTy);
1801  ConstantLValue tryEmitBase(const APValue::LValueBase &base);
1802 
1803  ConstantLValue VisitStmt(const Stmt *S) { return nullptr; }
1804  ConstantLValue VisitConstantExpr(const ConstantExpr *E);
1805  ConstantLValue VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
1806  ConstantLValue VisitStringLiteral(const StringLiteral *E);
1807  ConstantLValue VisitObjCBoxedExpr(const ObjCBoxedExpr *E);
1808  ConstantLValue VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
1809  ConstantLValue VisitObjCStringLiteral(const ObjCStringLiteral *E);
1810  ConstantLValue VisitPredefinedExpr(const PredefinedExpr *E);
1811  ConstantLValue VisitAddrLabelExpr(const AddrLabelExpr *E);
1812  ConstantLValue VisitCallExpr(const CallExpr *E);
1813  ConstantLValue VisitBlockExpr(const BlockExpr *E);
1814  ConstantLValue VisitCXXTypeidExpr(const CXXTypeidExpr *E);
1815  ConstantLValue VisitMaterializeTemporaryExpr(
1816  const MaterializeTemporaryExpr *E);
1817 
1818  bool hasNonZeroOffset() const {
1819  return !Value.getLValueOffset().isZero();
1820  }
1821 
1822  /// Return the value offset.
1823  llvm::Constant *getOffset() {
1824  return llvm::ConstantInt::get(CGM.Int64Ty,
1825  Value.getLValueOffset().getQuantity());
1826  }
1827 
1828  /// Apply the value offset to the given constant.
1829  llvm::Constant *applyOffset(llvm::Constant *C) {
1830  if (!hasNonZeroOffset())
1831  return C;
1832 
1833  llvm::Type *origPtrTy = C->getType();
1834  unsigned AS = origPtrTy->getPointerAddressSpace();
1835  llvm::Type *charPtrTy = CGM.Int8Ty->getPointerTo(AS);
1836  C = llvm::ConstantExpr::getBitCast(C, charPtrTy);
1837  C = llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, C, getOffset());
1838  C = llvm::ConstantExpr::getPointerCast(C, origPtrTy);
1839  return C;
1840  }
1841 };
1842 
1843 }
1844 
1845 llvm::Constant *ConstantLValueEmitter::tryEmit() {
1846  const APValue::LValueBase &base = Value.getLValueBase();
1847 
1848  // The destination type should be a pointer or reference
1849  // type, but it might also be a cast thereof.
1850  //
1851  // FIXME: the chain of casts required should be reflected in the APValue.
1852  // We need this in order to correctly handle things like a ptrtoint of a
1853  // non-zero null pointer and addrspace casts that aren't trivially
1854  // represented in LLVM IR.
1855  auto destTy = CGM.getTypes().ConvertTypeForMem(DestType);
1856  assert(isa<llvm::IntegerType>(destTy) || isa<llvm::PointerType>(destTy));
1857 
1858  // If there's no base at all, this is a null or absolute pointer,
1859  // possibly cast back to an integer type.
1860  if (!base) {
1861  return tryEmitAbsolute(destTy);
1862  }
1863 
1864  // Otherwise, try to emit the base.
1865  ConstantLValue result = tryEmitBase(base);
1866 
1867  // If that failed, we're done.
1868  llvm::Constant *value = result.Value;
1869  if (!value) return nullptr;
1870 
1871  // Apply the offset if necessary and not already done.
1872  if (!result.HasOffsetApplied) {
1873  value = applyOffset(value);
1874  }
1875 
1876  // Convert to the appropriate type; this could be an lvalue for
1877  // an integer. FIXME: performAddrSpaceCast
1878  if (isa<llvm::PointerType>(destTy))
1879  return llvm::ConstantExpr::getPointerCast(value, destTy);
1880 
1881  return llvm::ConstantExpr::getPtrToInt(value, destTy);
1882 }
1883 
1884 /// Try to emit an absolute l-value, such as a null pointer or an integer
1885 /// bitcast to pointer type.
1886 llvm::Constant *
1887 ConstantLValueEmitter::tryEmitAbsolute(llvm::Type *destTy) {
1888  // If we're producing a pointer, this is easy.
1889  auto destPtrTy = cast<llvm::PointerType>(destTy);
1890  if (Value.isNullPointer()) {
1891  // FIXME: integer offsets from non-zero null pointers.
1892  return CGM.getNullPointer(destPtrTy, DestType);
1893  }
1894 
1895  // Convert the integer to a pointer-sized integer before converting it
1896  // to a pointer.
1897  // FIXME: signedness depends on the original integer type.
1898  auto intptrTy = CGM.getDataLayout().getIntPtrType(destPtrTy);
1899  llvm::Constant *C;
1900  C = llvm::ConstantExpr::getIntegerCast(getOffset(), intptrTy,
1901  /*isSigned*/ false);
1902  C = llvm::ConstantExpr::getIntToPtr(C, destPtrTy);
1903  return C;
1904 }
1905 
1906 ConstantLValue
1907 ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
1908  // Handle values.
1909  if (const ValueDecl *D = base.dyn_cast<const ValueDecl*>()) {
1910  // The constant always points to the canonical declaration. We want to look
1911  // at properties of the most recent declaration at the point of emission.
1912  D = cast<ValueDecl>(D->getMostRecentDecl());
1913 
1914  if (D->hasAttr<WeakRefAttr>())
1915  return CGM.GetWeakRefReference(D).getPointer();
1916 
1917  if (auto FD = dyn_cast<FunctionDecl>(D))
1918  return CGM.GetAddrOfFunction(FD);
1919 
1920  if (auto VD = dyn_cast<VarDecl>(D)) {
1921  // We can never refer to a variable with local storage.
1922  if (!VD->hasLocalStorage()) {
1923  if (VD->isFileVarDecl() || VD->hasExternalStorage())
1924  return CGM.GetAddrOfGlobalVar(VD);
1925 
1926  if (VD->isLocalVarDecl()) {
1927  return CGM.getOrCreateStaticVarDecl(
1928  *VD, CGM.getLLVMLinkageVarDefinition(VD, /*IsConstant=*/false));
1929  }
1930  }
1931  }
1932 
1933  if (auto *GD = dyn_cast<MSGuidDecl>(D))
1934  return CGM.GetAddrOfMSGuidDecl(GD);
1935 
1936  if (auto *GCD = dyn_cast<UnnamedGlobalConstantDecl>(D))
1937  return CGM.GetAddrOfUnnamedGlobalConstantDecl(GCD);
1938 
1939  if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(D))
1940  return CGM.GetAddrOfTemplateParamObject(TPO);
1941 
1942  return nullptr;
1943  }
1944 
1945  // Handle typeid(T).
1946  if (TypeInfoLValue TI = base.dyn_cast<TypeInfoLValue>()) {
1947  llvm::Type *StdTypeInfoPtrTy =
1948  CGM.getTypes().ConvertType(base.getTypeInfoType())->getPointerTo();
1949  llvm::Constant *TypeInfo =
1950  CGM.GetAddrOfRTTIDescriptor(QualType(TI.getType(), 0));
1951  if (TypeInfo->getType() != StdTypeInfoPtrTy)
1952  TypeInfo = llvm::ConstantExpr::getBitCast(TypeInfo, StdTypeInfoPtrTy);
1953  return TypeInfo;
1954  }
1955 
1956  // Otherwise, it must be an expression.
1957  return Visit(base.get<const Expr*>());
1958 }
1959 
1960 ConstantLValue
1961 ConstantLValueEmitter::VisitConstantExpr(const ConstantExpr *E) {
1962  if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(E))
1963  return Result;
1964  return Visit(E->getSubExpr());
1965 }
1966 
1967 ConstantLValue
1968 ConstantLValueEmitter::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
1969  ConstantEmitter CompoundLiteralEmitter(CGM, Emitter.CGF);
1970  CompoundLiteralEmitter.setInConstantContext(Emitter.isInConstantContext());
1971  return tryEmitGlobalCompoundLiteral(CompoundLiteralEmitter, E);
1972 }
1973 
1974 ConstantLValue
1975 ConstantLValueEmitter::VisitStringLiteral(const StringLiteral *E) {
1976  return CGM.GetAddrOfConstantStringFromLiteral(E);
1977 }
1978 
1979 ConstantLValue
1980 ConstantLValueEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
1982 }
1983 
1984 static ConstantLValue emitConstantObjCStringLiteral(const StringLiteral *S,
1985  QualType T,
1986  CodeGenModule &CGM) {
1987  auto C = CGM.getObjCRuntime().GenerateConstantString(S);
1988  return C.getElementBitCast(CGM.getTypes().ConvertTypeForMem(T));
1989 }
1990 
1991 ConstantLValue
1992 ConstantLValueEmitter::VisitObjCStringLiteral(const ObjCStringLiteral *E) {
1993  return emitConstantObjCStringLiteral(E->getString(), E->getType(), CGM);
1994 }
1995 
1996 ConstantLValue
1997 ConstantLValueEmitter::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
1998  assert(E->isExpressibleAsConstantInitializer() &&
1999  "this boxed expression can't be emitted as a compile-time constant");
2000  auto *SL = cast<StringLiteral>(E->getSubExpr()->IgnoreParenCasts());
2001  return emitConstantObjCStringLiteral(SL, E->getType(), CGM);
2002 }
2003 
2004 ConstantLValue
2005 ConstantLValueEmitter::VisitPredefinedExpr(const PredefinedExpr *E) {
2007 }
2008 
2009 ConstantLValue
2010 ConstantLValueEmitter::VisitAddrLabelExpr(const AddrLabelExpr *E) {
2011  assert(Emitter.CGF && "Invalid address of label expression outside function");
2012  llvm::Constant *Ptr = Emitter.CGF->GetAddrOfLabel(E->getLabel());
2013  Ptr = llvm::ConstantExpr::getBitCast(Ptr,
2014  CGM.getTypes().ConvertType(E->getType()));
2015  return Ptr;
2016 }
2017 
2018 ConstantLValue
2019 ConstantLValueEmitter::VisitCallExpr(const CallExpr *E) {
2020  unsigned builtin = E->getBuiltinCallee();
2021  if (builtin == Builtin::BI__builtin_function_start)
2022  return CGM.GetFunctionStart(
2024  if (builtin != Builtin::BI__builtin___CFStringMakeConstantString &&
2025  builtin != Builtin::BI__builtin___NSStringMakeConstantString)
2026  return nullptr;
2027 
2028  auto literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts());
2029  if (builtin == Builtin::BI__builtin___NSStringMakeConstantString) {
2030  return CGM.getObjCRuntime().GenerateConstantString(literal);
2031  } else {
2032  // FIXME: need to deal with UCN conversion issues.
2033  return CGM.GetAddrOfConstantCFString(literal);
2034  }
2035 }
2036 
2037 ConstantLValue
2038 ConstantLValueEmitter::VisitBlockExpr(const BlockExpr *E) {
2039  StringRef functionName;
2040  if (auto CGF = Emitter.CGF)
2041  functionName = CGF->CurFn->getName();
2042  else
2043  functionName = "global";
2044 
2045  return CGM.GetAddrOfGlobalBlock(E, functionName);
2046 }
2047 
2048 ConstantLValue
2049 ConstantLValueEmitter::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
2050  QualType T;
2051  if (E->isTypeOperand())
2052  T = E->getTypeOperand(CGM.getContext());
2053  else
2054  T = E->getExprOperand()->getType();
2055  return CGM.GetAddrOfRTTIDescriptor(T);
2056 }
2057 
2058 ConstantLValue
2059 ConstantLValueEmitter::VisitMaterializeTemporaryExpr(
2060  const MaterializeTemporaryExpr *E) {
2061  assert(E->getStorageDuration() == SD_Static);
2062  SmallVector<const Expr *, 2> CommaLHSs;
2064  const Expr *Inner =
2065  E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
2066  return CGM.GetAddrOfGlobalTemporary(E, Inner);
2067 }
2068 
2070  QualType DestType) {
2071  switch (Value.getKind()) {
2072  case APValue::None:
2074  // Out-of-lifetime and indeterminate values can be modeled as 'undef'.
2075  return llvm::UndefValue::get(CGM.getTypes().ConvertType(DestType));
2076  case APValue::LValue:
2077  return ConstantLValueEmitter(*this, Value, DestType).tryEmit();
2078  case APValue::Int:
2079  return llvm::ConstantInt::get(CGM.getLLVMContext(), Value.getInt());
2080  case APValue::FixedPoint:
2081  return llvm::ConstantInt::get(CGM.getLLVMContext(),
2082  Value.getFixedPoint().getValue());
2083  case APValue::ComplexInt: {
2084  llvm::Constant *Complex[2];
2085 
2086  Complex[0] = llvm::ConstantInt::get(CGM.getLLVMContext(),
2087  Value.getComplexIntReal());
2088  Complex[1] = llvm::ConstantInt::get(CGM.getLLVMContext(),
2089  Value.getComplexIntImag());
2090 
2091  // FIXME: the target may want to specify that this is packed.
2092  llvm::StructType *STy =
2093  llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType());
2094  return llvm::ConstantStruct::get(STy, Complex);
2095  }
2096  case APValue::Float: {
2097  const llvm::APFloat &Init = Value.getFloat();
2098  if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf() &&
2099  !CGM.getContext().getLangOpts().NativeHalfType &&
2101  return llvm::ConstantInt::get(CGM.getLLVMContext(),
2102  Init.bitcastToAPInt());
2103  else
2104  return llvm::ConstantFP::get(CGM.getLLVMContext(), Init);
2105  }
2106  case APValue::ComplexFloat: {
2107  llvm::Constant *Complex[2];
2108 
2109  Complex[0] = llvm::ConstantFP::get(CGM.getLLVMContext(),
2110  Value.getComplexFloatReal());
2111  Complex[1] = llvm::ConstantFP::get(CGM.getLLVMContext(),
2112  Value.getComplexFloatImag());
2113 
2114  // FIXME: the target may want to specify that this is packed.
2115  llvm::StructType *STy =
2116  llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType());
2117  return llvm::ConstantStruct::get(STy, Complex);
2118  }
2119  case APValue::Vector: {
2120  unsigned NumElts = Value.getVectorLength();
2121  SmallVector<llvm::Constant *, 4> Inits(NumElts);
2122 
2123  for (unsigned I = 0; I != NumElts; ++I) {
2124  const APValue &Elt = Value.getVectorElt(I);
2125  if (Elt.isInt())
2126  Inits[I] = llvm::ConstantInt::get(CGM.getLLVMContext(), Elt.getInt());
2127  else if (Elt.isFloat())
2128  Inits[I] = llvm::ConstantFP::get(CGM.getLLVMContext(), Elt.getFloat());
2129  else
2130  llvm_unreachable("unsupported vector element type");
2131  }
2132  return llvm::ConstantVector::get(Inits);
2133  }
2134  case APValue::AddrLabelDiff: {
2135  const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
2136  const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
2137  llvm::Constant *LHS = tryEmitPrivate(LHSExpr, LHSExpr->getType());
2138  llvm::Constant *RHS = tryEmitPrivate(RHSExpr, RHSExpr->getType());
2139  if (!LHS || !RHS) return nullptr;
2140 
2141  // Compute difference
2142  llvm::Type *ResultType = CGM.getTypes().ConvertType(DestType);
2143  LHS = llvm::ConstantExpr::getPtrToInt(LHS, CGM.IntPtrTy);
2144  RHS = llvm::ConstantExpr::getPtrToInt(RHS, CGM.IntPtrTy);
2145  llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
2146 
2147  // LLVM is a bit sensitive about the exact format of the
2148  // address-of-label difference; make sure to truncate after
2149  // the subtraction.
2150  return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
2151  }
2152  case APValue::Struct:
2153  case APValue::Union:
2154  return ConstStructBuilder::BuildStruct(*this, Value, DestType);
2155  case APValue::Array: {
2156  const ArrayType *ArrayTy = CGM.getContext().getAsArrayType(DestType);
2157  unsigned NumElements = Value.getArraySize();
2158  unsigned NumInitElts = Value.getArrayInitializedElts();
2159 
2160  // Emit array filler, if there is one.
2161  llvm::Constant *Filler = nullptr;
2162  if (Value.hasArrayFiller()) {
2163  Filler = tryEmitAbstractForMemory(Value.getArrayFiller(),
2164  ArrayTy->getElementType());
2165  if (!Filler)
2166  return nullptr;
2167  }
2168 
2169  // Emit initializer elements.
2171  if (Filler && Filler->isNullValue())
2172  Elts.reserve(NumInitElts + 1);
2173  else
2174  Elts.reserve(NumElements);
2175 
2176  llvm::Type *CommonElementType = nullptr;
2177  for (unsigned I = 0; I < NumInitElts; ++I) {
2178  llvm::Constant *C = tryEmitPrivateForMemory(
2179  Value.getArrayInitializedElt(I), ArrayTy->getElementType());
2180  if (!C) return nullptr;
2181 
2182  if (I == 0)
2183  CommonElementType = C->getType();
2184  else if (C->getType() != CommonElementType)
2185  CommonElementType = nullptr;
2186  Elts.push_back(C);
2187  }
2188 
2189  llvm::ArrayType *Desired =
2190  cast<llvm::ArrayType>(CGM.getTypes().ConvertType(DestType));
2191  return EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts,
2192  Filler);
2193  }
2195  return CGM.getCXXABI().EmitMemberPointer(Value, DestType);
2196  }
2197  llvm_unreachable("Unknown APValue kind");
2198 }
2199 
2201  const CompoundLiteralExpr *E) {
2202  return EmittedCompoundLiterals.lookup(E);
2203 }
2204 
2206  const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV) {
2207  bool Ok = EmittedCompoundLiterals.insert(std::make_pair(CLE, GV)).second;
2208  (void)Ok;
2209  assert(Ok && "CLE has already been emitted!");
2210 }
2211 
2214  assert(E->isFileScope() && "not a file-scope compound literal expr");
2215  ConstantEmitter emitter(*this);
2216  return tryEmitGlobalCompoundLiteral(emitter, E);
2217 }
2218 
2219 llvm::Constant *
2221  // Member pointer constants always have a very particular form.
2222  const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
2223  const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
2224 
2225  // A member function pointer.
2226  if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
2227  return getCXXABI().EmitMemberFunctionPointer(method);
2228 
2229  // Otherwise, a member data pointer.
2230  uint64_t fieldOffset = getContext().getFieldOffset(decl);
2231  CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
2232  return getCXXABI().EmitMemberDataPointer(type, chars);
2233 }
2234 
2235 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
2236  llvm::Type *baseType,
2237  const CXXRecordDecl *base);
2238 
2239 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
2240  const RecordDecl *record,
2241  bool asCompleteObject) {
2242  const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
2243  llvm::StructType *structure =
2244  (asCompleteObject ? layout.getLLVMType()
2245  : layout.getBaseSubobjectLLVMType());
2246 
2247  unsigned numElements = structure->getNumElements();
2248  std::vector<llvm::Constant *> elements(numElements);
2249 
2250  auto CXXR = dyn_cast<CXXRecordDecl>(record);
2251  // Fill in all the bases.
2252  if (CXXR) {
2253  for (const auto &I : CXXR->bases()) {
2254  if (I.isVirtual()) {
2255  // Ignore virtual bases; if we're laying out for a complete
2256  // object, we'll lay these out later.
2257  continue;
2258  }
2259 
2260  const CXXRecordDecl *base =
2261  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
2262 
2263  // Ignore empty bases.
2264  if (base->isEmpty() ||
2266  .isZero())
2267  continue;
2268 
2269  unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
2270  llvm::Type *baseType = structure->getElementType(fieldIndex);
2271  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
2272  }
2273  }
2274 
2275  // Fill in all the fields.
2276  for (const auto *Field : record->fields()) {
2277  // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
2278  // will fill in later.)
2279  if (!Field->isBitField() && !Field->isZeroSize(CGM.getContext())) {
2280  unsigned fieldIndex = layout.getLLVMFieldNo(Field);
2281  elements[fieldIndex] = CGM.EmitNullConstant(Field->getType());
2282  }
2283 
2284  // For unions, stop after the first named field.
2285  if (record->isUnion()) {
2286  if (Field->getIdentifier())
2287  break;
2288  if (const auto *FieldRD = Field->getType()->getAsRecordDecl())
2289  if (FieldRD->findFirstNamedDataMember())
2290  break;
2291  }
2292  }
2293 
2294  // Fill in the virtual bases, if we're working with the complete object.
2295  if (CXXR && asCompleteObject) {
2296  for (const auto &I : CXXR->vbases()) {
2297  const CXXRecordDecl *base =
2298  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
2299 
2300  // Ignore empty bases.
2301  if (base->isEmpty())
2302  continue;
2303 
2304  unsigned fieldIndex = layout.getVirtualBaseIndex(base);
2305 
2306  // We might have already laid this field out.
2307  if (elements[fieldIndex]) continue;
2308 
2309  llvm::Type *baseType = structure->getElementType(fieldIndex);
2310  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
2311  }
2312  }
2313 
2314  // Now go through all other fields and zero them out.
2315  for (unsigned i = 0; i != numElements; ++i) {
2316  if (!elements[i])
2317  elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
2318  }
2319 
2320  return llvm::ConstantStruct::get(structure, elements);
2321 }
2322 
2323 /// Emit the null constant for a base subobject.
2324 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
2325  llvm::Type *baseType,
2326  const CXXRecordDecl *base) {
2327  const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
2328 
2329  // Just zero out bases that don't have any pointer to data members.
2330  if (baseLayout.isZeroInitializableAsBase())
2331  return llvm::Constant::getNullValue(baseType);
2332 
2333  // Otherwise, we can just use its null constant.
2334  return EmitNullConstant(CGM, base, /*asCompleteObject=*/false);
2335 }
2336 
2338  QualType T) {
2339  return emitForMemory(CGM, CGM.EmitNullConstant(T), T);
2340 }
2341 
2343  if (T->getAs<PointerType>())
2344  return getNullPointer(
2345  cast<llvm::PointerType>(getTypes().ConvertTypeForMem(T)), T);
2346 
2347  if (getTypes().isZeroInitializable(T))
2348  return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
2349 
2350  if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
2351  llvm::ArrayType *ATy =
2352  cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
2353 
2354  QualType ElementTy = CAT->getElementType();
2355 
2356  llvm::Constant *Element =
2357  ConstantEmitter::emitNullForMemory(*this, ElementTy);
2358  unsigned NumElements = CAT->getSize().getZExtValue();
2359  SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
2360  return llvm::ConstantArray::get(ATy, Array);
2361  }
2362 
2363  if (const RecordType *RT = T->getAs<RecordType>())
2364  return ::EmitNullConstant(*this, RT->getDecl(), /*complete object*/ true);
2365 
2366  assert(T->isMemberDataPointerType() &&
2367  "Should only see pointers to data members here!");
2368 
2370 }
2371 
2372 llvm::Constant *
2374  return ::EmitNullConstant(*this, Record, false);
2375 }
clang::StmtVisitor
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:183
clang::CodeGen::CodeGenModule::isTypeConstant
bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor)
isTypeConstant - Determine whether an object of this type can be emitted as a constant.
Definition: CodeGenModule.cpp:4258
clang::InternalLinkage
@ InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
clang::RecordDecl::hasFlexibleArrayMember
bool hasFlexibleArrayMember() const
Definition: Decl.h:4037
clang::CodeGen::ConstantEmitter::emitForInitializer
llvm::Constant * emitForInitializer(const APValue &value, LangAS destAddrSpace, QualType destType)
Definition: CGExprConstant.cpp:1444
clang::SubstNonTypeTemplateParmExpr
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4269
clang::ASTContext::getQualifiedType
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:2112
clang::CodeGen::CGRecordLayout::getBitFieldInfo
const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const
Return the BitFieldInfo that corresponds to the field FD.
Definition: CGRecordLayout.h:222
Builtins.h
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6973
emitConstantObjCStringLiteral
static ConstantLValue emitConstantObjCStringLiteral(const StringLiteral *S, QualType T, CodeGenModule &CGM)
Definition: CGExprConstant.cpp:1984
max
__DEVICE__ int max(int __a, int __b)
Definition: __clang_cuda_math.h:196
clang::RecordDecl::field_begin
field_iterator field_begin() const
Definition: Decl.cpp:4754
clang::APValue::LValueBase
Definition: APValue.h:146
clang::ConstantExpr::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.h:1097
clang::ASTRecordLayout::getFieldOffset
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:200
clang::CodeGen::CodeGenModule::GetAddrOfGlobalVar
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
Definition: CodeGenModule.cpp:4555
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2436
clang::CodeGen::CGCXXABI::EmitMemberPointerConversion
virtual llvm::Value * EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, llvm::Value *Src)
Perform a derived-to-base, base-to-derived, or bitcast member pointer conversion.
Definition: CGCXXABI.cpp:67
clang::ObjCBoxedExpr
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:128
clang::CodeGen::ConstantAddress
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:140
clang::CharUnits::getAsAlign
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition: CharUnits.h:183
clang::CodeGen::ConstantEmitter::tryEmitForInitializer
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
Definition: CGExprConstant.cpp:1432
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::CodeGen::CodeGenModule::EmitNullConstant
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
Definition: CGExprConstant.cpp:2342
clang::DeclContext::specific_decl_iterator
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2198
clang::ASTContext::getCharWidth
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2279
clang::CodeGen::CodeGenTypeCache::CharTy
llvm::IntegerType * CharTy
char
Definition: CodeGenTypeCache.h:45
clang::CodeGen::CGCXXABI::EmitMemberFunctionPointer
virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)
Create a member pointer for the given method.
Definition: CGCXXABI.cpp:102
CodeGenFunction.h
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::CodeGen::CGRecordLayout::isZeroInitializableAsBase
bool isZeroInitializableAsBase() const
Check whether this struct can be C++ zero-initialized with a zeroinitializer when considered as a bas...
Definition: CGRecordLayout.h:191
clang::APValue::LValueBase::getTypeInfoType
QualType getTypeInfoType() const
Definition: APValue.cpp:117
clang::CXXConstructExpr::getNumArgs
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Definition: ExprCXX.h:1615
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:3058
clang::APValue::FixedPoint
@ FixedPoint
Definition: APValue.h:134
clang::DesignatedInitUpdateExpr::getBase
Expr * getBase() const
Definition: Expr.h:5391
clang::CodeGen::CodeGenModule::GetAddrOfFunction
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
Definition: CodeGenModule.cpp:4127
clang::CodeGen::CGRecordLayout::getBaseSubobjectLLVMType
llvm::StructType * getBaseSubobjectLLVMType() const
Return the "base subobject" LLVM type associated with this record.
Definition: CGRecordLayout.h:179
clang::ConstantArrayType::getSize
const llvm::APInt & getSize() const
Definition: Type.h:3081
llvm::SmallVector
Definition: LLVM.h:38
clang::APValue::getInt
APSInt & getInt()
Definition: APValue.h:415
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::APValue::isFloat
bool isFloat() const
Definition: APValue.h:394
clang::MaterializeTemporaryExpr::getSubExpr
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
Definition: ExprCXX.h:4530
clang::CodeGen::ConstantEmitter::emitForMemory
llvm::Constant * emitForMemory(llvm::Constant *C, QualType T)
Definition: ConstantEmitter.h:121
clang::ConstantExpr::getAPValueResult
APValue getAPValueResult() const
Definition: Expr.cpp:464
clang::CastExpr::getSubExpr
Expr * getSubExpr()
Definition: Expr.h:3530
clang::APValue::Struct
@ Struct
Definition: APValue.h:140
CGRecordLayout.h
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:737
Attr.h
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:56
clang::ASTRecordLayout::getBaseClassOffset
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:249
clang::CXXTypeidExpr
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:846
clang::CodeGen::CodeGenModule::getContext
ASTContext & getContext() const
Definition: CodeGenModule.h:728
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2930
clang::ASTContext::getBaseElementType
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Definition: ASTContext.cpp:6985
clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:774
EmitNullConstant
static llvm::Constant * EmitNullConstant(CodeGenModule &CGM, const RecordDecl *record, bool asCompleteObject)
Definition: CGExprConstant.cpp:2239
clang::CodeGen::ConstantEmitter::tryEmitPrivateForVarInit
llvm::Constant * tryEmitPrivateForVarInit(const VarDecl &D)
Definition: CGExprConstant.cpp:1638
clang::CodeGen::ConstantEmitter::CGM
CodeGenModule & CGM
Definition: ConstantEmitter.h:25
clang::VarDecl::hasConstantInitialization
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
Definition: Decl.cpp:2542
clang::APValue::ComplexFloat
@ ComplexFloat
Definition: APValue.h:136
CGObjCRuntime.h
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4796
TargetInfo.h
llvm::Optional< size_t >
clang::ComparisonCategoryType::First
@ First
clang::UnaryOperator
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2172
clang::MaterializeTemporaryExpr::getStorageDuration
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4538
clang::Type::isVoidType
bool isVoidType() const
Definition: Type.h:7180
clang::APValue::None
@ None
There is no such object (it's outside its lifetime).
Definition: APValue.h:129
clang::ASTRecordLayout::getPrimaryBase
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
Definition: RecordLayout.h:234
clang::CodeGen::CGBitFieldInfo::Size
unsigned Size
The total size of the bit-field, in bits.
Definition: CGRecordLayout.h:71
clang::CodeGen::CodeGenModule::getTargetCodeGenInfo
const TargetCodeGenInfo & getTargetCodeGenInfo()
Definition: TargetInfo.cpp:12068
ConstantEmitter.h
clang::ASTContext::toBits
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
Definition: ASTContext.cpp:2510
clang::CXXTypeidExpr::getExprOperand
Expr * getExprOperand() const
Definition: ExprCXX.h:893
clang::InitListExpr::isTransparent
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
Definition: Expr.cpp:2408
clang::Expr::isGLValue
bool isGLValue() const
Definition: Expr.h:273
clang::CodeGen::ConstantEmitter::tryEmitAbstractForInitializer
llvm::Constant * tryEmitAbstractForInitializer(const VarDecl &D)
Try to emit the initializer of the given declaration as an abstract constant.
Definition: CGExprConstant.cpp:1374
clang::CodeGen::CodeGenTypes::ConvertType
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:401
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1565
clang::CodeGen::ConstantEmitter::tryEmitPrivate
llvm::Constant * tryEmitPrivate(const Expr *E, QualType T)
Definition: CGExprConstant.cpp:1740
Offset
unsigned Offset
Definition: Format.cpp:2717
clang::CodeGen::CGRecordLayout::getLLVMType
llvm::StructType * getLLVMType() const
Return the "complete object" LLVM type associated with this record.
Definition: CGRecordLayout.h:173
clang::CodeGen::CodeGenModule::GetFunctionStart
llvm::Constant * GetFunctionStart(const ValueDecl *Decl)
Definition: CodeGenModule.cpp:4166
clang::CodeGen::CodeGenModule::setAddrOfConstantCompoundLiteral
void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV)
Notes that CLE's GlobalVariable is GV.
Definition: CGExprConstant.cpp:2205
clang::ASTContext::getTypeAlignInChars
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
Definition: ASTContext.cpp:2525
clang::CodeGen::CodeGenModule::getOrCreateStaticVarDecl
llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGDecl.cpp:243
clang::CodeGen::CodeGenTypes::ConvertTypeForMem
llvm::Type * ConvertTypeForMem(QualType T, bool ForBitField=false)
ConvertTypeForMem - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:91
clang::CompoundLiteralExpr::isFileScope
bool isFileScope() const
Definition: Expr.h:3437
clang::CodeGen::ConstantEmitter::~ConstantEmitter
~ConstantEmitter()
Definition: CGExprConstant.cpp:1624
clang::TypeInfo
Definition: ASTContext.h:152
clang::Expr::skipRValueSubobjectAdjustments
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...
Definition: Expr.cpp:81
clang::Type::isReferenceType
bool isReferenceType() const
Definition: Type.h:6895
clang::CodeGen::CGCXXABI::EmitNullMemberPointer
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:98
clang::CodeGen::CodeGenModule::GetAddrOfConstantCFString
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
Definition: CodeGenModule.cpp:5536
clang::ast_matchers::expr
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchersInternal.cpp:891
min
__DEVICE__ int min(int __a, int __b)
Definition: __clang_cuda_math.h:197
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4816
clang::ASTContext::getAsConstantArrayType
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2699
clang::FunctionDecl::isTrivial
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2261
clang::CodeGen::CodeGenModule::getObjCRuntime
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
Definition: CodeGenModule.h:618
clang::QualType::getAddressSpace
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6756
clang::ParenExpr::getSubExpr
const Expr * getSubExpr() const
Definition: Expr.h:2136
GCCTypeClass::Complex
@ Complex
clang::APValue::Union
@ Union
Definition: APValue.h:141
clang::CodeGen::Address::getName
llvm::StringRef getName() const
Return the IR name of the pointer value.
Definition: Address.h:115
hlsl::uint64_t
unsigned long uint64_t
Definition: hlsl_basic_types.h:25
clang::BaseSubobject
Definition: BaseSubobject.h:30
clang::CodeGen::CGRecordLayout::getNonVirtualBaseLLVMFieldNo
unsigned getNonVirtualBaseLLVMFieldNo(const CXXRecordDecl *RD) const
Definition: CGRecordLayout.h:209
clang::CodeGen::ConstantEmitter::getCurrentAddrPrivate
llvm::GlobalValue * getCurrentAddrPrivate()
Get the address of the current location.
Definition: CGExprConstant.cpp:1453
clang::ASTContext::getAsArrayType
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
Definition: ASTContext.cpp:6874
clang::CharUnits::fromQuantity
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
clang::SubstNonTypeTemplateParmExpr::getReplacement
Expr * getReplacement() const
Definition: ExprCXX.h:4307
clang::CodeGen::CodeGenTypeCache::Int64Ty
llvm::IntegerType * Int64Ty
Definition: CodeGenTypeCache.h:37
clang::CodeGen::CGCXXABI::EmitMemberDataPointer
virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)
Create a member pointer for the given field.
Definition: CGCXXABI.cpp:107
clang::ObjCStringLiteral
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:52
clang::CodeGen::TargetCodeGenInfo::getNullPointer
virtual llvm::Constant * getNullPointer(const CodeGen::CodeGenModule &CGM, llvm::PointerType *T, QualType QT) const
Get target specific null pointer.
Definition: TargetInfo.cpp:509
clang::MaterializeTemporaryExpr
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4513
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
clang::APValue::Array
@ Array
Definition: APValue.h:139
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3012
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7386
clang::CallExpr::getArg
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:3001
clang::APValue::getStructBase
APValue & getStructBase(unsigned i)
Definition: APValue.h:538
APValue.h
clang::ASTRecordLayout::getNonVirtualSize
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Definition: RecordLayout.h:210
clang::CXXConstructorDecl::isCopyOrMoveConstructor
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:2690
clang::CodeGen::CGRecordLayout
CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...
Definition: CGRecordLayout.h:121
clang::CharUnits::One
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
clang::CodeGen::CodeGenModule::getModule
llvm::Module & getModule() const
Definition: CodeGenModule.h:738
clang::index::SymbolKind::Field
@ Field
clang::ASTContext::getTypeSize
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2275
clang::APValue::LValueBase::get
T get() const
Definition: APValue.h:164
clang::CodeGen::CGRecordLayout::getLLVMFieldNo
unsigned getLLVMFieldNo(const FieldDecl *FD) const
Return llvm::StructType element number that corresponds to the field FD.
Definition: CGRecordLayout.h:197
clang::StmtVisitorBase
StmtVisitorBase - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:36
clang::Expr::EvalResult
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:621
clang::ImplicitValueInitExpr
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5515
ASTContext.h
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:906
clang::PredefinedExpr::getFunctionName
StringLiteral * getFunctionName()
Definition: Expr.h:2023
clang::APValue::getVectorElt
APValue & getVectorElt(unsigned I)
Definition: APValue.h:489
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1776
clang::CodeGen::CodeGenModule::getTypes
CodeGenTypes & getTypes()
Definition: CodeGenModule.h:755
clang::CXXTypeidExpr::getTypeOperand
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
Definition: ExprCXX.cpp:161
clang::CXXConstructExpr::getConstructor
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1539
clang::ExprWithCleanups
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:3366
clang::APValue::getUnionField
const FieldDecl * getUnionField() const
Definition: APValue.h:555
clang::TagDecl::isUnion
bool isUnion() const
Definition: Decl.h:3629
clang::APValue::LValue
@ LValue
Definition: APValue.h:137
clang::Expr::getAsBuiltinConstantDeclRef
const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const
If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...
Definition: Expr.cpp:289
clang::CharUnits::Zero
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
clang::CodeGen::CodeGenModule::GetAddrOfConstantCompoundLiteral
ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E)
Returns a pointer to a constant global variable for the given file-scope compound literal expression.
Definition: CGExprConstant.cpp:2213
Base
CodeGenModule.h
clang::ObjCEncodeExpr
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:410
clang::CodeGen::CodeGenModule::GetAddrOfGlobalBlock
llvm::Constant * GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name)
Gets the address of a block which requires no captures.
Definition: CGBlocks.cpp:1288
clang::interp::Const
bool Const(InterpState &S, CodePtr OpPC, const T &Arg)
Definition: Interp.h:561
clang::APValue::isInt
bool isInt() const
Definition: APValue.h:393
clang::ConstantExpr
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:1041
clang::CastExpr::getCastKind
CastKind getCastKind() const
Definition: Expr.h:3524
clang::ChooseExpr
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4529
state
and static some checkers Checker The latter are built on top of the former via the Checker and CheckerVisitor and attempts to isolate them from much of the gore of the internal analysis the analyzer is basically a source code simulator that traces out possible paths of execution The state of the and the combination of state and program point is a node in an exploded which has the entry program point and initial state
Definition: README.txt:30
clang::ASTContext::getTargetAddressSpace
unsigned getTargetAddressSpace(LangAS AS) const
Definition: ASTContext.cpp:12231
clang::CodeGen::CodeGenTypeCache::Int32Ty
llvm::IntegerType * Int32Ty
Definition: CodeGenTypeCache.h:37
clang::APValue::Indeterminate
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
Definition: APValue.h:131
clang::APValue::AddrLabelDiff
@ AddrLabelDiff
Definition: APValue.h:143
clang::CXXConstructorDecl::isDefaultConstructor
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2670
getNonMemoryType
static QualType getNonMemoryType(CodeGenModule &CGM, QualType type)
Definition: CGExprConstant.cpp:1630
clang::CXXRecordDecl::isEmpty
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1150
clang::FullExpr::getSubExpr
const Expr * getSubExpr() const
Definition: Expr.h:1026
clang::CodeGen::CodeGenTypes::getCGRecordLayout
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
Definition: CodeGenTypes.cpp:908
clang::CodeGen::CGBitFieldInfo
Structure with information about how a bitfield should be accessed.
Definition: CGRecordLayout.h:65
clang::CodeGen::CodeGenModule::GetConstantArrayFromStringLiteral
llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)
Return a constant array for the given string.
Definition: CodeGenModule.cpp:5769
clang::LangAS
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
clang::CodeGen::CodeGenModule::getDataLayout
const llvm::DataLayout & getDataLayout() const
Definition: CodeGenModule.h:740
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7453
clang::transformer::EditKind::Range
@ Range
clang::CompoundLiteralExpr
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3410
Emitter
clang::CastExpr::getTargetUnionField
const FieldDecl * getTargetUnionField() const
Definition: Expr.h:3562
clang::CodeGen::CGCXXABI::EmitMemberPointer
virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)
Create a member pointer for the given member pointer constant.
Definition: CGCXXABI.cpp:112
clang::CodeGen::CGCXXABI::getVTableAddressPointForConstExpr
virtual llvm::Constant * getVTableAddressPointForConstExpr(BaseSubobject Base, const CXXRecordDecl *VTableClass)=0
Get the address point of the vtable for the given base subobject while building a constexpr.
clang::Expr::IgnoreParenCasts
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:3040
clang::ASTRecordLayout
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
clang::CodeGen::CodeGenModule::GetAddrOfTemplateParamObject
ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)
Get the address of a template parameter object.
Definition: CodeGenModule.cpp:3170
clang::Type::isUnionType
bool isUnionType() const
Definition: Type.cpp:595
clang::ast_matchers::decl
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchersInternal.cpp:735
clang::DesignatedInitUpdateExpr
Definition: Expr.h:5372
clang::CodeGen::ConstantEmitter::tryEmitConstantExpr
llvm::Constant * tryEmitConstantExpr(const ConstantExpr *CE)
Definition: CGExprConstant.cpp:1394
clang::ObjCEncodeExpr::getEncodedType
QualType getEncodedType() const
Definition: ExprObjC.h:429
clang::syntax::NodeRole::Size
@ Size
clang::CodeGen::CodeGenModule::EmitExplicitCastExprType
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
Definition: CGExpr.cpp:1023
clang::ChooseExpr::getChosenSubExpr
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:4565
clang::DesignatedInitUpdateExpr::getUpdater
InitListExpr * getUpdater() const
Definition: Expr.h:5394
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:701
clang::CXXDefaultInitExpr::getExpr
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1353
clang::ParenExpr
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:2121
clang::CharUnits::isZero
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
clang::CodeGen::CodeGenModule::getCXXABI
CGCXXABI & getCXXABI() const
Definition: CodeGenModule.h:748
clang::ASTRecordLayout::hasOwnVFPtr
bool hasOwnVFPtr() const
hasOwnVFPtr - Does this class provide its own virtual-function table pointer, rather than inheriting ...
Definition: RecordLayout.h:280
clang::ASTContext::getFieldOffset
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
Definition: RecordLayoutBuilder.cpp:3418
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:329
clang::ConstantExpr::hasAPValueResult
bool hasAPValueResult() const
Definition: Expr.h:1122
clang::CodeGen::CodeGenModule
This class organizes the cross-function state that is used while generating LLVM code.
Definition: CodeGenModule.h:279
clang::RecordDecl::fields
field_range fields() const
Definition: Decl.h:4209
clang::CodeGen::ConstantEmitter::emitAbstract
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded.
Definition: CGExprConstant.cpp:1406
clang::CodeGen::CodeGenModule::GetAddrOfRTTIDescriptor
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
Definition: CodeGenModule.cpp:6824
clang::APValue::ComplexInt
@ ComplexInt
Definition: APValue.h:135
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5975
llvm::ArrayRef
Definition: LLVM.h:34
Value
Value
Definition: UninitializedValues.cpp:103
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::CodeGen::CodeGenModule::GetAddrOfMSGuidDecl
ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)
Get the address of a GUID.
Definition: CodeGenModule.cpp:3086
clang::CXXTypeidExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:882
clang::AddrLabelExpr
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:4309
clang::CodeGen::ConstantEmitter::registerCurrentAddrPrivate
void registerCurrentAddrPrivate(llvm::Constant *signal, llvm::GlobalValue *placeholder)
Register a 'signal' value with the emitter to inform it where to resolve a placeholder.
Definition: CGExprConstant.cpp:1473
clang::CodeGen::ConstantEmitter::emitNullForMemory
llvm::Constant * emitNullForMemory(QualType T)
Definition: ConstantEmitter.h:118
clang::CodeGen::CGObjCRuntime::GenerateConstantString
virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0
Generate a constant string object.
clang::SD_Static
@ SD_Static
Static storage duration.
Definition: Specifiers.h:315
StmtVisitor.h
clang::CharUnits::alignTo
CharUnits alignTo(const CharUnits &Align) const
alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...
Definition: CharUnits.h:194
clang::InitListExpr::getArrayFiller
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4892
clang::APValue::getStructField
APValue & getStructField(unsigned i)
Definition: APValue.h:543
clang::APValue::getUnionValue
APValue & getUnionValue()
Definition: APValue.h:559
clang::APValue::getFloat
APFloat & getFloat()
Definition: APValue.h:429
clang::TypeInfoLValue
Symbolic representation of typeid(T) for some type T.
Definition: APValue.h:44
clang::APValue::Vector
@ Vector
Definition: APValue.h:138
clang::VarDecl::getInit
const Expr * getInit() const
Definition: Decl.h:1315
clang::ConstStmtVisitor
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:193
clang::Expr::EvaluateAsRValue
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Definition: ExprConstant.cpp:15135
clang::ASTContext::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:746
clang::CodeGen::CodeGenModule::getNullPointer
llvm::Constant * getNullPointer(llvm::PointerType *T, QualType QT)
Get target specific null pointer.
Definition: CGExprConstant.cpp:1762
clang::RecordDecl::field_end
field_iterator field_end() const
Definition: Decl.h:4212
clang::CodeGen::CodeGenModule::GetAddrOfConstantStringFromLiteral
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
Definition: CodeGenModule.cpp:5834
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2960
clang::ASTContext::getLValueReferenceType
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
Definition: ASTContext.cpp:3466
clang::CodeGen::ConstantAddress::getPointer
llvm::Constant * getPointer() const
Definition: Address.h:152
clang::CodeGen::CGRecordLayout::getVirtualBaseIndex
unsigned getVirtualBaseIndex(const CXXRecordDecl *base) const
Return the LLVM field index corresponding to the given virtual base.
Definition: CGRecordLayout.h:216
CGCXXABI.h
clang::CodeGen::ConstantAddress::invalid
static ConstantAddress invalid()
Definition: Address.h:148
clang::Expr::EvaluateAsLValue
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
Definition: ExprConstant.cpp:15197
clang::PredefinedExpr
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1968
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2769
clang::ObjCStringLiteral::getString
StringLiteral * getString()
Definition: ExprObjC.h:65
clang::CodeGen::CodeGenModule::getMemberPointerConstant
llvm::Constant * getMemberPointerConstant(const UnaryOperator *e)
Definition: CGExprConstant.cpp:2220
clang::CompoundLiteralExpr::getInitializer
const Expr * getInitializer() const
Definition: Expr.h:3433
clang::UnaryOperator::getSubExpr
Expr * getSubExpr() const
Definition: Expr.h:2219
clang::Expr::IgnoreParens
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3031
clang::Type::isMemberDataPointerType
bool isMemberDataPointerType() const
Definition: Type.h:6942
clang
Definition: CalledOnceCheck.h:17
hlsl::int64_t
long int64_t
Definition: hlsl_basic_types.h:26
clang::InitListExpr::getInitializedFieldInUnion
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4910
clang::Type::isArrayType
bool isArrayType() const
Definition: Type.h:6949
clang::interp::GE
bool GE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:519
clang::ASTContext::toCharUnitsFromBits
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Definition: ASTContext.cpp:2505
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:71
clang::ComparisonCategoryType::Last
@ Last
clang::CodeGen::CodeGenTypeCache::IntPtrTy
llvm::IntegerType * IntPtrTy
Definition: CodeGenTypeCache.h:49
clang::APValue::Int
@ Int
Definition: APValue.h:132
clang::GenericSelectionExpr
Represents a C11 generic selection.
Definition: Expr.h:5633
clang::operator<
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
Definition: DeclarationName.h:549
clang::Expr::getType
QualType getType() const
Definition: Expr.h:141
clang::CodeGen::ConstantEmitter::tryEmitPrivateForMemory
llvm::Constant * tryEmitPrivateForMemory(const Expr *E, QualType T)
Definition: CGExprConstant.cpp:1695
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::CodeGen::CodeGenModule::GetWeakRefReference
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
Definition: CodeGenModule.cpp:3197
clang::CodeGen::CodeGenModule::getLLVMLinkageVarDefinition
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD, bool IsConstant)
Returns LLVM linkage for a declarator.
Definition: CodeGenModule.cpp:5162
clang::ASTContext::getASTRecordLayout
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
Definition: RecordLayoutBuilder.cpp:3275
clang::CodeGen::ConstantEmitter
Definition: ConstantEmitter.h:23
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4826
clang::APValue::MemberPointer
@ MemberPointer
Definition: APValue.h:142
clang::CodeGen::TargetCodeGenInfo::performAddrSpaceCast
virtual llvm::Value * performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, llvm::Value *V, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Perform address space cast of an expression of pointer type.
Definition: TargetInfo.cpp:522
clang::InitListExpr::getInit
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4844
clang::CodeGen::ConstantEmitter::tryEmitAbstract
llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)
Try to emit the result of the given expression as an abstract constant.
Definition: CGExprConstant.cpp:1381
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
clang::CallExpr::getBuiltinCallee
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Definition: Expr.cpp:1564
clang::CodeGen::CodeGenModule::GetAddrOfConstantStringFromObjCEncode
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
Definition: CodeGenModule.cpp:5886
clang::CXXConstructExpr::getArg
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1618
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::AtomicType
Definition: Type.h:6440
clang::ASTContext::getObjCEncodingForType
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
Definition: ASTContext.cpp:7955
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:712
clang::ASTContext::hasSameUnqualifiedType
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2544
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:3033
clang::Expr
This represents one expression.
Definition: Expr.h:109
EmitNullConstantForBase
static llvm::Constant * EmitNullConstantForBase(CodeGenModule &CGM, llvm::Type *baseType, const CXXRecordDecl *base)
Emit the null constant for a base subobject.
Definition: CGExprConstant.cpp:2324
clang::CXXDefaultInitExpr
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1325
clang::VarDecl::hasLocalStorage
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1131
clang::CodeGen::CodeGenModule::GetAddrOfUnnamedGlobalConstantDecl
ConstantAddress GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD)
Get the address of a UnnamedGlobalConstant.
Definition: CodeGenModule.cpp:3139
clang::CodeGen::CodeGenTypeCache::Int8Ty
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Definition: CodeGenTypeCache.h:37
clang::ObjCBoxedExpr::getSubExpr
Expr * getSubExpr()
Definition: ExprObjC.h:144
clang::CastExpr
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3480
clang::AddrLabelExpr::getLabel
LabelDecl * getLabel() const
Definition: Expr.h:4332
clang::ObjCBoxedExpr::isExpressibleAsConstantInitializer
bool isExpressibleAsConstantInitializer() const
Definition: ExprObjC.h:153
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3983
clang::CodeGen::CodeGenModule::GetAddrOfGlobalTemporary
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
Definition: CodeGenModule.cpp:5930
clang::CodeGen::ConstantEmitter::finalize
void finalize(llvm::GlobalVariable *global)
Definition: CGExprConstant.cpp:1608
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2810
clang::CodeGen::CodeGenModule::getAddrOfConstantCompoundLiteralIfEmitted
llvm::GlobalVariable * getAddrOfConstantCompoundLiteralIfEmitted(const CompoundLiteralExpr *E)
If it's been emitted already, returns the GlobalVariable corresponding to a compound literal.
Definition: CGExprConstant.cpp:2200
clang::InitListExpr::getNumInits
unsigned getNumInits() const
Definition: Expr.h:4826
clang::CXXConstructExpr
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1467
clang::CodeGen::CodeGenModule::Error
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
Definition: CodeGenModule.cpp:1076
clang::ASTContext::getLangOpts
const LangOptions & getLangOpts() const
Definition: ASTContext.h:764
clang::CodeGen::CodeGenModule::getLLVMContext
llvm::LLVMContext & getLLVMContext()
Definition: CodeGenModule.h:749
clang::CharUnits::getQuantity
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
clang::prec::Shift
@ Shift
Definition: OperatorPrecedence.h:39
clang::CodeGen::ConstantEmitter::tryEmitAbstractForMemory
llvm::Constant * tryEmitAbstractForMemory(const Expr *E, QualType T)
Definition: CGExprConstant.cpp:1681
clang::TargetInfo::useFP16ConversionIntrinsics
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
Definition: TargetInfo.h:931
RecordLayout.h
clang::CodeGen::CodeGenModule::EmitNullConstantForBase
llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)
Return a null constant appropriate for zero-initializing a base class with the given type.
Definition: CGExprConstant.cpp:2373
clang::VarDecl::evaluateValue
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2472
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1240
clang::APValue::Float
@ Float
Definition: APValue.h:133
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1983
clang::APValue::LValueBase::dyn_cast
T dyn_cast() const
Definition: APValue.h:167