13b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// 23b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 33b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// The LLVM Compiler Infrastructure 43b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 53b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// This file is distributed under the University of Illinois Open Source 63b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// License. See LICENSE.TXT for details. 73b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 83b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson//===----------------------------------------------------------------------===// 93b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 103b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// This contains code to emit Constant Expr nodes as LLVM code. 113b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson// 123b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson//===----------------------------------------------------------------------===// 133b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 143b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "CodeGenFunction.h" 154c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 16af2f62ce32e462f256855cd24b06dec4755d2827Daniel Dunbar#include "CGObjCRuntime.h" 172924ade97ee4228fcf3518d89cd4bd1653236b48Daniel Dunbar#include "CGRecordLayout.h" 1855fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "CodeGenModule.h" 19f6b24ea67b5898295e2fc645327837037462a0fdChris Lattner#include "clang/AST/APValue.h" 20de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 214c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson#include "clang/AST/RecordLayout.h" 22de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 231b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner#include "clang/Basic/Builtins.h" 243b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/Constants.h" 253b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/DataLayout.h" 263b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/Function.h" 273b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/GlobalVariable.h" 283b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonusing namespace clang; 293b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonusing namespace CodeGen; 303b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 31eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner//===----------------------------------------------------------------------===// 32eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner// ConstStructBuilder 33eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner//===----------------------------------------------------------------------===// 34eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 35eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattnernamespace { 3685b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ConstStructBuilder { 374c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson CodeGenModule &CGM; 384c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson CodeGenFunction *CGF; 394c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump bool Packed; 41dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck CharUnits NextFieldOffsetInChars; 427d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck CharUnits LLVMStructAlignment; 43cf6511be740688c6fc554aaaeee1da9853b3c7dfBill Wendling SmallVector<llvm::Constant *, 32> Elements; 44eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattnerpublic: 45eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 46eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner InitListExpr *ILE); 472d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 482d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const APValue &Value, QualType ValTy); 492d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 502d6a5670465cb3f1d811695a9f23e372508240d2Richard Smithprivate: 514c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF) 52dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck : CGM(CGM), CGF(CGF), Packed(false), 53dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck NextFieldOffsetInChars(CharUnits::Zero()), 547d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck LLVMStructAlignment(CharUnits::One()) { } 554c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 56c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith void AppendVTablePointer(BaseSubobject Base, llvm::Constant *VTable, 57c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith const CXXRecordDecl *VTableClass); 58c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 592d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith void AppendField(const FieldDecl *Field, uint64_t FieldOffset, 608ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner llvm::Constant *InitExpr); 611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 62c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst); 63c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 641880666c13b909f858ddec9c2a7784c5a0c04041Chris Lattner void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset, 651880666c13b909f858ddec9c2a7784c5a0c04041Chris Lattner llvm::ConstantInt *InitExpr); 661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 67c29ea8fb903f9f7e3d8bdf8cb57b87eb3713826bKen Dyck void AppendPadding(CharUnits PadSize); 684c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 69106ca049e9a5b10ba80df1b60c0708b2491b7e18Ken Dyck void AppendTailPadding(CharUnits RecordSize); 701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 71eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner void ConvertStructToPacked(); 722d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 73eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner bool Build(InitListExpr *ILE); 74c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase, 75c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::Constant *VTable, const CXXRecordDecl *VTableClass, 76c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith CharUnits BaseOffset); 772d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *Finalize(QualType Ty); 781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 797d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck CharUnits getAlignment(const llvm::Constant *C) const { 807d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck if (Packed) return CharUnits::One(); 817d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck return CharUnits::fromQuantity( 8225a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow CGM.getDataLayout().getABITypeAlignment(C->getType())); 83eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8515c152e4f042eb073ac05e87d588dd8fe3aa9e9eKen Dyck CharUnits getSizeInChars(const llvm::Constant *C) const { 8615c152e4f042eb073ac05e87d588dd8fe3aa9e9eKen Dyck return CharUnits::fromQuantity( 8725a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow CGM.getDataLayout().getTypeAllocSize(C->getType())); 88eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 89eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner}; 904c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 91c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smithvoid ConstStructBuilder::AppendVTablePointer(BaseSubobject Base, 92c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::Constant *VTable, 93c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith const CXXRecordDecl *VTableClass) { 94c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith // Find the appropriate vtable within the vtable group. 95c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith uint64_t AddressPoint = 96c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith CGM.getVTableContext().getVTableLayout(VTableClass).getAddressPoint(Base); 97c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::Value *Indices[] = { 98c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::ConstantInt::get(CGM.Int64Ty, 0), 99c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::ConstantInt::get(CGM.Int64Ty, AddressPoint) 100c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith }; 101c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::Constant *VTableAddressPoint = 102c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Indices); 103c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 104c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith // Add the vtable at the start of the object. 1053754f9656ab6a4648e5264d891ad5fb2f94f2a1aEli Friedman AppendBytes(Base.getBaseOffset(), VTableAddressPoint); 106c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith} 107c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 1082d6a5670465cb3f1d811695a9f23e372508240d2Richard Smithvoid ConstStructBuilder:: 1098ce9e451b421e4c941bc120bcc7f422457656d63Chris LattnerAppendField(const FieldDecl *Field, uint64_t FieldOffset, 1108ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner llvm::Constant *InitCst) { 1116925cc498be5d363ac7fb235dc6650fd7da5f2f2Ken Dyck const ASTContext &Context = CGM.getContext(); 1126925cc498be5d363ac7fb235dc6650fd7da5f2f2Ken Dyck 1136925cc498be5d363ac7fb235dc6650fd7da5f2f2Ken Dyck CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset); 1141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 115c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith AppendBytes(FieldOffsetInChars, InitCst); 116c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith} 117c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 118c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smithvoid ConstStructBuilder:: 119c22adbd40ac2fc445e41fb664777179aa5c522e3Richard SmithAppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) { 120c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 121dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck assert(NextFieldOffsetInChars <= FieldOffsetInChars 122eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner && "Field offset mismatch!"); 1231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1247d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck CharUnits FieldAlignment = getAlignment(InitCst); 1252df96e7019853d80ea599453925bd324cd110a8fAnders Carlsson 126eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // Round up the field offset to the alignment of the field type. 127dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck CharUnits AlignedNextFieldOffsetInChars = 1287d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment); 1291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 130dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) { 131eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner assert(!Packed && "Alignment is wrong even with a packed struct!"); 1321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 133eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // Convert the struct to a packed struct. 134eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner ConvertStructToPacked(); 1352d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 136dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; 137eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 138eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 139dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) { 140eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // We need to append padding. 1412d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars); 142d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson 143dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck assert(NextFieldOffsetInChars == FieldOffsetInChars && 144eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner "Did not add enough padding!"); 145d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson 146dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck AlignedNextFieldOffsetInChars = NextFieldOffsetInChars; 147eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 1481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 149eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // Add the field. 1508ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner Elements.push_back(InitCst); 151dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck NextFieldOffsetInChars = AlignedNextFieldOffsetInChars + 15215c152e4f042eb073ac05e87d588dd8fe3aa9e9eKen Dyck getSizeInChars(InitCst); 1532d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 154eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner if (Packed) 1552d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(LLVMStructAlignment == CharUnits::One() && 1567d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck "Packed struct not byte-aligned!"); 157eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner else 158eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment); 159eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner} 160eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 1611880666c13b909f858ddec9c2a7784c5a0c04041Chris Lattnervoid ConstStructBuilder::AppendBitField(const FieldDecl *Field, 1621880666c13b909f858ddec9c2a7784c5a0c04041Chris Lattner uint64_t FieldOffset, 1631880666c13b909f858ddec9c2a7784c5a0c04041Chris Lattner llvm::ConstantInt *CI) { 164f004da49eae567b15240029cdd96617958c6b0c9Ken Dyck const ASTContext &Context = CGM.getContext(); 1654f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck const uint64_t CharWidth = Context.getCharWidth(); 166dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 167dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck if (FieldOffset > NextFieldOffsetInBits) { 168eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // We need to add padding. 169f004da49eae567b15240029cdd96617958c6b0c9Ken Dyck CharUnits PadSize = Context.toCharUnitsFromBits( 170dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck llvm::RoundUpToAlignment(FieldOffset - NextFieldOffsetInBits, 171bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Context.getTargetInfo().getCharAlign())); 172eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 173f004da49eae567b15240029cdd96617958c6b0c9Ken Dyck AppendPadding(PadSize); 174eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 1751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 176a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith uint64_t FieldSize = Field->getBitWidthValue(Context); 177d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson 178eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner llvm::APInt FieldValue = CI->getValue(); 1791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 180eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // Promote the size of FieldValue if necessary 181eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // FIXME: This should never occur, but currently it can because initializer 182eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // constants are cast to bool, and because clang is not enforcing bitfield 183eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // width limits. 184eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner if (FieldSize > FieldValue.getBitWidth()) 1859f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad FieldValue = FieldValue.zext(FieldSize); 1861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 187eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // Truncate the size of FieldValue to the bit field size. 188eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner if (FieldSize < FieldValue.getBitWidth()) 1899f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad FieldValue = FieldValue.trunc(FieldSize); 1901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 191dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars); 192dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck if (FieldOffset < NextFieldOffsetInBits) { 193eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // Either part of the field or the entire field can go into the previous 194eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // byte. 195eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner assert(!Elements.empty() && "Elements can't be empty!"); 1961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 197dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset; 1981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 199eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner bool FitsCompletelyInPreviousByte = 200eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner BitsInPreviousByte >= FieldValue.getBitWidth(); 2017a86d4b8a4fe34bb8a9e3bc94f839a4a657856b8Anders Carlsson 202eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner llvm::APInt Tmp = FieldValue; 2037a86d4b8a4fe34bb8a9e3bc94f839a4a657856b8Anders Carlsson 204eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner if (!FitsCompletelyInPreviousByte) { 205eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner unsigned NewFieldWidth = FieldSize - BitsInPreviousByte; 2061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20725a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow if (CGM.getDataLayout().isBigEndian()) { 208eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Tmp = Tmp.lshr(NewFieldWidth); 2099f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad Tmp = Tmp.trunc(BitsInPreviousByte); 2107a86d4b8a4fe34bb8a9e3bc94f839a4a657856b8Anders Carlsson 211eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // We want the remaining high bits. 2129f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad FieldValue = FieldValue.trunc(NewFieldWidth); 213eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } else { 2149f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad Tmp = Tmp.trunc(BitsInPreviousByte); 21588b172cd206aa94f8eab071787f4a7ec2442c407Daniel Dunbar 216eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // We want the remaining low bits. 217eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner FieldValue = FieldValue.lshr(BitsInPreviousByte); 2189f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad FieldValue = FieldValue.trunc(NewFieldWidth); 219eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 220eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 2211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2224f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck Tmp = Tmp.zext(CharWidth); 22325a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow if (CGM.getDataLayout().isBigEndian()) { 2247a86d4b8a4fe34bb8a9e3bc94f839a4a657856b8Anders Carlsson if (FitsCompletelyInPreviousByte) 225eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth()); 226eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } else { 2274f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck Tmp = Tmp.shl(CharWidth - BitsInPreviousByte); 228d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson } 2291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2302bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // 'or' in the bits that go into the previous byte. 2312bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner llvm::Value *LastElt = Elements.back(); 2322bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt)) 233eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Tmp |= Val->getValue(); 2342bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner else { 2352bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner assert(isa<llvm::UndefValue>(LastElt)); 2362bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // If there is an undef field that we're adding to, it can either be a 2372bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // scalar undef (in which case, we just replace it with our field) or it 2382bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // is an array. If it is an array, we have to pull one byte off the 2392bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // array so that the other undef bytes stay around. 2402bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner if (!isa<llvm::IntegerType>(LastElt->getType())) { 2412bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // The undef padding will be a multibyte array, create a new smaller 2422bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // padding and then an hole for our i8 to get plopped into. 2432bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner assert(isa<llvm::ArrayType>(LastElt->getType()) && 2442bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner "Expected array padding of undefs"); 2452acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType()); 2464f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck assert(AT->getElementType()->isIntegerTy(CharWidth) && 2472bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner AT->getNumElements() != 0 && 2482bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner "Expected non-empty array padding of undefs"); 2492bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner 2502bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // Remove the padding array. 251dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements()); 2522bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner Elements.pop_back(); 2532bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner 2542bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner // Add the padding back in two chunks. 255c29ea8fb903f9f7e3d8bdf8cb57b87eb3713826bKen Dyck AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1)); 256c29ea8fb903f9f7e3d8bdf8cb57b87eb3713826bKen Dyck AppendPadding(CharUnits::One()); 2572bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner assert(isa<llvm::UndefValue>(Elements.back()) && 2584f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck Elements.back()->getType()->isIntegerTy(CharWidth) && 2592bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner "Padding addition didn't work right"); 2602bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner } 2612bc00252d7597af32c84599076e4d14e678aaa8aChris Lattner } 2621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 263eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp); 2641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 265eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner if (FitsCompletelyInPreviousByte) 2661880666c13b909f858ddec9c2a7784c5a0c04041Chris Lattner return; 267eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 268d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson 2694f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck while (FieldValue.getBitWidth() > CharWidth) { 270eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner llvm::APInt Tmp; 271d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson 27225a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow if (CGM.getDataLayout().isBigEndian()) { 273eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // We want the high bits. 2744f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck Tmp = 2754f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth); 276eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } else { 277eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // We want the low bits. 2784f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck Tmp = FieldValue.trunc(CharWidth); 2791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2804f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck FieldValue = FieldValue.lshr(CharWidth); 281d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson } 282d24393bbc18fe8d30273e832fb9617604cb20493Anders Carlsson 283eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp)); 284199c1891e9c5add7867f1eab0bf6e9dde0e7d1d9Ken Dyck ++NextFieldOffsetInChars; 2851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2864f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth); 287eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 2884c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 289eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner assert(FieldValue.getBitWidth() > 0 && 290eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner "Should have at least one bit left!"); 2914f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck assert(FieldValue.getBitWidth() <= CharWidth && 292eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner "Should not have more than a byte left!"); 2934c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 2944f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck if (FieldValue.getBitWidth() < CharWidth) { 29525a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow if (CGM.getDataLayout().isBigEndian()) { 296eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner unsigned BitWidth = FieldValue.getBitWidth(); 2971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2984f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth); 299eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } else 3004f318c080b5ea89e3f7407516fd8ed45b733b99dKen Dyck FieldValue = FieldValue.zext(CharWidth); 3014c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson } 3024c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 303eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // Append the last element. 304eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), 305eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner FieldValue)); 306199c1891e9c5add7867f1eab0bf6e9dde0e7d1d9Ken Dyck ++NextFieldOffsetInChars; 307eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner} 3084c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 309c29ea8fb903f9f7e3d8bdf8cb57b87eb3713826bKen Dyckvoid ConstStructBuilder::AppendPadding(CharUnits PadSize) { 310c29ea8fb903f9f7e3d8bdf8cb57b87eb3713826bKen Dyck if (PadSize.isZero()) 311eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner return; 3121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3138b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::Type *Ty = CGM.Int8Ty; 314c29ea8fb903f9f7e3d8bdf8cb57b87eb3713826bKen Dyck if (PadSize > CharUnits::One()) 315c29ea8fb903f9f7e3d8bdf8cb57b87eb3713826bKen Dyck Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity()); 3161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 317cdb30b41590bf9e20d1d46a866fce071ebadf21aNuno Lopes llvm::Constant *C = llvm::UndefValue::get(Ty); 318eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Elements.push_back(C); 3197d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck assert(getAlignment(C) == CharUnits::One() && 3207d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck "Padding must have 1 byte alignment!"); 32131f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson 32215c152e4f042eb073ac05e87d588dd8fe3aa9e9eKen Dyck NextFieldOffsetInChars += getSizeInChars(C); 323eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner} 32431f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson 325106ca049e9a5b10ba80df1b60c0708b2491b7e18Ken Dyckvoid ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) { 326dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck assert(NextFieldOffsetInChars <= RecordSize && 327106ca049e9a5b10ba80df1b60c0708b2491b7e18Ken Dyck "Size mismatch!"); 32831f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson 329dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck AppendPadding(RecordSize - NextFieldOffsetInChars); 330eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner} 33131f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson 332eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattnervoid ConstStructBuilder::ConvertStructToPacked() { 33335f18a5e8b5a434894a4886ed98f3dbaa3b895c0Bill Wendling SmallVector<llvm::Constant *, 16> PackedElements; 3344a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck CharUnits ElementOffsetInChars = CharUnits::Zero(); 33531f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson 336eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 337eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner llvm::Constant *C = Elements[i]; 33831f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson 3397d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck CharUnits ElementAlign = CharUnits::fromQuantity( 34025a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow CGM.getDataLayout().getABITypeAlignment(C->getType())); 3414a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck CharUnits AlignedElementOffsetInChars = 3427d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck ElementOffsetInChars.RoundUpToAlignment(ElementAlign); 34331f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson 3444a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck if (AlignedElementOffsetInChars > ElementOffsetInChars) { 345eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // We need some padding. 3464a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck CharUnits NumChars = 3474a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck AlignedElementOffsetInChars - ElementOffsetInChars; 3481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3498b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::Type *Ty = CGM.Int8Ty; 3504a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck if (NumChars > CharUnits::One()) 3514a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity()); 3521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 353cdb30b41590bf9e20d1d46a866fce071ebadf21aNuno Lopes llvm::Constant *Padding = llvm::UndefValue::get(Ty); 354eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner PackedElements.push_back(Padding); 35515c152e4f042eb073ac05e87d588dd8fe3aa9e9eKen Dyck ElementOffsetInChars += getSizeInChars(Padding); 3564c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson } 3571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 358eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner PackedElements.push_back(C); 35915c152e4f042eb073ac05e87d588dd8fe3aa9e9eKen Dyck ElementOffsetInChars += getSizeInChars(C); 360eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 3611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3624a5c87ec3b92026523a6459f5b4547c4a9b5ab24Ken Dyck assert(ElementOffsetInChars == NextFieldOffsetInChars && 363eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner "Packing the struct changed its size!"); 364eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 36535f18a5e8b5a434894a4886ed98f3dbaa3b895c0Bill Wendling Elements.swap(PackedElements); 3667d2f9d54bd99f4b4689cb386b51d1b066c883a9eKen Dyck LLVMStructAlignment = CharUnits::One(); 367eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner Packed = true; 368eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner} 369eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 370eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattnerbool ConstStructBuilder::Build(InitListExpr *ILE) { 37124fe798fffc1748d8bce1321af42981c3719cb85Sebastian Redl if (ILE->initializesStdInitializerList()) { 37219b1a6eb2c90fab7cefe74bea5b6de490b65ac9dSebastian Redl //CGM.ErrorUnsupported(ILE, "global std::initializer_list"); 37324fe798fffc1748d8bce1321af42981c3719cb85Sebastian Redl return false; 37424fe798fffc1748d8bce1321af42981c3719cb85Sebastian Redl } 37524fe798fffc1748d8bce1321af42981c3719cb85Sebastian Redl 376eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 377eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 378eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 379eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner unsigned FieldNo = 0; 380eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner unsigned ElementNo = 0; 38107a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian const FieldDecl *LastFD = 0; 3825f608aedb6c5d32d2f7c51f9354a75b21f1eeaeeEli Friedman bool IsMsStruct = RD->isMsStruct(CGM.getContext()); 38307a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian 384eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner for (RecordDecl::field_iterator Field = RD->field_begin(), 3858ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 38607a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian if (IsMsStruct) { 38707a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian // Zero-length bitfields following non-bitfield members are 38807a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian // ignored: 389581deb3da481053c4993c7600f97acf7768caac5David Blaikie if (CGM.getContext().ZeroBitfieldFollowsNonBitfield(*Field, LastFD)) { 39007a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian --FieldNo; 39107a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian continue; 39207a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian } 393581deb3da481053c4993c7600f97acf7768caac5David Blaikie LastFD = *Field; 39407a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian } 3958ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner 3968ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner // If this is a union, skip all the fields that aren't being initialized. 397581deb3da481053c4993c7600f97acf7768caac5David Blaikie if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 398eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner continue; 399eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner 4008ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner // Don't emit anonymous bitfields, they just affect layout. 401dbff1a0dde2019f0a7688bf87656d6e5162912faEli Friedman if (Field->isUnnamedBitfield()) { 402581deb3da481053c4993c7600f97acf7768caac5David Blaikie LastFD = *Field; 4038ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner continue; 40407a8a21c3376f3a2ee470bfa3549c6f3ac4e236dFariborz Jahanian } 4051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4068ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner // Get the initializer. A struct can include fields without initializers, 4078ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner // we just use explicit null values for them. 4088ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner llvm::Constant *EltInit; 4098ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner if (ElementNo < ILE->getNumInits()) 4108ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++), 4118ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner Field->getType(), CGF); 4128ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner else 4138ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner EltInit = CGM.EmitNullConstant(Field->getType()); 414f0ca0ee66e5b1f3fc4d98e0d8795fa92559ce491Eli Friedman 415f0ca0ee66e5b1f3fc4d98e0d8795fa92559ce491Eli Friedman if (!EltInit) 416f0ca0ee66e5b1f3fc4d98e0d8795fa92559ce491Eli Friedman return false; 4178ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner 4188ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner if (!Field->isBitField()) { 4198ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner // Handle non-bitfield members. 420581deb3da481053c4993c7600f97acf7768caac5David Blaikie AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit); 4212d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } else { 4222d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Otherwise we have a bitfield. 423581deb3da481053c4993c7600f97acf7768caac5David Blaikie AppendBitField(*Field, Layout.getFieldOffset(FieldNo), 4242d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith cast<llvm::ConstantInt>(EltInit)); 4252d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 4262d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 4272d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 4282d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return true; 4292d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith} 4302d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 431c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smithnamespace { 432c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smithstruct BaseInfo { 433c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index) 434c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith : Decl(Decl), Offset(Offset), Index(Index) { 435c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith } 436c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 437c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith const CXXRecordDecl *Decl; 438c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith CharUnits Offset; 439c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith unsigned Index; 440c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 441c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith bool operator<(const BaseInfo &O) const { return Offset < O.Offset; } 442c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith}; 443c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith} 444c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 445c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smithvoid ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD, 446c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith bool IsPrimaryBase, llvm::Constant *VTable, 447c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith const CXXRecordDecl *VTableClass, 448c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith CharUnits Offset) { 4492d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 4502d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 451c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) { 452c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith // Add a vtable pointer, if we need one and it hasn't already been added. 453c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith if (CD->isDynamicClass() && !IsPrimaryBase) 454c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith AppendVTablePointer(BaseSubobject(CD, Offset), VTable, VTableClass); 455c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 456c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith // Accumulate and sort bases, in order to visit them in address order, which 457c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith // may not be the same as declaration order. 458cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector<BaseInfo, 8> Bases; 459c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith Bases.reserve(CD->getNumBases()); 4602d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith unsigned BaseNo = 0; 461c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(), 4622d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) { 463c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith assert(!Base->isVirtual() && "should not have virtual bases here"); 4642d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl(); 4652d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CharUnits BaseOffset = Layout.getBaseClassOffset(BD); 466c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo)); 467c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith } 468c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith std::stable_sort(Bases.begin(), Bases.end()); 4692d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 470c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith for (unsigned I = 0, N = Bases.size(); I != N; ++I) { 471c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith BaseInfo &Base = Bases[I]; 472c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 473c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl; 474c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase, 475c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith VTable, VTableClass, Offset + Base.Offset); 4762d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 4772d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 4782d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 4792d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith unsigned FieldNo = 0; 4802d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const FieldDecl *LastFD = 0; 4815f608aedb6c5d32d2f7c51f9354a75b21f1eeaeeEli Friedman bool IsMsStruct = RD->isMsStruct(CGM.getContext()); 4825fe61c6cb09a5a2d2ecddfb74f8b253d9d462165Eli Friedman uint64_t OffsetBits = CGM.getContext().toBits(Offset); 4832d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 4842d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith for (RecordDecl::field_iterator Field = RD->field_begin(), 4852d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { 4862d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (IsMsStruct) { 4872d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Zero-length bitfields following non-bitfield members are 4882d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // ignored: 489581deb3da481053c4993c7600f97acf7768caac5David Blaikie if (CGM.getContext().ZeroBitfieldFollowsNonBitfield(*Field, LastFD)) { 4902d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith --FieldNo; 4912d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith continue; 4922d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 493581deb3da481053c4993c7600f97acf7768caac5David Blaikie LastFD = *Field; 4942d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 4952d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 4962d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // If this is a union, skip all the fields that aren't being initialized. 497581deb3da481053c4993c7600f97acf7768caac5David Blaikie if (RD->isUnion() && Val.getUnionField() != *Field) 4982d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith continue; 4992d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5002d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Don't emit anonymous bitfields, they just affect layout. 5012d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (Field->isUnnamedBitfield()) { 502581deb3da481053c4993c7600f97acf7768caac5David Blaikie LastFD = *Field; 5032d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith continue; 5042d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 5052d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5062d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Emit the value of the initializer. 5072d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const APValue &FieldValue = 5082d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo); 5092d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *EltInit = 510a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith CGM.EmitConstantValueForMemory(FieldValue, Field->getType(), CGF); 5112d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(EltInit && "EmitConstantValue can't fail"); 5122d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5132d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (!Field->isBitField()) { 5142d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Handle non-bitfield members. 515581deb3da481053c4993c7600f97acf7768caac5David Blaikie AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit); 516eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } else { 5178ce9e451b421e4c941bc120bcc7f422457656d63Chris Lattner // Otherwise we have a bitfield. 518581deb3da481053c4993c7600f97acf7768caac5David Blaikie AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, 5191880666c13b909f858ddec9c2a7784c5a0c04041Chris Lattner cast<llvm::ConstantInt>(EltInit)); 52031f2f9ced8ed2dd17ac43b6addc84eb08a05442eAnders Carlsson } 521eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner } 5222d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith} 5232d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5242d6a5670465cb3f1d811695a9f23e372508240d2Richard Smithllvm::Constant *ConstStructBuilder::Finalize(QualType Ty) { 5252d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith RecordDecl *RD = Ty->getAs<RecordType>()->getDecl(); 5262d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 5271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 528dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck CharUnits LayoutSizeInChars = Layout.getSize(); 5291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 530dc496395fb41c5f765045bfc6ed13d57be9a7b9fKen Dyck if (NextFieldOffsetInChars > LayoutSizeInChars) { 531eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // If the struct is bigger than the size of the record type, 532eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // we must have a flexible array member at the end. 533eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner assert(RD->hasFlexibleArrayMember() && 534eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner "Must have flexible array member if struct is bigger than type!"); 5352d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 536eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner // No tail padding is necessary. 5372d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } else { 5382d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Append tail padding if necessary. 5392d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith AppendTailPadding(LayoutSizeInChars); 5401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5412d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CharUnits LLVMSizeInChars = 5422d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment); 5431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5442d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Check if we need to convert the struct to a packed struct. 5452d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (NextFieldOffsetInChars <= LayoutSizeInChars && 5462d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith LLVMSizeInChars > LayoutSizeInChars) { 5472d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(!Packed && "Size mismatch!"); 5481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5492d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith ConvertStructToPacked(); 5502d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(NextFieldOffsetInChars <= LayoutSizeInChars && 5512d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith "Converting to packed did not help!"); 5522d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 5534c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 5542d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(LayoutSizeInChars == NextFieldOffsetInChars && 5552d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith "Tail padding mismatch!"); 5562d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 5574c98efdf06f94da20a640aa36f6a4f3284c26bffAnders Carlsson 558c5cbb909e8a27deb8f1a2b6b7bf56a96051af81aChris Lattner // Pick the type to use. If the type is layout identical to the ConvertType 559c5cbb909e8a27deb8f1a2b6b7bf56a96051af81aChris Lattner // type then use it, otherwise use whatever the builder produced for us. 5602acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::StructType *STy = 561c5cbb909e8a27deb8f1a2b6b7bf56a96051af81aChris Lattner llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(), 5622d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Elements, Packed); 5632d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty); 5642d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) { 5652d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (ValSTy->isLayoutIdentical(STy)) 5662d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith STy = ValSTy; 567c5cbb909e8a27deb8f1a2b6b7bf56a96051af81aChris Lattner } 5682d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5692d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements); 5702d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5712d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(NextFieldOffsetInChars.RoundUpToAlignment(getAlignment(Result)) == 5722d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith getSizeInChars(Result) && "Size mismatch!"); 5732d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 574eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner return Result; 575eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner} 5761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5772d6a5670465cb3f1d811695a9f23e372508240d2Richard Smithllvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, 5782d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CodeGenFunction *CGF, 5792d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith InitListExpr *ILE) { 5802d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith ConstStructBuilder Builder(CGM, CGF); 5812d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5822d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (!Builder.Build(ILE)) 5832d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return 0; 5842d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5852d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return Builder.Finalize(ILE->getType()); 5862d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith} 5872d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 5882d6a5670465cb3f1d811695a9f23e372508240d2Richard Smithllvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM, 5892d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CodeGenFunction *CGF, 5902d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const APValue &Val, 5912d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith QualType ValTy) { 5922d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith ConstStructBuilder Builder(CGM, CGF); 593c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 594c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl(); 595c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD); 596c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith llvm::Constant *VTable = 0; 597c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith if (CD && CD->isDynamicClass()) 598c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith VTable = CGM.getVTables().GetAddrOfVTable(CD); 599c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 600c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith Builder.Build(Val, RD, false, VTable, CD, CharUnits::Zero()); 601c22adbd40ac2fc445e41fb664777179aa5c522e3Richard Smith 6022d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return Builder.Finalize(ValTy); 6032d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith} 6042d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 6052d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 606eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner//===----------------------------------------------------------------------===// 607eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner// ConstExprEmitter 608eba3e5af56b292f5c96fe50dbbd66bfdefc8d48cChris Lattner//===----------------------------------------------------------------------===// 609e7aa62de659049428976052eadf69188eae64170Richard Smith 610e7aa62de659049428976052eadf69188eae64170Richard Smith/// This class only needs to handle two cases: 611e7aa62de659049428976052eadf69188eae64170Richard Smith/// 1) Literals (this is used by APValue emission to emit literals). 612e7aa62de659049428976052eadf69188eae64170Richard Smith/// 2) Arrays, structs and unions (outside C++11 mode, we don't currently 613e7aa62de659049428976052eadf69188eae64170Richard Smith/// constant fold these types). 61485b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ConstExprEmitter : 61584005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 6163b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson CodeGenModule &CGM; 617813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio CodeGenFunction *CGF; 618a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson llvm::LLVMContext &VMContext; 6193b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonpublic: 620813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 621a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) { 6223b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6243b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson //===--------------------------------------------------------------------===// 6253b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Visitor Methods 6263b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson //===--------------------------------------------------------------------===// 6271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6283b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitStmt(Stmt *S) { 629069880ef6a2ecfdbc98a4980de53d3902499e83bAnders Carlsson return 0; 6303b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::Constant *VisitParenExpr(ParenExpr *PE) { 6331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Visit(PE->getSubExpr()); 6343b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 63691a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall llvm::Constant * 63791a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 63891a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall return Visit(PE->getReplacement()); 63991a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall } 64091a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall 641f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 642f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne return Visit(GE->getResultExpr()); 643f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne } 644f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne 6453b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 6463b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return Visit(E->getInitializer()); 6473b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 6485808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 6490835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis llvm::Constant *VisitCastExpr(CastExpr* E) { 6508bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall Expr *subExpr = E->getSubExpr(); 6518bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF); 6528bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall if (!C) return 0; 6538bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall 6542acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *destType = ConvertType(E->getType()); 6558bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall 6560086ccb1985f392ac688a19b35b300610db102e8Anders Carlsson switch (E->getCastKind()) { 6572de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToUnion: { 6580086ccb1985f392ac688a19b35b300610db102e8Anders Carlsson // GCC cast to union extension 6590086ccb1985f392ac688a19b35b300610db102e8Anders Carlsson assert(E->getType()->isUnionType() && 6600086ccb1985f392ac688a19b35b300610db102e8Anders Carlsson "Destination type is not union type!"); 6611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 662aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson // Build a struct with the union sub-element as the first member, 663aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson // and padded to the appropriate size 664f9ea953f22d8e50cae7fd541406d6f563ef86cdaBill Wendling SmallVector<llvm::Constant*, 2> Elts; 665f9ea953f22d8e50cae7fd541406d6f563ef86cdaBill Wendling SmallVector<llvm::Type*, 2> Types; 666aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson Elts.push_back(C); 667aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson Types.push_back(C->getType()); 66825a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow unsigned CurSize = CGM.getDataLayout().getTypeAllocSize(C->getType()); 66925a6a84cf5067b32c271e3ba078676dee838798dMicah Villmow unsigned TotalSize = CGM.getDataLayout().getTypeAllocSize(destType); 6701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 671aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson assert(CurSize <= TotalSize && "Union size mismatch!"); 672aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson if (unsigned NumPadBytes = TotalSize - CurSize) { 6738b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::Type *Ty = CGM.Int8Ty; 674aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson if (NumPadBytes > 1) 675aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson Ty = llvm::ArrayType::get(Ty, NumPadBytes); 6760086ccb1985f392ac688a19b35b300610db102e8Anders Carlsson 677cdb30b41590bf9e20d1d46a866fce071ebadf21aNuno Lopes Elts.push_back(llvm::UndefValue::get(Ty)); 678aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson Types.push_back(Ty); 679aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson } 6801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6810086ccb1985f392ac688a19b35b300610db102e8Anders Carlsson llvm::StructType* STy = 6820086ccb1985f392ac688a19b35b300610db102e8Anders Carlsson llvm::StructType::get(C->getType()->getContext(), Types, false); 683aaed50dfb52d358a407dbbdd1ca323f9328e957aAnders Carlsson return llvm::ConstantStruct::get(STy, Elts); 68481e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes } 685bb378cbf04e343fb15ae3611a153dde60671b514Anders Carlsson 6868bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_LValueToRValue: 6877a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnall case CK_AtomicToNonAtomic: 6887a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnall case CK_NonAtomicToAtomic: 6898bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_NoOp: 6908bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall return C; 6918bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall 6928bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_Dependent: llvm_unreachable("saw dependent cast!"); 6938bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall 694a6c66cedc022c9e5d45a937d6b8cff491a6bf81bEli Friedman case CK_BuiltinFnToFnPtr: 695a6c66cedc022c9e5d45a937d6b8cff491a6bf81bEli Friedman llvm_unreachable("builtin functions are handled elsewhere"); 696a6c66cedc022c9e5d45a937d6b8cff491a6bf81bEli Friedman 6974d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall case CK_ReinterpretMemberPointer: 6984d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall case CK_DerivedToBaseMemberPointer: 6994d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall case CK_BaseToDerivedMemberPointer: 7004d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall return CGM.getCXXABI().EmitMemberPointerConversion(E, C); 7014d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall 7028bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall // These will never be supported. 7038bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_ObjCObjectLValueCast: 70433e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCProduceObject: 70533e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCConsumeObject: 70633e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCReclaimReturnedObject: 70733e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCExtendBlockObject: 708ac1303eca6cbe3e623fb5ec6fe7ec184ef4b0dfaDouglas Gregor case CK_CopyAndAutoreleaseBlockObject: 7098bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall return 0; 7108bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall 711e7aa62de659049428976052eadf69188eae64170Richard Smith // These don't need to be handled here because Evaluate knows how to 712e7aa62de659049428976052eadf69188eae64170Richard Smith // evaluate them in the cases where they can be folded. 7134d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall case CK_BitCast: 714e7aa62de659049428976052eadf69188eae64170Richard Smith case CK_ToVoid: 715e7aa62de659049428976052eadf69188eae64170Richard Smith case CK_Dynamic: 716e7aa62de659049428976052eadf69188eae64170Richard Smith case CK_LValueBitCast: 717e7aa62de659049428976052eadf69188eae64170Richard Smith case CK_NullToMemberPointer: 7188bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_UserDefinedConversion: 7198bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_ConstructorConversion: 72065639284118d54ddf2e51a05d2ffccda567fe246Eli Friedman case CK_CPointerToObjCPointerCast: 72165639284118d54ddf2e51a05d2ffccda567fe246Eli Friedman case CK_BlockPointerToObjCPointerCast: 72265639284118d54ddf2e51a05d2ffccda567fe246Eli Friedman case CK_AnyPointerToBlockPointerCast: 7238bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_ArrayToPointerDecay: 7248bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FunctionToPointerDecay: 7258bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_BaseToDerived: 7268bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_DerivedToBase: 7278bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_UncheckedDerivedToBase: 7288bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_MemberPointerToBoolean: 7298bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_VectorSplat: 7308bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingRealToComplex: 7318bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingComplexToReal: 7328bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingComplexToBoolean: 7338bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingComplexCast: 7348bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingComplexToIntegralComplex: 7358bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_IntegralRealToComplex: 7368bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_IntegralComplexToReal: 7378bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_IntegralComplexToBoolean: 7388bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_IntegralComplexCast: 7398bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_IntegralComplexToFloatingComplex: 7408bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_PointerToIntegral: 7418bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_PointerToBoolean: 7428bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_NullToPointer: 74365639284118d54ddf2e51a05d2ffccda567fe246Eli Friedman case CK_IntegralCast: 74465639284118d54ddf2e51a05d2ffccda567fe246Eli Friedman case CK_IntegralToPointer: 7458bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_IntegralToBoolean: 7468bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_IntegralToFloating: 7478bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingToIntegral: 7488bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingToBoolean: 7498bba1f4ab1f06864fec627befdf7cf8e1ad017beJohn McCall case CK_FloatingCast: 750e6b9d802fb7b16d93474c4f1c179ab36202e8a8bGuy Benyei case CK_ZeroToOCLEvent: 75165639284118d54ddf2e51a05d2ffccda567fe246Eli Friedman return 0; 752ddd2b6e1e7406ab45f71398fb78b86c36acd789bEli Friedman } 75317d12fec91098fd4946c3c3e4f45b84423027407Matt Beaumont-Gay llvm_unreachable("Invalid CastKind"); 7543b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 755f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson 75604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 75704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 75804421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 75904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner 76003e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 76103e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor return Visit(E->GetTemporaryExpr()); 76203e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor } 76303e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor 764a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 765fe587201feaebc69e6d18858bea85c77926b6ecfRichard Smith if (ILE->isStringLiteralInit()) 7664d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman return Visit(ILE->getInit(0)); 767a75b71f967d7f090ef16a3d255baddbdce7ff81eNuno Lopes 7682acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::ArrayType *AType = 769a75b71f967d7f090ef16a3d255baddbdce7ff81eNuno Lopes cast<llvm::ArrayType>(ConvertType(ILE->getType())); 7702acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ElemTy = AType->getElementType(); 771fe587201feaebc69e6d18858bea85c77926b6ecfRichard Smith unsigned NumInitElements = ILE->getNumInits(); 772eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumElements = AType->getNumElements(); 773eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 7741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Initialising an array requires us to automatically 775eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // initialise any elements that have not been initialised explicitly 776eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumInitableElts = std::min(NumInitElements, NumElements); 777eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 778eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Copy initializer elements. 779f9ea953f22d8e50cae7fd541406d6f563ef86cdaBill Wendling std::vector<llvm::Constant*> Elts; 780f9ea953f22d8e50cae7fd541406d6f563ef86cdaBill Wendling Elts.reserve(NumInitableElts + NumElements); 78114c598268ff7534d3753ae84eba9b8a81bf0bf8fBenjamin Kramer 782a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman bool RewriteType = false; 78314c598268ff7534d3753ae84eba9b8a81bf0bf8fBenjamin Kramer for (unsigned i = 0; i < NumInitableElts; ++i) { 784e9352cc9818ba59e7cf88500ef048991c90f3821Anders Carlsson Expr *Init = ILE->getInit(i); 785e9352cc9818ba59e7cf88500ef048991c90f3821Anders Carlsson llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 786d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (!C) 787d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return 0; 788a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman RewriteType |= (C->getType() != ElemTy); 789eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel Elts.push_back(C); 7903b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 791a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 792eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Initialize remaining array elements. 7930f59312e7b625fa5821a63db65377d4b3b667e99Eli Friedman // FIXME: This doesn't handle member pointers correctly! 7944423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis llvm::Constant *fillC; 7954423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis if (Expr *filler = ILE->getArrayFiller()) 7964423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF); 7974423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis else 7984423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis fillC = llvm::Constant::getNullValue(ElemTy); 7994423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis if (!fillC) 8004423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis return 0; 8014423ac0282acb8ba801eb05b38712438dc0c1e3eArgyrios Kyrtzidis RewriteType |= (fillC->getType() != ElemTy); 80214c598268ff7534d3753ae84eba9b8a81bf0bf8fBenjamin Kramer Elts.resize(NumElements, fillC); 803eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 804a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman if (RewriteType) { 805a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman // FIXME: Try to avoid packing the array 806ef6de3da8572607f786303c07150daa6e140ab19Jay Foad std::vector<llvm::Type*> Types; 807f9ea953f22d8e50cae7fd541406d6f563ef86cdaBill Wendling Types.reserve(NumInitableElts + NumElements); 808fd3e5ef640df089a1e717097cdb599eb9dd32ec4Bill Wendling for (unsigned i = 0, e = Elts.size(); i < e; ++i) 809a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman Types.push_back(Elts[i]->getType()); 8102acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::StructType *SType = llvm::StructType::get(AType->getContext(), 81147a434ff3d49e7906eda88e8e8242e4297725b32Owen Anderson Types, true); 81208e252425ca2cbdc44ba65d9a657ed5398014e36Owen Anderson return llvm::ConstantStruct::get(SType, Elts); 813a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman } 814a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 8151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return llvm::ConstantArray::get(AType, Elts); 816eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 817eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 8181b5c336fc7b2013a619a50895d7a43f3f4334515Richard Smith llvm::Constant *EmitRecordInitialization(InitListExpr *ILE) { 819f6c43965c41e042f0541bdd47b1511d585b2dcfdAnders Carlsson return ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 820a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 821a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 8227d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 8230f59312e7b625fa5821a63db65377d4b3b667e99Eli Friedman return CGM.EmitNullConstant(E->getType()); 8247d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson } 8251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 826eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 827a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isArrayType()) 828a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitArrayInitialization(ILE); 829a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 83045e4e086cf7b4552e806669825f5b2aa2368cc36Jin-Gu Kang if (ILE->getType()->isRecordType()) 8311b5c336fc7b2013a619a50895d7a43f3f4334515Richard Smith return EmitRecordInitialization(ILE); 83245e4e086cf7b4552e806669825f5b2aa2368cc36Jin-Gu Kang 8337ead5c7b6fd48cf549e55b4db499c26ecf88ae75Eli Friedman return 0; 8343b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 8353b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman 836fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) { 837fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall if (!E->getConstructor()->isTrivial()) 838fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall return 0; 839fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall 8402ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson QualType Ty = E->getType(); 8412ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson 8422ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson // FIXME: We should not have to call getBaseElementType here. 8432ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson const RecordType *RT = 8442ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>(); 8452ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 8462ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson 8472ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson // If the class doesn't have a trivial destructor, we can't emit it as a 8482ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson // constant expr. 8492ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson if (!RD->hasTrivialDestructor()) 8502ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson return 0; 8512ca4f633b21c65e1a4edc2405a768d7f5db564ebAnders Carlsson 852fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall // Only copy and default constructors can be trivial. 853fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall 854fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall 855fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall if (E->getNumArgs()) { 856fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument"); 85785ea7aa961deac1d754f610af8062ae3f8b4e2a5Sebastian Redl assert(E->getConstructor()->isCopyOrMoveConstructor() && 85885ea7aa961deac1d754f610af8062ae3f8b4e2a5Sebastian Redl "trivial ctor has argument but isn't a copy/move ctor"); 859fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall 860fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall Expr *Arg = E->getArg(0); 861fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) && 862fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall "argument to copy ctor is of wrong type"); 863fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall 864878b55ce6cbbf62461c796163f586cc75202f7d4Chandler Carruth return Visit(Arg); 865fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall } 866fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall 867fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall return CGM.EmitNullConstant(Ty); 868fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall } 869fb8b69aef3377aaa786d1278aaae7e7b04ac095fJohn McCall 8703b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitStringLiteral(StringLiteral *E) { 87164f45a24b19eb89ff88f7c3ff0df9be8e861ac97Eli Friedman return CGM.GetConstantArrayFromStringLiteral(E); 8723b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 8733b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 874eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 875eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // This must be an @encode initializing an array in a static initializer. 876eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // Don't emit it as the address of the string, emit the string data itself 877eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // as an inline array. 878eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner std::string Str; 879eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 880eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType()); 8811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 882eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // Resize the string to the right size, adding zeros at the end, or 883eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // truncating as needed. 884eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner Str.resize(CAT->getSize().getZExtValue(), '\0'); 88594010695f7fce626e41ef045b60def9c912e9ce8Chris Lattner return llvm::ConstantDataArray::getString(VMContext, Str, false); 886eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner } 8871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 888bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 889bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return Visit(E->getSubExpr()); 890bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 891b83d287bc7f47d36fb0751a481e2ef9308b37252Mike Stump 8923b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Utility methods 8932acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ConvertType(QualType T) { 8943b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return CGM.getTypes().ConvertType(T); 8953b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 89684005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson 8975ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlssonpublic: 8981bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith llvm::Constant *EmitLValue(APValue::LValueBase LVBase) { 8991bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) { 900da1826102fcadb5d3c5d2d20dfa51f0e77489004Rafael Espindola if (Decl->hasAttr<WeakRefAttr>()) 901a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman return CGM.GetWeakRefReference(Decl); 902e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 903555b4bb2749aea2ec8e2adc351a71ec1cb9bdc33Anders Carlsson return CGM.GetAddrOfFunction(FD); 904248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 905d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar // We can never refer to a variable with local storage. 9061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!VD->hasLocalStorage()) { 907d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar if (VD->isFileVarDecl() || VD->hasExternalStorage()) 908d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar return CGM.GetAddrOfGlobalVar(VD); 90989e19b43b81a6b5d092a81d2ebf6ec9a4097a48dEli Friedman else if (VD->isLocalVarDecl()) 91089e19b43b81a6b5d092a81d2ebf6ec9a4097a48dEli Friedman return CGM.getStaticLocalDeclAddress(VD); 911248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff } 912813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio } 9131bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith return 0; 9141bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith } 9151bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith 9161bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>()); 9171bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith switch (E->getStmtClass()) { 9181bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith default: break; 9191bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith case Expr::CompoundLiteralExprClass: { 9201bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith // Note that due to the nature of compound literals, this is guaranteed 9211bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith // to be the only use of the variable, so we just generate it here. 9221bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 92358c65fcb909c9c25d06507bcf41eb630b3d5e2daEli Friedman llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(), 92458c65fcb909c9c25d06507bcf41eb630b3d5e2daEli Friedman CLE->getType(), CGF); 9251bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith // FIXME: "Leaked" on failure. 9261bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith if (C) 9271bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), 9281bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith E->getType().isConstant(CGM.getContext()), 9291bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith llvm::GlobalValue::InternalLinkage, 9305e2d5dec7736f6f9292d4212dec67295909f1328Hans Wennborg C, ".compoundliteral", 0, 9315e2d5dec7736f6f9292d4212dec67295909f1328Hans Wennborg llvm::GlobalVariable::NotThreadLocal, 9321bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith CGM.getContext().getTargetAddressSpace(E->getType())); 9331bf9a9e6a5bdc0de7939908855dcddf46b661800Richard Smith return C; 934e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 9356143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar case Expr::StringLiteralClass: 9366143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 937eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case Expr::ObjCEncodeExprClass: 938eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); 9395ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson case Expr::ObjCStringLiteralClass: { 9405ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 9410d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall llvm::Constant *C = 9420d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall CGM.getObjCRuntime().GenerateConstantString(SL->getString()); 9433c4972def972f8ca44dcd0561779a12aaa6fec97Owen Anderson return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 9445ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson } 94535345640442594acbc29445fbde4874a6e4c860aChris Lattner case Expr::PredefinedExprClass: { 946f70b24e7fa15d72506534af43d4090bb37a32694Eli Friedman unsigned Type = cast<PredefinedExpr>(E)->getIdentType(); 947f70b24e7fa15d72506534af43d4090bb37a32694Eli Friedman if (CGF) { 9483ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E)); 949f70b24e7fa15d72506534af43d4090bb37a32694Eli Friedman return cast<llvm::Constant>(Res.getAddress()); 950f70b24e7fa15d72506534af43d4090bb37a32694Eli Friedman } else if (Type == PredefinedExpr::PrettyFunction) { 951f70b24e7fa15d72506534af43d4090bb37a32694Eli Friedman return CGM.GetAddrOfConstantCString("top level", ".tmp"); 952f70b24e7fa15d72506534af43d4090bb37a32694Eli Friedman } 9531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 954f70b24e7fa15d72506534af43d4090bb37a32694Eli Friedman return CGM.GetAddrOfConstantCString("", ".tmp"); 95535345640442594acbc29445fbde4874a6e4c860aChris Lattner } 956f01158941ba4560c63150032073bb231ce38999eEli Friedman case Expr::AddrLabelExprClass: { 957f01158941ba4560c63150032073bb231ce38999eEli Friedman assert(CGF && "Invalid address of label expression outside function."); 958d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Constant *Ptr = 959d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 960d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType())); 961f01158941ba4560c63150032073bb231ce38999eEli Friedman } 9623941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman case Expr::CallExprClass: { 9633941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman CallExpr* CE = cast<CallExpr>(E); 964180f47959a066795cc0f409433023af448bb0328Richard Smith unsigned builtin = CE->isBuiltinCall(); 9650d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall if (builtin != 9660d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall Builtin::BI__builtin___CFStringMakeConstantString && 9670d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall builtin != 9680d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall Builtin::BI__builtin___NSStringMakeConstantString) 9693941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman break; 9703941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 9713941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman const StringLiteral *Literal = cast<StringLiteral>(Arg); 9720d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall if (builtin == 9730d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall Builtin::BI__builtin___NSStringMakeConstantString) { 9740d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall return CGM.getObjCRuntime().GenerateConstantString(Literal); 9750d13f6fdbdd6f06e2449b8834dda53334abd399aDavid Chisnall } 97633fdb738a6c125f4c788733897021b7c1a062b0cSteve Naroff // FIXME: need to deal with UCN conversion issues. 9778d4141f83d9de379547cf05bd75d4c6cf894b189Steve Naroff return CGM.GetAddrOfConstantCFString(Literal); 9783941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman } 979bd65cac8de63d108a681035782a71d42954b03abMike Stump case Expr::BlockExprClass: { 9804de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson std::string FunctionName; 9814de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson if (CGF) 9824de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson FunctionName = CGF->CurFn->getName(); 9834de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson else 9844de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson FunctionName = "global"; 9854de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson 9864de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); 987bd65cac8de63d108a681035782a71d42954b03abMike Stump } 98847d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith case Expr::CXXTypeidExprClass: { 98947d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E); 99047d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith QualType T; 99147d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith if (Typeid->isTypeOperand()) 99247d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith T = Typeid->getTypeOperand(); 99347d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith else 99447d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith T = Typeid->getExprOperand()->getType(); 99547d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith return CGM.GetAddrOfRTTIDescriptor(T); 99647d2145675099893d702be4bc06bd9f26d8ddd13Richard Smith } 997c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber case Expr::CXXUuidofExprClass: { 998c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber return CGM.GetAddrOfUuidDescriptor(cast<CXXUuidofExpr>(E)); 999c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber } 1000546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman } 1001d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar 1002d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return 0; 1003e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 1004e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson}; 10051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10063b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson} // end anonymous namespace. 10073b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 10082d6a5670465cb3f1d811695a9f23e372508240d2Richard Smithllvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D, 10092d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CodeGenFunction *CGF) { 1010c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian // Make a quick check if variable can be default NULL initialized 1011c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian // and avoid going through rest of code which may do, for c++11, 1012c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian // initialization of memory to all NULLs. 1013c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian if (!D.hasLocalStorage()) { 1014c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian QualType Ty = D.getType(); 1015c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian if (Ty->isArrayType()) 1016c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian Ty = Context.getBaseElementType(Ty); 1017c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian if (Ty->isRecordType()) 1018c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian if (const CXXConstructExpr *E = 1019c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian dyn_cast_or_null<CXXConstructExpr>(D.getInit())) { 1020c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian const CXXConstructorDecl *CD = E->getConstructor(); 1021c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian if (CD->isTrivial() && CD->isDefaultConstructor() && 1022c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian Ty->getAsCXXRecordDecl()->hasTrivialDestructor()) 1023c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian return EmitNullConstant(D.getType()); 1024c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian } 1025c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian } 1026c2316db5decd9cb7f8768ca67fad41fd8cffc110Fariborz Jahanian 10272d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (const APValue *Value = D.evaluateValue()) 1028a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith return EmitConstantValueForMemory(*Value, D.getType(), CGF); 10292d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 10307ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a 10317ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith // reference is a constant expression, and the reference binds to a temporary, 10327ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith // then constant initialization is performed. ConstExprEmitter will 10337ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith // incorrectly emit a prvalue constant in this case, and the calling code 10347ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith // interprets that as the (pointer) value of the reference, rather than the 10357ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith // desired value of the referee. 10367ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith if (D.getType()->isReferenceType()) 10377ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith return 0; 10387ca4850a3e3530fa6c93b64b740446e32c97f992Richard Smith 10392d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const Expr *E = D.getInit(); 10402d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(E && "No initializer to emit"); 10412d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 10422d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 10432d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (C && C->getType()->isIntegerTy(1)) { 10442d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 10452d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith C = llvm::ConstantExpr::getZExt(C, BoolTy); 10462d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 10472d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return C; 10482d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith} 10492d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 1050813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venanciollvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 1051e9352cc9818ba59e7cf88500ef048991c90f3821Anders Carlsson QualType DestType, 10529619662a1d42e2008b865d3459c0677e149dad1bChris Lattner CodeGenFunction *CGF) { 10534b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson Expr::EvalResult Result; 10541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10551e5dc6e12ccda4e783c67fa9ae11be419d7b0573Anders Carlsson bool Success = false; 10561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 105750c39ea4858265f3f5f42a0c624557ce2281936bEli Friedman if (DestType->isReferenceType()) 105850c39ea4858265f3f5f42a0c624557ce2281936bEli Friedman Success = E->EvaluateAsLValue(Result, Context); 10591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else 106051f4708c00110940ca3f337961915f2ca1668375Richard Smith Success = E->EvaluateAsRValue(Result, Context); 10611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1062a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith llvm::Constant *C = 0; 10632d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (Success && !Result.HasSideEffects) 1064a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith C = EmitConstantValue(Result.Val, DestType, CGF); 1065a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith else 1066a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 1067e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 10682d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (C && C->getType()->isIntegerTy(1)) { 10692d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 10702d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith C = llvm::ConstantExpr::getZExt(C, BoolTy); 10712d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 10722d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return C; 10732d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith} 1074e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 10752d6a5670465cb3f1d811695a9f23e372508240d2Richard Smithllvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value, 10762d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith QualType DestType, 10772d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CodeGenFunction *CGF) { 10782d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith switch (Value.getKind()) { 10792d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::Uninitialized: 10802d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm_unreachable("Constant expressions should be initialized."); 10812d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::LValue: { 10822d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType); 10832d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *Offset = 10848b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity()); 10852d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 10862d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *C; 10872d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (APValue::LValueBase LVBase = Value.getLValueBase()) { 10882d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // An array can be represented as an lvalue referring to the base. 10892d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (isa<llvm::ArrayType>(DestTy)) { 10902d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith assert(Offset->isNullValue() && "offset on array initializer"); 10912d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return ConstExprEmitter(*this, CGF).Visit( 10922d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const_cast<Expr*>(LVBase.get<const Expr*>())); 10932d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 1094e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 10952d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase); 1096e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 10972d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Apply offset if necessary. 10982d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (!Offset->isNullValue()) { 10998b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Int8PtrTy); 11002d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset); 11012d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith C = llvm::ConstantExpr::getBitCast(Casted, C->getType()); 11025ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson } 11031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11042d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Convert to the appropriate type; this could be an lvalue for 11052d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // an integer. 11062d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (isa<llvm::PointerType>(DestTy)) 11072d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantExpr::getBitCast(C, DestTy); 11081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11092d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantExpr::getPtrToInt(C, DestTy); 11102d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } else { 11112d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith C = Offset; 1112d06fea8580658470f92fb5d0d3d7ab5b475728dcAnton Yartsev 11132d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Convert to the appropriate type; this could be an lvalue for 11142d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // an integer. 11152d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (isa<llvm::PointerType>(DestTy)) 11162d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantExpr::getIntToPtr(C, DestTy); 1117d06fea8580658470f92fb5d0d3d7ab5b475728dcAnton Yartsev 11182d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // If the types don't match this should only be a truncate. 11192d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (C->getType() != DestTy) 11202d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantExpr::getTrunc(C, DestTy); 1121d06fea8580658470f92fb5d0d3d7ab5b475728dcAnton Yartsev 11222d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return C; 11233d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman } 11242d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 1125a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith case APValue::Int: 1126a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith return llvm::ConstantInt::get(VMContext, Value.getInt()); 11272d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::ComplexInt: { 11282d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *Complex[2]; 11292d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 11302d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Complex[0] = llvm::ConstantInt::get(VMContext, 11312d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Value.getComplexIntReal()); 11322d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Complex[1] = llvm::ConstantInt::get(VMContext, 11332d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Value.getComplexIntImag()); 11342d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 11352d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // FIXME: the target may want to specify that this is packed. 11362d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), 11372d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Complex[1]->getType(), 11382d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith NULL); 11392d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantStruct::get(STy, Complex); 11402d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 11412d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::Float: { 11422d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const llvm::APFloat &Init = Value.getFloat(); 114319dbb20ac4371fae3190379a7e7bd467af3c00aaJoey Gouly if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf && 114419dbb20ac4371fae3190379a7e7bd467af3c00aaJoey Gouly !Context.getLangOpts().NativeHalfType) 11452d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt()); 11462d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith else 11472d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantFP::get(VMContext, Init); 11482d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 11492d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::ComplexFloat: { 11502d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *Complex[2]; 11512d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 11522d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Complex[0] = llvm::ConstantFP::get(VMContext, 11532d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Value.getComplexFloatReal()); 11542d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Complex[1] = llvm::ConstantFP::get(VMContext, 11552d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Value.getComplexFloatImag()); 11562d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 11572d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // FIXME: the target may want to specify that this is packed. 11582d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(), 11592d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Complex[1]->getType(), 11602d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith NULL); 11612d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantStruct::get(STy, Complex); 11622d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 11632d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::Vector: { 11642d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith SmallVector<llvm::Constant *, 4> Inits; 11652d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith unsigned NumElts = Value.getVectorLength(); 11662d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 11672d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith for (unsigned i = 0; i != NumElts; ++i) { 11682d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const APValue &Elt = Value.getVectorElt(i); 11692d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (Elt.isInt()) 11702d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt())); 11712d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith else 11722d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat())); 11735a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson } 11742d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantVector::get(Inits); 11755a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson } 11762d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::AddrLabelDiff: { 11772d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS(); 11782d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS(); 11792d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF); 11802d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF); 11812d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 11822d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Compute difference 11832d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Type *ResultType = getTypes().ConvertType(DestType); 11842d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy); 11852d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy); 11862d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS); 11872d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 11882d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // LLVM is a bit sensitive about the exact format of the 11892d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // address-of-label difference; make sure to truncate after 11902d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // the subtraction. 11912d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType); 11922d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 11932d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::Struct: 11942d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::Union: 11952d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType); 11962d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::Array: { 11972d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith const ArrayType *CAT = Context.getAsArrayType(DestType); 11982d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith unsigned NumElements = Value.getArraySize(); 11992d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith unsigned NumInitElts = Value.getArrayInitializedElts(); 12007dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman 12012d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith std::vector<llvm::Constant*> Elts; 12022d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Elts.reserve(NumElements); 12032d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 12042d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Emit array filler, if there is one. 12052d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *Filler = 0; 12062d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (Value.hasArrayFiller()) 1207a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith Filler = EmitConstantValueForMemory(Value.getArrayFiller(), 1208a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith CAT->getElementType(), CGF); 12092d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 12102d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // Emit initializer elements. 12112d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Type *CommonElementType = 0; 12122d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith for (unsigned I = 0; I < NumElements; ++I) { 12132d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::Constant *C = Filler; 12142d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (I < NumInitElts) 1215a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I), 1216a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith CAT->getElementType(), CGF); 121741f3f3a4792f46787632fdb94f952f6b3ce3f4aeJordan Rose else 121841f3f3a4792f46787632fdb94f952f6b3ce3f4aeJordan Rose assert(Filler && "Missing filler for implicit elements of initializer"); 12192d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (I == 0) 12202d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CommonElementType = C->getType(); 12212d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith else if (C->getType() != CommonElementType) 12222d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith CommonElementType = 0; 12232d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Elts.push_back(C); 12242d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 12252d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 12262d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith if (!CommonElementType) { 12272d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith // FIXME: Try to avoid packing the array 12282d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith std::vector<llvm::Type*> Types; 1229f9ea953f22d8e50cae7fd541406d6f563ef86cdaBill Wendling Types.reserve(NumElements); 1230fd3e5ef640df089a1e717097cdb599eb9dd32ec4Bill Wendling for (unsigned i = 0, e = Elts.size(); i < e; ++i) 12312d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith Types.push_back(Elts[i]->getType()); 12322d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true); 12332d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantStruct::get(SType, Elts); 12342d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 12352d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith 12362d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::ArrayType *AType = 12372d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm::ArrayType::get(CommonElementType, NumElements); 12382d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return llvm::ConstantArray::get(AType, Elts); 12397dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman } 12402d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith case APValue::MemberPointer: 12412d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith return getCXXABI().EmitMemberPointer(Value, DestType); 12422d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith } 12432d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith llvm_unreachable("Unknown APValue kind"); 12443b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson} 12450f59312e7b625fa5821a63db65377d4b3b667e99Eli Friedman 12467401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smithllvm::Constant * 1247a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard SmithCodeGenModule::EmitConstantValueForMemory(const APValue &Value, 1248a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith QualType DestType, 1249a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith CodeGenFunction *CGF) { 1250a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith llvm::Constant *C = EmitConstantValue(Value, DestType, CGF); 1251a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith if (C->getType()->isIntegerTy(1)) { 1252a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType); 1253a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith C = llvm::ConstantExpr::getZExt(C, BoolTy); 1254a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith } 1255a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith return C; 1256a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith} 1257a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smith 1258a3ca41f0c2bd1c4a752df88b283332f3b757d21eRichard Smithllvm::Constant * 12597401cf524cdb7aad4951d8727d280f8b271af5a2Richard SmithCodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) { 12607401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith assert(E->isFileScope() && "not a file-scope compound literal expr"); 12617401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith return ConstExprEmitter(*this, 0).EmitLValue(E); 12627401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith} 12637401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith 12645808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCallllvm::Constant * 12655808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCallCodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) { 12665808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall // Member pointer constants always have a very particular form. 12675808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall const MemberPointerType *type = cast<MemberPointerType>(uo->getType()); 12685808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl(); 12695808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 12705808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall // A member function pointer. 12715808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl)) 12725808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall return getCXXABI().EmitMemberPointer(method); 12735808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 12745808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall // Otherwise, a member data pointer. 12752d6a5670465cb3f1d811695a9f23e372508240d2Richard Smith uint64_t fieldOffset = getContext().getFieldOffset(decl); 12765808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset); 12775808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall return getCXXABI().EmitMemberDataPointer(type, chars); 12785808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall} 12795808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 1280a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlssonstatic void 1281a83fb4bf8119b980ccf7de0795dff250a799ea58Anders CarlssonFillInNullDataMemberPointers(CodeGenModule &CGM, QualType T, 128235f18a5e8b5a434894a4886ed98f3dbaa3b895c0Bill Wendling SmallVectorImpl<llvm::Constant *> &Elements, 1283a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson uint64_t StartOffset) { 1284c4d68db1397b1c1a0a2fb33464dc65f9c51aec09Ken Dyck assert(StartOffset % CGM.getContext().getCharWidth() == 0 && 1285c4d68db1397b1c1a0a2fb33464dc65f9c51aec09Ken Dyck "StartOffset not byte aligned!"); 1286a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1287f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (CGM.getTypes().isZeroInitializable(T)) 1288a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson return; 1289a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1290a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson if (const ConstantArrayType *CAT = 1291a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson CGM.getContext().getAsConstantArrayType(T)) { 1292a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson QualType ElementTy = CAT->getElementType(); 1293a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy); 1294a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1295a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) { 1296a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson FillInNullDataMemberPointers(CGM, ElementTy, Elements, 1297a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson StartOffset + I * ElementSize); 1298a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson } 1299a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson } else if (const RecordType *RT = T->getAs<RecordType>()) { 1300a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1301a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 1302a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1303a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson // Go through all bases and fill in any null pointer to data members. 1304a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1305a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson E = RD->bases_end(); I != E; ++I) { 13060a87b377d9a8af87ebc99585be96aac2d36ccfcbAnders Carlsson if (I->isVirtual()) { 1307ada4b32749458644272d90e34e4149c307376e59Anders Carlsson // Ignore virtual bases. 13080a87b377d9a8af87ebc99585be96aac2d36ccfcbAnders Carlsson continue; 13090a87b377d9a8af87ebc99585be96aac2d36ccfcbAnders Carlsson } 1310a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1311a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson const CXXRecordDecl *BaseDecl = 1312a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 1313a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1314a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson // Ignore empty bases. 1315a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson if (BaseDecl->isEmpty()) 1316a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson continue; 1317a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1318a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson // Ignore bases that don't have any pointer to data members. 1319f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (CGM.getTypes().isZeroInitializable(BaseDecl)) 1320a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson continue; 1321a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1322d4f5198ae07d9a4958d8191bac694ded12173ad9Benjamin Kramer uint64_t BaseOffset = 1323d4f5198ae07d9a4958d8191bac694ded12173ad9Benjamin Kramer CGM.getContext().toBits(Layout.getBaseClassOffset(BaseDecl)); 1324a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson FillInNullDataMemberPointers(CGM, I->getType(), 1325a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson Elements, StartOffset + BaseOffset); 1326a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson } 1327a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1328a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson // Visit all fields. 1329a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson unsigned FieldNo = 0; 1330a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson for (RecordDecl::field_iterator I = RD->field_begin(), 1331a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson E = RD->field_end(); I != E; ++I, ++FieldNo) { 1332a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson QualType FieldType = I->getType(); 1333a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1334f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (CGM.getTypes().isZeroInitializable(FieldType)) 1335a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson continue; 1336a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1337a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo); 1338a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset); 1339a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson } 1340a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson } else { 1341a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson assert(T->isMemberPointerType() && "Should only see member pointers here!"); 1342a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() && 1343a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson "Should only see pointers to data members here!"); 1344a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1345c4d68db1397b1c1a0a2fb33464dc65f9c51aec09Ken Dyck CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset); 1346c4d68db1397b1c1a0a2fb33464dc65f9c51aec09Ken Dyck CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T); 1347a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 13485808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall // FIXME: hardcodes Itanium member pointer representation! 1349a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson llvm::Constant *NegativeOne = 13508b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::ConstantInt::get(CGM.Int8Ty, -1ULL, /*isSigned*/true); 1351a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 1352a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson // Fill in the null data member pointer. 1353c4d68db1397b1c1a0a2fb33464dc65f9c51aec09Ken Dyck for (CharUnits I = StartIndex; I != EndIndex; ++I) 1354c4d68db1397b1c1a0a2fb33464dc65f9c51aec09Ken Dyck Elements[I.getQuantity()] = NegativeOne; 1355a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson } 1356a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson} 1357a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson 13589b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCallstatic llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 13592acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *baseType, 13609b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall const CXXRecordDecl *base); 1361ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 13629b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCallstatic llvm::Constant *EmitNullConstant(CodeGenModule &CGM, 13639b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall const CXXRecordDecl *record, 13649b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall bool asCompleteObject) { 13659b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record); 13662acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::StructType *structure = 13679b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall (asCompleteObject ? layout.getLLVMType() 13689b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall : layout.getBaseSubobjectLLVMType()); 13699b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 13709b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall unsigned numElements = structure->getNumElements(); 13719b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall std::vector<llvm::Constant *> elements(numElements); 13729b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 13739b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Fill in all the bases. 13749b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall for (CXXRecordDecl::base_class_const_iterator 13759b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall I = record->bases_begin(), E = record->bases_end(); I != E; ++I) { 1376ada4b32749458644272d90e34e4149c307376e59Anders Carlsson if (I->isVirtual()) { 13779b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Ignore virtual bases; if we're laying out for a complete 13789b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // object, we'll lay these out later. 1379ada4b32749458644272d90e34e4149c307376e59Anders Carlsson continue; 1380ada4b32749458644272d90e34e4149c307376e59Anders Carlsson } 1381ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 13829b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall const CXXRecordDecl *base = 13839b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 1384ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 1385ada4b32749458644272d90e34e4149c307376e59Anders Carlsson // Ignore empty bases. 13869b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (base->isEmpty()) 1387ada4b32749458644272d90e34e4149c307376e59Anders Carlsson continue; 1388ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 13899b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base); 13902acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *baseType = structure->getElementType(fieldIndex); 13919b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 1392ada4b32749458644272d90e34e4149c307376e59Anders Carlsson } 1393ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 13949b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Fill in all the fields. 13959b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall for (RecordDecl::field_iterator I = record->field_begin(), 13969b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall E = record->field_end(); I != E; ++I) { 1397581deb3da481053c4993c7600f97acf7768caac5David Blaikie const FieldDecl *field = *I; 139826e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman 139926e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman // Fill in non-bitfields. (Bitfields always use a zero pattern, which we 140026e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman // will fill in later.) 140126e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman if (!field->isBitField()) { 140226e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman unsigned fieldIndex = layout.getLLVMFieldNo(field); 140326e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman elements[fieldIndex] = CGM.EmitNullConstant(field->getType()); 140426e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman } 140526e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman 140626e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman // For unions, stop after the first named field. 140726e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman if (record->isUnion() && field->getDeclName()) 140826e80cdfe8933a7f804e1d05b379d5ad50119db5Eli Friedman break; 14099b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall } 14109b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14119b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Fill in the virtual bases, if we're working with the complete object. 14129b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (asCompleteObject) { 14139b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall for (CXXRecordDecl::base_class_const_iterator 14149b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall I = record->vbases_begin(), E = record->vbases_end(); I != E; ++I) { 14159b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall const CXXRecordDecl *base = 14169b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl()); 14179b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14189b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Ignore empty bases. 14199b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (base->isEmpty()) 14209b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall continue; 14219b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14229b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall unsigned fieldIndex = layout.getVirtualBaseIndex(base); 14239b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14249b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // We might have already laid this field out. 14259b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (elements[fieldIndex]) continue; 14269b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14272acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *baseType = structure->getElementType(fieldIndex); 14289b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base); 14299b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall } 1430ada4b32749458644272d90e34e4149c307376e59Anders Carlsson } 1431ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 1432ada4b32749458644272d90e34e4149c307376e59Anders Carlsson // Now go through all other fields and zero them out. 14339b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall for (unsigned i = 0; i != numElements; ++i) { 14349b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (!elements[i]) 14359b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall elements[i] = llvm::Constant::getNullValue(structure->getElementType(i)); 1436ada4b32749458644272d90e34e4149c307376e59Anders Carlsson } 1437ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 14389b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall return llvm::ConstantStruct::get(structure, elements); 14399b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall} 14409b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14419b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall/// Emit the null constant for a base subobject. 14429b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCallstatic llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM, 14432acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *baseType, 14449b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall const CXXRecordDecl *base) { 14459b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base); 14469b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14479b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Just zero out bases that don't have any pointer to data members. 14489b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (baseLayout.isZeroInitializableAsBase()) 14499b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall return llvm::Constant::getNullValue(baseType); 14509b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14519b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // If the base type is a struct, we can just use its null constant. 14529b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (isa<llvm::StructType>(baseType)) { 14539b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall return EmitNullConstant(CGM, base, /*complete*/ false); 14549b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall } 14559b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14569b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Otherwise, some bases are represented as arrays of i8 if the size 14579b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // of the base is smaller than its corresponding LLVM type. Figure 14589b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // out how many elements this base array has. 14592acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::ArrayType *baseArrayType = cast<llvm::ArrayType>(baseType); 14609b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall unsigned numBaseElements = baseArrayType->getNumElements(); 14619b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14629b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Fill in null data member pointers. 146335f18a5e8b5a434894a4886ed98f3dbaa3b895c0Bill Wendling SmallVector<llvm::Constant *, 16> baseElements(numBaseElements); 14649b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base), 14659b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall baseElements, 0); 14669b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14679b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall // Now go through all other elements and zero them out. 14689b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (numBaseElements) { 14698b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::Constant *i8_zero = llvm::Constant::getNullValue(CGM.Int8Ty); 14709b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall for (unsigned i = 0; i != numBaseElements; ++i) { 14719b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall if (!baseElements[i]) 14729b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall baseElements[i] = i8_zero; 14739b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall } 14749b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall } 14759b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall 14769b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall return llvm::ConstantArray::get(baseArrayType, baseElements); 1477ada4b32749458644272d90e34e4149c307376e59Anders Carlsson} 1478ada4b32749458644272d90e34e4149c307376e59Anders Carlsson 14790f59312e7b625fa5821a63db65377d4b3b667e99Eli Friedmanllvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { 1480f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (getTypes().isZeroInitializable(T)) 1481ad3e7118c40711faf5f51f08d599dbd525d3408aAnders Carlsson return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T)); 14822c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson 1483237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) { 14846ef016f87244aa8072394687e27b3b4fa0147028Chris Lattner llvm::ArrayType *ATy = 14856ef016f87244aa8072394687e27b3b4fa0147028Chris Lattner cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T)); 14861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1487237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson QualType ElementTy = CAT->getElementType(); 1488237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson 14892c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson llvm::Constant *Element = EmitNullConstant(ElementTy); 14902c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson unsigned NumElements = CAT->getSize().getZExtValue(); 14916ef016f87244aa8072394687e27b3b4fa0147028Chris Lattner 14926ef016f87244aa8072394687e27b3b4fa0147028Chris Lattner if (Element->isNullValue()) 14936ef016f87244aa8072394687e27b3b4fa0147028Chris Lattner return llvm::ConstantAggregateZero::get(ATy); 14946ef016f87244aa8072394687e27b3b4fa0147028Chris Lattner 14956ef016f87244aa8072394687e27b3b4fa0147028Chris Lattner SmallVector<llvm::Constant *, 8> Array(NumElements, Element); 14962c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson return llvm::ConstantArray::get(ATy, Array); 1497237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson } 1498fc3eaa47fa2ef70ab21131005c328adda3020737Anders Carlsson 1499fc3eaa47fa2ef70ab21131005c328adda3020737Anders Carlsson if (const RecordType *RT = T->getAs<RecordType>()) { 15002c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 15019b7da1c46d6d2849f9cb51328d7fcddf2c417672John McCall return ::EmitNullConstant(*this, RD, /*complete object*/ true); 1502fc3eaa47fa2ef70ab21131005c328adda3020737Anders Carlsson } 15031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1504a83fb4bf8119b980ccf7de0795dff250a799ea58Anders Carlsson assert(T->isMemberPointerType() && "Should only see member pointers here!"); 15052c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() && 15062c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson "Should only see pointers to data members here!"); 15072c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson 15082c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson // Itanium C++ ABI 2.3: 15092c12d0319a267b844cb7d569d84426cd344b90f7Anders Carlsson // A NULL pointer is represented as -1. 15105808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>()); 15110f59312e7b625fa5821a63db65377d4b3b667e99Eli Friedman} 15122ed7cb649aa709b875c519f4a980a1e2b5712370Eli Friedman 15132ed7cb649aa709b875c519f4a980a1e2b5712370Eli Friedmanllvm::Constant * 15142ed7cb649aa709b875c519f4a980a1e2b5712370Eli FriedmanCodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) { 15152ed7cb649aa709b875c519f4a980a1e2b5712370Eli Friedman return ::EmitNullConstant(*this, Record, false); 15162ed7cb649aa709b875c519f4a980a1e2b5712370Eli Friedman} 1517