clang  3.9.0
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 "clang/AST/APValue.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/RecordLayout.h"
22 #include "clang/AST/StmtVisitor.h"
23 #include "clang/Basic/Builtins.h"
24 #include "llvm/IR/Constants.h"
25 #include "llvm/IR/DataLayout.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/IR/GlobalVariable.h"
28 using namespace clang;
29 using namespace CodeGen;
30 
31 //===----------------------------------------------------------------------===//
32 // ConstStructBuilder
33 //===----------------------------------------------------------------------===//
34 
35 namespace {
36 class ConstExprEmitter;
37 class ConstStructBuilder {
38  CodeGenModule &CGM;
39  CodeGenFunction *CGF;
40 
41  bool Packed;
42  CharUnits NextFieldOffsetInChars;
43  CharUnits LLVMStructAlignment;
45 public:
46  static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CFG,
47  ConstExprEmitter *Emitter,
48  llvm::ConstantStruct *Base,
49  InitListExpr *Updater);
50  static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
51  InitListExpr *ILE);
52  static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
53  const APValue &Value, QualType ValTy);
54 
55 private:
56  ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF)
57  : CGM(CGM), CGF(CGF), Packed(false),
58  NextFieldOffsetInChars(CharUnits::Zero()),
59  LLVMStructAlignment(CharUnits::One()) { }
60 
61  void AppendField(const FieldDecl *Field, uint64_t FieldOffset,
62  llvm::Constant *InitExpr);
63 
64  void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst);
65 
66  void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
67  llvm::ConstantInt *InitExpr);
68 
69  void AppendPadding(CharUnits PadSize);
70 
71  void AppendTailPadding(CharUnits RecordSize);
72 
73  void ConvertStructToPacked();
74 
75  bool Build(InitListExpr *ILE);
76  bool Build(ConstExprEmitter *Emitter, llvm::ConstantStruct *Base,
77  InitListExpr *Updater);
78  void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase,
79  const CXXRecordDecl *VTableClass, CharUnits BaseOffset);
80  llvm::Constant *Finalize(QualType Ty);
81 
82  CharUnits getAlignment(const llvm::Constant *C) const {
83  if (Packed) return CharUnits::One();
85  CGM.getDataLayout().getABITypeAlignment(C->getType()));
86  }
87 
88  CharUnits getSizeInChars(const llvm::Constant *C) const {
90  CGM.getDataLayout().getTypeAllocSize(C->getType()));
91  }
92 };
93 
94 void ConstStructBuilder::
95 AppendField(const FieldDecl *Field, uint64_t FieldOffset,
96  llvm::Constant *InitCst) {
97  const ASTContext &Context = CGM.getContext();
98 
99  CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
100 
101  AppendBytes(FieldOffsetInChars, InitCst);
102 }
103 
104 void ConstStructBuilder::
105 AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) {
106 
107  assert(NextFieldOffsetInChars <= FieldOffsetInChars
108  && "Field offset mismatch!");
109 
110  CharUnits FieldAlignment = getAlignment(InitCst);
111 
112  // Round up the field offset to the alignment of the field type.
113  CharUnits AlignedNextFieldOffsetInChars =
114  NextFieldOffsetInChars.alignTo(FieldAlignment);
115 
116  if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) {
117  // We need to append padding.
118  AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars);
119 
120  assert(NextFieldOffsetInChars == FieldOffsetInChars &&
121  "Did not add enough padding!");
122 
123  AlignedNextFieldOffsetInChars =
124  NextFieldOffsetInChars.alignTo(FieldAlignment);
125  }
126 
127  if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) {
128  assert(!Packed && "Alignment is wrong even with a packed struct!");
129 
130  // Convert the struct to a packed struct.
131  ConvertStructToPacked();
132 
133  // After we pack the struct, we may need to insert padding.
134  if (NextFieldOffsetInChars < FieldOffsetInChars) {
135  // We need to append padding.
136  AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars);
137 
138  assert(NextFieldOffsetInChars == FieldOffsetInChars &&
139  "Did not add enough padding!");
140  }
141  AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
142  }
143 
144  // Add the field.
145  Elements.push_back(InitCst);
146  NextFieldOffsetInChars = AlignedNextFieldOffsetInChars +
147  getSizeInChars(InitCst);
148 
149  if (Packed)
150  assert(LLVMStructAlignment == CharUnits::One() &&
151  "Packed struct not byte-aligned!");
152  else
153  LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment);
154 }
155 
156 void ConstStructBuilder::AppendBitField(const FieldDecl *Field,
157  uint64_t FieldOffset,
158  llvm::ConstantInt *CI) {
159  const ASTContext &Context = CGM.getContext();
160  const uint64_t CharWidth = Context.getCharWidth();
161  uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
162  if (FieldOffset > NextFieldOffsetInBits) {
163  // We need to add padding.
164  CharUnits PadSize = Context.toCharUnitsFromBits(
165  llvm::alignTo(FieldOffset - NextFieldOffsetInBits,
166  Context.getTargetInfo().getCharAlign()));
167 
168  AppendPadding(PadSize);
169  }
170 
171  uint64_t FieldSize = Field->getBitWidthValue(Context);
172 
173  llvm::APInt FieldValue = CI->getValue();
174 
175  // Promote the size of FieldValue if necessary
176  // FIXME: This should never occur, but currently it can because initializer
177  // constants are cast to bool, and because clang is not enforcing bitfield
178  // width limits.
179  if (FieldSize > FieldValue.getBitWidth())
180  FieldValue = FieldValue.zext(FieldSize);
181 
182  // Truncate the size of FieldValue to the bit field size.
183  if (FieldSize < FieldValue.getBitWidth())
184  FieldValue = FieldValue.trunc(FieldSize);
185 
186  NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
187  if (FieldOffset < NextFieldOffsetInBits) {
188  // Either part of the field or the entire field can go into the previous
189  // byte.
190  assert(!Elements.empty() && "Elements can't be empty!");
191 
192  unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset;
193 
194  bool FitsCompletelyInPreviousByte =
195  BitsInPreviousByte >= FieldValue.getBitWidth();
196 
197  llvm::APInt Tmp = FieldValue;
198 
199  if (!FitsCompletelyInPreviousByte) {
200  unsigned NewFieldWidth = FieldSize - BitsInPreviousByte;
201 
202  if (CGM.getDataLayout().isBigEndian()) {
203  Tmp = Tmp.lshr(NewFieldWidth);
204  Tmp = Tmp.trunc(BitsInPreviousByte);
205 
206  // We want the remaining high bits.
207  FieldValue = FieldValue.trunc(NewFieldWidth);
208  } else {
209  Tmp = Tmp.trunc(BitsInPreviousByte);
210 
211  // We want the remaining low bits.
212  FieldValue = FieldValue.lshr(BitsInPreviousByte);
213  FieldValue = FieldValue.trunc(NewFieldWidth);
214  }
215  }
216 
217  Tmp = Tmp.zext(CharWidth);
218  if (CGM.getDataLayout().isBigEndian()) {
219  if (FitsCompletelyInPreviousByte)
220  Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth());
221  } else {
222  Tmp = Tmp.shl(CharWidth - BitsInPreviousByte);
223  }
224 
225  // 'or' in the bits that go into the previous byte.
226  llvm::Value *LastElt = Elements.back();
227  if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt))
228  Tmp |= Val->getValue();
229  else {
230  assert(isa<llvm::UndefValue>(LastElt));
231  // If there is an undef field that we're adding to, it can either be a
232  // scalar undef (in which case, we just replace it with our field) or it
233  // is an array. If it is an array, we have to pull one byte off the
234  // array so that the other undef bytes stay around.
235  if (!isa<llvm::IntegerType>(LastElt->getType())) {
236  // The undef padding will be a multibyte array, create a new smaller
237  // padding and then an hole for our i8 to get plopped into.
238  assert(isa<llvm::ArrayType>(LastElt->getType()) &&
239  "Expected array padding of undefs");
240  llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType());
241  assert(AT->getElementType()->isIntegerTy(CharWidth) &&
242  AT->getNumElements() != 0 &&
243  "Expected non-empty array padding of undefs");
244 
245  // Remove the padding array.
246  NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements());
247  Elements.pop_back();
248 
249  // Add the padding back in two chunks.
250  AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1));
251  AppendPadding(CharUnits::One());
252  assert(isa<llvm::UndefValue>(Elements.back()) &&
253  Elements.back()->getType()->isIntegerTy(CharWidth) &&
254  "Padding addition didn't work right");
255  }
256  }
257 
258  Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp);
259 
260  if (FitsCompletelyInPreviousByte)
261  return;
262  }
263 
264  while (FieldValue.getBitWidth() > CharWidth) {
265  llvm::APInt Tmp;
266 
267  if (CGM.getDataLayout().isBigEndian()) {
268  // We want the high bits.
269  Tmp =
270  FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth);
271  } else {
272  // We want the low bits.
273  Tmp = FieldValue.trunc(CharWidth);
274 
275  FieldValue = FieldValue.lshr(CharWidth);
276  }
277 
278  Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp));
279  ++NextFieldOffsetInChars;
280 
281  FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth);
282  }
283 
284  assert(FieldValue.getBitWidth() > 0 &&
285  "Should have at least one bit left!");
286  assert(FieldValue.getBitWidth() <= CharWidth &&
287  "Should not have more than a byte left!");
288 
289  if (FieldValue.getBitWidth() < CharWidth) {
290  if (CGM.getDataLayout().isBigEndian()) {
291  unsigned BitWidth = FieldValue.getBitWidth();
292 
293  FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth);
294  } else
295  FieldValue = FieldValue.zext(CharWidth);
296  }
297 
298  // Append the last element.
299  Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(),
300  FieldValue));
301  ++NextFieldOffsetInChars;
302 }
303 
304 void ConstStructBuilder::AppendPadding(CharUnits PadSize) {
305  if (PadSize.isZero())
306  return;
307 
308  llvm::Type *Ty = CGM.Int8Ty;
309  if (PadSize > CharUnits::One())
310  Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity());
311 
312  llvm::Constant *C = llvm::UndefValue::get(Ty);
313  Elements.push_back(C);
314  assert(getAlignment(C) == CharUnits::One() &&
315  "Padding must have 1 byte alignment!");
316 
317  NextFieldOffsetInChars += getSizeInChars(C);
318 }
319 
320 void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) {
321  assert(NextFieldOffsetInChars <= RecordSize &&
322  "Size mismatch!");
323 
324  AppendPadding(RecordSize - NextFieldOffsetInChars);
325 }
326 
327 void ConstStructBuilder::ConvertStructToPacked() {
328  SmallVector<llvm::Constant *, 16> PackedElements;
329  CharUnits ElementOffsetInChars = CharUnits::Zero();
330 
331  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
332  llvm::Constant *C = Elements[i];
333 
334  CharUnits ElementAlign = CharUnits::fromQuantity(
335  CGM.getDataLayout().getABITypeAlignment(C->getType()));
336  CharUnits AlignedElementOffsetInChars =
337  ElementOffsetInChars.alignTo(ElementAlign);
338 
339  if (AlignedElementOffsetInChars > ElementOffsetInChars) {
340  // We need some padding.
341  CharUnits NumChars =
342  AlignedElementOffsetInChars - ElementOffsetInChars;
343 
344  llvm::Type *Ty = CGM.Int8Ty;
345  if (NumChars > CharUnits::One())
346  Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity());
347 
348  llvm::Constant *Padding = llvm::UndefValue::get(Ty);
349  PackedElements.push_back(Padding);
350  ElementOffsetInChars += getSizeInChars(Padding);
351  }
352 
353  PackedElements.push_back(C);
354  ElementOffsetInChars += getSizeInChars(C);
355  }
356 
357  assert(ElementOffsetInChars == NextFieldOffsetInChars &&
358  "Packing the struct changed its size!");
359 
360  Elements.swap(PackedElements);
361  LLVMStructAlignment = CharUnits::One();
362  Packed = true;
363 }
364 
365 bool ConstStructBuilder::Build(InitListExpr *ILE) {
366  RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
367  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
368 
369  unsigned FieldNo = 0;
370  unsigned ElementNo = 0;
371 
372  // Bail out if we have base classes. We could support these, but they only
373  // arise in C++1z where we will have already constant folded most interesting
374  // cases. FIXME: There are still a few more cases we can handle this way.
375  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
376  if (CXXRD->getNumBases())
377  return false;
378 
379  for (RecordDecl::field_iterator Field = RD->field_begin(),
380  FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
381  // If this is a union, skip all the fields that aren't being initialized.
382  if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field)
383  continue;
384 
385  // Don't emit anonymous bitfields, they just affect layout.
386  if (Field->isUnnamedBitfield())
387  continue;
388 
389  // Get the initializer. A struct can include fields without initializers,
390  // we just use explicit null values for them.
391  llvm::Constant *EltInit;
392  if (ElementNo < ILE->getNumInits())
393  EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++),
394  Field->getType(), CGF);
395  else
396  EltInit = CGM.EmitNullConstant(Field->getType());
397 
398  if (!EltInit)
399  return false;
400 
401  if (!Field->isBitField()) {
402  // Handle non-bitfield members.
403  AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit);
404  } else {
405  // Otherwise we have a bitfield.
406  if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) {
407  AppendBitField(*Field, Layout.getFieldOffset(FieldNo), CI);
408  } else {
409  // We are trying to initialize a bitfield with a non-trivial constant,
410  // this must require run-time code.
411  return false;
412  }
413  }
414  }
415 
416  return true;
417 }
418 
419 namespace {
420 struct BaseInfo {
421  BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
422  : Decl(Decl), Offset(Offset), Index(Index) {
423  }
424 
425  const CXXRecordDecl *Decl;
427  unsigned Index;
428 
429  bool operator<(const BaseInfo &O) const { return Offset < O.Offset; }
430 };
431 }
432 
433 void ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
434  bool IsPrimaryBase,
435  const CXXRecordDecl *VTableClass,
436  CharUnits Offset) {
437  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
438 
439  if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
440  // Add a vtable pointer, if we need one and it hasn't already been added.
441  if (CD->isDynamicClass() && !IsPrimaryBase) {
442  llvm::Constant *VTableAddressPoint =
443  CGM.getCXXABI().getVTableAddressPointForConstExpr(
444  BaseSubobject(CD, Offset), VTableClass);
445  AppendBytes(Offset, VTableAddressPoint);
446  }
447 
448  // Accumulate and sort bases, in order to visit them in address order, which
449  // may not be the same as declaration order.
451  Bases.reserve(CD->getNumBases());
452  unsigned BaseNo = 0;
453  for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
454  BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
455  assert(!Base->isVirtual() && "should not have virtual bases here");
456  const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
457  CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
458  Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));
459  }
460  std::stable_sort(Bases.begin(), Bases.end());
461 
462  for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
463  BaseInfo &Base = Bases[I];
464 
465  bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
466  Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
467  VTableClass, Offset + Base.Offset);
468  }
469  }
470 
471  unsigned FieldNo = 0;
472  uint64_t OffsetBits = CGM.getContext().toBits(Offset);
473 
474  for (RecordDecl::field_iterator Field = RD->field_begin(),
475  FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
476  // If this is a union, skip all the fields that aren't being initialized.
477  if (RD->isUnion() && Val.getUnionField() != *Field)
478  continue;
479 
480  // Don't emit anonymous bitfields, they just affect layout.
481  if (Field->isUnnamedBitfield())
482  continue;
483 
484  // Emit the value of the initializer.
485  const APValue &FieldValue =
486  RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo);
487  llvm::Constant *EltInit =
488  CGM.EmitConstantValueForMemory(FieldValue, Field->getType(), CGF);
489  assert(EltInit && "EmitConstantValue can't fail");
490 
491  if (!Field->isBitField()) {
492  // Handle non-bitfield members.
493  AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit);
494  } else {
495  // Otherwise we have a bitfield.
496  AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
497  cast<llvm::ConstantInt>(EltInit));
498  }
499  }
500 }
501 
502 llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) {
503  RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
504  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
505 
506  CharUnits LayoutSizeInChars = Layout.getSize();
507 
508  if (NextFieldOffsetInChars > LayoutSizeInChars) {
509  // If the struct is bigger than the size of the record type,
510  // we must have a flexible array member at the end.
511  assert(RD->hasFlexibleArrayMember() &&
512  "Must have flexible array member if struct is bigger than type!");
513 
514  // No tail padding is necessary.
515  } else {
516  // Append tail padding if necessary.
517  CharUnits LLVMSizeInChars =
518  NextFieldOffsetInChars.alignTo(LLVMStructAlignment);
519 
520  if (LLVMSizeInChars != LayoutSizeInChars)
521  AppendTailPadding(LayoutSizeInChars);
522 
523  LLVMSizeInChars = NextFieldOffsetInChars.alignTo(LLVMStructAlignment);
524 
525  // Check if we need to convert the struct to a packed struct.
526  if (NextFieldOffsetInChars <= LayoutSizeInChars &&
527  LLVMSizeInChars > LayoutSizeInChars) {
528  assert(!Packed && "Size mismatch!");
529 
530  ConvertStructToPacked();
531  assert(NextFieldOffsetInChars <= LayoutSizeInChars &&
532  "Converting to packed did not help!");
533  }
534 
535  LLVMSizeInChars = NextFieldOffsetInChars.alignTo(LLVMStructAlignment);
536 
537  assert(LayoutSizeInChars == LLVMSizeInChars &&
538  "Tail padding mismatch!");
539  }
540 
541  // Pick the type to use. If the type is layout identical to the ConvertType
542  // type then use it, otherwise use whatever the builder produced for us.
543  llvm::StructType *STy =
544  llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(),
545  Elements, Packed);
546  llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty);
547  if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) {
548  if (ValSTy->isLayoutIdentical(STy))
549  STy = ValSTy;
550  }
551 
552  llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements);
553 
554  assert(NextFieldOffsetInChars.alignTo(getAlignment(Result)) ==
555  getSizeInChars(Result) &&
556  "Size mismatch!");
557 
558  return Result;
559 }
560 
561 llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
562  CodeGenFunction *CGF,
563  ConstExprEmitter *Emitter,
564  llvm::ConstantStruct *Base,
565  InitListExpr *Updater) {
566  ConstStructBuilder Builder(CGM, CGF);
567  if (!Builder.Build(Emitter, Base, Updater))
568  return nullptr;
569  return Builder.Finalize(Updater->getType());
570 }
571 
572 llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
573  CodeGenFunction *CGF,
574  InitListExpr *ILE) {
575  ConstStructBuilder Builder(CGM, CGF);
576 
577  if (!Builder.Build(ILE))
578  return nullptr;
579 
580  return Builder.Finalize(ILE->getType());
581 }
582 
583 llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
584  CodeGenFunction *CGF,
585  const APValue &Val,
586  QualType ValTy) {
587  ConstStructBuilder Builder(CGM, CGF);
588 
589  const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl();
590  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
591  Builder.Build(Val, RD, false, CD, CharUnits::Zero());
592 
593  return Builder.Finalize(ValTy);
594 }
595 
596 
597 //===----------------------------------------------------------------------===//
598 // ConstExprEmitter
599 //===----------------------------------------------------------------------===//
600 
601 /// This class only needs to handle two cases:
602 /// 1) Literals (this is used by APValue emission to emit literals).
603 /// 2) Arrays, structs and unions (outside C++11 mode, we don't currently
604 /// constant fold these types).
605 class ConstExprEmitter :
606  public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
607  CodeGenModule &CGM;
608  CodeGenFunction *CGF;
609  llvm::LLVMContext &VMContext;
610 public:
611  ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
612  : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) {
613  }
614 
615  //===--------------------------------------------------------------------===//
616  // Visitor Methods
617  //===--------------------------------------------------------------------===//
618 
619  llvm::Constant *VisitStmt(Stmt *S) {
620  return nullptr;
621  }
622 
623  llvm::Constant *VisitParenExpr(ParenExpr *PE) {
624  return Visit(PE->getSubExpr());
625  }
626 
627  llvm::Constant *
628  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
629  return Visit(PE->getReplacement());
630  }
631 
632  llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
633  return Visit(GE->getResultExpr());
634  }
635 
636  llvm::Constant *VisitChooseExpr(ChooseExpr *CE) {
637  return Visit(CE->getChosenSubExpr());
638  }
639 
640  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
641  return Visit(E->getInitializer());
642  }
643 
644  llvm::Constant *VisitCastExpr(CastExpr* E) {
645  if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
646  CGM.EmitExplicitCastExprType(ECE, CGF);
647  Expr *subExpr = E->getSubExpr();
648  llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF);
649  if (!C) return nullptr;
650 
651  llvm::Type *destType = ConvertType(E->getType());
652 
653  switch (E->getCastKind()) {
654  case CK_ToUnion: {
655  // GCC cast to union extension
656  assert(E->getType()->isUnionType() &&
657  "Destination type is not union type!");
658 
659  // Build a struct with the union sub-element as the first member,
660  // and padded to the appropriate size
663  Elts.push_back(C);
664  Types.push_back(C->getType());
665  unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType());
666  unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destType);
667 
668  assert(CurSize <= TotalSize && "Union size mismatch!");
669  if (unsigned NumPadBytes = TotalSize - CurSize) {
670  llvm::Type *Ty = CGM.Int8Ty;
671  if (NumPadBytes > 1)
672  Ty = llvm::ArrayType::get(Ty, NumPadBytes);
673 
674  Elts.push_back(llvm::UndefValue::get(Ty));
675  Types.push_back(Ty);
676  }
677 
678  llvm::StructType* STy =
679  llvm::StructType::get(C->getType()->getContext(), Types, false);
680  return llvm::ConstantStruct::get(STy, Elts);
681  }
682 
683  case CK_AddressSpaceConversion:
684  return llvm::ConstantExpr::getAddrSpaceCast(C, destType);
685 
686  case CK_LValueToRValue:
687  case CK_AtomicToNonAtomic:
688  case CK_NonAtomicToAtomic:
689  case CK_NoOp:
690  case CK_ConstructorConversion:
691  return C;
692 
693  case CK_Dependent: llvm_unreachable("saw dependent cast!");
694 
695  case CK_BuiltinFnToFnPtr:
696  llvm_unreachable("builtin functions are handled elsewhere");
697 
698  case CK_ReinterpretMemberPointer:
699  case CK_DerivedToBaseMemberPointer:
700  case CK_BaseToDerivedMemberPointer:
701  return CGM.getCXXABI().EmitMemberPointerConversion(E, C);
702 
703  // These will never be supported.
704  case CK_ObjCObjectLValueCast:
705  case CK_ARCProduceObject:
706  case CK_ARCConsumeObject:
707  case CK_ARCReclaimReturnedObject:
708  case CK_ARCExtendBlockObject:
709  case CK_CopyAndAutoreleaseBlockObject:
710  return nullptr;
711 
712  // These don't need to be handled here because Evaluate knows how to
713  // evaluate them in the cases where they can be folded.
714  case CK_BitCast:
715  case CK_ToVoid:
716  case CK_Dynamic:
717  case CK_LValueBitCast:
718  case CK_NullToMemberPointer:
719  case CK_UserDefinedConversion:
720  case CK_CPointerToObjCPointerCast:
721  case CK_BlockPointerToObjCPointerCast:
722  case CK_AnyPointerToBlockPointerCast:
723  case CK_ArrayToPointerDecay:
724  case CK_FunctionToPointerDecay:
725  case CK_BaseToDerived:
726  case CK_DerivedToBase:
727  case CK_UncheckedDerivedToBase:
728  case CK_MemberPointerToBoolean:
729  case CK_VectorSplat:
730  case CK_FloatingRealToComplex:
731  case CK_FloatingComplexToReal:
732  case CK_FloatingComplexToBoolean:
733  case CK_FloatingComplexCast:
734  case CK_FloatingComplexToIntegralComplex:
735  case CK_IntegralRealToComplex:
736  case CK_IntegralComplexToReal:
737  case CK_IntegralComplexToBoolean:
738  case CK_IntegralComplexCast:
739  case CK_IntegralComplexToFloatingComplex:
740  case CK_PointerToIntegral:
741  case CK_PointerToBoolean:
742  case CK_NullToPointer:
743  case CK_IntegralCast:
744  case CK_BooleanToSignedIntegral:
745  case CK_IntegralToPointer:
746  case CK_IntegralToBoolean:
747  case CK_IntegralToFloating:
748  case CK_FloatingToIntegral:
749  case CK_FloatingToBoolean:
750  case CK_FloatingCast:
751  case CK_ZeroToOCLEvent:
752  return nullptr;
753  }
754  llvm_unreachable("Invalid CastKind");
755  }
756 
757  llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
758  return Visit(DAE->getExpr());
759  }
760 
761  llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
762  // No need for a DefaultInitExprScope: we don't handle 'this' in a
763  // constant expression.
764  return Visit(DIE->getExpr());
765  }
766 
767  llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E) {
768  if (!E->cleanupsHaveSideEffects())
769  return Visit(E->getSubExpr());
770  return nullptr;
771  }
772 
773  llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
774  return Visit(E->GetTemporaryExpr());
775  }
776 
777  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
778  if (ILE->isStringLiteralInit())
779  return Visit(ILE->getInit(0));
780 
781  llvm::ArrayType *AType =
782  cast<llvm::ArrayType>(ConvertType(ILE->getType()));
783  llvm::Type *ElemTy = AType->getElementType();
784  unsigned NumInitElements = ILE->getNumInits();
785  unsigned NumElements = AType->getNumElements();
786 
787  // Initialising an array requires us to automatically
788  // initialise any elements that have not been initialised explicitly
789  unsigned NumInitableElts = std::min(NumInitElements, NumElements);
790 
791  // Initialize remaining array elements.
792  // FIXME: This doesn't handle member pointers correctly!
793  llvm::Constant *fillC;
794  if (Expr *filler = ILE->getArrayFiller())
795  fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF);
796  else
797  fillC = llvm::Constant::getNullValue(ElemTy);
798  if (!fillC)
799  return nullptr;
800 
801  // Try to use a ConstantAggregateZero if we can.
802  if (fillC->isNullValue() && !NumInitableElts)
803  return llvm::ConstantAggregateZero::get(AType);
804 
805  // Copy initializer elements.
806  std::vector<llvm::Constant*> Elts;
807  Elts.reserve(NumInitableElts + NumElements);
808 
809  bool RewriteType = false;
810  for (unsigned i = 0; i < NumInitableElts; ++i) {
811  Expr *Init = ILE->getInit(i);
812  llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
813  if (!C)
814  return nullptr;
815  RewriteType |= (C->getType() != ElemTy);
816  Elts.push_back(C);
817  }
818 
819  RewriteType |= (fillC->getType() != ElemTy);
820  Elts.resize(NumElements, fillC);
821 
822  if (RewriteType) {
823  // FIXME: Try to avoid packing the array
824  std::vector<llvm::Type*> Types;
825  Types.reserve(NumInitableElts + NumElements);
826  for (unsigned i = 0, e = Elts.size(); i < e; ++i)
827  Types.push_back(Elts[i]->getType());
828  llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
829  Types, true);
830  return llvm::ConstantStruct::get(SType, Elts);
831  }
832 
833  return llvm::ConstantArray::get(AType, Elts);
834  }
835 
836  llvm::Constant *EmitRecordInitialization(InitListExpr *ILE) {
837  return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
838  }
839 
840  llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
841  return CGM.EmitNullConstant(E->getType());
842  }
843 
844  llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
845  if (ILE->getType()->isArrayType())
846  return EmitArrayInitialization(ILE);
847 
848  if (ILE->getType()->isRecordType())
849  return EmitRecordInitialization(ILE);
850 
851  return nullptr;
852  }
853 
854  llvm::Constant *EmitDesignatedInitUpdater(llvm::Constant *Base,
855  InitListExpr *Updater) {
856  QualType ExprType = Updater->getType();
857 
858  if (ExprType->isArrayType()) {
859  llvm::ArrayType *AType = cast<llvm::ArrayType>(ConvertType(ExprType));
860  llvm::Type *ElemType = AType->getElementType();
861 
862  unsigned NumInitElements = Updater->getNumInits();
863  unsigned NumElements = AType->getNumElements();
864 
865  std::vector<llvm::Constant *> Elts;
866  Elts.reserve(NumElements);
867 
868  if (llvm::ConstantDataArray *DataArray =
869  dyn_cast<llvm::ConstantDataArray>(Base))
870  for (unsigned i = 0; i != NumElements; ++i)
871  Elts.push_back(DataArray->getElementAsConstant(i));
872  else if (llvm::ConstantArray *Array =
873  dyn_cast<llvm::ConstantArray>(Base))
874  for (unsigned i = 0; i != NumElements; ++i)
875  Elts.push_back(Array->getOperand(i));
876  else
877  return nullptr; // FIXME: other array types not implemented
878 
879  llvm::Constant *fillC = nullptr;
880  if (Expr *filler = Updater->getArrayFiller())
881  if (!isa<NoInitExpr>(filler))
882  fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF);
883  bool RewriteType = (fillC && fillC->getType() != ElemType);
884 
885  for (unsigned i = 0; i != NumElements; ++i) {
886  Expr *Init = nullptr;
887  if (i < NumInitElements)
888  Init = Updater->getInit(i);
889 
890  if (!Init && fillC)
891  Elts[i] = fillC;
892  else if (!Init || isa<NoInitExpr>(Init))
893  ; // Do nothing.
894  else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init))
895  Elts[i] = EmitDesignatedInitUpdater(Elts[i], ChildILE);
896  else
897  Elts[i] = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
898 
899  if (!Elts[i])
900  return nullptr;
901  RewriteType |= (Elts[i]->getType() != ElemType);
902  }
903 
904  if (RewriteType) {
905  std::vector<llvm::Type *> Types;
906  Types.reserve(NumElements);
907  for (unsigned i = 0; i != NumElements; ++i)
908  Types.push_back(Elts[i]->getType());
909  llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
910  Types, true);
911  return llvm::ConstantStruct::get(SType, Elts);
912  }
913 
914  return llvm::ConstantArray::get(AType, Elts);
915  }
916 
917  if (ExprType->isRecordType())
918  return ConstStructBuilder::BuildStruct(CGM, CGF, this,
919  dyn_cast<llvm::ConstantStruct>(Base), Updater);
920 
921  return nullptr;
922  }
923 
924  llvm::Constant *VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
925  return EmitDesignatedInitUpdater(
926  CGM.EmitConstantExpr(E->getBase(), E->getType(), CGF),
927  E->getUpdater());
928  }
929 
930  llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) {
931  if (!E->getConstructor()->isTrivial())
932  return nullptr;
933 
934  QualType Ty = E->getType();
935 
936  // FIXME: We should not have to call getBaseElementType here.
937  const RecordType *RT =
939  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
940 
941  // If the class doesn't have a trivial destructor, we can't emit it as a
942  // constant expr.
943  if (!RD->hasTrivialDestructor())
944  return nullptr;
945 
946  // Only copy and default constructors can be trivial.
947 
948 
949  if (E->getNumArgs()) {
950  assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
951  assert(E->getConstructor()->isCopyOrMoveConstructor() &&
952  "trivial ctor has argument but isn't a copy/move ctor");
953 
954  Expr *Arg = E->getArg(0);
955  assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
956  "argument to copy ctor is of wrong type");
957 
958  return Visit(Arg);
959  }
960 
961  return CGM.EmitNullConstant(Ty);
962  }
963 
964  llvm::Constant *VisitStringLiteral(StringLiteral *E) {
965  return CGM.GetConstantArrayFromStringLiteral(E);
966  }
967 
968  llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
969  // This must be an @encode initializing an array in a static initializer.
970  // Don't emit it as the address of the string, emit the string data itself
971  // as an inline array.
972  std::string Str;
974  QualType T = E->getType();
975  if (T->getTypeClass() == Type::TypeOfExpr)
976  T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
977  const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
978 
979  // Resize the string to the right size, adding zeros at the end, or
980  // truncating as needed.
981  Str.resize(CAT->getSize().getZExtValue(), '\0');
982  return llvm::ConstantDataArray::getString(VMContext, Str, false);
983  }
984 
985  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
986  return Visit(E->getSubExpr());
987  }
988 
989  // Utility methods
990  llvm::Type *ConvertType(QualType T) {
991  return CGM.getTypes().ConvertType(T);
992  }
993 
994 public:
995  ConstantAddress EmitLValue(APValue::LValueBase LVBase) {
996  if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) {
997  if (Decl->hasAttr<WeakRefAttr>())
998  return CGM.GetWeakRefReference(Decl);
999  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
1001  if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
1002  // We can never refer to a variable with local storage.
1003  if (!VD->hasLocalStorage()) {
1004  CharUnits Align = CGM.getContext().getDeclAlign(VD);
1005  if (VD->isFileVarDecl() || VD->hasExternalStorage())
1006  return ConstantAddress(CGM.GetAddrOfGlobalVar(VD), Align);
1007  else if (VD->isLocalVarDecl()) {
1008  auto Ptr = CGM.getOrCreateStaticVarDecl(
1009  *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false));
1010  return ConstantAddress(Ptr, Align);
1011  }
1012  }
1013  }
1014  return ConstantAddress::invalid();
1015  }
1016 
1017  Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>());
1018  switch (E->getStmtClass()) {
1019  default: break;
1020  case Expr::CompoundLiteralExprClass: {
1021  // Note that due to the nature of compound literals, this is guaranteed
1022  // to be the only use of the variable, so we just generate it here.
1023  CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
1024  llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(),
1025  CLE->getType(), CGF);
1026  // FIXME: "Leaked" on failure.
1027  if (!C) return ConstantAddress::invalid();
1028 
1029  CharUnits Align = CGM.getContext().getTypeAlignInChars(E->getType());
1030 
1031  auto GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
1032  E->getType().isConstant(CGM.getContext()),
1034  C, ".compoundliteral", nullptr,
1035  llvm::GlobalVariable::NotThreadLocal,
1037  GV->setAlignment(Align.getQuantity());
1038  return ConstantAddress(GV, Align);
1039  }
1040  case Expr::StringLiteralClass:
1041  return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
1042  case Expr::ObjCEncodeExprClass:
1043  return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
1044  case Expr::ObjCStringLiteralClass: {
1045  ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
1046  ConstantAddress C =
1048  return C.getElementBitCast(ConvertType(E->getType()));
1049  }
1050  case Expr::PredefinedExprClass: {
1051  unsigned Type = cast<PredefinedExpr>(E)->getIdentType();
1052  if (CGF) {
1053  LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E));
1054  return cast<ConstantAddress>(Res.getAddress());
1055  } else if (Type == PredefinedExpr::PrettyFunction) {
1056  return CGM.GetAddrOfConstantCString("top level", ".tmp");
1057  }
1058 
1059  return CGM.GetAddrOfConstantCString("", ".tmp");
1060  }
1061  case Expr::AddrLabelExprClass: {
1062  assert(CGF && "Invalid address of label expression outside function.");
1063  llvm::Constant *Ptr =
1064  CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
1065  Ptr = llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType()));
1066  return ConstantAddress(Ptr, CharUnits::One());
1067  }
1068  case Expr::CallExprClass: {
1069  CallExpr* CE = cast<CallExpr>(E);
1070  unsigned builtin = CE->getBuiltinCallee();
1071  if (builtin !=
1072  Builtin::BI__builtin___CFStringMakeConstantString &&
1073  builtin !=
1074  Builtin::BI__builtin___NSStringMakeConstantString)
1075  break;
1076  const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
1077  const StringLiteral *Literal = cast<StringLiteral>(Arg);
1078  if (builtin ==
1079  Builtin::BI__builtin___NSStringMakeConstantString) {
1080  return CGM.getObjCRuntime().GenerateConstantString(Literal);
1081  }
1082  // FIXME: need to deal with UCN conversion issues.
1083  return CGM.GetAddrOfConstantCFString(Literal);
1084  }
1085  case Expr::BlockExprClass: {
1086  std::string FunctionName;
1087  if (CGF)
1088  FunctionName = CGF->CurFn->getName();
1089  else
1090  FunctionName = "global";
1091 
1092  // This is not really an l-value.
1093  llvm::Constant *Ptr =
1094  CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
1095  return ConstantAddress(Ptr, CGM.getPointerAlign());
1096  }
1097  case Expr::CXXTypeidExprClass: {
1098  CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E);
1099  QualType T;
1100  if (Typeid->isTypeOperand())
1101  T = Typeid->getTypeOperand(CGM.getContext());
1102  else
1103  T = Typeid->getExprOperand()->getType();
1105  CGM.getPointerAlign());
1106  }
1107  case Expr::CXXUuidofExprClass: {
1108  return CGM.GetAddrOfUuidDescriptor(cast<CXXUuidofExpr>(E));
1109  }
1110  case Expr::MaterializeTemporaryExprClass: {
1111  MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(E);
1112  assert(MTE->getStorageDuration() == SD_Static);
1113  SmallVector<const Expr *, 2> CommaLHSs;
1115  const Expr *Inner = MTE->GetTemporaryExpr()
1116  ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
1117  return CGM.GetAddrOfGlobalTemporary(MTE, Inner);
1118  }
1119  }
1120 
1121  return ConstantAddress::invalid();
1122  }
1123 };
1124 
1125 } // end anonymous namespace.
1126 
1127 bool ConstStructBuilder::Build(ConstExprEmitter *Emitter,
1128  llvm::ConstantStruct *Base,
1129  InitListExpr *Updater) {
1130  assert(Base && "base expression should not be empty");
1131 
1132  QualType ExprType = Updater->getType();
1133  RecordDecl *RD = ExprType->getAs<RecordType>()->getDecl();
1134  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1135  const llvm::StructLayout *BaseLayout = CGM.getDataLayout().getStructLayout(
1136  Base->getType());
1137  unsigned FieldNo = -1;
1138  unsigned ElementNo = 0;
1139 
1140  // Bail out if we have base classes. We could support these, but they only
1141  // arise in C++1z where we will have already constant folded most interesting
1142  // cases. FIXME: There are still a few more cases we can handle this way.
1143  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1144  if (CXXRD->getNumBases())
1145  return false;
1146 
1147  for (FieldDecl *Field : RD->fields()) {
1148  ++FieldNo;
1149 
1150  if (RD->isUnion() && Updater->getInitializedFieldInUnion() != Field)
1151  continue;
1152 
1153  // Skip anonymous bitfields.
1154  if (Field->isUnnamedBitfield())
1155  continue;
1156 
1157  llvm::Constant *EltInit = Base->getOperand(ElementNo);
1158 
1159  // Bail out if the type of the ConstantStruct does not have the same layout
1160  // as the type of the InitListExpr.
1161  if (CGM.getTypes().ConvertType(Field->getType()) != EltInit->getType() ||
1162  Layout.getFieldOffset(ElementNo) !=
1163  BaseLayout->getElementOffsetInBits(ElementNo))
1164  return false;
1165 
1166  // Get the initializer. If we encounter an empty field or a NoInitExpr,
1167  // we use values from the base expression.
1168  Expr *Init = nullptr;
1169  if (ElementNo < Updater->getNumInits())
1170  Init = Updater->getInit(ElementNo);
1171 
1172  if (!Init || isa<NoInitExpr>(Init))
1173  ; // Do nothing.
1174  else if (InitListExpr *ChildILE = dyn_cast<InitListExpr>(Init))
1175  EltInit = Emitter->EmitDesignatedInitUpdater(EltInit, ChildILE);
1176  else
1177  EltInit = CGM.EmitConstantExpr(Init, Field->getType(), CGF);
1178 
1179  ++ElementNo;
1180 
1181  if (!EltInit)
1182  return false;
1183 
1184  if (!Field->isBitField())
1185  AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit);
1186  else if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(EltInit))
1187  AppendBitField(Field, Layout.getFieldOffset(FieldNo), CI);
1188  else
1189  // Initializing a bitfield with a non-trivial constant?
1190  return false;
1191  }
1192 
1193  return true;
1194 }
1195 
1196 llvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D,
1197  CodeGenFunction *CGF) {
1198  // Make a quick check if variable can be default NULL initialized
1199  // and avoid going through rest of code which may do, for c++11,
1200  // initialization of memory to all NULLs.
1201  if (!D.hasLocalStorage()) {
1202  QualType Ty = D.getType();
1203  if (Ty->isArrayType())
1204  Ty = Context.getBaseElementType(Ty);
1205  if (Ty->isRecordType())
1206  if (const CXXConstructExpr *E =
1207  dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
1208  const CXXConstructorDecl *CD = E->getConstructor();
1209  if (CD->isTrivial() && CD->isDefaultConstructor())
1210  return EmitNullConstant(D.getType());
1211  }
1212  }
1213 
1214  if (const APValue *Value = D.evaluateValue())
1215  return EmitConstantValueForMemory(*Value, D.getType(), CGF);
1216 
1217  // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
1218  // reference is a constant expression, and the reference binds to a temporary,
1219  // then constant initialization is performed. ConstExprEmitter will
1220  // incorrectly emit a prvalue constant in this case, and the calling code
1221  // interprets that as the (pointer) value of the reference, rather than the
1222  // desired value of the referee.
1223  if (D.getType()->isReferenceType())
1224  return nullptr;
1225 
1226  const Expr *E = D.getInit();
1227  assert(E && "No initializer to emit");
1228 
1229  llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
1230  if (C && C->getType()->isIntegerTy(1)) {
1231  llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1232  C = llvm::ConstantExpr::getZExt(C, BoolTy);
1233  }
1234  return C;
1235 }
1236 
1237 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
1238  QualType DestType,
1239  CodeGenFunction *CGF) {
1240  Expr::EvalResult Result;
1241 
1242  bool Success = false;
1243 
1244  if (DestType->isReferenceType())
1245  Success = E->EvaluateAsLValue(Result, Context);
1246  else
1247  Success = E->EvaluateAsRValue(Result, Context);
1248 
1249  llvm::Constant *C = nullptr;
1250  if (Success && !Result.HasSideEffects)
1251  C = EmitConstantValue(Result.Val, DestType, CGF);
1252  else
1253  C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
1254 
1255  if (C && C->getType()->isIntegerTy(1)) {
1256  llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1257  C = llvm::ConstantExpr::getZExt(C, BoolTy);
1258  }
1259  return C;
1260 }
1261 
1263  QualType DestType,
1264  CodeGenFunction *CGF) {
1265  // For an _Atomic-qualified constant, we may need to add tail padding.
1266  if (auto *AT = DestType->getAs<AtomicType>()) {
1267  QualType InnerType = AT->getValueType();
1268  auto *Inner = EmitConstantValue(Value, InnerType, CGF);
1269 
1270  uint64_t InnerSize = Context.getTypeSize(InnerType);
1271  uint64_t OuterSize = Context.getTypeSize(DestType);
1272  if (InnerSize == OuterSize)
1273  return Inner;
1274 
1275  assert(InnerSize < OuterSize && "emitted over-large constant for atomic");
1276  llvm::Constant *Elts[] = {
1277  Inner,
1278  llvm::ConstantAggregateZero::get(
1279  llvm::ArrayType::get(Int8Ty, (OuterSize - InnerSize) / 8))
1280  };
1281  return llvm::ConstantStruct::getAnon(Elts);
1282  }
1283 
1284  switch (Value.getKind()) {
1286  llvm_unreachable("Constant expressions should be initialized.");
1287  case APValue::LValue: {
1288  llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType);
1289  llvm::Constant *Offset =
1290  llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity());
1291 
1292  llvm::Constant *C = nullptr;
1293  if (APValue::LValueBase LVBase = Value.getLValueBase()) {
1294  // An array can be represented as an lvalue referring to the base.
1295  if (isa<llvm::ArrayType>(DestTy)) {
1296  assert(Offset->isNullValue() && "offset on array initializer");
1297  return ConstExprEmitter(*this, CGF).Visit(
1298  const_cast<Expr*>(LVBase.get<const Expr*>()));
1299  }
1300 
1301  C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase).getPointer();
1302 
1303  // Apply offset if necessary.
1304  if (!Offset->isNullValue()) {
1305  unsigned AS = C->getType()->getPointerAddressSpace();
1306  llvm::Type *CharPtrTy = Int8Ty->getPointerTo(AS);
1307  llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, CharPtrTy);
1308  Casted = llvm::ConstantExpr::getGetElementPtr(Int8Ty, Casted, Offset);
1309  C = llvm::ConstantExpr::getPointerCast(Casted, C->getType());
1310  }
1311 
1312  // Convert to the appropriate type; this could be an lvalue for
1313  // an integer.
1314  if (isa<llvm::PointerType>(DestTy))
1315  return llvm::ConstantExpr::getPointerCast(C, DestTy);
1316 
1317  return llvm::ConstantExpr::getPtrToInt(C, DestTy);
1318  } else {
1319  C = Offset;
1320 
1321  // Convert to the appropriate type; this could be an lvalue for
1322  // an integer.
1323  if (isa<llvm::PointerType>(DestTy)) {
1324  // Convert the integer to a pointer-sized integer before converting it
1325  // to a pointer.
1326  C = llvm::ConstantExpr::getIntegerCast(
1327  C, getDataLayout().getIntPtrType(DestTy),
1328  /*isSigned=*/false);
1329  return llvm::ConstantExpr::getIntToPtr(C, DestTy);
1330  }
1331 
1332  // If the types don't match this should only be a truncate.
1333  if (C->getType() != DestTy)
1334  return llvm::ConstantExpr::getTrunc(C, DestTy);
1335 
1336  return C;
1337  }
1338  }
1339  case APValue::Int:
1340  return llvm::ConstantInt::get(VMContext, Value.getInt());
1341  case APValue::ComplexInt: {
1342  llvm::Constant *Complex[2];
1343 
1344  Complex[0] = llvm::ConstantInt::get(VMContext,
1345  Value.getComplexIntReal());
1346  Complex[1] = llvm::ConstantInt::get(VMContext,
1347  Value.getComplexIntImag());
1348 
1349  // FIXME: the target may want to specify that this is packed.
1350  llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1351  Complex[1]->getType(),
1352  nullptr);
1353  return llvm::ConstantStruct::get(STy, Complex);
1354  }
1355  case APValue::Float: {
1356  const llvm::APFloat &Init = Value.getFloat();
1357  if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf &&
1358  !Context.getLangOpts().NativeHalfType &&
1359  !Context.getLangOpts().HalfArgsAndReturns)
1360  return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt());
1361  else
1362  return llvm::ConstantFP::get(VMContext, Init);
1363  }
1364  case APValue::ComplexFloat: {
1365  llvm::Constant *Complex[2];
1366 
1367  Complex[0] = llvm::ConstantFP::get(VMContext,
1368  Value.getComplexFloatReal());
1369  Complex[1] = llvm::ConstantFP::get(VMContext,
1370  Value.getComplexFloatImag());
1371 
1372  // FIXME: the target may want to specify that this is packed.
1373  llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1374  Complex[1]->getType(),
1375  nullptr);
1376  return llvm::ConstantStruct::get(STy, Complex);
1377  }
1378  case APValue::Vector: {
1379  unsigned NumElts = Value.getVectorLength();
1381 
1382  for (unsigned I = 0; I != NumElts; ++I) {
1383  const APValue &Elt = Value.getVectorElt(I);
1384  if (Elt.isInt())
1385  Inits[I] = llvm::ConstantInt::get(VMContext, Elt.getInt());
1386  else if (Elt.isFloat())
1387  Inits[I] = llvm::ConstantFP::get(VMContext, Elt.getFloat());
1388  else
1389  llvm_unreachable("unsupported vector element type");
1390  }
1391  return llvm::ConstantVector::get(Inits);
1392  }
1393  case APValue::AddrLabelDiff: {
1394  const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
1395  const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
1396  llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF);
1397  llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF);
1398 
1399  // Compute difference
1400  llvm::Type *ResultType = getTypes().ConvertType(DestType);
1401  LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy);
1402  RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy);
1403  llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
1404 
1405  // LLVM is a bit sensitive about the exact format of the
1406  // address-of-label difference; make sure to truncate after
1407  // the subtraction.
1408  return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
1409  }
1410  case APValue::Struct:
1411  case APValue::Union:
1412  return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType);
1413  case APValue::Array: {
1414  const ArrayType *CAT = Context.getAsArrayType(DestType);
1415  unsigned NumElements = Value.getArraySize();
1416  unsigned NumInitElts = Value.getArrayInitializedElts();
1417 
1418  // Emit array filler, if there is one.
1419  llvm::Constant *Filler = nullptr;
1420  if (Value.hasArrayFiller())
1421  Filler = EmitConstantValueForMemory(Value.getArrayFiller(),
1422  CAT->getElementType(), CGF);
1423 
1424  // Emit initializer elements.
1425  llvm::Type *CommonElementType =
1427 
1428  // Try to use a ConstantAggregateZero if we can.
1429  if (Filler && Filler->isNullValue() && !NumInitElts) {
1430  llvm::ArrayType *AType =
1431  llvm::ArrayType::get(CommonElementType, NumElements);
1432  return llvm::ConstantAggregateZero::get(AType);
1433  }
1434 
1435  std::vector<llvm::Constant*> Elts;
1436  Elts.reserve(NumElements);
1437  for (unsigned I = 0; I < NumElements; ++I) {
1438  llvm::Constant *C = Filler;
1439  if (I < NumInitElts)
1441  CAT->getElementType(), CGF);
1442  else
1443  assert(Filler && "Missing filler for implicit elements of initializer");
1444  if (I == 0)
1445  CommonElementType = C->getType();
1446  else if (C->getType() != CommonElementType)
1447  CommonElementType = nullptr;
1448  Elts.push_back(C);
1449  }
1450 
1451  if (!CommonElementType) {
1452  // FIXME: Try to avoid packing the array
1453  std::vector<llvm::Type*> Types;
1454  Types.reserve(NumElements);
1455  for (unsigned i = 0, e = Elts.size(); i < e; ++i)
1456  Types.push_back(Elts[i]->getType());
1457  llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true);
1458  return llvm::ConstantStruct::get(SType, Elts);
1459  }
1460 
1461  llvm::ArrayType *AType =
1462  llvm::ArrayType::get(CommonElementType, NumElements);
1463  return llvm::ConstantArray::get(AType, Elts);
1464  }
1466  return getCXXABI().EmitMemberPointer(Value, DestType);
1467  }
1468  llvm_unreachable("Unknown APValue kind");
1469 }
1470 
1471 llvm::Constant *
1473  QualType DestType,
1474  CodeGenFunction *CGF) {
1475  llvm::Constant *C = EmitConstantValue(Value, DestType, CGF);
1476  if (C->getType()->isIntegerTy(1)) {
1477  llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType);
1478  C = llvm::ConstantExpr::getZExt(C, BoolTy);
1479  }
1480  return C;
1481 }
1482 
1485  assert(E->isFileScope() && "not a file-scope compound literal expr");
1486  return ConstExprEmitter(*this, nullptr).EmitLValue(E);
1487 }
1488 
1489 llvm::Constant *
1491  // Member pointer constants always have a very particular form.
1492  const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
1493  const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
1494 
1495  // A member function pointer.
1496  if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
1497  return getCXXABI().EmitMemberFunctionPointer(method);
1498 
1499  // Otherwise, a member data pointer.
1500  uint64_t fieldOffset = getContext().getFieldOffset(decl);
1501  CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
1502  return getCXXABI().EmitMemberDataPointer(type, chars);
1503 }
1504 
1505 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
1506  llvm::Type *baseType,
1507  const CXXRecordDecl *base);
1508 
1509 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
1510  const CXXRecordDecl *record,
1511  bool asCompleteObject) {
1512  const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
1513  llvm::StructType *structure =
1514  (asCompleteObject ? layout.getLLVMType()
1515  : layout.getBaseSubobjectLLVMType());
1516 
1517  unsigned numElements = structure->getNumElements();
1518  std::vector<llvm::Constant *> elements(numElements);
1519 
1520  // Fill in all the bases.
1521  for (const auto &I : record->bases()) {
1522  if (I.isVirtual()) {
1523  // Ignore virtual bases; if we're laying out for a complete
1524  // object, we'll lay these out later.
1525  continue;
1526  }
1527 
1528  const CXXRecordDecl *base =
1529  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
1530 
1531  // Ignore empty bases.
1532  if (base->isEmpty())
1533  continue;
1534 
1535  unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
1536  llvm::Type *baseType = structure->getElementType(fieldIndex);
1537  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1538  }
1539 
1540  // Fill in all the fields.
1541  for (const auto *Field : record->fields()) {
1542  // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
1543  // will fill in later.)
1544  if (!Field->isBitField()) {
1545  unsigned fieldIndex = layout.getLLVMFieldNo(Field);
1546  elements[fieldIndex] = CGM.EmitNullConstant(Field->getType());
1547  }
1548 
1549  // For unions, stop after the first named field.
1550  if (record->isUnion()) {
1551  if (Field->getIdentifier())
1552  break;
1553  if (const auto *FieldRD =
1554  dyn_cast_or_null<RecordDecl>(Field->getType()->getAsTagDecl()))
1555  if (FieldRD->findFirstNamedDataMember())
1556  break;
1557  }
1558  }
1559 
1560  // Fill in the virtual bases, if we're working with the complete object.
1561  if (asCompleteObject) {
1562  for (const auto &I : record->vbases()) {
1563  const CXXRecordDecl *base =
1564  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
1565 
1566  // Ignore empty bases.
1567  if (base->isEmpty())
1568  continue;
1569 
1570  unsigned fieldIndex = layout.getVirtualBaseIndex(base);
1571 
1572  // We might have already laid this field out.
1573  if (elements[fieldIndex]) continue;
1574 
1575  llvm::Type *baseType = structure->getElementType(fieldIndex);
1576  elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1577  }
1578  }
1579 
1580  // Now go through all other fields and zero them out.
1581  for (unsigned i = 0; i != numElements; ++i) {
1582  if (!elements[i])
1583  elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
1584  }
1585 
1586  return llvm::ConstantStruct::get(structure, elements);
1587 }
1588 
1589 /// Emit the null constant for a base subobject.
1590 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
1591  llvm::Type *baseType,
1592  const CXXRecordDecl *base) {
1593  const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
1594 
1595  // Just zero out bases that don't have any pointer to data members.
1596  if (baseLayout.isZeroInitializableAsBase())
1597  return llvm::Constant::getNullValue(baseType);
1598 
1599  // Otherwise, we can just use its null constant.
1600  return EmitNullConstant(CGM, base, /*asCompleteObject=*/false);
1601 }
1602 
1604  if (getTypes().isZeroInitializable(T))
1605  return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
1606 
1607  if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
1608  llvm::ArrayType *ATy =
1609  cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
1610 
1611  QualType ElementTy = CAT->getElementType();
1612 
1613  llvm::Constant *Element = EmitNullConstant(ElementTy);
1614  unsigned NumElements = CAT->getSize().getZExtValue();
1615  SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
1616  return llvm::ConstantArray::get(ATy, Array);
1617  }
1618 
1619  if (const RecordType *RT = T->getAs<RecordType>()) {
1620  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1621  return ::EmitNullConstant(*this, RD, /*complete object*/ true);
1622  }
1623 
1624  assert(T->isMemberDataPointerType() &&
1625  "Should only see pointers to data members here!");
1626 
1628 }
1629 
1630 llvm::Constant *
1632  return ::EmitNullConstant(*this, Record, false);
1633 }
Defines the clang::ASTContext interface.
unsigned getNumInits() const
Definition: Expr.h:3776
CastKind getCastKind() const
Definition: Expr.h:2680
virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)
Create a member pointer for the given member pointer constant.
Definition: CGCXXABI.cpp:147
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
const FieldDecl * getUnionField() const
Definition: APValue.h:322
bool isFileScope() const
Definition: Expr.h:2592
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2134
A (possibly-)qualified type.
Definition: Type.h:598
Static storage duration.
Definition: Specifiers.h:273
base_class_range bases()
Definition: DeclCXX.h:718
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2217
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2361
llvm::Module & getModule() const
CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...
llvm::Constant * getMemberPointerConstant(const UnaryOperator *e)
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4003
#define trunc(__x)
Definition: tgmath.h:1223
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
bool isRecordType() const
Definition: Type.h:5539
Address getAddress() const
Definition: CGValue.h:331
bool hasFlexibleArrayMember() const
Definition: Decl.h:3305
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1619
const llvm::DataLayout & getDataLayout() const
The base class of the type hierarchy.
Definition: Type.h:1281
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2456
const Expr * getResultExpr() const
The generic selection's result expression.
Definition: Expr.h:4481
const Expr * getInit() const
Definition: Decl.h:1139
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1162
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
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
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2187
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3962
llvm::Constant * EmitConstantValue(const APValue &Value, QualType DestType, CodeGenFunction *CGF=nullptr)
Emit the given constant value as a constant, in the type's scalar representation. ...
const llvm::APInt & getSize() const
Definition: Type.h:2527
unsigned getLLVMFieldNo(const FieldDecl *FD) const
Return llvm::StructType element number that corresponds to the field FD.
llvm::StructType * getLLVMType() const
Return the "complete object" LLVM type associated with this record.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2562
APFloat & getComplexFloatReal()
Definition: APValue.h:232
field_iterator field_begin() const
Definition: Decl.cpp:3767
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1813
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:1883
bool isMemberDataPointerType() const
Definition: Type.h:5515
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2936
bool isUnionType() const
Definition: Type.cpp:391
llvm::Constant * EmitConstantValueForMemory(const APValue &Value, QualType DestType, CodeGenFunction *CGF=nullptr)
Emit the given constant value as a constant, in the type's memory representation. ...
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1150
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Definition: Type.cpp:1532
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
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:92
bool isReferenceType() const
Definition: Type.h:5491
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
StringLiteral * getString()
Definition: ExprObjC.h:40
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:283
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Expr * getSubExpr()
Definition: Expr.h:2684
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2007
llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)
Return a constant array for the given string.
unsigned getVirtualBaseIndex(const CXXRecordDecl *base) const
Return the LLVM field index corresponding to the given virtual base.
Describes an C or C++ initializer list.
Definition: Expr.h:3746
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:575
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:3588
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:588
const LangOptions & getLangOpts() const
Definition: ASTContext.h:604
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:564
uint32_t Offset
Definition: CacheTokens.cpp:44
bool isZeroInitializableAsBase() const
Check whether this struct can be C++ zero-initialized with a zeroinitializer when considered as a bas...
Expr * getExprOperand() const
Definition: ExprCXX.h:630
field_range fields() const
Definition: Decl.h:3382
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
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:54
RecordDecl * getDecl() const
Definition: Type.h:3716
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2326
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:29
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:177
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2632
TypeClass getTypeClass() const
Definition: Type.h:1533
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Definition: Expr.cpp:1244
detail::InMemoryDirectory::const_iterator I
APSInt & getComplexIntReal()
Definition: APValue.h:216
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:967
QualType getType() const
Definition: Decl.h:599
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2367
field_iterator field_end() const
Definition: Decl.h:3385
APValue & getVectorElt(unsigned I)
Definition: APValue.h:258
bool isUnion() const
Definition: Decl.h:2939
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
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...
APValue & getArrayFiller()
Definition: APValue.h:282
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.
ASTContext * Context
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1062
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:34
unsigned getArrayInitializedElts() const
Definition: APValue.h:290
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
Expr - This represents one expression.
Definition: Expr.h:105
CFG - Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt...
Definition: CFG.h:721
CGCXXABI & getCXXABI() const
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4006
Inits[]
Definition: OpenMPClause.h:312
ASTContext & getContext() const
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:219
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD, bool IsConstant)
Returns LLVM linkage for a declarator.
Expr * getSubExpr() const
Definition: Expr.h:1695
APValue & getStructField(unsigned i)
Definition: APValue.h:311
virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)
Create a member pointer for the given method.
Definition: CGCXXABI.cpp:137
ConstantAddress GetAddrOfUuidDescriptor(const CXXUuidofExpr *E)
Get the address of a uuid descriptor .
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1668
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3767
APSInt & getComplexIntImag()
Definition: APValue.h:224
The result type of a method or function.
InitListExpr * getUpdater() const
Definition: Expr.h:4295
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
The l-value was considered opaque, so the alignment was determined from a type.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
APValue & getStructBase(unsigned i)
Definition: APValue.h:307
llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGDecl.cpp:186
bool cleanupsHaveSideEffects() const
Definition: ExprCXX.h:2978
APValue & getArrayInitializedElt(unsigned I)
Definition: APValue.h:271
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:102
#define false
Definition: stdbool.h:33
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
llvm::Constant * EmitConstantExpr(const Expr *E, QualType DestType, CodeGenFunction *CGF=nullptr)
Try to emit the given expression as a constant; returns 0 if the expression cannot be emitted as a co...
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, bool IsForDefinition=false)
Return the llvm::Constant for the address of the given global variable.
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:170
virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0
Generate a constant string object.
bool isConstant(const ASTContext &Ctx) const
Definition: Type.h:735
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3468
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
Definition: RecordLayout.h:204
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
const AddrLabelExpr * getAddrLabelDiffLHS() const
Definition: APValue.h:338
APValue & getUnionValue()
Definition: APValue.h:326
ValueKind getKind() const
Definition: APValue.h:180
APFloat & getFloat()
Definition: APValue.h:208
ConstantAddress getElementBitCast(llvm::Type *ty) const
Definition: Address.h:93
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
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:178
llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)
Return a null constant appropriate for zero-initializing a base class with the given type...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2114
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5849
const AddrLabelExpr * getAddrLabelDiffRHS() const
Definition: APValue.h:342
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:133
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:3831
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating '\0' character...
Represents a C11 generic selection.
Definition: Expr.h:4413
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3339
QualType getType() const
Definition: Expr.h:126
This class organizes the cross-function state that is used while generating LLVM code.
const Expr * getExpr() const
Definition: ExprCXX.h:998
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
Definition: ExprCXX.cpp:43
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:562
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
unsigned getNonVirtualBaseLLVMFieldNo(const CXXRecordDecl *RD) const
static llvm::Constant * EmitNullConstantForBase(CodeGenModule &CGM, llvm::Type *baseType, const CXXRecordDecl *base)
Emit the null constant for a base subobject.
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
detail::InMemoryDirectory::const_iterator E
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2401
unsigned getNumArgs() const
Definition: ExprCXX.h:1285
bool isFloat() const
Definition: APValue.h:183
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:1473
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
Definition: CGExpr.cpp:804
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:535
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
llvm::PointerUnion< const ValueDecl *, const Expr * > LValueBase
Definition: APValue.h:56
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:355
virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)
Create a member pointer for the given field.
Definition: CGCXXABI.cpp:142
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1288
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1225
llvm::Constant * GetAddrOfGlobalBlock(const BlockExpr *BE, const char *)
Gets the address of a block which requires no captures.
Definition: CGBlocks.cpp:1044
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1848
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:1817
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
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:159
const Expr * getInitializer() const
Definition: Expr.h:2588
llvm::Constant * EmitConstantInit(const VarDecl &D, CodeGenFunction *CGF=nullptr)
Try to emit the initializer for the given declaration as a constant; returns 0 if the expression cann...
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:1863
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1037
const Expr * getSubExpr() const
Definition: Expr.h:1635
APFloat & getComplexFloatImag()
Definition: APValue.h:240
const LValueBase getLValueBase() const
Definition: APValue.cpp:553
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
BoundNodesTreeBuilder *const Builder
QualType getEncodedType() const
Definition: ExprObjC.h:376
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3547
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:75
bool isArrayType() const
Definition: Type.h:5521
LValue EmitPredefinedLValue(const PredefinedExpr *E)
Definition: CGExpr.cpp:2284
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1466
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2148
static ConstantAddress invalid()
Definition: Address.h:80
bool isInt() const
Definition: APValue.h:182
bool isStringLiteralInit() const
Definition: Expr.cpp:1819
Expr * getBase() const
Definition: Expr.h:4292
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2200
QualType getElementType() const
Definition: Type.h:2490
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3785
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:3849
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
static llvm::Constant * EmitNullConstant(CodeGenModule &CGM, const CXXRecordDecl *record, bool asCompleteObject)
LValue - This represents an lvalue references.
Definition: CGValue.h:152
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
APSInt & getInt()
Definition: APValue.h:200
unsigned getArraySize() const
Definition: APValue.h:294
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 ...
bool isTypeOperand() const
Definition: ExprCXX.h:613
llvm::StructType * getBaseSubobjectLLVMType() const
Return the "base subobject" LLVM type associated with this record.
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, bool IsForDefinition=false)
Return the address of the given function.
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
base_class_range vbases()
Definition: DeclCXX.h:735
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2512
unsigned getVectorLength() const
Definition: APValue.h:266
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
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:4315
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Definition: Decl.h:963
bool hasArrayFiller() const
Definition: APValue.h:279
CharUnits & getLValueOffset()
Definition: APValue.cpp:563