Home | History | Annotate | Download | only in CodeGen 
      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 ConstStructBuilder {
     37   CodeGenModule &CGM;
     38   CodeGenFunction *CGF;
     39 
     40   bool Packed;
     41   CharUnits NextFieldOffsetInChars;
     42   CharUnits LLVMStructAlignment;
     43   SmallVector<llvm::Constant *, 32> Elements;
     44 public:
     45   static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
     46                                      InitListExpr *ILE);
     47   static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
     48                                      const APValue &Value, QualType ValTy);
     49 
     50 private:
     51   ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF)
     52     : CGM(CGM), CGF(CGF), Packed(false),
     53     NextFieldOffsetInChars(CharUnits::Zero()),
     54     LLVMStructAlignment(CharUnits::One()) { }
     55 
     56   void AppendVTablePointer(BaseSubobject Base, llvm::Constant *VTable,
     57                            const CXXRecordDecl *VTableClass);
     58 
     59   void AppendField(const FieldDecl *Field, uint64_t FieldOffset,
     60                    llvm::Constant *InitExpr);
     61 
     62   void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst);
     63 
     64   void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
     65                       llvm::ConstantInt *InitExpr);
     66 
     67   void AppendPadding(CharUnits PadSize);
     68 
     69   void AppendTailPadding(CharUnits RecordSize);
     70 
     71   void ConvertStructToPacked();
     72 
     73   bool Build(InitListExpr *ILE);
     74   void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase,
     75              llvm::Constant *VTable, const CXXRecordDecl *VTableClass,
     76              CharUnits BaseOffset);
     77   llvm::Constant *Finalize(QualType Ty);
     78 
     79   CharUnits getAlignment(const llvm::Constant *C) const {
     80     if (Packed)  return CharUnits::One();
     81     return CharUnits::fromQuantity(
     82         CGM.getDataLayout().getABITypeAlignment(C->getType()));
     83   }
     84 
     85   CharUnits getSizeInChars(const llvm::Constant *C) const {
     86     return CharUnits::fromQuantity(
     87         CGM.getDataLayout().getTypeAllocSize(C->getType()));
     88   }
     89 };
     90 
     91 void ConstStructBuilder::AppendVTablePointer(BaseSubobject Base,
     92                                              llvm::Constant *VTable,
     93                                              const CXXRecordDecl *VTableClass) {
     94   // Find the appropriate vtable within the vtable group.
     95   uint64_t AddressPoint =
     96     CGM.getVTableContext().getVTableLayout(VTableClass).getAddressPoint(Base);
     97   llvm::Value *Indices[] = {
     98     llvm::ConstantInt::get(CGM.Int64Ty, 0),
     99     llvm::ConstantInt::get(CGM.Int64Ty, AddressPoint)
    100   };
    101   llvm::Constant *VTableAddressPoint =
    102     llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Indices);
    103 
    104   // Add the vtable at the start of the object.
    105   AppendBytes(Base.getBaseOffset(), VTableAddressPoint);
    106 }
    107 
    108 void ConstStructBuilder::
    109 AppendField(const FieldDecl *Field, uint64_t FieldOffset,
    110             llvm::Constant *InitCst) {
    111   const ASTContext &Context = CGM.getContext();
    112 
    113   CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
    114 
    115   AppendBytes(FieldOffsetInChars, InitCst);
    116 }
    117 
    118 void ConstStructBuilder::
    119 AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) {
    120 
    121   assert(NextFieldOffsetInChars <= FieldOffsetInChars
    122          && "Field offset mismatch!");
    123 
    124   CharUnits FieldAlignment = getAlignment(InitCst);
    125 
    126   // Round up the field offset to the alignment of the field type.
    127   CharUnits AlignedNextFieldOffsetInChars =
    128     NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment);
    129 
    130   if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) {
    131     assert(!Packed && "Alignment is wrong even with a packed struct!");
    132 
    133     // Convert the struct to a packed struct.
    134     ConvertStructToPacked();
    135 
    136     AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
    137   }
    138 
    139   if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) {
    140     // We need to append padding.
    141     AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars);
    142 
    143     assert(NextFieldOffsetInChars == FieldOffsetInChars &&
    144            "Did not add enough padding!");
    145 
    146     AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
    147   }
    148 
    149   // Add the field.
    150   Elements.push_back(InitCst);
    151   NextFieldOffsetInChars = AlignedNextFieldOffsetInChars +
    152                            getSizeInChars(InitCst);
    153 
    154   if (Packed)
    155     assert(LLVMStructAlignment == CharUnits::One() &&
    156            "Packed struct not byte-aligned!");
    157   else
    158     LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment);
    159 }
    160 
    161 void ConstStructBuilder::AppendBitField(const FieldDecl *Field,
    162                                         uint64_t FieldOffset,
    163                                         llvm::ConstantInt *CI) {
    164   const ASTContext &Context = CGM.getContext();
    165   const uint64_t CharWidth = Context.getCharWidth();
    166   uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
    167   if (FieldOffset > NextFieldOffsetInBits) {
    168     // We need to add padding.
    169     CharUnits PadSize = Context.toCharUnitsFromBits(
    170       llvm::RoundUpToAlignment(FieldOffset - NextFieldOffsetInBits,
    171                                Context.getTargetInfo().getCharAlign()));
    172 
    173     AppendPadding(PadSize);
    174   }
    175 
    176   uint64_t FieldSize = Field->getBitWidthValue(Context);
    177 
    178   llvm::APInt FieldValue = CI->getValue();
    179 
    180   // Promote the size of FieldValue if necessary
    181   // FIXME: This should never occur, but currently it can because initializer
    182   // constants are cast to bool, and because clang is not enforcing bitfield
    183   // width limits.
    184   if (FieldSize > FieldValue.getBitWidth())
    185     FieldValue = FieldValue.zext(FieldSize);
    186 
    187   // Truncate the size of FieldValue to the bit field size.
    188   if (FieldSize < FieldValue.getBitWidth())
    189     FieldValue = FieldValue.trunc(FieldSize);
    190 
    191   NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
    192   if (FieldOffset < NextFieldOffsetInBits) {
    193     // Either part of the field or the entire field can go into the previous
    194     // byte.
    195     assert(!Elements.empty() && "Elements can't be empty!");
    196 
    197     unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset;
    198 
    199     bool FitsCompletelyInPreviousByte =
    200       BitsInPreviousByte >= FieldValue.getBitWidth();
    201 
    202     llvm::APInt Tmp = FieldValue;
    203 
    204     if (!FitsCompletelyInPreviousByte) {
    205       unsigned NewFieldWidth = FieldSize - BitsInPreviousByte;
    206 
    207       if (CGM.getDataLayout().isBigEndian()) {
    208         Tmp = Tmp.lshr(NewFieldWidth);
    209         Tmp = Tmp.trunc(BitsInPreviousByte);
    210 
    211         // We want the remaining high bits.
    212         FieldValue = FieldValue.trunc(NewFieldWidth);
    213       } else {
    214         Tmp = Tmp.trunc(BitsInPreviousByte);
    215 
    216         // We want the remaining low bits.
    217         FieldValue = FieldValue.lshr(BitsInPreviousByte);
    218         FieldValue = FieldValue.trunc(NewFieldWidth);
    219       }
    220     }
    221 
    222     Tmp = Tmp.zext(CharWidth);
    223     if (CGM.getDataLayout().isBigEndian()) {
    224       if (FitsCompletelyInPreviousByte)
    225         Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth());
    226     } else {
    227       Tmp = Tmp.shl(CharWidth - BitsInPreviousByte);
    228     }
    229 
    230     // 'or' in the bits that go into the previous byte.
    231     llvm::Value *LastElt = Elements.back();
    232     if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt))
    233       Tmp |= Val->getValue();
    234     else {
    235       assert(isa<llvm::UndefValue>(LastElt));
    236       // If there is an undef field that we're adding to, it can either be a
    237       // scalar undef (in which case, we just replace it with our field) or it
    238       // is an array.  If it is an array, we have to pull one byte off the
    239       // array so that the other undef bytes stay around.
    240       if (!isa<llvm::IntegerType>(LastElt->getType())) {
    241         // The undef padding will be a multibyte array, create a new smaller
    242         // padding and then an hole for our i8 to get plopped into.
    243         assert(isa<llvm::ArrayType>(LastElt->getType()) &&
    244                "Expected array padding of undefs");
    245         llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType());
    246         assert(AT->getElementType()->isIntegerTy(CharWidth) &&
    247                AT->getNumElements() != 0 &&
    248                "Expected non-empty array padding of undefs");
    249 
    250         // Remove the padding array.
    251         NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements());
    252         Elements.pop_back();
    253 
    254         // Add the padding back in two chunks.
    255         AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1));
    256         AppendPadding(CharUnits::One());
    257         assert(isa<llvm::UndefValue>(Elements.back()) &&
    258                Elements.back()->getType()->isIntegerTy(CharWidth) &&
    259                "Padding addition didn't work right");
    260       }
    261     }
    262 
    263     Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp);
    264 
    265     if (FitsCompletelyInPreviousByte)
    266       return;
    267   }
    268 
    269   while (FieldValue.getBitWidth() > CharWidth) {
    270     llvm::APInt Tmp;
    271 
    272     if (CGM.getDataLayout().isBigEndian()) {
    273       // We want the high bits.
    274       Tmp =
    275         FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth);
    276     } else {
    277       // We want the low bits.
    278       Tmp = FieldValue.trunc(CharWidth);
    279 
    280       FieldValue = FieldValue.lshr(CharWidth);
    281     }
    282 
    283     Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp));
    284     ++NextFieldOffsetInChars;
    285 
    286     FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth);
    287   }
    288 
    289   assert(FieldValue.getBitWidth() > 0 &&
    290          "Should have at least one bit left!");
    291   assert(FieldValue.getBitWidth() <= CharWidth &&
    292          "Should not have more than a byte left!");
    293 
    294   if (FieldValue.getBitWidth() < CharWidth) {
    295     if (CGM.getDataLayout().isBigEndian()) {
    296       unsigned BitWidth = FieldValue.getBitWidth();
    297 
    298       FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth);
    299     } else
    300       FieldValue = FieldValue.zext(CharWidth);
    301   }
    302 
    303   // Append the last element.
    304   Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(),
    305                                             FieldValue));
    306   ++NextFieldOffsetInChars;
    307 }
    308 
    309 void ConstStructBuilder::AppendPadding(CharUnits PadSize) {
    310   if (PadSize.isZero())
    311     return;
    312 
    313   llvm::Type *Ty = CGM.Int8Ty;
    314   if (PadSize > CharUnits::One())
    315     Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity());
    316 
    317   llvm::Constant *C = llvm::UndefValue::get(Ty);
    318   Elements.push_back(C);
    319   assert(getAlignment(C) == CharUnits::One() &&
    320          "Padding must have 1 byte alignment!");
    321 
    322   NextFieldOffsetInChars += getSizeInChars(C);
    323 }
    324 
    325 void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) {
    326   assert(NextFieldOffsetInChars <= RecordSize &&
    327          "Size mismatch!");
    328 
    329   AppendPadding(RecordSize - NextFieldOffsetInChars);
    330 }
    331 
    332 void ConstStructBuilder::ConvertStructToPacked() {
    333   SmallVector<llvm::Constant *, 16> PackedElements;
    334   CharUnits ElementOffsetInChars = CharUnits::Zero();
    335 
    336   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
    337     llvm::Constant *C = Elements[i];
    338 
    339     CharUnits ElementAlign = CharUnits::fromQuantity(
    340       CGM.getDataLayout().getABITypeAlignment(C->getType()));
    341     CharUnits AlignedElementOffsetInChars =
    342       ElementOffsetInChars.RoundUpToAlignment(ElementAlign);
    343 
    344     if (AlignedElementOffsetInChars > ElementOffsetInChars) {
    345       // We need some padding.
    346       CharUnits NumChars =
    347         AlignedElementOffsetInChars - ElementOffsetInChars;
    348 
    349       llvm::Type *Ty = CGM.Int8Ty;
    350       if (NumChars > CharUnits::One())
    351         Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity());
    352 
    353       llvm::Constant *Padding = llvm::UndefValue::get(Ty);
    354       PackedElements.push_back(Padding);
    355       ElementOffsetInChars += getSizeInChars(Padding);
    356     }
    357 
    358     PackedElements.push_back(C);
    359     ElementOffsetInChars += getSizeInChars(C);
    360   }
    361 
    362   assert(ElementOffsetInChars == NextFieldOffsetInChars &&
    363          "Packing the struct changed its size!");
    364 
    365   Elements.swap(PackedElements);
    366   LLVMStructAlignment = CharUnits::One();
    367   Packed = true;
    368 }
    369 
    370 bool ConstStructBuilder::Build(InitListExpr *ILE) {
    371   if (ILE->initializesStdInitializerList()) {
    372     //CGM.ErrorUnsupported(ILE, "global std::initializer_list");
    373     return false;
    374   }
    375 
    376   RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
    377   const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
    378 
    379   unsigned FieldNo = 0;
    380   unsigned ElementNo = 0;
    381   const FieldDecl *LastFD = 0;
    382   bool IsMsStruct = RD->isMsStruct(CGM.getContext());
    383 
    384   for (RecordDecl::field_iterator Field = RD->field_begin(),
    385        FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
    386     if (IsMsStruct) {
    387       // Zero-length bitfields following non-bitfield members are
    388       // ignored:
    389       if (CGM.getContext().ZeroBitfieldFollowsNonBitfield(*Field, LastFD)) {
    390         --FieldNo;
    391         continue;
    392       }
    393       LastFD = *Field;
    394     }
    395 
    396     // If this is a union, skip all the fields that aren't being initialized.
    397     if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field)
    398       continue;
    399 
    400     // Don't emit anonymous bitfields, they just affect layout.
    401     if (Field->isUnnamedBitfield()) {
    402       LastFD = *Field;
    403       continue;
    404     }
    405 
    406     // Get the initializer.  A struct can include fields without initializers,
    407     // we just use explicit null values for them.
    408     llvm::Constant *EltInit;
    409     if (ElementNo < ILE->getNumInits())
    410       EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++),
    411                                      Field->getType(), CGF);
    412     else
    413       EltInit = CGM.EmitNullConstant(Field->getType());
    414 
    415     if (!EltInit)
    416       return false;
    417 
    418     if (!Field->isBitField()) {
    419       // Handle non-bitfield members.
    420       AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit);
    421     } else {
    422       // Otherwise we have a bitfield.
    423       AppendBitField(*Field, Layout.getFieldOffset(FieldNo),
    424                      cast<llvm::ConstantInt>(EltInit));
    425     }
    426   }
    427 
    428   return true;
    429 }
    430 
    431 namespace {
    432 struct BaseInfo {
    433   BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
    434     : Decl(Decl), Offset(Offset), Index(Index) {
    435   }
    436 
    437   const CXXRecordDecl *Decl;
    438   CharUnits Offset;
    439   unsigned Index;
    440 
    441   bool operator<(const BaseInfo &O) const { return Offset < O.Offset; }
    442 };
    443 }
    444 
    445 void ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
    446                                bool IsPrimaryBase, llvm::Constant *VTable,
    447                                const CXXRecordDecl *VTableClass,
    448                                CharUnits Offset) {
    449   const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
    450 
    451   if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
    452     // Add a vtable pointer, if we need one and it hasn't already been added.
    453     if (CD->isDynamicClass() && !IsPrimaryBase)
    454       AppendVTablePointer(BaseSubobject(CD, Offset), VTable, VTableClass);
    455 
    456     // Accumulate and sort bases, in order to visit them in address order, which
    457     // may not be the same as declaration order.
    458     SmallVector<BaseInfo, 8> Bases;
    459     Bases.reserve(CD->getNumBases());
    460     unsigned BaseNo = 0;
    461     for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
    462          BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
    463       assert(!Base->isVirtual() && "should not have virtual bases here");
    464       const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
    465       CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
    466       Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));
    467     }
    468     std::stable_sort(Bases.begin(), Bases.end());
    469 
    470     for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
    471       BaseInfo &Base = Bases[I];
    472 
    473       bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
    474       Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
    475             VTable, VTableClass, Offset + Base.Offset);
    476     }
    477   }
    478 
    479   unsigned FieldNo = 0;
    480   const FieldDecl *LastFD = 0;
    481   bool IsMsStruct = RD->isMsStruct(CGM.getContext());
    482   uint64_t OffsetBits = CGM.getContext().toBits(Offset);
    483 
    484   for (RecordDecl::field_iterator Field = RD->field_begin(),
    485        FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
    486     if (IsMsStruct) {
    487       // Zero-length bitfields following non-bitfield members are
    488       // ignored:
    489       if (CGM.getContext().ZeroBitfieldFollowsNonBitfield(*Field, LastFD)) {
    490         --FieldNo;
    491         continue;
    492       }
    493       LastFD = *Field;
    494     }
    495 
    496     // If this is a union, skip all the fields that aren't being initialized.
    497     if (RD->isUnion() && Val.getUnionField() != *Field)
    498       continue;
    499 
    500     // Don't emit anonymous bitfields, they just affect layout.
    501     if (Field->isUnnamedBitfield()) {
    502       LastFD = *Field;
    503       continue;
    504     }
    505 
    506     // Emit the value of the initializer.
    507     const APValue &FieldValue =
    508       RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo);
    509     llvm::Constant *EltInit =
    510       CGM.EmitConstantValueForMemory(FieldValue, Field->getType(), CGF);
    511     assert(EltInit && "EmitConstantValue can't fail");
    512 
    513     if (!Field->isBitField()) {
    514       // Handle non-bitfield members.
    515       AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit);
    516     } else {
    517       // Otherwise we have a bitfield.
    518       AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
    519                      cast<llvm::ConstantInt>(EltInit));
    520     }
    521   }
    522 }
    523 
    524 llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) {
    525   RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
    526   const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
    527 
    528   CharUnits LayoutSizeInChars = Layout.getSize();
    529 
    530   if (NextFieldOffsetInChars > LayoutSizeInChars) {
    531     // If the struct is bigger than the size of the record type,
    532     // we must have a flexible array member at the end.
    533     assert(RD->hasFlexibleArrayMember() &&
    534            "Must have flexible array member if struct is bigger than type!");
    535 
    536     // No tail padding is necessary.
    537   } else {
    538     // Append tail padding if necessary.
    539     AppendTailPadding(LayoutSizeInChars);
    540 
    541     CharUnits LLVMSizeInChars =
    542       NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment);
    543 
    544     // Check if we need to convert the struct to a packed struct.
    545     if (NextFieldOffsetInChars <= LayoutSizeInChars &&
    546         LLVMSizeInChars > LayoutSizeInChars) {
    547       assert(!Packed && "Size mismatch!");
    548 
    549       ConvertStructToPacked();
    550       assert(NextFieldOffsetInChars <= LayoutSizeInChars &&
    551              "Converting to packed did not help!");
    552     }
    553 
    554     assert(LayoutSizeInChars == NextFieldOffsetInChars &&
    555            "Tail padding mismatch!");
    556   }
    557 
    558   // Pick the type to use.  If the type is layout identical to the ConvertType
    559   // type then use it, otherwise use whatever the builder produced for us.
    560   llvm::StructType *STy =
    561       llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(),
    562                                                Elements, Packed);
    563   llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty);
    564   if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) {
    565     if (ValSTy->isLayoutIdentical(STy))
    566       STy = ValSTy;
    567   }
    568 
    569   llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements);
    570 
    571   assert(NextFieldOffsetInChars.RoundUpToAlignment(getAlignment(Result)) ==
    572          getSizeInChars(Result) && "Size mismatch!");
    573 
    574   return Result;
    575 }
    576 
    577 llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
    578                                                 CodeGenFunction *CGF,
    579                                                 InitListExpr *ILE) {
    580   ConstStructBuilder Builder(CGM, CGF);
    581 
    582   if (!Builder.Build(ILE))
    583     return 0;
    584 
    585   return Builder.Finalize(ILE->getType());
    586 }
    587 
    588 llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
    589                                                 CodeGenFunction *CGF,
    590                                                 const APValue &Val,
    591                                                 QualType ValTy) {
    592   ConstStructBuilder Builder(CGM, CGF);
    593 
    594   const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl();
    595   const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
    596   llvm::Constant *VTable = 0;
    597   if (CD && CD->isDynamicClass())
    598     VTable = CGM.getVTables().GetAddrOfVTable(CD);
    599 
    600   Builder.Build(Val, RD, false, VTable, CD, CharUnits::Zero());
    601 
    602   return Builder.Finalize(ValTy);
    603 }
    604 
    605 
    606 //===----------------------------------------------------------------------===//
    607 //                             ConstExprEmitter
    608 //===----------------------------------------------------------------------===//
    609 
    610 /// This class only needs to handle two cases:
    611 /// 1) Literals (this is used by APValue emission to emit literals).
    612 /// 2) Arrays, structs and unions (outside C++11 mode, we don't currently
    613 ///    constant fold these types).
    614 class ConstExprEmitter :
    615   public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
    616   CodeGenModule &CGM;
    617   CodeGenFunction *CGF;
    618   llvm::LLVMContext &VMContext;
    619 public:
    620   ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
    621     : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) {
    622   }
    623 
    624   //===--------------------------------------------------------------------===//
    625   //                            Visitor Methods
    626   //===--------------------------------------------------------------------===//
    627 
    628   llvm::Constant *VisitStmt(Stmt *S) {
    629     return 0;
    630   }
    631 
    632   llvm::Constant *VisitParenExpr(ParenExpr *PE) {
    633     return Visit(PE->getSubExpr());
    634   }
    635 
    636   llvm::Constant *
    637   VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
    638     return Visit(PE->getReplacement());
    639   }
    640 
    641   llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
    642     return Visit(GE->getResultExpr());
    643   }
    644 
    645   llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
    646     return Visit(E->getInitializer());
    647   }
    648 
    649   llvm::Constant *VisitCastExpr(CastExpr* E) {
    650     Expr *subExpr = E->getSubExpr();
    651     llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF);
    652     if (!C) return 0;
    653 
    654     llvm::Type *destType = ConvertType(E->getType());
    655 
    656     switch (E->getCastKind()) {
    657     case CK_ToUnion: {
    658       // GCC cast to union extension
    659       assert(E->getType()->isUnionType() &&
    660              "Destination type is not union type!");
    661 
    662       // Build a struct with the union sub-element as the first member,
    663       // and padded to the appropriate size
    664       SmallVector<llvm::Constant*, 2> Elts;
    665       SmallVector<llvm::Type*, 2> Types;
    666       Elts.push_back(C);
    667       Types.push_back(C->getType());
    668       unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType());
    669       unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destType);
    670 
    671       assert(CurSize <= TotalSize && "Union size mismatch!");
    672       if (unsigned NumPadBytes = TotalSize - CurSize) {
    673         llvm::Type *Ty = CGM.Int8Ty;
    674         if (NumPadBytes > 1)
    675           Ty = llvm::ArrayType::get(Ty, NumPadBytes);
    676 
    677         Elts.push_back(llvm::UndefValue::get(Ty));
    678         Types.push_back(Ty);
    679       }
    680 
    681       llvm::StructType* STy =
    682         llvm::StructType::get(C->getType()->getContext(), Types, false);
    683       return llvm::ConstantStruct::get(STy, Elts);
    684     }
    685 
    686     case CK_LValueToRValue:
    687     case CK_AtomicToNonAtomic:
    688     case CK_NonAtomicToAtomic:
    689     case CK_NoOp:
    690       return C;
    691 
    692     case CK_Dependent: llvm_unreachable("saw dependent cast!");
    693 
    694     case CK_BuiltinFnToFnPtr:
    695       llvm_unreachable("builtin functions are handled elsewhere");
    696 
    697     case CK_ReinterpretMemberPointer:
    698     case CK_DerivedToBaseMemberPointer:
    699     case CK_BaseToDerivedMemberPointer:
    700       return CGM.getCXXABI().EmitMemberPointerConversion(E, C);
    701 
    702     // These will never be supported.
    703     case CK_ObjCObjectLValueCast:
    704     case CK_ARCProduceObject:
    705     case CK_ARCConsumeObject:
    706     case CK_ARCReclaimReturnedObject:
    707     case CK_ARCExtendBlockObject:
    708     case CK_CopyAndAutoreleaseBlockObject:
    709       return 0;
    710 
    711     // These don't need to be handled here because Evaluate knows how to
    712     // evaluate them in the cases where they can be folded.
    713     case CK_BitCast:
    714     case CK_ToVoid:
    715     case CK_Dynamic:
    716     case CK_LValueBitCast:
    717     case CK_NullToMemberPointer:
    718     case CK_UserDefinedConversion:
    719     case CK_ConstructorConversion:
    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_IntegralToPointer:
    745     case CK_IntegralToBoolean:
    746     case CK_IntegralToFloating:
    747     case CK_FloatingToIntegral:
    748     case CK_FloatingToBoolean:
    749     case CK_FloatingCast:
    750     case CK_ZeroToOCLEvent:
    751       return 0;
    752     }
    753     llvm_unreachable("Invalid CastKind");
    754   }
    755 
    756   llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
    757     return Visit(DAE->getExpr());
    758   }
    759 
    760   llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
    761     return Visit(E->GetTemporaryExpr());
    762   }
    763 
    764   llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
    765     if (ILE->isStringLiteralInit())
    766       return Visit(ILE->getInit(0));
    767 
    768     llvm::ArrayType *AType =
    769         cast<llvm::ArrayType>(ConvertType(ILE->getType()));
    770     llvm::Type *ElemTy = AType->getElementType();
    771     unsigned NumInitElements = ILE->getNumInits();
    772     unsigned NumElements = AType->getNumElements();
    773 
    774     // Initialising an array requires us to automatically
    775     // initialise any elements that have not been initialised explicitly
    776     unsigned NumInitableElts = std::min(NumInitElements, NumElements);
    777 
    778     // Copy initializer elements.
    779     std::vector<llvm::Constant*> Elts;
    780     Elts.reserve(NumInitableElts + NumElements);
    781 
    782     bool RewriteType = false;
    783     for (unsigned i = 0; i < NumInitableElts; ++i) {
    784       Expr *Init = ILE->getInit(i);
    785       llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
    786       if (!C)
    787         return 0;
    788       RewriteType |= (C->getType() != ElemTy);
    789       Elts.push_back(C);
    790     }
    791 
    792     // Initialize remaining array elements.
    793     // FIXME: This doesn't handle member pointers correctly!
    794     llvm::Constant *fillC;
    795     if (Expr *filler = ILE->getArrayFiller())
    796       fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF);
    797     else
    798       fillC = llvm::Constant::getNullValue(ElemTy);
    799     if (!fillC)
    800       return 0;
    801     RewriteType |= (fillC->getType() != ElemTy);
    802     Elts.resize(NumElements, fillC);
    803 
    804     if (RewriteType) {
    805       // FIXME: Try to avoid packing the array
    806       std::vector<llvm::Type*> Types;
    807       Types.reserve(NumInitableElts + NumElements);
    808       for (unsigned i = 0, e = Elts.size(); i < e; ++i)
    809         Types.push_back(Elts[i]->getType());
    810       llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
    811                                                             Types, true);
    812       return llvm::ConstantStruct::get(SType, Elts);
    813     }
    814 
    815     return llvm::ConstantArray::get(AType, Elts);
    816   }
    817 
    818   llvm::Constant *EmitRecordInitialization(InitListExpr *ILE) {
    819     return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
    820   }
    821 
    822   llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
    823     return CGM.EmitNullConstant(E->getType());
    824   }
    825 
    826   llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
    827     if (ILE->getType()->isArrayType())
    828       return EmitArrayInitialization(ILE);
    829 
    830     if (ILE->getType()->isRecordType())
    831       return EmitRecordInitialization(ILE);
    832 
    833     return 0;
    834   }
    835 
    836   llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) {
    837     if (!E->getConstructor()->isTrivial())
    838       return 0;
    839 
    840     QualType Ty = E->getType();
    841 
    842     // FIXME: We should not have to call getBaseElementType here.
    843     const RecordType *RT =
    844       CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>();
    845     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
    846 
    847     // If the class doesn't have a trivial destructor, we can't emit it as a
    848     // constant expr.
    849     if (!RD->hasTrivialDestructor())
    850       return 0;
    851 
    852     // Only copy and default constructors can be trivial.
    853 
    854 
    855     if (E->getNumArgs()) {
    856       assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
    857       assert(E->getConstructor()->isCopyOrMoveConstructor() &&
    858              "trivial ctor has argument but isn't a copy/move ctor");
    859 
    860       Expr *Arg = E->getArg(0);
    861       assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
    862              "argument to copy ctor is of wrong type");
    863 
    864       return Visit(Arg);
    865     }
    866 
    867     return CGM.EmitNullConstant(Ty);
    868   }
    869 
    870   llvm::Constant *VisitStringLiteral(StringLiteral *E) {
    871     return CGM.GetConstantArrayFromStringLiteral(E);
    872   }
    873 
    874   llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
    875     // This must be an @encode initializing an array in a static initializer.
    876     // Don't emit it as the address of the string, emit the string data itself
    877     // as an inline array.
    878     std::string Str;
    879     CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
    880     const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
    881 
    882     // Resize the string to the right size, adding zeros at the end, or
    883     // truncating as needed.
    884     Str.resize(CAT->getSize().getZExtValue(), '\0');
    885     return llvm::ConstantDataArray::getString(VMContext, Str, false);
    886   }
    887 
    888   llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
    889     return Visit(E->getSubExpr());
    890   }
    891 
    892   // Utility methods
    893   llvm::Type *ConvertType(QualType T) {
    894     return CGM.getTypes().ConvertType(T);
    895   }
    896 
    897 public:
    898   llvm::Constant *EmitLValue(APValue::LValueBase LVBase) {
    899     if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) {
    900       if (Decl->hasAttr<WeakRefAttr>())
    901         return CGM.GetWeakRefReference(Decl);
    902       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
    903         return CGM.GetAddrOfFunction(FD);
    904       if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
    905         // We can never refer to a variable with local storage.
    906         if (!VD->hasLocalStorage()) {
    907           if (VD->isFileVarDecl() || VD->hasExternalStorage())
    908             return CGM.GetAddrOfGlobalVar(VD);
    909           else if (VD->isLocalVarDecl())
    910             return CGM.getStaticLocalDeclAddress(VD);
    911         }
    912       }
    913       return 0;
    914     }
    915 
    916     Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>());
    917     switch (E->getStmtClass()) {
    918     default: break;
    919     case Expr::CompoundLiteralExprClass: {
    920       // Note that due to the nature of compound literals, this is guaranteed
    921       // to be the only use of the variable, so we just generate it here.
    922       CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
    923       llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(),
    924                                                CLE->getType(), CGF);
    925       // FIXME: "Leaked" on failure.
    926       if (C)
    927         C = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
    928                                      E->getType().isConstant(CGM.getContext()),
    929                                      llvm::GlobalValue::InternalLinkage,
    930                                      C, ".compoundliteral", 0,
    931                                      llvm::GlobalVariable::NotThreadLocal,
    932                           CGM.getContext().getTargetAddressSpace(E->getType()));
    933       return C;
    934     }
    935     case Expr::StringLiteralClass:
    936       return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
    937     case Expr::ObjCEncodeExprClass:
    938       return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
    939     case Expr::ObjCStringLiteralClass: {
    940       ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
    941       llvm::Constant *C =
    942           CGM.getObjCRuntime().GenerateConstantString(SL->getString());
    943       return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
    944     }
    945     case Expr::PredefinedExprClass: {
    946       unsigned Type = cast<PredefinedExpr>(E)->getIdentType();
    947       if (CGF) {
    948         LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E));
    949         return cast<llvm::Constant>(Res.getAddress());
    950       } else if (Type == PredefinedExpr::PrettyFunction) {
    951         return CGM.GetAddrOfConstantCString("top level", ".tmp");
    952       }
    953 
    954       return CGM.GetAddrOfConstantCString("", ".tmp");
    955     }
    956     case Expr::AddrLabelExprClass: {
    957       assert(CGF && "Invalid address of label expression outside function.");
    958       llvm::Constant *Ptr =
    959         CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
    960       return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType()));
    961     }
    962     case Expr::CallExprClass: {
    963       CallExpr* CE = cast<CallExpr>(E);
    964       unsigned builtin = CE->isBuiltinCall();
    965       if (builtin !=
    966             Builtin::BI__builtin___CFStringMakeConstantString &&
    967           builtin !=
    968             Builtin::BI__builtin___NSStringMakeConstantString)
    969         break;
    970       const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
    971       const StringLiteral *Literal = cast<StringLiteral>(Arg);
    972       if (builtin ==
    973             Builtin::BI__builtin___NSStringMakeConstantString) {
    974         return CGM.getObjCRuntime().GenerateConstantString(Literal);
    975       }
    976       // FIXME: need to deal with UCN conversion issues.
    977       return CGM.GetAddrOfConstantCFString(Literal);
    978     }
    979     case Expr::BlockExprClass: {
    980       std::string FunctionName;
    981       if (CGF)
    982         FunctionName = CGF->CurFn->getName();
    983       else
    984         FunctionName = "global";
    985 
    986       return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
    987     }
    988     case Expr::CXXTypeidExprClass: {
    989       CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E);
    990       QualType T;
    991       if (Typeid->isTypeOperand())
    992         T = Typeid->getTypeOperand();
    993       else
    994         T = Typeid->getExprOperand()->getType();
    995       return CGM.GetAddrOfRTTIDescriptor(T);
    996     }
    997     case Expr::CXXUuidofExprClass: {
    998       return CGM.GetAddrOfUuidDescriptor(cast<CXXUuidofExpr>(E));
    999     }
   1000     }
   1001 
   1002     return 0;
   1003   }
   1004 };
   1005 
   1006 }  // end anonymous namespace.
   1007 
   1008 llvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D,
   1009                                                 CodeGenFunction *CGF) {
   1010   // Make a quick check if variable can be default NULL initialized
   1011   // and avoid going through rest of code which may do, for c++11,
   1012   // initialization of memory to all NULLs.
   1013   if (!D.hasLocalStorage()) {
   1014     QualType Ty = D.getType();
   1015     if (Ty->isArrayType())
   1016       Ty = Context.getBaseElementType(Ty);
   1017     if (Ty->isRecordType())
   1018       if (const CXXConstructExpr *E =
   1019           dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
   1020         const CXXConstructorDecl *CD = E->getConstructor();
   1021         if (CD->isTrivial() && CD->isDefaultConstructor() &&
   1022             Ty->getAsCXXRecordDecl()->hasTrivialDestructor())
   1023           return EmitNullConstant(D.getType());
   1024       }
   1025   }
   1026 
   1027   if (const APValue *Value = D.evaluateValue())
   1028     return EmitConstantValueForMemory(*Value, D.getType(), CGF);
   1029 
   1030   // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
   1031   // reference is a constant expression, and the reference binds to a temporary,
   1032   // then constant initialization is performed. ConstExprEmitter will
   1033   // incorrectly emit a prvalue constant in this case, and the calling code
   1034   // interprets that as the (pointer) value of the reference, rather than the
   1035   // desired value of the referee.
   1036   if (D.getType()->isReferenceType())
   1037     return 0;
   1038 
   1039   const Expr *E = D.getInit();
   1040   assert(E && "No initializer to emit");
   1041 
   1042   llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
   1043   if (C && C->getType()->isIntegerTy(1)) {
   1044     llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
   1045     C = llvm::ConstantExpr::getZExt(C, BoolTy);
   1046   }
   1047   return C;
   1048 }
   1049 
   1050 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
   1051                                                 QualType DestType,
   1052                                                 CodeGenFunction *CGF) {
   1053   Expr::EvalResult Result;
   1054 
   1055   bool Success = false;
   1056 
   1057   if (DestType->isReferenceType())
   1058     Success = E->EvaluateAsLValue(Result, Context);
   1059   else
   1060     Success = E->EvaluateAsRValue(Result, Context);
   1061 
   1062   llvm::Constant *C = 0;
   1063   if (Success && !Result.HasSideEffects)
   1064     C = EmitConstantValue(Result.Val, DestType, CGF);
   1065   else
   1066     C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
   1067 
   1068   if (C && C->getType()->isIntegerTy(1)) {
   1069     llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
   1070     C = llvm::ConstantExpr::getZExt(C, BoolTy);
   1071   }
   1072   return C;
   1073 }
   1074 
   1075 llvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value,
   1076                                                  QualType DestType,
   1077                                                  CodeGenFunction *CGF) {
   1078   switch (Value.getKind()) {
   1079   case APValue::Uninitialized:
   1080     llvm_unreachable("Constant expressions should be initialized.");
   1081   case APValue::LValue: {
   1082     llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType);
   1083     llvm::Constant *Offset =
   1084       llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity());
   1085 
   1086     llvm::Constant *C;
   1087     if (APValue::LValueBase LVBase = Value.getLValueBase()) {
   1088       // An array can be represented as an lvalue referring to the base.
   1089       if (isa<llvm::ArrayType>(DestTy)) {
   1090         assert(Offset->isNullValue() && "offset on array initializer");
   1091         return ConstExprEmitter(*this, CGF).Visit(
   1092           const_cast<Expr*>(LVBase.get<const Expr*>()));
   1093       }
   1094 
   1095       C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase);
   1096 
   1097       // Apply offset if necessary.
   1098       if (!Offset->isNullValue()) {
   1099         llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Int8PtrTy);
   1100         Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset);
   1101         C = llvm::ConstantExpr::getBitCast(Casted, C->getType());
   1102       }
   1103 
   1104       // Convert to the appropriate type; this could be an lvalue for
   1105       // an integer.
   1106       if (isa<llvm::PointerType>(DestTy))
   1107         return llvm::ConstantExpr::getBitCast(C, DestTy);
   1108 
   1109       return llvm::ConstantExpr::getPtrToInt(C, DestTy);
   1110     } else {
   1111       C = Offset;
   1112 
   1113       // Convert to the appropriate type; this could be an lvalue for
   1114       // an integer.
   1115       if (isa<llvm::PointerType>(DestTy))
   1116         return llvm::ConstantExpr::getIntToPtr(C, DestTy);
   1117 
   1118       // If the types don't match this should only be a truncate.
   1119       if (C->getType() != DestTy)
   1120         return llvm::ConstantExpr::getTrunc(C, DestTy);
   1121 
   1122       return C;
   1123     }
   1124   }
   1125   case APValue::Int:
   1126     return llvm::ConstantInt::get(VMContext, Value.getInt());
   1127   case APValue::ComplexInt: {
   1128     llvm::Constant *Complex[2];
   1129 
   1130     Complex[0] = llvm::ConstantInt::get(VMContext,
   1131                                         Value.getComplexIntReal());
   1132     Complex[1] = llvm::ConstantInt::get(VMContext,
   1133                                         Value.getComplexIntImag());
   1134 
   1135     // FIXME: the target may want to specify that this is packed.
   1136     llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
   1137                                                   Complex[1]->getType(),
   1138                                                   NULL);
   1139     return llvm::ConstantStruct::get(STy, Complex);
   1140   }
   1141   case APValue::Float: {
   1142     const llvm::APFloat &Init = Value.getFloat();
   1143     if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf &&
   1144          !Context.getLangOpts().NativeHalfType)
   1145       return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt());
   1146     else
   1147       return llvm::ConstantFP::get(VMContext, Init);
   1148   }
   1149   case APValue::ComplexFloat: {
   1150     llvm::Constant *Complex[2];
   1151 
   1152     Complex[0] = llvm::ConstantFP::get(VMContext,
   1153                                        Value.getComplexFloatReal());
   1154     Complex[1] = llvm::ConstantFP::get(VMContext,
   1155                                        Value.getComplexFloatImag());
   1156 
   1157     // FIXME: the target may want to specify that this is packed.
   1158     llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
   1159                                                   Complex[1]->getType(),
   1160                                                   NULL);
   1161     return llvm::ConstantStruct::get(STy, Complex);
   1162   }
   1163   case APValue::Vector: {
   1164     SmallVector<llvm::Constant *, 4> Inits;
   1165     unsigned NumElts = Value.getVectorLength();
   1166 
   1167     for (unsigned i = 0; i != NumElts; ++i) {
   1168       const APValue &Elt = Value.getVectorElt(i);
   1169       if (Elt.isInt())
   1170         Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt()));
   1171       else
   1172         Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat()));
   1173     }
   1174     return llvm::ConstantVector::get(Inits);
   1175   }
   1176   case APValue::AddrLabelDiff: {
   1177     const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
   1178     const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
   1179     llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF);
   1180     llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF);
   1181 
   1182     // Compute difference
   1183     llvm::Type *ResultType = getTypes().ConvertType(DestType);
   1184     LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy);
   1185     RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy);
   1186     llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
   1187 
   1188     // LLVM is a bit sensitive about the exact format of the
   1189     // address-of-label difference; make sure to truncate after
   1190     // the subtraction.
   1191     return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
   1192   }
   1193   case APValue::Struct:
   1194   case APValue::Union:
   1195     return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType);
   1196   case APValue::Array: {
   1197     const ArrayType *CAT = Context.getAsArrayType(DestType);
   1198     unsigned NumElements = Value.getArraySize();
   1199     unsigned NumInitElts = Value.getArrayInitializedElts();
   1200 
   1201     std::vector<llvm::Constant*> Elts;
   1202     Elts.reserve(NumElements);
   1203 
   1204     // Emit array filler, if there is one.
   1205     llvm::Constant *Filler = 0;
   1206     if (Value.hasArrayFiller())
   1207       Filler = EmitConstantValueForMemory(Value.getArrayFiller(),
   1208                                           CAT->getElementType(), CGF);
   1209 
   1210     // Emit initializer elements.
   1211     llvm::Type *CommonElementType = 0;
   1212     for (unsigned I = 0; I < NumElements; ++I) {
   1213       llvm::Constant *C = Filler;
   1214       if (I < NumInitElts)
   1215         C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I),
   1216                                        CAT->getElementType(), CGF);
   1217       else
   1218         assert(Filler && "Missing filler for implicit elements of initializer");
   1219       if (I == 0)
   1220         CommonElementType = C->getType();
   1221       else if (C->getType() != CommonElementType)
   1222         CommonElementType = 0;
   1223       Elts.push_back(C);
   1224     }
   1225 
   1226     if (!CommonElementType) {
   1227       // FIXME: Try to avoid packing the array
   1228       std::vector<llvm::Type*> Types;
   1229       Types.reserve(NumElements);
   1230       for (unsigned i = 0, e = Elts.size(); i < e; ++i)
   1231         Types.push_back(Elts[i]->getType());
   1232       llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true);
   1233       return llvm::ConstantStruct::get(SType, Elts);
   1234     }
   1235 
   1236     llvm::ArrayType *AType =
   1237       llvm::ArrayType::get(CommonElementType, NumElements);
   1238     return llvm::ConstantArray::get(AType, Elts);
   1239   }
   1240   case APValue::MemberPointer:
   1241     return getCXXABI().EmitMemberPointer(Value, DestType);
   1242   }
   1243   llvm_unreachable("Unknown APValue kind");
   1244 }
   1245 
   1246 llvm::Constant *
   1247 CodeGenModule::EmitConstantValueForMemory(const APValue &Value,
   1248                                           QualType DestType,
   1249                                           CodeGenFunction *CGF) {
   1250   llvm::Constant *C = EmitConstantValue(Value, DestType, CGF);
   1251   if (C->getType()->isIntegerTy(1)) {
   1252     llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType);
   1253     C = llvm::ConstantExpr::getZExt(C, BoolTy);
   1254   }
   1255   return C;
   1256 }
   1257 
   1258 llvm::Constant *
   1259 CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) {
   1260   assert(E->isFileScope() && "not a file-scope compound literal expr");
   1261   return ConstExprEmitter(*this, 0).EmitLValue(E);
   1262 }
   1263 
   1264 llvm::Constant *
   1265 CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) {
   1266   // Member pointer constants always have a very particular form.
   1267   const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
   1268   const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
   1269 
   1270   // A member function pointer.
   1271   if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
   1272     return getCXXABI().EmitMemberPointer(method);
   1273 
   1274   // Otherwise, a member data pointer.
   1275   uint64_t fieldOffset = getContext().getFieldOffset(decl);
   1276   CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
   1277   return getCXXABI().EmitMemberDataPointer(type, chars);
   1278 }
   1279 
   1280 static void
   1281 FillInNullDataMemberPointers(CodeGenModule &CGM, QualType T,
   1282                              SmallVectorImpl<llvm::Constant *> &Elements,
   1283                              uint64_t StartOffset) {
   1284   assert(StartOffset % CGM.getContext().getCharWidth() == 0 &&
   1285          "StartOffset not byte aligned!");
   1286 
   1287   if (CGM.getTypes().isZeroInitializable(T))
   1288     return;
   1289 
   1290   if (const ConstantArrayType *CAT =
   1291         CGM.getContext().getAsConstantArrayType(T)) {
   1292     QualType ElementTy = CAT->getElementType();
   1293     uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy);
   1294 
   1295     for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) {
   1296       FillInNullDataMemberPointers(CGM, ElementTy, Elements,
   1297                                    StartOffset + I * ElementSize);
   1298     }
   1299   } else if (const RecordType *RT = T->getAs<RecordType>()) {
   1300     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
   1301     const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
   1302 
   1303     // Go through all bases and fill in any null pointer to data members.
   1304     for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
   1305          E = RD->bases_end(); I != E; ++I) {
   1306       if (I->isVirtual()) {
   1307         // Ignore virtual bases.
   1308         continue;
   1309       }
   1310 
   1311       const CXXRecordDecl *BaseDecl =
   1312       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
   1313 
   1314       // Ignore empty bases.
   1315       if (BaseDecl->isEmpty())
   1316         continue;
   1317 
   1318       // Ignore bases that don't have any pointer to data members.
   1319       if (CGM.getTypes().isZeroInitializable(BaseDecl))
   1320         continue;
   1321 
   1322       uint64_t BaseOffset =
   1323         CGM.getContext().toBits(Layout.getBaseClassOffset(BaseDecl));
   1324       FillInNullDataMemberPointers(CGM, I->getType(),
   1325                                    Elements, StartOffset + BaseOffset);
   1326     }
   1327 
   1328     // Visit all fields.
   1329     unsigned FieldNo = 0;
   1330     for (RecordDecl::field_iterator I = RD->field_begin(),
   1331          E = RD->field_end(); I != E; ++I, ++FieldNo) {
   1332       QualType FieldType = I->getType();
   1333 
   1334       if (CGM.getTypes().isZeroInitializable(FieldType))
   1335         continue;
   1336 
   1337       uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo);
   1338       FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset);
   1339     }
   1340   } else {
   1341     assert(T->isMemberPointerType() && "Should only see member pointers here!");
   1342     assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
   1343            "Should only see pointers to data members here!");
   1344 
   1345     CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset);
   1346     CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T);
   1347 
   1348     // FIXME: hardcodes Itanium member pointer representation!
   1349     llvm::Constant *NegativeOne =
   1350       llvm::ConstantInt::get(CGM.Int8Ty, -1ULL, /*isSigned*/true);
   1351 
   1352     // Fill in the null data member pointer.
   1353     for (CharUnits I = StartIndex; I != EndIndex; ++I)
   1354       Elements[I.getQuantity()] = NegativeOne;
   1355   }
   1356 }
   1357 
   1358 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
   1359                                                llvm::Type *baseType,
   1360                                                const CXXRecordDecl *base);
   1361 
   1362 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
   1363                                         const CXXRecordDecl *record,
   1364                                         bool asCompleteObject) {
   1365   const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
   1366   llvm::StructType *structure =
   1367     (asCompleteObject ? layout.getLLVMType()
   1368                       : layout.getBaseSubobjectLLVMType());
   1369 
   1370   unsigned numElements = structure->getNumElements();
   1371   std::vector<llvm::Constant *> elements(numElements);
   1372 
   1373   // Fill in all the bases.
   1374   for (CXXRecordDecl::base_class_const_iterator
   1375          I = record->bases_begin(), E = record->bases_end(); I != E; ++I) {
   1376     if (I->isVirtual()) {
   1377       // Ignore virtual bases; if we're laying out for a complete
   1378       // object, we'll lay these out later.
   1379       continue;
   1380     }
   1381 
   1382     const CXXRecordDecl *base =
   1383       cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
   1384 
   1385     // Ignore empty bases.
   1386     if (base->isEmpty())
   1387       continue;
   1388 
   1389     unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
   1390     llvm::Type *baseType = structure->getElementType(fieldIndex);
   1391     elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
   1392   }
   1393 
   1394   // Fill in all the fields.
   1395   for (RecordDecl::field_iterator I = record->field_begin(),
   1396          E = record->field_end(); I != E; ++I) {
   1397     const FieldDecl *field = *I;
   1398 
   1399     // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
   1400     // will fill in later.)
   1401     if (!field->isBitField()) {
   1402       unsigned fieldIndex = layout.getLLVMFieldNo(field);
   1403       elements[fieldIndex] = CGM.EmitNullConstant(field->getType());
   1404     }
   1405 
   1406     // For unions, stop after the first named field.
   1407     if (record->isUnion() && field->getDeclName())
   1408       break;
   1409   }
   1410 
   1411   // Fill in the virtual bases, if we're working with the complete object.
   1412   if (asCompleteObject) {
   1413     for (CXXRecordDecl::base_class_const_iterator
   1414            I = record->vbases_begin(), E = record->vbases_end(); I != E; ++I) {
   1415       const CXXRecordDecl *base =
   1416         cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
   1417 
   1418       // Ignore empty bases.
   1419       if (base->isEmpty())
   1420         continue;
   1421 
   1422       unsigned fieldIndex = layout.getVirtualBaseIndex(base);
   1423 
   1424       // We might have already laid this field out.
   1425       if (elements[fieldIndex]) continue;
   1426 
   1427       llvm::Type *baseType = structure->getElementType(fieldIndex);
   1428       elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
   1429     }
   1430   }
   1431 
   1432   // Now go through all other fields and zero them out.
   1433   for (unsigned i = 0; i != numElements; ++i) {
   1434     if (!elements[i])
   1435       elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
   1436   }
   1437 
   1438   return llvm::ConstantStruct::get(structure, elements);
   1439 }
   1440 
   1441 /// Emit the null constant for a base subobject.
   1442 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
   1443                                                llvm::Type *baseType,
   1444                                                const CXXRecordDecl *base) {
   1445   const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
   1446 
   1447   // Just zero out bases that don't have any pointer to data members.
   1448   if (baseLayout.isZeroInitializableAsBase())
   1449     return llvm::Constant::getNullValue(baseType);
   1450 
   1451   // If the base type is a struct, we can just use its null constant.
   1452   if (isa<llvm::StructType>(baseType)) {
   1453     return EmitNullConstant(CGM, base, /*complete*/ false);
   1454   }
   1455 
   1456   // Otherwise, some bases are represented as arrays of i8 if the size
   1457   // of the base is smaller than its corresponding LLVM type.  Figure
   1458   // out how many elements this base array has.
   1459   llvm::ArrayType *baseArrayType = cast<llvm::ArrayType>(baseType);
   1460   unsigned numBaseElements = baseArrayType->getNumElements();
   1461 
   1462   // Fill in null data member pointers.
   1463   SmallVector<llvm::Constant *, 16> baseElements(numBaseElements);
   1464   FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base),
   1465                                baseElements, 0);
   1466 
   1467   // Now go through all other elements and zero them out.
   1468   if (numBaseElements) {
   1469     llvm::Constant *i8_zero = llvm::Constant::getNullValue(CGM.Int8Ty);
   1470     for (unsigned i = 0; i != numBaseElements; ++i) {
   1471       if (!baseElements[i])
   1472         baseElements[i] = i8_zero;
   1473     }
   1474   }
   1475 
   1476   return llvm::ConstantArray::get(baseArrayType, baseElements);
   1477 }
   1478 
   1479 llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
   1480   if (getTypes().isZeroInitializable(T))
   1481     return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
   1482 
   1483   if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
   1484     llvm::ArrayType *ATy =
   1485       cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
   1486 
   1487     QualType ElementTy = CAT->getElementType();
   1488 
   1489     llvm::Constant *Element = EmitNullConstant(ElementTy);
   1490     unsigned NumElements = CAT->getSize().getZExtValue();
   1491 
   1492     if (Element->isNullValue())
   1493       return llvm::ConstantAggregateZero::get(ATy);
   1494 
   1495     SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
   1496     return llvm::ConstantArray::get(ATy, Array);
   1497   }
   1498 
   1499   if (const RecordType *RT = T->getAs<RecordType>()) {
   1500     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
   1501     return ::EmitNullConstant(*this, RD, /*complete object*/ true);
   1502   }
   1503 
   1504   assert(T->isMemberPointerType() && "Should only see member pointers here!");
   1505   assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
   1506          "Should only see pointers to data members here!");
   1507 
   1508   // Itanium C++ ABI 2.3:
   1509   //   A NULL pointer is represented as -1.
   1510   return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
   1511 }
   1512 
   1513 llvm::Constant *
   1514 CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) {
   1515   return ::EmitNullConstant(*this, Record, false);
   1516 }
   1517