contrib/llvm/tools/clang/lib/CodeGen/CGExprConstant.cpp

   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;
  44   SmallVector<llvm::Constant *, 32> Elements;
  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();
  84     return CharUnits::fromQuantity(
  85         CGM.getDataLayout().getABITypeAlignment(C->getType()));
  86   }
  87
  88   CharUnits getSizeInChars(const llvm::Constant *C) const {
  89     return CharUnits::fromQuantity(
  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;
 426   CharUnits Offset;
 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.
 450     SmallVector<BaseInfo, 8> Bases;
 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
 661       SmallVector<llvm::Constant*, 2> Elts;
 662       SmallVector<llvm::Type*, 2> Types;
 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 =
 938       CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>();
 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;
 973     CGM.getContext().getObjCEncodingForType(E->getEncodedType(), 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))
1000         return ConstantAddress(CGM.GetAddrOfFunction(FD), CharUnits::One());
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()),
1033                                      llvm::GlobalValue::InternalLinkage,
1034                                      C, ".compoundliteral", nullptr,
1035                                      llvm::GlobalVariable::NotThreadLocal,
1036                           CGM.getContext().getTargetAddressSpace(E->getType()));
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 =
1047           CGM.getObjCRuntime().GenerateConstantString(SL->getString());
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();
1104       return ConstantAddress(CGM.GetAddrOfRTTIDescriptor(T),
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;
1114       SmallVector<SubobjectAdjustment, 2> Adjustments;
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
1262 llvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value,
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()) {
1285   case APValue::Uninitialized:
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();
1380     SmallVector<llvm::Constant *, 4> Inits(NumElts);
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 =
1426         getTypes().ConvertType(CAT->getElementType());
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)
1440         C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I),
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   }
1465   case APValue::MemberPointer:
1466     return getCXXABI().EmitMemberPointer(Value, DestType);
1467   }
1468   llvm_unreachable("Unknown APValue kind");
1469 }
1470
1471 llvm::Constant *
1472 CodeGenModule::EmitConstantValueForMemory(const APValue &Value,
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
1483 ConstantAddress
1484 CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) {
1485   assert(E->isFileScope() && "not a file-scope compound literal expr");
1486   return ConstExprEmitter(*this, nullptr).EmitLValue(E);
1487 }
1488
1489 llvm::Constant *
1490 CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) {
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
1603 llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
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
1627   return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
1628 }
1629
1630 llvm::Constant *
1631 CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) {
1632   return ::EmitNullConstant(*this, Record, false);
1633 }