1193326Sed//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This contains code to emit Constant Expr nodes as LLVM code. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14193326Sed#include "CodeGenFunction.h" 15212904Sdim#include "CGCXXABI.h" 16193326Sed#include "CGObjCRuntime.h" 17206084Srdivacky#include "CGRecordLayout.h" 18252723Sdim#include "CodeGenModule.h" 19193326Sed#include "clang/AST/APValue.h" 20193326Sed#include "clang/AST/ASTContext.h" 21198092Srdivacky#include "clang/AST/RecordLayout.h" 22193326Sed#include "clang/AST/StmtVisitor.h" 23194179Sed#include "clang/Basic/Builtins.h" 24252723Sdim#include "llvm/IR/Constants.h" 25252723Sdim#include "llvm/IR/DataLayout.h" 26252723Sdim#include "llvm/IR/Function.h" 27252723Sdim#include "llvm/IR/GlobalVariable.h" 28193326Sedusing namespace clang; 29193326Sedusing namespace CodeGen; 30193326Sed 31207619Srdivacky//===----------------------------------------------------------------------===// 32207619Srdivacky// ConstStructBuilder 33207619Srdivacky//===----------------------------------------------------------------------===// 34207619Srdivacky 35207619Srdivackynamespace { 36199990Srdivackyclass ConstStructBuilder { 37198092Srdivacky CodeGenModule &CGM; 38198092Srdivacky CodeGenFunction *CGF; 39198092Srdivacky 40198092Srdivacky bool Packed; 41221345Sdim CharUnits NextFieldOffsetInChars; 42221345Sdim CharUnits LLVMStructAlignment; 43235633Sdim SmallVector<llvm::Constant *, 32> Elements; 44207619Srdivackypublic: 45207619Srdivacky static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 46207619Srdivacky InitListExpr *ILE); 47235633Sdim static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 48235633Sdim const APValue &Value, QualType ValTy); 49235633Sdim 50235633Sdimprivate: 51198092Srdivacky ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF) 52221345Sdim : CGM(CGM), CGF(CGF), Packed(false), 53221345Sdim NextFieldOffsetInChars(CharUnits::Zero()), 54221345Sdim LLVMStructAlignment(CharUnits::One()) { } 55198092Srdivacky 56235633Sdim void AppendField(const FieldDecl *Field, uint64_t FieldOffset, 57207619Srdivacky llvm::Constant *InitExpr); 58198092Srdivacky 59235633Sdim void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst); 60235633Sdim 61210299Sed void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, 62210299Sed llvm::ConstantInt *InitExpr); 63198092Srdivacky 64221345Sdim void AppendPadding(CharUnits PadSize); 65198092Srdivacky 66221345Sdim void AppendTailPadding(CharUnits RecordSize); 67198092Srdivacky 68207619Srdivacky void ConvertStructToPacked(); 69235633Sdim 70207619Srdivacky bool Build(InitListExpr *ILE); 71235633Sdim void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase, 72263509Sdim const CXXRecordDecl *VTableClass, CharUnits BaseOffset); 73235633Sdim llvm::Constant *Finalize(QualType Ty); 74198092Srdivacky 75221345Sdim CharUnits getAlignment(const llvm::Constant *C) const { 76221345Sdim if (Packed) return CharUnits::One(); 77221345Sdim return CharUnits::fromQuantity( 78245431Sdim CGM.getDataLayout().getABITypeAlignment(C->getType())); 79207619Srdivacky } 80198092Srdivacky 81221345Sdim CharUnits getSizeInChars(const llvm::Constant *C) const { 82221345Sdim return CharUnits::fromQuantity( 83245431Sdim CGM.getDataLayout().getTypeAllocSize(C->getType())); 84207619Srdivacky } 85207619Srdivacky}; 86198092Srdivacky 87235633Sdimvoid ConstStructBuilder:: 88207619SrdivackyAppendField(const FieldDecl *Field, uint64_t FieldOffset, 89207619Srdivacky llvm::Constant *InitCst) { 90221345Sdim const ASTContext &Context = CGM.getContext(); 91221345Sdim 92221345Sdim CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset); 93221345Sdim 94235633Sdim AppendBytes(FieldOffsetInChars, InitCst); 95235633Sdim} 96235633Sdim 97235633Sdimvoid ConstStructBuilder:: 98235633SdimAppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) { 99235633Sdim 100221345Sdim assert(NextFieldOffsetInChars <= FieldOffsetInChars 101207619Srdivacky && "Field offset mismatch!"); 102198092Srdivacky 103221345Sdim CharUnits FieldAlignment = getAlignment(InitCst); 104198092Srdivacky 105207619Srdivacky // Round up the field offset to the alignment of the field type. 106221345Sdim CharUnits AlignedNextFieldOffsetInChars = 107221345Sdim NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment); 108198092Srdivacky 109221345Sdim if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) { 110207619Srdivacky assert(!Packed && "Alignment is wrong even with a packed struct!"); 111198092Srdivacky 112207619Srdivacky // Convert the struct to a packed struct. 113207619Srdivacky ConvertStructToPacked(); 114235633Sdim 115221345Sdim AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; 116207619Srdivacky } 117198092Srdivacky 118221345Sdim if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) { 119207619Srdivacky // We need to append padding. 120235633Sdim AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars); 121198092Srdivacky 122221345Sdim assert(NextFieldOffsetInChars == FieldOffsetInChars && 123207619Srdivacky "Did not add enough padding!"); 124198092Srdivacky 125221345Sdim AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; 126207619Srdivacky } 127198092Srdivacky 128207619Srdivacky // Add the field. 129207619Srdivacky Elements.push_back(InitCst); 130221345Sdim NextFieldOffsetInChars = AlignedNextFieldOffsetInChars + 131221345Sdim getSizeInChars(InitCst); 132235633Sdim 133207619Srdivacky if (Packed) 134235633Sdim assert(LLVMStructAlignment == CharUnits::One() && 135221345Sdim "Packed struct not byte-aligned!"); 136207619Srdivacky else 137207619Srdivacky LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment); 138207619Srdivacky} 139198092Srdivacky 140210299Sedvoid ConstStructBuilder::AppendBitField(const FieldDecl *Field, 141210299Sed uint64_t FieldOffset, 142210299Sed llvm::ConstantInt *CI) { 143221345Sdim const ASTContext &Context = CGM.getContext(); 144221345Sdim const uint64_t CharWidth = Context.getCharWidth(); 145221345Sdim uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 146221345Sdim if (FieldOffset > NextFieldOffsetInBits) { 147207619Srdivacky // We need to add padding. 148221345Sdim CharUnits PadSize = Context.toCharUnitsFromBits( 149221345Sdim llvm::RoundUpToAlignment(FieldOffset - NextFieldOffsetInBits, 150226890Sdim Context.getTargetInfo().getCharAlign())); 151198092Srdivacky 152221345Sdim AppendPadding(PadSize); 153207619Srdivacky } 154198092Srdivacky 155226890Sdim uint64_t FieldSize = Field->getBitWidthValue(Context); 156198092Srdivacky 157207619Srdivacky llvm::APInt FieldValue = CI->getValue(); 158198092Srdivacky 159207619Srdivacky // Promote the size of FieldValue if necessary 160207619Srdivacky // FIXME: This should never occur, but currently it can because initializer 161207619Srdivacky // constants are cast to bool, and because clang is not enforcing bitfield 162207619Srdivacky // width limits. 163207619Srdivacky if (FieldSize > FieldValue.getBitWidth()) 164218893Sdim FieldValue = FieldValue.zext(FieldSize); 165198092Srdivacky 166207619Srdivacky // Truncate the size of FieldValue to the bit field size. 167207619Srdivacky if (FieldSize < FieldValue.getBitWidth()) 168218893Sdim FieldValue = FieldValue.trunc(FieldSize); 169198092Srdivacky 170221345Sdim NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 171221345Sdim if (FieldOffset < NextFieldOffsetInBits) { 172207619Srdivacky // Either part of the field or the entire field can go into the previous 173207619Srdivacky // byte. 174207619Srdivacky assert(!Elements.empty() && "Elements can't be empty!"); 175198092Srdivacky 176221345Sdim unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset; 177198092Srdivacky 178207619Srdivacky bool FitsCompletelyInPreviousByte = 179207619Srdivacky BitsInPreviousByte >= FieldValue.getBitWidth(); 180200583Srdivacky 181207619Srdivacky llvm::APInt Tmp = FieldValue; 182198092Srdivacky 183207619Srdivacky if (!FitsCompletelyInPreviousByte) { 184207619Srdivacky unsigned NewFieldWidth = FieldSize - BitsInPreviousByte; 185198092Srdivacky 186245431Sdim if (CGM.getDataLayout().isBigEndian()) { 187207619Srdivacky Tmp = Tmp.lshr(NewFieldWidth); 188218893Sdim Tmp = Tmp.trunc(BitsInPreviousByte); 189198092Srdivacky 190207619Srdivacky // We want the remaining high bits. 191218893Sdim FieldValue = FieldValue.trunc(NewFieldWidth); 192198092Srdivacky } else { 193218893Sdim Tmp = Tmp.trunc(BitsInPreviousByte); 194198092Srdivacky 195207619Srdivacky // We want the remaining low bits. 196207619Srdivacky FieldValue = FieldValue.lshr(BitsInPreviousByte); 197218893Sdim FieldValue = FieldValue.trunc(NewFieldWidth); 198198092Srdivacky } 199207619Srdivacky } 200198092Srdivacky 201221345Sdim Tmp = Tmp.zext(CharWidth); 202245431Sdim if (CGM.getDataLayout().isBigEndian()) { 203207619Srdivacky if (FitsCompletelyInPreviousByte) 204207619Srdivacky Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth()); 205207619Srdivacky } else { 206221345Sdim Tmp = Tmp.shl(CharWidth - BitsInPreviousByte); 207198092Srdivacky } 208198092Srdivacky 209210299Sed // 'or' in the bits that go into the previous byte. 210210299Sed llvm::Value *LastElt = Elements.back(); 211210299Sed if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt)) 212207619Srdivacky Tmp |= Val->getValue(); 213210299Sed else { 214210299Sed assert(isa<llvm::UndefValue>(LastElt)); 215210299Sed // If there is an undef field that we're adding to, it can either be a 216210299Sed // scalar undef (in which case, we just replace it with our field) or it 217210299Sed // is an array. If it is an array, we have to pull one byte off the 218210299Sed // array so that the other undef bytes stay around. 219210299Sed if (!isa<llvm::IntegerType>(LastElt->getType())) { 220210299Sed // The undef padding will be a multibyte array, create a new smaller 221210299Sed // padding and then an hole for our i8 to get plopped into. 222210299Sed assert(isa<llvm::ArrayType>(LastElt->getType()) && 223210299Sed "Expected array padding of undefs"); 224226890Sdim llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType()); 225221345Sdim assert(AT->getElementType()->isIntegerTy(CharWidth) && 226210299Sed AT->getNumElements() != 0 && 227210299Sed "Expected non-empty array padding of undefs"); 228210299Sed 229210299Sed // Remove the padding array. 230221345Sdim NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements()); 231210299Sed Elements.pop_back(); 232210299Sed 233210299Sed // Add the padding back in two chunks. 234221345Sdim AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1)); 235221345Sdim AppendPadding(CharUnits::One()); 236210299Sed assert(isa<llvm::UndefValue>(Elements.back()) && 237221345Sdim Elements.back()->getType()->isIntegerTy(CharWidth) && 238210299Sed "Padding addition didn't work right"); 239210299Sed } 240210299Sed } 241198092Srdivacky 242207619Srdivacky Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp); 243198092Srdivacky 244207619Srdivacky if (FitsCompletelyInPreviousByte) 245210299Sed return; 246198092Srdivacky } 247198092Srdivacky 248221345Sdim while (FieldValue.getBitWidth() > CharWidth) { 249207619Srdivacky llvm::APInt Tmp; 250198092Srdivacky 251245431Sdim if (CGM.getDataLayout().isBigEndian()) { 252207619Srdivacky // We want the high bits. 253221345Sdim Tmp = 254221345Sdim FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth); 255207619Srdivacky } else { 256207619Srdivacky // We want the low bits. 257221345Sdim Tmp = FieldValue.trunc(CharWidth); 258198092Srdivacky 259221345Sdim FieldValue = FieldValue.lshr(CharWidth); 260207619Srdivacky } 261198092Srdivacky 262207619Srdivacky Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp)); 263221345Sdim ++NextFieldOffsetInChars; 264207619Srdivacky 265221345Sdim FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth); 266198092Srdivacky } 267198092Srdivacky 268207619Srdivacky assert(FieldValue.getBitWidth() > 0 && 269207619Srdivacky "Should have at least one bit left!"); 270221345Sdim assert(FieldValue.getBitWidth() <= CharWidth && 271207619Srdivacky "Should not have more than a byte left!"); 272198092Srdivacky 273221345Sdim if (FieldValue.getBitWidth() < CharWidth) { 274245431Sdim if (CGM.getDataLayout().isBigEndian()) { 275207619Srdivacky unsigned BitWidth = FieldValue.getBitWidth(); 276198092Srdivacky 277221345Sdim FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth); 278207619Srdivacky } else 279221345Sdim FieldValue = FieldValue.zext(CharWidth); 280198092Srdivacky } 281198092Srdivacky 282207619Srdivacky // Append the last element. 283207619Srdivacky Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), 284207619Srdivacky FieldValue)); 285221345Sdim ++NextFieldOffsetInChars; 286207619Srdivacky} 287198092Srdivacky 288221345Sdimvoid ConstStructBuilder::AppendPadding(CharUnits PadSize) { 289221345Sdim if (PadSize.isZero()) 290207619Srdivacky return; 291198092Srdivacky 292235633Sdim llvm::Type *Ty = CGM.Int8Ty; 293221345Sdim if (PadSize > CharUnits::One()) 294221345Sdim Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity()); 295198092Srdivacky 296207619Srdivacky llvm::Constant *C = llvm::UndefValue::get(Ty); 297207619Srdivacky Elements.push_back(C); 298221345Sdim assert(getAlignment(C) == CharUnits::One() && 299221345Sdim "Padding must have 1 byte alignment!"); 300198092Srdivacky 301221345Sdim NextFieldOffsetInChars += getSizeInChars(C); 302207619Srdivacky} 303198092Srdivacky 304221345Sdimvoid ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) { 305221345Sdim assert(NextFieldOffsetInChars <= RecordSize && 306221345Sdim "Size mismatch!"); 307198092Srdivacky 308221345Sdim AppendPadding(RecordSize - NextFieldOffsetInChars); 309207619Srdivacky} 310198092Srdivacky 311207619Srdivackyvoid ConstStructBuilder::ConvertStructToPacked() { 312235633Sdim SmallVector<llvm::Constant *, 16> PackedElements; 313221345Sdim CharUnits ElementOffsetInChars = CharUnits::Zero(); 314198092Srdivacky 315207619Srdivacky for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 316207619Srdivacky llvm::Constant *C = Elements[i]; 317198092Srdivacky 318221345Sdim CharUnits ElementAlign = CharUnits::fromQuantity( 319245431Sdim CGM.getDataLayout().getABITypeAlignment(C->getType())); 320221345Sdim CharUnits AlignedElementOffsetInChars = 321221345Sdim ElementOffsetInChars.RoundUpToAlignment(ElementAlign); 322198092Srdivacky 323221345Sdim if (AlignedElementOffsetInChars > ElementOffsetInChars) { 324207619Srdivacky // We need some padding. 325221345Sdim CharUnits NumChars = 326221345Sdim AlignedElementOffsetInChars - ElementOffsetInChars; 327198092Srdivacky 328235633Sdim llvm::Type *Ty = CGM.Int8Ty; 329221345Sdim if (NumChars > CharUnits::One()) 330221345Sdim Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity()); 331207619Srdivacky 332207619Srdivacky llvm::Constant *Padding = llvm::UndefValue::get(Ty); 333207619Srdivacky PackedElements.push_back(Padding); 334221345Sdim ElementOffsetInChars += getSizeInChars(Padding); 335198092Srdivacky } 336198092Srdivacky 337207619Srdivacky PackedElements.push_back(C); 338221345Sdim ElementOffsetInChars += getSizeInChars(C); 339207619Srdivacky } 340198092Srdivacky 341221345Sdim assert(ElementOffsetInChars == NextFieldOffsetInChars && 342207619Srdivacky "Packing the struct changed its size!"); 343198092Srdivacky 344235633Sdim Elements.swap(PackedElements); 345221345Sdim LLVMStructAlignment = CharUnits::One(); 346207619Srdivacky Packed = true; 347207619Srdivacky} 348207619Srdivacky 349207619Srdivackybool ConstStructBuilder::Build(InitListExpr *ILE) { 350207619Srdivacky RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 351207619Srdivacky const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 352198092Srdivacky 353207619Srdivacky unsigned FieldNo = 0; 354207619Srdivacky unsigned ElementNo = 0; 355221345Sdim 356207619Srdivacky for (RecordDecl::field_iterator Field = RD->field_begin(), 357207619Srdivacky FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 358207619Srdivacky // If this is a union, skip all the fields that aren't being initialized. 359207619Srdivacky if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 360207619Srdivacky continue; 361207619Srdivacky 362207619Srdivacky // Don't emit anonymous bitfields, they just affect layout. 363263509Sdim if (Field->isUnnamedBitfield()) 364207619Srdivacky continue; 365207619Srdivacky 366207619Srdivacky // Get the initializer. A struct can include fields without initializers, 367207619Srdivacky // we just use explicit null values for them. 368207619Srdivacky llvm::Constant *EltInit; 369207619Srdivacky if (ElementNo < ILE->getNumInits()) 370207619Srdivacky EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++), 371207619Srdivacky Field->getType(), CGF); 372207619Srdivacky else 373207619Srdivacky EltInit = CGM.EmitNullConstant(Field->getType()); 374212904Sdim 375212904Sdim if (!EltInit) 376212904Sdim return false; 377207619Srdivacky 378207619Srdivacky if (!Field->isBitField()) { 379207619Srdivacky // Handle non-bitfield members. 380235633Sdim AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit); 381207619Srdivacky } else { 382207619Srdivacky // Otherwise we have a bitfield. 383210299Sed AppendBitField(*Field, Layout.getFieldOffset(FieldNo), 384210299Sed cast<llvm::ConstantInt>(EltInit)); 385198092Srdivacky } 386207619Srdivacky } 387198092Srdivacky 388235633Sdim return true; 389235633Sdim} 390235633Sdim 391235633Sdimnamespace { 392235633Sdimstruct BaseInfo { 393235633Sdim BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index) 394235633Sdim : Decl(Decl), Offset(Offset), Index(Index) { 395235633Sdim } 396235633Sdim 397235633Sdim const CXXRecordDecl *Decl; 398235633Sdim CharUnits Offset; 399235633Sdim unsigned Index; 400235633Sdim 401235633Sdim bool operator<(const BaseInfo &O) const { return Offset < O.Offset; } 402235633Sdim}; 403235633Sdim} 404235633Sdim 405235633Sdimvoid ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD, 406263509Sdim bool IsPrimaryBase, 407235633Sdim const CXXRecordDecl *VTableClass, 408235633Sdim CharUnits Offset) { 409235633Sdim const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 410235633Sdim 411235633Sdim if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) { 412235633Sdim // Add a vtable pointer, if we need one and it hasn't already been added. 413263509Sdim if (CD->isDynamicClass() && !IsPrimaryBase) { 414263509Sdim llvm::Constant *VTableAddressPoint = 415263509Sdim CGM.getCXXABI().getVTableAddressPointForConstExpr( 416263509Sdim BaseSubobject(CD, Offset), VTableClass); 417263509Sdim AppendBytes(Offset, VTableAddressPoint); 418263509Sdim } 419235633Sdim 420235633Sdim // Accumulate and sort bases, in order to visit them in address order, which 421235633Sdim // may not be the same as declaration order. 422252723Sdim SmallVector<BaseInfo, 8> Bases; 423235633Sdim Bases.reserve(CD->getNumBases()); 424235633Sdim unsigned BaseNo = 0; 425235633Sdim for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(), 426235633Sdim BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) { 427235633Sdim assert(!Base->isVirtual() && "should not have virtual bases here"); 428235633Sdim const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl(); 429235633Sdim CharUnits BaseOffset = Layout.getBaseClassOffset(BD); 430235633Sdim Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo)); 431235633Sdim } 432235633Sdim std::stable_sort(Bases.begin(), Bases.end()); 433235633Sdim 434235633Sdim for (unsigned I = 0, N = Bases.size(); I != N; ++I) { 435235633Sdim BaseInfo &Base = Bases[I]; 436235633Sdim 437235633Sdim bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl; 438235633Sdim Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase, 439263509Sdim VTableClass, Offset + Base.Offset); 440235633Sdim } 441235633Sdim } 442235633Sdim 443235633Sdim unsigned FieldNo = 0; 444235633Sdim uint64_t OffsetBits = CGM.getContext().toBits(Offset); 445235633Sdim 446235633Sdim for (RecordDecl::field_iterator Field = RD->field_begin(), 447235633Sdim FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 448235633Sdim // If this is a union, skip all the fields that aren't being initialized. 449235633Sdim if (RD->isUnion() && Val.getUnionField() != *Field) 450235633Sdim continue; 451235633Sdim 452235633Sdim // Don't emit anonymous bitfields, they just affect layout. 453263509Sdim if (Field->isUnnamedBitfield()) 454235633Sdim continue; 455235633Sdim 456235633Sdim // Emit the value of the initializer. 457235633Sdim const APValue &FieldValue = 458235633Sdim RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo); 459235633Sdim llvm::Constant *EltInit = 460235633Sdim CGM.EmitConstantValueForMemory(FieldValue, Field->getType(), CGF); 461235633Sdim assert(EltInit && "EmitConstantValue can't fail"); 462235633Sdim 463235633Sdim if (!Field->isBitField()) { 464235633Sdim // Handle non-bitfield members. 465235633Sdim AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit); 466235633Sdim } else { 467235633Sdim // Otherwise we have a bitfield. 468235633Sdim AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, 469235633Sdim cast<llvm::ConstantInt>(EltInit)); 470235633Sdim } 471235633Sdim } 472235633Sdim} 473235633Sdim 474235633Sdimllvm::Constant *ConstStructBuilder::Finalize(QualType Ty) { 475235633Sdim RecordDecl *RD = Ty->getAs<RecordType>()->getDecl(); 476235633Sdim const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 477235633Sdim 478221345Sdim CharUnits LayoutSizeInChars = Layout.getSize(); 479198092Srdivacky 480221345Sdim if (NextFieldOffsetInChars > LayoutSizeInChars) { 481207619Srdivacky // If the struct is bigger than the size of the record type, 482207619Srdivacky // we must have a flexible array member at the end. 483207619Srdivacky assert(RD->hasFlexibleArrayMember() && 484207619Srdivacky "Must have flexible array member if struct is bigger than type!"); 485235633Sdim 486207619Srdivacky // No tail padding is necessary. 487235633Sdim } else { 488235633Sdim // Append tail padding if necessary. 489235633Sdim AppendTailPadding(LayoutSizeInChars); 490198092Srdivacky 491235633Sdim CharUnits LLVMSizeInChars = 492235633Sdim NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment); 493198092Srdivacky 494235633Sdim // Check if we need to convert the struct to a packed struct. 495235633Sdim if (NextFieldOffsetInChars <= LayoutSizeInChars && 496235633Sdim LLVMSizeInChars > LayoutSizeInChars) { 497235633Sdim assert(!Packed && "Size mismatch!"); 498198092Srdivacky 499235633Sdim ConvertStructToPacked(); 500235633Sdim assert(NextFieldOffsetInChars <= LayoutSizeInChars && 501235633Sdim "Converting to packed did not help!"); 502235633Sdim } 503198092Srdivacky 504235633Sdim assert(LayoutSizeInChars == NextFieldOffsetInChars && 505235633Sdim "Tail padding mismatch!"); 506235633Sdim } 507198092Srdivacky 508224145Sdim // Pick the type to use. If the type is layout identical to the ConvertType 509224145Sdim // type then use it, otherwise use whatever the builder produced for us. 510226890Sdim llvm::StructType *STy = 511224145Sdim llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(), 512235633Sdim Elements, Packed); 513235633Sdim llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty); 514235633Sdim if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) { 515235633Sdim if (ValSTy->isLayoutIdentical(STy)) 516235633Sdim STy = ValSTy; 517224145Sdim } 518235633Sdim 519235633Sdim llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements); 520235633Sdim 521235633Sdim assert(NextFieldOffsetInChars.RoundUpToAlignment(getAlignment(Result)) == 522235633Sdim getSizeInChars(Result) && "Size mismatch!"); 523235633Sdim 524207619Srdivacky return Result; 525207619Srdivacky} 526198092Srdivacky 527235633Sdimllvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, 528235633Sdim CodeGenFunction *CGF, 529235633Sdim InitListExpr *ILE) { 530235633Sdim ConstStructBuilder Builder(CGM, CGF); 531235633Sdim 532235633Sdim if (!Builder.Build(ILE)) 533235633Sdim return 0; 534235633Sdim 535235633Sdim return Builder.Finalize(ILE->getType()); 536235633Sdim} 537235633Sdim 538235633Sdimllvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, 539235633Sdim CodeGenFunction *CGF, 540235633Sdim const APValue &Val, 541235633Sdim QualType ValTy) { 542235633Sdim ConstStructBuilder Builder(CGM, CGF); 543235633Sdim 544235633Sdim const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl(); 545235633Sdim const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD); 546263509Sdim Builder.Build(Val, RD, false, CD, CharUnits::Zero()); 547235633Sdim 548235633Sdim return Builder.Finalize(ValTy); 549235633Sdim} 550235633Sdim 551235633Sdim 552207619Srdivacky//===----------------------------------------------------------------------===// 553207619Srdivacky// ConstExprEmitter 554207619Srdivacky//===----------------------------------------------------------------------===// 555235633Sdim 556235633Sdim/// This class only needs to handle two cases: 557235633Sdim/// 1) Literals (this is used by APValue emission to emit literals). 558235633Sdim/// 2) Arrays, structs and unions (outside C++11 mode, we don't currently 559235633Sdim/// constant fold these types). 560199990Srdivackyclass ConstExprEmitter : 561193326Sed public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 562193326Sed CodeGenModule &CGM; 563193326Sed CodeGenFunction *CGF; 564198092Srdivacky llvm::LLVMContext &VMContext; 565193326Sedpublic: 566193326Sed ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 567198092Srdivacky : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) { 568193326Sed } 569198092Srdivacky 570193326Sed //===--------------------------------------------------------------------===// 571193326Sed // Visitor Methods 572193326Sed //===--------------------------------------------------------------------===// 573198092Srdivacky 574193326Sed llvm::Constant *VisitStmt(Stmt *S) { 575193326Sed return 0; 576193326Sed } 577198092Srdivacky 578198092Srdivacky llvm::Constant *VisitParenExpr(ParenExpr *PE) { 579198092Srdivacky return Visit(PE->getSubExpr()); 580193326Sed } 581198092Srdivacky 582224145Sdim llvm::Constant * 583224145Sdim VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 584224145Sdim return Visit(PE->getReplacement()); 585224145Sdim } 586224145Sdim 587221345Sdim llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 588221345Sdim return Visit(GE->getResultExpr()); 589221345Sdim } 590221345Sdim 591263509Sdim llvm::Constant *VisitChooseExpr(ChooseExpr *CE) { 592263509Sdim return Visit(CE->getChosenSubExpr()); 593263509Sdim } 594263509Sdim 595193326Sed llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 596193326Sed return Visit(E->getInitializer()); 597193326Sed } 598218893Sdim 599193326Sed llvm::Constant *VisitCastExpr(CastExpr* E) { 600221345Sdim Expr *subExpr = E->getSubExpr(); 601221345Sdim llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF); 602221345Sdim if (!C) return 0; 603221345Sdim 604226890Sdim llvm::Type *destType = ConvertType(E->getType()); 605221345Sdim 606198092Srdivacky switch (E->getCastKind()) { 607212904Sdim case CK_ToUnion: { 608198092Srdivacky // GCC cast to union extension 609198092Srdivacky assert(E->getType()->isUnionType() && 610198092Srdivacky "Destination type is not union type!"); 611198092Srdivacky 612198092Srdivacky // Build a struct with the union sub-element as the first member, 613198092Srdivacky // and padded to the appropriate size 614235633Sdim SmallVector<llvm::Constant*, 2> Elts; 615235633Sdim SmallVector<llvm::Type*, 2> Types; 616198092Srdivacky Elts.push_back(C); 617198092Srdivacky Types.push_back(C->getType()); 618245431Sdim unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType()); 619245431Sdim unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destType); 620198092Srdivacky 621198092Srdivacky assert(CurSize <= TotalSize && "Union size mismatch!"); 622198092Srdivacky if (unsigned NumPadBytes = TotalSize - CurSize) { 623235633Sdim llvm::Type *Ty = CGM.Int8Ty; 624198092Srdivacky if (NumPadBytes > 1) 625198092Srdivacky Ty = llvm::ArrayType::get(Ty, NumPadBytes); 626198092Srdivacky 627198893Srdivacky Elts.push_back(llvm::UndefValue::get(Ty)); 628198092Srdivacky Types.push_back(Ty); 629198092Srdivacky } 630198092Srdivacky 631198092Srdivacky llvm::StructType* STy = 632198092Srdivacky llvm::StructType::get(C->getType()->getContext(), Types, false); 633198092Srdivacky return llvm::ConstantStruct::get(STy, Elts); 634193326Sed } 635198092Srdivacky 636221345Sdim case CK_LValueToRValue: 637235633Sdim case CK_AtomicToNonAtomic: 638235633Sdim case CK_NonAtomicToAtomic: 639221345Sdim case CK_NoOp: 640263509Sdim case CK_ConstructorConversion: 641221345Sdim return C; 642198398Srdivacky 643221345Sdim case CK_Dependent: llvm_unreachable("saw dependent cast!"); 644221345Sdim 645245431Sdim case CK_BuiltinFnToFnPtr: 646245431Sdim llvm_unreachable("builtin functions are handled elsewhere"); 647245431Sdim 648235633Sdim case CK_ReinterpretMemberPointer: 649235633Sdim case CK_DerivedToBaseMemberPointer: 650235633Sdim case CK_BaseToDerivedMemberPointer: 651235633Sdim return CGM.getCXXABI().EmitMemberPointerConversion(E, C); 652235633Sdim 653221345Sdim // These will never be supported. 654221345Sdim case CK_ObjCObjectLValueCast: 655226890Sdim case CK_ARCProduceObject: 656226890Sdim case CK_ARCConsumeObject: 657226890Sdim case CK_ARCReclaimReturnedObject: 658226890Sdim case CK_ARCExtendBlockObject: 659235633Sdim case CK_CopyAndAutoreleaseBlockObject: 660198092Srdivacky return 0; 661221345Sdim 662235633Sdim // These don't need to be handled here because Evaluate knows how to 663235633Sdim // evaluate them in the cases where they can be folded. 664235633Sdim case CK_BitCast: 665235633Sdim case CK_ToVoid: 666235633Sdim case CK_Dynamic: 667235633Sdim case CK_LValueBitCast: 668235633Sdim case CK_NullToMemberPointer: 669221345Sdim case CK_UserDefinedConversion: 670235633Sdim case CK_CPointerToObjCPointerCast: 671235633Sdim case CK_BlockPointerToObjCPointerCast: 672235633Sdim case CK_AnyPointerToBlockPointerCast: 673221345Sdim case CK_ArrayToPointerDecay: 674221345Sdim case CK_FunctionToPointerDecay: 675221345Sdim case CK_BaseToDerived: 676221345Sdim case CK_DerivedToBase: 677221345Sdim case CK_UncheckedDerivedToBase: 678221345Sdim case CK_MemberPointerToBoolean: 679221345Sdim case CK_VectorSplat: 680221345Sdim case CK_FloatingRealToComplex: 681221345Sdim case CK_FloatingComplexToReal: 682221345Sdim case CK_FloatingComplexToBoolean: 683221345Sdim case CK_FloatingComplexCast: 684221345Sdim case CK_FloatingComplexToIntegralComplex: 685221345Sdim case CK_IntegralRealToComplex: 686221345Sdim case CK_IntegralComplexToReal: 687221345Sdim case CK_IntegralComplexToBoolean: 688221345Sdim case CK_IntegralComplexCast: 689221345Sdim case CK_IntegralComplexToFloatingComplex: 690221345Sdim case CK_PointerToIntegral: 691221345Sdim case CK_PointerToBoolean: 692221345Sdim case CK_NullToPointer: 693235633Sdim case CK_IntegralCast: 694235633Sdim case CK_IntegralToPointer: 695221345Sdim case CK_IntegralToBoolean: 696221345Sdim case CK_IntegralToFloating: 697221345Sdim case CK_FloatingToIntegral: 698221345Sdim case CK_FloatingToBoolean: 699221345Sdim case CK_FloatingCast: 700252723Sdim case CK_ZeroToOCLEvent: 701235633Sdim return 0; 702221345Sdim } 703221345Sdim llvm_unreachable("Invalid CastKind"); 704193326Sed } 705193326Sed 706193326Sed llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 707193326Sed return Visit(DAE->getExpr()); 708193326Sed } 709193326Sed 710252723Sdim llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 711252723Sdim // No need for a DefaultInitExprScope: we don't handle 'this' in a 712252723Sdim // constant expression. 713252723Sdim return Visit(DIE->getExpr()); 714252723Sdim } 715252723Sdim 716224145Sdim llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 717224145Sdim return Visit(E->GetTemporaryExpr()); 718224145Sdim } 719224145Sdim 720193326Sed llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 721235633Sdim if (ILE->isStringLiteralInit()) 722207619Srdivacky return Visit(ILE->getInit(0)); 723207619Srdivacky 724226890Sdim llvm::ArrayType *AType = 725193326Sed cast<llvm::ArrayType>(ConvertType(ILE->getType())); 726226890Sdim llvm::Type *ElemTy = AType->getElementType(); 727235633Sdim unsigned NumInitElements = ILE->getNumInits(); 728193326Sed unsigned NumElements = AType->getNumElements(); 729193326Sed 730198092Srdivacky // Initialising an array requires us to automatically 731193326Sed // initialise any elements that have not been initialised explicitly 732193326Sed unsigned NumInitableElts = std::min(NumInitElements, NumElements); 733193326Sed 734193326Sed // Copy initializer elements. 735235633Sdim std::vector<llvm::Constant*> Elts; 736235633Sdim Elts.reserve(NumInitableElts + NumElements); 737235633Sdim 738193326Sed bool RewriteType = false; 739235633Sdim for (unsigned i = 0; i < NumInitableElts; ++i) { 740193326Sed Expr *Init = ILE->getInit(i); 741193326Sed llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 742193326Sed if (!C) 743193326Sed return 0; 744193326Sed RewriteType |= (C->getType() != ElemTy); 745193326Sed Elts.push_back(C); 746193326Sed } 747193326Sed 748193326Sed // Initialize remaining array elements. 749193326Sed // FIXME: This doesn't handle member pointers correctly! 750221345Sdim llvm::Constant *fillC; 751221345Sdim if (Expr *filler = ILE->getArrayFiller()) 752221345Sdim fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF); 753221345Sdim else 754221345Sdim fillC = llvm::Constant::getNullValue(ElemTy); 755221345Sdim if (!fillC) 756221345Sdim return 0; 757221345Sdim RewriteType |= (fillC->getType() != ElemTy); 758235633Sdim Elts.resize(NumElements, fillC); 759193326Sed 760193326Sed if (RewriteType) { 761193326Sed // FIXME: Try to avoid packing the array 762224145Sdim std::vector<llvm::Type*> Types; 763235633Sdim Types.reserve(NumInitableElts + NumElements); 764235633Sdim for (unsigned i = 0, e = Elts.size(); i < e; ++i) 765193326Sed Types.push_back(Elts[i]->getType()); 766226890Sdim llvm::StructType *SType = llvm::StructType::get(AType->getContext(), 767198092Srdivacky Types, true); 768193326Sed return llvm::ConstantStruct::get(SType, Elts); 769193326Sed } 770193326Sed 771198092Srdivacky return llvm::ConstantArray::get(AType, Elts); 772193326Sed } 773193326Sed 774245431Sdim llvm::Constant *EmitRecordInitialization(InitListExpr *ILE) { 775198092Srdivacky return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 776193326Sed } 777193326Sed 778193326Sed llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 779193326Sed return CGM.EmitNullConstant(E->getType()); 780193326Sed } 781198092Srdivacky 782193326Sed llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 783193326Sed if (ILE->getType()->isArrayType()) 784193326Sed return EmitArrayInitialization(ILE); 785193326Sed 786199990Srdivacky if (ILE->getType()->isRecordType()) 787245431Sdim return EmitRecordInitialization(ILE); 788193326Sed 789235633Sdim return 0; 790193326Sed } 791193326Sed 792203955Srdivacky llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) { 793203955Srdivacky if (!E->getConstructor()->isTrivial()) 794203955Srdivacky return 0; 795203955Srdivacky 796203955Srdivacky QualType Ty = E->getType(); 797203955Srdivacky 798203955Srdivacky // FIXME: We should not have to call getBaseElementType here. 799203955Srdivacky const RecordType *RT = 800203955Srdivacky CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>(); 801203955Srdivacky const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 802203955Srdivacky 803203955Srdivacky // If the class doesn't have a trivial destructor, we can't emit it as a 804203955Srdivacky // constant expr. 805203955Srdivacky if (!RD->hasTrivialDestructor()) 806203955Srdivacky return 0; 807203955Srdivacky 808203955Srdivacky // Only copy and default constructors can be trivial. 809203955Srdivacky 810203955Srdivacky 811203955Srdivacky if (E->getNumArgs()) { 812203955Srdivacky assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument"); 813226890Sdim assert(E->getConstructor()->isCopyOrMoveConstructor() && 814226890Sdim "trivial ctor has argument but isn't a copy/move ctor"); 815203955Srdivacky 816203955Srdivacky Expr *Arg = E->getArg(0); 817203955Srdivacky assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) && 818203955Srdivacky "argument to copy ctor is of wrong type"); 819203955Srdivacky 820203955Srdivacky return Visit(Arg); 821203955Srdivacky } 822203955Srdivacky 823203955Srdivacky return CGM.EmitNullConstant(Ty); 824203955Srdivacky } 825203955Srdivacky 826193326Sed llvm::Constant *VisitStringLiteral(StringLiteral *E) { 827235633Sdim return CGM.GetConstantArrayFromStringLiteral(E); 828193326Sed } 829193326Sed 830193326Sed llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 831193326Sed // This must be an @encode initializing an array in a static initializer. 832193326Sed // Don't emit it as the address of the string, emit the string data itself 833193326Sed // as an inline array. 834193326Sed std::string Str; 835193326Sed CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 836193326Sed const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType()); 837198092Srdivacky 838193326Sed // Resize the string to the right size, adding zeros at the end, or 839193326Sed // truncating as needed. 840193326Sed Str.resize(CAT->getSize().getZExtValue(), '\0'); 841235633Sdim return llvm::ConstantDataArray::getString(VMContext, Str, false); 842193326Sed } 843198092Srdivacky 844193326Sed llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 845193326Sed return Visit(E->getSubExpr()); 846193326Sed } 847193326Sed 848193326Sed // Utility methods 849226890Sdim llvm::Type *ConvertType(QualType T) { 850193326Sed return CGM.getTypes().ConvertType(T); 851193326Sed } 852193326Sed 853193326Sedpublic: 854235633Sdim llvm::Constant *EmitLValue(APValue::LValueBase LVBase) { 855235633Sdim if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) { 856204793Srdivacky if (Decl->hasAttr<WeakRefAttr>()) 857212904Sdim return CGM.GetWeakRefReference(Decl); 858193326Sed if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 859198092Srdivacky return CGM.GetAddrOfFunction(FD); 860193326Sed if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 861193326Sed // We can never refer to a variable with local storage. 862198092Srdivacky if (!VD->hasLocalStorage()) { 863193326Sed if (VD->isFileVarDecl() || VD->hasExternalStorage()) 864193326Sed return CGM.GetAddrOfGlobalVar(VD); 865252723Sdim else if (VD->isLocalVarDecl()) 866252723Sdim return CGM.getStaticLocalDeclAddress(VD); 867193326Sed } 868193326Sed } 869235633Sdim return 0; 870193326Sed } 871235633Sdim 872235633Sdim Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>()); 873235633Sdim switch (E->getStmtClass()) { 874235633Sdim default: break; 875235633Sdim case Expr::CompoundLiteralExprClass: { 876235633Sdim // Note that due to the nature of compound literals, this is guaranteed 877235633Sdim // to be the only use of the variable, so we just generate it here. 878235633Sdim CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 879235633Sdim llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(), 880235633Sdim CLE->getType(), CGF); 881235633Sdim // FIXME: "Leaked" on failure. 882235633Sdim if (C) 883235633Sdim C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), 884235633Sdim E->getType().isConstant(CGM.getContext()), 885235633Sdim llvm::GlobalValue::InternalLinkage, 886245431Sdim C, ".compoundliteral", 0, 887245431Sdim llvm::GlobalVariable::NotThreadLocal, 888235633Sdim CGM.getContext().getTargetAddressSpace(E->getType())); 889235633Sdim return C; 890235633Sdim } 891193326Sed case Expr::StringLiteralClass: 892193326Sed return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 893193326Sed case Expr::ObjCEncodeExprClass: 894193326Sed return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); 895193326Sed case Expr::ObjCStringLiteralClass: { 896193326Sed ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 897202879Srdivacky llvm::Constant *C = 898202879Srdivacky CGM.getObjCRuntime().GenerateConstantString(SL->getString()); 899193326Sed return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 900193326Sed } 901193326Sed case Expr::PredefinedExprClass: { 902199482Srdivacky unsigned Type = cast<PredefinedExpr>(E)->getIdentType(); 903199482Srdivacky if (CGF) { 904212904Sdim LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E)); 905199482Srdivacky return cast<llvm::Constant>(Res.getAddress()); 906199482Srdivacky } else if (Type == PredefinedExpr::PrettyFunction) { 907199482Srdivacky return CGM.GetAddrOfConstantCString("top level", ".tmp"); 908199482Srdivacky } 909198092Srdivacky 910199482Srdivacky return CGM.GetAddrOfConstantCString("", ".tmp"); 911193326Sed } 912193326Sed case Expr::AddrLabelExprClass: { 913193326Sed assert(CGF && "Invalid address of label expression outside function."); 914198893Srdivacky llvm::Constant *Ptr = 915198893Srdivacky CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 916198893Srdivacky return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType())); 917193326Sed } 918193326Sed case Expr::CallExprClass: { 919193326Sed CallExpr* CE = cast<CallExpr>(E); 920235633Sdim unsigned builtin = CE->isBuiltinCall(); 921202879Srdivacky if (builtin != 922202879Srdivacky Builtin::BI__builtin___CFStringMakeConstantString && 923202879Srdivacky builtin != 924202879Srdivacky Builtin::BI__builtin___NSStringMakeConstantString) 925193326Sed break; 926193326Sed const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 927193326Sed const StringLiteral *Literal = cast<StringLiteral>(Arg); 928202879Srdivacky if (builtin == 929202879Srdivacky Builtin::BI__builtin___NSStringMakeConstantString) { 930202879Srdivacky return CGM.getObjCRuntime().GenerateConstantString(Literal); 931202879Srdivacky } 932193326Sed // FIXME: need to deal with UCN conversion issues. 933193326Sed return CGM.GetAddrOfConstantCFString(Literal); 934193326Sed } 935193326Sed case Expr::BlockExprClass: { 936193326Sed std::string FunctionName; 937193326Sed if (CGF) 938193326Sed FunctionName = CGF->CurFn->getName(); 939193326Sed else 940193326Sed FunctionName = "global"; 941193326Sed 942193326Sed return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); 943193326Sed } 944235633Sdim case Expr::CXXTypeidExprClass: { 945235633Sdim CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E); 946235633Sdim QualType T; 947235633Sdim if (Typeid->isTypeOperand()) 948263509Sdim T = Typeid->getTypeOperand(CGM.getContext()); 949235633Sdim else 950235633Sdim T = Typeid->getExprOperand()->getType(); 951235633Sdim return CGM.GetAddrOfRTTIDescriptor(T); 952193326Sed } 953245431Sdim case Expr::CXXUuidofExprClass: { 954245431Sdim return CGM.GetAddrOfUuidDescriptor(cast<CXXUuidofExpr>(E)); 955235633Sdim } 956263509Sdim case Expr::MaterializeTemporaryExprClass: { 957263509Sdim MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(E); 958263509Sdim assert(MTE->getStorageDuration() == SD_Static); 959263509Sdim SmallVector<const Expr *, 2> CommaLHSs; 960263509Sdim SmallVector<SubobjectAdjustment, 2> Adjustments; 961263509Sdim const Expr *Inner = MTE->GetTemporaryExpr() 962263509Sdim ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); 963263509Sdim return CGM.GetAddrOfGlobalTemporary(MTE, Inner); 964245431Sdim } 965263509Sdim } 966193326Sed 967193326Sed return 0; 968193326Sed } 969193326Sed}; 970198092Srdivacky 971193326Sed} // end anonymous namespace. 972193326Sed 973235633Sdimllvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D, 974235633Sdim CodeGenFunction *CGF) { 975252723Sdim // Make a quick check if variable can be default NULL initialized 976252723Sdim // and avoid going through rest of code which may do, for c++11, 977252723Sdim // initialization of memory to all NULLs. 978252723Sdim if (!D.hasLocalStorage()) { 979252723Sdim QualType Ty = D.getType(); 980252723Sdim if (Ty->isArrayType()) 981252723Sdim Ty = Context.getBaseElementType(Ty); 982252723Sdim if (Ty->isRecordType()) 983252723Sdim if (const CXXConstructExpr *E = 984252723Sdim dyn_cast_or_null<CXXConstructExpr>(D.getInit())) { 985252723Sdim const CXXConstructorDecl *CD = E->getConstructor(); 986252723Sdim if (CD->isTrivial() && CD->isDefaultConstructor()) 987252723Sdim return EmitNullConstant(D.getType()); 988252723Sdim } 989252723Sdim } 990252723Sdim 991235633Sdim if (const APValue *Value = D.evaluateValue()) 992235633Sdim return EmitConstantValueForMemory(*Value, D.getType(), CGF); 993235633Sdim 994235633Sdim // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a 995235633Sdim // reference is a constant expression, and the reference binds to a temporary, 996235633Sdim // then constant initialization is performed. ConstExprEmitter will 997235633Sdim // incorrectly emit a prvalue constant in this case, and the calling code 998235633Sdim // interprets that as the (pointer) value of the reference, rather than the 999235633Sdim // desired value of the referee. 1000235633Sdim if (D.getType()->isReferenceType()) 1001235633Sdim return 0; 1002235633Sdim 1003235633Sdim const Expr *E = D.getInit(); 1004235633Sdim assert(E && "No initializer to emit"); 1005235633Sdim 1006235633Sdim llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 1007235633Sdim if (C && C->getType()->isIntegerTy(1)) { 1008235633Sdim llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 1009235633Sdim C = llvm::ConstantExpr::getZExt(C, BoolTy); 1010235633Sdim } 1011235633Sdim return C; 1012235633Sdim} 1013235633Sdim 1014193326Sedllvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 1015193326Sed QualType DestType, 1016193326Sed CodeGenFunction *CGF) { 1017193326Sed Expr::EvalResult Result; 1018198092Srdivacky 1019193326Sed bool Success = false; 1020198092Srdivacky 1021193326Sed if (DestType->isReferenceType()) 1022193326Sed Success = E->EvaluateAsLValue(Result, Context); 1023198092Srdivacky else 1024235633Sdim Success = E->EvaluateAsRValue(Result, Context); 1025198092Srdivacky 1026235633Sdim llvm::Constant *C = 0; 1027235633Sdim if (Success && !Result.HasSideEffects) 1028235633Sdim C = EmitConstantValue(Result.Val, DestType, CGF); 1029235633Sdim else 1030235633Sdim C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 1031198092Srdivacky 1032235633Sdim if (C && C->getType()->isIntegerTy(1)) { 1033235633Sdim llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 1034235633Sdim C = llvm::ConstantExpr::getZExt(C, BoolTy); 1035235633Sdim } 1036235633Sdim return C; 1037235633Sdim} 1038193326Sed 1039235633Sdimllvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value, 1040235633Sdim QualType DestType, 1041235633Sdim CodeGenFunction *CGF) { 1042235633Sdim switch (Value.getKind()) { 1043235633Sdim case APValue::Uninitialized: 1044235633Sdim llvm_unreachable("Constant expressions should be initialized."); 1045235633Sdim case APValue::LValue: { 1046235633Sdim llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType); 1047235633Sdim llvm::Constant *Offset = 1048235633Sdim llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity()); 1049193326Sed 1050235633Sdim llvm::Constant *C; 1051235633Sdim if (APValue::LValueBase LVBase = Value.getLValueBase()) { 1052235633Sdim // An array can be represented as an lvalue referring to the base. 1053235633Sdim if (isa<llvm::ArrayType>(DestTy)) { 1054235633Sdim assert(Offset->isNullValue() && "offset on array initializer"); 1055235633Sdim return ConstExprEmitter(*this, CGF).Visit( 1056235633Sdim const_cast<Expr*>(LVBase.get<const Expr*>())); 1057235633Sdim } 1058193326Sed 1059235633Sdim C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase); 1060193326Sed 1061235633Sdim // Apply offset if necessary. 1062235633Sdim if (!Offset->isNullValue()) { 1063235633Sdim llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Int8PtrTy); 1064235633Sdim Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset); 1065235633Sdim C = llvm::ConstantExpr::getBitCast(Casted, C->getType()); 1066235633Sdim } 1067193326Sed 1068235633Sdim // Convert to the appropriate type; this could be an lvalue for 1069235633Sdim // an integer. 1070235633Sdim if (isa<llvm::PointerType>(DestTy)) 1071235633Sdim return llvm::ConstantExpr::getBitCast(C, DestTy); 1072193326Sed 1073235633Sdim return llvm::ConstantExpr::getPtrToInt(C, DestTy); 1074235633Sdim } else { 1075235633Sdim C = Offset; 1076198092Srdivacky 1077235633Sdim // Convert to the appropriate type; this could be an lvalue for 1078235633Sdim // an integer. 1079235633Sdim if (isa<llvm::PointerType>(DestTy)) 1080235633Sdim return llvm::ConstantExpr::getIntToPtr(C, DestTy); 1081235633Sdim 1082235633Sdim // If the types don't match this should only be a truncate. 1083235633Sdim if (C->getType() != DestTy) 1084235633Sdim return llvm::ConstantExpr::getTrunc(C, DestTy); 1085235633Sdim 1086193326Sed return C; 1087193326Sed } 1088235633Sdim } 1089235633Sdim case APValue::Int: 1090235633Sdim return llvm::ConstantInt::get(VMContext, Value.getInt()); 1091235633Sdim case APValue::ComplexInt: { 1092235633Sdim llvm::Constant *Complex[2]; 1093198092Srdivacky 1094235633Sdim Complex[0] = llvm::ConstantInt::get(VMContext, 1095235633Sdim Value.getComplexIntReal()); 1096235633Sdim Complex[1] = llvm::ConstantInt::get(VMContext, 1097235633Sdim Value.getComplexIntImag()); 1098198092Srdivacky 1099235633Sdim // FIXME: the target may want to specify that this is packed. 1100235633Sdim llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), 1101235633Sdim Complex[1]->getType(), 1102235633Sdim NULL); 1103235633Sdim return llvm::ConstantStruct::get(STy, Complex); 1104235633Sdim } 1105235633Sdim case APValue::Float: { 1106235633Sdim const llvm::APFloat &Init = Value.getFloat(); 1107252723Sdim if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf && 1108252723Sdim !Context.getLangOpts().NativeHalfType) 1109235633Sdim return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt()); 1110235633Sdim else 1111235633Sdim return llvm::ConstantFP::get(VMContext, Init); 1112235633Sdim } 1113235633Sdim case APValue::ComplexFloat: { 1114235633Sdim llvm::Constant *Complex[2]; 1115235633Sdim 1116235633Sdim Complex[0] = llvm::ConstantFP::get(VMContext, 1117235633Sdim Value.getComplexFloatReal()); 1118235633Sdim Complex[1] = llvm::ConstantFP::get(VMContext, 1119235633Sdim Value.getComplexFloatImag()); 1120235633Sdim 1121235633Sdim // FIXME: the target may want to specify that this is packed. 1122235633Sdim llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), 1123235633Sdim Complex[1]->getType(), 1124235633Sdim NULL); 1125235633Sdim return llvm::ConstantStruct::get(STy, Complex); 1126235633Sdim } 1127235633Sdim case APValue::Vector: { 1128235633Sdim SmallVector<llvm::Constant *, 4> Inits; 1129235633Sdim unsigned NumElts = Value.getVectorLength(); 1130235633Sdim 1131235633Sdim for (unsigned i = 0; i != NumElts; ++i) { 1132235633Sdim const APValue &Elt = Value.getVectorElt(i); 1133235633Sdim if (Elt.isInt()) 1134235633Sdim Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt())); 1135226890Sdim else 1136235633Sdim Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat())); 1137226890Sdim } 1138235633Sdim return llvm::ConstantVector::get(Inits); 1139235633Sdim } 1140235633Sdim case APValue::AddrLabelDiff: { 1141235633Sdim const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS(); 1142235633Sdim const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS(); 1143235633Sdim llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF); 1144235633Sdim llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF); 1145198092Srdivacky 1146235633Sdim // Compute difference 1147235633Sdim llvm::Type *ResultType = getTypes().ConvertType(DestType); 1148235633Sdim LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy); 1149235633Sdim RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy); 1150235633Sdim llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS); 1151198092Srdivacky 1152235633Sdim // LLVM is a bit sensitive about the exact format of the 1153235633Sdim // address-of-label difference; make sure to truncate after 1154235633Sdim // the subtraction. 1155235633Sdim return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType); 1156235633Sdim } 1157235633Sdim case APValue::Struct: 1158235633Sdim case APValue::Union: 1159235633Sdim return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType); 1160235633Sdim case APValue::Array: { 1161235633Sdim const ArrayType *CAT = Context.getAsArrayType(DestType); 1162235633Sdim unsigned NumElements = Value.getArraySize(); 1163235633Sdim unsigned NumInitElts = Value.getArrayInitializedElts(); 1164198092Srdivacky 1165235633Sdim std::vector<llvm::Constant*> Elts; 1166235633Sdim Elts.reserve(NumElements); 1167221345Sdim 1168235633Sdim // Emit array filler, if there is one. 1169235633Sdim llvm::Constant *Filler = 0; 1170235633Sdim if (Value.hasArrayFiller()) 1171235633Sdim Filler = EmitConstantValueForMemory(Value.getArrayFiller(), 1172235633Sdim CAT->getElementType(), CGF); 1173221345Sdim 1174235633Sdim // Emit initializer elements. 1175235633Sdim llvm::Type *CommonElementType = 0; 1176235633Sdim for (unsigned I = 0; I < NumElements; ++I) { 1177235633Sdim llvm::Constant *C = Filler; 1178235633Sdim if (I < NumInitElts) 1179235633Sdim C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I), 1180235633Sdim CAT->getElementType(), CGF); 1181252723Sdim else 1182252723Sdim assert(Filler && "Missing filler for implicit elements of initializer"); 1183235633Sdim if (I == 0) 1184235633Sdim CommonElementType = C->getType(); 1185235633Sdim else if (C->getType() != CommonElementType) 1186235633Sdim CommonElementType = 0; 1187235633Sdim Elts.push_back(C); 1188235633Sdim } 1189221345Sdim 1190235633Sdim if (!CommonElementType) { 1191235633Sdim // FIXME: Try to avoid packing the array 1192235633Sdim std::vector<llvm::Type*> Types; 1193235633Sdim Types.reserve(NumElements); 1194235633Sdim for (unsigned i = 0, e = Elts.size(); i < e; ++i) 1195235633Sdim Types.push_back(Elts[i]->getType()); 1196235633Sdim llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true); 1197235633Sdim return llvm::ConstantStruct::get(SType, Elts); 1198193326Sed } 1199235633Sdim 1200235633Sdim llvm::ArrayType *AType = 1201235633Sdim llvm::ArrayType::get(CommonElementType, NumElements); 1202235633Sdim return llvm::ConstantArray::get(AType, Elts); 1203193326Sed } 1204235633Sdim case APValue::MemberPointer: 1205235633Sdim return getCXXABI().EmitMemberPointer(Value, DestType); 1206235633Sdim } 1207235633Sdim llvm_unreachable("Unknown APValue kind"); 1208235633Sdim} 1209193326Sed 1210235633Sdimllvm::Constant * 1211235633SdimCodeGenModule::EmitConstantValueForMemory(const APValue &Value, 1212235633Sdim QualType DestType, 1213235633Sdim CodeGenFunction *CGF) { 1214235633Sdim llvm::Constant *C = EmitConstantValue(Value, DestType, CGF); 1215235633Sdim if (C->getType()->isIntegerTy(1)) { 1216235633Sdim llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType); 1217193326Sed C = llvm::ConstantExpr::getZExt(C, BoolTy); 1218193326Sed } 1219193326Sed return C; 1220193326Sed} 1221193326Sed 1222235633Sdimllvm::Constant * 1223235633SdimCodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) { 1224235633Sdim assert(E->isFileScope() && "not a file-scope compound literal expr"); 1225235633Sdim return ConstExprEmitter(*this, 0).EmitLValue(E); 1226218893Sdim} 1227235633Sdim 1228218893Sdimllvm::Constant * 1229218893SdimCodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) { 1230218893Sdim // Member pointer constants always have a very particular form. 1231218893Sdim const MemberPointerType *type = cast<MemberPointerType>(uo->getType()); 1232218893Sdim const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl(); 1233218893Sdim 1234218893Sdim // A member function pointer. 1235218893Sdim if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl)) 1236218893Sdim return getCXXABI().EmitMemberPointer(method); 1237218893Sdim 1238218893Sdim // Otherwise, a member data pointer. 1239235633Sdim uint64_t fieldOffset = getContext().getFieldOffset(decl); 1240218893Sdim CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset); 1241218893Sdim return getCXXABI().EmitMemberDataPointer(type, chars); 1242218893Sdim} 1243218893Sdim 1244208600Srdivackystatic void 1245208600SrdivackyFillInNullDataMemberPointers(CodeGenModule &CGM, QualType T, 1246235633Sdim SmallVectorImpl<llvm::Constant *> &Elements, 1247208600Srdivacky uint64_t StartOffset) { 1248221345Sdim assert(StartOffset % CGM.getContext().getCharWidth() == 0 && 1249221345Sdim "StartOffset not byte aligned!"); 1250208600Srdivacky 1251212904Sdim if (CGM.getTypes().isZeroInitializable(T)) 1252208600Srdivacky return; 1253208600Srdivacky 1254208600Srdivacky if (const ConstantArrayType *CAT = 1255208600Srdivacky CGM.getContext().getAsConstantArrayType(T)) { 1256208600Srdivacky QualType ElementTy = CAT->getElementType(); 1257208600Srdivacky uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy); 1258208600Srdivacky 1259208600Srdivacky for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) { 1260208600Srdivacky FillInNullDataMemberPointers(CGM, ElementTy, Elements, 1261208600Srdivacky StartOffset + I * ElementSize); 1262208600Srdivacky } 1263208600Srdivacky } else if (const RecordType *RT = T->getAs<RecordType>()) { 1264203955Srdivacky const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1265208600Srdivacky const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 1266208600Srdivacky 1267208600Srdivacky // Go through all bases and fill in any null pointer to data members. 1268208600Srdivacky for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1269208600Srdivacky E = RD->bases_end(); I != E; ++I) { 1270210299Sed if (I->isVirtual()) { 1271218893Sdim // Ignore virtual bases. 1272210299Sed continue; 1273210299Sed } 1274208600Srdivacky 1275208600Srdivacky const CXXRecordDecl *BaseDecl = 1276208600Srdivacky cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 1277208600Srdivacky 1278208600Srdivacky // Ignore empty bases. 1279208600Srdivacky if (BaseDecl->isEmpty()) 1280208600Srdivacky continue; 1281208600Srdivacky 1282208600Srdivacky // Ignore bases that don't have any pointer to data members. 1283212904Sdim if (CGM.getTypes().isZeroInitializable(BaseDecl)) 1284208600Srdivacky continue; 1285208600Srdivacky 1286245431Sdim uint64_t BaseOffset = 1287245431Sdim CGM.getContext().toBits(Layout.getBaseClassOffset(BaseDecl)); 1288208600Srdivacky FillInNullDataMemberPointers(CGM, I->getType(), 1289208600Srdivacky Elements, StartOffset + BaseOffset); 1290208600Srdivacky } 1291203955Srdivacky 1292208600Srdivacky // Visit all fields. 1293208600Srdivacky unsigned FieldNo = 0; 1294208600Srdivacky for (RecordDecl::field_iterator I = RD->field_begin(), 1295208600Srdivacky E = RD->field_end(); I != E; ++I, ++FieldNo) { 1296208600Srdivacky QualType FieldType = I->getType(); 1297208600Srdivacky 1298212904Sdim if (CGM.getTypes().isZeroInitializable(FieldType)) 1299208600Srdivacky continue; 1300208600Srdivacky 1301208600Srdivacky uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo); 1302208600Srdivacky FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset); 1303208600Srdivacky } 1304208600Srdivacky } else { 1305208600Srdivacky assert(T->isMemberPointerType() && "Should only see member pointers here!"); 1306208600Srdivacky assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() && 1307208600Srdivacky "Should only see pointers to data members here!"); 1308208600Srdivacky 1309221345Sdim CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset); 1310221345Sdim CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T); 1311208600Srdivacky 1312218893Sdim // FIXME: hardcodes Itanium member pointer representation! 1313208600Srdivacky llvm::Constant *NegativeOne = 1314235633Sdim llvm::ConstantInt::get(CGM.Int8Ty, -1ULL, /*isSigned*/true); 1315208600Srdivacky 1316208600Srdivacky // Fill in the null data member pointer. 1317221345Sdim for (CharUnits I = StartIndex; I != EndIndex; ++I) 1318221345Sdim Elements[I.getQuantity()] = NegativeOne; 1319203955Srdivacky } 1320198092Srdivacky} 1321198092Srdivacky 1322218893Sdimstatic llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 1323226890Sdim llvm::Type *baseType, 1324218893Sdim const CXXRecordDecl *base); 1325218893Sdim 1326218893Sdimstatic llvm::Constant *EmitNullConstant(CodeGenModule &CGM, 1327218893Sdim const CXXRecordDecl *record, 1328218893Sdim bool asCompleteObject) { 1329218893Sdim const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record); 1330226890Sdim llvm::StructType *structure = 1331218893Sdim (asCompleteObject ? layout.getLLVMType() 1332218893Sdim : layout.getBaseSubobjectLLVMType()); 1333218893Sdim 1334218893Sdim unsigned numElements = structure->getNumElements(); 1335218893Sdim std::vector<llvm::Constant *> elements(numElements); 1336218893Sdim 1337218893Sdim // Fill in all the bases. 1338218893Sdim for (CXXRecordDecl::base_class_const_iterator 1339218893Sdim I = record->bases_begin(), E = record->bases_end(); I != E; ++I) { 1340218893Sdim if (I->isVirtual()) { 1341218893Sdim // Ignore virtual bases; if we're laying out for a complete 1342218893Sdim // object, we'll lay these out later. 1343218893Sdim continue; 1344218893Sdim } 1345218893Sdim 1346218893Sdim const CXXRecordDecl *base = 1347218893Sdim cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 1348218893Sdim 1349218893Sdim // Ignore empty bases. 1350218893Sdim if (base->isEmpty()) 1351218893Sdim continue; 1352218893Sdim 1353218893Sdim unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base); 1354226890Sdim llvm::Type *baseType = structure->getElementType(fieldIndex); 1355218893Sdim elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 1356218893Sdim } 1357218893Sdim 1358218893Sdim // Fill in all the fields. 1359218893Sdim for (RecordDecl::field_iterator I = record->field_begin(), 1360218893Sdim E = record->field_end(); I != E; ++I) { 1361218893Sdim const FieldDecl *field = *I; 1362235633Sdim 1363235633Sdim // Fill in non-bitfields. (Bitfields always use a zero pattern, which we 1364235633Sdim // will fill in later.) 1365235633Sdim if (!field->isBitField()) { 1366235633Sdim unsigned fieldIndex = layout.getLLVMFieldNo(field); 1367235633Sdim elements[fieldIndex] = CGM.EmitNullConstant(field->getType()); 1368235633Sdim } 1369235633Sdim 1370235633Sdim // For unions, stop after the first named field. 1371235633Sdim if (record->isUnion() && field->getDeclName()) 1372235633Sdim break; 1373218893Sdim } 1374218893Sdim 1375218893Sdim // Fill in the virtual bases, if we're working with the complete object. 1376218893Sdim if (asCompleteObject) { 1377218893Sdim for (CXXRecordDecl::base_class_const_iterator 1378218893Sdim I = record->vbases_begin(), E = record->vbases_end(); I != E; ++I) { 1379218893Sdim const CXXRecordDecl *base = 1380218893Sdim cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 1381218893Sdim 1382218893Sdim // Ignore empty bases. 1383218893Sdim if (base->isEmpty()) 1384218893Sdim continue; 1385218893Sdim 1386218893Sdim unsigned fieldIndex = layout.getVirtualBaseIndex(base); 1387218893Sdim 1388218893Sdim // We might have already laid this field out. 1389218893Sdim if (elements[fieldIndex]) continue; 1390218893Sdim 1391226890Sdim llvm::Type *baseType = structure->getElementType(fieldIndex); 1392218893Sdim elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 1393218893Sdim } 1394218893Sdim } 1395218893Sdim 1396218893Sdim // Now go through all other fields and zero them out. 1397218893Sdim for (unsigned i = 0; i != numElements; ++i) { 1398218893Sdim if (!elements[i]) 1399218893Sdim elements[i] = llvm::Constant::getNullValue(structure->getElementType(i)); 1400218893Sdim } 1401218893Sdim 1402218893Sdim return llvm::ConstantStruct::get(structure, elements); 1403218893Sdim} 1404218893Sdim 1405218893Sdim/// Emit the null constant for a base subobject. 1406218893Sdimstatic llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 1407226890Sdim llvm::Type *baseType, 1408218893Sdim const CXXRecordDecl *base) { 1409218893Sdim const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base); 1410218893Sdim 1411218893Sdim // Just zero out bases that don't have any pointer to data members. 1412218893Sdim if (baseLayout.isZeroInitializableAsBase()) 1413218893Sdim return llvm::Constant::getNullValue(baseType); 1414218893Sdim 1415218893Sdim // If the base type is a struct, we can just use its null constant. 1416218893Sdim if (isa<llvm::StructType>(baseType)) { 1417218893Sdim return EmitNullConstant(CGM, base, /*complete*/ false); 1418218893Sdim } 1419218893Sdim 1420218893Sdim // Otherwise, some bases are represented as arrays of i8 if the size 1421218893Sdim // of the base is smaller than its corresponding LLVM type. Figure 1422218893Sdim // out how many elements this base array has. 1423226890Sdim llvm::ArrayType *baseArrayType = cast<llvm::ArrayType>(baseType); 1424218893Sdim unsigned numBaseElements = baseArrayType->getNumElements(); 1425218893Sdim 1426218893Sdim // Fill in null data member pointers. 1427235633Sdim SmallVector<llvm::Constant *, 16> baseElements(numBaseElements); 1428218893Sdim FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base), 1429218893Sdim baseElements, 0); 1430218893Sdim 1431218893Sdim // Now go through all other elements and zero them out. 1432218893Sdim if (numBaseElements) { 1433235633Sdim llvm::Constant *i8_zero = llvm::Constant::getNullValue(CGM.Int8Ty); 1434218893Sdim for (unsigned i = 0; i != numBaseElements; ++i) { 1435218893Sdim if (!baseElements[i]) 1436218893Sdim baseElements[i] = i8_zero; 1437218893Sdim } 1438218893Sdim } 1439218893Sdim 1440218893Sdim return llvm::ConstantArray::get(baseArrayType, baseElements); 1441218893Sdim} 1442218893Sdim 1443193326Sedllvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { 1444212904Sdim if (getTypes().isZeroInitializable(T)) 1445198092Srdivacky return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 1446203955Srdivacky 1447198092Srdivacky if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { 1448235633Sdim llvm::ArrayType *ATy = 1449235633Sdim cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); 1450198092Srdivacky 1451198092Srdivacky QualType ElementTy = CAT->getElementType(); 1452198092Srdivacky 1453203955Srdivacky llvm::Constant *Element = EmitNullConstant(ElementTy); 1454203955Srdivacky unsigned NumElements = CAT->getSize().getZExtValue(); 1455235633Sdim 1456235633Sdim if (Element->isNullValue()) 1457235633Sdim return llvm::ConstantAggregateZero::get(ATy); 1458235633Sdim 1459235633Sdim SmallVector<llvm::Constant *, 8> Array(NumElements, Element); 1460203955Srdivacky return llvm::ConstantArray::get(ATy, Array); 1461198092Srdivacky } 1462198092Srdivacky 1463198092Srdivacky if (const RecordType *RT = T->getAs<RecordType>()) { 1464203955Srdivacky const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1465218893Sdim return ::EmitNullConstant(*this, RD, /*complete object*/ true); 1466198092Srdivacky } 1467198092Srdivacky 1468208600Srdivacky assert(T->isMemberPointerType() && "Should only see member pointers here!"); 1469203955Srdivacky assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() && 1470203955Srdivacky "Should only see pointers to data members here!"); 1471203955Srdivacky 1472203955Srdivacky // Itanium C++ ABI 2.3: 1473203955Srdivacky // A NULL pointer is represented as -1. 1474218893Sdim return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>()); 1475203955Srdivacky} 1476226890Sdim 1477226890Sdimllvm::Constant * 1478226890SdimCodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) { 1479226890Sdim return ::EmitNullConstant(*this, Record, false); 1480226890Sdim} 1481