CGExprConstant.cpp revision 4c98efdf06f94da20a640aa36f6a4f3284c26bff
1ec3ed6a5ebf6f2c406d7bcf94b6bc34fcaeb976eepoger@google.com//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===// 2ec3ed6a5ebf6f2c406d7bcf94b6bc34fcaeb976eepoger@google.com// 3ec3ed6a5ebf6f2c406d7bcf94b6bc34fcaeb976eepoger@google.com// The LLVM Compiler Infrastructure 4ec3ed6a5ebf6f2c406d7bcf94b6bc34fcaeb976eepoger@google.com// 5ec3ed6a5ebf6f2c406d7bcf94b6bc34fcaeb976eepoger@google.com// This file is distributed under the University of Illinois Open Source 6ec3ed6a5ebf6f2c406d7bcf94b6bc34fcaeb976eepoger@google.com// License. See LICENSE.TXT for details. 7ec3ed6a5ebf6f2c406d7bcf94b6bc34fcaeb976eepoger@google.com// 88a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com//===----------------------------------------------------------------------===// 98a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com// 108a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com// This contains code to emit Constant Expr nodes as LLVM code. 118a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com// 128a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com//===----------------------------------------------------------------------===// 138a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 148a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "CodeGenFunction.h" 158a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "CodeGenModule.h" 168a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "CGObjCRuntime.h" 178a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "clang/AST/APValue.h" 188a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "clang/AST/ASTContext.h" 198a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "clang/AST/RecordLayout.h" 208a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "clang/AST/StmtVisitor.h" 218a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "clang/Basic/Builtins.h" 228a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "llvm/Constants.h" 238a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "llvm/Function.h" 248a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "llvm/GlobalVariable.h" 258a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "llvm/Support/Compiler.h" 268a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com#include "llvm/Target/TargetData.h" 278a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.comusing namespace clang; 288a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.comusing namespace CodeGen; 298a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 308a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.comnamespace { 315119bdb952025a30f115b9c6a187173956e55097reed@android.com 325119bdb952025a30f115b9c6a187173956e55097reed@android.comclass VISIBILITY_HIDDEN ConstStructBuilder { 338a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com CodeGenModule &CGM; 348a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com CodeGenFunction *CGF; 358a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 368a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com bool Packed; 378a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com unsigned NextFieldOffsetInBytes; 388a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 398a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com std::vector<llvm::Constant *> Elements; 408a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 418a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF) 428a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com : CGM(CGM), CGF(CGF), Packed(false), NextFieldOffsetInBytes(0) { } 438a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 448a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com bool AppendField(const FieldDecl *Field, uint64_t FieldOffset, 458a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com const Expr *InitExpr) { 468a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com uint64_t FieldOffsetInBytes = FieldOffset / 8; 478a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 488a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com assert(NextFieldOffsetInBytes <= FieldOffsetInBytes 498a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com && "Field offset mismatch!"); 508a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 518a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com // Emit the field. 528a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com llvm::Constant *C = CGM.EmitConstantExpr(InitExpr, Field->getType(), CGF); 538a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (!C) 548a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return false; 558a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 568a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com unsigned FieldAlignment = getAlignment(C); 578a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 588a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com // Round up the field offset to the alignment of the field type. 598a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com uint64_t AlignedNextFieldOffsetInBytes = 608a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com llvm::RoundUpToAlignment(NextFieldOffsetInBytes, FieldAlignment); 618a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 628a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (AlignedNextFieldOffsetInBytes > FieldOffsetInBytes) { 638a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com // FIXME: Must convert the struct to a packed struct. 648a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return false; 658a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 668a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 678a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (AlignedNextFieldOffsetInBytes < FieldOffsetInBytes) { 688a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com // We need to append padding. 698a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com AppendPadding(FieldOffsetInBytes - AlignedNextFieldOffsetInBytes); 708a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 718a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com assert(NextFieldOffsetInBytes == FieldOffsetInBytes && 728a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com "Did not add enough padding!"); 738a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 748a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com AlignedNextFieldOffsetInBytes = NextFieldOffsetInBytes; 758a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 768a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 778a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com // Add the field. 788a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com Elements.push_back(C); 798a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com NextFieldOffsetInBytes = AlignedNextFieldOffsetInBytes + getSizeInBytes(C); 808a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 818a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return true; 828a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 838a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 848a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com void AppendPadding(uint64_t NumBytes) { 858a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (!NumBytes) 868a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return; 878a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 888a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com const llvm::Type *Ty = llvm::Type::Int8Ty; 898a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (NumBytes > 1) 908a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com Ty = CGM.getLLVMContext().getArrayType(Ty, NumBytes); 918a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 928a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com llvm::Constant *C = CGM.getLLVMContext().getNullValue(Ty); 938a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com Elements.push_back(C); 94ee467ee79d449ebe6ae7f7946e613cc70a479c69reed@google.com assert(getAlignment(C) == 1 && "Padding must have 1 byte alignment!"); 95ee467ee79d449ebe6ae7f7946e613cc70a479c69reed@google.com 9629e5054dd07c97c2195c5f64bf67aaa6b5afa204senorblanco@chromium.org NextFieldOffsetInBytes += getSizeInBytes(C); 978dd90a926a8660da2bacc7af149f4ac5b2e7c64ctomhudson@google.com } 988a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 998a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com void AppendTailPadding(uint64_t RecordSize) { 1008a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com assert(RecordSize % 8 == 0 && "Invalid record size!"); 1018a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1028a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com uint64_t RecordSizeInBytes = RecordSize / 8; 1038a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com assert(NextFieldOffsetInBytes <= RecordSizeInBytes && "Size mismatch!"); 1048a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1058a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com unsigned NumPadBytes = RecordSizeInBytes - NextFieldOffsetInBytes; 1068a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com AppendPadding(NumPadBytes); 1078a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 108dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com 1098a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com bool Build(const InitListExpr *ILE) { 110dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 111dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD); 1128a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 113dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com unsigned FieldNo = 0; 1148a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com unsigned ElementNo = 0; 1158a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com for (RecordDecl::field_iterator Field = RD->field_begin(), 1168a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com FieldEnd = RD->field_end(); 1178a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com ElementNo < ILE->getNumInits() && Field != FieldEnd; 118dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com ++Field, ++FieldNo) { 1198a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (Field->isBitField()) { 120dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com if (!Field->getIdentifier()) 121dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com continue; 122dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com 123b602b8e5334edc0bfcdf086c2ea58e2b5d5f1f3breed@android.com // FIXME: Bitfield support. 1248a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return false; 125dafaf7ac4d89f183dc515907665cdac3e3098466reed@android.com } else { 1268a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (!AppendField(*Field, Layout.getFieldOffset(FieldNo), 1278a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com ILE->getInit(ElementNo))) 1288a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return false; 1298a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 1308a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1318a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com ElementNo++; 1328a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 1333bafe74a29c37761082980ed4ee9b831256bd27ereed@google.com 1348a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com // Append tail padding if necessary. 1351750bf17635e788198200f971d9cb66f67399363reed@google.com AppendTailPadding(Layout.getSize()); 1363bafe74a29c37761082980ed4ee9b831256bd27ereed@google.com 1378a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com assert(Layout.getSize() / 8 == NextFieldOffsetInBytes && 138c4cae85752e3e486cf4eac8cd8128f57b6f40563reed@android.com "Tail padding mismatch!"); 139c4cae85752e3e486cf4eac8cd8128f57b6f40563reed@android.com 140c4cae85752e3e486cf4eac8cd8128f57b6f40563reed@android.com return true; 141c4cae85752e3e486cf4eac8cd8128f57b6f40563reed@android.com } 1423bafe74a29c37761082980ed4ee9b831256bd27ereed@google.com 1438a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com unsigned getAlignment(const llvm::Constant *C) const { 1448a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (Packed) 1453bafe74a29c37761082980ed4ee9b831256bd27ereed@google.com return 1; 1468a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1478a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return CGM.getTargetData().getABITypeAlignment(C->getType()); 1488a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 1491fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com 1508a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com uint64_t getSizeInBytes(const llvm::Constant *C) const { 1518a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return CGM.getTargetData().getTypeAllocSize(C->getType()); 1528a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 1538a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1548a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.compublic: 1558a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF, 1568a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com const InitListExpr *ILE) { 1578a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com ConstStructBuilder Builder(CGM, CGF); 1588a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1598a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com // FIXME: Use this when it works well enough. 1608a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return 0; 161981d4798007b91e2e19c13b171583927a56df63breed@google.com 1628a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com if (!Builder.Build(ILE)) 1638a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return 0; 1648a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1651fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com llvm::Constant *Result = 1661fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com CGM.getLLVMContext().getConstantStruct(Builder.Elements, Builder.Packed); 1671fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com 1681fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com assert(Builder.NextFieldOffsetInBytes == Builder.getSizeInBytes(Result)); 1691fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com 1701fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com return 0; 171981d4798007b91e2e19c13b171583927a56df63breed@google.com } 1721fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com}; 1731fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com 1741fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.comclass VISIBILITY_HIDDEN ConstExprEmitter : 1751fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 1761fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com CodeGenModule &CGM; 1771fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com CodeGenFunction *CGF; 1781fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com llvm::LLVMContext &VMContext; 1798a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.compublic: 1808a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 1818a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) { 1828a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com } 1838a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com 1841fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com //===--------------------------------------------------------------------===// 1851fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com // Visitor Methods 1861fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com //===--------------------------------------------------------------------===// 1871fc4c605def61d9e10489f9cd63dc378baa6ade3reed@android.com 1888a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com llvm::Constant *VisitStmt(Stmt *S) { 1898a1c16ff38322f0210116fa7293eb8817c7e477ereed@android.com return 0; 190 } 191 192 llvm::Constant *VisitParenExpr(ParenExpr *PE) { 193 return Visit(PE->getSubExpr()); 194 } 195 196 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 197 return Visit(E->getInitializer()); 198 } 199 200 llvm::Constant *VisitCastExpr(CastExpr* E) { 201 // GCC cast to union extension 202 if (E->getType()->isUnionType()) { 203 const llvm::Type *Ty = ConvertType(E->getType()); 204 Expr *SubExpr = E->getSubExpr(); 205 return EmitUnion(CGM.EmitConstantExpr(SubExpr, SubExpr->getType(), CGF), 206 Ty); 207 } 208 // Explicit and implicit no-op casts 209 QualType Ty = E->getType(), SubTy = E->getSubExpr()->getType(); 210 if (CGM.getContext().hasSameUnqualifiedType(Ty, SubTy)) { 211 return Visit(E->getSubExpr()); 212 } 213 return 0; 214 } 215 216 llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 217 return Visit(DAE->getExpr()); 218 } 219 220 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 221 std::vector<llvm::Constant*> Elts; 222 const llvm::ArrayType *AType = 223 cast<llvm::ArrayType>(ConvertType(ILE->getType())); 224 unsigned NumInitElements = ILE->getNumInits(); 225 // FIXME: Check for wide strings 226 // FIXME: Check for NumInitElements exactly equal to 1?? 227 if (NumInitElements > 0 && 228 (isa<StringLiteral>(ILE->getInit(0)) || 229 isa<ObjCEncodeExpr>(ILE->getInit(0))) && 230 ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType()) 231 return Visit(ILE->getInit(0)); 232 const llvm::Type *ElemTy = AType->getElementType(); 233 unsigned NumElements = AType->getNumElements(); 234 235 // Initialising an array requires us to automatically 236 // initialise any elements that have not been initialised explicitly 237 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 238 239 // Copy initializer elements. 240 unsigned i = 0; 241 bool RewriteType = false; 242 for (; i < NumInitableElts; ++i) { 243 Expr *Init = ILE->getInit(i); 244 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 245 if (!C) 246 return 0; 247 RewriteType |= (C->getType() != ElemTy); 248 Elts.push_back(C); 249 } 250 251 // Initialize remaining array elements. 252 // FIXME: This doesn't handle member pointers correctly! 253 for (; i < NumElements; ++i) 254 Elts.push_back(VMContext.getNullValue(ElemTy)); 255 256 if (RewriteType) { 257 // FIXME: Try to avoid packing the array 258 std::vector<const llvm::Type*> Types; 259 for (unsigned i = 0; i < Elts.size(); ++i) 260 Types.push_back(Elts[i]->getType()); 261 const llvm::StructType *SType = VMContext.getStructType(Types, true); 262 return VMContext.getConstantStruct(SType, Elts); 263 } 264 265 return VMContext.getConstantArray(AType, Elts); 266 } 267 268 void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts, 269 FieldDecl* Field, Expr* E) { 270 // Calculate the value to insert 271 llvm::Constant *C = CGM.EmitConstantExpr(E, Field->getType(), CGF); 272 if (!C) 273 return; 274 275 llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C); 276 if (!CI) { 277 CGM.ErrorUnsupported(E, "bitfield initialization"); 278 return; 279 } 280 llvm::APInt V = CI->getValue(); 281 282 // Calculate information about the relevant field 283 const llvm::Type* Ty = CI->getType(); 284 const llvm::TargetData &TD = CGM.getTypes().getTargetData(); 285 unsigned size = TD.getTypeAllocSizeInBits(Ty); 286 CodeGenTypes::BitFieldInfo Info = CGM.getTypes().getBitFieldInfo(Field); 287 unsigned FieldOffset = Info.FieldNo * size; 288 289 FieldOffset += Info.Start; 290 291 // Find where to start the insertion 292 // FIXME: This is O(n^2) in the number of bit-fields! 293 // FIXME: This won't work if the struct isn't completely packed! 294 unsigned offset = 0, i = 0; 295 while (offset < (FieldOffset & -8)) 296 offset += TD.getTypeAllocSizeInBits(Elts[i++]->getType()); 297 298 // Advance over 0 sized elements (must terminate in bounds since 299 // the bitfield must have a size). 300 while (TD.getTypeAllocSizeInBits(Elts[i]->getType()) == 0) 301 ++i; 302 303 // Promote the size of V if necessary 304 // FIXME: This should never occur, but currently it can because initializer 305 // constants are cast to bool, and because clang is not enforcing bitfield 306 // width limits. 307 if (Info.Size > V.getBitWidth()) 308 V.zext(Info.Size); 309 310 // Insert the bits into the struct 311 // FIXME: This algorthm is only correct on X86! 312 // FIXME: THis algorthm assumes bit-fields only have byte-size elements! 313 unsigned bitsToInsert = Info.Size; 314 unsigned curBits = std::min(8 - (FieldOffset & 7), bitsToInsert); 315 unsigned byte = V.getLoBits(curBits).getZExtValue() << (FieldOffset & 7); 316 do { 317 llvm::Constant* byteC = 318 VMContext.getConstantInt(llvm::Type::Int8Ty, byte); 319 Elts[i] = VMContext.getConstantExprOr(Elts[i], byteC); 320 ++i; 321 V = V.lshr(curBits); 322 bitsToInsert -= curBits; 323 324 if (!bitsToInsert) 325 break; 326 327 curBits = bitsToInsert > 8 ? 8 : bitsToInsert; 328 byte = V.getLoBits(curBits).getZExtValue(); 329 } while (true); 330 } 331 332 llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 333 ConstStructBuilder::BuildStruct(CGM, CGF, ILE); 334 335 const llvm::StructType *SType = 336 cast<llvm::StructType>(ConvertType(ILE->getType())); 337 RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 338 std::vector<llvm::Constant*> Elts; 339 340 // Initialize the whole structure to zero. 341 // FIXME: This doesn't handle member pointers correctly! 342 for (unsigned i = 0; i < SType->getNumElements(); ++i) { 343 const llvm::Type *FieldTy = SType->getElementType(i); 344 Elts.push_back(VMContext.getNullValue(FieldTy)); 345 } 346 347 // Copy initializer elements. Skip padding fields. 348 unsigned EltNo = 0; // Element no in ILE 349 bool RewriteType = false; 350 for (RecordDecl::field_iterator Field = RD->field_begin(), 351 FieldEnd = RD->field_end(); 352 EltNo < ILE->getNumInits() && Field != FieldEnd; ++Field) { 353 if (Field->isBitField()) { 354 if (!Field->getIdentifier()) 355 continue; 356 InsertBitfieldIntoStruct(Elts, *Field, ILE->getInit(EltNo)); 357 } else { 358 unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(*Field); 359 llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), 360 Field->getType(), CGF); 361 if (!C) return 0; 362 RewriteType |= (C->getType() != Elts[FieldNo]->getType()); 363 Elts[FieldNo] = C; 364 } 365 EltNo++; 366 } 367 368 if (RewriteType) { 369 // FIXME: Make this work for non-packed structs 370 assert(SType->isPacked() && "Cannot recreate unpacked structs"); 371 std::vector<const llvm::Type*> Types; 372 for (unsigned i = 0; i < Elts.size(); ++i) 373 Types.push_back(Elts[i]->getType()); 374 SType = VMContext.getStructType(Types, true); 375 } 376 377 return VMContext.getConstantStruct(SType, Elts); 378 } 379 380 llvm::Constant *EmitUnion(llvm::Constant *C, const llvm::Type *Ty) { 381 if (!C) 382 return 0; 383 384 // Build a struct with the union sub-element as the first member, 385 // and padded to the appropriate size 386 std::vector<llvm::Constant*> Elts; 387 std::vector<const llvm::Type*> Types; 388 Elts.push_back(C); 389 Types.push_back(C->getType()); 390 unsigned CurSize = CGM.getTargetData().getTypeAllocSize(C->getType()); 391 unsigned TotalSize = CGM.getTargetData().getTypeAllocSize(Ty); 392 393 assert(CurSize <= TotalSize && "Union size mismatch!"); 394 if (unsigned NumPadBytes = TotalSize - CurSize) { 395 const llvm::Type *Ty = llvm::Type::Int8Ty; 396 if (NumPadBytes > 1) 397 Ty = VMContext.getArrayType(Ty, NumPadBytes); 398 399 Elts.push_back(VMContext.getNullValue(Ty)); 400 Types.push_back(Ty); 401 } 402 403 llvm::StructType* STy = VMContext.getStructType(Types, false); 404 return VMContext.getConstantStruct(STy, Elts); 405 } 406 407 llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 408 const llvm::Type *Ty = ConvertType(ILE->getType()); 409 410 FieldDecl* curField = ILE->getInitializedFieldInUnion(); 411 if (!curField) { 412 // There's no field to initialize, so value-initialize the union. 413#ifndef NDEBUG 414 // Make sure that it's really an empty and not a failure of 415 // semantic analysis. 416 RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 417 for (RecordDecl::field_iterator Field = RD->field_begin(), 418 FieldEnd = RD->field_end(); 419 Field != FieldEnd; ++Field) 420 assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed"); 421#endif 422 return VMContext.getNullValue(Ty); 423 } 424 425 if (curField->isBitField()) { 426 // Create a dummy struct for bit-field insertion 427 unsigned NumElts = CGM.getTargetData().getTypeAllocSize(Ty); 428 llvm::Constant* NV = 429 VMContext.getNullValue(llvm::Type::Int8Ty); 430 std::vector<llvm::Constant*> Elts(NumElts, NV); 431 432 InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0)); 433 const llvm::ArrayType *RetTy = 434 VMContext.getArrayType(NV->getType(), NumElts); 435 return VMContext.getConstantArray(RetTy, Elts); 436 } 437 438 llvm::Constant *InitElem; 439 if (ILE->getNumInits() > 0) { 440 Expr *Init = ILE->getInit(0); 441 InitElem = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 442 } else { 443 InitElem = CGM.EmitNullConstant(curField->getType()); 444 } 445 return EmitUnion(InitElem, Ty); 446 } 447 448 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) { 449 const llvm::VectorType *VType = 450 cast<llvm::VectorType>(ConvertType(ILE->getType())); 451 const llvm::Type *ElemTy = VType->getElementType(); 452 std::vector<llvm::Constant*> Elts; 453 unsigned NumElements = VType->getNumElements(); 454 unsigned NumInitElements = ILE->getNumInits(); 455 456 unsigned NumInitableElts = std::min(NumInitElements, NumElements); 457 458 // Copy initializer elements. 459 unsigned i = 0; 460 for (; i < NumInitableElts; ++i) { 461 Expr *Init = ILE->getInit(i); 462 llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF); 463 if (!C) 464 return 0; 465 Elts.push_back(C); 466 } 467 468 for (; i < NumElements; ++i) 469 Elts.push_back(VMContext.getNullValue(ElemTy)); 470 471 return VMContext.getConstantVector(VType, Elts); 472 } 473 474 llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 475 return CGM.EmitNullConstant(E->getType()); 476 } 477 478 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 479 if (ILE->getType()->isScalarType()) { 480 // We have a scalar in braces. Just use the first element. 481 if (ILE->getNumInits() > 0) { 482 Expr *Init = ILE->getInit(0); 483 return CGM.EmitConstantExpr(Init, Init->getType(), CGF); 484 } 485 return CGM.EmitNullConstant(ILE->getType()); 486 } 487 488 if (ILE->getType()->isArrayType()) 489 return EmitArrayInitialization(ILE); 490 491 if (ILE->getType()->isStructureType()) 492 return EmitStructInitialization(ILE); 493 494 if (ILE->getType()->isUnionType()) 495 return EmitUnionInitialization(ILE); 496 497 if (ILE->getType()->isVectorType()) 498 return EmitVectorInitialization(ILE); 499 500 assert(0 && "Unable to handle InitListExpr"); 501 // Get rid of control reaches end of void function warning. 502 // Not reached. 503 return 0; 504 } 505 506 llvm::Constant *VisitStringLiteral(StringLiteral *E) { 507 assert(!E->getType()->isPointerType() && "Strings are always arrays"); 508 509 // This must be a string initializing an array in a static initializer. 510 // Don't emit it as the address of the string, emit the string data itself 511 // as an inline array. 512 return VMContext.getConstantArray(CGM.GetStringForStringLiteral(E), false); 513 } 514 515 llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 516 // This must be an @encode initializing an array in a static initializer. 517 // Don't emit it as the address of the string, emit the string data itself 518 // as an inline array. 519 std::string Str; 520 CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 521 const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType()); 522 523 // Resize the string to the right size, adding zeros at the end, or 524 // truncating as needed. 525 Str.resize(CAT->getSize().getZExtValue(), '\0'); 526 return VMContext.getConstantArray(Str, false); 527 } 528 529 llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 530 return Visit(E->getSubExpr()); 531 } 532 533 // Utility methods 534 const llvm::Type *ConvertType(QualType T) { 535 return CGM.getTypes().ConvertType(T); 536 } 537 538public: 539 llvm::Constant *EmitLValue(Expr *E) { 540 switch (E->getStmtClass()) { 541 default: break; 542 case Expr::CompoundLiteralExprClass: { 543 // Note that due to the nature of compound literals, this is guaranteed 544 // to be the only use of the variable, so we just generate it here. 545 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 546 llvm::Constant* C = Visit(CLE->getInitializer()); 547 // FIXME: "Leaked" on failure. 548 if (C) 549 C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), 550 E->getType().isConstQualified(), 551 llvm::GlobalValue::InternalLinkage, 552 C, ".compoundliteral"); 553 return C; 554 } 555 case Expr::DeclRefExprClass: 556 case Expr::QualifiedDeclRefExprClass: { 557 NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 558 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 559 return CGM.GetAddrOfFunction(GlobalDecl(FD)); 560 if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 561 // We can never refer to a variable with local storage. 562 if (!VD->hasLocalStorage()) { 563 if (VD->isFileVarDecl() || VD->hasExternalStorage()) 564 return CGM.GetAddrOfGlobalVar(VD); 565 else if (VD->isBlockVarDecl()) { 566 assert(CGF && "Can't access static local vars without CGF"); 567 return CGF->GetAddrOfStaticLocalVar(VD); 568 } 569 } 570 } 571 break; 572 } 573 case Expr::StringLiteralClass: 574 return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 575 case Expr::ObjCEncodeExprClass: 576 return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); 577 case Expr::ObjCStringLiteralClass: { 578 ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 579 llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(SL); 580 return VMContext.getConstantExprBitCast(C, ConvertType(E->getType())); 581 } 582 case Expr::PredefinedExprClass: { 583 // __func__/__FUNCTION__ -> "". __PRETTY_FUNCTION__ -> "top level". 584 std::string Str; 585 if (cast<PredefinedExpr>(E)->getIdentType() == 586 PredefinedExpr::PrettyFunction) 587 Str = "top level"; 588 589 return CGM.GetAddrOfConstantCString(Str, ".tmp"); 590 } 591 case Expr::AddrLabelExprClass: { 592 assert(CGF && "Invalid address of label expression outside function."); 593 unsigned id = CGF->GetIDForAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 594 llvm::Constant *C = VMContext.getConstantInt(llvm::Type::Int32Ty, id); 595 return VMContext.getConstantExprIntToPtr(C, ConvertType(E->getType())); 596 } 597 case Expr::CallExprClass: { 598 CallExpr* CE = cast<CallExpr>(E); 599 if (CE->isBuiltinCall(CGM.getContext()) != 600 Builtin::BI__builtin___CFStringMakeConstantString) 601 break; 602 const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 603 const StringLiteral *Literal = cast<StringLiteral>(Arg); 604 // FIXME: need to deal with UCN conversion issues. 605 return CGM.GetAddrOfConstantCFString(Literal); 606 } 607 case Expr::BlockExprClass: { 608 std::string FunctionName; 609 if (CGF) 610 FunctionName = CGF->CurFn->getName(); 611 else 612 FunctionName = "global"; 613 614 return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); 615 } 616 } 617 618 return 0; 619 } 620}; 621 622} // end anonymous namespace. 623 624llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 625 QualType DestType, 626 CodeGenFunction *CGF) { 627 Expr::EvalResult Result; 628 629 bool Success = false; 630 631 if (DestType->isReferenceType()) 632 Success = E->EvaluateAsLValue(Result, Context); 633 else 634 Success = E->Evaluate(Result, Context); 635 636 if (Success) { 637 assert(!Result.HasSideEffects && 638 "Constant expr should not have any side effects!"); 639 switch (Result.Val.getKind()) { 640 case APValue::Uninitialized: 641 assert(0 && "Constant expressions should be initialized."); 642 return 0; 643 case APValue::LValue: { 644 const llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType); 645 llvm::Constant *Offset = 646 VMContext.getConstantInt(llvm::Type::Int64Ty, 647 Result.Val.getLValueOffset()); 648 649 llvm::Constant *C; 650 if (const Expr *LVBase = Result.Val.getLValueBase()) { 651 C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase)); 652 653 // Apply offset if necessary. 654 if (!Offset->isNullValue()) { 655 const llvm::Type *Type = 656 VMContext.getPointerTypeUnqual(llvm::Type::Int8Ty); 657 llvm::Constant *Casted = VMContext.getConstantExprBitCast(C, Type); 658 Casted = VMContext.getConstantExprGetElementPtr(Casted, &Offset, 1); 659 C = VMContext.getConstantExprBitCast(Casted, C->getType()); 660 } 661 662 // Convert to the appropriate type; this could be an lvalue for 663 // an integer. 664 if (isa<llvm::PointerType>(DestTy)) 665 return VMContext.getConstantExprBitCast(C, DestTy); 666 667 return VMContext.getConstantExprPtrToInt(C, DestTy); 668 } else { 669 C = Offset; 670 671 // Convert to the appropriate type; this could be an lvalue for 672 // an integer. 673 if (isa<llvm::PointerType>(DestTy)) 674 return VMContext.getConstantExprIntToPtr(C, DestTy); 675 676 // If the types don't match this should only be a truncate. 677 if (C->getType() != DestTy) 678 return VMContext.getConstantExprTrunc(C, DestTy); 679 680 return C; 681 } 682 } 683 case APValue::Int: { 684 llvm::Constant *C = VMContext.getConstantInt(Result.Val.getInt()); 685 686 if (C->getType() == llvm::Type::Int1Ty) { 687 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 688 C = VMContext.getConstantExprZExt(C, BoolTy); 689 } 690 return C; 691 } 692 case APValue::ComplexInt: { 693 llvm::Constant *Complex[2]; 694 695 Complex[0] = VMContext.getConstantInt(Result.Val.getComplexIntReal()); 696 Complex[1] = VMContext.getConstantInt(Result.Val.getComplexIntImag()); 697 698 return VMContext.getConstantStruct(Complex, 2); 699 } 700 case APValue::Float: 701 return VMContext.getConstantFP(Result.Val.getFloat()); 702 case APValue::ComplexFloat: { 703 llvm::Constant *Complex[2]; 704 705 Complex[0] = VMContext.getConstantFP(Result.Val.getComplexFloatReal()); 706 Complex[1] = VMContext.getConstantFP(Result.Val.getComplexFloatImag()); 707 708 return VMContext.getConstantStruct(Complex, 2); 709 } 710 case APValue::Vector: { 711 llvm::SmallVector<llvm::Constant *, 4> Inits; 712 unsigned NumElts = Result.Val.getVectorLength(); 713 714 for (unsigned i = 0; i != NumElts; ++i) { 715 APValue &Elt = Result.Val.getVectorElt(i); 716 if (Elt.isInt()) 717 Inits.push_back(VMContext.getConstantInt(Elt.getInt())); 718 else 719 Inits.push_back(VMContext.getConstantFP(Elt.getFloat())); 720 } 721 return VMContext.getConstantVector(&Inits[0], Inits.size()); 722 } 723 } 724 } 725 726 llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 727 if (C && C->getType() == llvm::Type::Int1Ty) { 728 const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 729 C = VMContext.getConstantExprZExt(C, BoolTy); 730 } 731 return C; 732} 733 734llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) { 735 // Always return an LLVM null constant for now; this will change when we 736 // get support for IRGen of member pointers. 737 return getLLVMContext().getNullValue(getTypes().ConvertType(T)); 738} 739