clang  8.0.0svn
CGExprConstant.cpp
Go to the documentation of this file.
1 //===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to emit Constant Expr nodes as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CGCXXABI.h"
16 #include "CGObjCRuntime.h"
17 #include "CGRecordLayout.h"
18 #include "CodeGenModule.h"
19 #include "ConstantEmitter.h"
20 #include "TargetInfo.h"
21 #include "clang/AST/APValue.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/RecordLayout.h"
24 #include "clang/AST/StmtVisitor.h"
25 #include "clang/Basic/Builtins.h"
26 #include "llvm/IR/Constants.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/Function.h"
29 #include "llvm/IR/GlobalVariable.h"
30 using namespace clang;
31 using namespace CodeGen;
32 
33 //===----------------------------------------------------------------------===//
34 // ConstStructBuilder
35 //===----------------------------------------------------------------------===//
36 
37 namespace {
38 class ConstExprEmitter;
39 class ConstStructBuilder {
40  CodeGenModule &CGM;
41  ConstantEmitter &Emitter;
42 
43  bool Packed;
44  CharUnits NextFieldOffsetInChars;
45  CharUnits LLVMStructAlignment;
47 public:
48  static llvm::Constant *BuildStruct(ConstantEmitter &Emitter,
49  ConstExprEmitter *ExprEmitter,
50  llvm::ConstantStruct *Base,
51  InitListExpr *Updater,
52  QualType ValTy);
53  static llvm::Constant *BuildStruct(ConstantEmitter &Emitter,
54  InitListExpr *ILE, QualType StructTy);
55  static llvm::Constant *BuildStruct(ConstantEmitter &Emitter,
56  const APValue &Value, QualType ValTy);
57 
58 private:
59  ConstStructBuilder(ConstantEmitter &emitter)
60  : CGM(emitter.CGM), Emitter(emitter), Packed(false),
61  NextFieldOffsetInChars(CharUnits::Zero()),
62  LLVMStructAlignment(CharUnits::One()) { }
63 
64  void AppendField(const FieldDecl *Field, uint64_t FieldOffset,
65  llvm::Constant *InitExpr);
66 
67  void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst);
68 
69  void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
70  llvm::ConstantInt *InitExpr);
71 
72  void AppendPadding(CharUnits PadSize);
73 
74  void AppendTailPadding(CharUnits RecordSize);
75 
76  void ConvertStructToPacked();
77 
78  bool Build(InitListExpr *ILE);
79  bool Build(ConstExprEmitter *Emitter, llvm::ConstantStruct *Base,
80  InitListExpr *Updater);
81  bool Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase,
82  const CXXRecordDecl *VTableClass, CharUnits BaseOffset);
83  llvm::Constant *Finalize(QualType Ty);
84 
85  CharUnits getAlignment(const llvm::Constant *C) const {
86  if (Packed) return CharUnits::One();
88  CGM.getDataLayout().getABITypeAlignment(C->getType()));
89  }
90 
91  CharUnits getSizeInChars(const llvm::Constant *C) const {
93  CGM.getDataLayout().getTypeAllocSize(C->getType()));
94  }
95 };
96 
97 void ConstStructBuilder::
98 AppendField(const FieldDecl *Field, uint64_t FieldOffset,
99  llvm::Constant *InitCst) {
100  const ASTContext &Context = CGM.getContext();
101 
102  CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
103 
104  AppendBytes(FieldOffsetInChars, InitCst);
105 }
106 
107 void ConstStructBuilder::
108 AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) {
109 
110  assert(NextFieldOffsetInChars <= FieldOffsetInChars
111  && "Field offset mismatch!");
112 
113  CharUnits FieldAlignment = getAlignment(InitCst);
114 
115  // Round up the field offset to the alignment of the field type.
116  CharUnits AlignedNextFieldOffsetInChars =
117  NextFieldOffsetInChars.alignTo(FieldAlignment);
118 
119  if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) {
120  // We need to append padding.
121  AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars);
122 
123  assert(NextFieldOffsetInChars == FieldOffsetInChars &&
124  "Did not add enough padding!");
125 
126  AlignedNextFieldOffsetInChars =
127  NextFieldOffsetInChars.alignTo(FieldAlignment);
128  }
129 
130  if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) {
131  assert(!Packed && "Alignment is wrong even with a packed struct!");
132 
133  // Convert the struct to a packed struct.
134  ConvertStructToPacked();
135 
136  // After we pack the struct, we may need to insert padding.
137  if (NextFieldOffsetInChars < FieldOffsetInChars) {
138  // We need to append padding.
139  AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars);
140 
141  assert(NextFieldOffsetInChars == FieldOffsetInChars &&
142  "Did not add enough padding!");
143  }
144  AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
145  }
146 
147  // Add the field.
148  Elements.push_back(InitCst);
149  NextFieldOffsetInChars = AlignedNextFieldOffsetInChars +
150  getSizeInChars(InitCst);
151 
152  if (Packed)
153  assert(LLVMStructAlignment == CharUnits::One() &&
154  "Packed struct not byte-aligned!");
155  else
156  LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment);
157 }
158 
159 void ConstStructBuilder::AppendBitField(const FieldDecl *Field,
160  uint64_t FieldOffset,
161  llvm::ConstantInt *CI) {
162  const ASTContext &Context = CGM.getContext();
163  const uint64_t CharWidth = Context.getCharWidth();
164  uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
165  if (FieldOffset > NextFieldOffsetInBits) {
166  // We need to add padding.
167  CharUnits PadSize = Context.toCharUnitsFromBits(
168  llvm::alignTo(FieldOffset - NextFieldOffsetInBits,
169  Context.getTargetInfo().getCharAlign()));
170 
171  AppendPadding(PadSize);
172  }
173 
174  uint64_t FieldSize = Field->getBitWidthValue(Context);
175 
176  llvm::APInt FieldValue = CI->getValue();
177 
178  // Promote the size of FieldValue if necessary
179  // FIXME: This should never occur, but currently it can because initializer
180  // constants are cast to bool, and because clang is not enforcing bitfield
181  // width limits.
182  if (FieldSize > FieldValue.getBitWidth())
183  FieldValue = FieldValue.zext(FieldSize);
184 
185  // Truncate the size of FieldValue to the bit field size.
186  if (FieldSize < FieldValue.getBitWidth())
187  FieldValue = FieldValue.trunc(FieldSize);
188 
189  NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
190  if (FieldOffset < NextFieldOffsetInBits) {
191  // Either part of the field or the entire field can go into the previous
192  // byte.
193  assert(!Elements.empty() && "Elements can't be empty!");
194 
195  unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset;
196 
197  bool FitsCompletelyInPreviousByte =
198  BitsInPreviousByte >= FieldValue.getBitWidth();
199 
200  llvm::APInt Tmp = FieldValue;
201 
202  if (!FitsCompletelyInPreviousByte) {
203  unsigned NewFieldWidth = FieldSize - BitsInPreviousByte;
204 
205  if (CGM.getDataLayout().isBigEndian()) {
206  Tmp.lshrInPlace(NewFieldWidth);
207  Tmp = Tmp.trunc(BitsInPreviousByte);
208 
209  // We want the remaining high bits.
210  FieldValue = FieldValue.trunc(NewFieldWidth);
211  } else {
212  Tmp = Tmp.trunc(BitsInPreviousByte);
213 
214  // We want the remaining low bits.
215  FieldValue.lshrInPlace(BitsInPreviousByte);
216  FieldValue = FieldValue.trunc(NewFieldWidth);
217  }
218  }
219 
220  Tmp = Tmp.zext(CharWidth);
221  if (CGM.getDataLayout().isBigEndian()) {
222  if (FitsCompletelyInPreviousByte)
223  Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth());
224  } else {
225  Tmp = Tmp.shl(CharWidth - BitsInPreviousByte);
226  }
227 
228  // 'or' in the bits that go into the previous byte.
229  llvm::Value *LastElt = Elements.back();
230  if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt))
231  Tmp |= Val->getValue();
232  else {
233  assert(isa<llvm::UndefValue>(LastElt));
234  // If there is an undef field that we're adding to, it can either be a
235  // scalar undef (in which case, we just replace it with our field) or it
236  // is an array. If it is an array, we have to pull one byte off the
237  // array so that the other undef bytes stay around.
238  if (!isa<llvm::IntegerType>(LastElt->getType())) {
239  // The undef padding will be a multibyte array, create a new smaller
240  // padding and then an hole for our i8 to get plopped into.
241  assert(isa<llvm::ArrayType>(LastElt->getType()) &&
242  "Expected array padding of undefs");
243  llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType());
244  assert(AT->getElementType()->isIntegerTy(CharWidth) &&
245  AT->getNumElements() != 0 &&
246  "Expected non-empty array padding of undefs");
247 
248  // Remove the padding array.
249  NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements());
250  Elements.pop_back();
251 
252  // Add the padding back in two chunks.
253  AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1));
254  AppendPadding(CharUnits::One());
255  assert(isa<llvm::UndefValue>(Elements.back()) &&
256  Elements.back()->getType()->isIntegerTy(CharWidth) &&
257  "Padding addition didn't work right");
258  }
259  }
260 
261  Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp);
262 
263  if (FitsCompletelyInPreviousByte)
264  return;
265  }
266 
267  while (FieldValue.getBitWidth() > CharWidth) {
268  llvm::APInt Tmp;
269 
270  if (CGM.getDataLayout().isBigEndian()) {
271  // We want the high bits.
272  Tmp =
273  FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth);
274  } else {
275  // We want the low bits.
276  Tmp = FieldValue.trunc(CharWidth);
277 
278  FieldValue.lshrInPlace(CharWidth);
279  }
280 
281  Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp));
282  ++NextFieldOffsetInChars;
283 
284  FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth);
285  }
286 
287  assert(FieldValue.getBitWidth() > 0 &&
288  "Should have at least one bit left!");
289  assert(FieldValue.getBitWidth() <= CharWidth &&
290  "Should not have more than a byte left!");
291 
292  if (FieldValue.getBitWidth() < CharWidth) {
293  if (CGM.getDataLayout().isBigEndian()) {
294  unsigned BitWidth = FieldValue.getBitWidth();
295 
296  FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth);
297  } else
298  FieldValue = FieldValue.zext(CharWidth);
299  }
300 
301  // Append the last element.
302  Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(),
303  FieldValue));
304  ++NextFieldOffsetInChars;
305 }
306 
307 void ConstStructBuilder::AppendPadding(CharUnits PadSize) {
308  if (PadSize.isZero())
309  return;
310 
311  llvm::Type *Ty = CGM.Int8Ty;
312  if (PadSize > CharUnits::One())
313  Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity());
314 
315  llvm::Constant *C = llvm::UndefValue::get(Ty);
316  Elements.push_back(C);
317  assert(getAlignment(C) == CharUnits::One() &&
318  "Padding must have 1 byte alignment!");
319 
320  NextFieldOffsetInChars += getSizeInChars(C);
321 }
322 
323 void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) {
324  assert(NextFieldOffsetInChars <= RecordSize &&
325  "Size mismatch!");
326 
327  AppendPadding(RecordSize - NextFieldOffsetInChars);
328 }
329 
330 void ConstStructBuilder::ConvertStructToPacked() {
331  SmallVector<llvm::Constant *, 16> PackedElements;
332  CharUnits ElementOffsetInChars = CharUnits::Zero();
333 
334  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
335  llvm::Constant *C = Elements[i];
336 
337  CharUnits ElementAlign = CharUnits::fromQuantity(
338  CGM.getDataLayout().getABITypeAlignment(C->getType()));
339  CharUnits AlignedElementOffsetInChars =
340  ElementOffsetInChars.alignTo(ElementAlign);
341 
342  if (AlignedElementOffsetInChars > ElementOffsetInChars) {
343  // We need some padding.
344  CharUnits NumChars =
345  AlignedElementOffsetInChars - ElementOffsetInChars;
346 
347  llvm::Type *Ty = CGM.Int8Ty;
348  if (NumChars > CharUnits::One())
349  Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity());
350 
351  llvm::Constant *Padding = llvm::UndefValue::get(Ty);
352  PackedElements.push_back(Padding);
353  ElementOffsetInChars += getSizeInChars(Padding);
354  }
355 
356  PackedElements.push_back(C);
357  ElementOffsetInChars += getSizeInChars(C);
358  }
359 
360  assert(ElementOffsetInChars == NextFieldOffsetInChars &&
361  "Packing the struct changed its size!");
362 
363  Elements.swap(PackedElements);
364  LLVMStructAlignment = CharUnits::One();
365  Packed = true;
366 }
367 
368 bool ConstStructBuilder::Build(InitListExpr *ILE) {
369  RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
370  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
371 
372  unsigned FieldNo = 0;
373  unsigned ElementNo = 0;
374 
375  // Bail out if we have base classes. We could support these, but they only
376  // arise in C++1z where we will have already constant folded most interesting
377  // cases. FIXME: There are still a few more cases we can handle this way.
378  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
379  if (CXXRD->getNumBases())
380  return false;
381 
382  for (RecordDecl::field_iterator Field = RD->field_begin(),
383  FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
384  // If this is a union, skip all the fields that aren't being initialized.
385  if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field)
386  continue;
387 
388  // Don't emit anonymous bitfields, they just affect layout.
389  if (Field->isUnnamedBitfield())
390  continue;
391 
392  // Get the initializer. A struct can include fields without initializers,
393  // we just use explicit null values for them.
394  llvm::Constant *EltInit;
395  if (ElementNo < ILE->getNumInits())
396  EltInit = Emitter.tryEmitPrivateForMemory(ILE->getInit(ElementNo++),
397  Field->getType());
398  else
399  EltInit = Emitter.emitNullForMemory(Field->getType());
400 
401  if (!EltInit)
402  return false;
403 
404  if (!Field->isBitField()) {
405  // Handle non-bitfield members.
406  AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit);
407  } else {
408  // Otherwise we have a bitfield.
409  if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) {
410  AppendBitField(*Field, Layout.getFieldOffset(FieldNo), CI);
411  } else {
412  // We are trying to initialize a bitfield with a non-trivial constant,
413  // this must require run-time code.
414  return false;
415  }
416  }
417  }
418 
419  return true;
420 }
421 
422 namespace {
423 struct BaseInfo {
424  BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
425  : Decl(Decl), Offset(Offset), Index(Index) {
426  }
427 
428  const CXXRecordDecl *Decl;
430  unsigned Index;
431 
432  bool operator<(const BaseInfo &O) const { return Offset < O.Offset; }
433 };
434 }
435 
436 bool ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
437  bool IsPrimaryBase,
438  const CXXRecordDecl *VTableClass,
439  CharUnits Offset) {
440  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
441 
442  if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
443  // Add a vtable pointer, if we need one and it hasn't already been added.
444  if (CD->isDynamicClass() && !IsPrimaryBase) {
445  llvm::Constant *VTableAddressPoint =
447  BaseSubobject(CD, Offset), VTableClass);
448  AppendBytes(Offset, VTableAddressPoint);
449  }
450 
451  // Accumulate and sort bases, in order to visit them in address order, which
452  // may not be the same as declaration order.
454  Bases.reserve(CD->getNumBases());
455  unsigned BaseNo = 0;
456  for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
457  BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
458  assert(!Base->isVirtual() && "should not have virtual bases here");
459  const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
460  CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
461  Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));
462  }
463  std::stable_sort(Bases.begin(), Bases.end());
464 
465  for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
466  BaseInfo &Base = Bases[I];
467 
468  bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
469  Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
470  VTableClass, Offset + Base.Offset);
471  }
472  }
473 
474  unsigned FieldNo = 0;
475  uint64_t OffsetBits = CGM.getContext().toBits(Offset);
476 
477  for (RecordDecl::field_iterator Field = RD->field_begin(),
478  FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
479  // If this is a union, skip all the fields that aren't being initialized.
480  if (RD->isUnion() && Val.getUnionField() != *Field)
481  continue;
482 
483  // Don't emit anonymous bitfields, they just affect layout.
484  if (Field->isUnnamedBitfield())
485  continue;
486 
487  // Emit the value of the initializer.
488  const APValue &FieldValue =
489  RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo);
490  llvm::Constant *EltInit =
491  Emitter.tryEmitPrivateForMemory(FieldValue, Field->getType());
492  if (!EltInit)
493  return false;
494 
495  if (!Field->isBitField()) {
496  // Handle non-bitfield members.
497  AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit);
498  } else {
499  // Otherwise we have a bitfield.
500  AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
501  cast<llvm::ConstantInt>(EltInit));
502  }
503  }
504 
505  return true;
506 }
507 
508 llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) {
509  RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
510  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
511 
512  CharUnits LayoutSizeInChars = Layout.getSize();
513 
514  if (NextFieldOffsetInChars > LayoutSizeInChars) {
515  // If the struct is bigger than the size of the record type,
516  // we must have a flexible array member at the end.
517  assert(RD->hasFlexibleArrayMember() &&
518  "Must have flexible array member if struct is bigger than type!");
519 
520  // No tail padding is necessary.
521  } else {
522  // Append tail padding if necessary.
523  CharUnits LLVMSizeInChars =
524  NextFieldOffsetInChars.alignTo(LLVMStructAlignment);
525 
526  if (LLVMSizeInChars != LayoutSizeInChars)
527  AppendTailPadding(LayoutSizeInChars);
528 
529  LLVMSizeInChars = NextFieldOffsetInChars.alignTo(LLVMStructAlignment);
530 
531  // Check if we need to convert the struct to a packed struct.
532  if (NextFieldOffsetInChars <= LayoutSizeInChars &&
533  LLVMSizeInChars > LayoutSizeInChars) {
534  assert(!Packed && "Size mismatch!");
535 
536  ConvertStructToPacked();
537  assert(NextFieldOffsetInChars <= LayoutSizeInChars &&
538  "Converting to packed did not help!");
539  }
540 
541  LLVMSizeInChars = NextFieldOffsetInChars.alignTo(LLVMStructAlignment);
542 
543  assert(LayoutSizeInChars == LLVMSizeInChars &&
544  "Tail padding mismatch!");
545  }
546 
547  // Pick the type to use. If the type is layout identical to the ConvertType
548  // type then use it, otherwise use whatever the builder produced for us.
549  llvm::StructType *STy =
550  llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(),
551  Elements, Packed);
552  llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty);
553  if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) {
554  if (ValSTy->isLayoutIdentical(STy))
555  STy = ValSTy;
556  }
557 
558  llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements);
559 
560  assert(NextFieldOffsetInChars.alignTo(getAlignment(Result)) ==
561  getSizeInChars(Result) &&
562  "Size mismatch!");
563 
564  return Result;
565 }
566 
567 llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
568  ConstExprEmitter *ExprEmitter,
569  llvm::ConstantStruct *Base,
570  InitListExpr *Updater,
571  QualType ValTy) {
572  ConstStructBuilder Builder(Emitter);
573  if (!Builder.Build(ExprEmitter, Base, Updater))
574  return nullptr;
575  return Builder.Finalize(ValTy);
576 }
577 
578 llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
579  InitListExpr *ILE,
580  QualType ValTy) {
581  ConstStructBuilder Builder(Emitter);
582 
583  if (!Builder.Build(ILE))
584  return nullptr;
585 
586  return Builder.Finalize(ValTy);
587 }
588 
589 llvm::Constant *ConstStructBuilder::BuildStruct(ConstantEmitter &Emitter,
590  const APValue &Val,
591  QualType ValTy) {
592  ConstStructBuilder Builder(Emitter);
593 
594  const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl();
595  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
596  if (!Builder.Build(Val, RD, false, CD, CharUnits::Zero()))
597  return nullptr;
598 
599  return Builder.Finalize(ValTy);
600 }
601 
602 
603 //===----------------------------------------------------------------------===//
604 // ConstExprEmitter
605 //===----------------------------------------------------------------------===//
606 
607 static ConstantAddress tryEmitGlobalCompoundLiteral(CodeGenModule &CGM,
608  CodeGenFunction *CGF,
609  const CompoundLiteralExpr *E) {
610  CharUnits Align = CGM.getContext().getTypeAlignInChars(E->getType());
611  if (llvm::GlobalVariable *Addr =
613  return ConstantAddress(Addr, Align);
614 
615  LangAS addressSpace = E->getType().getAddressSpace();
616 
617  ConstantEmitter emitter(CGM, CGF);
618  llvm::Constant *C = emitter.tryEmitForInitializer(E->getInitializer(),
619  addressSpace, E->getType());
620  if (!C) {
621  assert(!E->isFileScope() &&
622  "file-scope compound literal did not have constant initializer!");
623  return ConstantAddress::invalid();
624  }
625 
626  auto GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
627  CGM.isTypeConstant(E->getType(), true),
629  C, ".compoundliteral", nullptr,
630  llvm::GlobalVariable::NotThreadLocal,
631  CGM.getContext().getTargetAddressSpace(addressSpace));
632  emitter.finalize(GV);
633  GV->setAlignment(Align.getQuantity());
635  return ConstantAddress(GV, Align);
636 }
637 
638 static llvm::Constant *
639 EmitArrayConstant(CodeGenModule &CGM, const ConstantArrayType *DestType,
640  llvm::Type *CommonElementType, unsigned ArrayBound,
642  llvm::Constant *Filler) {
643  // Figure out how long the initial prefix of non-zero elements is.
644  unsigned NonzeroLength = ArrayBound;
645  if (Elements.size() < NonzeroLength && Filler->isNullValue())
646  NonzeroLength = Elements.size();
647  if (NonzeroLength == Elements.size()) {
648  while (NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue())
649  --NonzeroLength;
650  }
651 
652  if (NonzeroLength == 0) {
653  return llvm::ConstantAggregateZero::get(
654  CGM.getTypes().ConvertType(QualType(DestType, 0)));
655  }
656 
657  // Add a zeroinitializer array filler if we have lots of trailing zeroes.
658  unsigned TrailingZeroes = ArrayBound - NonzeroLength;
659  if (TrailingZeroes >= 8) {
660  assert(Elements.size() >= NonzeroLength &&
661  "missing initializer for non-zero element");
662 
663  // If all the elements had the same type up to the trailing zeroes, emit a
664  // struct of two arrays (the nonzero data and the zeroinitializer).
665  if (CommonElementType && NonzeroLength >= 8) {
666  llvm::Constant *Initial = llvm::ConstantArray::get(
667  llvm::ArrayType::get(CommonElementType, NonzeroLength),
668  makeArrayRef(Elements).take_front(NonzeroLength));
669  Elements.resize(2);
670  Elements[0] = Initial;
671  } else {
672  Elements.resize(NonzeroLength + 1);
673  }
674 
675  auto *FillerType =
676  CommonElementType
677  ? CommonElementType
678  : CGM.getTypes().ConvertType(DestType->getElementType());
679  FillerType = llvm::ArrayType::get(FillerType, TrailingZeroes);
680  Elements.back() = llvm::ConstantAggregateZero::get(FillerType);
681  CommonElementType = nullptr;
682  } else if (Elements.size() != ArrayBound) {
683  // Otherwise pad to the right size with the filler if necessary.
684  Elements.resize(ArrayBound, Filler);
685  if (Filler->getType() != CommonElementType)
686  CommonElementType = nullptr;
687  }
688 
689  // If all elements have the same type, just emit an array constant.
690  if (CommonElementType)
691  return llvm::ConstantArray::get(
692  llvm::ArrayType::get(CommonElementType, ArrayBound), Elements);
693 
694  // We have mixed types. Use a packed struct.
696  Types.reserve(Elements.size());
697  for (llvm::Constant *Elt : Elements)
698  Types.push_back(Elt->getType());
699  llvm::StructType *SType =
700  llvm::StructType::get(CGM.getLLVMContext(), Types, true);
701  return llvm::ConstantStruct::get(SType, Elements);
702 }
703 
704 /// This class only needs to handle two cases:
705 /// 1) Literals (this is used by APValue emission to emit literals).
706 /// 2) Arrays, structs and unions (outside C++11 mode, we don't currently
707 /// constant fold these types).
708 class ConstExprEmitter :
709  public StmtVisitor<ConstExprEmitter, llvm::Constant*, QualType> {
710  CodeGenModule &CGM;
711  ConstantEmitter &Emitter;
712  llvm::LLVMContext &VMContext;
713 public:
714  ConstExprEmitter(ConstantEmitter &emitter)
715  : CGM(emitter.CGM), Emitter(emitter), VMContext(CGM.getLLVMContext()) {
716  }
717 
718  //===--------------------------------------------------------------------===//
719  // Visitor Methods
720  //===--------------------------------------------------------------------===//
721 
722  llvm::Constant *VisitStmt(Stmt *S, QualType T) {
723  return nullptr;
724  }
725 
726  llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) {
727  return Visit(PE->getSubExpr(), T);
728  }
729 
730  llvm::Constant *
731  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE,
732  QualType T) {
733  return Visit(PE->getReplacement(), T);
734  }
735 
736  llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE,
737  QualType T) {
738  return Visit(GE->getResultExpr(), T);
739  }
740 
741  llvm::Constant *VisitChooseExpr(ChooseExpr *CE, QualType T) {
742  return Visit(CE->getChosenSubExpr(), T);
743  }
744 
745  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E, QualType T) {
746  return Visit(E->getInitializer(), T);
747  }
748 
749  llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
750  if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
751  CGM.EmitExplicitCastExprType(ECE, Emitter.CGF);
752  Expr *subExpr = E->getSubExpr();
753 
754  switch (E->getCastKind()) {
755  case CK_ToUnion: {
756  // GCC cast to union extension
757  assert(E->getType()->isUnionType() &&
758  "Destination type is not union type!");
759 
760  auto field = E->getTargetUnionField();
761 
762  auto C = Emitter.tryEmitPrivateForMemory(subExpr, field->getType());
763  if (!C) return nullptr;
764 
765  auto destTy = ConvertType(destType);
766  if (C->getType() == destTy) return C;
767 
768  // Build a struct with the union sub-element as the first member,
769  // and padded to the appropriate size.
772  Elts.push_back(C);
773  Types.push_back(C->getType());
774  unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType());
775  unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destTy);
776 
777  assert(CurSize <= TotalSize && "Union size mismatch!");
778  if (unsigned NumPadBytes = TotalSize - CurSize) {
779  llvm::Type *Ty = CGM.Int8Ty;
780  if (NumPadBytes > 1)
781  Ty = llvm::ArrayType::get(Ty, NumPadBytes);
782 
783  Elts.push_back(llvm::UndefValue::get(Ty));
784  Types.push_back(Ty);
785  }
786 
787  llvm::StructType *STy = llvm::StructType::get(VMContext, Types, false);
788  return llvm::ConstantStruct::get(STy, Elts);
789  }
790 
791  case CK_AddressSpaceConversion: {
792  auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType());
793  if (!C) return nullptr;
794  LangAS destAS = E->getType()->getPointeeType().getAddressSpace();
795  LangAS srcAS = subExpr->getType()->getPointeeType().getAddressSpace();
796  llvm::Type *destTy = ConvertType(E->getType());
797  return CGM.getTargetCodeGenInfo().performAddrSpaceCast(CGM, C, srcAS,
798  destAS, destTy);
799  }
800 
801  case CK_LValueToRValue:
802  case CK_AtomicToNonAtomic:
803  case CK_NonAtomicToAtomic:
804  case CK_NoOp:
805  case CK_ConstructorConversion:
806  return Visit(subExpr, destType);
807 
808  case CK_IntToOCLSampler:
809  llvm_unreachable("global sampler variables are not generated");
810 
811  case CK_Dependent: llvm_unreachable("saw dependent cast!");
812 
813  case CK_BuiltinFnToFnPtr:
814  llvm_unreachable("builtin functions are handled elsewhere");
815 
816  case CK_ReinterpretMemberPointer:
817  case CK_DerivedToBaseMemberPointer:
818  case CK_BaseToDerivedMemberPointer: {
819  auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType());
820  if (!C) return nullptr;
821  return CGM.getCXXABI().EmitMemberPointerConversion(E, C);
822  }
823 
824  // These will never be supported.
825  case CK_ObjCObjectLValueCast:
826  case CK_ARCProduceObject:
827  case CK_ARCConsumeObject:
828  case CK_ARCReclaimReturnedObject:
829  case CK_ARCExtendBlockObject:
830  case CK_CopyAndAutoreleaseBlockObject:
831  return nullptr;
832 
833  // These don't need to be handled here because Evaluate knows how to
834  // evaluate them in the cases where they can be folded.
835  case CK_BitCast:
836  case CK_ToVoid:
837  case CK_Dynamic:
838  case CK_LValueBitCast:
839  case CK_NullToMemberPointer:
840  case CK_UserDefinedConversion:
841  case CK_CPointerToObjCPointerCast:
842  case CK_BlockPointerToObjCPointerCast:
843  case CK_AnyPointerToBlockPointerCast:
844  case CK_ArrayToPointerDecay:
845  case CK_FunctionToPointerDecay:
846  case CK_BaseToDerived:
847  case CK_DerivedToBase:
848  case CK_UncheckedDerivedToBase:
849  case CK_MemberPointerToBoolean:
850  case CK_VectorSplat:
851  case CK_FloatingRealToComplex:
852  case CK_FloatingComplexToReal:
853  case CK_FloatingComplexToBoolean:
854  case CK_FloatingComplexCast:
855  case CK_FloatingComplexToIntegralComplex:
856  case CK_IntegralRealToComplex:
857  case CK_IntegralComplexToReal:
858  case CK_IntegralComplexToBoolean:
859  case CK_IntegralComplexCast:
860  case CK_IntegralComplexToFloatingComplex:
861  case CK_PointerToIntegral:
862  case CK_PointerToBoolean:
863  case CK_NullToPointer:
864  case CK_IntegralCast:
865  case CK_BooleanToSignedIntegral:
866  case CK_IntegralToPointer:
867  case CK_IntegralToBoolean:
868  case CK_IntegralToFloating:
869  case CK_FloatingToIntegral:
870  case CK_FloatingToBoolean:
871  case CK_FloatingCast:
872  case CK_ZeroToOCLEvent:
873  case CK_ZeroToOCLQueue:
874  return nullptr;
875  }
876  llvm_unreachable("Invalid CastKind");
877  }
878 
879  llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE, QualType T) {
880  return Visit(DAE->getExpr(), T);
881  }
882 
883  llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) {
884  // No need for a DefaultInitExprScope: we don't handle 'this' in a
885  // constant expression.
886  return Visit(DIE->getExpr(), T);
887  }
888 
889  llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E, QualType T) {
890  if (!E->cleanupsHaveSideEffects())
891  return Visit(E->getSubExpr(), T);
892  return nullptr;
893  }
894 
895  llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E,
896  QualType T) {
897  return Visit(E->GetTemporaryExpr(), T);
898  }
899 
900  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) {
901  auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType());
902  assert(CAT && "can't emit array init for non-constant-bound array");
903  unsigned NumInitElements = ILE->getNumInits();
904  unsigned NumElements = CAT->getSize().getZExtValue();
905 
906  // Initialising an array requires us to automatically
907  // initialise any elements that have not been initialised explicitly
908  unsigned NumInitableElts = std::min(NumInitElements, NumElements);
909 
910  QualType EltType = CAT->getElementType();
911 
912  // Initialize remaining array elements.
913  llvm::Constant *fillC = nullptr;
914  if (Expr *filler = ILE->getArrayFiller()) {
915  fillC = Emitter.tryEmitAbstractForMemory(filler, EltType);
916  if (!fillC)
917  return nullptr;
918  }
919 
920  // Copy initializer elements.
922  if (fillC && fillC->isNullValue())
923  Elts.reserve(NumInitableElts + 1);
924  else
925  Elts.reserve(NumElements);
926 
927  llvm::Type *CommonElementType = nullptr;
928  for (unsigned i = 0; i < NumInitableElts; ++i) {
929  Expr *Init = ILE->getInit(i);
930  llvm::Constant *C = Emitter.tryEmitPrivateForMemory(Init, EltType);
931  if (!C)
932  return nullptr;
933  if (i == 0)
934  CommonElementType = C->getType();
935  else if (C->getType() != CommonElementType)
936  CommonElementType = nullptr;
937  Elts.push_back(C);
938  }
939 
940  return EmitArrayConstant(CGM, CAT, CommonElementType, NumElements, Elts,
941  fillC);
942  }
943 
944  llvm::Constant *EmitRecordInitialization(InitListExpr *ILE, QualType T) {
945  return ConstStructBuilder::BuildStruct(Emitter, ILE, T);
946  }
947 
948  llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E,
949  QualType T) {
950  return CGM.EmitNullConstant(T);
951  }
952 
953  llvm::Constant *VisitInitListExpr(InitListExpr *ILE, QualType T) {
954  if (ILE->isTransparent())
955  return Visit(ILE->getInit(0), T);
956 
957  if (ILE->getType()->isArrayType())
958  return EmitArrayInitialization(ILE, T);
959 
960  if (ILE->getType()->isRecordType())
961  return EmitRecordInitialization(ILE, T);
962 
963  return nullptr;
964  }
965 
966  llvm::Constant *EmitDesignatedInitUpdater(llvm::Constant *Base,
967  InitListExpr *Updater,
968  QualType destType) {
969  if (auto destAT = CGM.getContext().getAsArrayType(destType)) {
970  llvm::ArrayType *AType = cast<llvm::ArrayType>(ConvertType(destType));
971  llvm::Type *ElemType = AType->getElementType();
972 
973  unsigned NumInitElements = Updater->getNumInits();
974  unsigned NumElements = AType->getNumElements();
975 
976  std::vector<llvm::Constant *> Elts;
977  Elts.reserve(NumElements);
978 
979  QualType destElemType = destAT->getElementType();
980 
981  if (auto DataArray = dyn_cast<llvm::ConstantDataArray>(Base))
982  for (unsigned i = 0; i != NumElements; ++i)
983  Elts.push_back(DataArray->getElementAsConstant(i));
984  else if (auto Array = dyn_cast<llvm::ConstantArray>(Base))
985  for (unsigned i = 0; i != NumElements; ++i)
986  Elts.push_back(Array->getOperand(i));
987  else
988  return nullptr; // FIXME: other array types not implemented
989 
990  llvm::Constant *fillC = nullptr;
991  if (Expr *filler = Updater->getArrayFiller())
992  if (!isa<NoInitExpr>(filler))
993  fillC = Emitter.tryEmitAbstractForMemory(filler, destElemType);
994  bool RewriteType = (fillC && fillC->getType() != ElemType);
995 
996  for (unsigned i = 0; i != NumElements; ++i) {
997  Expr *Init = nullptr;
998  if (i < NumInitElements)
999  Init = Updater->getInit(i);
1000 
1001  if (!Init && fillC)
1002  Elts[i] = fillC;
1003  else if (!Init || isa<NoInitExpr>(Init))
1004  ; // Do nothing.
1005  else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init))
1006  Elts[i] = EmitDesignatedInitUpdater(Elts[i], ChildILE, destElemType);
1007  else
1008  Elts[i] = Emitter.tryEmitPrivateForMemory(Init, destElemType);
1009 
1010  if (!Elts[i])
1011  return nullptr;
1012  RewriteType |= (Elts[i]->getType() != ElemType);
1013  }
1014 
1015  if (RewriteType) {
1016  std::vector<llvm::Type *> Types;
1017  Types.reserve(NumElements);
1018  for (unsigned i = 0; i != NumElements; ++i)
1019  Types.push_back(Elts[i]->getType());
1020  llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
1021  Types, true);
1022  return llvm::ConstantStruct::get(SType, Elts);
1023  }
1024 
1025  return llvm::ConstantArray::get(AType, Elts);
1026  }
1027 
1028  if (destType->isRecordType())
1029  return ConstStructBuilder::BuildStruct(Emitter, this,
1030  dyn_cast<llvm::ConstantStruct>(Base), Updater, destType);
1031 
1032  return nullptr;
1033  }
1034 
1035  llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E,
1036  QualType destType) {
1037  auto C = Visit(E->getBase(), destType);
1038  if (!C) return nullptr;
1039  return EmitDesignatedInitUpdater(C, E->getUpdater(), destType);
1040  }
1041 
1042  llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E, QualType Ty) {
1043  if (!E->getConstructor()->isTrivial())
1044  return nullptr;
1045 
1046  // FIXME: We should not have to call getBaseElementType here.
1047  const RecordType *RT =
1049  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1050 
1051  // If the class doesn't have a trivial destructor, we can't emit it as a
1052  // constant expr.
1053  if (!RD->hasTrivialDestructor())
1054  return nullptr;
1055 
1056  // Only copy and default constructors can be trivial.
1057 
1058 
1059  if (E->getNumArgs()) {
1060  assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
1061  assert(E->getConstructor()->isCopyOrMoveConstructor() &&
1062  "trivial ctor has argument but isn't a copy/move ctor");
1063 
1064  Expr *Arg = E->getArg(0);
1065  assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
1066  "argument to copy ctor is of wrong type");
1067 
1068  return Visit(Arg, Ty);
1069  }
1070 
1071  return CGM.EmitNullConstant(Ty);
1072  }
1073 
1074  llvm::Constant *VisitStringLiteral(StringLiteral *E, QualType T) {
1075  return CGM.GetConstantArrayFromStringLiteral(E);
1076  }
1077 
1078  llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E, QualType T) {
1079  // This must be an @encode initializing an array in a static initializer.
1080  // Don't emit it as the address of the string, emit the string data itself
1081  // as an inline array.
1082  std::string Str;
1084  const ConstantArrayType *CAT = CGM.getContext().getAsConstantArrayType(T);
1085 
1086  // Resize the string to the right size, adding zeros at the end, or
1087  // truncating as needed.
1088  Str.resize(CAT->getSize().getZExtValue(), '\0');
1089  return llvm::ConstantDataArray::getString(VMContext, Str, false);
1090  }
1091 
1092  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E, QualType T) {
1093  return Visit(E->getSubExpr(), T);
1094  }
1095 
1096  // Utility methods
1097  llvm::Type *ConvertType(QualType T) {
1098  return CGM.getTypes().ConvertType(T);
1099  }
1100 };
1101 
1102 } // end anonymous namespace.
1103 
1104 bool ConstStructBuilder::Build(ConstExprEmitter *ExprEmitter,
1105  llvm::ConstantStruct *Base,
1106  InitListExpr *Updater) {
1107  assert(Base && "base expression should not be empty");
1108 
1109  QualType ExprType = Updater->getType();
1110  RecordDecl *RD = ExprType->getAs<RecordType>()->getDecl();
1111  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1112  const llvm::StructLayout *BaseLayout = CGM.getDataLayout().getStructLayout(
1113  Base->getType());
1114  unsigned FieldNo = -1;
1115  unsigned ElementNo = 0;
1116 
1117  // Bail out if we have base classes. We could support these, but they only
1118  // arise in C++1z where we will have already constant folded most interesting
1119  // cases. FIXME: There are still a few more cases we can handle this way.
1120  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1121  if (CXXRD->getNumBases())
1122  return false;
1123 
1124  for (FieldDecl *Field : RD->fields()) {
1125  ++FieldNo;
1126 
1127  if (RD->isUnion() && Updater->getInitializedFieldInUnion() != Field)
1128  continue;
1129 
1130  // Skip anonymous bitfields.
1131  if (Field->isUnnamedBitfield())
1132  continue;
1133 
1134  llvm::Constant *EltInit = Base->getOperand(ElementNo);
1135 
1136  // Bail out if the type of the ConstantStruct does not have the same layout
1137  // as the type of the InitListExpr.
1138  if (CGM.getTypes().ConvertType(Field->getType()) != EltInit->getType() ||
1139  Layout.getFieldOffset(ElementNo) !=
1140  BaseLayout->getElementOffsetInBits(ElementNo))
1141  return false;
1142 
1143  // Get the initializer. If we encounter an empty field or a NoInitExpr,
1144  // we use values from the base expression.
1145  Expr *Init = nullptr;
1146  if (ElementNo < Updater->getNumInits())
1147  Init = Updater->getInit(ElementNo);
1148 
1149  if (!Init || isa<NoInitExpr>(Init))
1150  ; // Do nothing.
1151  else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init))
1152  EltInit = ExprEmitter->EmitDesignatedInitUpdater(EltInit, ChildILE,
1153  Field->getType());
1154  else
1155  EltInit = Emitter.tryEmitPrivateForMemory(Init, Field->getType());
1156 
1157  ++ElementNo;
1158 
1159  if (!EltInit)
1160  return false;
1161 
1162  if (!Field->isBitField())
1163  AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit);
1164  else if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(EltInit))
1165  AppendBitField(Field, Layout.getFieldOffset(FieldNo), CI);
1166  else
1167  // Initializing a bitfield with a non-trivial constant?
1168  return false;
1169  }
1170 
1171  return true;
1172 }
1173 
1174 llvm::Constant *ConstantEmitter::validateAndPopAbstract(llvm::Constant *C,
1175  AbstractState saved) {
1176  Abstract = saved.OldValue;
1177 
1178  assert(saved.OldPlaceholdersSize == PlaceholderAddresses.size() &&
1179  "created a placeholder while doing an abstract emission?");
1180 
1181  // No validation necessary for now.
1182  // No cleanup to do for now.
1183  return C;
1184 }
1185 
1186 llvm::Constant *
1188  auto state = pushAbstract();
1189  auto C = tryEmitPrivateForVarInit(D);
1190  return validateAndPopAbstract(C, state);
1191 }
1192 
1193 llvm::Constant *
1195  auto state = pushAbstract();
1196  auto C = tryEmitPrivate(E, destType);
1197  return validateAndPopAbstract(C, state);
1198 }
1199 
1200 llvm::Constant *
1202  auto state = pushAbstract();
1203  auto C = tryEmitPrivate(value, destType);
1204  return validateAndPopAbstract(C, state);
1205 }
1206 
1207 llvm::Constant *
1209  auto state = pushAbstract();
1210  auto C = tryEmitPrivate(E, destType);
1211  C = validateAndPopAbstract(C, state);
1212  if (!C) {
1213  CGM.Error(E->getExprLoc(),
1214  "internal error: could not emit constant value \"abstractly\"");
1215  C = CGM.EmitNullConstant(destType);
1216  }
1217  return C;
1218 }
1219 
1220 llvm::Constant *
1222  QualType destType) {
1223  auto state = pushAbstract();
1224  auto C = tryEmitPrivate(value, destType);
1225  C = validateAndPopAbstract(C, state);
1226  if (!C) {
1227  CGM.Error(loc,
1228  "internal error: could not emit constant value \"abstractly\"");
1229  C = CGM.EmitNullConstant(destType);
1230  }
1231  return C;
1232 }
1233 
1235  initializeNonAbstract(D.getType().getAddressSpace());
1236  return markIfFailed(tryEmitPrivateForVarInit(D));
1237 }
1238 
1240  LangAS destAddrSpace,
1241  QualType destType) {
1242  initializeNonAbstract(destAddrSpace);
1243  return markIfFailed(tryEmitPrivateForMemory(E, destType));
1244 }
1245 
1246 llvm::Constant *ConstantEmitter::emitForInitializer(const APValue &value,
1247  LangAS destAddrSpace,
1248  QualType destType) {
1249  initializeNonAbstract(destAddrSpace);
1250  auto C = tryEmitPrivateForMemory(value, destType);
1251  assert(C && "couldn't emit constant value non-abstractly?");
1252  return C;
1253 }
1254 
1256  assert(!Abstract && "cannot get current address for abstract constant");
1257 
1258 
1259 
1260  // Make an obviously ill-formed global that should blow up compilation
1261  // if it survives.
1262  auto global = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty, true,
1263  llvm::GlobalValue::PrivateLinkage,
1264  /*init*/ nullptr,
1265  /*name*/ "",
1266  /*before*/ nullptr,
1267  llvm::GlobalVariable::NotThreadLocal,
1268  CGM.getContext().getTargetAddressSpace(DestAddressSpace));
1269 
1270  PlaceholderAddresses.push_back(std::make_pair(nullptr, global));
1271 
1272  return global;
1273 }
1274 
1276  llvm::GlobalValue *placeholder) {
1277  assert(!PlaceholderAddresses.empty());
1278  assert(PlaceholderAddresses.back().first == nullptr);
1279  assert(PlaceholderAddresses.back().second == placeholder);
1280  PlaceholderAddresses.back().first = signal;
1281 }
1282 
1283 namespace {
1284  struct ReplacePlaceholders {
1285  CodeGenModule &CGM;
1286 
1287  /// The base address of the global.
1288  llvm::Constant *Base;
1289  llvm::Type *BaseValueTy = nullptr;
1290 
1291  /// The placeholder addresses that were registered during emission.
1292  llvm::DenseMap<llvm::Constant*, llvm::GlobalVariable*> PlaceholderAddresses;
1293 
1294  /// The locations of the placeholder signals.
1295  llvm::DenseMap<llvm::GlobalVariable*, llvm::Constant*> Locations;
1296 
1297  /// The current index stack. We use a simple unsigned stack because
1298  /// we assume that placeholders will be relatively sparse in the
1299  /// initializer, but we cache the index values we find just in case.
1302 
1303  ReplacePlaceholders(CodeGenModule &CGM, llvm::Constant *base,
1304  ArrayRef<std::pair<llvm::Constant*,
1305  llvm::GlobalVariable*>> addresses)
1306  : CGM(CGM), Base(base),
1307  PlaceholderAddresses(addresses.begin(), addresses.end()) {
1308  }
1309 
1310  void replaceInInitializer(llvm::Constant *init) {
1311  // Remember the type of the top-most initializer.
1312  BaseValueTy = init->getType();
1313 
1314  // Initialize the stack.
1315  Indices.push_back(0);
1316  IndexValues.push_back(nullptr);
1317 
1318  // Recurse into the initializer.
1319  findLocations(init);
1320 
1321  // Check invariants.
1322  assert(IndexValues.size() == Indices.size() && "mismatch");
1323  assert(Indices.size() == 1 && "didn't pop all indices");
1324 
1325  // Do the replacement; this basically invalidates 'init'.
1326  assert(Locations.size() == PlaceholderAddresses.size() &&
1327  "missed a placeholder?");
1328 
1329  // We're iterating over a hashtable, so this would be a source of
1330  // non-determinism in compiler output *except* that we're just
1331  // messing around with llvm::Constant structures, which never itself
1332  // does anything that should be visible in compiler output.
1333  for (auto &entry : Locations) {
1334  assert(entry.first->getParent() == nullptr && "not a placeholder!");
1335  entry.first->replaceAllUsesWith(entry.second);
1336  entry.first->eraseFromParent();
1337  }
1338  }
1339 
1340  private:
1341  void findLocations(llvm::Constant *init) {
1342  // Recurse into aggregates.
1343  if (auto agg = dyn_cast<llvm::ConstantAggregate>(init)) {
1344  for (unsigned i = 0, e = agg->getNumOperands(); i != e; ++i) {
1345  Indices.push_back(i);
1346  IndexValues.push_back(nullptr);
1347 
1348  findLocations(agg->getOperand(i));
1349 
1350  IndexValues.pop_back();
1351  Indices.pop_back();
1352  }
1353  return;
1354  }
1355 
1356  // Otherwise, check for registered constants.
1357  while (true) {
1358  auto it = PlaceholderAddresses.find(init);
1359  if (it != PlaceholderAddresses.end()) {
1360  setLocation(it->second);
1361  break;
1362  }
1363 
1364  // Look through bitcasts or other expressions.
1365  if (auto expr = dyn_cast<llvm::ConstantExpr>(init)) {
1366  init = expr->getOperand(0);
1367  } else {
1368  break;
1369  }
1370  }
1371  }
1372 
1373  void setLocation(llvm::GlobalVariable *placeholder) {
1374  assert(Locations.find(placeholder) == Locations.end() &&
1375  "already found location for placeholder!");
1376 
1377  // Lazily fill in IndexValues with the values from Indices.
1378  // We do this in reverse because we should always have a strict
1379  // prefix of indices from the start.
1380  assert(Indices.size() == IndexValues.size());
1381  for (size_t i = Indices.size() - 1; i != size_t(-1); --i) {
1382  if (IndexValues[i]) {
1383 #ifndef NDEBUG
1384  for (size_t j = 0; j != i + 1; ++j) {
1385  assert(IndexValues[j] &&
1386  isa<llvm::ConstantInt>(IndexValues[j]) &&
1387  cast<llvm::ConstantInt>(IndexValues[j])->getZExtValue()
1388  == Indices[j]);
1389  }
1390 #endif
1391  break;
1392  }
1393 
1394  IndexValues[i] = llvm::ConstantInt::get(CGM.Int32Ty, Indices[i]);
1395  }
1396 
1397  // Form a GEP and then bitcast to the placeholder type so that the
1398  // replacement will succeed.
1399  llvm::Constant *location =
1400  llvm::ConstantExpr::getInBoundsGetElementPtr(BaseValueTy,
1401  Base, IndexValues);
1402  location = llvm::ConstantExpr::getBitCast(location,
1403  placeholder->getType());
1404 
1405  Locations.insert({placeholder, location});
1406  }
1407  };
1408 }
1409 
1410 void ConstantEmitter::finalize(llvm::GlobalVariable *global) {
1411  assert(InitializedNonAbstract &&
1412  "finalizing emitter that was used for abstract emission?");
1413  assert(!Finalized && "finalizing emitter multiple times");
1414  assert(global->getInitializer());
1415 
1416  // Note that we might also be Failed.
1417  Finalized = true;
1418 
1419  if (!PlaceholderAddresses.empty()) {
1420  ReplacePlaceholders(CGM, global, PlaceholderAddresses)
1421  .replaceInInitializer(global->getInitializer());
1422  PlaceholderAddresses.clear(); // satisfy
1423  }
1424 }
1425 
1427  assert((!InitializedNonAbstract || Finalized || Failed) &&
1428  "not finalized after being initialized for non-abstract emission");
1429  assert(PlaceholderAddresses.empty() && "unhandled placeholders");
1430 }
1431 
1433  if (auto AT = type->getAs<AtomicType>()) {
1434  return CGM.getContext().getQualifiedType(AT->getValueType(),
1435  type.getQualifiers());
1436  }
1437  return type;
1438 }
1439 
1441  // Make a quick check if variable can be default NULL initialized
1442  // and avoid going through rest of code which may do, for c++11,
1443  // initialization of memory to all NULLs.
1444  if (!D.hasLocalStorage()) {
1446  if (Ty->isRecordType())
1447  if (const CXXConstructExpr *E =
1448  dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
1449  const CXXConstructorDecl *CD = E->getConstructor();
1450  if (CD->isTrivial() && CD->isDefaultConstructor())
1451  return CGM.EmitNullConstant(D.getType());
1452  }
1453  }
1454 
1455  QualType destType = D.getType();
1456 
1457  // Try to emit the initializer. Note that this can allow some things that
1458  // are not allowed by tryEmitPrivateForMemory alone.
1459  if (auto value = D.evaluateValue()) {
1460  return tryEmitPrivateForMemory(*value, destType);
1461  }
1462 
1463  // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
1464  // reference is a constant expression, and the reference binds to a temporary,
1465  // then constant initialization is performed. ConstExprEmitter will
1466  // incorrectly emit a prvalue constant in this case, and the calling code
1467  // interprets that as the (pointer) value of the reference, rather than the
1468  // desired value of the referee.
1469  if (destType->isReferenceType())
1470  return nullptr;
1471 
1472  const Expr *E = D.getInit();
1473  assert(E && "No initializer to emit");
1474 
1475  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1476  auto C =
1477  ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), nonMemoryDestType);
1478  return (C ? emitForMemory(C, destType) : nullptr);
1479 }
1480 
1481 llvm::Constant *
1483  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1484  auto C = tryEmitAbstract(E, nonMemoryDestType);
1485  return (C ? emitForMemory(C, destType) : nullptr);
1486 }
1487 
1488 llvm::Constant *
1490  QualType destType) {
1491  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1492  auto C = tryEmitAbstract(value, nonMemoryDestType);
1493  return (C ? emitForMemory(C, destType) : nullptr);
1494 }
1495 
1497  QualType destType) {
1498  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1499  llvm::Constant *C = tryEmitPrivate(E, nonMemoryDestType);
1500  return (C ? emitForMemory(C, destType) : nullptr);
1501 }
1502 
1504  QualType destType) {
1505  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
1506  auto C = tryEmitPrivate(value, nonMemoryDestType);
1507  return (C ? emitForMemory(C, destType) : nullptr);
1508 }
1509 
1511  llvm::Constant *C,
1512  QualType destType) {
1513  // For an _Atomic-qualified constant, we may need to add tail padding.
1514  if (auto AT = destType->getAs<AtomicType>()) {
1515  QualType destValueType = AT->getValueType();
1516  C = emitForMemory(CGM, C, destValueType);
1517 
1518  uint64_t innerSize = CGM.getContext().getTypeSize(destValueType);
1519  uint64_t outerSize = CGM.getContext().getTypeSize(destType);
1520  if (innerSize == outerSize)
1521  return C;
1522 
1523  assert(innerSize < outerSize && "emitted over-large constant for atomic");
1524  llvm::Constant *elts[] = {
1525  C,
1526  llvm::ConstantAggregateZero::get(
1527  llvm::ArrayType::get(CGM.Int8Ty, (outerSize - innerSize) / 8))
1528  };
1529  return llvm::ConstantStruct::getAnon(elts);
1530  }
1531 
1532  // Zero-extend bool.
1533  if (C->getType()->isIntegerTy(1)) {
1534  llvm::Type *boolTy = CGM.getTypes().ConvertTypeForMem(destType);
1535  return llvm::ConstantExpr::getZExt(C, boolTy);
1536  }
1537 
1538  return C;
1539 }
1540 
1541 llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E,
1542  QualType destType) {
1543  Expr::EvalResult Result;
1544 
1545  bool Success = false;
1546 
1547  if (destType->isReferenceType())
1548  Success = E->EvaluateAsLValue(Result, CGM.getContext());
1549  else
1550  Success = E->EvaluateAsRValue(Result, CGM.getContext());
1551 
1552  llvm::Constant *C;
1553  if (Success && !Result.HasSideEffects)
1554  C = tryEmitPrivate(Result.Val, destType);
1555  else
1556  C = ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), destType);
1557 
1558  return C;
1559 }
1560 
1561 llvm::Constant *CodeGenModule::getNullPointer(llvm::PointerType *T, QualType QT) {
1562  return getTargetCodeGenInfo().getNullPointer(*this, T, QT);
1563 }
1564 
1565 namespace {
1566 /// A struct which can be used to peephole certain kinds of finalization
1567 /// that normally happen during l-value emission.
1568 struct ConstantLValue {
1569  llvm::Constant *Value;
1570  bool HasOffsetApplied;
1571 
1572  /*implicit*/ ConstantLValue(llvm::Constant *value,
1573  bool hasOffsetApplied = false)
1574  : Value(value), HasOffsetApplied(false) {}
1575 
1576  /*implicit*/ ConstantLValue(ConstantAddress address)
1577  : ConstantLValue(address.getPointer()) {}
1578 };
1579 
1580 /// A helper class for emitting constant l-values.
1581 class ConstantLValueEmitter : public ConstStmtVisitor<ConstantLValueEmitter,
1582  ConstantLValue> {
1583  CodeGenModule &CGM;
1584  ConstantEmitter &Emitter;
1585  const APValue &Value;
1586  QualType DestType;
1587 
1588  // Befriend StmtVisitorBase so that we don't have to expose Visit*.
1589  friend StmtVisitorBase;
1590 
1591 public:
1592  ConstantLValueEmitter(ConstantEmitter &emitter, const APValue &value,
1593  QualType destType)
1594  : CGM(emitter.CGM), Emitter(emitter), Value(value), DestType(destType) {}
1595 
1596  llvm::Constant *tryEmit();
1597 
1598 private:
1599  llvm::Constant *tryEmitAbsolute(llvm::Type *destTy);
1600  ConstantLValue tryEmitBase(const APValue::LValueBase &base);
1601 
1602  ConstantLValue VisitStmt(const Stmt *S) { return nullptr; }
1603  ConstantLValue VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
1604  ConstantLValue VisitStringLiteral(const StringLiteral *E);
1605  ConstantLValue VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
1606  ConstantLValue VisitObjCStringLiteral(const ObjCStringLiteral *E);
1607  ConstantLValue VisitPredefinedExpr(const PredefinedExpr *E);
1608  ConstantLValue VisitAddrLabelExpr(const AddrLabelExpr *E);
1609  ConstantLValue VisitCallExpr(const CallExpr *E);
1610  ConstantLValue VisitBlockExpr(const BlockExpr *E);
1611  ConstantLValue VisitCXXTypeidExpr(const CXXTypeidExpr *E);
1612  ConstantLValue VisitCXXUuidofExpr(const CXXUuidofExpr *E);
1613  ConstantLValue VisitMaterializeTemporaryExpr(
1614  const MaterializeTemporaryExpr *E);
1615 
1616  bool hasNonZeroOffset() const {
1617  return !Value.getLValueOffset().isZero();
1618  }
1619 
1620  /// Return the value offset.
1621  llvm::Constant *getOffset() {
1622  return llvm::ConstantInt::get(CGM.Int64Ty,
1623  Value.getLValueOffset().getQuantity());
1624  }
1625 
1626  /// Apply the value offset to the given constant.
1627  llvm::Constant *applyOffset(llvm::Constant *C) {
1628  if (!hasNonZeroOffset())
1629  return C;
1630 
1631  llvm::Type *origPtrTy = C->getType();
1632  unsigned AS = origPtrTy->getPointerAddressSpace();
1633  llvm::Type *charPtrTy = CGM.Int8Ty->getPointerTo(AS);
1634  C = llvm::ConstantExpr::getBitCast(C, charPtrTy);
1635  C = llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, C, getOffset());
1636  C = llvm::ConstantExpr::getPointerCast(C, origPtrTy);
1637  return C;
1638  }
1639 };
1640 
1641 }
1642 
1643 llvm::Constant *ConstantLValueEmitter::tryEmit() {
1644  const APValue::LValueBase &base = Value.getLValueBase();
1645 
1646  // Certain special array initializers are represented in APValue
1647  // as l-values referring to the base expression which generates the
1648  // array. This happens with e.g. string literals. These should
1649  // probably just get their own representation kind in APValue.
1650  if (DestType->isArrayType()) {
1651  assert(!hasNonZeroOffset() && "offset on array initializer");
1652  auto expr = const_cast<Expr*>(base.get<const Expr*>());
1653  return ConstExprEmitter(Emitter).Visit(expr, DestType);
1654  }
1655 
1656  // Otherwise, the destination type should be a pointer or reference
1657  // type, but it might also be a cast thereof.
1658  //
1659  // FIXME: the chain of casts required should be reflected in the APValue.
1660  // We need this in order to correctly handle things like a ptrtoint of a
1661  // non-zero null pointer and addrspace casts that aren't trivially
1662  // represented in LLVM IR.
1663  auto destTy = CGM.getTypes().ConvertTypeForMem(DestType);
1664  assert(isa<llvm::IntegerType>(destTy) || isa<llvm::PointerType>(destTy));
1665 
1666  // If there's no base at all, this is a null or absolute pointer,
1667  // possibly cast back to an integer type.
1668  if (!base) {
1669  return tryEmitAbsolute(destTy);
1670  }
1671 
1672  // Otherwise, try to emit the base.
1673  ConstantLValue result = tryEmitBase(base);
1674 
1675  // If that failed, we're done.
1676  llvm::Constant *value = result.Value;
1677  if (!value) return nullptr;
1678 
1679  // Apply the offset if necessary and not already done.
1680  if (!result.HasOffsetApplied) {
1681  value = applyOffset(value);
1682  }
1683 
1684  // Convert to the appropriate type; this could be an lvalue for
1685  // an integer. FIXME: performAddrSpaceCast
1686  if (isa<llvm::PointerType>(destTy))
1687  return llvm::ConstantExpr::getPointerCast(value, destTy);
1688 
1689  return llvm::ConstantExpr::getPtrToInt(value, destTy);
1690 }
1691 
1692 /// Try to emit an absolute l-value, such as a null pointer or an integer
1693 /// bitcast to pointer type.
1694 llvm::Constant *
1695 ConstantLValueEmitter::tryEmitAbsolute(llvm::Type *destTy) {
1696  auto offset = getOffset();
1697 
1698  // If we're producing a pointer, this is easy.
1699  if (auto destPtrTy = cast<llvm::PointerType>(destTy)) {
1700  if (Value.isNullPointer()) {
1701  // FIXME: integer offsets from non-zero null pointers.
1702  return CGM.getNullPointer(destPtrTy, DestType);
1703  }
1704 
1705  // Convert the integer to a pointer-sized integer before converting it
1706  // to a pointer.
1707  // FIXME: signedness depends on the original integer type.
1708  auto intptrTy = CGM.getDataLayout().getIntPtrType(destPtrTy);
1709  llvm::Constant *C = offset;
1710  C = llvm::ConstantExpr::getIntegerCast(getOffset(), intptrTy,
1711  /*isSigned*/ false);
1712  C = llvm::ConstantExpr::getIntToPtr(C, destPtrTy);
1713  return C;
1714  }
1715 
1716  // Otherwise, we're basically returning an integer constant.
1717 
1718  // FIXME: this does the wrong thing with ptrtoint of a null pointer,
1719  // but since we don't know the original pointer type, there's not much
1720  // we can do about it.
1721 
1722  auto C = getOffset();
1723  C = llvm::ConstantExpr::getIntegerCast(C, destTy, /*isSigned*/ false);
1724  return C;
1725 }
1726 
1727 ConstantLValue
1728 ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
1729  // Handle values.
1730  if (const ValueDecl *D = base.dyn_cast<const ValueDecl*>()) {
1731  if (D->hasAttr<WeakRefAttr>())
1732  return CGM.GetWeakRefReference(D).getPointer();
1733 
1734  if (auto FD = dyn_cast<FunctionDecl>(D))
1735  return CGM.GetAddrOfFunction(FD);
1736 
1737  if (auto VD = dyn_cast<VarDecl>(D)) {
1738  // We can never refer to a variable with local storage.
1739  if (!VD->hasLocalStorage()) {
1740  if (VD->isFileVarDecl() || VD->hasExternalStorage())
1741  return CGM.GetAddrOfGlobalVar(VD);
1742 
1743  if (VD->isLocalVarDecl()) {
1744  return CGM.getOrCreateStaticVarDecl(
1745  *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false));
1746  }
1747  }
1748  }
1749 
1750  return nullptr;
1751  }
1752 
1753  // Otherwise, it must be an expression.
1754  return Visit(base.get<const Expr*>());
1755 }
1756 
1757 ConstantLValue
1758 ConstantLValueEmitter::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
1759  return tryEmitGlobalCompoundLiteral(CGM, Emitter.CGF, E);
1760 }
1761 
1762 ConstantLValue
1763 ConstantLValueEmitter::VisitStringLiteral(const StringLiteral *E) {
1764  return CGM.GetAddrOfConstantStringFromLiteral(E);
1765 }
1766 
1767 ConstantLValue
1768 ConstantLValueEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
1770 }
1771 
1772 ConstantLValue
1773 ConstantLValueEmitter::VisitObjCStringLiteral(const ObjCStringLiteral *E) {
1774  auto C = CGM.getObjCRuntime().GenerateConstantString(E->getString());
1775  return C.getElementBitCast(CGM.getTypes().ConvertTypeForMem(E->getType()));
1776 }
1777 
1778 ConstantLValue
1779 ConstantLValueEmitter::VisitPredefinedExpr(const PredefinedExpr *E) {
1780  if (auto CGF = Emitter.CGF) {
1781  LValue Res = CGF->EmitPredefinedLValue(E);
1782  return cast<ConstantAddress>(Res.getAddress());
1783  }
1784 
1785  auto kind = E->getIdentType();
1786  if (kind == PredefinedExpr::PrettyFunction) {
1787  return CGM.GetAddrOfConstantCString("top level", ".tmp");
1788  }
1789 
1790  return CGM.GetAddrOfConstantCString("", ".tmp");
1791 }
1792 
1793 ConstantLValue
1794 ConstantLValueEmitter::VisitAddrLabelExpr(const AddrLabelExpr *E) {
1795  assert(Emitter.CGF && "Invalid address of label expression outside function");
1796  llvm::Constant *Ptr = Emitter.CGF->GetAddrOfLabel(E->getLabel());
1797  Ptr = llvm::ConstantExpr::getBitCast(Ptr,
1798  CGM.getTypes().ConvertType(E->getType()));
1799  return Ptr;
1800 }
1801 
1802 ConstantLValue
1803 ConstantLValueEmitter::VisitCallExpr(const CallExpr *E) {
1804  unsigned builtin = E->getBuiltinCallee();
1805  if (builtin != Builtin::BI__builtin___CFStringMakeConstantString &&
1806  builtin != Builtin::BI__builtin___NSStringMakeConstantString)
1807  return nullptr;
1808 
1809  auto literal = cast<StringLiteral>(E->getArg(0)->IgnoreParenCasts());
1810  if (builtin == Builtin::BI__builtin___NSStringMakeConstantString) {
1811  return CGM.getObjCRuntime().GenerateConstantString(literal);
1812  } else {
1813  // FIXME: need to deal with UCN conversion issues.
1814  return CGM.GetAddrOfConstantCFString(literal);
1815  }
1816 }
1817 
1818 ConstantLValue
1819 ConstantLValueEmitter::VisitBlockExpr(const BlockExpr *E) {
1820  StringRef functionName;
1821  if (auto CGF = Emitter.CGF)
1822  functionName = CGF->CurFn->getName();
1823  else
1824  functionName = "global";
1825 
1826  return CGM.GetAddrOfGlobalBlock(E, functionName);
1827 }
1828 
1829 ConstantLValue
1830 ConstantLValueEmitter::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
1831  QualType T;
1832  if (E->isTypeOperand())
1833  T = E->getTypeOperand(CGM.getContext());
1834  else
1835  T = E->getExprOperand()->getType();
1836  return CGM.GetAddrOfRTTIDescriptor(T);
1837 }
1838 
1839 ConstantLValue
1840 ConstantLValueEmitter::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
1841  return CGM.GetAddrOfUuidDescriptor(E);
1842 }
1843 
1844 ConstantLValue
1845 ConstantLValueEmitter::VisitMaterializeTemporaryExpr(
1846  const MaterializeTemporaryExpr *E) {
1847  assert(E->getStorageDuration() == SD_Static);
1848  SmallVector<const Expr *, 2> CommaLHSs;
1850  const Expr *Inner = E->GetTemporaryExpr()
1851  ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
1852  return CGM.GetAddrOfGlobalTemporary(E, Inner);
1853 }
1854 
1856  QualType DestType) {
1857  switch (Value.getKind()) {
1859  llvm_unreachable("Constant expressions should be initialized.");
1860  case APValue::LValue:
1861  return ConstantLValueEmitter(*this, Value, DestType).tryEmit();
1862  case APValue::Int:
1863  return llvm::ConstantInt::get(CGM.getLLVMContext(), Value.getInt());
1864  case APValue::ComplexInt: {
1865  llvm::Constant *Complex[2];
1866 
1867  Complex[0] = llvm::ConstantInt::get(CGM.getLLVMContext(),
1868  Value.getComplexIntReal());
1869  Complex[1] = llvm::ConstantInt::get(CGM.getLLVMContext(),
1870  Value.getComplexIntImag());
1871 
1872  // FIXME: the target may want to specify that this is packed.
1873  llvm::StructType *STy =
1874  llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType());
1875  return llvm::ConstantStruct::get(STy, Complex);
1876  }
1877  case APValue::Float: {
1878  const llvm::APFloat &Init = Value.getFloat();
1879  if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf() &&
1880  !CGM.getContext().getLangOpts().NativeHalfType &&
1882  return llvm::ConstantInt::get(CGM.getLLVMContext(),
1883  Init.bitcastToAPInt());
1884  else
1885  return llvm::ConstantFP::get(CGM.getLLVMContext(), Init);
1886  }
1887  case APValue::ComplexFloat: {
1888  llvm::Constant *Complex[2];
1889 
1890  Complex[0] = llvm::ConstantFP::get(CGM.getLLVMContext(),
1891  Value.getComplexFloatReal());
1892  Complex[1] = llvm::ConstantFP::get(CGM.getLLVMContext(),
1893  Value.getComplexFloatImag());
1894 
1895  // FIXME: the target may want to specify that this is packed.
1896  llvm::StructType *STy =
1897  llvm::StructType::get(Complex[0]->getType(), Complex[1]->getType());
1898  return llvm::ConstantStruct::get(STy, Complex);
1899  }
1900  case APValue::Vector: {
1901  unsigned NumElts = Value.getVectorLength();
1903 
1904  for (unsigned I = 0; I != NumElts; ++I) {
1905  const APValue &Elt = Value.getVectorElt(I);
1906  if (Elt.isInt())
1907  Inits[I] = llvm::ConstantInt::get(CGM.getLLVMContext(), Elt.getInt());
1908  else if (Elt.isFloat())
1909  Inits[I] = llvm::ConstantFP::get(CGM.getLLVMContext(), Elt.getFloat());
1910  else
1911  llvm_unreachable("unsupported vector element type");
1912  }
1913  return llvm::ConstantVector::get(Inits);
1914  }
1915  case APValue::AddrLabelDiff: {
1916  const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
1917  const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
1918  llvm::Constant *LHS = tryEmitPrivate(LHSExpr, LHSExpr->getType());
1919  llvm::Constant *RHS = tryEmitPrivate(RHSExpr, RHSExpr->getType());
1920  if (!LHS || !RHS) return nullptr;
1921 
1922  // Compute difference
1923  llvm::Type *ResultType = CGM.getTypes().ConvertType(DestType);
1924  LHS = llvm::ConstantExpr::getPtrToInt(LHS, CGM.IntPtrTy);
1925  RHS = llvm::ConstantExpr::getPtrToInt(RHS, CGM.IntPtrTy);
1926  llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
1927 
1928  // LLVM is a bit sensitive about the exact format of the
1929  // address-of-label difference; make sure to truncate after
1930  // the subtraction.
1931  return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
1932  }
1933  case APValue::Struct:
1934  case APValue::Union:
1935  return ConstStructBuilder::BuildStruct(*this, Value, DestType);
1936  case APValue::Array: {
1937  const ConstantArrayType *CAT =
1938  CGM.getContext().getAsConstantArrayType(DestType);
1939  unsigned NumElements = Value.getArraySize();
1940  unsigned NumInitElts = Value.getArrayInitializedElts();
1941 
1942  // Emit array filler, if there is one.
1943  llvm::Constant *Filler = nullptr;
1944  if (Value.hasArrayFiller()) {
1945  Filler = tryEmitAbstractForMemory(Value.getArrayFiller(),
1946  CAT->getElementType());
1947  if (!Filler)
1948  return nullptr;
1949  }
1950 
1951  // Emit initializer elements.
1953  if (Filler && Filler->isNullValue())
1954  Elts.reserve(NumInitElts + 1);
1955  else
1956  Elts.reserve(NumElements);
1957 
1958  llvm::Type *CommonElementType = nullptr;
1959  for (unsigned I = 0; I < NumInitElts; ++I) {
1960  llvm::Constant *C = tryEmitPrivateForMemory(
1961  Value.getArrayInitializedElt(I), CAT->getElementType());
1962  if (!C) return nullptr;
1963 
1964  if (I == 0)
1965  CommonElementType = C->getType();
1966  else if (C->getType() != CommonElementType)
1967  CommonElementType = nullptr;
1968  Elts.push_back(C);
1969  }
1970 
1971  // This means that the array type is probably "IncompleteType" or some
1972  // type that is not ConstantArray.
1973  if (CAT == nullptr && CommonElementType == nullptr && !NumInitElts) {
1974  const ArrayType *AT = CGM.getContext().getAsArrayType(DestType);
1975  CommonElementType = CGM.getTypes().ConvertType(AT->getElementType());
1976  llvm::ArrayType *AType = llvm::ArrayType::get(CommonElementType,
1977  NumElements);
1978  return llvm::ConstantAggregateZero::get(AType);
1979  }
1980 
1981  return EmitArrayConstant(CGM, CAT, CommonElementType, NumElements, Elts,
1982  Filler);
1983  }
1985  return CGM.getCXXABI().EmitMemberPointer(Value, DestType);
1986  }
1987  llvm_unreachable("Unknown APValue kind");
1988 }
1989 
1991  const CompoundLiteralExpr *E) {
1992  return EmittedCompoundLiterals.lookup(E);
1993 }
1994 
1996  const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV) {
1997  bool Ok = EmittedCompoundLiterals.insert(std::make_pair(CLE, GV)).second;
1998  (void)Ok;
1999  assert(Ok && "CLE has already been emitted!");
2000 }
2001 
2004  assert(E->isFileScope() && "not a file-scope compound literal expr");
2005  return tryEmitGlobalCompoundLiteral(*this, nullptr, E);
2006 }
2007 
2008 llvm::Constant *
2010  // Member pointer constants always have a very particular form.
2011  const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
2012  const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
2013 
2014  // A member function pointer.
2015  if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
2016  return getCXXABI().EmitMemberFunctionPointer(method);
2017 
2018  // Otherwise, a member data pointer.
2019  uint64_t fieldOffset = getContext().getFieldOffset(decl);
2020  CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
2021  return getCXXABI().EmitMemberDataPointer(type, chars);
2022 }
2023 
2024 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
2025  llvm::Type *baseType,
2026  const CXXRecordDecl *base);
2027 
2028 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
2029  const RecordDecl *record,
2030  bool asCompleteObject) {
2031  const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
2032  llvm::StructType *structure =
2033  (asCompleteObject ? layout.getLLVMType()
2034  : layout.getBaseSubobjectLLVMType());
2035 
2036  unsigned numElements = structure->getNumElements();
2037  std::vector<llvm::Constant *> elements(numElements);
2038 
2039  auto CXXR = dyn_cast<CXXRecordDecl>(record);
2040  // Fill in all the bases.
2041  if (CXXR) {
2042  for (const auto &I : CXXR->bases()) {
2043  if (I.isVirtual()) {
2044  // Ignore virtual bases; if we're laying out for a complete
2045  // object, we'll lay these out later.
2046  continue;
2047  }
2048 
2049  const CXXRecordDecl *base =
2050  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
2051 
2052  // Ignore empty bases.
2053  if (base->isEmpty() ||
2055  .isZero())
2056  continue;
2057 
2058  unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
2059  llvm::Type *baseType = structure->getElementType(fieldIndex);
2060  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
2061  }
2062  }
2063 
2064  // Fill in all the fields.
2065  for (const auto *Field : record->fields()) {
2066  // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
2067  // will fill in later.)
2068  if (!Field->isBitField()) {
2069  unsigned fieldIndex = layout.getLLVMFieldNo(Field);
2070  elements[fieldIndex] = CGM.EmitNullConstant(Field->getType());
2071  }
2072 
2073  // For unions, stop after the first named field.
2074  if (record->isUnion()) {
2075  if (Field->getIdentifier())
2076  break;
2077  if (const auto *FieldRD = Field->getType()->getAsRecordDecl())
2078  if (FieldRD->findFirstNamedDataMember())
2079  break;
2080  }
2081  }
2082 
2083  // Fill in the virtual bases, if we're working with the complete object.
2084  if (CXXR && asCompleteObject) {
2085  for (const auto &I : CXXR->vbases()) {
2086  const CXXRecordDecl *base =
2087  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
2088 
2089  // Ignore empty bases.
2090  if (base->isEmpty())
2091  continue;
2092 
2093  unsigned fieldIndex = layout.getVirtualBaseIndex(base);
2094 
2095  // We might have already laid this field out.
2096  if (elements[fieldIndex]) continue;
2097 
2098  llvm::Type *baseType = structure->getElementType(fieldIndex);
2099  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
2100  }
2101  }
2102 
2103  // Now go through all other fields and zero them out.
2104  for (unsigned i = 0; i != numElements; ++i) {
2105  if (!elements[i])
2106  elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
2107  }
2108 
2109  return llvm::ConstantStruct::get(structure, elements);
2110 }
2111 
2112 /// Emit the null constant for a base subobject.
2113 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
2114  llvm::Type *baseType,
2115  const CXXRecordDecl *base) {
2116  const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
2117 
2118  // Just zero out bases that don't have any pointer to data members.
2119  if (baseLayout.isZeroInitializableAsBase())
2120  return llvm::Constant::getNullValue(baseType);
2121 
2122  // Otherwise, we can just use its null constant.
2123  return EmitNullConstant(CGM, base, /*asCompleteObject=*/false);
2124 }
2125 
2127  QualType T) {
2128  return emitForMemory(CGM, CGM.EmitNullConstant(T), T);
2129 }
2130 
2132  if (T->getAs<PointerType>())
2133  return getNullPointer(
2134  cast<llvm::PointerType>(getTypes().ConvertTypeForMem(T)), T);
2135 
2136  if (getTypes().isZeroInitializable(T))
2137  return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
2138 
2139  if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
2140  llvm::ArrayType *ATy =
2141  cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
2142 
2143  QualType ElementTy = CAT->getElementType();
2144 
2145  llvm::Constant *Element =
2146  ConstantEmitter::emitNullForMemory(*this, ElementTy);
2147  unsigned NumElements = CAT->getSize().getZExtValue();
2148  SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
2149  return llvm::ConstantArray::get(ATy, Array);
2150  }
2151 
2152  if (const RecordType *RT = T->getAs<RecordType>())
2153  return ::EmitNullConstant(*this, RT->getDecl(), /*complete object*/ true);
2154 
2155  assert(T->isMemberDataPointerType() &&
2156  "Should only see pointers to data members here!");
2157 
2158  return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
2159 }
2160 
2161 llvm::Constant *
2163  return ::EmitNullConstant(*this, Record, false);
2164 }
const llvm::DataLayout & getDataLayout() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
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:184
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:4045
virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)
Create a member pointer for the given member pointer constant.
Definition: CGCXXABI.cpp:119
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2497
A (possibly-)qualified type.
Definition: Type.h:641
Static storage duration.
Definition: Specifiers.h:280
bool isArrayType() const
Definition: Type.h:6261
llvm::Constant * emitForInitializer(const APValue &value, LangAS destAddrSpace, QualType destType)
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2475
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:77
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:195
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:60
CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...
bool isMemberDataPointerType() const
Definition: Type.h:6254
llvm::Constant * getMemberPointerConstant(const UnaryOperator *e)
llvm::LLVMContext & getLLVMContext()
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4284
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Stmt - This represents one statement.
Definition: Stmt.h:66
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:497
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:233
#define trunc(__x)
Definition: tgmath.h:1232
bool isRecordType() const
Definition: Type.h:6285
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1937
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
llvm::Constant * emitForMemory(llvm::Constant *C, QualType T)
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic, and whose semantics are that of the sole contained initializer)?
Definition: Expr.cpp:2008
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1805
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2772
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1382
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:698
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2483
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4393
const Expr * getResultExpr() const
The generic selection&#39;s result expression.
Definition: Expr.h:5196
const AddrLabelExpr * getAddrLabelDiffLHS() const
Definition: APValue.h:392
QualType getElementType() const
Definition: Type.h:2807
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2319
llvm::Constant * tryEmitPrivateForVarInit(const VarDecl &D)
Represents a variable declaration or definition.
Definition: Decl.h:820
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2854
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
APFloat & getComplexFloatReal()
Definition: APValue.h:284
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6625
unsigned getCharAlign() const
Definition: TargetInfo.h:371
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:26
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
Expr * getExprOperand() const
Definition: ExprCXX.h:764
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3269
bool isZeroInitializableAsBase() const
Check whether this struct can be C++ zero-initialized with a zeroinitializer when considered as a bas...
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Represents a struct/union/class.
Definition: Decl.h:3572
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1337
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4434
Address getAddress() const
Definition: CGValue.h:327
bool cleanupsHaveSideEffects() const
Definition: ExprCXX.h:3312
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
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...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:153
llvm::Constant * tryEmitAbstractForInitializer(const VarDecl &D)
Try to emit the initializer of the given declaration as an abstract constant.
bool isFileScope() const
Definition: Expr.h:2884
field_range fields() const
Definition: Decl.h:3763
Represents a member of a struct/union/class.
Definition: Decl.h:2554
StringLiteral * getString()
Definition: ExprObjC.h:63
unsigned getNonVirtualBaseLLVMFieldNo(const CXXRecordDecl *RD) const
bool isReferenceType() const
Definition: Type.h:6224
unsigned getArraySize() const
Definition: APValue.h:348
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Expr * getSubExpr()
Definition: Expr.h:3000
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final * state
bool isFloat() const
Definition: APValue.h:235
llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)
Return a constant array for the given string.
Describes an C or C++ initializer list.
Definition: Expr.h:4236
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:707
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2632
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:573
uint32_t Offset
Definition: CacheTokens.cpp:43
llvm::Constant * tryEmitPrivate(const Expr *E, QualType T)
llvm::StructType * getBaseSubobjectLLVMType() const
Return the "base subobject" LLVM type associated with this record.
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2544
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:51
field_iterator field_begin() const
Definition: Decl.cpp:4107
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3749
bool isInt() const
Definition: APValue.h:234
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2935
APSInt & getComplexIntReal()
Definition: APValue.h:268
llvm::GlobalValue * getCurrentAddrPrivate()
Get the address of the current location.
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1159
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:447
bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor)
isTypeConstant - Determine whether an object of this type can be emitted as a constant.
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1266
APValue & getVectorElt(unsigned I)
Definition: APValue.h:312
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition: Type.cpp:1631
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
ConstantAddress getElementBitCast(llvm::Type *ty) const
Definition: Address.h:93
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
const TargetCodeGenInfo & getTargetCodeGenInfo()
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1445
APValue & getArrayFiller()
Definition: APValue.h:336
llvm::Constant * getNullPointer(llvm::PointerType *T, QualType QT)
Get target specific null pointer.
InitListExpr * getUpdater() const
Definition: Expr.h:4862
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
bool hasArrayFiller() const
Definition: APValue.h:333
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:640
Expr - This represents one expression.
Definition: Expr.h:106
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:2339
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1041
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.
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6688
Inits[]
Definition: OpenMPClause.h:145
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5303
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
unsigned getNumInits() const
Definition: Expr.h:4266
field_iterator field_end() const
Definition: Decl.h:3766
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
Definition: RecordLayout.h:218
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
QualType getType() const
Definition: Expr.h:128
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD, bool IsConstant)
Returns LLVM linkage for a declarator.
APValue & getStructField(unsigned i)
Definition: APValue.h:365
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4437
QualType getEncodedType() const
Definition: ExprObjC.h:447
ConstantAddress GetAddrOfUuidDescriptor(const CXXUuidofExpr *E)
Get the address of a uuid descriptor .
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1865
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
Definition: ExprCXX.cpp:77
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4171
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2238
APSInt & getComplexIntImag()
Definition: APValue.h:276
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2010
const Expr * getSubExpr() const
Definition: Expr.h:1821
bool isUnionType() const
Definition: Type.cpp:467
ASTContext & getContext() const
const FieldDecl * getUnionField() const
Definition: APValue.h:376
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Definition: Expr.cpp:1314
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:4249
APValue & getStructBase(unsigned i)
Definition: APValue.h:361
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:719
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:191
llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGDecl.cpp:209
Expr * getBase() const
Definition: Expr.h:4859
APValue & getArrayInitializedElt(unsigned I)
Definition: APValue.h:325
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:74
#define false
Definition: stdbool.h:33
static QualType getNonMemoryType(CodeGenModule &CGM, QualType type)
Encodes a location in the source.
const AddrLabelExpr * getAddrLabelDiffRHS() const
Definition: APValue.h:396
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6104
virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0
Generate a constant string object.
Expr * getSubExpr() const
Definition: Expr.h:1892
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
CastKind getCastKind() const
Definition: Expr.h:2994
APValue & getUnionValue()
Definition: APValue.h:380
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2635
APFloat & getFloat()
Definition: APValue.h:260
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2051
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2417
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:186
llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)
Return a null constant appropriate for zero-initializing a base class with the given type...
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded...
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
void registerCurrentAddrPrivate(llvm::Constant *signal, llvm::GlobalValue *placeholder)
Register a &#39;signal&#39; value with the emitter to inform it where to resolve a placeholder.
llvm::GlobalVariable * getAddrOfConstantCompoundLiteralIfEmitted(const CompoundLiteralExpr *E)
If it&#39;s been emitted already, returns the GlobalVariable corresponding to a compound literal...
IdentType getIdentType() const
Definition: Expr.h:1248
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can&#39;t be done.
llvm::Constant * emitNullForMemory(QualType T)
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4330
bool hasFlexibleArrayMember() const
Definition: Decl.h:3626
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2297
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
const Expr * getInitializer() const
Definition: Expr.h:2880
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating &#39;\0&#39; character...
Represents a C11 generic selection.
Definition: Expr.h:5120
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3752
const FieldDecl * getTargetUnionField() const
Definition: Expr.h:3029
This class organizes the cross-function state that is used while generating LLVM code.
bool isTypeOperand() const
Definition: ExprCXX.h:747
Dataflow Directional Tag Classes.
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:184
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1220
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:571
const Expr * getInit() const
Definition: Decl.h:1225
static llvm::Constant * EmitNullConstantForBase(CodeGenModule &CGM, llvm::Type *baseType, const CXXRecordDecl *base)
Emit the null constant for a base subobject.
llvm::Constant * getPointer() const
Definition: Address.h:84
const Expr * getExpr() const
Definition: ExprCXX.h:1194
unsigned getArrayInitializedElts() const
Definition: APValue.h:344
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2716
llvm::Module & getModule() const
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:2034
LabelDecl * getLabel() const
Definition: Expr.h:3782
llvm::Constant * tryEmitPrivateForMemory(const Expr *E, QualType T)
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
Definition: CGExpr.cpp:1009
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:544
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4239
StmtVisitorBase - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:39
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:426
const llvm::APInt & getSize() const
Definition: Type.h:2850
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2078
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.
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1508
llvm::StructType * getLLVMType() const
Return the "complete object" LLVM type associated with this record.
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.
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:32
ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E)
Returns a pointer to a constant global variable for the given file-scope compound literal expression...
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2074
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1238
void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV)
Notes that CLE&#39;s GlobalVariable is GV.
static llvm::Constant * EmitNullConstant(CodeGenModule &CGM, const RecordDecl *record, bool asCompleteObject)
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
ValueKind getKind() const
Definition: APValue.h:232
APFloat & getComplexFloatImag()
Definition: APValue.h:292
Represents a C++ struct/union/class.
Definition: DeclCXX.h:308
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4004
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6015
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:75
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Definition: RecordLayout.h:203
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
unsigned getVirtualBaseIndex(const CXXRecordDecl *base) const
Return the LLVM field index corresponding to the given virtual base.
LValue EmitPredefinedLValue(const PredefinedExpr *E)
Definition: CGExpr.cpp:2657
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1633
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2406
void finalize(llvm::GlobalVariable *global)
llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)
Try to emit the result of the given expression as an abstract constant.
static ConstantAddress invalid()
Definition: Address.h:80
CGCXXABI & getCXXABI() const
__DEVICE__ int max(int __a, int __b)
bool isUnion() const
Definition: Decl.h:3231
llvm::Constant * tryEmitAbstractForMemory(const Expr *E, QualType T)
__DEVICE__ int min(int __a, int __b)
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4348
llvm::Constant * GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name)
Gets the address of a block which requires no captures.
Definition: CGBlocks.cpp:1321
QualType getType() const
Definition: Decl.h:651
unsigned getNumArgs() const
Definition: ExprCXX.h:1505
LValue - This represents an lvalue references.
Definition: CGValue.h:167
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:949
APSInt & getInt()
Definition: APValue.h:252
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2503
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:715
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2832
Defines enum values for all the target-independent builtin functions.
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5000
CharUnits & getLValueOffset()
Definition: APValue.cpp:605
unsigned getLLVMFieldNo(const FieldDecl *FD) const
Return llvm::StructType element number that corresponds to the field FD.
unsigned getVectorLength() const
Definition: APValue.h:320