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 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 *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
 761     // No need for a DefaultInitExprScope: we don't handle 'this' in a
 762     // constant expression.
 763     return Visit(DIE->getExpr());
 764   }
 765
 766   llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
 767     return Visit(E->GetTemporaryExpr());
 768   }
 769
 770   llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
 771     if (ILE->isStringLiteralInit())
 772       return Visit(ILE->getInit(0));
 773
 774     llvm::ArrayType *AType =
 775         cast<llvm::ArrayType>(ConvertType(ILE->getType()));
 776     llvm::Type *ElemTy = AType->getElementType();
 777     unsigned NumInitElements = ILE->getNumInits();
 778     unsigned NumElements = AType->getNumElements();
 779
 780     // Initialising an array requires us to automatically
 781     // initialise any elements that have not been initialised explicitly
 782     unsigned NumInitableElts = std::min(NumInitElements, NumElements);
 783
 784     // Copy initializer elements.
 785     std::vector<llvm::Constant*> Elts;
 786     Elts.reserve(NumInitableElts + NumElements);
 787
 788     bool RewriteType = false;
 789     for (unsigned i = 0; i < NumInitableElts; ++i) {
 790       Expr *Init = ILE->getInit(i);
 791       llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
 792       if (!C)
 793         return 0;
 794       RewriteType |= (C->getType() != ElemTy);
 795       Elts.push_back(C);
 796     }
 797
 798     // Initialize remaining array elements.
 799     // FIXME: This doesn't handle member pointers correctly!
 800     llvm::Constant *fillC;
 801     if (Expr *filler = ILE->getArrayFiller())
 802       fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF);
 803     else
 804       fillC = llvm::Constant::getNullValue(ElemTy);
 805     if (!fillC)
 806       return 0;
 807     RewriteType |= (fillC->getType() != ElemTy);
 808     Elts.resize(NumElements, fillC);
 809
 810     if (RewriteType) {
 811       // FIXME: Try to avoid packing the array
 812       std::vector<llvm::Type*> Types;
 813       Types.reserve(NumInitableElts + NumElements);
 814       for (unsigned i = 0, e = Elts.size(); i < e; ++i)
 815         Types.push_back(Elts[i]->getType());
 816       llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
 817                                                             Types, true);
 818       return llvm::ConstantStruct::get(SType, Elts);
 819     }
 820
 821     return llvm::ConstantArray::get(AType, Elts);
 822   }
 823
 824   llvm::Constant *EmitRecordInitialization(InitListExpr *ILE) {
 825     return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
 826   }
 827
 828   llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
 829     return CGM.EmitNullConstant(E->getType());
 830   }
 831
 832   llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
 833     if (ILE->getType()->isArrayType())
 834       return EmitArrayInitialization(ILE);
 835
 836     if (ILE->getType()->isRecordType())
 837       return EmitRecordInitialization(ILE);
 838
 839     return 0;
 840   }
 841
 842   llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) {
 843     if (!E->getConstructor()->isTrivial())
 844       return 0;
 845
 846     QualType Ty = E->getType();
 847
 848     // FIXME: We should not have to call getBaseElementType here.
 849     const RecordType *RT =
 850       CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>();
 851     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 852
 853     // If the class doesn't have a trivial destructor, we can't emit it as a
 854     // constant expr.
 855     if (!RD->hasTrivialDestructor())
 856       return 0;
 857
 858     // Only copy and default constructors can be trivial.
 859
 860
 861     if (E->getNumArgs()) {
 862       assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
 863       assert(E->getConstructor()->isCopyOrMoveConstructor() &&
 864              "trivial ctor has argument but isn't a copy/move ctor");
 865
 866       Expr *Arg = E->getArg(0);
 867       assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
 868              "argument to copy ctor is of wrong type");
 869
 870       return Visit(Arg);
 871     }
 872
 873     return CGM.EmitNullConstant(Ty);
 874   }
 875
 876   llvm::Constant *VisitStringLiteral(StringLiteral *E) {
 877     return CGM.GetConstantArrayFromStringLiteral(E);
 878   }
 879
 880   llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 881     // This must be an @encode initializing an array in a static initializer.
 882     // Don't emit it as the address of the string, emit the string data itself
 883     // as an inline array.
 884     std::string Str;
 885     CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
 886     const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
 887
 888     // Resize the string to the right size, adding zeros at the end, or
 889     // truncating as needed.
 890     Str.resize(CAT->getSize().getZExtValue(), '\0');
 891     return llvm::ConstantDataArray::getString(VMContext, Str, false);
 892   }
 893
 894   llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
 895     return Visit(E->getSubExpr());
 896   }
 897
 898   // Utility methods
 899   llvm::Type *ConvertType(QualType T) {
 900     return CGM.getTypes().ConvertType(T);
 901   }
 902
 903 public:
 904   llvm::Constant *EmitLValue(APValue::LValueBase LVBase) {
 905     if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) {
 906       if (Decl->hasAttr<WeakRefAttr>())
 907         return CGM.GetWeakRefReference(Decl);
 908       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
 909         return CGM.GetAddrOfFunction(FD);
 910       if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
 911         // We can never refer to a variable with local storage.
 912         if (!VD->hasLocalStorage()) {
 913           if (VD->isFileVarDecl() || VD->hasExternalStorage())
 914             return CGM.GetAddrOfGlobalVar(VD);
 915           else if (VD->isLocalVarDecl())
 916             return CGM.getStaticLocalDeclAddress(VD);
 917         }
 918       }
 919       return 0;
 920     }
 921
 922     Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>());
 923     switch (E->getStmtClass()) {
 924     default: break;
 925     case Expr::CompoundLiteralExprClass: {
 926       // Note that due to the nature of compound literals, this is guaranteed
 927       // to be the only use of the variable, so we just generate it here.
 928       CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
 929       llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(),
 930                                                CLE->getType(), CGF);
 931       // FIXME: "Leaked" on failure.
 932       if (C)
 933         C = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
 934                                      E->getType().isConstant(CGM.getContext()),
 935                                      llvm::GlobalValue::InternalLinkage,
 936                                      C, ".compoundliteral", 0,
 937                                      llvm::GlobalVariable::NotThreadLocal,
 938                           CGM.getContext().getTargetAddressSpace(E->getType()));
 939       return C;
 940     }
 941     case Expr::StringLiteralClass:
 942       return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
 943     case Expr::ObjCEncodeExprClass:
 944       return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
 945     case Expr::ObjCStringLiteralClass: {
 946       ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
 947       llvm::Constant *C =
 948           CGM.getObjCRuntime().GenerateConstantString(SL->getString());
 949       return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
 950     }
 951     case Expr::PredefinedExprClass: {
 952       unsigned Type = cast<PredefinedExpr>(E)->getIdentType();
 953       if (CGF) {
 954         LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E));
 955         return cast<llvm::Constant>(Res.getAddress());
 956       } else if (Type == PredefinedExpr::PrettyFunction) {
 957         return CGM.GetAddrOfConstantCString("top level", ".tmp");
 958       }
 959
 960       return CGM.GetAddrOfConstantCString("", ".tmp");
 961     }
 962     case Expr::AddrLabelExprClass: {
 963       assert(CGF && "Invalid address of label expression outside function.");
 964       llvm::Constant *Ptr =
 965         CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
 966       return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType()));
 967     }
 968     case Expr::CallExprClass: {
 969       CallExpr* CE = cast<CallExpr>(E);
 970       unsigned builtin = CE->isBuiltinCall();
 971       if (builtin !=
 972             Builtin::BI__builtin___CFStringMakeConstantString &&
 973           builtin !=
 974             Builtin::BI__builtin___NSStringMakeConstantString)
 975         break;
 976       const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
 977       const StringLiteral *Literal = cast<StringLiteral>(Arg);
 978       if (builtin ==
 979             Builtin::BI__builtin___NSStringMakeConstantString) {
 980         return CGM.getObjCRuntime().GenerateConstantString(Literal);
 981       }
 982       // FIXME: need to deal with UCN conversion issues.
 983       return CGM.GetAddrOfConstantCFString(Literal);
 984     }
 985     case Expr::BlockExprClass: {
 986       std::string FunctionName;
 987       if (CGF)
 988         FunctionName = CGF->CurFn->getName();
 989       else
 990         FunctionName = "global";
 991
 992       return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
 993     }
 994     case Expr::CXXTypeidExprClass: {
 995       CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E);
 996       QualType T;
 997       if (Typeid->isTypeOperand())
 998         T = Typeid->getTypeOperand();
 999       else
1000         T = Typeid->getExprOperand()->getType();
1001       return CGM.GetAddrOfRTTIDescriptor(T);
1002     }
1003     case Expr::CXXUuidofExprClass: {
1004       return CGM.GetAddrOfUuidDescriptor(cast<CXXUuidofExpr>(E));
1005     }
1006     }
1007
1008     return 0;
1009   }
1010 };
1011
1012 }  // end anonymous namespace.
1013
1014 llvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D,
1015                                                 CodeGenFunction *CGF) {
1016   // Make a quick check if variable can be default NULL initialized
1017   // and avoid going through rest of code which may do, for c++11,
1018   // initialization of memory to all NULLs.
1019   if (!D.hasLocalStorage()) {
1020     QualType Ty = D.getType();
1021     if (Ty->isArrayType())
1022       Ty = Context.getBaseElementType(Ty);
1023     if (Ty->isRecordType())
1024       if (const CXXConstructExpr *E =
1025           dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
1026         const CXXConstructorDecl *CD = E->getConstructor();
1027         if (CD->isTrivial() && CD->isDefaultConstructor())
1028           return EmitNullConstant(D.getType());
1029       }
1030   }
1031
1032   if (const APValue *Value = D.evaluateValue())
1033     return EmitConstantValueForMemory(*Value, D.getType(), CGF);
1034
1035   // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
1036   // reference is a constant expression, and the reference binds to a temporary,
1037   // then constant initialization is performed. ConstExprEmitter will
1038   // incorrectly emit a prvalue constant in this case, and the calling code
1039   // interprets that as the (pointer) value of the reference, rather than the
1040   // desired value of the referee.
1041   if (D.getType()->isReferenceType())
1042     return 0;
1043
1044   const Expr *E = D.getInit();
1045   assert(E && "No initializer to emit");
1046
1047   llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
1048   if (C && C->getType()->isIntegerTy(1)) {
1049     llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1050     C = llvm::ConstantExpr::getZExt(C, BoolTy);
1051   }
1052   return C;
1053 }
1054
1055 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
1056                                                 QualType DestType,
1057                                                 CodeGenFunction *CGF) {
1058   Expr::EvalResult Result;
1059
1060   bool Success = false;
1061
1062   if (DestType->isReferenceType())
1063     Success = E->EvaluateAsLValue(Result, Context);
1064   else
1065     Success = E->EvaluateAsRValue(Result, Context);
1066
1067   llvm::Constant *C = 0;
1068   if (Success && !Result.HasSideEffects)
1069     C = EmitConstantValue(Result.Val, DestType, CGF);
1070   else
1071     C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
1072
1073   if (C && C->getType()->isIntegerTy(1)) {
1074     llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1075     C = llvm::ConstantExpr::getZExt(C, BoolTy);
1076   }
1077   return C;
1078 }
1079
1080 llvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value,
1081                                                  QualType DestType,
1082                                                  CodeGenFunction *CGF) {
1083   switch (Value.getKind()) {
1084   case APValue::Uninitialized:
1085     llvm_unreachable("Constant expressions should be initialized.");
1086   case APValue::LValue: {
1087     llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType);
1088     llvm::Constant *Offset =
1089       llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity());
1090
1091     llvm::Constant *C;
1092     if (APValue::LValueBase LVBase = Value.getLValueBase()) {
1093       // An array can be represented as an lvalue referring to the base.
1094       if (isa<llvm::ArrayType>(DestTy)) {
1095         assert(Offset->isNullValue() && "offset on array initializer");
1096         return ConstExprEmitter(*this, CGF).Visit(
1097           const_cast<Expr*>(LVBase.get<const Expr*>()));
1098       }
1099
1100       C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase);
1101
1102       // Apply offset if necessary.
1103       if (!Offset->isNullValue()) {
1104         llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Int8PtrTy);
1105         Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset);
1106         C = llvm::ConstantExpr::getBitCast(Casted, C->getType());
1107       }
1108
1109       // Convert to the appropriate type; this could be an lvalue for
1110       // an integer.
1111       if (isa<llvm::PointerType>(DestTy))
1112         return llvm::ConstantExpr::getBitCast(C, DestTy);
1113
1114       return llvm::ConstantExpr::getPtrToInt(C, DestTy);
1115     } else {
1116       C = Offset;
1117
1118       // Convert to the appropriate type; this could be an lvalue for
1119       // an integer.
1120       if (isa<llvm::PointerType>(DestTy))
1121         return llvm::ConstantExpr::getIntToPtr(C, DestTy);
1122
1123       // If the types don't match this should only be a truncate.
1124       if (C->getType() != DestTy)
1125         return llvm::ConstantExpr::getTrunc(C, DestTy);
1126
1127       return C;
1128     }
1129   }
1130   case APValue::Int:
1131     return llvm::ConstantInt::get(VMContext, Value.getInt());
1132   case APValue::ComplexInt: {
1133     llvm::Constant *Complex[2];
1134
1135     Complex[0] = llvm::ConstantInt::get(VMContext,
1136                                         Value.getComplexIntReal());
1137     Complex[1] = llvm::ConstantInt::get(VMContext,
1138                                         Value.getComplexIntImag());
1139
1140     // FIXME: the target may want to specify that this is packed.
1141     llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1142                                                   Complex[1]->getType(),
1143                                                   NULL);
1144     return llvm::ConstantStruct::get(STy, Complex);
1145   }
1146   case APValue::Float: {
1147     const llvm::APFloat &Init = Value.getFloat();
1148     if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf &&
1149          !Context.getLangOpts().NativeHalfType)
1150       return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt());
1151     else
1152       return llvm::ConstantFP::get(VMContext, Init);
1153   }
1154   case APValue::ComplexFloat: {
1155     llvm::Constant *Complex[2];
1156
1157     Complex[0] = llvm::ConstantFP::get(VMContext,
1158                                        Value.getComplexFloatReal());
1159     Complex[1] = llvm::ConstantFP::get(VMContext,
1160                                        Value.getComplexFloatImag());
1161
1162     // FIXME: the target may want to specify that this is packed.
1163     llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1164                                                   Complex[1]->getType(),
1165                                                   NULL);
1166     return llvm::ConstantStruct::get(STy, Complex);
1167   }
1168   case APValue::Vector: {
1169     SmallVector<llvm::Constant *, 4> Inits;
1170     unsigned NumElts = Value.getVectorLength();
1171
1172     for (unsigned i = 0; i != NumElts; ++i) {
1173       const APValue &Elt = Value.getVectorElt(i);
1174       if (Elt.isInt())
1175         Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt()));
1176       else
1177         Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat()));
1178     }
1179     return llvm::ConstantVector::get(Inits);
1180   }
1181   case APValue::AddrLabelDiff: {
1182     const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
1183     const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
1184     llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF);
1185     llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF);
1186
1187     // Compute difference
1188     llvm::Type *ResultType = getTypes().ConvertType(DestType);
1189     LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy);
1190     RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy);
1191     llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
1192
1193     // LLVM is a bit sensitive about the exact format of the
1194     // address-of-label difference; make sure to truncate after
1195     // the subtraction.
1196     return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
1197   }
1198   case APValue::Struct:
1199   case APValue::Union:
1200     return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType);
1201   case APValue::Array: {
1202     const ArrayType *CAT = Context.getAsArrayType(DestType);
1203     unsigned NumElements = Value.getArraySize();
1204     unsigned NumInitElts = Value.getArrayInitializedElts();
1205
1206     std::vector<llvm::Constant*> Elts;
1207     Elts.reserve(NumElements);
1208
1209     // Emit array filler, if there is one.
1210     llvm::Constant *Filler = 0;
1211     if (Value.hasArrayFiller())
1212       Filler = EmitConstantValueForMemory(Value.getArrayFiller(),
1213                                           CAT->getElementType(), CGF);
1214
1215     // Emit initializer elements.
1216     llvm::Type *CommonElementType = 0;
1217     for (unsigned I = 0; I < NumElements; ++I) {
1218       llvm::Constant *C = Filler;
1219       if (I < NumInitElts)
1220         C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I),
1221                                        CAT->getElementType(), CGF);
1222       else
1223         assert(Filler && "Missing filler for implicit elements of initializer");
1224       if (I == 0)
1225         CommonElementType = C->getType();
1226       else if (C->getType() != CommonElementType)
1227         CommonElementType = 0;
1228       Elts.push_back(C);
1229     }
1230
1231     if (!CommonElementType) {
1232       // FIXME: Try to avoid packing the array
1233       std::vector<llvm::Type*> Types;
1234       Types.reserve(NumElements);
1235       for (unsigned i = 0, e = Elts.size(); i < e; ++i)
1236         Types.push_back(Elts[i]->getType());
1237       llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true);
1238       return llvm::ConstantStruct::get(SType, Elts);
1239     }
1240
1241     llvm::ArrayType *AType =
1242       llvm::ArrayType::get(CommonElementType, NumElements);
1243     return llvm::ConstantArray::get(AType, Elts);
1244   }
1245   case APValue::MemberPointer:
1246     return getCXXABI().EmitMemberPointer(Value, DestType);
1247   }
1248   llvm_unreachable("Unknown APValue kind");
1249 }
1250
1251 llvm::Constant *
1252 CodeGenModule::EmitConstantValueForMemory(const APValue &Value,
1253                                           QualType DestType,
1254                                           CodeGenFunction *CGF) {
1255   llvm::Constant *C = EmitConstantValue(Value, DestType, CGF);
1256   if (C->getType()->isIntegerTy(1)) {
1257     llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType);
1258     C = llvm::ConstantExpr::getZExt(C, BoolTy);
1259   }
1260   return C;
1261 }
1262
1263 llvm::Constant *
1264 CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) {
1265   assert(E->isFileScope() && "not a file-scope compound literal expr");
1266   return ConstExprEmitter(*this, 0).EmitLValue(E);
1267 }
1268
1269 llvm::Constant *
1270 CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) {
1271   // Member pointer constants always have a very particular form.
1272   const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
1273   const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
1274
1275   // A member function pointer.
1276   if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
1277     return getCXXABI().EmitMemberPointer(method);
1278
1279   // Otherwise, a member data pointer.
1280   uint64_t fieldOffset = getContext().getFieldOffset(decl);
1281   CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
1282   return getCXXABI().EmitMemberDataPointer(type, chars);
1283 }
1284
1285 static void
1286 FillInNullDataMemberPointers(CodeGenModule &CGM, QualType T,
1287                              SmallVectorImpl<llvm::Constant *> &Elements,
1288                              uint64_t StartOffset) {
1289   assert(StartOffset % CGM.getContext().getCharWidth() == 0 &&
1290          "StartOffset not byte aligned!");
1291
1292   if (CGM.getTypes().isZeroInitializable(T))
1293     return;
1294
1295   if (const ConstantArrayType *CAT =
1296         CGM.getContext().getAsConstantArrayType(T)) {
1297     QualType ElementTy = CAT->getElementType();
1298     uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy);
1299
1300     for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) {
1301       FillInNullDataMemberPointers(CGM, ElementTy, Elements,
1302                                    StartOffset + I * ElementSize);
1303     }
1304   } else if (const RecordType *RT = T->getAs<RecordType>()) {
1305     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1306     const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1307
1308     // Go through all bases and fill in any null pointer to data members.
1309     for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1310          E = RD->bases_end(); I != E; ++I) {
1311       if (I->isVirtual()) {
1312         // Ignore virtual bases.
1313         continue;
1314       }
1315
1316       const CXXRecordDecl *BaseDecl =
1317       cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1318
1319       // Ignore empty bases.
1320       if (BaseDecl->isEmpty())
1321         continue;
1322
1323       // Ignore bases that don't have any pointer to data members.
1324       if (CGM.getTypes().isZeroInitializable(BaseDecl))
1325         continue;
1326
1327       uint64_t BaseOffset =
1328         CGM.getContext().toBits(Layout.getBaseClassOffset(BaseDecl));
1329       FillInNullDataMemberPointers(CGM, I->getType(),
1330                                    Elements, StartOffset + BaseOffset);
1331     }
1332
1333     // Visit all fields.
1334     unsigned FieldNo = 0;
1335     for (RecordDecl::field_iterator I = RD->field_begin(),
1336          E = RD->field_end(); I != E; ++I, ++FieldNo) {
1337       QualType FieldType = I->getType();
1338
1339       if (CGM.getTypes().isZeroInitializable(FieldType))
1340         continue;
1341
1342       uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo);
1343       FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset);
1344     }
1345   } else {
1346     assert(T->isMemberPointerType() && "Should only see member pointers here!");
1347     assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
1348            "Should only see pointers to data members here!");
1349
1350     CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset);
1351     CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T);
1352
1353     // FIXME: hardcodes Itanium member pointer representation!
1354     llvm::Constant *NegativeOne =
1355       llvm::ConstantInt::get(CGM.Int8Ty, -1ULL, /*isSigned*/true);
1356
1357     // Fill in the null data member pointer.
1358     for (CharUnits I = StartIndex; I != EndIndex; ++I)
1359       Elements[I.getQuantity()] = NegativeOne;
1360   }
1361 }
1362
1363 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
1364                                                llvm::Type *baseType,
1365                                                const CXXRecordDecl *base);
1366
1367 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
1368                                         const CXXRecordDecl *record,
1369                                         bool asCompleteObject) {
1370   const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
1371   llvm::StructType *structure =
1372     (asCompleteObject ? layout.getLLVMType()
1373                       : layout.getBaseSubobjectLLVMType());
1374
1375   unsigned numElements = structure->getNumElements();
1376   std::vector<llvm::Constant *> elements(numElements);
1377
1378   // Fill in all the bases.
1379   for (CXXRecordDecl::base_class_const_iterator
1380          I = record->bases_begin(), E = record->bases_end(); I != E; ++I) {
1381     if (I->isVirtual()) {
1382       // Ignore virtual bases; if we're laying out for a complete
1383       // object, we'll lay these out later.
1384       continue;
1385     }
1386
1387     const CXXRecordDecl *base =
1388       cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
1389
1390     // Ignore empty bases.
1391     if (base->isEmpty())
1392       continue;
1393
1394     unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
1395     llvm::Type *baseType = structure->getElementType(fieldIndex);
1396     elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1397   }
1398
1399   // Fill in all the fields.
1400   for (RecordDecl::field_iterator I = record->field_begin(),
1401          E = record->field_end(); I != E; ++I) {
1402     const FieldDecl *field = *I;
1403
1404     // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
1405     // will fill in later.)
1406     if (!field->isBitField()) {
1407       unsigned fieldIndex = layout.getLLVMFieldNo(field);
1408       elements[fieldIndex] = CGM.EmitNullConstant(field->getType());
1409     }
1410
1411     // For unions, stop after the first named field.
1412     if (record->isUnion() && field->getDeclName())
1413       break;
1414   }
1415
1416   // Fill in the virtual bases, if we're working with the complete object.
1417   if (asCompleteObject) {
1418     for (CXXRecordDecl::base_class_const_iterator
1419            I = record->vbases_begin(), E = record->vbases_end(); I != E; ++I) {
1420       const CXXRecordDecl *base =
1421         cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
1422
1423       // Ignore empty bases.
1424       if (base->isEmpty())
1425         continue;
1426
1427       unsigned fieldIndex = layout.getVirtualBaseIndex(base);
1428
1429       // We might have already laid this field out.
1430       if (elements[fieldIndex]) continue;
1431
1432       llvm::Type *baseType = structure->getElementType(fieldIndex);
1433       elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1434     }
1435   }
1436
1437   // Now go through all other fields and zero them out.
1438   for (unsigned i = 0; i != numElements; ++i) {
1439     if (!elements[i])
1440       elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
1441   }
1442
1443   return llvm::ConstantStruct::get(structure, elements);
1444 }
1445
1446 /// Emit the null constant for a base subobject.
1447 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
1448                                                llvm::Type *baseType,
1449                                                const CXXRecordDecl *base) {
1450   const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
1451
1452   // Just zero out bases that don't have any pointer to data members.
1453   if (baseLayout.isZeroInitializableAsBase())
1454     return llvm::Constant::getNullValue(baseType);
1455
1456   // If the base type is a struct, we can just use its null constant.
1457   if (isa<llvm::StructType>(baseType)) {
1458     return EmitNullConstant(CGM, base, /*complete*/ false);
1459   }
1460
1461   // Otherwise, some bases are represented as arrays of i8 if the size
1462   // of the base is smaller than its corresponding LLVM type.  Figure
1463   // out how many elements this base array has.
1464   llvm::ArrayType *baseArrayType = cast<llvm::ArrayType>(baseType);
1465   unsigned numBaseElements = baseArrayType->getNumElements();
1466
1467   // Fill in null data member pointers.
1468   SmallVector<llvm::Constant *, 16> baseElements(numBaseElements);
1469   FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base),
1470                                baseElements, 0);
1471
1472   // Now go through all other elements and zero them out.
1473   if (numBaseElements) {
1474     llvm::Constant *i8_zero = llvm::Constant::getNullValue(CGM.Int8Ty);
1475     for (unsigned i = 0; i != numBaseElements; ++i) {
1476       if (!baseElements[i])
1477         baseElements[i] = i8_zero;
1478     }
1479   }
1480
1481   return llvm::ConstantArray::get(baseArrayType, baseElements);
1482 }
1483
1484 llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
1485   if (getTypes().isZeroInitializable(T))
1486     return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
1487
1488   if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
1489     llvm::ArrayType *ATy =
1490       cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
1491
1492     QualType ElementTy = CAT->getElementType();
1493
1494     llvm::Constant *Element = EmitNullConstant(ElementTy);
1495     unsigned NumElements = CAT->getSize().getZExtValue();
1496
1497     if (Element->isNullValue())
1498       return llvm::ConstantAggregateZero::get(ATy);
1499
1500     SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
1501     return llvm::ConstantArray::get(ATy, Array);
1502   }
1503
1504   if (const RecordType *RT = T->getAs<RecordType>()) {
1505     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1506     return ::EmitNullConstant(*this, RD, /*complete object*/ true);
1507   }
1508
1509   assert(T->isMemberPointerType() && "Should only see member pointers here!");
1510   assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
1511          "Should only see pointers to data members here!");
1512
1513   // Itanium C++ ABI 2.3:
1514   //   A NULL pointer is represented as -1.
1515   return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
1516 }
1517
1518 llvm::Constant *
1519 CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) {
1520   return ::EmitNullConstant(*this, Record, false);
1521 }