clang  14.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 None;
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  CharUnits DesiredSize = Utils.getSize(DesiredTy);
443  CharUnits Align = CharUnits::One();
444  for (llvm::Constant *C : Elems)
445  Align = std::max(Align, Utils.getAlignment(C));
446  CharUnits AlignedSize = Size.alignTo(Align);
447 
448  bool Packed = false;
449  ArrayRef<llvm::Constant*> UnpackedElems = Elems;
450  llvm::SmallVector<llvm::Constant*, 32> UnpackedElemStorage;
451  if ((DesiredSize < AlignedSize && !AllowOversized) ||
452  DesiredSize.alignTo(Align) != DesiredSize) {
453  // The natural layout would be the wrong size; force use of a packed layout.
454  NaturalLayout = false;
455  Packed = true;
456  } else if (DesiredSize > AlignedSize) {
457  // The constant would be too small. Add padding to fix it.
458  UnpackedElemStorage.assign(Elems.begin(), Elems.end());
459  UnpackedElemStorage.push_back(Utils.getPadding(DesiredSize - Size));
460  UnpackedElems = UnpackedElemStorage;
461  }
462 
463  // If we don't have a natural layout, insert padding as necessary.
464  // As we go, double-check to see if we can actually just emit Elems
465  // as a non-packed struct and do so opportunistically if possible.
467  if (!NaturalLayout) {
468  CharUnits SizeSoFar = CharUnits::Zero();
469  for (size_t I = 0; I != Elems.size(); ++I) {
470  CharUnits Align = Utils.getAlignment(Elems[I]);
471  CharUnits NaturalOffset = SizeSoFar.alignTo(Align);
472  CharUnits DesiredOffset = Offset(I);
473  assert(DesiredOffset >= SizeSoFar && "elements out of order");
474 
475  if (DesiredOffset != NaturalOffset)
476  Packed = true;
477  if (DesiredOffset != SizeSoFar)
478  PackedElems.push_back(Utils.getPadding(DesiredOffset - SizeSoFar));
479  PackedElems.push_back(Elems[I]);
480  SizeSoFar = DesiredOffset + Utils.getSize(Elems[I]);
481  }
482  // If we're using the packed layout, pad it out to the desired size if
483  // necessary.
484  if (Packed) {
485  assert((SizeSoFar <= DesiredSize || AllowOversized) &&
486  "requested size is too small for contents");
487  if (SizeSoFar < DesiredSize)
488  PackedElems.push_back(Utils.getPadding(DesiredSize - SizeSoFar));
489  }
490  }
491 
492  llvm::StructType *STy = llvm::ConstantStruct::getTypeForElements(
493  CGM.getLLVMContext(), Packed ? PackedElems : UnpackedElems, Packed);
494 
495  // Pick the type to use. If the type is layout identical to the desired
496  // type then use it, otherwise use whatever the builder produced for us.
497  if (llvm::StructType *DesiredSTy = dyn_cast<llvm::StructType>(DesiredTy)) {
498  if (DesiredSTy->isLayoutIdentical(STy))
499  STy = DesiredSTy;
500  }
501 
502  return llvm::ConstantStruct::get(STy, Packed ? PackedElems : UnpackedElems);
503 }
504 
505 void ConstantAggregateBuilder::condense(CharUnits Offset,
506  llvm::Type *DesiredTy) {
507  CharUnits Size = getSize(DesiredTy);
508 
509  llvm::Optional<size_t> FirstElemToReplace = splitAt(Offset);
510  if (!FirstElemToReplace)
511  return;
512  size_t First = *FirstElemToReplace;
513 
514  llvm::Optional<size_t> LastElemToReplace = splitAt(Offset + Size);
515  if (!LastElemToReplace)
516  return;
517  size_t Last = *LastElemToReplace;
518 
519  size_t Length = Last - First;
520  if (Length == 0)
521  return;
522 
523  if (Length == 1 && Offsets[First] == Offset &&
524  getSize(Elems[First]) == Size) {
525  // Re-wrap single element structs if necessary. Otherwise, leave any single
526  // element constant of the right size alone even if it has the wrong type.
527  auto *STy = dyn_cast<llvm::StructType>(DesiredTy);
528  if (STy && STy->getNumElements() == 1 &&
529  STy->getElementType(0) == Elems[First]->getType())
530  Elems[First] = llvm::ConstantStruct::get(STy, Elems[First]);
531  return;
532  }
533 
534  llvm::Constant *Replacement = buildFrom(
535  CGM, makeArrayRef(Elems).slice(First, Length),
536  makeArrayRef(Offsets).slice(First, Length), Offset, getSize(DesiredTy),
537  /*known to have natural layout=*/false, DesiredTy, false);
538  replace(Elems, First, Last, {Replacement});
539  replace(Offsets, First, Last, {Offset});
540 }
541 
542 //===----------------------------------------------------------------------===//
543 // ConstStructBuilder
544 //===----------------------------------------------------------------------===//
545 
546 class ConstStructBuilder {
547  CodeGenModule &CGM;
549  ConstantAggregateBuilder &Builder;
550  CharUnits StartOffset;
551 
552 public:
553  static llvm::Constant *BuildStruct(ConstantEmitter &Emitter,
554  InitListExpr *ILE, QualType StructTy);
555  static llvm::Constant *BuildStruct(ConstantEmitter &Emitter,
556  const APValue &Value, QualType ValTy);
557  static bool UpdateStruct(ConstantEmitter &Emitter,
558  ConstantAggregateBuilder &Const, CharUnits Offset,
559  InitListExpr *Updater);
560 
561 private:
562  ConstStructBuilder(ConstantEmitter &Emitter,
563  ConstantAggregateBuilder &Builder, CharUnits StartOffset)
564  : CGM(Emitter.CGM), Emitter(Emitter), Builder(Builder),
565  StartOffset(StartOffset) {}
566 
567  bool AppendField(const FieldDecl *Field, uint64_t FieldOffset,
568  llvm::Constant *InitExpr, bool AllowOverwrite = false);
569 
570  bool AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst,
571  bool AllowOverwrite = false);
572 
573  bool AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
574  llvm::ConstantInt *InitExpr, bool AllowOverwrite = false);
575 
576  bool Build(InitListExpr *ILE, bool AllowOverwrite);
577  bool Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase,
578  const CXXRecordDecl *VTableClass, CharUnits BaseOffset);
579  llvm::Constant *Finalize(QualType Ty);
580 };
581 
582 bool ConstStructBuilder::AppendField(
583  const FieldDecl *Field, uint64_t FieldOffset, llvm::Constant *InitCst,
584  bool AllowOverwrite) {
585  const ASTContext &Context = CGM.getContext();
586 
587  CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
588 
589  return AppendBytes(FieldOffsetInChars, InitCst, AllowOverwrite);
590 }
591 
592 bool ConstStructBuilder::AppendBytes(CharUnits FieldOffsetInChars,
593  llvm::Constant *InitCst,
594  bool AllowOverwrite) {
595  return Builder.add(InitCst, StartOffset + FieldOffsetInChars, AllowOverwrite);
596 }
597 
598 bool ConstStructBuilder::AppendBitField(
599  const FieldDecl *Field, uint64_t FieldOffset, llvm::ConstantInt *CI,
600  bool AllowOverwrite) {
601  const CGRecordLayout &RL =
602  CGM.getTypes().getCGRecordLayout(Field->getParent());
603  const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
604  llvm::APInt FieldValue = CI->getValue();
605 
606  // Promote the size of FieldValue if necessary
607  // FIXME: This should never occur, but currently it can because initializer
608  // constants are cast to bool, and because clang is not enforcing bitfield
609  // width limits.
610  if (Info.Size > FieldValue.getBitWidth())
611  FieldValue = FieldValue.zext(Info.Size);
612 
613  // Truncate the size of FieldValue to the bit field size.
614  if (Info.Size < FieldValue.getBitWidth())
615  FieldValue = FieldValue.trunc(Info.Size);
616 
617  return Builder.addBits(FieldValue,
618  CGM.getContext().toBits(StartOffset) + FieldOffset,
619  AllowOverwrite);
620 }
621 
622 static bool EmitDesignatedInitUpdater(ConstantEmitter &Emitter,
623  ConstantAggregateBuilder &Const,
625  InitListExpr *Updater) {
626  if (Type->isRecordType())
627  return ConstStructBuilder::UpdateStruct(Emitter, Const, Offset, Updater);
628 
629  auto CAT = Emitter.CGM.getContext().getAsConstantArrayType(Type);
630  if (!CAT)
631  return false;
632  QualType ElemType = CAT->getElementType();
633  CharUnits ElemSize = Emitter.CGM.getContext().getTypeSizeInChars(ElemType);
634  llvm::Type *ElemTy = Emitter.CGM.getTypes().ConvertTypeForMem(ElemType);
635 
636  llvm::Constant *FillC = nullptr;
637  if (Expr *Filler = Updater->getArrayFiller()) {
638  if (!isa<NoInitExpr>(Filler)) {
639  FillC = Emitter.tryEmitAbstractForMemory(Filler, ElemType);
640  if (!FillC)
641  return false;
642  }
643  }
644 
645  unsigned NumElementsToUpdate =
646  FillC ? CAT->getSize().getZExtValue() : Updater->getNumInits();
647  for (unsigned I = 0; I != NumElementsToUpdate; ++I, Offset += ElemSize) {
648  Expr *Init = nullptr;
649  if (I < Updater->getNumInits())
650  Init = Updater->getInit(I);
651 
652  if (!Init && FillC) {
653  if (!Const.add(FillC, Offset, true))
654  return false;
655  } else if (!Init || isa<NoInitExpr>(Init)) {
656  continue;
657  } else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init)) {
658  if (!EmitDesignatedInitUpdater(Emitter, Const, Offset, ElemType,
659  ChildILE))
660  return false;
661  // Attempt to reduce the array element to a single constant if necessary.
662  Const.condense(Offset, ElemTy);
663  } else {
664  llvm::Constant *Val = Emitter.tryEmitPrivateForMemory(Init, ElemType);
665  if (!Const.add(Val, Offset, true))
666  return false;
667  }
668  }
669 
670  return true;
671 }
672 
673 bool ConstStructBuilder::Build(InitListExpr *ILE, bool AllowOverwrite) {
674  RecordDecl *RD = ILE->getType()->castAs<RecordType>()->getDecl();
675  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
676 
677  unsigned FieldNo = -1;
678  unsigned ElementNo = 0;
679 
680  // Bail out if we have base classes. We could support these, but they only
681  // arise in C++1z where we will have already constant folded most interesting
682  // cases. FIXME: There are still a few more cases we can handle this way.
683  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
684  if (CXXRD->getNumBases())
685  return false;
686 
687  for (FieldDecl *Field : RD->fields()) {
688  ++FieldNo;
689 
690  // If this is a union, skip all the fields that aren't being initialized.
691  if (RD->isUnion() &&
693  continue;
694 
695  // Don't emit anonymous bitfields or zero-sized fields.
696  if (Field->isUnnamedBitfield() || Field->isZeroSize(CGM.getContext()))
697  continue;
698 
699  // Get the initializer. A struct can include fields without initializers,
700  // we just use explicit null values for them.
701  Expr *Init = nullptr;
702  if (ElementNo < ILE->getNumInits())
703  Init = ILE->getInit(ElementNo++);
704  if (Init && isa<NoInitExpr>(Init))
705  continue;
706 
707  // When emitting a DesignatedInitUpdateExpr, a nested InitListExpr
708  // represents additional overwriting of our current constant value, and not
709  // a new constant to emit independently.
710  if (AllowOverwrite &&
711  (Field->getType()->isArrayType() || Field->getType()->isRecordType())) {
712  if (auto *SubILE = dyn_cast<InitListExpr>(Init)) {
714  Layout.getFieldOffset(FieldNo));
715  if (!EmitDesignatedInitUpdater(Emitter, Builder, StartOffset + Offset,
716  Field->getType(), SubILE))
717  return false;
718  // If we split apart the field's value, try to collapse it down to a
719  // single value now.
720  Builder.condense(StartOffset + Offset,
721  CGM.getTypes().ConvertTypeForMem(Field->getType()));
722  continue;
723  }
724  }
725 
726  llvm::Constant *EltInit =
727  Init ? Emitter.tryEmitPrivateForMemory(Init, Field->getType())
728  : Emitter.emitNullForMemory(Field->getType());
729  if (!EltInit)
730  return false;
731 
732  if (!Field->isBitField()) {
733  // Handle non-bitfield members.
734  if (!AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit,
735  AllowOverwrite))
736  return false;
737  // After emitting a non-empty field with [[no_unique_address]], we may
738  // need to overwrite its tail padding.
739  if (Field->hasAttr<NoUniqueAddressAttr>())
740  AllowOverwrite = true;
741  } else {
742  // Otherwise we have a bitfield.
743  if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) {
744  if (!AppendBitField(Field, Layout.getFieldOffset(FieldNo), CI,
745  AllowOverwrite))
746  return false;
747  } else {
748  // We are trying to initialize a bitfield with a non-trivial constant,
749  // this must require run-time code.
750  return false;
751  }
752  }
753  }
754 
755  return true;
756 }
757 
758 namespace {
759 struct BaseInfo {
760  BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
761  : Decl(Decl), Offset(Offset), Index(Index) {
762  }
763 
764  const CXXRecordDecl *Decl;
766  unsigned Index;
767 
768  bool operator<(const BaseInfo &O) const { return Offset < O.Offset; }
769 };
770 }
771 
772 bool ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
773  bool IsPrimaryBase,
774  const CXXRecordDecl *VTableClass,
775  CharUnits Offset) {
776  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
777 
778  if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
779  // Add a vtable pointer, if we need one and it hasn't already been added.
780  if (Layout.hasOwnVFPtr()) {
781  llvm::Constant *VTableAddressPoint =
783  BaseSubobject(CD, Offset), VTableClass);
784  if (!AppendBytes(Offset, VTableAddressPoint))
785  return false;
786  }
787 
788  // Accumulate and sort bases, in order to visit them in address order, which
789  // may not be the same as declaration order.
791  Bases.reserve(CD->getNumBases());
792  unsigned BaseNo = 0;
793  for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
794  BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
795  assert(!Base->isVirtual() && "should not have virtual bases here");
796  const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
797  CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
798  Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));
799  }
800  llvm::stable_sort(Bases);
801 
802  for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
803  BaseInfo &Base = Bases[I];
804 
805  bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
806  Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
807  VTableClass, Offset + Base.Offset);
808  }
809  }
810 
811  unsigned FieldNo = 0;
812  uint64_t OffsetBits = CGM.getContext().toBits(Offset);
813 
814  bool AllowOverwrite = false;
815  for (RecordDecl::field_iterator Field = RD->field_begin(),
816  FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
817  // If this is a union, skip all the fields that aren't being initialized.
818  if (RD->isUnion() && !declaresSameEntity(Val.getUnionField(), *Field))
819  continue;
820 
821  // Don't emit anonymous bitfields or zero-sized fields.
822  if (Field->isUnnamedBitfield() || Field->isZeroSize(CGM.getContext()))
823  continue;
824 
825  // Emit the value of the initializer.
826  const APValue &FieldValue =
827  RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo);
828  llvm::Constant *EltInit =
829  Emitter.tryEmitPrivateForMemory(FieldValue, Field->getType());
830  if (!EltInit)
831  return false;
832 
833  if (!Field->isBitField()) {
834  // Handle non-bitfield members.
835  if (!AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
836  EltInit, AllowOverwrite))
837  return false;
838  // After emitting a non-empty field with [[no_unique_address]], we may
839  // need to overwrite its tail padding.
840  if (Field->hasAttr<NoUniqueAddressAttr>())
841  AllowOverwrite = true;
842  } else {
843  // Otherwise we have a bitfield.
844  if (!AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
845  cast<llvm::ConstantInt>(EltInit), AllowOverwrite))
846  return false;
847  }
848  }
849 
850  return true;
851 }
852 
853 llvm::Constant *ConstStructBuilder::Finalize(QualType Type) {
854  RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
855  llvm::Type *ValTy = CGM.getTypes().ConvertType(Type);
856  return Builder.build(ValTy, RD->hasFlexibleArrayMember());
857 }
858 
859 llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
860  InitListExpr *ILE,
861  QualType ValTy) {
862  ConstantAggregateBuilder Const(Emitter.CGM);
863  ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero());
864 
865  if (!Builder.Build(ILE, /*AllowOverwrite*/false))
866  return nullptr;
867 
868  return Builder.Finalize(ValTy);
869 }
870 
871 llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
872  const APValue &Val,
873  QualType ValTy) {
874  ConstantAggregateBuilder Const(Emitter.CGM);
875  ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero());
876 
877  const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl();
878  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
879  if (!Builder.Build(Val, RD, false, CD, CharUnits::Zero()))
880  return nullptr;
881 
882  return Builder.Finalize(ValTy);
883 }
884 
885 bool ConstStructBuilder::UpdateStruct(ConstantEmitter &Emitter,
886  ConstantAggregateBuilder &Const,
887  CharUnits Offset, InitListExpr *Updater) {
888  return ConstStructBuilder(Emitter, Const, Offset)
889  .Build(Updater, /*AllowOverwrite*/ true);
890 }
891 
892 //===----------------------------------------------------------------------===//
893 // ConstExprEmitter
894 //===----------------------------------------------------------------------===//
895 
896 static ConstantAddress tryEmitGlobalCompoundLiteral(CodeGenModule &CGM,
897  CodeGenFunction *CGF,
898  const CompoundLiteralExpr *E) {
899  CharUnits Align = CGM.getContext().getTypeAlignInChars(E->getType());
900  if (llvm::GlobalVariable *Addr =
902  return ConstantAddress(Addr, Align);
903 
904  LangAS addressSpace = E->getType().getAddressSpace();
905 
906  ConstantEmitter emitter(CGM, CGF);
907  llvm::Constant *C = emitter.tryEmitForInitializer(E->getInitializer(),
908  addressSpace, E->getType());
909  if (!C) {
910  assert(!E->isFileScope() &&
911  "file-scope compound literal did not have constant initializer!");
912  return ConstantAddress::invalid();
913  }
914 
915  auto GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
916  CGM.isTypeConstant(E->getType(), true),
918  C, ".compoundliteral", nullptr,
919  llvm::GlobalVariable::NotThreadLocal,
920  CGM.getContext().getTargetAddressSpace(addressSpace));
921  emitter.finalize(GV);
922  GV->setAlignment(Align.getAsAlign());
924  return ConstantAddress(GV, Align);
925 }
926 
927 static llvm::Constant *
928 EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType,
929  llvm::Type *CommonElementType, unsigned ArrayBound,
931  llvm::Constant *Filler) {
932  // Figure out how long the initial prefix of non-zero elements is.
933  unsigned NonzeroLength = ArrayBound;
934  if (Elements.size() < NonzeroLength && Filler->isNullValue())
935  NonzeroLength = Elements.size();
936  if (NonzeroLength == Elements.size()) {
937  while (NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue())
938  --NonzeroLength;
939  }
940 
941  if (NonzeroLength == 0)
942  return llvm::ConstantAggregateZero::get(DesiredType);
943 
944  // Add a zeroinitializer array filler if we have lots of trailing zeroes.
945  unsigned TrailingZeroes = ArrayBound - NonzeroLength;
946  if (TrailingZeroes >= 8) {
947  assert(Elements.size() >= NonzeroLength &&
948  "missing initializer for non-zero element");
949 
950  // If all the elements had the same type up to the trailing zeroes, emit a
951  // struct of two arrays (the nonzero data and the zeroinitializer).
952  if (CommonElementType && NonzeroLength >= 8) {
953  llvm::Constant *Initial = llvm::ConstantArray::get(
954  llvm::ArrayType::get(CommonElementType, NonzeroLength),
955  makeArrayRef(Elements).take_front(NonzeroLength));
956  Elements.resize(2);
957  Elements[0] = Initial;
958  } else {
959  Elements.resize(NonzeroLength + 1);
960  }
961 
962  auto *FillerType =
963  CommonElementType ? CommonElementType : DesiredType->getElementType();
964  FillerType = llvm::ArrayType::get(FillerType, TrailingZeroes);
965  Elements.back() = llvm::ConstantAggregateZero::get(FillerType);
966  CommonElementType = nullptr;
967  } else if (Elements.size() != ArrayBound) {
968  // Otherwise pad to the right size with the filler if necessary.
969  Elements.resize(ArrayBound, Filler);
970  if (Filler->getType() != CommonElementType)
971  CommonElementType = nullptr;
972  }
973 
974  // If all elements have the same type, just emit an array constant.
975  if (CommonElementType)
976  return llvm::ConstantArray::get(
977  llvm::ArrayType::get(CommonElementType, ArrayBound), Elements);
978 
979  // We have mixed types. Use a packed struct.
981  Types.reserve(Elements.size());
982  for (llvm::Constant *Elt : Elements)
983  Types.push_back(Elt->getType());
984  llvm::StructType *SType =
985  llvm::StructType::get(CGM.getLLVMContext(), Types, true);
986  return llvm::ConstantStruct::get(SType, Elements);
987 }
988 
989 // This class only needs to handle arrays, structs and unions. Outside C++11
990 // mode, we don't currently constant fold those types. All other types are
991 // handled by constant folding.
992 //
993 // Constant folding is currently missing support for a few features supported
994 // here: CK_ToUnion, CK_ReinterpretMemberPointer, and DesignatedInitUpdateExpr.
995 class ConstExprEmitter :
996  public StmtVisitor<ConstExprEmitter, llvm::Constant*, QualType> {
997  CodeGenModule &CGM;
999  llvm::LLVMContext &VMContext;
1000 public:
1001  ConstExprEmitter(ConstantEmitter &emitter)
1002  : CGM(emitter.CGM), Emitter(emitter), VMContext(CGM.getLLVMContext()) {
1003  }
1004 
1005  //===--------------------------------------------------------------------===//
1006  // Visitor Methods
1007  //===--------------------------------------------------------------------===//
1008 
1009  llvm::Constant *VisitStmt(Stmt *S, QualType T) {
1010  return nullptr;
1011  }
1012 
1013  llvm::Constant *VisitConstantExpr(ConstantExpr *CE, QualType T) {
1014  if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(CE))
1015  return Result;
1016  return Visit(CE->getSubExpr(), T);
1017  }
1018 
1019  llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) {
1020  return Visit(PE->getSubExpr(), T);
1021  }
1022 
1023  llvm::Constant *
1024  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE,
1025  QualType T) {
1026  return Visit(PE->getReplacement(), T);
1027  }
1028 
1029  llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE,
1030  QualType T) {
1031  return Visit(GE->getResultExpr(), T);
1032  }
1033 
1034  llvm::Constant *VisitChooseExpr(ChooseExpr *CE, QualType T) {
1035  return Visit(CE->getChosenSubExpr(), T);
1036  }
1037 
1038  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E, QualType T) {
1039  return Visit(E->getInitializer(), T);
1040  }
1041 
1042  llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
1043  if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
1044  CGM.EmitExplicitCastExprType(ECE, Emitter.CGF);
1045  Expr *subExpr = E->getSubExpr();
1046 
1047  switch (E->getCastKind()) {
1048  case CK_ToUnion: {
1049  // GCC cast to union extension
1050  assert(E->getType()->isUnionType() &&
1051  "Destination type is not union type!");
1052 
1053  auto field = E->getTargetUnionField();
1054 
1055  auto C = Emitter.tryEmitPrivateForMemory(subExpr, field->getType());
1056  if (!C) return nullptr;
1057 
1058  auto destTy = ConvertType(destType);
1059  if (C->getType() == destTy) return C;
1060 
1061  // Build a struct with the union sub-element as the first member,
1062  // and padded to the appropriate size.
1065  Elts.push_back(C);
1066  Types.push_back(C->getType());
1067  unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType());
1068  unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destTy);
1069 
1070  assert(CurSize <= TotalSize && "Union size mismatch!");
1071  if (unsigned NumPadBytes = TotalSize - CurSize) {
1072  llvm::Type *Ty = CGM.CharTy;
1073  if (NumPadBytes > 1)
1074  Ty = llvm::ArrayType::get(Ty, NumPadBytes);
1075 
1076  Elts.push_back(llvm::UndefValue::get(Ty));
1077  Types.push_back(Ty);
1078  }
1079 
1080  llvm::StructType *STy = llvm::StructType::get(VMContext, Types, false);
1081  return llvm::ConstantStruct::get(STy, Elts);
1082  }
1083 
1084  case CK_AddressSpaceConversion: {
1085  auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType());
1086  if (!C) return nullptr;
1087  LangAS destAS = E->getType()->getPointeeType().getAddressSpace();
1088  LangAS srcAS = subExpr->getType()->getPointeeType().getAddressSpace();
1089  llvm::Type *destTy = ConvertType(E->getType());
1090  return CGM.getTargetCodeGenInfo().performAddrSpaceCast(CGM, C, srcAS,
1091  destAS, destTy);
1092  }
1093 
1094  case CK_LValueToRValue:
1095  case CK_AtomicToNonAtomic:
1096  case CK_NonAtomicToAtomic:
1097  case CK_NoOp:
1098  case CK_ConstructorConversion:
1099  return Visit(subExpr, destType);
1100 
1101  case CK_IntToOCLSampler:
1102  llvm_unreachable("global sampler variables are not generated");
1103 
1104  case CK_Dependent: llvm_unreachable("saw dependent cast!");
1105 
1106  case CK_BuiltinFnToFnPtr:
1107  llvm_unreachable("builtin functions are handled elsewhere");
1108 
1109  case CK_ReinterpretMemberPointer:
1110  case CK_DerivedToBaseMemberPointer:
1111  case CK_BaseToDerivedMemberPointer: {
1112  auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType());
1113  if (!C) return nullptr;
1114  return CGM.getCXXABI().EmitMemberPointerConversion(E, C);
1115  }
1116 
1117  // These will never be supported.
1118  case CK_ObjCObjectLValueCast:
1119  case CK_ARCProduceObject:
1120  case CK_ARCConsumeObject:
1121  case CK_ARCReclaimReturnedObject:
1122  case CK_ARCExtendBlockObject:
1123  case CK_CopyAndAutoreleaseBlockObject:
1124  return nullptr;
1125 
1126  // These don't need to be handled here because Evaluate knows how to
1127  // evaluate them in the cases where they can be folded.
1128  case CK_BitCast:
1129  case CK_ToVoid:
1130  case CK_Dynamic:
1131  case CK_LValueBitCast:
1132  case CK_LValueToRValueBitCast:
1133  case CK_NullToMemberPointer:
1134  case CK_UserDefinedConversion:
1135  case CK_CPointerToObjCPointerCast:
1136  case CK_BlockPointerToObjCPointerCast:
1137  case CK_AnyPointerToBlockPointerCast:
1138  case CK_ArrayToPointerDecay:
1139  case CK_FunctionToPointerDecay:
1140  case CK_BaseToDerived:
1141  case CK_DerivedToBase:
1142  case CK_UncheckedDerivedToBase:
1143  case CK_MemberPointerToBoolean:
1144  case CK_VectorSplat:
1145  case CK_FloatingRealToComplex:
1146  case CK_FloatingComplexToReal:
1147  case CK_FloatingComplexToBoolean:
1148  case CK_FloatingComplexCast:
1149  case CK_FloatingComplexToIntegralComplex:
1150  case CK_IntegralRealToComplex:
1151  case CK_IntegralComplexToReal:
1152  case CK_IntegralComplexToBoolean:
1153  case CK_IntegralComplexCast:
1154  case CK_IntegralComplexToFloatingComplex:
1155  case CK_PointerToIntegral:
1156  case CK_PointerToBoolean:
1157  case CK_NullToPointer:
1158  case CK_IntegralCast:
1159  case CK_BooleanToSignedIntegral:
1160  case CK_IntegralToPointer:
1161  case CK_IntegralToBoolean:
1162  case CK_IntegralToFloating:
1163  case CK_FloatingToIntegral:
1164  case CK_FloatingToBoolean:
1165  case CK_FloatingCast:
1166  case CK_FloatingToFixedPoint:
1167  case CK_FixedPointToFloating:
1168  case CK_FixedPointCast:
1169  case CK_FixedPointToBoolean:
1170  case CK_FixedPointToIntegral:
1171  case CK_IntegralToFixedPoint:
1172  case CK_ZeroToOCLOpaqueType:
1173  case CK_MatrixCast:
1174  return nullptr;
1175  }
1176  llvm_unreachable("Invalid CastKind");
1177  }
1178 
1179  llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) {
1180  // No need for a DefaultInitExprScope: we don't handle 'this' in a
1181  // constant expression.
1182  return Visit(DIE->getExpr(), T);
1183  }
1184 
1185  llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E, QualType T) {
1186  return Visit(E->getSubExpr(), T);
1187  }
1188 
1189  llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E,
1190  QualType T) {
1191  return Visit(E->getSubExpr(), T);
1192  }
1193 
1194  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) {
1195  auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType());
1196  assert(CAT && "can't emit array init for non-constant-bound array");
1197  unsigned NumInitElements = ILE->getNumInits();
1198  unsigned NumElements = CAT->getSize().getZExtValue();
1199 
1200  // Initialising an array requires us to automatically
1201  // initialise any elements that have not been initialised explicitly
1202  unsigned NumInitableElts = std::min(NumInitElements, NumElements);
1203 
1204  QualType EltType = CAT->getElementType();
1205 
1206  // Initialize remaining array elements.
1207  llvm::Constant *fillC = nullptr;
1208  if (Expr *filler = ILE->getArrayFiller()) {
1209  fillC = Emitter.tryEmitAbstractForMemory(filler, EltType);
1210  if (!fillC)
1211  return nullptr;
1212  }
1213 
1214  // Copy initializer elements.
1216  if (fillC && fillC->isNullValue())
1217  Elts.reserve(NumInitableElts + 1);
1218  else
1219  Elts.reserve(NumElements);
1220 
1221  llvm::Type *CommonElementType = nullptr;
1222  for (unsigned i = 0; i < NumInitableElts; ++i) {
1223  Expr *Init = ILE->getInit(i);
1224  llvm::Constant *C = Emitter.tryEmitPrivateForMemory(Init, EltType);
1225  if (!C)
1226  return nullptr;
1227  if (i == 0)
1228  CommonElementType = C->getType();
1229  else if (C->getType() != CommonElementType)
1230  CommonElementType = nullptr;
1231  Elts.push_back(C);
1232  }
1233 
1234  llvm::ArrayType *Desired =
1235  cast<llvm::ArrayType>(CGM.getTypes().ConvertType(ILE->getType()));
1236  return EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts,
1237  fillC);
1238  }
1239 
1240  llvm::Constant *EmitRecordInitialization(InitListExpr *ILE, QualType T) {
1241  return ConstStructBuilder::BuildStruct(Emitter, ILE, T);
1242  }
1243 
1244  llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E,
1245  QualType T) {
1246  return CGM.EmitNullConstant(T);
1247  }
1248 
1249  llvm::Constant *VisitInitListExpr(InitListExpr *ILE, QualType T) {
1250  if (ILE->isTransparent())
1251  return Visit(ILE->getInit(0), T);
1252 
1253  if (ILE->getType()->isArrayType())
1254  return EmitArrayInitialization(ILE, T);
1255 
1256  if (ILE->getType()->isRecordType())
1257  return EmitRecordInitialization(ILE, T);
1258 
1259  return nullptr;
1260  }
1261 
1262  llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E,
1263  QualType destType) {
1264  auto C = Visit(E->getBase(), destType);
1265  if (!C)
1266  return nullptr;
1267 
1268  ConstantAggregateBuilder Const(CGM);
1269  Const.add(C, CharUnits::Zero(), false);
1270 
1271  if (!EmitDesignatedInitUpdater(Emitter, Const, CharUnits::Zero(), destType,
1272  E->getUpdater()))
1273  return nullptr;
1274 
1275  llvm::Type *ValTy = CGM.getTypes().ConvertType(destType);
1276  bool HasFlexibleArray = false;
1277  if (auto *RT = destType->getAs<RecordType>())
1278  HasFlexibleArray = RT->getDecl()->hasFlexibleArrayMember();
1279  return Const.build(ValTy, HasFlexibleArray);
1280  }
1281 
1282  llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E, QualType Ty) {
1283  if (!E->getConstructor()->isTrivial())
1284  return nullptr;
1285 
1286  // Only default and copy/move constructors can be trivial.
1287  if (E->getNumArgs()) {
1288  assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
1289  assert(E->getConstructor()->isCopyOrMoveConstructor() &&
1290  "trivial ctor has argument but isn't a copy/move ctor");
1291 
1292  Expr *Arg = E->getArg(0);
1293  assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
1294  "argument to copy ctor is of wrong type");
1295 
1296  return Visit(Arg, Ty);
1297  }
1298 
1299  return CGM.EmitNullConstant(Ty);
1300  }
1301 
1302  llvm::Constant *VisitStringLiteral(StringLiteral *E, QualType T) {
1303  // This is a string literal initializing an array in an initializer.
1304  return CGM.GetConstantArrayFromStringLiteral(E);
1305  }
1306 
1307  llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E, QualType T) {
1308  // This must be an @encode initializing an array in a static initializer.
1309  // Don't emit it as the address of the string, emit the string data itself
1310  // as an inline array.
1311  std::string Str;
1313  const ConstantArrayType *CAT = CGM.getContext().getAsConstantArrayType(T);
1314 
1315  // Resize the string to the right size, adding zeros at the end, or
1316  // truncating as needed.
1317  Str.resize(CAT->getSize().getZExtValue(), '\0');
1318  return llvm::ConstantDataArray::getString(VMContext, Str, false);
1319  }
1320 
1321  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E, QualType T) {
1322  return Visit(E->getSubExpr(), T);
1323  }
1324 
1325  // Utility methods
1326  llvm::Type *ConvertType(QualType T) {
1327  return CGM.getTypes().ConvertType(T);
1328  }
1329 };
1330 
1331 } // end anonymous namespace.
1332 
1333 llvm::Constant *ConstantEmitter::validateAndPopAbstract(llvm::Constant *C,
1334  AbstractState saved) {
1335  Abstract = saved.OldValue;
1336 
1337  assert(saved.OldPlaceholdersSize == PlaceholderAddresses.size() &&
1338  "created a placeholder while doing an abstract emission?");
1339 
1340  // No validation necessary for now.
1341  // No cleanup to do for now.
1342  return C;
1343 }
1344 
1345 llvm::Constant *
1347  auto state = pushAbstract();
1348  auto C = tryEmitPrivateForVarInit(D);
1349  return validateAndPopAbstract(C, state);
1350 }
1351 
1352 llvm::Constant *
1354  auto state = pushAbstract();
1355  auto C = tryEmitPrivate(E, destType);
1356  return validateAndPopAbstract(C, state);
1357 }
1358 
1359 llvm::Constant *
1361  auto state = pushAbstract();
1362  auto C = tryEmitPrivate(value, destType);
1363  return validateAndPopAbstract(C, state);
1364 }
1365 
1367  if (!CE->hasAPValueResult())
1368  return nullptr;
1369  const Expr *Inner = CE->getSubExpr()->IgnoreImplicit();
1370  QualType RetType;
1371  if (auto *Call = dyn_cast<CallExpr>(Inner))
1372  RetType = Call->getCallReturnType(CGM.getContext());
1373  else if (auto *Ctor = dyn_cast<CXXConstructExpr>(Inner))
1374  RetType = Ctor->getType();
1375  llvm::Constant *Res =
1376  emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(), RetType);
1377  return Res;
1378 }
1379 
1380 llvm::Constant *
1382  auto state = pushAbstract();
1383  auto C = tryEmitPrivate(E, destType);
1384  C = validateAndPopAbstract(C, state);
1385  if (!C) {
1386  CGM.Error(E->getExprLoc(),
1387  "internal error: could not emit constant value \"abstractly\"");
1388  C = CGM.EmitNullConstant(destType);
1389  }
1390  return C;
1391 }
1392 
1393 llvm::Constant *
1395  QualType destType) {
1396  auto state = pushAbstract();
1397  auto C = tryEmitPrivate(value, destType);
1398  C = validateAndPopAbstract(C, state);
1399  if (!C) {
1400  CGM.Error(loc,
1401  "internal error: could not emit constant value \"abstractly\"");
1402  C = CGM.EmitNullConstant(destType);
1403  }
1404  return C;
1405 }
1406 
1408  initializeNonAbstract(D.getType().getAddressSpace());
1409  return markIfFailed(tryEmitPrivateForVarInit(D));
1410 }
1411 
1413  LangAS destAddrSpace,
1414  QualType destType) {
1415  initializeNonAbstract(destAddrSpace);
1416  return markIfFailed(tryEmitPrivateForMemory(E, destType));
1417 }
1418 
1419 llvm::Constant *ConstantEmitter::emitForInitializer(const APValue &value,
1420  LangAS destAddrSpace,
1421  QualType destType) {
1422  initializeNonAbstract(destAddrSpace);
1423  auto C = tryEmitPrivateForMemory(value, destType);
1424  assert(C && "couldn't emit constant value non-abstractly?");
1425  return C;
1426 }
1427 
1429  assert(!Abstract && "cannot get current address for abstract constant");
1430 
1431 
1432 
1433  // Make an obviously ill-formed global that should blow up compilation
1434  // if it survives.
1435  auto global = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty, true,
1436  llvm::GlobalValue::PrivateLinkage,
1437  /*init*/ nullptr,
1438  /*name*/ "",
1439  /*before*/ nullptr,
1440  llvm::GlobalVariable::NotThreadLocal,
1441  CGM.getContext().getTargetAddressSpace(DestAddressSpace));
1442 
1443  PlaceholderAddresses.push_back(std::make_pair(nullptr, global));
1444 
1445  return global;
1446 }
1447 
1449  llvm::GlobalValue *placeholder) {
1450  assert(!PlaceholderAddresses.empty());
1451  assert(PlaceholderAddresses.back().first == nullptr);
1452  assert(PlaceholderAddresses.back().second == placeholder);
1453  PlaceholderAddresses.back().first = signal;
1454 }
1455 
1456 namespace {
1457  struct ReplacePlaceholders {
1458  CodeGenModule &CGM;
1459 
1460  /// The base address of the global.
1461  llvm::Constant *Base;
1462  llvm::Type *BaseValueTy = nullptr;
1463 
1464  /// The placeholder addresses that were registered during emission.
1465  llvm::DenseMap<llvm::Constant*, llvm::GlobalVariable*> PlaceholderAddresses;
1466 
1467  /// The locations of the placeholder signals.
1468  llvm::DenseMap<llvm::GlobalVariable*, llvm::Constant*> Locations;
1469 
1470  /// The current index stack. We use a simple unsigned stack because
1471  /// we assume that placeholders will be relatively sparse in the
1472  /// initializer, but we cache the index values we find just in case.
1475 
1476  ReplacePlaceholders(CodeGenModule &CGM, llvm::Constant *base,
1477  ArrayRef<std::pair<llvm::Constant*,
1478  llvm::GlobalVariable*>> addresses)
1479  : CGM(CGM), Base(base),
1480  PlaceholderAddresses(addresses.begin(), addresses.end()) {
1481  }
1482 
1483  void replaceInInitializer(llvm::Constant *init) {
1484  // Remember the type of the top-most initializer.
1485  BaseValueTy = init->getType();
1486 
1487  // Initialize the stack.
1488  Indices.push_back(0);
1489  IndexValues.push_back(nullptr);
1490 
1491  // Recurse into the initializer.
1492  findLocations(init);
1493 
1494  // Check invariants.
1495  assert(IndexValues.size() == Indices.size() && "mismatch");
1496  assert(Indices.size() == 1 && "didn't pop all indices");
1497 
1498  // Do the replacement; this basically invalidates 'init'.
1499  assert(Locations.size() == PlaceholderAddresses.size() &&
1500  "missed a placeholder?");
1501 
1502  // We're iterating over a hashtable, so this would be a source of
1503  // non-determinism in compiler output *except* that we're just
1504  // messing around with llvm::Constant structures, which never itself
1505  // does anything that should be visible in compiler output.
1506  for (auto &entry : Locations) {
1507  assert(entry.first->getParent() == nullptr && "not a placeholder!");
1508  entry.first->replaceAllUsesWith(entry.second);
1509  entry.first->eraseFromParent();
1510  }
1511  }
1512 
1513  private:
1514  void findLocations(llvm::Constant *init) {
1515  // Recurse into aggregates.
1516  if (auto agg = dyn_cast<llvm::ConstantAggregate>(init)) {
1517  for (unsigned i = 0, e = agg->getNumOperands(); i != e; ++i) {
1518  Indices.push_back(i);
1519  IndexValues.push_back(nullptr);
1520 
1521  findLocations(agg->getOperand(i));
1522 
1523  IndexValues.pop_back();
1524  Indices.pop_back();
1525  }
1526  return;
1527  }
1528 
1529  // Otherwise, check for registered constants.
1530  while (true) {
1531  auto it = PlaceholderAddresses.find(init);
1532  if (it != PlaceholderAddresses.end()) {
1533  setLocation(it->second);
1534  break;
1535  }
1536 
1537  // Look through bitcasts or other expressions.
1538  if (auto expr = dyn_cast<llvm::ConstantExpr>(init)) {
1539  init = expr->getOperand(0);
1540  } else {
1541  break;
1542  }
1543  }
1544  }
1545 
1546  void setLocation(llvm::GlobalVariable *placeholder) {
1547  assert(Locations.find(placeholder) == Locations.end() &&
1548  "already found location for placeholder!");
1549 
1550  // Lazily fill in IndexValues with the values from Indices.
1551  // We do this in reverse because we should always have a strict
1552  // prefix of indices from the start.
1553  assert(Indices.size() == IndexValues.size());
1554  for (size_t i = Indices.size() - 1; i != size_t(-1); --i) {
1555  if (IndexValues[i]) {
1556 #ifndef NDEBUG
1557  for (size_t j = 0; j != i + 1; ++j) {
1558  assert(IndexValues[j] &&
1559  isa<llvm::ConstantInt>(IndexValues[j]) &&
1560  cast<llvm::ConstantInt>(IndexValues[j])->getZExtValue()
1561  == Indices[j]);
1562  }
1563 #endif
1564  break;
1565  }
1566 
1567  IndexValues[i] = llvm::ConstantInt::get(CGM.Int32Ty, Indices[i]);
1568  }
1569 
1570  // Form a GEP and then bitcast to the placeholder type so that the
1571  // replacement will succeed.
1572  llvm::Constant *location =
1573  llvm::ConstantExpr::getInBoundsGetElementPtr(BaseValueTy,
1574  Base, IndexValues);
1575  location = llvm::ConstantExpr::getBitCast(location,
1576  placeholder->getType());
1577 
1578  Locations.insert({placeholder, location});
1579  }
1580  };
1581 }
1582 
1583 void ConstantEmitter::finalize(llvm::GlobalVariable *global) {
1584  assert(InitializedNonAbstract &&
1585  "finalizing emitter that was used for abstract emission?");
1586  assert(!Finalized && "finalizing emitter multiple times");
1587  assert(global->getInitializer());
1588 
1589  // Note that we might also be Failed.
1590  Finalized = true;
1591 
1592  if (!PlaceholderAddresses.empty()) {
1593  ReplacePlaceholders(CGM, global, PlaceholderAddresses)
1594  .replaceInInitializer(global->getInitializer());
1595  PlaceholderAddresses.clear(); // satisfy
1596  }
1597 }
1598 
1600  assert((!InitializedNonAbstract || Finalized || Failed) &&
1601  "not finalized after being initialized for non-abstract emission");
1602  assert(PlaceholderAddresses.empty() && "unhandled placeholders");
1603 }
1604 
1606  if (auto AT = type->getAs<AtomicType>()) {
1607  return CGM.getContext().getQualifiedType(AT->getValueType(),
1608  type.getQualifiers());
1609  }
1610  return type;
1611 }
1612 
1614  // Make a quick check if variable can be default NULL initialized
1615  // and avoid going through rest of code which may do, for c++11,
1616  // initialization of memory to all NULLs.
1617  if (!D.hasLocalStorage()) {
1619  if (Ty->isRecordType())
1620  if (const CXXConstructExpr *E =
1621  dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
1622  const CXXConstructorDecl *CD = E->getConstructor();
1623  if (CD->isTrivial() && CD->isDefaultConstructor())
1624  return CGM.EmitNullConstant(D.getType());
1625  }
1626  }
1627  InConstantContext = D.hasConstantInitialization();
1628 
1629  QualType destType = D.getType();
1630 
1631  // Try to emit the initializer. Note that this can allow some things that
1632  // are not allowed by tryEmitPrivateForMemory alone.
1633  if (auto value = D.evaluateValue()) {
1634  return tryEmitPrivateForMemory(*value, destType);
1635  }
1636 
1637  // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
1638  // reference is a constant expression, and the reference binds to a temporary,
1639  // then constant initialization is performed. ConstExprEmitter will
1640  // incorrectly emit a prvalue constant in this case, and the calling code
1641  // interprets that as the (pointer) value of the reference, rather than the
1642  // desired value of the referee.
1643  if (destType->isReferenceType())
1644  return nullptr;
1645 
1646  const Expr *E = D.getInit();
1647  assert(E && "No initializer to emit");
1648 
1649  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1650  auto C =
1651  ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), nonMemoryDestType);
1652  return (C ? emitForMemory(C, destType) : nullptr);
1653 }
1654 
1655 llvm::Constant *
1657  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1658  auto C = tryEmitAbstract(E, nonMemoryDestType);
1659  return (C ? emitForMemory(C, destType) : nullptr);
1660 }
1661 
1662 llvm::Constant *
1664  QualType destType) {
1665  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1666  auto C = tryEmitAbstract(value, nonMemoryDestType);
1667  return (C ? emitForMemory(C, destType) : nullptr);
1668 }
1669 
1671  QualType destType) {
1672  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1673  llvm::Constant *C = tryEmitPrivate(E, nonMemoryDestType);
1674  return (C ? emitForMemory(C, destType) : nullptr);
1675 }
1676 
1678  QualType destType) {
1679  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1680  auto C = tryEmitPrivate(value, nonMemoryDestType);
1681  return (C ? emitForMemory(C, destType) : nullptr);
1682 }
1683 
1685  llvm::Constant *C,
1686  QualType destType) {
1687  // For an _Atomic-qualified constant, we may need to add tail padding.
1688  if (auto AT = destType->getAs<AtomicType>()) {
1689  QualType destValueType = AT->getValueType();
1690  C = emitForMemory(CGM, C, destValueType);
1691 
1692  uint64_t innerSize = CGM.getContext().getTypeSize(destValueType);
1693  uint64_t outerSize = CGM.getContext().getTypeSize(destType);
1694  if (innerSize == outerSize)
1695  return C;
1696 
1697  assert(innerSize < outerSize && "emitted over-large constant for atomic");
1698  llvm::Constant *elts[] = {
1699  C,
1700  llvm::ConstantAggregateZero::get(
1701  llvm::ArrayType::get(CGM.Int8Ty, (outerSize - innerSize) / 8))
1702  };
1703  return llvm::ConstantStruct::getAnon(elts);
1704  }
1705 
1706  // Zero-extend bool.
1707  if (C->getType()->isIntegerTy(1)) {
1708  llvm::Type *boolTy = CGM.getTypes().ConvertTypeForMem(destType);
1709  return llvm::ConstantExpr::getZExt(C, boolTy);
1710  }
1711 
1712  return C;
1713 }
1714 
1715 llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E,
1716  QualType destType) {
1717  assert(!destType->isVoidType() && "can't emit a void constant");
1718 
1719  Expr::EvalResult Result;
1720 
1721  bool Success = false;
1722 
1723  if (destType->isReferenceType())
1724  Success = E->EvaluateAsLValue(Result, CGM.getContext());
1725  else
1726  Success = E->EvaluateAsRValue(Result, CGM.getContext(), InConstantContext);
1727 
1728  llvm::Constant *C;
1729  if (Success && !Result.HasSideEffects)
1730  C = tryEmitPrivate(Result.Val, destType);
1731  else
1732  C = ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), destType);
1733 
1734  return C;
1735 }
1736 
1737 llvm::Constant *CodeGenModule::getNullPointer(llvm::PointerType *T, QualType QT) {
1738  return getTargetCodeGenInfo().getNullPointer(*this, T, QT);
1739 }
1740 
1741 namespace {
1742 /// A struct which can be used to peephole certain kinds of finalization
1743 /// that normally happen during l-value emission.
1744 struct ConstantLValue {
1745  llvm::Constant *Value;
1746  bool HasOffsetApplied;
1747 
1748  /*implicit*/ ConstantLValue(llvm::Constant *value,
1749  bool hasOffsetApplied = false)
1750  : Value(value), HasOffsetApplied(hasOffsetApplied) {}
1751 
1752  /*implicit*/ ConstantLValue(ConstantAddress address)
1753  : ConstantLValue(address.getPointer()) {}
1754 };
1755 
1756 /// A helper class for emitting constant l-values.
1757 class ConstantLValueEmitter : public ConstStmtVisitor<ConstantLValueEmitter,
1758  ConstantLValue> {
1759  CodeGenModule &CGM;
1761  const APValue &Value;
1762  QualType DestType;
1763 
1764  // Befriend StmtVisitorBase so that we don't have to expose Visit*.
1765  friend StmtVisitorBase;
1766 
1767 public:
1768  ConstantLValueEmitter(ConstantEmitter &emitter, const APValue &value,
1769  QualType destType)
1770  : CGM(emitter.CGM), Emitter(emitter), Value(value), DestType(destType) {}
1771 
1772  llvm::Constant *tryEmit();
1773 
1774 private:
1775  llvm::Constant *tryEmitAbsolute(llvm::Type *destTy);
1776  ConstantLValue tryEmitBase(const APValue::LValueBase &base);
1777 
1778  ConstantLValue VisitStmt(const Stmt *S) { return nullptr; }
1779  ConstantLValue VisitConstantExpr(const ConstantExpr *E);
1780  ConstantLValue VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
1781  ConstantLValue VisitStringLiteral(const StringLiteral *E);
1782  ConstantLValue VisitObjCBoxedExpr(const ObjCBoxedExpr *E);
1783  ConstantLValue VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
1784  ConstantLValue VisitObjCStringLiteral(const ObjCStringLiteral *E);
1785  ConstantLValue VisitPredefinedExpr(const PredefinedExpr *E);
1786  ConstantLValue VisitAddrLabelExpr(const AddrLabelExpr *E);
1787  ConstantLValue VisitCallExpr(const CallExpr *E);
1788  ConstantLValue VisitBlockExpr(const BlockExpr *E);
1789  ConstantLValue VisitCXXTypeidExpr(const CXXTypeidExpr *E);
1790  ConstantLValue VisitMaterializeTemporaryExpr(
1791  const MaterializeTemporaryExpr *E);
1792 
1793  bool hasNonZeroOffset() const {
1794  return !Value.getLValueOffset().isZero();
1795  }
1796 
1797  /// Return the value offset.
1798  llvm::Constant *getOffset() {
1799  return llvm::ConstantInt::get(CGM.Int64Ty,
1800  Value.getLValueOffset().getQuantity());
1801  }
1802 
1803  /// Apply the value offset to the given constant.
1804  llvm::Constant *applyOffset(llvm::Constant *C) {
1805  if (!hasNonZeroOffset())
1806  return C;
1807 
1808  llvm::Type *origPtrTy = C->getType();
1809  unsigned AS = origPtrTy->getPointerAddressSpace();
1810  llvm::Type *charPtrTy = CGM.Int8Ty->getPointerTo(AS);
1811  C = llvm::ConstantExpr::getBitCast(C, charPtrTy);
1812  C = llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, C, getOffset());
1813  C = llvm::ConstantExpr::getPointerCast(C, origPtrTy);
1814  return C;
1815  }
1816 };
1817 
1818 }
1819 
1820 llvm::Constant *ConstantLValueEmitter::tryEmit() {
1821  const APValue::LValueBase &base = Value.getLValueBase();
1822 
1823  // The destination type should be a pointer or reference
1824  // type, but it might also be a cast thereof.
1825  //
1826  // FIXME: the chain of casts required should be reflected in the APValue.
1827  // We need this in order to correctly handle things like a ptrtoint of a
1828  // non-zero null pointer and addrspace casts that aren't trivially
1829  // represented in LLVM IR.
1830  auto destTy = CGM.getTypes().ConvertTypeForMem(DestType);
1831  assert(isa<llvm::IntegerType>(destTy) || isa<llvm::PointerType>(destTy));
1832 
1833  // If there's no base at all, this is a null or absolute pointer,
1834  // possibly cast back to an integer type.
1835  if (!base) {
1836  return tryEmitAbsolute(destTy);
1837  }
1838 
1839  // Otherwise, try to emit the base.
1840  ConstantLValue result = tryEmitBase(base);
1841 
1842  // If that failed, we're done.
1843  llvm::Constant *value = result.Value;
1844  if (!value) return nullptr;
1845 
1846  // Apply the offset if necessary and not already done.
1847  if (!result.HasOffsetApplied) {
1848  value = applyOffset(value);
1849  }
1850 
1851  // Convert to the appropriate type; this could be an lvalue for
1852  // an integer. FIXME: performAddrSpaceCast
1853  if (isa<llvm::PointerType>(destTy))
1854  return llvm::ConstantExpr::getPointerCast(value, destTy);
1855 
1856  return llvm::ConstantExpr::getPtrToInt(value, destTy);
1857 }
1858 
1859 /// Try to emit an absolute l-value, such as a null pointer or an integer
1860 /// bitcast to pointer type.
1861 llvm::Constant *
1862 ConstantLValueEmitter::tryEmitAbsolute(llvm::Type *destTy) {
1863  // If we're producing a pointer, this is easy.
1864  auto destPtrTy = cast<llvm::PointerType>(destTy);
1865  if (Value.isNullPointer()) {
1866  // FIXME: integer offsets from non-zero null pointers.
1867  return CGM.getNullPointer(destPtrTy, DestType);
1868  }
1869 
1870  // Convert the integer to a pointer-sized integer before converting it
1871  // to a pointer.
1872  // FIXME: signedness depends on the original integer type.
1873  auto intptrTy = CGM.getDataLayout().getIntPtrType(destPtrTy);
1874  llvm::Constant *C;
1875  C = llvm::ConstantExpr::getIntegerCast(getOffset(), intptrTy,
1876  /*isSigned*/ false);
1877  C = llvm::ConstantExpr::getIntToPtr(C, destPtrTy);
1878  return C;
1879 }
1880 
1881 ConstantLValue
1882 ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
1883  // Handle values.
1884  if (const ValueDecl *D = base.dyn_cast<const ValueDecl*>()) {
1885  // The constant always points to the canonical declaration. We want to look
1886  // at properties of the most recent declaration at the point of emission.
1887  D = cast<ValueDecl>(D->getMostRecentDecl());
1888 
1889  if (D->hasAttr<WeakRefAttr>())
1890  return CGM.GetWeakRefReference(D).getPointer();
1891 
1892  if (auto FD = dyn_cast<FunctionDecl>(D))
1893  return CGM.GetAddrOfFunction(FD);
1894 
1895  if (auto VD = dyn_cast<VarDecl>(D)) {
1896  // We can never refer to a variable with local storage.
1897  if (!VD->hasLocalStorage()) {
1898  if (VD->isFileVarDecl() || VD->hasExternalStorage())
1899  return CGM.GetAddrOfGlobalVar(VD);
1900 
1901  if (VD->isLocalVarDecl()) {
1902  return CGM.getOrCreateStaticVarDecl(
1903  *VD, CGM.getLLVMLinkageVarDefinition(VD, /*IsConstant=*/false));
1904  }
1905  }
1906  }
1907 
1908  if (auto *GD = dyn_cast<MSGuidDecl>(D))
1909  return CGM.GetAddrOfMSGuidDecl(GD);
1910 
1911  if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(D))
1912  return CGM.GetAddrOfTemplateParamObject(TPO);
1913 
1914  return nullptr;
1915  }
1916 
1917  // Handle typeid(T).
1918  if (TypeInfoLValue TI = base.dyn_cast<TypeInfoLValue>()) {
1919  llvm::Type *StdTypeInfoPtrTy =
1920  CGM.getTypes().ConvertType(base.getTypeInfoType())->getPointerTo();
1921  llvm::Constant *TypeInfo =
1922  CGM.GetAddrOfRTTIDescriptor(QualType(TI.getType(), 0));
1923  if (TypeInfo->getType() != StdTypeInfoPtrTy)
1924  TypeInfo = llvm::ConstantExpr::getBitCast(TypeInfo, StdTypeInfoPtrTy);
1925  return TypeInfo;
1926  }
1927 
1928  // Otherwise, it must be an expression.
1929  return Visit(base.get<const Expr*>());
1930 }
1931 
1932 ConstantLValue
1933 ConstantLValueEmitter::VisitConstantExpr(const ConstantExpr *E) {
1934  if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(E))
1935  return Result;
1936  return Visit(E->getSubExpr());
1937 }
1938 
1939 ConstantLValue
1940 ConstantLValueEmitter::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
1941  return tryEmitGlobalCompoundLiteral(CGM, Emitter.CGF, E);
1942 }
1943 
1944 ConstantLValue
1945 ConstantLValueEmitter::VisitStringLiteral(const StringLiteral *E) {
1946  return CGM.GetAddrOfConstantStringFromLiteral(E);
1947 }
1948 
1949 ConstantLValue
1950 ConstantLValueEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
1952 }
1953 
1954 static ConstantLValue emitConstantObjCStringLiteral(const StringLiteral *S,
1955  QualType T,
1956  CodeGenModule &CGM) {
1957  auto C = CGM.getObjCRuntime().GenerateConstantString(S);
1958  return C.getElementBitCast(CGM.getTypes().ConvertTypeForMem(T));
1959 }
1960 
1961 ConstantLValue
1962 ConstantLValueEmitter::VisitObjCStringLiteral(const ObjCStringLiteral *E) {
1963  return emitConstantObjCStringLiteral(E->getString(), E->getType(), CGM);
1964 }
1965 
1966 ConstantLValue
1967 ConstantLValueEmitter::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
1968  assert(E->isExpressibleAsConstantInitializer() &&
1969  "this boxed expression can't be emitted as a compile-time constant");
1970  auto *SL = cast<StringLiteral>(E->getSubExpr()->IgnoreParenCasts());
1971  return emitConstantObjCStringLiteral(SL, E->getType(), CGM);
1972 }
1973 
1974 ConstantLValue
1975 ConstantLValueEmitter::VisitPredefinedExpr(const PredefinedExpr *E) {
1977 }
1978 
1979 ConstantLValue
1980 ConstantLValueEmitter::VisitAddrLabelExpr(const AddrLabelExpr *E) {
1981  assert(Emitter.CGF && "Invalid address of label expression outside function");
1982  llvm::Constant *Ptr = Emitter.CGF->GetAddrOfLabel(E->getLabel());
1983  Ptr = llvm::ConstantExpr::getBitCast(Ptr,
1984  CGM.getTypes().ConvertType(E->getType()));
1985  return Ptr;
1986 }
1987 
1988 ConstantLValue
1989 ConstantLValueEmitter::VisitCallExpr(const CallExpr *E) {
1990  unsigned builtin = E->getBuiltinCallee();
1991  if (builtin != Builtin::BI__builtin___CFStringMakeConstantString &&
1992  builtin != Builtin::BI__builtin___NSStringMakeConstantString)
1993  return nullptr;
1994 
1995  auto literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts());
1996  if (builtin == Builtin::BI__builtin___NSStringMakeConstantString) {
1997  return CGM.getObjCRuntime().GenerateConstantString(literal);
1998  } else {
1999  // FIXME: need to deal with UCN conversion issues.
2000  return CGM.GetAddrOfConstantCFString(literal);
2001  }
2002 }
2003 
2004 ConstantLValue
2005 ConstantLValueEmitter::VisitBlockExpr(const BlockExpr *E) {
2006  StringRef functionName;
2007  if (auto CGF = Emitter.CGF)
2008  functionName = CGF->CurFn->getName();
2009  else
2010  functionName = "global";
2011 
2012  return CGM.GetAddrOfGlobalBlock(E, functionName);
2013 }
2014 
2015 ConstantLValue
2016 ConstantLValueEmitter::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
2017  QualType T;
2018  if (E->isTypeOperand())
2019  T = E->getTypeOperand(CGM.getContext());
2020  else
2021  T = E->getExprOperand()->getType();
2022  return CGM.GetAddrOfRTTIDescriptor(T);
2023 }
2024 
2025 ConstantLValue
2026 ConstantLValueEmitter::VisitMaterializeTemporaryExpr(
2027  const MaterializeTemporaryExpr *E) {
2028  assert(E->getStorageDuration() == SD_Static);
2029  SmallVector<const Expr *, 2> CommaLHSs;
2031  const Expr *Inner =
2032  E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
2033  return CGM.GetAddrOfGlobalTemporary(E, Inner);
2034 }
2035 
2037  QualType DestType) {
2038  switch (Value.getKind()) {
2039  case APValue::None:
2041  // Out-of-lifetime and indeterminate values can be modeled as 'undef'.
2042  return llvm::UndefValue::get(CGM.getTypes().ConvertType(DestType));
2043  case APValue::LValue:
2044  return ConstantLValueEmitter(*this, Value, DestType).tryEmit();
2045  case APValue::Int:
2046  return llvm::ConstantInt::get(CGM.getLLVMContext(), Value.getInt());
2047  case APValue::FixedPoint:
2048  return llvm::ConstantInt::get(CGM.getLLVMContext(),
2049  Value.getFixedPoint().getValue());
2050  case APValue::ComplexInt: {
2051  llvm::Constant *Complex[2];
2052 
2053  Complex[0] = llvm::ConstantInt::get(CGM.getLLVMContext(),
2054  Value.getComplexIntReal());
2055  Complex[1] = llvm::ConstantInt::get(CGM.getLLVMContext(),
2056  Value.getComplexIntImag());
2057 
2058  // FIXME: the target may want to specify that this is packed.
2059  llvm::StructType *STy =
2060  llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType());
2061  return llvm::ConstantStruct::get(STy, Complex);
2062  }
2063  case APValue::Float: {
2064  const llvm::APFloat &Init = Value.getFloat();
2065  if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf() &&
2066  !CGM.getContext().getLangOpts().NativeHalfType &&
2068  return llvm::ConstantInt::get(CGM.getLLVMContext(),
2069  Init.bitcastToAPInt());
2070  else
2071  return llvm::ConstantFP::get(CGM.getLLVMContext(), Init);
2072  }
2073  case APValue::ComplexFloat: {
2074  llvm::Constant *Complex[2];
2075 
2076  Complex[0] = llvm::ConstantFP::get(CGM.getLLVMContext(),
2077  Value.getComplexFloatReal());
2078  Complex[1] = llvm::ConstantFP::get(CGM.getLLVMContext(),
2079  Value.getComplexFloatImag());
2080 
2081  // FIXME: the target may want to specify that this is packed.
2082  llvm::StructType *STy =
2083  llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType());
2084  return llvm::ConstantStruct::get(STy, Complex);
2085  }
2086  case APValue::Vector: {
2087  unsigned NumElts = Value.getVectorLength();
2088  SmallVector<llvm::Constant *, 4> Inits(NumElts);
2089 
2090  for (unsigned I = 0; I != NumElts; ++I) {
2091  const APValue &Elt = Value.getVectorElt(I);
2092  if (Elt.isInt())
2093  Inits[I] = llvm::ConstantInt::get(CGM.getLLVMContext(), Elt.getInt());
2094  else if (Elt.isFloat())
2095  Inits[I] = llvm::ConstantFP::get(CGM.getLLVMContext(), Elt.getFloat());
2096  else
2097  llvm_unreachable("unsupported vector element type");
2098  }
2099  return llvm::ConstantVector::get(Inits);
2100  }
2101  case APValue::AddrLabelDiff: {
2102  const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
2103  const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
2104  llvm::Constant *LHS = tryEmitPrivate(LHSExpr, LHSExpr->getType());
2105  llvm::Constant *RHS = tryEmitPrivate(RHSExpr, RHSExpr->getType());
2106  if (!LHS || !RHS) return nullptr;
2107 
2108  // Compute difference
2109  llvm::Type *ResultType = CGM.getTypes().ConvertType(DestType);
2110  LHS = llvm::ConstantExpr::getPtrToInt(LHS, CGM.IntPtrTy);
2111  RHS = llvm::ConstantExpr::getPtrToInt(RHS, CGM.IntPtrTy);
2112  llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
2113 
2114  // LLVM is a bit sensitive about the exact format of the
2115  // address-of-label difference; make sure to truncate after
2116  // the subtraction.
2117  return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
2118  }
2119  case APValue::Struct:
2120  case APValue::Union:
2121  return ConstStructBuilder::BuildStruct(*this, Value, DestType);
2122  case APValue::Array: {
2123  const ArrayType *ArrayTy = CGM.getContext().getAsArrayType(DestType);
2124  unsigned NumElements = Value.getArraySize();
2125  unsigned NumInitElts = Value.getArrayInitializedElts();
2126 
2127  // Emit array filler, if there is one.
2128  llvm::Constant *Filler = nullptr;
2129  if (Value.hasArrayFiller()) {
2130  Filler = tryEmitAbstractForMemory(Value.getArrayFiller(),
2131  ArrayTy->getElementType());
2132  if (!Filler)
2133  return nullptr;
2134  }
2135 
2136  // Emit initializer elements.
2138  if (Filler && Filler->isNullValue())
2139  Elts.reserve(NumInitElts + 1);
2140  else
2141  Elts.reserve(NumElements);
2142 
2143  llvm::Type *CommonElementType = nullptr;
2144  for (unsigned I = 0; I < NumInitElts; ++I) {
2145  llvm::Constant *C = tryEmitPrivateForMemory(
2146  Value.getArrayInitializedElt(I), ArrayTy->getElementType());
2147  if (!C) return nullptr;
2148 
2149  if (I == 0)
2150  CommonElementType = C->getType();
2151  else if (C->getType() != CommonElementType)
2152  CommonElementType = nullptr;
2153  Elts.push_back(C);
2154  }
2155 
2156  llvm::ArrayType *Desired =
2157  cast<llvm::ArrayType>(CGM.getTypes().ConvertType(DestType));
2158  return EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts,
2159  Filler);
2160  }
2162  return CGM.getCXXABI().EmitMemberPointer(Value, DestType);
2163  }
2164  llvm_unreachable("Unknown APValue kind");
2165 }
2166 
2168  const CompoundLiteralExpr *E) {
2169  return EmittedCompoundLiterals.lookup(E);
2170 }
2171 
2173  const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV) {
2174  bool Ok = EmittedCompoundLiterals.insert(std::make_pair(CLE, GV)).second;
2175  (void)Ok;
2176  assert(Ok && "CLE has already been emitted!");
2177 }
2178 
2181  assert(E->isFileScope() && "not a file-scope compound literal expr");
2182  return tryEmitGlobalCompoundLiteral(*this, nullptr, E);
2183 }
2184 
2185 llvm::Constant *
2187  // Member pointer constants always have a very particular form.
2188  const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
2189  const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
2190 
2191  // A member function pointer.
2192  if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
2193  return getCXXABI().EmitMemberFunctionPointer(method);
2194 
2195  // Otherwise, a member data pointer.
2196  uint64_t fieldOffset = getContext().getFieldOffset(decl);
2197  CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
2198  return getCXXABI().EmitMemberDataPointer(type, chars);
2199 }
2200 
2201 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
2202  llvm::Type *baseType,
2203  const CXXRecordDecl *base);
2204 
2205 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
2206  const RecordDecl *record,
2207  bool asCompleteObject) {
2208  const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
2209  llvm::StructType *structure =
2210  (asCompleteObject ? layout.getLLVMType()
2211  : layout.getBaseSubobjectLLVMType());
2212 
2213  unsigned numElements = structure->getNumElements();
2214  std::vector<llvm::Constant *> elements(numElements);
2215 
2216  auto CXXR = dyn_cast<CXXRecordDecl>(record);
2217  // Fill in all the bases.
2218  if (CXXR) {
2219  for (const auto &I : CXXR->bases()) {
2220  if (I.isVirtual()) {
2221  // Ignore virtual bases; if we're laying out for a complete
2222  // object, we'll lay these out later.
2223  continue;
2224  }
2225 
2226  const CXXRecordDecl *base =
2227  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
2228 
2229  // Ignore empty bases.
2230  if (base->isEmpty() ||
2232  .isZero())
2233  continue;
2234 
2235  unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
2236  llvm::Type *baseType = structure->getElementType(fieldIndex);
2237  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
2238  }
2239  }
2240 
2241  // Fill in all the fields.
2242  for (const auto *Field : record->fields()) {
2243  // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
2244  // will fill in later.)
2245  if (!Field->isBitField() && !Field->isZeroSize(CGM.getContext())) {
2246  unsigned fieldIndex = layout.getLLVMFieldNo(Field);
2247  elements[fieldIndex] = CGM.EmitNullConstant(Field->getType());
2248  }
2249 
2250  // For unions, stop after the first named field.
2251  if (record->isUnion()) {
2252  if (Field->getIdentifier())
2253  break;
2254  if (const auto *FieldRD = Field->getType()->getAsRecordDecl())
2255  if (FieldRD->findFirstNamedDataMember())
2256  break;
2257  }
2258  }
2259 
2260  // Fill in the virtual bases, if we're working with the complete object.
2261  if (CXXR && asCompleteObject) {
2262  for (const auto &I : CXXR->vbases()) {
2263  const CXXRecordDecl *base =
2264  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
2265 
2266  // Ignore empty bases.
2267  if (base->isEmpty())
2268  continue;
2269 
2270  unsigned fieldIndex = layout.getVirtualBaseIndex(base);
2271 
2272  // We might have already laid this field out.
2273  if (elements[fieldIndex]) continue;
2274 
2275  llvm::Type *baseType = structure->getElementType(fieldIndex);
2276  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
2277  }
2278  }
2279 
2280  // Now go through all other fields and zero them out.
2281  for (unsigned i = 0; i != numElements; ++i) {
2282  if (!elements[i])
2283  elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
2284  }
2285 
2286  return llvm::ConstantStruct::get(structure, elements);
2287 }
2288 
2289 /// Emit the null constant for a base subobject.
2290 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
2291  llvm::Type *baseType,
2292  const CXXRecordDecl *base) {
2293  const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
2294 
2295  // Just zero out bases that don't have any pointer to data members.
2296  if (baseLayout.isZeroInitializableAsBase())
2297  return llvm::Constant::getNullValue(baseType);
2298 
2299  // Otherwise, we can just use its null constant.
2300  return EmitNullConstant(CGM, base, /*asCompleteObject=*/false);
2301 }
2302 
2304  QualType T) {
2305  return emitForMemory(CGM, CGM.EmitNullConstant(T), T);
2306 }
2307 
2309  if (T->getAs<PointerType>())
2310  return getNullPointer(
2311  cast<llvm::PointerType>(getTypes().ConvertTypeForMem(T)), T);
2312 
2313  if (getTypes().isZeroInitializable(T))
2314  return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
2315 
2316  if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
2317  llvm::ArrayType *ATy =
2318  cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
2319 
2320  QualType ElementTy = CAT->getElementType();
2321 
2322  llvm::Constant *Element =
2323  ConstantEmitter::emitNullForMemory(*this, ElementTy);
2324  unsigned NumElements = CAT->getSize().getZExtValue();
2325  SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
2326  return llvm::ConstantArray::get(ATy, Array);
2327  }
2328 
2329  if (const RecordType *RT = T->getAs<RecordType>())
2330  return ::EmitNullConstant(*this, RT->getDecl(), /*complete object*/ true);
2331 
2332  assert(T->isMemberDataPointerType() &&
2333  "Should only see pointers to data members here!");
2334 
2336 }
2337 
2338 llvm::Constant *
2340  return ::EmitNullConstant(*this, Record, false);
2341 }
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:3835
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:3913
clang::CodeGen::ConstantEmitter::emitForInitializer
llvm::Constant * emitForInitializer(const APValue &value, LangAS destAddrSpace, QualType destType)
Definition: CGExprConstant.cpp:1419
clang::SubstNonTypeTemplateParmExpr
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4245
clang::ASTContext::getQualifiedType
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:2086
clang::CodeGen::CGRecordLayout::getBitFieldInfo
const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const
Return the BitFieldInfo that corresponds to the field FD.
Definition: CGRecordLayout.h:216
Builtins.h
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6762
emitConstantObjCStringLiteral
static ConstantLValue emitConstantObjCStringLiteral(const StringLiteral *S, QualType T, CodeGenModule &CGM)
Definition: CGExprConstant.cpp:1954
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:4605
clang::APValue::LValueBase
Definition: APValue.h:146
clang::ConstantExpr::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.h:1082
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:4127
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2401
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:68
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:74
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:1407
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:2308
clang::DeclContext::specific_decl_iterator
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2135
clang::ASTContext::getCharWidth
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2249
type
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:103
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:1608
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2929
clang::APValue::FixedPoint
@ FixedPoint
Definition: APValue.h:134
clang::DesignatedInitUpdateExpr::getBase
Expr * getBase() const
Definition: Expr.h:5381
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:3712
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:2952
clang::Expr::IgnoreImplicit
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:2907
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:88
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:4479
clang::CodeGen::ConstantEmitter::emitForMemory
llvm::Constant * emitForMemory(llvm::Constant *C, QualType T)
Definition: ConstantEmitter.h:118
clang::ConstantExpr::getAPValueResult
APValue getAPValueResult() const
Definition: Expr.cpp:364
clang::CastExpr::getSubExpr
Expr * getSubExpr()
Definition: Expr.h:3524
clang::APValue::Struct
@ Struct
Definition: APValue.h:140
CGRecordLayout.h
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
Attr.h
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:54
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:839
clang::CodeGen::CodeGenModule::getContext
ASTContext & getContext() const
Definition: CodeGenModule.h:702
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2835
clang::ASTContext::getBaseElementType
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Definition: ASTContext.cpp:6300
clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:772
EmitNullConstant
static llvm::Constant * EmitNullConstant(CodeGenModule &CGM, const RecordDecl *record, bool asCompleteObject)
Definition: CGExprConstant.cpp:2205
clang::CodeGen::ConstantEmitter::tryEmitPrivateForVarInit
llvm::Constant * tryEmitPrivateForVarInit(const VarDecl &D)
Definition: CGExprConstant.cpp:1613
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:2500
clang::APValue::ComplexFloat
@ ComplexFloat
Definition: APValue.h:136
CGObjCRuntime.h
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4786
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:2157
clang::MaterializeTemporaryExpr::getStorageDuration
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4487
clang::Type::isVoidType
bool isVoidType() const
Definition: Type.h:6955
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:11083
ConstantEmitter.h
clang::ASTContext::toBits
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
Definition: ASTContext.cpp:2444
clang::CXXTypeidExpr::getExprOperand
Expr * getExprOperand() const
Definition: ExprCXX.h:886
clang::InitListExpr::isTransparent
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
Definition: Expr.cpp:2306
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:1346
clang::CodeGen::CodeGenTypes::ConvertType
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:395
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1490
clang::CodeGen::ConstantEmitter::tryEmitPrivate
llvm::Constant * tryEmitPrivate(const Expr *E, QualType T)
Definition: CGExprConstant.cpp:1715
Offset
unsigned Offset
Definition: Format.cpp:2335
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::setAddrOfConstantCompoundLiteral
void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV)
Notes that CLE's GlobalVariable is GV.
Definition: CGExprConstant.cpp:2172
clang::ASTContext::getTypeAlignInChars
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
Definition: ASTContext.cpp:2459
clang::CodeGen::CodeGenModule::getOrCreateStaticVarDecl
llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGDecl.cpp:239
clang::CodeGen::CodeGenTypes::ConvertTypeForMem
llvm::Type * ConvertTypeForMem(QualType T, bool ForBitField=false)
ConvertTypeForMem - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:90
clang::CompoundLiteralExpr::isFileScope
bool isFileScope() const
Definition: Expr.h:3430
clang::CodeGen::ConstantEmitter::~ConstantEmitter
~ConstantEmitter()
Definition: CGExprConstant.cpp:1599
clang::TypeInfo
Definition: ASTContext.h:182
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:80
clang::Type::isReferenceType
bool isReferenceType() const
Definition: Type.h:6684
clang::CodeGen::CGCXXABI::EmitNullMemberPointer
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:99
clang::CodeGen::CodeGenModule::GetAddrOfConstantCFString
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
Definition: CodeGenModule.cpp:5088
clang::ast_matchers::expr
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchersInternal.cpp:889
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:4613
clang::ASTContext::getAsConstantArrayType
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2629
clang::FunctionDecl::isTrivial
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2207
clang::CodeGen::CodeGenModule::getObjCRuntime
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
Definition: CodeGenModule.h:599
clang::QualType::getAddressSpace
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6545
clang::ParenExpr::getSubExpr
const Expr * getSubExpr() const
Definition: Expr.h:2121
GCCTypeClass::Complex
@ Complex
clang::APValue::Union
@ Union
Definition: APValue.h:141
clang::XRayInstrKind::None
constexpr XRayInstrMask None
Definition: XRayInstr.h:38
clang::BaseSubobject
Definition: BaseSubobject.h:30
clang::CodeGen::CGRecordLayout::getNonVirtualBaseLLVMFieldNo
unsigned getNonVirtualBaseLLVMFieldNo(const CXXRecordDecl *RD) const
Definition: CGRecordLayout.h:203
clang::CodeGen::ConstantEmitter::getCurrentAddrPrivate
llvm::GlobalValue * getCurrentAddrPrivate()
Get the address of the current location.
Definition: CGExprConstant.cpp:1428
clang::ASTContext::getAsArrayType
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
Definition: ASTContext.cpp:6189
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:4277
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:108
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:484
clang::MaterializeTemporaryExpr
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4462
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:212
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:2883
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7161
clang::CallExpr::getArg
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2986
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:2653
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:709
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:2245
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:606
clang::ImplicitValueInitExpr
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5505
ASTContext.h
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:876
clang::PredefinedExpr::getFunctionName
StringLiteral * getFunctionName()
Definition: Expr.h:2008
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:1761
clang::CodeGen::CodeGenModule::getTypes
CodeGenTypes & getTypes()
Definition: CodeGenModule.h:726
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:1532
clang::ExprWithCleanups
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:3342
clang::APValue::getUnionField
const FieldDecl * getUnionField() const
Definition: APValue.h:555
clang::TagDecl::isUnion
bool isUnion() const
Definition: Decl.h:3516
clang::APValue::LValue
@ LValue
Definition: APValue.h:137
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:2180
Base
CodeGenModule.h
clang::ObjCEncodeExpr
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:409
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:1287
clang::interp::Const
bool Const(InterpState &S, CodePtr OpPC, const T &Arg)
Definition: Interp.h:296
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:1026
clang::CastExpr::getCastKind
CastKind getCastKind() const
Definition: Expr.h:3518
clang::ChooseExpr
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4520
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::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::ASTContext::getTargetAddressSpace
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2720
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:2633
getNonMemoryType
static QualType getNonMemoryType(CodeGenModule &CGM, QualType type)
Definition: CGExprConstant.cpp:1605
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:1141
clang::FullExpr::getSubExpr
const Expr * getSubExpr() const
Definition: Expr.h:1011
clang::CodeGen::CodeGenTypes::getCGRecordLayout
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
Definition: CodeGenTypes.cpp:875
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:5319
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:711
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7226
clang::transformer::EditKind::Range
@ Range
clang::CompoundLiteralExpr
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3403
Emitter
clang::CastExpr::getTargetUnionField
const FieldDecl * getTargetUnionField() const
Definition: Expr.h:3556
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:113
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:2924
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:255
clang::CodeGen::CodeGenModule::GetAddrOfTemplateParamObject
ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)
Get the address of a template parameter object.
Definition: CodeGenModule.cpp:2822
clang::Type::isUnionType
bool isUnionType() const
Definition: Type.cpp:595
clang::ast_matchers::decl
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchersInternal.cpp:734
clang::DesignatedInitUpdateExpr
Definition: Expr.h:5362
clang::CodeGen::ConstantEmitter::tryEmitConstantExpr
llvm::Constant * tryEmitConstantExpr(const ConstantExpr *CE)
Definition: CGExprConstant.cpp:1366
clang::ObjCEncodeExpr::getEncodedType
QualType getEncodedType() const
Definition: ExprObjC.h:428
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:1044
clang::ChooseExpr::getChosenSubExpr
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:4556
clang::DesignatedInitUpdateExpr::getUpdater
InitListExpr * getUpdater() const
Definition: Expr.h:5384
clang::CodeGen::CodeGenFunction
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Definition: CodeGenFunction.h:235
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:676
clang::CXXDefaultInitExpr::getExpr
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1346
clang::ParenExpr
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:2106
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:719
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:3389
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:229
clang::ConstantExpr::hasAPValueResult
bool hasAPValueResult() const
Definition: Expr.h:1107
clang::CodeGen::CodeGenModule
This class organizes the cross-function state that is used while generating LLVM code.
Definition: CodeGenModule.h:284
clang::RecordDecl::fields
field_range fields() const
Definition: Decl.h:4079
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:1381
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:6229
clang::APValue::ComplexInt
@ ComplexInt
Definition: APValue.h:135
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5965
llvm::ArrayRef
Definition: LLVM.h:34
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::CodeGen::CodeGenModule::GetAddrOfMSGuidDecl
ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)
Get the address of a GUID.
Definition: CodeGenModule.cpp:2769
clang::CXXTypeidExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:875
clang::AddrLabelExpr
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:4300
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:1448
clang::CodeGen::ConstantEmitter::emitNullForMemory
llvm::Constant * emitNullForMemory(QualType T)
Definition: ConstantEmitter.h:115
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:310
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:188
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:4882
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:1285
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:14717
clang::ASTContext::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:747
clang::CodeGen::CodeGenModule::getNullPointer
llvm::Constant * getNullPointer(llvm::PointerType *T, QualType QT)
Get target specific null pointer.
Definition: CGExprConstant.cpp:1737
clang::RecordDecl::field_end
field_iterator field_end() const
Definition: Decl.h:4082
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:5384
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2831
clang::CodeGen::ConstantAddress::getPointer
llvm::Constant * getPointer() const
Definition: Address.h:83
clang::CodeGen::CGRecordLayout::getVirtualBaseIndex
unsigned getVirtualBaseIndex(const CXXRecordDecl *base) const
Return the LLVM field index corresponding to the given virtual base.
Definition: CGRecordLayout.h:210
CGCXXABI.h
clang::CodeGen::ConstantAddress::invalid
static ConstantAddress invalid()
Definition: Address.h:79
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:14774
clang::PredefinedExpr
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1953
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2640
clang::ObjCStringLiteral::getString
StringLiteral * getString()
Definition: ExprObjC.h:65
clang::CodeGen::CodeGenModule::getMemberPointerConstant
llvm::Constant * getMemberPointerConstant(const UnaryOperator *e)
Definition: CGExprConstant.cpp:2186
clang::CompoundLiteralExpr::getInitializer
const Expr * getInitializer() const
Definition: Expr.h:3426
clang::CodeGen::CodeGenFunction::CurFn
llvm::Function * CurFn
Definition: CodeGenFunction.h:330
clang::UnaryOperator::getSubExpr
Expr * getSubExpr() const
Definition: Expr.h:2204
clang::Type::isMemberDataPointerType
bool isMemberDataPointerType() const
Definition: Type.h:6731
clang
Definition: CalledOnceCheck.h:17
clang::InitListExpr::getInitializedFieldInUnion
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4900
clang::Type::isArrayType
bool isArrayType() const
Definition: Type.h:6738
clang::interp::GE
bool GE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:254
clang::ASTContext::toCharUnitsFromBits
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Definition: ASTContext.cpp:2439
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:69
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:5623
clang::operator<
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
Definition: DeclarationName.h:540
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:1670
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:147
clang::CodeGen::CodeGenModule::GetWeakRefReference
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
Definition: CodeGenModule.cpp:2849
clang::CodeGen::CodeGenModule::getLLVMLinkageVarDefinition
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD, bool IsConstant)
Returns LLVM linkage for a declarator.
Definition: CodeGenModule.cpp:4720
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:3246
clang::CodeGen::ConstantEmitter
Definition: ConstantEmitter.h:23
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4623
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:497
clang::InitListExpr::getInit
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4834
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:1353
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:1501
clang::CodeGen::CodeGenModule::GetAddrOfConstantStringFromObjCEncode
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
Definition: CodeGenModule.cpp:5432
clang::CXXConstructExpr::getArg
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1611
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::AtomicType
Definition: Type.h:6242
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:7291
llvm::SmallVectorImpl
Definition: LLVM.h:39
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:687
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:2508
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2904
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:2290
clang::CXXDefaultInitExpr
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1318
clang::VarDecl::hasLocalStorage
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1101
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:3473
clang::AddrLabelExpr::getLabel
LabelDecl * getLabel() const
Definition: Expr.h:4323
clang::ObjCBoxedExpr::isExpressibleAsConstantInitializer
bool isExpressibleAsConstantInitializer() const
Definition: ExprObjC.h:153
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3859
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:5476
clang::CodeGen::ConstantEmitter::finalize
void finalize(llvm::GlobalVariable *global)
Definition: CGExprConstant.cpp:1583
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2795
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:2167
clang::InitListExpr::getNumInits
unsigned getNumInits() const
Definition: Expr.h:4816
clang::CXXConstructExpr
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1460
clang::CodeGen::CodeGenModule::Error
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
Definition: CodeGenModule.cpp:957
clang::ASTContext::getLangOpts
const LangOptions & getLangOpts() const
Definition: ASTContext.h:765
clang::CodeGen::CodeGenModule::getLLVMContext
llvm::LLVMContext & getLLVMContext()
Definition: CodeGenModule.h:720
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:1656
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:865
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:2339
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:2430
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1198
clang::APValue::Float
@ Float
Definition: APValue.h:133
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1948
clang::APValue::LValueBase::dyn_cast
T dyn_cast() const
Definition: APValue.h:167