CGCall.cpp revision bac7c250c9b098ee3d637c8ed77da62e860d9244
15f7643150411b16e71bc012c6ceb2d865c0a34d4Ted Kremenek//===----- CGCall.h - Encapsulate calling convention details ----*- C++ -*-===// 2cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// 3cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// The LLVM Compiler Infrastructure 4cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// 5cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// This file is distributed under the University of Illinois Open Source 6cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// License. See LICENSE.TXT for details. 7cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// 8cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu//===----------------------------------------------------------------------===// 9cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// 10cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// These classes wrap the information about a call or function 11cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// definition used to handle ABI compliancy. 12cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu// 13cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu//===----------------------------------------------------------------------===// 14eb48bd1dd4168ab206a330bf523659170291a6a0Argyrios Kyrtzidis 159b663716449b618ba0390b1dbebc54fa8e971124Ted Kremenek#include "CGCall.h" 169b663716449b618ba0390b1dbebc54fa8e971124Ted Kremenek#include "CodeGenFunction.h" 17d1e5a89226da79f7e6f43d40facc46abda9e5245Jordy Rose#include "CodeGenModule.h" 18cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu#include "clang/Basic/TargetInfo.h" 19cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu#include "clang/AST/Decl.h" 20cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu#include "clang/AST/DeclCXX.h" 219ef6537a894c33003359b1f9b9676e9178e028b7Ted Kremenek#include "clang/AST/DeclObjC.h" 22cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu#include "clang/Frontend/CompileOptions.h" 23c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek#include "llvm/Attributes.h" 24c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek#include "llvm/Support/CallSite.h" 25c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek#include "llvm/Target/TargetData.h" 26c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek 27c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek#include "ABIInfo.h" 28c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek 29c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenekusing namespace clang; 30c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenekusing namespace CodeGen; 31c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek 32c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek/***/ 33c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek 34d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios Kyrtzidis// FIXME: Use iterator and sidestep silly type array creation. 35b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu 3682c63bfa0c5130e0cf274c1974b6157ebefc04feMarcin Swiderskiconst 3782c63bfa0c5130e0cf274c1974b6157ebefc04feMarcin SwiderskiCGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionNoProtoType *FTNP) { 38c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek // FIXME: Set calling convention correctly, it needs to be associated with the 39c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek // type somehow. 405f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner return getFunctionInfo(FTNP->getResultType(), 41b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu llvm::SmallVector<QualType, 16>(), 0); 42b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu} 43b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu 44b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xuconst 45b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing XuCGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionProtoType *FTP) { 46b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu llvm::SmallVector<QualType, 16> ArgTys; 47b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // FIXME: Kill copy. 48b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) 49b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu ArgTys.push_back(FTP->getArgType(i)); 50b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // FIXME: Set calling convention correctly, it needs to be associated with the 51b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // type somehow. 52b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu return getFunctionInfo(FTP->getResultType(), ArgTys, 0); 53c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek} 54b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu 5582c63bfa0c5130e0cf274c1974b6157ebefc04feMarcin Swiderskistatic unsigned getCallingConventionForDecl(const Decl *D) { 5682c63bfa0c5130e0cf274c1974b6157ebefc04feMarcin Swiderski // Set the appropriate calling convention for the Function. 5782c63bfa0c5130e0cf274c1974b6157ebefc04feMarcin Swiderski if (D->hasAttr<StdCallAttr>()) 58c69c43845aa3ede95af837b8be52868eca55d64dTed Kremenek return llvm::CallingConv::X86_StdCall; 59892697dd2287caf7c29aaaa82909b0e90b8b63feTed Kremenek 60b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu if (D->hasAttr<FastCallAttr>()) 61b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu return llvm::CallingConv::X86_FastCall; 62b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu 63b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu return llvm::CallingConv::C; 64b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu} 65b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu 66b277159055933e610bbc80262b600d3ad7e0595cTed Kremenekconst CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXMethodDecl *MD) { 67b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek llvm::SmallVector<QualType, 16> ArgTys; 68b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek // Add the 'this' pointer unless this is a static method. 69b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek if (MD->isInstance()) 70b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek ArgTys.push_back(MD->getThisType(Context)); 71b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek 72b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek const FunctionProtoType *FTP = MD->getType()->getAsFunctionProtoType(); 73b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) 74b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek ArgTys.push_back(FTP->getArgType(i)); 75b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek return getFunctionInfo(FTP->getResultType(), ArgTys, 76b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek getCallingConventionForDecl(MD)); 77b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek} 78b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek 79b277159055933e610bbc80262b600d3ad7e0595cTed Kremenekconst CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionDecl *FD) { 80b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 81b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek if (MD->isInstance()) 82b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek return getFunctionInfo(MD); 83b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek 84b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek unsigned CallingConvention = getCallingConventionForDecl(FD); 85b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek const FunctionType *FTy = FD->getType()->getAsFunctionType(); 86b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek if (const FunctionNoProtoType *FNTP = dyn_cast<FunctionNoProtoType>(FTy)) 87b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek return getFunctionInfo(FNTP->getResultType(), 88b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek llvm::SmallVector<QualType, 16>(), 89b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek CallingConvention); 90b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek 91b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy); 92b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek llvm::SmallVector<QualType, 16> ArgTys; 93b277159055933e610bbc80262b600d3ad7e0595cTed Kremenek // FIXME: Kill copy. 94d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios Kyrtzidis for (unsigned i = 0, e = FPT->getNumArgs(); i != e; ++i) 95cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu ArgTys.push_back(FPT->getArgType(i)); 96f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return getFunctionInfo(FPT->getResultType(), ArgTys, CallingConvention); 97b168cbfa1ca9b50115f8dd787d11d272fff2ad81John McCall} 98c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek 99cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xuconst CGFunctionInfo &CodeGenTypes::getFunctionInfo(const ObjCMethodDecl *MD) { 100cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu llvm::SmallVector<QualType, 16> ArgTys; 101d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios Kyrtzidis ArgTys.push_back(MD->getSelfDecl()->getType()); 10232303020d0f1a21cbcab65ae0c69a4218dc8f0fbZhongxing Xu ArgTys.push_back(Context.getObjCSelType()); 103c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek // FIXME: Kill copy? 10432303020d0f1a21cbcab65ae0c69a4218dc8f0fbZhongxing Xu for (ObjCMethodDecl::param_iterator i = MD->param_begin(), 10532303020d0f1a21cbcab65ae0c69a4218dc8f0fbZhongxing Xu e = MD->param_end(); i != e; ++i) 10632303020d0f1a21cbcab65ae0c69a4218dc8f0fbZhongxing Xu ArgTys.push_back((*i)->getType()); 107eea72a925f294225391ecec876a342771c09b635Ted Kremenek return getFunctionInfo(MD->getResultType(), ArgTys, 108eea72a925f294225391ecec876a342771c09b635Ted Kremenek getCallingConventionForDecl(MD)); 109eea72a925f294225391ecec876a342771c09b635Ted Kremenek} 110aa0aeb1cbe117db68d35700cb3a34aace0f99b99Anna Zaks 1116a835dddf45922e71a87637fdfac0863de65123cTed Kremenekconst CGFunctionInfo &CodeGenTypes::getFunctionInfo(QualType ResTy, 1126a835dddf45922e71a87637fdfac0863de65123cTed Kremenek const CallArgList &Args, 1135eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek unsigned CallingConvention){ 114cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu // FIXME: Kill copy. 1156a835dddf45922e71a87637fdfac0863de65123cTed Kremenek llvm::SmallVector<QualType, 16> ArgTys; 1166a835dddf45922e71a87637fdfac0863de65123cTed Kremenek for (CallArgList::const_iterator i = Args.begin(), e = Args.end(); 1175eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek i != e; ++i) 118cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu ArgTys.push_back(i->second); 1196a835dddf45922e71a87637fdfac0863de65123cTed Kremenek return getFunctionInfo(ResTy, ArgTys, CallingConvention); 1205eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek} 121cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu 1226a835dddf45922e71a87637fdfac0863de65123cTed Kremenekconst CGFunctionInfo &CodeGenTypes::getFunctionInfo(QualType ResTy, 1235eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek const FunctionArgList &Args, 124cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu unsigned CallingConvention){ 125cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu // FIXME: Kill copy. 126d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios Kyrtzidis llvm::SmallVector<QualType, 16> ArgTys; 1275fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 1285fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek i != e; ++i) 1295fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek ArgTys.push_back(i->second); 130cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu return getFunctionInfo(ResTy, ArgTys, CallingConvention); 131cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu} 132cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu 1335fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenekconst CGFunctionInfo &CodeGenTypes::getFunctionInfo(QualType ResTy, 1345fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek const llvm::SmallVector<QualType, 16> &ArgTys, 13510620eb5164e31208fcbf0437cd79ae535ed0559Sean Hunt unsigned CallingConvention){ 136cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu // Lookup or create unique function info. 137cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu llvm::FoldingSetNodeID ID; 1385fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek CGFunctionInfo::Profile(ID, CallingConvention, ResTy, 139cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu ArgTys.begin(), ArgTys.end()); 140cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu 1419c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek void *InsertPos = 0; 142107ccd1f56836ae57c1a5a9c13c881b0293d1e98Zhongxing Xu CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, InsertPos); 1439c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek if (FI) 1445fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek return *FI; 1455fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1465fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek // Construct the function info. 1475fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek FI = new CGFunctionInfo(CallingConvention, ResTy, ArgTys); 1485fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek FunctionInfos.InsertNode(FI, InsertPos); 149fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner 1505fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek // Compute ABI information. 1515fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek getABIInfo().computeInfo(*FI, getContext(), TheModule.getContext()); 1525fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1535fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek return *FI; 1545fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek} 1555fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1565fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed KremenekCGFunctionInfo::CGFunctionInfo(unsigned _CallingConvention, 1575fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek QualType ResTy, 1585fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek const llvm::SmallVector<QualType, 16> &ArgTys) 1595fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek : CallingConvention(_CallingConvention) 1605fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek{ 1615fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek NumArgs = ArgTys.size(); 1625fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek Args = new ArgInfo[1 + NumArgs]; 1635fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek Args[0].type = ResTy; 1645fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek for (unsigned i = 0; i < NumArgs; ++i) 1655fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek Args[1 + i].type = ArgTys[i]; 1665fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek} 1675fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1685fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek/***/ 1695fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1705fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenekvoid CodeGenTypes::GetExpandedTypes(QualType Ty, 1715fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek std::vector<const llvm::Type*> &ArgTys) { 1725fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek const RecordType *RT = Ty->getAsStructureType(); 1735fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek assert(RT && "Can only expand structure types."); 1745fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek const RecordDecl *RD = RT->getDecl(); 1755fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek assert(!RD->hasFlexibleArrayMember() && 1765fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek "Cannot expand structure with flexible array."); 1775fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 178ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 179ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks i != e; ++i) { 1805fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek const FieldDecl *FD = *i; 1815fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek assert(!FD->isBitField() && 1825fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek "Cannot expand structure with bit-field members."); 1835fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1845fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek QualType FT = FD->getType(); 1855fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek if (CodeGenFunction::hasAggregateLLVMType(FT)) { 1865fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek GetExpandedTypes(FT, ArgTys); 187aa0aeb1cbe117db68d35700cb3a34aace0f99b99Anna Zaks } else { 1885fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek ArgTys.push_back(ConvertType(FT)); 1895fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek } 19018c66fdc3c4008d335885695fe36fb5353c5f672Ted Kremenek } 1915fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek} 1925fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1935fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenekllvm::Function::arg_iterator 194ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna ZaksCodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV, 1955fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek llvm::Function::arg_iterator AI) { 196cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu const RecordType *RT = Ty->getAsStructureType(); 1975fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek assert(RT && "Can only expand structure types."); 1985fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek 1995fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek RecordDecl *RD = RT->getDecl(); 2005fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek assert(LV.isSimple() && 2015fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek "Unexpected non-simple lvalue during struct expansion."); 202aa0aeb1cbe117db68d35700cb3a34aace0f99b99Anna Zaks llvm::Value *Addr = LV.getAddress(); 203ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 204ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks i != e; ++i) { 205ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks FieldDecl *FD = *i; 206ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks QualType FT = FD->getType(); 207ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks 208ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks // FIXME: What are the right qualifiers here? 209ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks LValue LV = EmitLValueForField(Addr, FD, false, 0); 2105fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek if (CodeGenFunction::hasAggregateLLVMType(FT)) { 2115eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek AI = ExpandTypeFromArgs(FT, LV, AI); 212ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks } else { 213ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks EmitStoreThroughLValue(RValue::get(AI), LV, FT); 2145fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek ++AI; 2155fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek } 2165fe98728dca1f3a7a378ce1a21984a0f8a0c0b8bTed Kremenek } 217cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu 218cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu return AI; 219d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios Kyrtzidis} 220ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks 221ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaksvoid 222ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna ZaksCodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV, 223ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks llvm::SmallVector<llvm::Value*, 16> &Args) { 224aa0aeb1cbe117db68d35700cb3a34aace0f99b99Anna Zaks const RecordType *RT = Ty->getAsStructureType(); 22510620eb5164e31208fcbf0437cd79ae535ed0559Sean Hunt assert(RT && "Can only expand structure types."); 226b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu 227b1b5daf30d2597e066936772bd206500232d7d65Ted Kremenek RecordDecl *RD = RT->getDecl(); 228b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu assert(RV.isAggregate() && "Unexpected rvalue during struct expansion"); 229b1b5daf30d2597e066936772bd206500232d7d65Ted Kremenek llvm::Value *Addr = RV.getAggregateAddr(); 2301d26f48dc2eea1c07431ca1519d7034a21b9bcffTed Kremenek for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 231b1b5daf30d2597e066936772bd206500232d7d65Ted Kremenek i != e; ++i) { 232ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks FieldDecl *FD = *i; 233b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu QualType FT = FD->getType(); 234b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu 235b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu // FIXME: What are the right qualifiers here? 23619b78d9e3dbbc27bbcbdd8c3017a00fe88849ecdZhongxing Xu LValue LV = EmitLValueForField(Addr, FD, false, 0); 237b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu if (CodeGenFunction::hasAggregateLLVMType(FT)) { 23818c66fdc3c4008d335885695fe36fb5353c5f672Ted Kremenek ExpandTypeToArgs(FT, RValue::getAggregate(LV.getAddress()), Args); 239b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu } else { 240ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks RValue RV = EmitLoadOfLValue(LV, FT); 241b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu assert(RV.isScalar() && 242b13453bd8a91f331d0910ca95ad52aa41b52f648Zhongxing Xu "Unexpected non-scalar rvalue during struct expansion."); 243d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios Kyrtzidis Args.push_back(RV.getScalarVal()); 244cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu } 245aa0aeb1cbe117db68d35700cb3a34aace0f99b99Anna Zaks } 24641c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek} 247ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks 248c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek/// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as 2499d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek/// a pointer to an object of type \arg Ty. 25041c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek/// 251cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu/// This safely handles the case when the src type is smaller than the 252cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu/// destination type; in this situation the values of bits which not 25341c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek/// present in the src are undefined. 25441c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenekstatic llvm::Value *CreateCoercedLoad(llvm::Value *SrcPtr, 25541c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek const llvm::Type *Ty, 25641c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek CodeGenFunction &CGF) { 25741c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek const llvm::Type *SrcTy = 25818c66fdc3c4008d335885695fe36fb5353c5f672Ted Kremenek cast<llvm::PointerType>(SrcPtr->getType())->getElementType(); 2595eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek uint64_t SrcSize = CGF.CGM.getTargetData().getTypeAllocSize(SrcTy); 2605eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek uint64_t DstSize = CGF.CGM.getTargetData().getTypeAllocSize(Ty); 261ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks 26241c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek // If load is legal, just bitcast the src pointer. 26341c5f498b2d10fab683f1c5685ff79c90a737d24Ted Kremenek if (SrcSize >= DstSize) { 264cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu // Generally SrcSize is never greater than DstSize, since this means we are 265b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // losing bits. However, this can happen in cases where the structure has 266b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // additional padding, for example due to a user specified alignment. 267b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // 268b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // FIXME: Assert that we aren't truncating non-padding bits when have access 269b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // to that information. 2709c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek llvm::Value *Casted = 271ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty)); 2729c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted); 2739c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek // FIXME: Use better alignment / avoid requiring aligned load. 274ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks Load->setAlignment(1); 275cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu return Load; 276b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu } else { 2779c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek // Otherwise do coercion through memory. This is stupid, but 2789c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek // simple. 2799d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek llvm::Value *Tmp = CGF.CreateTempAlloca(Ty); 28018c66fdc3c4008d335885695fe36fb5353c5f672Ted Kremenek llvm::Value *Casted = 2819d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek CGF.Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(SrcTy)); 2829d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek llvm::StoreInst *Store = 2839d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek CGF.Builder.CreateStore(CGF.Builder.CreateLoad(SrcPtr), Casted); 2849d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek // FIXME: Use better alignment / avoid requiring aligned store. 2855f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner Store->setAlignment(1); 2869d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek return CGF.Builder.CreateLoad(Tmp); 2879d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek } 2889d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek} 2899d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek 2905eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek/// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src, 2919d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek/// where the source and destination may have different types. 2929d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek/// 2939d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek/// This safely handles the case when the src type is larger than the 294b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu/// destination type; the upper bits of the src will be lost. 295b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xustatic void CreateCoercedStore(llvm::Value *Src, 2969d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek llvm::Value *DstPtr, 2979d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek CodeGenFunction &CGF) { 298eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks const llvm::Type *SrcTy = Src->getType(); 299eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks const llvm::Type *DstTy = 300537716ad8dd10f984b6cfe6985afade1185c5e3cJordy Rose cast<llvm::PointerType>(DstPtr->getType())->getElementType(); 301eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 3029d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek uint64_t SrcSize = CGF.CGM.getTargetData().getTypeAllocSize(SrcTy); 303b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu uint64_t DstSize = CGF.CGM.getTargetData().getTypeAllocSize(DstTy); 3049d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek 305eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks // If store is legal, just bitcast the src pointer. 306eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks if (SrcSize <= DstSize) { 307537716ad8dd10f984b6cfe6985afade1185c5e3cJordy Rose llvm::Value *Casted = 308eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy)); 3099d5d308c9be367ec41cc6a89f215d45f675b4617Ted Kremenek // FIXME: Use better alignment / avoid requiring aligned store. 310b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu CGF.Builder.CreateStore(Src, Casted)->setAlignment(1); 3115eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek } else { 3125eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek // Otherwise do coercion through memory. This is stupid, but 313b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // simple. 314b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu 315b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // Generally SrcSize is never greater than DstSize, since this means we are 316b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // losing bits. However, this can happen in cases where the structure has 317b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // additional padding, for example due to a user specified alignment. 318b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // 319b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu // FIXME: Assert that we aren't truncating non-padding bits when have access 3205eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek // to that information. 3215eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy); 322ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks CGF.Builder.CreateStore(Src, Tmp); 323b17b1b3cc2b0d4d3b263b9384571bbc7f3995771Zhongxing Xu llvm::Value *Casted = 324cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu CGF.Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(DstTy)); 325cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted); 326d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios Kyrtzidis // FIXME: Use better alignment / avoid requiring aligned load. 327ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks Load->setAlignment(1); 3286b8513829895e56a7b97e787ea74520bc626512eZhongxing Xu CGF.Builder.CreateStore(Load, DstPtr); 3299c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek } 3309c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek} 331aa0aeb1cbe117db68d35700cb3a34aace0f99b99Anna Zaks 3329c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek/***/ 3339c14953d0c84f7cf5adfb4cd3c0f05a9b1723c1cTed Kremenek 33418c66fdc3c4008d335885695fe36fb5353c5f672Ted Kremenekbool CodeGenModule::ReturnTypeUsesSret(const CGFunctionInfo &FI) { 335ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks return FI.getReturnInfo().isIndirect(); 3366b8513829895e56a7b97e787ea74520bc626512eZhongxing Xu} 3376b8513829895e56a7b97e787ea74520bc626512eZhongxing Xu 338cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xuconst llvm::FunctionType * 339d2592a34a059e7cbb2b11dc53649ac4912422909Argyrios KyrtzidisCodeGenTypes::GetFunctionType(const CGFunctionInfo &FI, bool IsVariadic) { 3406b8513829895e56a7b97e787ea74520bc626512eZhongxing Xu std::vector<const llvm::Type*> ArgTys; 341aa0aeb1cbe117db68d35700cb3a34aace0f99b99Anna Zaks 342ebae6d0209e1ec3d5ea14f9e63bd0d740218ed14Anna Zaks const llvm::Type *ResultType = 0; 343cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu 3445eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek QualType RetTy = FI.getReturnType(); 345cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu const ABIArgInfo &RetAI = FI.getReturnInfo(); 346c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek switch (RetAI.getKind()) { 347cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu case ABIArgInfo::Expand: 3485eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek assert(0 && "Invalid ABI kind for return argument"); 349cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu 35018c66fdc3c4008d335885695fe36fb5353c5f672Ted Kremenek case ABIArgInfo::Extend: 351cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu case ABIArgInfo::Direct: 3525eca482fe895ea57bc82410222e6426c09e63284Ted Kremenek ResultType = ConvertType(RetTy); 353cb7464ab402d057849dda9749d62a62d86c35ab8Zhongxing Xu break; 354 355 case ABIArgInfo::Indirect: { 356 assert(!RetAI.getIndirectAlign() && "Align unused on indirect return."); 357 ResultType = llvm::Type::getVoidTy(getLLVMContext()); 358 const llvm::Type *STy = ConvertType(RetTy); 359 ArgTys.push_back(llvm::PointerType::get(STy, RetTy.getAddressSpace())); 360 break; 361 } 362 363 case ABIArgInfo::Ignore: 364 ResultType = llvm::Type::getVoidTy(getLLVMContext()); 365 break; 366 367 case ABIArgInfo::Coerce: 368 ResultType = RetAI.getCoerceToType(); 369 break; 370 } 371 372 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), 373 ie = FI.arg_end(); it != ie; ++it) { 374 const ABIArgInfo &AI = it->info; 375 376 switch (AI.getKind()) { 377 case ABIArgInfo::Ignore: 378 break; 379 380 case ABIArgInfo::Coerce: 381 ArgTys.push_back(AI.getCoerceToType()); 382 break; 383 384 case ABIArgInfo::Indirect: { 385 // indirect arguments are always on the stack, which is addr space #0. 386 const llvm::Type *LTy = ConvertTypeForMem(it->type); 387 ArgTys.push_back(llvm::PointerType::getUnqual(LTy)); 388 break; 389 } 390 391 case ABIArgInfo::Extend: 392 case ABIArgInfo::Direct: 393 ArgTys.push_back(ConvertType(it->type)); 394 break; 395 396 case ABIArgInfo::Expand: 397 GetExpandedTypes(it->type, ArgTys); 398 break; 399 } 400 } 401 402 return llvm::FunctionType::get(ResultType, ArgTys, IsVariadic); 403} 404 405void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, 406 const Decl *TargetDecl, 407 AttributeListType &PAL) { 408 unsigned FuncAttrs = 0; 409 unsigned RetAttrs = 0; 410 411 // FIXME: handle sseregparm someday... 412 if (TargetDecl) { 413 if (TargetDecl->hasAttr<NoThrowAttr>()) 414 FuncAttrs |= llvm::Attribute::NoUnwind; 415 if (TargetDecl->hasAttr<NoReturnAttr>()) 416 FuncAttrs |= llvm::Attribute::NoReturn; 417 if (TargetDecl->hasAttr<ConstAttr>()) 418 FuncAttrs |= llvm::Attribute::ReadNone; 419 else if (TargetDecl->hasAttr<PureAttr>()) 420 FuncAttrs |= llvm::Attribute::ReadOnly; 421 if (TargetDecl->hasAttr<MallocAttr>()) 422 RetAttrs |= llvm::Attribute::NoAlias; 423 } 424 425 if (CompileOpts.DisableRedZone) 426 FuncAttrs |= llvm::Attribute::NoRedZone; 427 if (CompileOpts.NoImplicitFloat) 428 FuncAttrs |= llvm::Attribute::NoImplicitFloat; 429 430 if (Features.getStackProtectorMode() == LangOptions::SSPOn) 431 FuncAttrs |= llvm::Attribute::StackProtect; 432 else if (Features.getStackProtectorMode() == LangOptions::SSPReq) 433 FuncAttrs |= llvm::Attribute::StackProtectReq; 434 435 QualType RetTy = FI.getReturnType(); 436 unsigned Index = 1; 437 const ABIArgInfo &RetAI = FI.getReturnInfo(); 438 switch (RetAI.getKind()) { 439 case ABIArgInfo::Extend: 440 if (RetTy->isSignedIntegerType()) { 441 RetAttrs |= llvm::Attribute::SExt; 442 } else if (RetTy->isUnsignedIntegerType()) { 443 RetAttrs |= llvm::Attribute::ZExt; 444 } 445 // FALLTHROUGH 446 case ABIArgInfo::Direct: 447 break; 448 449 case ABIArgInfo::Indirect: 450 PAL.push_back(llvm::AttributeWithIndex::get(Index, 451 llvm::Attribute::StructRet | 452 llvm::Attribute::NoAlias)); 453 ++Index; 454 // sret disables readnone and readonly 455 FuncAttrs &= ~(llvm::Attribute::ReadOnly | 456 llvm::Attribute::ReadNone); 457 break; 458 459 case ABIArgInfo::Ignore: 460 case ABIArgInfo::Coerce: 461 break; 462 463 case ABIArgInfo::Expand: 464 assert(0 && "Invalid ABI kind for return argument"); 465 } 466 467 if (RetAttrs) 468 PAL.push_back(llvm::AttributeWithIndex::get(0, RetAttrs)); 469 470 // FIXME: we need to honour command line settings also... 471 // FIXME: RegParm should be reduced in case of nested functions and/or global 472 // register variable. 473 signed RegParm = 0; 474 if (TargetDecl) 475 if (const RegparmAttr *RegParmAttr 476 = TargetDecl->getAttr<RegparmAttr>()) 477 RegParm = RegParmAttr->getNumParams(); 478 479 unsigned PointerWidth = getContext().Target.getPointerWidth(0); 480 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), 481 ie = FI.arg_end(); it != ie; ++it) { 482 QualType ParamType = it->type; 483 const ABIArgInfo &AI = it->info; 484 unsigned Attributes = 0; 485 486 switch (AI.getKind()) { 487 case ABIArgInfo::Coerce: 488 break; 489 490 case ABIArgInfo::Indirect: 491 Attributes |= llvm::Attribute::ByVal; 492 Attributes |= 493 llvm::Attribute::constructAlignmentFromInt(AI.getIndirectAlign()); 494 // byval disables readnone and readonly. 495 FuncAttrs &= ~(llvm::Attribute::ReadOnly | 496 llvm::Attribute::ReadNone); 497 break; 498 499 case ABIArgInfo::Extend: 500 if (ParamType->isSignedIntegerType()) { 501 Attributes |= llvm::Attribute::SExt; 502 } else if (ParamType->isUnsignedIntegerType()) { 503 Attributes |= llvm::Attribute::ZExt; 504 } 505 // FALLS THROUGH 506 case ABIArgInfo::Direct: 507 if (RegParm > 0 && 508 (ParamType->isIntegerType() || ParamType->isPointerType())) { 509 RegParm -= 510 (Context.getTypeSize(ParamType) + PointerWidth - 1) / PointerWidth; 511 if (RegParm >= 0) 512 Attributes |= llvm::Attribute::InReg; 513 } 514 // FIXME: handle sseregparm someday... 515 break; 516 517 case ABIArgInfo::Ignore: 518 // Skip increment, no matching LLVM parameter. 519 continue; 520 521 case ABIArgInfo::Expand: { 522 std::vector<const llvm::Type*> Tys; 523 // FIXME: This is rather inefficient. Do we ever actually need to do 524 // anything here? The result should be just reconstructed on the other 525 // side, so extension should be a non-issue. 526 getTypes().GetExpandedTypes(ParamType, Tys); 527 Index += Tys.size(); 528 continue; 529 } 530 } 531 532 if (Attributes) 533 PAL.push_back(llvm::AttributeWithIndex::get(Index, Attributes)); 534 ++Index; 535 } 536 if (FuncAttrs) 537 PAL.push_back(llvm::AttributeWithIndex::get(~0, FuncAttrs)); 538} 539 540void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI, 541 llvm::Function *Fn, 542 const FunctionArgList &Args) { 543 // If this is an implicit-return-zero function, go ahead and 544 // initialize the return value. TODO: it might be nice to have 545 // a more general mechanism for this that didn't require synthesized 546 // return statements. 547 if (const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl)) { 548 if (FD->hasImplicitReturnZero()) { 549 QualType RetTy = FD->getResultType().getUnqualifiedType(); 550 const llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy); 551 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy); 552 Builder.CreateStore(Zero, ReturnValue); 553 } 554 } 555 556 // FIXME: We no longer need the types from FunctionArgList; lift up and 557 // simplify. 558 559 // Emit allocs for param decls. Give the LLVM Argument nodes names. 560 llvm::Function::arg_iterator AI = Fn->arg_begin(); 561 562 // Name the struct return argument. 563 if (CGM.ReturnTypeUsesSret(FI)) { 564 AI->setName("agg.result"); 565 ++AI; 566 } 567 568 assert(FI.arg_size() == Args.size() && 569 "Mismatch between function signature & arguments."); 570 CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin(); 571 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 572 i != e; ++i, ++info_it) { 573 const VarDecl *Arg = i->first; 574 QualType Ty = info_it->type; 575 const ABIArgInfo &ArgI = info_it->info; 576 577 switch (ArgI.getKind()) { 578 case ABIArgInfo::Indirect: { 579 llvm::Value* V = AI; 580 if (hasAggregateLLVMType(Ty)) { 581 // Do nothing, aggregates and complex variables are accessed by 582 // reference. 583 } else { 584 // Load scalar value from indirect argument. 585 V = EmitLoadOfScalar(V, false, Ty); 586 if (!getContext().typesAreCompatible(Ty, Arg->getType())) { 587 // This must be a promotion, for something like 588 // "void a(x) short x; {..." 589 V = EmitScalarConversion(V, Ty, Arg->getType()); 590 } 591 } 592 EmitParmDecl(*Arg, V); 593 break; 594 } 595 596 case ABIArgInfo::Extend: 597 case ABIArgInfo::Direct: { 598 assert(AI != Fn->arg_end() && "Argument mismatch!"); 599 llvm::Value* V = AI; 600 if (hasAggregateLLVMType(Ty)) { 601 // Create a temporary alloca to hold the argument; the rest of 602 // codegen expects to access aggregates & complex values by 603 // reference. 604 V = CreateTempAlloca(ConvertTypeForMem(Ty)); 605 Builder.CreateStore(AI, V); 606 } else { 607 if (!getContext().typesAreCompatible(Ty, Arg->getType())) { 608 // This must be a promotion, for something like 609 // "void a(x) short x; {..." 610 V = EmitScalarConversion(V, Ty, Arg->getType()); 611 } 612 } 613 EmitParmDecl(*Arg, V); 614 break; 615 } 616 617 case ABIArgInfo::Expand: { 618 // If this structure was expanded into multiple arguments then 619 // we need to create a temporary and reconstruct it from the 620 // arguments. 621 std::string Name = Arg->getNameAsString(); 622 llvm::Value *Temp = CreateTempAlloca(ConvertTypeForMem(Ty), 623 (Name + ".addr").c_str()); 624 // FIXME: What are the right qualifiers here? 625 llvm::Function::arg_iterator End = 626 ExpandTypeFromArgs(Ty, LValue::MakeAddr(Temp,0), AI); 627 EmitParmDecl(*Arg, Temp); 628 629 // Name the arguments used in expansion and increment AI. 630 unsigned Index = 0; 631 for (; AI != End; ++AI, ++Index) 632 AI->setName(Name + "." + llvm::Twine(Index)); 633 continue; 634 } 635 636 case ABIArgInfo::Ignore: 637 // Initialize the local variable appropriately. 638 if (hasAggregateLLVMType(Ty)) { 639 EmitParmDecl(*Arg, CreateTempAlloca(ConvertTypeForMem(Ty))); 640 } else { 641 EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType()))); 642 } 643 644 // Skip increment, no matching LLVM parameter. 645 continue; 646 647 case ABIArgInfo::Coerce: { 648 assert(AI != Fn->arg_end() && "Argument mismatch!"); 649 // FIXME: This is very wasteful; EmitParmDecl is just going to drop the 650 // result in a new alloca anyway, so we could just store into that 651 // directly if we broke the abstraction down more. 652 llvm::Value *V = CreateTempAlloca(ConvertTypeForMem(Ty), "coerce"); 653 CreateCoercedStore(AI, V, *this); 654 // Match to what EmitParmDecl is expecting for this type. 655 if (!CodeGenFunction::hasAggregateLLVMType(Ty)) { 656 V = EmitLoadOfScalar(V, false, Ty); 657 if (!getContext().typesAreCompatible(Ty, Arg->getType())) { 658 // This must be a promotion, for something like 659 // "void a(x) short x; {..." 660 V = EmitScalarConversion(V, Ty, Arg->getType()); 661 } 662 } 663 EmitParmDecl(*Arg, V); 664 break; 665 } 666 } 667 668 ++AI; 669 } 670 assert(AI == Fn->arg_end() && "Argument mismatch!"); 671} 672 673void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI, 674 llvm::Value *ReturnValue) { 675 llvm::Value *RV = 0; 676 677 // Functions with no result always return void. 678 if (ReturnValue) { 679 QualType RetTy = FI.getReturnType(); 680 const ABIArgInfo &RetAI = FI.getReturnInfo(); 681 682 switch (RetAI.getKind()) { 683 case ABIArgInfo::Indirect: 684 if (RetTy->isAnyComplexType()) { 685 ComplexPairTy RT = LoadComplexFromAddr(ReturnValue, false); 686 StoreComplexToAddr(RT, CurFn->arg_begin(), false); 687 } else if (CodeGenFunction::hasAggregateLLVMType(RetTy)) { 688 EmitAggregateCopy(CurFn->arg_begin(), ReturnValue, RetTy); 689 } else { 690 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), CurFn->arg_begin(), 691 false, RetTy); 692 } 693 break; 694 695 case ABIArgInfo::Extend: 696 case ABIArgInfo::Direct: 697 // The internal return value temp always will have 698 // pointer-to-return-type type. 699 RV = Builder.CreateLoad(ReturnValue); 700 break; 701 702 case ABIArgInfo::Ignore: 703 break; 704 705 case ABIArgInfo::Coerce: 706 RV = CreateCoercedLoad(ReturnValue, RetAI.getCoerceToType(), *this); 707 break; 708 709 case ABIArgInfo::Expand: 710 assert(0 && "Invalid ABI kind for return argument"); 711 } 712 } 713 714 if (RV) { 715 Builder.CreateRet(RV); 716 } else { 717 Builder.CreateRetVoid(); 718 } 719} 720 721RValue CodeGenFunction::EmitCallArg(const Expr *E, QualType ArgType) { 722 if (ArgType->isReferenceType()) 723 return EmitReferenceBindingToExpr(E, ArgType); 724 725 return EmitAnyExprToTemp(E); 726} 727 728RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, 729 llvm::Value *Callee, 730 const CallArgList &CallArgs, 731 const Decl *TargetDecl) { 732 // FIXME: We no longer need the types from CallArgs; lift up and simplify. 733 llvm::SmallVector<llvm::Value*, 16> Args; 734 735 // Handle struct-return functions by passing a pointer to the 736 // location that we would like to return into. 737 QualType RetTy = CallInfo.getReturnType(); 738 const ABIArgInfo &RetAI = CallInfo.getReturnInfo(); 739 740 741 // If the call returns a temporary with struct return, create a temporary 742 // alloca to hold the result. 743 if (CGM.ReturnTypeUsesSret(CallInfo)) 744 Args.push_back(CreateTempAlloca(ConvertTypeForMem(RetTy))); 745 746 assert(CallInfo.arg_size() == CallArgs.size() && 747 "Mismatch between function signature & arguments."); 748 CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin(); 749 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); 750 I != E; ++I, ++info_it) { 751 const ABIArgInfo &ArgInfo = info_it->info; 752 RValue RV = I->first; 753 754 switch (ArgInfo.getKind()) { 755 case ABIArgInfo::Indirect: 756 if (RV.isScalar() || RV.isComplex()) { 757 // Make a temporary alloca to pass the argument. 758 Args.push_back(CreateTempAlloca(ConvertTypeForMem(I->second))); 759 if (RV.isScalar()) 760 EmitStoreOfScalar(RV.getScalarVal(), Args.back(), false, I->second); 761 else 762 StoreComplexToAddr(RV.getComplexVal(), Args.back(), false); 763 } else { 764 Args.push_back(RV.getAggregateAddr()); 765 } 766 break; 767 768 case ABIArgInfo::Extend: 769 case ABIArgInfo::Direct: 770 if (RV.isScalar()) { 771 Args.push_back(RV.getScalarVal()); 772 } else if (RV.isComplex()) { 773 llvm::Value *Tmp = llvm::UndefValue::get(ConvertType(I->second)); 774 Tmp = Builder.CreateInsertValue(Tmp, RV.getComplexVal().first, 0); 775 Tmp = Builder.CreateInsertValue(Tmp, RV.getComplexVal().second, 1); 776 Args.push_back(Tmp); 777 } else { 778 Args.push_back(Builder.CreateLoad(RV.getAggregateAddr())); 779 } 780 break; 781 782 case ABIArgInfo::Ignore: 783 break; 784 785 case ABIArgInfo::Coerce: { 786 // FIXME: Avoid the conversion through memory if possible. 787 llvm::Value *SrcPtr; 788 if (RV.isScalar()) { 789 SrcPtr = CreateTempAlloca(ConvertTypeForMem(I->second), "coerce"); 790 EmitStoreOfScalar(RV.getScalarVal(), SrcPtr, false, I->second); 791 } else if (RV.isComplex()) { 792 SrcPtr = CreateTempAlloca(ConvertTypeForMem(I->second), "coerce"); 793 StoreComplexToAddr(RV.getComplexVal(), SrcPtr, false); 794 } else 795 SrcPtr = RV.getAggregateAddr(); 796 Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(), 797 *this)); 798 break; 799 } 800 801 case ABIArgInfo::Expand: 802 ExpandTypeToArgs(I->second, RV, Args); 803 break; 804 } 805 } 806 807 // If the callee is a bitcast of a function to a varargs pointer to function 808 // type, check to see if we can remove the bitcast. This handles some cases 809 // with unprototyped functions. 810 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Callee)) 811 if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) { 812 const llvm::PointerType *CurPT=cast<llvm::PointerType>(Callee->getType()); 813 const llvm::FunctionType *CurFT = 814 cast<llvm::FunctionType>(CurPT->getElementType()); 815 const llvm::FunctionType *ActualFT = CalleeF->getFunctionType(); 816 817 if (CE->getOpcode() == llvm::Instruction::BitCast && 818 ActualFT->getReturnType() == CurFT->getReturnType() && 819 ActualFT->getNumParams() == CurFT->getNumParams() && 820 ActualFT->getNumParams() == Args.size()) { 821 bool ArgsMatch = true; 822 for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i) 823 if (ActualFT->getParamType(i) != CurFT->getParamType(i)) { 824 ArgsMatch = false; 825 break; 826 } 827 828 // Strip the cast if we can get away with it. This is a nice cleanup, 829 // but also allows us to inline the function at -O0 if it is marked 830 // always_inline. 831 if (ArgsMatch) 832 Callee = CalleeF; 833 } 834 } 835 836 837 llvm::BasicBlock *InvokeDest = getInvokeDest(); 838 CodeGen::AttributeListType AttributeList; 839 CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList); 840 llvm::AttrListPtr Attrs = llvm::AttrListPtr::get(AttributeList.begin(), 841 AttributeList.end()); 842 843 llvm::CallSite CS; 844 if (!InvokeDest || (Attrs.getFnAttributes() & llvm::Attribute::NoUnwind)) { 845 CS = Builder.CreateCall(Callee, Args.data(), Args.data()+Args.size()); 846 } else { 847 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont"); 848 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, 849 Args.data(), Args.data()+Args.size()); 850 EmitBlock(Cont); 851 } 852 853 CS.setAttributes(Attrs); 854 if (const llvm::Function *F = 855 dyn_cast<llvm::Function>(Callee->stripPointerCasts())) 856 CS.setCallingConv(F->getCallingConv()); 857 858 // If the call doesn't return, finish the basic block and clear the 859 // insertion point; this allows the rest of IRgen to discard 860 // unreachable code. 861 if (CS.doesNotReturn()) { 862 Builder.CreateUnreachable(); 863 Builder.ClearInsertionPoint(); 864 865 // FIXME: For now, emit a dummy basic block because expr emitters in 866 // generally are not ready to handle emitting expressions at unreachable 867 // points. 868 EnsureInsertPoint(); 869 870 // Return a reasonable RValue. 871 return GetUndefRValue(RetTy); 872 } 873 874 llvm::Instruction *CI = CS.getInstruction(); 875 if (Builder.isNamePreserving() && 876 CI->getType() != llvm::Type::getVoidTy(VMContext)) 877 CI->setName("call"); 878 879 switch (RetAI.getKind()) { 880 case ABIArgInfo::Indirect: 881 if (RetTy->isAnyComplexType()) 882 return RValue::getComplex(LoadComplexFromAddr(Args[0], false)); 883 if (CodeGenFunction::hasAggregateLLVMType(RetTy)) 884 return RValue::getAggregate(Args[0]); 885 return RValue::get(EmitLoadOfScalar(Args[0], false, RetTy)); 886 887 case ABIArgInfo::Extend: 888 case ABIArgInfo::Direct: 889 if (RetTy->isAnyComplexType()) { 890 llvm::Value *Real = Builder.CreateExtractValue(CI, 0); 891 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1); 892 return RValue::getComplex(std::make_pair(Real, Imag)); 893 } 894 if (CodeGenFunction::hasAggregateLLVMType(RetTy)) { 895 llvm::Value *V = CreateTempAlloca(ConvertTypeForMem(RetTy), "agg.tmp"); 896 Builder.CreateStore(CI, V); 897 return RValue::getAggregate(V); 898 } 899 return RValue::get(CI); 900 901 case ABIArgInfo::Ignore: 902 // If we are ignoring an argument that had a result, make sure to 903 // construct the appropriate return value for our caller. 904 return GetUndefRValue(RetTy); 905 906 case ABIArgInfo::Coerce: { 907 // FIXME: Avoid the conversion through memory if possible. 908 llvm::Value *V = CreateTempAlloca(ConvertTypeForMem(RetTy), "coerce"); 909 CreateCoercedStore(CI, V, *this); 910 if (RetTy->isAnyComplexType()) 911 return RValue::getComplex(LoadComplexFromAddr(V, false)); 912 if (CodeGenFunction::hasAggregateLLVMType(RetTy)) 913 return RValue::getAggregate(V); 914 return RValue::get(EmitLoadOfScalar(V, false, RetTy)); 915 } 916 917 case ABIArgInfo::Expand: 918 assert(0 && "Invalid ABI kind for return argument"); 919 } 920 921 assert(0 && "Unhandled ABIArgInfo::Kind"); 922 return RValue::get(0); 923} 924 925/* VarArg handling */ 926 927llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) { 928 return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this); 929} 930