CGExprConstant.cpp revision 4de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8
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" 153b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "CodeGenModule.h" 16af2f62ce32e462f256855cd24b06dec4755d2827Daniel Dunbar#include "CGObjCRuntime.h" 17f6b24ea67b5898295e2fc645327837037462a0fdChris Lattner#include "clang/AST/APValue.h" 18de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 19de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 203b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/Constants.h" 213b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/Function.h" 223b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/GlobalVariable.h" 233b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson#include "llvm/Support/Compiler.h" 24a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman#include "llvm/Target/TargetData.h" 253b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonusing namespace clang; 263b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonusing namespace CodeGen; 273b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 283b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonnamespace { 2984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlssonclass VISIBILITY_HIDDEN ConstExprEmitter : 3084005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson public StmtVisitor<ConstExprEmitter, llvm::Constant*> { 313b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson CodeGenModule &CGM; 32813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio CodeGenFunction *CGF; 333b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlssonpublic: 34813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf) 35813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio : CGM(cgm), CGF(cgf) { 363b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 373b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 383b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson //===--------------------------------------------------------------------===// 393b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Visitor Methods 403b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson //===--------------------------------------------------------------------===// 413b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 423b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitStmt(Stmt *S) { 43488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGM.ErrorUnsupported(S, "constant expression"); 4498be4943e8dc4f3905629a7102668960873cf863Chris Lattner QualType T = cast<Expr>(S)->getType(); 4598be4943e8dc4f3905629a7102668960873cf863Chris Lattner return llvm::UndefValue::get(CGM.getTypes().ConvertType(T)); 463b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 473b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 483b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitParenExpr(ParenExpr *PE) { 493b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return Visit(PE->getSubExpr()); 503b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 51bcf6225ad69ea388e287f952981fd076636991b2Anders Carlsson 523b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 533b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return Visit(E->getInitializer()); 543b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 553b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 560835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis llvm::Constant *VisitCastExpr(CastExpr* E) { 5781e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes // GCC cast to union extension 5881e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes if (E->getType()->isUnionType()) { 5981e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes const llvm::Type *Ty = ConvertType(E->getType()); 6081e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes return EmitUnion(CGM.EmitConstantExpr(E->getSubExpr(), CGF), Ty); 6181e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes } 62ddd2b6e1e7406ab45f71398fb78b86c36acd789bEli Friedman if (CGM.getContext().getCanonicalType(E->getSubExpr()->getType()) == 63ddd2b6e1e7406ab45f71398fb78b86c36acd789bEli Friedman CGM.getContext().getCanonicalType(E->getType())) { 64ddd2b6e1e7406ab45f71398fb78b86c36acd789bEli Friedman return Visit(E->getSubExpr()); 65ddd2b6e1e7406ab45f71398fb78b86c36acd789bEli Friedman } 66ddd2b6e1e7406ab45f71398fb78b86c36acd789bEli Friedman return 0; 673b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 68f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson 6904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 7004421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 7104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 7204421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner 73a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) { 744d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman std::vector<llvm::Constant*> Elts; 75a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::ArrayType *AType = 76a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman cast<llvm::ArrayType>(ConvertType(ILE->getType())); 774d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman unsigned NumInitElements = ILE->getNumInits(); 784d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman // FIXME: Check for wide strings 79eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // FIXME: Check for NumInitElements exactly equal to 1?? 80eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner if (NumInitElements > 0 && 81eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner (isa<StringLiteral>(ILE->getInit(0)) || 82eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner isa<ObjCEncodeExpr>(ILE->getInit(0))) && 83c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType()) 844d1c01860708c05757f6a0e17fd90e584000c752Eli Friedman return Visit(ILE->getInit(0)); 85eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel const llvm::Type *ElemTy = AType->getElementType(); 86eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumElements = AType->getNumElements(); 87eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 88eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Initialising an array requires us to automatically 89eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // initialise any elements that have not been initialised explicitly 90eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumInitableElts = std::min(NumInitElements, NumElements); 91eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 92eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Copy initializer elements. 93eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned i = 0; 94a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman bool RewriteType = false; 95eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel for (; i < NumInitableElts; ++i) { 96aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF); 97d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (!C) 98d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return 0; 99a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman RewriteType |= (C->getType() != ElemTy); 100eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel Elts.push_back(C); 1013b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 102a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 103eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Initialize remaining array elements. 104eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel for (; i < NumElements; ++i) 105eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 106eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 107a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman if (RewriteType) { 108a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman // FIXME: Try to avoid packing the array 109a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman std::vector<const llvm::Type*> Types; 110a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman for (unsigned i = 0; i < Elts.size(); ++i) 111a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman Types.push_back(Elts[i]->getType()); 112a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman const llvm::StructType *SType = llvm::StructType::get(Types, true); 113a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman return llvm::ConstantStruct::get(SType, Elts); 114a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman } 115a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 116eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel return llvm::ConstantArray::get(AType, Elts); 117eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 118eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 119a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts, 120a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman FieldDecl* Field, Expr* E) { 121a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Calculate the value to insert 122aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson llvm::Constant *C = CGM.EmitConstantExpr(E, CGF); 123d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (!C) 124d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return; 125d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar 126a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C); 127a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (!CI) { 128488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGM.ErrorUnsupported(E, "bitfield initialization"); 129a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return; 130a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 131a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::APInt V = CI->getValue(); 132a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 133a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Calculate information about the relevant field 134a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::Type* Ty = CI->getType(); 1359ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar const llvm::TargetData &TD = CGM.getTypes().getTargetData(); 1367f5221b023bca69a3f5fdbe03934edb74a25fa18Eli Friedman unsigned size = TD.getTypePaddedSizeInBits(Ty); 137a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size; 138a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman CodeGenTypes::BitFieldInfo bitFieldInfo = 139a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman CGM.getTypes().getBitFieldInfo(Field); 140a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman fieldOffset += bitFieldInfo.Begin; 141a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 142a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Find where to start the insertion 143a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: This is O(n^2) in the number of bit-fields! 144a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: This won't work if the struct isn't completely packed! 145a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned offset = 0, i = 0; 146a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman while (offset < (fieldOffset & -8)) 1477f5221b023bca69a3f5fdbe03934edb74a25fa18Eli Friedman offset += TD.getTypePaddedSizeInBits(Elts[i++]->getType()); 1489ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar 1499ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar // Advance over 0 sized elements (must terminate in bounds since 1509ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar // the bitfield must have a size). 1517f5221b023bca69a3f5fdbe03934edb74a25fa18Eli Friedman while (TD.getTypePaddedSizeInBits(Elts[i]->getType()) == 0) 1529ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3Daniel Dunbar ++i; 153a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 1541f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // Promote the size of V if necessary 1551f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // FIXME: This should never occur, but currently it can because 1561f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // initializer constants are cast to bool, and because clang is 1571f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar // not enforcing bitfield width limits. 1581f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar if (bitFieldInfo.Size > V.getBitWidth()) 1591f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar V.zext(bitFieldInfo.Size); 1601f3846e3013a3b6679aeaa2e4c61de37a5c320eeDaniel Dunbar 161a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Insert the bits into the struct 162a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: This algorthm is only correct on X86! 163a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // FIXME: THis algorthm assumes bit-fields only have byte-size elements! 164a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned bitsToInsert = bitFieldInfo.Size; 165a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert); 166a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7); 167a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman do { 168a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte); 169a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC); 170a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman ++i; 171a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman V = V.lshr(curBits); 172a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman bitsToInsert -= curBits; 173eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 174a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (!bitsToInsert) 175a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman break; 176a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 177a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman curBits = bitsToInsert > 8 ? 8 : bitsToInsert; 178a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman byte = V.getLoBits(curBits).getZExtValue(); 179a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } while (true); 180a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 181a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 182a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { 183a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::StructType *SType = 184a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman cast<llvm::StructType>(ConvertType(ILE->getType())); 185017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 186eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel std::vector<llvm::Constant*> Elts; 187017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman 188017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman // Initialize the whole structure to zero. 189017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman for (unsigned i = 0; i < SType->getNumElements(); ++i) { 190017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman const llvm::Type *FieldTy = SType->getElementType(i); 191017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman Elts.push_back(llvm::Constant::getNullValue(FieldTy)); 192017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman } 193eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 194eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel // Copy initializer elements. Skip padding fields. 195eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned EltNo = 0; // Element no in ILE 196017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman int FieldNo = 0; // Field no in RecordDecl 197a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman bool RewriteType = false; 19844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor for (RecordDecl::field_iterator Field = RD->field_begin(), 19944b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor FieldEnd = RD->field_end(); 20044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor EltNo < ILE->getNumInits() && Field != FieldEnd; ++Field) { 201017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman FieldNo++; 20244b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor if (!Field->getIdentifier()) 203eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel continue; 204017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman 20544b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor if (Field->isBitField()) { 20644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor InsertBitfieldIntoStruct(Elts, *Field, ILE->getInit(EltNo)); 207017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman } else { 20844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(*Field); 209aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF); 210d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (!C) return 0; 211a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman RewriteType |= (C->getType() != Elts[FieldNo]->getType()); 212a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman Elts[FieldNo] = C; 213017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman } 214eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel EltNo++; 215eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 216017cbdfd5417d4d31ae6406421276f90269f75e2Eli Friedman 217a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman if (RewriteType) { 218a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman // FIXME: Make this work for non-packed structs 219a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman assert(SType->isPacked() && "Cannot recreate unpacked structs"); 220a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman std::vector<const llvm::Type*> Types; 221a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman for (unsigned i = 0; i < Elts.size(); ++i) 222a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman Types.push_back(Elts[i]->getType()); 223a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman SType = llvm::StructType::get(Types, true); 224a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman } 225a04a1538ee5e286e94e3374caf51ba1094d289b0Eli Friedman 226eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel return llvm::ConstantStruct::get(SType, Elts); 227eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 22847fb6977509a285501d02611845e9f8e081a15e1Devang Patel 22981e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes llvm::Constant *EmitUnion(llvm::Constant *C, const llvm::Type *Ty) { 230d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (!C) 231d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return 0; 232d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar 23381e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes // Build a struct with the union sub-element as the first member, 23481e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes // and padded to the appropriate size 23581e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes std::vector<llvm::Constant*> Elts; 23681e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes std::vector<const llvm::Type*> Types; 23781e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes Elts.push_back(C); 23881e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes Types.push_back(C->getType()); 2397f5221b023bca69a3f5fdbe03934edb74a25fa18Eli Friedman unsigned CurSize = CGM.getTargetData().getTypePaddedSize(C->getType()); 2407f5221b023bca69a3f5fdbe03934edb74a25fa18Eli Friedman unsigned TotalSize = CGM.getTargetData().getTypePaddedSize(Ty); 24181e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes while (CurSize < TotalSize) { 24281e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty)); 24381e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes Types.push_back(llvm::Type::Int8Ty); 24481e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes CurSize++; 24581e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes } 24681e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes 24781e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes // This always generates a packed struct 24881e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes // FIXME: Try to generate an unpacked struct when we can 24981e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes llvm::StructType* STy = llvm::StructType::get(Types, true); 25081e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes return llvm::ConstantStruct::get(STy, Elts); 25181e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes } 25281e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes 253a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) { 254a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::Type *Ty = ConvertType(ILE->getType()); 255a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 2560bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor // If this is an empty initializer list, we value-initialize the 2570bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor // union. 2580bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor if (ILE->getNumInits() == 0) 2590bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor return llvm::Constant::getNullValue(Ty); 26034e7946831a63f96d3ba3478c74ca8e25ee52d7eDouglas Gregor 2610bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor FieldDecl* curField = ILE->getInitializedFieldInUnion(); 2620bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor if (!curField) { 2630bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor // There's no field to initialize, so value-initialize the union. 2640bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor#ifndef NDEBUG 2650bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor // Make sure that it's really an empty and not a failure of 2660bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor // semantic analysis. 26771d817451626fe7ac6b080955ff87624b76bd058Douglas Gregor RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); 2680bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor for (RecordDecl::field_iterator Field = RD->field_begin(), 2690bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor FieldEnd = RD->field_end(); 2700bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor Field != FieldEnd; ++Field) 2710bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed"); 2720bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor#endif 273a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return llvm::Constant::getNullValue(Ty); 2740bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor } 275a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 276a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (curField->isBitField()) { 277a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // Create a dummy struct for bit-field insertion 278491c7b77cd8ec8570f646d43b937a5aec688bcbfDaniel Dunbar unsigned NumElts = CGM.getTargetData().getTypePaddedSize(Ty) / 8; 279a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty); 280a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman std::vector<llvm::Constant*> Elts(NumElts, NV); 281eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 282a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0)); 283a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::ArrayType *RetTy = 284a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::ArrayType::get(NV->getType(), NumElts); 285a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return llvm::ConstantArray::get(RetTy, Elts); 286a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 287a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 28881e51e2c5bf1e4edc3b70040e2083fa83d314e40Nuno Lopes return EmitUnion(CGM.EmitConstantExpr(ILE->getInit(0), CGF), Ty); 289a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman } 290a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 291a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) { 292a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::VectorType *VType = 293a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman cast<llvm::VectorType>(ConvertType(ILE->getType())); 294cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman const llvm::Type *ElemTy = VType->getElementType(); 295cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman std::vector<llvm::Constant*> Elts; 296eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel unsigned NumElements = VType->getNumElements(); 297cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman unsigned NumInitElements = ILE->getNumInits(); 298cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman 299cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman unsigned NumInitableElts = std::min(NumInitElements, NumElements); 30047fb6977509a285501d02611845e9f8e081a15e1Devang Patel 3013b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Copy initializer elements. 3023b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson unsigned i = 0; 303cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman for (; i < NumInitableElts; ++i) { 304aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF); 305d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (!C) 306d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return 0; 3073b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson Elts.push_back(C); 3083b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 309eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel 310cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman for (; i < NumElements; ++i) 311cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman Elts.push_back(llvm::Constant::getNullValue(ElemTy)); 312cfb313bd56fb935c54544489d71d77364fd312dbEli Friedman 313eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel return llvm::ConstantVector::get(VType, Elts); 314eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel } 3157d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson 3167d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) { 3177d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson const llvm::Type* RetTy = CGM.getTypes().ConvertType(E->getType()); 3187d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson return llvm::Constant::getNullValue(RetTy); 3197d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson } 3207d801eae4db97c46e47c40d431d34225ce6f6143Anders Carlsson 321eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::Constant *VisitInitListExpr(InitListExpr *ILE) { 322a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isScalarType()) { 323a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman // We have a scalar in braces. Just use the first element. 324a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getNumInits() > 0) 325aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson return CGM.EmitConstantExpr(ILE->getInit(0), CGF); 326a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 327a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType()); 328a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return llvm::Constant::getNullValue(RetTy); 32947fb6977509a285501d02611845e9f8e081a15e1Devang Patel } 330be20bb558cae5352898e6a913e29d24d20134841Chris Lattner 331a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isArrayType()) 332a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitArrayInitialization(ILE); 333a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 334a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isStructureType()) 335a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitStructInitialization(ILE); 336a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 337a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isUnionType()) 338a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitUnionInitialization(ILE); 339a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman 340a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman if (ILE->getType()->isVectorType()) 341a823400df727968fda4b2df23abab0d8ecff7a75Eli Friedman return EmitVectorInitialization(ILE); 34247fb6977509a285501d02611845e9f8e081a15e1Devang Patel 343eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel assert(0 && "Unable to handle InitListExpr"); 3442b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner // Get rid of control reaches end of void function warning. 3452b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner // Not reached. 3462b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner return 0; 3473b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3483b707e7476cd46945e4e187b57b7f0ad811d8752Eli Friedman 3493b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson llvm::Constant *VisitStringLiteral(StringLiteral *E) { 350a7ad98ff0919d6a24ea7c46634ea29bea551c1a0Chris Lattner assert(!E->getType()->isPointerType() && "Strings are always arrays"); 3513b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 352eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // This must be a string initializing an array in a static initializer. 353eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // Don't emit it as the address of the string, emit the string data itself 354eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // as an inline array. 3556143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar return llvm::ConstantArray::get(CGM.GetStringForStringLiteral(E), false); 3563b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 3573b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 358eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 359eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // This must be an @encode initializing an array in a static initializer. 360eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // Don't emit it as the address of the string, emit the string data itself 361eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // as an inline array. 362eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner std::string Str; 363eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str); 364eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType()); 365eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner 366eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // Resize the string to the right size, adding zeros at the end, or 367eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner // truncating as needed. 368eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner Str.resize(CAT->getSize().getZExtValue(), '\0'); 369eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner return llvm::ConstantArray::get(Str, false); 370eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner } 371eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner 372bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) { 373bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman return Visit(E->getSubExpr()); 374bc5ed6ef52d43b5a3c924421aac3c1f0f829dcc8Eli Friedman } 375b83d287bc7f47d36fb0751a481e2ef9308b37252Mike Stump 3763b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson // Utility methods 3773b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson const llvm::Type *ConvertType(QualType T) { 3783b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson return CGM.getTypes().ConvertType(T); 3793b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson } 38084005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson 3815ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlssonpublic: 38284005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant *EmitLValue(Expr *E) { 383e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson switch (E->getStmtClass()) { 384546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman default: break; 385e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson case Expr::CompoundLiteralExprClass: { 386e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson // Note that due to the nature of compound literals, this is guaranteed 387e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson // to be the only use of the variable, so we just generate it here. 38884005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 38984005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson llvm::Constant* C = Visit(CLE->getInitializer()); 390d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar // FIXME: "Leaked" on failure. 391d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (C) 392d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar C = new llvm::GlobalVariable(C->getType(), 393d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar E->getType().isConstQualified(), 394d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar llvm::GlobalValue::InternalLinkage, 395d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar C, ".compoundliteral", &CGM.getModule()); 396e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson return C; 39784005b4b6b92e3a716fa4a792bea7d41bbb0102eAnders Carlsson } 3981a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case Expr::DeclRefExprClass: 3991a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case Expr::QualifiedDeclRefExprClass: { 4008e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl(); 401e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl)) 402bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar return CGM.GetAddrOfFunction(FD); 403248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) { 404d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar // We can never refer to a variable with local storage. 405d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar if (!VD->hasLocalStorage()) { 406d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar if (VD->isFileVarDecl() || VD->hasExternalStorage()) 407d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar return CGM.GetAddrOfGlobalVar(VD); 408d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar else if (VD->isBlockVarDecl()) { 409d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar assert(CGF && "Can't access static local vars without CGF"); 410d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar return CGF->GetAddrOfStaticLocalVar(VD); 411d01b669f26703663da3515638e254fa7a987e860Daniel Dunbar } 412248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff } 413813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio } 414546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman break; 415e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 4166143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar case Expr::StringLiteralClass: 4176143293fa4366ee95d7e47e61bd030a34bf68b55Daniel Dunbar return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E)); 418eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case Expr::ObjCEncodeExprClass: 419eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E)); 4205ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson case Expr::ObjCStringLiteralClass: { 4215ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E); 4225ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson std::string S(SL->getString()->getStrData(), 4235ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson SL->getString()->getByteLength()); 4245ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S); 4255ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 4265ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson } 42735345640442594acbc29445fbde4874a6e4c860aChris Lattner case Expr::PredefinedExprClass: { 42835345640442594acbc29445fbde4874a6e4c860aChris Lattner // __func__/__FUNCTION__ -> "". __PRETTY_FUNCTION__ -> "top level". 42935345640442594acbc29445fbde4874a6e4c860aChris Lattner std::string Str; 43035345640442594acbc29445fbde4874a6e4c860aChris Lattner if (cast<PredefinedExpr>(E)->getIdentType() == 43135345640442594acbc29445fbde4874a6e4c860aChris Lattner PredefinedExpr::PrettyFunction) 43235345640442594acbc29445fbde4874a6e4c860aChris Lattner Str = "top level"; 43335345640442594acbc29445fbde4874a6e4c860aChris Lattner 43435345640442594acbc29445fbde4874a6e4c860aChris Lattner return CGM.GetAddrOfConstantCString(Str, ".tmp"); 43535345640442594acbc29445fbde4874a6e4c860aChris Lattner } 436f01158941ba4560c63150032073bb231ce38999eEli Friedman case Expr::AddrLabelExprClass: { 437f01158941ba4560c63150032073bb231ce38999eEli Friedman assert(CGF && "Invalid address of label expression outside function."); 438f01158941ba4560c63150032073bb231ce38999eEli Friedman unsigned id = CGF->GetIDForAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel()); 439f01158941ba4560c63150032073bb231ce38999eEli Friedman llvm::Constant *C = llvm::ConstantInt::get(llvm::Type::Int32Ty, id); 440f01158941ba4560c63150032073bb231ce38999eEli Friedman return llvm::ConstantExpr::getIntToPtr(C, ConvertType(E->getType())); 441f01158941ba4560c63150032073bb231ce38999eEli Friedman } 4423941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman case Expr::CallExprClass: { 4433941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman CallExpr* CE = cast<CallExpr>(E); 4443c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CE->isBuiltinCall(CGM.getContext()) != 4453c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor Builtin::BI__builtin___CFStringMakeConstantString) 4463941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman break; 4473941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman const Expr *Arg = CE->getArg(0)->IgnoreParenCasts(); 4483941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman const StringLiteral *Literal = cast<StringLiteral>(Arg); 4493941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman std::string S(Literal->getStrData(), Literal->getByteLength()); 4503941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman return CGM.GetAddrOfConstantCFString(S); 4513941b18b8e441c8c466efecd557de60b9a32d10bEli Friedman } 452bd65cac8de63d108a681035782a71d42954b03abMike Stump case Expr::BlockExprClass: { 4534de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson std::string FunctionName; 4544de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson if (CGF) 4554de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson FunctionName = CGF->CurFn->getName(); 4564de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson else 4574de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson FunctionName = "global"; 4584de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson 4594de9fce48e42cc7ec1345c0fd21b3dbc5b9114c8Anders Carlsson return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str()); 460bd65cac8de63d108a681035782a71d42954b03abMike Stump } 461546d94c77e4636a7dbce160c3c8e4157a2fe6d81Eli Friedman } 462d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar 463d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return 0; 464e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson } 465e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson}; 466e3d3b7d44ffb69ad7a756de50dda2f22441f5d0dAnders Carlsson 4673b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson} // end anonymous namespace. 4683b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson 469813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venanciollvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E, 4709619662a1d42e2008b865d3459c0677e149dad1bChris Lattner CodeGenFunction *CGF) { 4714b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson Expr::EvalResult Result; 4724b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson 4734b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson if (E->Evaluate(Result, Context)) { 4744b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson assert(!Result.HasSideEffects && 4754b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson "Constant expr should not have any side effects!"); 4764b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson switch (Result.Val.getKind()) { 477a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar case APValue::Uninitialized: 478d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar assert(0 && "Constant expressions should be initialized."); 479d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar return 0; 4805a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson case APValue::LValue: { 481e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar const llvm::Type *DestType = getTypes().ConvertTypeForMem(E->getType()); 4824b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson llvm::Constant *Offset = 4834b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson llvm::ConstantInt::get(llvm::Type::Int64Ty, 4844b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson Result.Val.getLValueOffset()); 4855a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson 486e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar llvm::Constant *C; 4874b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson if (const Expr *LVBase = Result.Val.getLValueBase()) { 488e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase)); 489e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 490e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar // Apply offset if necessary. 491e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar if (!Offset->isNullValue()) { 492e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar const llvm::Type *Type = 493e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 494e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type); 495e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar Casted = llvm::ConstantExpr::getGetElementPtr(Casted, &Offset, 1); 496e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar C = llvm::ConstantExpr::getBitCast(Casted, C->getType()); 497e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar } 4985ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson 499e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar // Convert to the appropriate type; this could be an lvalue for 500e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar // an integer. 501e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar if (isa<llvm::PointerType>(DestType)) 502e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar return llvm::ConstantExpr::getBitCast(C, DestType); 503e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 504e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar return llvm::ConstantExpr::getPtrToInt(C, DestType); 505e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar } else { 506e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar C = Offset; 507e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 508e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar // Convert to the appropriate type; this could be an lvalue for 509e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar // an integer. 510e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar if (isa<llvm::PointerType>(DestType)) 511e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar return llvm::ConstantExpr::getIntToPtr(C, DestType); 512e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 513e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar // If the types don't match this should only be a truncate. 514e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar if (C->getType() != DestType) 515e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar return llvm::ConstantExpr::getTrunc(C, DestType); 516e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar 517e20de512d88cf42a26ef994687d87fc6f5826625Daniel Dunbar return C; 5185ea7d07ea7d9f2b679c85df7cc45fcc6e157e396Anders Carlsson } 5195a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson } 5207b30b1c866deb37fabe2b25684b7d238258d46adEli Friedman case APValue::Int: { 5214b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson llvm::Constant *C = llvm::ConstantInt::get(Result.Val.getInt()); 5225a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson 5235a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson if (C->getType() == llvm::Type::Int1Ty) { 5245a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 5255a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson C = llvm::ConstantExpr::getZExt(C, BoolTy); 5265a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson } 5275a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson return C; 5287b30b1c866deb37fabe2b25684b7d238258d46adEli Friedman } 529a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar case APValue::ComplexInt: { 530a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar llvm::Constant *Complex[2]; 531a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar 532a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar Complex[0] = llvm::ConstantInt::get(Result.Val.getComplexIntReal()); 533a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar Complex[1] = llvm::ConstantInt::get(Result.Val.getComplexIntImag()); 534a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar 535a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar return llvm::ConstantStruct::get(Complex, 2); 536a5fd07bbc5e4bae542c06643da3fbfe4967a9379Daniel Dunbar } 5375a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson case APValue::Float: 5384b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson return llvm::ConstantFP::get(Result.Val.getFloat()); 539aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson case APValue::ComplexFloat: { 540aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson llvm::Constant *Complex[2]; 541aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson 5424b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson Complex[0] = llvm::ConstantFP::get(Result.Val.getComplexFloatReal()); 5434b3f9c06d548d3de576441a91ef986c6840bd983Anders Carlsson Complex[1] = llvm::ConstantFP::get(Result.Val.getComplexFloatImag()); 544aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson 545aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson return llvm::ConstantStruct::get(Complex, 2); 546aa432560efb1ff10aec504a68fe909cd9ae7c1a2Anders Carlsson } 5473d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman case APValue::Vector: { 5483d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman llvm::SmallVector<llvm::Constant *, 4> Inits; 5493d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman unsigned NumElts = Result.Val.getVectorLength(); 5503d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman 5513d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman for (unsigned i = 0; i != NumElts; ++i) { 5523d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman APValue &Elt = Result.Val.getVectorElt(i); 5533d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman if (Elt.isInt()) 5543d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman Inits.push_back(llvm::ConstantInt::get(Elt.getInt())); 5553d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman else 5563d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman Inits.push_back(llvm::ConstantFP::get(Elt.getFloat())); 5573d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman } 5583d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman return llvm::ConstantVector::get(&Inits[0], Inits.size()); 5593d309f9d62a6f9f634b869937139d533ccd7265bNate Begeman } 5605a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson } 5615a9a457ecf66343ae8b64baa7909007837b2a2cdAnders Carlsson } 5627dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman 5637dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E)); 564d60f2fbf69df08e952377b498c036f269395024dDaniel Dunbar if (C && C->getType() == llvm::Type::Int1Ty) { 5657dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType()); 5667dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman C = llvm::ConstantExpr::getZExt(C, BoolTy); 5677dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman } 5687dfa639e9274b9f40c8f207e35c0fcbfe75d04f8Eli Friedman return C; 5693b1d57b623702865e4158b00cb1d984ba6dd5d50Anders Carlsson} 570