CGCall.cpp revision c3f7fd67c8431ab1494f2d14725f5da03554365b
1//===--- CGCall.cpp - Encapsulate calling convention details --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// These classes wrap the information about a call or function 11// definition used to handle ABI compliancy. 12// 13//===----------------------------------------------------------------------===// 14 15#include "CGCall.h" 16#include "ABIInfo.h" 17#include "CGCXXABI.h" 18#include "CodeGenFunction.h" 19#include "CodeGenModule.h" 20#include "TargetInfo.h" 21#include "clang/AST/Decl.h" 22#include "clang/AST/DeclCXX.h" 23#include "clang/AST/DeclObjC.h" 24#include "clang/Basic/TargetInfo.h" 25#include "clang/Frontend/CodeGenOptions.h" 26#include "llvm/ADT/StringExtras.h" 27#include "llvm/IR/Attributes.h" 28#include "llvm/IR/DataLayout.h" 29#include "llvm/IR/InlineAsm.h" 30#include "llvm/MC/SubtargetFeature.h" 31#include "llvm/Support/CallSite.h" 32#include "llvm/Transforms/Utils/Local.h" 33using namespace clang; 34using namespace CodeGen; 35 36/***/ 37 38static unsigned ClangCallConvToLLVMCallConv(CallingConv CC) { 39 switch (CC) { 40 default: return llvm::CallingConv::C; 41 case CC_X86StdCall: return llvm::CallingConv::X86_StdCall; 42 case CC_X86FastCall: return llvm::CallingConv::X86_FastCall; 43 case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall; 44 case CC_X86_64Win64: return llvm::CallingConv::X86_64_Win64; 45 case CC_X86_64SysV: return llvm::CallingConv::X86_64_SysV; 46 case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS; 47 case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP; 48 case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI; 49 // TODO: add support for CC_X86Pascal to llvm 50 } 51} 52 53/// Derives the 'this' type for codegen purposes, i.e. ignoring method 54/// qualification. 55/// FIXME: address space qualification? 56static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) { 57 QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal(); 58 return Context.getPointerType(CanQualType::CreateUnsafe(RecTy)); 59} 60 61/// Returns the canonical formal type of the given C++ method. 62static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) { 63 return MD->getType()->getCanonicalTypeUnqualified() 64 .getAs<FunctionProtoType>(); 65} 66 67/// Returns the "extra-canonicalized" return type, which discards 68/// qualifiers on the return type. Codegen doesn't care about them, 69/// and it makes ABI code a little easier to be able to assume that 70/// all parameter and return types are top-level unqualified. 71static CanQualType GetReturnType(QualType RetTy) { 72 return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType(); 73} 74 75/// Arrange the argument and result information for a value of the given 76/// unprototyped freestanding function type. 77const CGFunctionInfo & 78CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) { 79 // When translating an unprototyped function type, always use a 80 // variadic type. 81 return arrangeLLVMFunctionInfo(FTNP->getResultType().getUnqualifiedType(), 82 None, FTNP->getExtInfo(), RequiredArgs(0)); 83} 84 85/// Arrange the LLVM function layout for a value of the given function 86/// type, on top of any implicit parameters already stored. Use the 87/// given ExtInfo instead of the ExtInfo from the function type. 88static const CGFunctionInfo &arrangeLLVMFunctionInfo(CodeGenTypes &CGT, 89 SmallVectorImpl<CanQualType> &prefix, 90 CanQual<FunctionProtoType> FTP, 91 FunctionType::ExtInfo extInfo) { 92 RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, prefix.size()); 93 // FIXME: Kill copy. 94 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) 95 prefix.push_back(FTP->getArgType(i)); 96 CanQualType resultType = FTP->getResultType().getUnqualifiedType(); 97 return CGT.arrangeLLVMFunctionInfo(resultType, prefix, extInfo, required); 98} 99 100/// Arrange the argument and result information for a free function (i.e. 101/// not a C++ or ObjC instance method) of the given type. 102static const CGFunctionInfo &arrangeFreeFunctionType(CodeGenTypes &CGT, 103 SmallVectorImpl<CanQualType> &prefix, 104 CanQual<FunctionProtoType> FTP) { 105 return arrangeLLVMFunctionInfo(CGT, prefix, FTP, FTP->getExtInfo()); 106} 107 108/// Arrange the argument and result information for a free function (i.e. 109/// not a C++ or ObjC instance method) of the given type. 110static const CGFunctionInfo &arrangeCXXMethodType(CodeGenTypes &CGT, 111 SmallVectorImpl<CanQualType> &prefix, 112 CanQual<FunctionProtoType> FTP) { 113 FunctionType::ExtInfo extInfo = FTP->getExtInfo(); 114 return arrangeLLVMFunctionInfo(CGT, prefix, FTP, extInfo); 115} 116 117/// Arrange the argument and result information for a value of the 118/// given freestanding function type. 119const CGFunctionInfo & 120CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) { 121 SmallVector<CanQualType, 16> argTypes; 122 return ::arrangeFreeFunctionType(*this, argTypes, FTP); 123} 124 125static CallingConv getCallingConventionForDecl(const Decl *D) { 126 // Set the appropriate calling convention for the Function. 127 if (D->hasAttr<StdCallAttr>()) 128 return CC_X86StdCall; 129 130 if (D->hasAttr<FastCallAttr>()) 131 return CC_X86FastCall; 132 133 if (D->hasAttr<ThisCallAttr>()) 134 return CC_X86ThisCall; 135 136 if (D->hasAttr<PascalAttr>()) 137 return CC_X86Pascal; 138 139 if (PcsAttr *PCS = D->getAttr<PcsAttr>()) 140 return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP); 141 142 if (D->hasAttr<PnaclCallAttr>()) 143 return CC_PnaclCall; 144 145 if (D->hasAttr<IntelOclBiccAttr>()) 146 return CC_IntelOclBicc; 147 148 return CC_C; 149} 150 151/// Arrange the argument and result information for a call to an 152/// unknown C++ non-static member function of the given abstract type. 153/// (Zero value of RD means we don't have any meaningful "this" argument type, 154/// so fall back to a generic pointer type). 155/// The member function must be an ordinary function, i.e. not a 156/// constructor or destructor. 157const CGFunctionInfo & 158CodeGenTypes::arrangeCXXMethodType(const CXXRecordDecl *RD, 159 const FunctionProtoType *FTP) { 160 SmallVector<CanQualType, 16> argTypes; 161 162 // Add the 'this' pointer. 163 if (RD) 164 argTypes.push_back(GetThisType(Context, RD)); 165 else 166 argTypes.push_back(Context.VoidPtrTy); 167 168 return ::arrangeCXXMethodType(*this, argTypes, 169 FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>()); 170} 171 172/// Arrange the argument and result information for a declaration or 173/// definition of the given C++ non-static member function. The 174/// member function must be an ordinary function, i.e. not a 175/// constructor or destructor. 176const CGFunctionInfo & 177CodeGenTypes::arrangeCXXMethodDeclaration(const CXXMethodDecl *MD) { 178 assert(!isa<CXXConstructorDecl>(MD) && "wrong method for constructors!"); 179 assert(!isa<CXXDestructorDecl>(MD) && "wrong method for destructors!"); 180 181 CanQual<FunctionProtoType> prototype = GetFormalType(MD); 182 183 if (MD->isInstance()) { 184 // The abstract case is perfectly fine. 185 const CXXRecordDecl *ThisType = TheCXXABI.getThisArgumentTypeForMethod(MD); 186 return arrangeCXXMethodType(ThisType, prototype.getTypePtr()); 187 } 188 189 return arrangeFreeFunctionType(prototype); 190} 191 192/// Arrange the argument and result information for a declaration 193/// or definition to the given constructor variant. 194const CGFunctionInfo & 195CodeGenTypes::arrangeCXXConstructorDeclaration(const CXXConstructorDecl *D, 196 CXXCtorType ctorKind) { 197 SmallVector<CanQualType, 16> argTypes; 198 argTypes.push_back(GetThisType(Context, D->getParent())); 199 200 GlobalDecl GD(D, ctorKind); 201 CanQualType resultType = 202 TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; 203 204 TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes); 205 206 CanQual<FunctionProtoType> FTP = GetFormalType(D); 207 208 RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, argTypes.size()); 209 210 // Add the formal parameters. 211 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i) 212 argTypes.push_back(FTP->getArgType(i)); 213 214 FunctionType::ExtInfo extInfo = FTP->getExtInfo(); 215 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, required); 216} 217 218/// Arrange the argument and result information for a declaration, 219/// definition, or call to the given destructor variant. It so 220/// happens that all three cases produce the same information. 221const CGFunctionInfo & 222CodeGenTypes::arrangeCXXDestructor(const CXXDestructorDecl *D, 223 CXXDtorType dtorKind) { 224 SmallVector<CanQualType, 2> argTypes; 225 argTypes.push_back(GetThisType(Context, D->getParent())); 226 227 GlobalDecl GD(D, dtorKind); 228 CanQualType resultType = 229 TheCXXABI.HasThisReturn(GD) ? argTypes.front() : Context.VoidTy; 230 231 TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes); 232 233 CanQual<FunctionProtoType> FTP = GetFormalType(D); 234 assert(FTP->getNumArgs() == 0 && "dtor with formal parameters"); 235 assert(FTP->isVariadic() == 0 && "dtor with formal parameters"); 236 237 FunctionType::ExtInfo extInfo = FTP->getExtInfo(); 238 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, 239 RequiredArgs::All); 240} 241 242/// Arrange the argument and result information for the declaration or 243/// definition of the given function. 244const CGFunctionInfo & 245CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) { 246 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 247 if (MD->isInstance()) 248 return arrangeCXXMethodDeclaration(MD); 249 250 CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified(); 251 252 assert(isa<FunctionType>(FTy)); 253 254 // When declaring a function without a prototype, always use a 255 // non-variadic type. 256 if (isa<FunctionNoProtoType>(FTy)) { 257 CanQual<FunctionNoProtoType> noProto = FTy.getAs<FunctionNoProtoType>(); 258 return arrangeLLVMFunctionInfo(noProto->getResultType(), None, 259 noProto->getExtInfo(), RequiredArgs::All); 260 } 261 262 assert(isa<FunctionProtoType>(FTy)); 263 return arrangeFreeFunctionType(FTy.getAs<FunctionProtoType>()); 264} 265 266/// Arrange the argument and result information for the declaration or 267/// definition of an Objective-C method. 268const CGFunctionInfo & 269CodeGenTypes::arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD) { 270 // It happens that this is the same as a call with no optional 271 // arguments, except also using the formal 'self' type. 272 return arrangeObjCMessageSendSignature(MD, MD->getSelfDecl()->getType()); 273} 274 275/// Arrange the argument and result information for the function type 276/// through which to perform a send to the given Objective-C method, 277/// using the given receiver type. The receiver type is not always 278/// the 'self' type of the method or even an Objective-C pointer type. 279/// This is *not* the right method for actually performing such a 280/// message send, due to the possibility of optional arguments. 281const CGFunctionInfo & 282CodeGenTypes::arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD, 283 QualType receiverType) { 284 SmallVector<CanQualType, 16> argTys; 285 argTys.push_back(Context.getCanonicalParamType(receiverType)); 286 argTys.push_back(Context.getCanonicalParamType(Context.getObjCSelType())); 287 // FIXME: Kill copy? 288 for (ObjCMethodDecl::param_const_iterator i = MD->param_begin(), 289 e = MD->param_end(); i != e; ++i) { 290 argTys.push_back(Context.getCanonicalParamType((*i)->getType())); 291 } 292 293 FunctionType::ExtInfo einfo; 294 einfo = einfo.withCallingConv(getCallingConventionForDecl(MD)); 295 296 if (getContext().getLangOpts().ObjCAutoRefCount && 297 MD->hasAttr<NSReturnsRetainedAttr>()) 298 einfo = einfo.withProducesResult(true); 299 300 RequiredArgs required = 301 (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All); 302 303 return arrangeLLVMFunctionInfo(GetReturnType(MD->getResultType()), argTys, 304 einfo, required); 305} 306 307const CGFunctionInfo & 308CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) { 309 // FIXME: Do we need to handle ObjCMethodDecl? 310 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 311 312 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) 313 return arrangeCXXConstructorDeclaration(CD, GD.getCtorType()); 314 315 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD)) 316 return arrangeCXXDestructor(DD, GD.getDtorType()); 317 318 return arrangeFunctionDeclaration(FD); 319} 320 321/// Arrange a call as unto a free function, except possibly with an 322/// additional number of formal parameters considered required. 323static const CGFunctionInfo & 324arrangeFreeFunctionLikeCall(CodeGenTypes &CGT, 325 CodeGenModule &CGM, 326 const CallArgList &args, 327 const FunctionType *fnType, 328 unsigned numExtraRequiredArgs) { 329 assert(args.size() >= numExtraRequiredArgs); 330 331 // In most cases, there are no optional arguments. 332 RequiredArgs required = RequiredArgs::All; 333 334 // If we have a variadic prototype, the required arguments are the 335 // extra prefix plus the arguments in the prototype. 336 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) { 337 if (proto->isVariadic()) 338 required = RequiredArgs(proto->getNumArgs() + numExtraRequiredArgs); 339 340 // If we don't have a prototype at all, but we're supposed to 341 // explicitly use the variadic convention for unprototyped calls, 342 // treat all of the arguments as required but preserve the nominal 343 // possibility of variadics. 344 } else if (CGM.getTargetCodeGenInfo() 345 .isNoProtoCallVariadic(args, 346 cast<FunctionNoProtoType>(fnType))) { 347 required = RequiredArgs(args.size()); 348 } 349 350 return CGT.arrangeFreeFunctionCall(fnType->getResultType(), args, 351 fnType->getExtInfo(), required); 352} 353 354/// Figure out the rules for calling a function with the given formal 355/// type using the given arguments. The arguments are necessary 356/// because the function might be unprototyped, in which case it's 357/// target-dependent in crazy ways. 358const CGFunctionInfo & 359CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args, 360 const FunctionType *fnType) { 361 return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 0); 362} 363 364/// A block function call is essentially a free-function call with an 365/// extra implicit argument. 366const CGFunctionInfo & 367CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args, 368 const FunctionType *fnType) { 369 return arrangeFreeFunctionLikeCall(*this, CGM, args, fnType, 1); 370} 371 372const CGFunctionInfo & 373CodeGenTypes::arrangeFreeFunctionCall(QualType resultType, 374 const CallArgList &args, 375 FunctionType::ExtInfo info, 376 RequiredArgs required) { 377 // FIXME: Kill copy. 378 SmallVector<CanQualType, 16> argTypes; 379 for (CallArgList::const_iterator i = args.begin(), e = args.end(); 380 i != e; ++i) 381 argTypes.push_back(Context.getCanonicalParamType(i->Ty)); 382 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info, 383 required); 384} 385 386/// Arrange a call to a C++ method, passing the given arguments. 387const CGFunctionInfo & 388CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args, 389 const FunctionProtoType *FPT, 390 RequiredArgs required) { 391 // FIXME: Kill copy. 392 SmallVector<CanQualType, 16> argTypes; 393 for (CallArgList::const_iterator i = args.begin(), e = args.end(); 394 i != e; ++i) 395 argTypes.push_back(Context.getCanonicalParamType(i->Ty)); 396 397 FunctionType::ExtInfo info = FPT->getExtInfo(); 398 return arrangeLLVMFunctionInfo(GetReturnType(FPT->getResultType()), 399 argTypes, info, required); 400} 401 402const CGFunctionInfo & 403CodeGenTypes::arrangeFunctionDeclaration(QualType resultType, 404 const FunctionArgList &args, 405 const FunctionType::ExtInfo &info, 406 bool isVariadic) { 407 // FIXME: Kill copy. 408 SmallVector<CanQualType, 16> argTypes; 409 for (FunctionArgList::const_iterator i = args.begin(), e = args.end(); 410 i != e; ++i) 411 argTypes.push_back(Context.getCanonicalParamType((*i)->getType())); 412 413 RequiredArgs required = 414 (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All); 415 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info, 416 required); 417} 418 419const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() { 420 return arrangeLLVMFunctionInfo(getContext().VoidTy, None, 421 FunctionType::ExtInfo(), RequiredArgs::All); 422} 423 424/// Arrange the argument and result information for an abstract value 425/// of a given function type. This is the method which all of the 426/// above functions ultimately defer to. 427const CGFunctionInfo & 428CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType, 429 ArrayRef<CanQualType> argTypes, 430 FunctionType::ExtInfo info, 431 RequiredArgs required) { 432#ifndef NDEBUG 433 for (ArrayRef<CanQualType>::const_iterator 434 I = argTypes.begin(), E = argTypes.end(); I != E; ++I) 435 assert(I->isCanonicalAsParam()); 436#endif 437 438 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC()); 439 440 // Lookup or create unique function info. 441 llvm::FoldingSetNodeID ID; 442 CGFunctionInfo::Profile(ID, info, required, resultType, argTypes); 443 444 void *insertPos = 0; 445 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos); 446 if (FI) 447 return *FI; 448 449 // Construct the function info. We co-allocate the ArgInfos. 450 FI = CGFunctionInfo::create(CC, info, resultType, argTypes, required); 451 FunctionInfos.InsertNode(FI, insertPos); 452 453 bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted; 454 assert(inserted && "Recursively being processed?"); 455 456 // Compute ABI information. 457 getABIInfo().computeInfo(*FI); 458 459 // Loop over all of the computed argument and return value info. If any of 460 // them are direct or extend without a specified coerce type, specify the 461 // default now. 462 ABIArgInfo &retInfo = FI->getReturnInfo(); 463 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == 0) 464 retInfo.setCoerceToType(ConvertType(FI->getReturnType())); 465 466 for (CGFunctionInfo::arg_iterator I = FI->arg_begin(), E = FI->arg_end(); 467 I != E; ++I) 468 if (I->info.canHaveCoerceToType() && I->info.getCoerceToType() == 0) 469 I->info.setCoerceToType(ConvertType(I->type)); 470 471 bool erased = FunctionsBeingProcessed.erase(FI); (void)erased; 472 assert(erased && "Not in set?"); 473 474 return *FI; 475} 476 477CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC, 478 const FunctionType::ExtInfo &info, 479 CanQualType resultType, 480 ArrayRef<CanQualType> argTypes, 481 RequiredArgs required) { 482 void *buffer = operator new(sizeof(CGFunctionInfo) + 483 sizeof(ArgInfo) * (argTypes.size() + 1)); 484 CGFunctionInfo *FI = new(buffer) CGFunctionInfo(); 485 FI->CallingConvention = llvmCC; 486 FI->EffectiveCallingConvention = llvmCC; 487 FI->ASTCallingConvention = info.getCC(); 488 FI->NoReturn = info.getNoReturn(); 489 FI->ReturnsRetained = info.getProducesResult(); 490 FI->Required = required; 491 FI->HasRegParm = info.getHasRegParm(); 492 FI->RegParm = info.getRegParm(); 493 FI->NumArgs = argTypes.size(); 494 FI->getArgsBuffer()[0].type = resultType; 495 for (unsigned i = 0, e = argTypes.size(); i != e; ++i) 496 FI->getArgsBuffer()[i + 1].type = argTypes[i]; 497 return FI; 498} 499 500/***/ 501 502void CodeGenTypes::GetExpandedTypes(QualType type, 503 SmallVectorImpl<llvm::Type*> &expandedTypes) { 504 if (const ConstantArrayType *AT = Context.getAsConstantArrayType(type)) { 505 uint64_t NumElts = AT->getSize().getZExtValue(); 506 for (uint64_t Elt = 0; Elt < NumElts; ++Elt) 507 GetExpandedTypes(AT->getElementType(), expandedTypes); 508 } else if (const RecordType *RT = type->getAs<RecordType>()) { 509 const RecordDecl *RD = RT->getDecl(); 510 assert(!RD->hasFlexibleArrayMember() && 511 "Cannot expand structure with flexible array."); 512 if (RD->isUnion()) { 513 // Unions can be here only in degenerative cases - all the fields are same 514 // after flattening. Thus we have to use the "largest" field. 515 const FieldDecl *LargestFD = 0; 516 CharUnits UnionSize = CharUnits::Zero(); 517 518 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 519 i != e; ++i) { 520 const FieldDecl *FD = *i; 521 assert(!FD->isBitField() && 522 "Cannot expand structure with bit-field members."); 523 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); 524 if (UnionSize < FieldSize) { 525 UnionSize = FieldSize; 526 LargestFD = FD; 527 } 528 } 529 if (LargestFD) 530 GetExpandedTypes(LargestFD->getType(), expandedTypes); 531 } else { 532 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 533 i != e; ++i) { 534 assert(!i->isBitField() && 535 "Cannot expand structure with bit-field members."); 536 GetExpandedTypes(i->getType(), expandedTypes); 537 } 538 } 539 } else if (const ComplexType *CT = type->getAs<ComplexType>()) { 540 llvm::Type *EltTy = ConvertType(CT->getElementType()); 541 expandedTypes.push_back(EltTy); 542 expandedTypes.push_back(EltTy); 543 } else 544 expandedTypes.push_back(ConvertType(type)); 545} 546 547llvm::Function::arg_iterator 548CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV, 549 llvm::Function::arg_iterator AI) { 550 assert(LV.isSimple() && 551 "Unexpected non-simple lvalue during struct expansion."); 552 553 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { 554 unsigned NumElts = AT->getSize().getZExtValue(); 555 QualType EltTy = AT->getElementType(); 556 for (unsigned Elt = 0; Elt < NumElts; ++Elt) { 557 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(LV.getAddress(), 0, Elt); 558 LValue LV = MakeAddrLValue(EltAddr, EltTy); 559 AI = ExpandTypeFromArgs(EltTy, LV, AI); 560 } 561 } else if (const RecordType *RT = Ty->getAs<RecordType>()) { 562 RecordDecl *RD = RT->getDecl(); 563 if (RD->isUnion()) { 564 // Unions can be here only in degenerative cases - all the fields are same 565 // after flattening. Thus we have to use the "largest" field. 566 const FieldDecl *LargestFD = 0; 567 CharUnits UnionSize = CharUnits::Zero(); 568 569 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 570 i != e; ++i) { 571 const FieldDecl *FD = *i; 572 assert(!FD->isBitField() && 573 "Cannot expand structure with bit-field members."); 574 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); 575 if (UnionSize < FieldSize) { 576 UnionSize = FieldSize; 577 LargestFD = FD; 578 } 579 } 580 if (LargestFD) { 581 // FIXME: What are the right qualifiers here? 582 LValue SubLV = EmitLValueForField(LV, LargestFD); 583 AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI); 584 } 585 } else { 586 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 587 i != e; ++i) { 588 FieldDecl *FD = *i; 589 QualType FT = FD->getType(); 590 591 // FIXME: What are the right qualifiers here? 592 LValue SubLV = EmitLValueForField(LV, FD); 593 AI = ExpandTypeFromArgs(FT, SubLV, AI); 594 } 595 } 596 } else if (const ComplexType *CT = Ty->getAs<ComplexType>()) { 597 QualType EltTy = CT->getElementType(); 598 llvm::Value *RealAddr = Builder.CreateStructGEP(LV.getAddress(), 0, "real"); 599 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(RealAddr, EltTy)); 600 llvm::Value *ImagAddr = Builder.CreateStructGEP(LV.getAddress(), 1, "imag"); 601 EmitStoreThroughLValue(RValue::get(AI++), MakeAddrLValue(ImagAddr, EltTy)); 602 } else { 603 EmitStoreThroughLValue(RValue::get(AI), LV); 604 ++AI; 605 } 606 607 return AI; 608} 609 610/// EnterStructPointerForCoercedAccess - Given a struct pointer that we are 611/// accessing some number of bytes out of it, try to gep into the struct to get 612/// at its inner goodness. Dive as deep as possible without entering an element 613/// with an in-memory size smaller than DstSize. 614static llvm::Value * 615EnterStructPointerForCoercedAccess(llvm::Value *SrcPtr, 616 llvm::StructType *SrcSTy, 617 uint64_t DstSize, CodeGenFunction &CGF) { 618 // We can't dive into a zero-element struct. 619 if (SrcSTy->getNumElements() == 0) return SrcPtr; 620 621 llvm::Type *FirstElt = SrcSTy->getElementType(0); 622 623 // If the first elt is at least as large as what we're looking for, or if the 624 // first element is the same size as the whole struct, we can enter it. 625 uint64_t FirstEltSize = 626 CGF.CGM.getDataLayout().getTypeAllocSize(FirstElt); 627 if (FirstEltSize < DstSize && 628 FirstEltSize < CGF.CGM.getDataLayout().getTypeAllocSize(SrcSTy)) 629 return SrcPtr; 630 631 // GEP into the first element. 632 SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive"); 633 634 // If the first element is a struct, recurse. 635 llvm::Type *SrcTy = 636 cast<llvm::PointerType>(SrcPtr->getType())->getElementType(); 637 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) 638 return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF); 639 640 return SrcPtr; 641} 642 643/// CoerceIntOrPtrToIntOrPtr - Convert a value Val to the specific Ty where both 644/// are either integers or pointers. This does a truncation of the value if it 645/// is too large or a zero extension if it is too small. 646/// 647/// This behaves as if the value were coerced through memory, so on big-endian 648/// targets the high bits are preserved in a truncation, while little-endian 649/// targets preserve the low bits. 650static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val, 651 llvm::Type *Ty, 652 CodeGenFunction &CGF) { 653 if (Val->getType() == Ty) 654 return Val; 655 656 if (isa<llvm::PointerType>(Val->getType())) { 657 // If this is Pointer->Pointer avoid conversion to and from int. 658 if (isa<llvm::PointerType>(Ty)) 659 return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val"); 660 661 // Convert the pointer to an integer so we can play with its width. 662 Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi"); 663 } 664 665 llvm::Type *DestIntTy = Ty; 666 if (isa<llvm::PointerType>(DestIntTy)) 667 DestIntTy = CGF.IntPtrTy; 668 669 if (Val->getType() != DestIntTy) { 670 const llvm::DataLayout &DL = CGF.CGM.getDataLayout(); 671 if (DL.isBigEndian()) { 672 // Preserve the high bits on big-endian targets. 673 // That is what memory coercion does. 674 uint64_t SrcSize = DL.getTypeAllocSizeInBits(Val->getType()); 675 uint64_t DstSize = DL.getTypeAllocSizeInBits(DestIntTy); 676 if (SrcSize > DstSize) { 677 Val = CGF.Builder.CreateLShr(Val, SrcSize - DstSize, "coerce.highbits"); 678 Val = CGF.Builder.CreateTrunc(Val, DestIntTy, "coerce.val.ii"); 679 } else { 680 Val = CGF.Builder.CreateZExt(Val, DestIntTy, "coerce.val.ii"); 681 Val = CGF.Builder.CreateShl(Val, DstSize - SrcSize, "coerce.highbits"); 682 } 683 } else { 684 // Little-endian targets preserve the low bits. No shifts required. 685 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii"); 686 } 687 } 688 689 if (isa<llvm::PointerType>(Ty)) 690 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip"); 691 return Val; 692} 693 694 695 696/// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as 697/// a pointer to an object of type \arg Ty. 698/// 699/// This safely handles the case when the src type is smaller than the 700/// destination type; in this situation the values of bits which not 701/// present in the src are undefined. 702static llvm::Value *CreateCoercedLoad(llvm::Value *SrcPtr, 703 llvm::Type *Ty, 704 CodeGenFunction &CGF) { 705 llvm::Type *SrcTy = 706 cast<llvm::PointerType>(SrcPtr->getType())->getElementType(); 707 708 // If SrcTy and Ty are the same, just do a load. 709 if (SrcTy == Ty) 710 return CGF.Builder.CreateLoad(SrcPtr); 711 712 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty); 713 714 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) { 715 SrcPtr = EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF); 716 SrcTy = cast<llvm::PointerType>(SrcPtr->getType())->getElementType(); 717 } 718 719 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy); 720 721 // If the source and destination are integer or pointer types, just do an 722 // extension or truncation to the desired type. 723 if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) && 724 (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) { 725 llvm::LoadInst *Load = CGF.Builder.CreateLoad(SrcPtr); 726 return CoerceIntOrPtrToIntOrPtr(Load, Ty, CGF); 727 } 728 729 // If load is legal, just bitcast the src pointer. 730 if (SrcSize >= DstSize) { 731 // Generally SrcSize is never greater than DstSize, since this means we are 732 // losing bits. However, this can happen in cases where the structure has 733 // additional padding, for example due to a user specified alignment. 734 // 735 // FIXME: Assert that we aren't truncating non-padding bits when have access 736 // to that information. 737 llvm::Value *Casted = 738 CGF.Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty)); 739 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Casted); 740 // FIXME: Use better alignment / avoid requiring aligned load. 741 Load->setAlignment(1); 742 return Load; 743 } 744 745 // Otherwise do coercion through memory. This is stupid, but 746 // simple. 747 llvm::Value *Tmp = CGF.CreateTempAlloca(Ty); 748 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); 749 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); 750 llvm::Value *SrcCasted = CGF.Builder.CreateBitCast(SrcPtr, I8PtrTy); 751 // FIXME: Use better alignment. 752 CGF.Builder.CreateMemCpy(Casted, SrcCasted, 753 llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize), 754 1, false); 755 return CGF.Builder.CreateLoad(Tmp); 756} 757 758// Function to store a first-class aggregate into memory. We prefer to 759// store the elements rather than the aggregate to be more friendly to 760// fast-isel. 761// FIXME: Do we need to recurse here? 762static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val, 763 llvm::Value *DestPtr, bool DestIsVolatile, 764 bool LowAlignment) { 765 // Prefer scalar stores to first-class aggregate stores. 766 if (llvm::StructType *STy = 767 dyn_cast<llvm::StructType>(Val->getType())) { 768 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { 769 llvm::Value *EltPtr = CGF.Builder.CreateConstGEP2_32(DestPtr, 0, i); 770 llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i); 771 llvm::StoreInst *SI = CGF.Builder.CreateStore(Elt, EltPtr, 772 DestIsVolatile); 773 if (LowAlignment) 774 SI->setAlignment(1); 775 } 776 } else { 777 llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile); 778 if (LowAlignment) 779 SI->setAlignment(1); 780 } 781} 782 783/// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src, 784/// where the source and destination may have different types. 785/// 786/// This safely handles the case when the src type is larger than the 787/// destination type; the upper bits of the src will be lost. 788static void CreateCoercedStore(llvm::Value *Src, 789 llvm::Value *DstPtr, 790 bool DstIsVolatile, 791 CodeGenFunction &CGF) { 792 llvm::Type *SrcTy = Src->getType(); 793 llvm::Type *DstTy = 794 cast<llvm::PointerType>(DstPtr->getType())->getElementType(); 795 if (SrcTy == DstTy) { 796 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); 797 return; 798 } 799 800 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy); 801 802 if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) { 803 DstPtr = EnterStructPointerForCoercedAccess(DstPtr, DstSTy, SrcSize, CGF); 804 DstTy = cast<llvm::PointerType>(DstPtr->getType())->getElementType(); 805 } 806 807 // If the source and destination are integer or pointer types, just do an 808 // extension or truncation to the desired type. 809 if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) && 810 (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) { 811 Src = CoerceIntOrPtrToIntOrPtr(Src, DstTy, CGF); 812 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile); 813 return; 814 } 815 816 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy); 817 818 // If store is legal, just bitcast the src pointer. 819 if (SrcSize <= DstSize) { 820 llvm::Value *Casted = 821 CGF.Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy)); 822 // FIXME: Use better alignment / avoid requiring aligned store. 823 BuildAggStore(CGF, Src, Casted, DstIsVolatile, true); 824 } else { 825 // Otherwise do coercion through memory. This is stupid, but 826 // simple. 827 828 // Generally SrcSize is never greater than DstSize, since this means we are 829 // losing bits. However, this can happen in cases where the structure has 830 // additional padding, for example due to a user specified alignment. 831 // 832 // FIXME: Assert that we aren't truncating non-padding bits when have access 833 // to that information. 834 llvm::Value *Tmp = CGF.CreateTempAlloca(SrcTy); 835 CGF.Builder.CreateStore(Src, Tmp); 836 llvm::Type *I8PtrTy = CGF.Builder.getInt8PtrTy(); 837 llvm::Value *Casted = CGF.Builder.CreateBitCast(Tmp, I8PtrTy); 838 llvm::Value *DstCasted = CGF.Builder.CreateBitCast(DstPtr, I8PtrTy); 839 // FIXME: Use better alignment. 840 CGF.Builder.CreateMemCpy(DstCasted, Casted, 841 llvm::ConstantInt::get(CGF.IntPtrTy, DstSize), 842 1, false); 843 } 844} 845 846/***/ 847 848bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) { 849 return FI.getReturnInfo().isIndirect(); 850} 851 852bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) { 853 if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) { 854 switch (BT->getKind()) { 855 default: 856 return false; 857 case BuiltinType::Float: 858 return getTarget().useObjCFPRetForRealType(TargetInfo::Float); 859 case BuiltinType::Double: 860 return getTarget().useObjCFPRetForRealType(TargetInfo::Double); 861 case BuiltinType::LongDouble: 862 return getTarget().useObjCFPRetForRealType(TargetInfo::LongDouble); 863 } 864 } 865 866 return false; 867} 868 869bool CodeGenModule::ReturnTypeUsesFP2Ret(QualType ResultType) { 870 if (const ComplexType *CT = ResultType->getAs<ComplexType>()) { 871 if (const BuiltinType *BT = CT->getElementType()->getAs<BuiltinType>()) { 872 if (BT->getKind() == BuiltinType::LongDouble) 873 return getTarget().useObjCFP2RetForComplexLongDouble(); 874 } 875 } 876 877 return false; 878} 879 880llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) { 881 const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD); 882 return GetFunctionType(FI); 883} 884 885llvm::FunctionType * 886CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) { 887 888 bool Inserted = FunctionsBeingProcessed.insert(&FI); (void)Inserted; 889 assert(Inserted && "Recursively being processed?"); 890 891 SmallVector<llvm::Type*, 8> argTypes; 892 llvm::Type *resultType = 0; 893 894 const ABIArgInfo &retAI = FI.getReturnInfo(); 895 switch (retAI.getKind()) { 896 case ABIArgInfo::Expand: 897 llvm_unreachable("Invalid ABI kind for return argument"); 898 899 case ABIArgInfo::Extend: 900 case ABIArgInfo::Direct: 901 resultType = retAI.getCoerceToType(); 902 break; 903 904 case ABIArgInfo::Indirect: { 905 assert(!retAI.getIndirectAlign() && "Align unused on indirect return."); 906 resultType = llvm::Type::getVoidTy(getLLVMContext()); 907 908 QualType ret = FI.getReturnType(); 909 llvm::Type *ty = ConvertType(ret); 910 unsigned addressSpace = Context.getTargetAddressSpace(ret); 911 argTypes.push_back(llvm::PointerType::get(ty, addressSpace)); 912 break; 913 } 914 915 case ABIArgInfo::Ignore: 916 resultType = llvm::Type::getVoidTy(getLLVMContext()); 917 break; 918 } 919 920 // Add in all of the required arguments. 921 CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), ie; 922 if (FI.isVariadic()) { 923 ie = it + FI.getRequiredArgs().getNumRequiredArgs(); 924 } else { 925 ie = FI.arg_end(); 926 } 927 for (; it != ie; ++it) { 928 const ABIArgInfo &argAI = it->info; 929 930 // Insert a padding type to ensure proper alignment. 931 if (llvm::Type *PaddingType = argAI.getPaddingType()) 932 argTypes.push_back(PaddingType); 933 934 switch (argAI.getKind()) { 935 case ABIArgInfo::Ignore: 936 break; 937 938 case ABIArgInfo::Indirect: { 939 // indirect arguments are always on the stack, which is addr space #0. 940 llvm::Type *LTy = ConvertTypeForMem(it->type); 941 argTypes.push_back(LTy->getPointerTo()); 942 break; 943 } 944 945 case ABIArgInfo::Extend: 946 case ABIArgInfo::Direct: { 947 // If the coerce-to type is a first class aggregate, flatten it. Either 948 // way is semantically identical, but fast-isel and the optimizer 949 // generally likes scalar values better than FCAs. 950 llvm::Type *argType = argAI.getCoerceToType(); 951 if (llvm::StructType *st = dyn_cast<llvm::StructType>(argType)) { 952 for (unsigned i = 0, e = st->getNumElements(); i != e; ++i) 953 argTypes.push_back(st->getElementType(i)); 954 } else { 955 argTypes.push_back(argType); 956 } 957 break; 958 } 959 960 case ABIArgInfo::Expand: 961 GetExpandedTypes(it->type, argTypes); 962 break; 963 } 964 } 965 966 bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased; 967 assert(Erased && "Not in set?"); 968 969 return llvm::FunctionType::get(resultType, argTypes, FI.isVariadic()); 970} 971 972llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) { 973 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 974 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>(); 975 976 if (!isFuncTypeConvertible(FPT)) 977 return llvm::StructType::get(getLLVMContext()); 978 979 const CGFunctionInfo *Info; 980 if (isa<CXXDestructorDecl>(MD)) 981 Info = &arrangeCXXDestructor(cast<CXXDestructorDecl>(MD), GD.getDtorType()); 982 else 983 Info = &arrangeCXXMethodDeclaration(MD); 984 return GetFunctionType(*Info); 985} 986 987void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI, 988 const Decl *TargetDecl, 989 AttributeListType &PAL, 990 unsigned &CallingConv, 991 bool AttrOnCallSite) { 992 llvm::AttrBuilder FuncAttrs; 993 llvm::AttrBuilder RetAttrs; 994 995 CallingConv = FI.getEffectiveCallingConvention(); 996 997 if (FI.isNoReturn()) 998 FuncAttrs.addAttribute(llvm::Attribute::NoReturn); 999 1000 // FIXME: handle sseregparm someday... 1001 if (TargetDecl) { 1002 if (TargetDecl->hasAttr<ReturnsTwiceAttr>()) 1003 FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice); 1004 if (TargetDecl->hasAttr<NoThrowAttr>()) 1005 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); 1006 if (TargetDecl->hasAttr<NoReturnAttr>()) 1007 FuncAttrs.addAttribute(llvm::Attribute::NoReturn); 1008 1009 if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) { 1010 const FunctionProtoType *FPT = Fn->getType()->getAs<FunctionProtoType>(); 1011 if (FPT && FPT->isNothrow(getContext())) 1012 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); 1013 // Don't use [[noreturn]] or _Noreturn for a call to a virtual function. 1014 // These attributes are not inherited by overloads. 1015 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn); 1016 if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual())) 1017 FuncAttrs.addAttribute(llvm::Attribute::NoReturn); 1018 } 1019 1020 // 'const' and 'pure' attribute functions are also nounwind. 1021 if (TargetDecl->hasAttr<ConstAttr>()) { 1022 FuncAttrs.addAttribute(llvm::Attribute::ReadNone); 1023 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); 1024 } else if (TargetDecl->hasAttr<PureAttr>()) { 1025 FuncAttrs.addAttribute(llvm::Attribute::ReadOnly); 1026 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind); 1027 } 1028 if (TargetDecl->hasAttr<MallocAttr>()) 1029 RetAttrs.addAttribute(llvm::Attribute::NoAlias); 1030 } 1031 1032 if (CodeGenOpts.OptimizeSize) 1033 FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize); 1034 if (CodeGenOpts.OptimizeSize == 2) 1035 FuncAttrs.addAttribute(llvm::Attribute::MinSize); 1036 if (CodeGenOpts.DisableRedZone) 1037 FuncAttrs.addAttribute(llvm::Attribute::NoRedZone); 1038 if (CodeGenOpts.NoImplicitFloat) 1039 FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat); 1040 1041 if (AttrOnCallSite) { 1042 // Attributes that should go on the call site only. 1043 if (!CodeGenOpts.SimplifyLibCalls) 1044 FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin); 1045 } else { 1046 // Attributes that should go on the function, but not the call site. 1047 if (!CodeGenOpts.DisableFPElim) { 1048 FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); 1049 } else if (CodeGenOpts.OmitLeafFramePointer) { 1050 FuncAttrs.addAttribute("no-frame-pointer-elim", "false"); 1051 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); 1052 } else { 1053 FuncAttrs.addAttribute("no-frame-pointer-elim", "true"); 1054 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf"); 1055 } 1056 1057 FuncAttrs.addAttribute("less-precise-fpmad", 1058 llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD)); 1059 FuncAttrs.addAttribute("no-infs-fp-math", 1060 llvm::toStringRef(CodeGenOpts.NoInfsFPMath)); 1061 FuncAttrs.addAttribute("no-nans-fp-math", 1062 llvm::toStringRef(CodeGenOpts.NoNaNsFPMath)); 1063 FuncAttrs.addAttribute("unsafe-fp-math", 1064 llvm::toStringRef(CodeGenOpts.UnsafeFPMath)); 1065 FuncAttrs.addAttribute("use-soft-float", 1066 llvm::toStringRef(CodeGenOpts.SoftFloat)); 1067 FuncAttrs.addAttribute("stack-protector-buffer-size", 1068 llvm::utostr(CodeGenOpts.SSPBufferSize)); 1069 1070 if (!CodeGenOpts.StackRealignment) 1071 FuncAttrs.addAttribute("no-realign-stack"); 1072 } 1073 1074 QualType RetTy = FI.getReturnType(); 1075 unsigned Index = 1; 1076 const ABIArgInfo &RetAI = FI.getReturnInfo(); 1077 switch (RetAI.getKind()) { 1078 case ABIArgInfo::Extend: 1079 if (RetTy->hasSignedIntegerRepresentation()) 1080 RetAttrs.addAttribute(llvm::Attribute::SExt); 1081 else if (RetTy->hasUnsignedIntegerRepresentation()) 1082 RetAttrs.addAttribute(llvm::Attribute::ZExt); 1083 // FALL THROUGH 1084 case ABIArgInfo::Direct: 1085 if (RetAI.getInReg()) 1086 RetAttrs.addAttribute(llvm::Attribute::InReg); 1087 break; 1088 case ABIArgInfo::Ignore: 1089 break; 1090 1091 case ABIArgInfo::Indirect: { 1092 llvm::AttrBuilder SRETAttrs; 1093 SRETAttrs.addAttribute(llvm::Attribute::StructRet); 1094 if (RetAI.getInReg()) 1095 SRETAttrs.addAttribute(llvm::Attribute::InReg); 1096 PAL.push_back(llvm:: 1097 AttributeSet::get(getLLVMContext(), Index, SRETAttrs)); 1098 1099 ++Index; 1100 // sret disables readnone and readonly 1101 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) 1102 .removeAttribute(llvm::Attribute::ReadNone); 1103 break; 1104 } 1105 1106 case ABIArgInfo::Expand: 1107 llvm_unreachable("Invalid ABI kind for return argument"); 1108 } 1109 1110 if (RetAttrs.hasAttributes()) 1111 PAL.push_back(llvm:: 1112 AttributeSet::get(getLLVMContext(), 1113 llvm::AttributeSet::ReturnIndex, 1114 RetAttrs)); 1115 1116 for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(), 1117 ie = FI.arg_end(); it != ie; ++it) { 1118 QualType ParamType = it->type; 1119 const ABIArgInfo &AI = it->info; 1120 llvm::AttrBuilder Attrs; 1121 1122 if (AI.getPaddingType()) { 1123 if (AI.getPaddingInReg()) 1124 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, 1125 llvm::Attribute::InReg)); 1126 // Increment Index if there is padding. 1127 ++Index; 1128 } 1129 1130 // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we 1131 // have the corresponding parameter variable. It doesn't make 1132 // sense to do it here because parameters are so messed up. 1133 switch (AI.getKind()) { 1134 case ABIArgInfo::Extend: 1135 if (ParamType->isSignedIntegerOrEnumerationType()) 1136 Attrs.addAttribute(llvm::Attribute::SExt); 1137 else if (ParamType->isUnsignedIntegerOrEnumerationType()) 1138 Attrs.addAttribute(llvm::Attribute::ZExt); 1139 // FALL THROUGH 1140 case ABIArgInfo::Direct: 1141 if (AI.getInReg()) 1142 Attrs.addAttribute(llvm::Attribute::InReg); 1143 1144 // FIXME: handle sseregparm someday... 1145 1146 if (llvm::StructType *STy = 1147 dyn_cast<llvm::StructType>(AI.getCoerceToType())) { 1148 unsigned Extra = STy->getNumElements()-1; // 1 will be added below. 1149 if (Attrs.hasAttributes()) 1150 for (unsigned I = 0; I < Extra; ++I) 1151 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index + I, 1152 Attrs)); 1153 Index += Extra; 1154 } 1155 break; 1156 1157 case ABIArgInfo::Indirect: 1158 if (AI.getInReg()) 1159 Attrs.addAttribute(llvm::Attribute::InReg); 1160 1161 if (AI.getIndirectByVal()) 1162 Attrs.addAttribute(llvm::Attribute::ByVal); 1163 1164 Attrs.addAlignmentAttr(AI.getIndirectAlign()); 1165 1166 // byval disables readnone and readonly. 1167 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly) 1168 .removeAttribute(llvm::Attribute::ReadNone); 1169 break; 1170 1171 case ABIArgInfo::Ignore: 1172 // Skip increment, no matching LLVM parameter. 1173 continue; 1174 1175 case ABIArgInfo::Expand: { 1176 SmallVector<llvm::Type*, 8> types; 1177 // FIXME: This is rather inefficient. Do we ever actually need to do 1178 // anything here? The result should be just reconstructed on the other 1179 // side, so extension should be a non-issue. 1180 getTypes().GetExpandedTypes(ParamType, types); 1181 Index += types.size(); 1182 continue; 1183 } 1184 } 1185 1186 if (Attrs.hasAttributes()) 1187 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs)); 1188 ++Index; 1189 } 1190 if (FuncAttrs.hasAttributes()) 1191 PAL.push_back(llvm:: 1192 AttributeSet::get(getLLVMContext(), 1193 llvm::AttributeSet::FunctionIndex, 1194 FuncAttrs)); 1195} 1196 1197/// An argument came in as a promoted argument; demote it back to its 1198/// declared type. 1199static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF, 1200 const VarDecl *var, 1201 llvm::Value *value) { 1202 llvm::Type *varType = CGF.ConvertType(var->getType()); 1203 1204 // This can happen with promotions that actually don't change the 1205 // underlying type, like the enum promotions. 1206 if (value->getType() == varType) return value; 1207 1208 assert((varType->isIntegerTy() || varType->isFloatingPointTy()) 1209 && "unexpected promotion type"); 1210 1211 if (isa<llvm::IntegerType>(varType)) 1212 return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote"); 1213 1214 return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote"); 1215} 1216 1217void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI, 1218 llvm::Function *Fn, 1219 const FunctionArgList &Args) { 1220 // If this is an implicit-return-zero function, go ahead and 1221 // initialize the return value. TODO: it might be nice to have 1222 // a more general mechanism for this that didn't require synthesized 1223 // return statements. 1224 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) { 1225 if (FD->hasImplicitReturnZero()) { 1226 QualType RetTy = FD->getResultType().getUnqualifiedType(); 1227 llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy); 1228 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy); 1229 Builder.CreateStore(Zero, ReturnValue); 1230 } 1231 } 1232 1233 // FIXME: We no longer need the types from FunctionArgList; lift up and 1234 // simplify. 1235 1236 // Emit allocs for param decls. Give the LLVM Argument nodes names. 1237 llvm::Function::arg_iterator AI = Fn->arg_begin(); 1238 1239 // Name the struct return argument. 1240 if (CGM.ReturnTypeUsesSRet(FI)) { 1241 AI->setName("agg.result"); 1242 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), 1243 AI->getArgNo() + 1, 1244 llvm::Attribute::NoAlias)); 1245 ++AI; 1246 } 1247 1248 assert(FI.arg_size() == Args.size() && 1249 "Mismatch between function signature & arguments."); 1250 unsigned ArgNo = 1; 1251 CGFunctionInfo::const_arg_iterator info_it = FI.arg_begin(); 1252 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 1253 i != e; ++i, ++info_it, ++ArgNo) { 1254 const VarDecl *Arg = *i; 1255 QualType Ty = info_it->type; 1256 const ABIArgInfo &ArgI = info_it->info; 1257 1258 bool isPromoted = 1259 isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted(); 1260 1261 // Skip the dummy padding argument. 1262 if (ArgI.getPaddingType()) 1263 ++AI; 1264 1265 switch (ArgI.getKind()) { 1266 case ABIArgInfo::Indirect: { 1267 llvm::Value *V = AI; 1268 1269 if (!hasScalarEvaluationKind(Ty)) { 1270 // Aggregates and complex variables are accessed by reference. All we 1271 // need to do is realign the value, if requested 1272 if (ArgI.getIndirectRealign()) { 1273 llvm::Value *AlignedTemp = CreateMemTemp(Ty, "coerce"); 1274 1275 // Copy from the incoming argument pointer to the temporary with the 1276 // appropriate alignment. 1277 // 1278 // FIXME: We should have a common utility for generating an aggregate 1279 // copy. 1280 llvm::Type *I8PtrTy = Builder.getInt8PtrTy(); 1281 CharUnits Size = getContext().getTypeSizeInChars(Ty); 1282 llvm::Value *Dst = Builder.CreateBitCast(AlignedTemp, I8PtrTy); 1283 llvm::Value *Src = Builder.CreateBitCast(V, I8PtrTy); 1284 Builder.CreateMemCpy(Dst, 1285 Src, 1286 llvm::ConstantInt::get(IntPtrTy, 1287 Size.getQuantity()), 1288 ArgI.getIndirectAlign(), 1289 false); 1290 V = AlignedTemp; 1291 } 1292 } else { 1293 // Load scalar value from indirect argument. 1294 CharUnits Alignment = getContext().getTypeAlignInChars(Ty); 1295 V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty, 1296 Arg->getLocStart()); 1297 1298 if (isPromoted) 1299 V = emitArgumentDemotion(*this, Arg, V); 1300 } 1301 EmitParmDecl(*Arg, V, ArgNo); 1302 break; 1303 } 1304 1305 case ABIArgInfo::Extend: 1306 case ABIArgInfo::Direct: { 1307 1308 // If we have the trivial case, handle it with no muss and fuss. 1309 if (!isa<llvm::StructType>(ArgI.getCoerceToType()) && 1310 ArgI.getCoerceToType() == ConvertType(Ty) && 1311 ArgI.getDirectOffset() == 0) { 1312 assert(AI != Fn->arg_end() && "Argument mismatch!"); 1313 llvm::Value *V = AI; 1314 1315 if (Arg->getType().isRestrictQualified()) 1316 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(), 1317 AI->getArgNo() + 1, 1318 llvm::Attribute::NoAlias)); 1319 1320 // Ensure the argument is the correct type. 1321 if (V->getType() != ArgI.getCoerceToType()) 1322 V = Builder.CreateBitCast(V, ArgI.getCoerceToType()); 1323 1324 if (isPromoted) 1325 V = emitArgumentDemotion(*this, Arg, V); 1326 1327 if (const CXXMethodDecl *MD = 1328 dyn_cast_or_null<CXXMethodDecl>(CurCodeDecl)) { 1329 if (MD->isVirtual() && Arg == CXXABIThisDecl) 1330 V = CGM.getCXXABI(). 1331 adjustThisParameterInVirtualFunctionPrologue(*this, CurGD, V); 1332 } 1333 1334 // Because of merging of function types from multiple decls it is 1335 // possible for the type of an argument to not match the corresponding 1336 // type in the function type. Since we are codegening the callee 1337 // in here, add a cast to the argument type. 1338 llvm::Type *LTy = ConvertType(Arg->getType()); 1339 if (V->getType() != LTy) 1340 V = Builder.CreateBitCast(V, LTy); 1341 1342 EmitParmDecl(*Arg, V, ArgNo); 1343 break; 1344 } 1345 1346 llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName()); 1347 1348 // The alignment we need to use is the max of the requested alignment for 1349 // the argument plus the alignment required by our access code below. 1350 unsigned AlignmentToUse = 1351 CGM.getDataLayout().getABITypeAlignment(ArgI.getCoerceToType()); 1352 AlignmentToUse = std::max(AlignmentToUse, 1353 (unsigned)getContext().getDeclAlign(Arg).getQuantity()); 1354 1355 Alloca->setAlignment(AlignmentToUse); 1356 llvm::Value *V = Alloca; 1357 llvm::Value *Ptr = V; // Pointer to store into. 1358 1359 // If the value is offset in memory, apply the offset now. 1360 if (unsigned Offs = ArgI.getDirectOffset()) { 1361 Ptr = Builder.CreateBitCast(Ptr, Builder.getInt8PtrTy()); 1362 Ptr = Builder.CreateConstGEP1_32(Ptr, Offs); 1363 Ptr = Builder.CreateBitCast(Ptr, 1364 llvm::PointerType::getUnqual(ArgI.getCoerceToType())); 1365 } 1366 1367 // If the coerce-to type is a first class aggregate, we flatten it and 1368 // pass the elements. Either way is semantically identical, but fast-isel 1369 // and the optimizer generally likes scalar values better than FCAs. 1370 llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType()); 1371 if (STy && STy->getNumElements() > 1) { 1372 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy); 1373 llvm::Type *DstTy = 1374 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 1375 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy); 1376 1377 if (SrcSize <= DstSize) { 1378 Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy)); 1379 1380 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { 1381 assert(AI != Fn->arg_end() && "Argument mismatch!"); 1382 AI->setName(Arg->getName() + ".coerce" + Twine(i)); 1383 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(Ptr, 0, i); 1384 Builder.CreateStore(AI++, EltPtr); 1385 } 1386 } else { 1387 llvm::AllocaInst *TempAlloca = 1388 CreateTempAlloca(ArgI.getCoerceToType(), "coerce"); 1389 TempAlloca->setAlignment(AlignmentToUse); 1390 llvm::Value *TempV = TempAlloca; 1391 1392 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { 1393 assert(AI != Fn->arg_end() && "Argument mismatch!"); 1394 AI->setName(Arg->getName() + ".coerce" + Twine(i)); 1395 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(TempV, 0, i); 1396 Builder.CreateStore(AI++, EltPtr); 1397 } 1398 1399 Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse); 1400 } 1401 } else { 1402 // Simple case, just do a coerced store of the argument into the alloca. 1403 assert(AI != Fn->arg_end() && "Argument mismatch!"); 1404 AI->setName(Arg->getName() + ".coerce"); 1405 CreateCoercedStore(AI++, Ptr, /*DestIsVolatile=*/false, *this); 1406 } 1407 1408 1409 // Match to what EmitParmDecl is expecting for this type. 1410 if (CodeGenFunction::hasScalarEvaluationKind(Ty)) { 1411 V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty, Arg->getLocStart()); 1412 if (isPromoted) 1413 V = emitArgumentDemotion(*this, Arg, V); 1414 } 1415 EmitParmDecl(*Arg, V, ArgNo); 1416 continue; // Skip ++AI increment, already done. 1417 } 1418 1419 case ABIArgInfo::Expand: { 1420 // If this structure was expanded into multiple arguments then 1421 // we need to create a temporary and reconstruct it from the 1422 // arguments. 1423 llvm::AllocaInst *Alloca = CreateMemTemp(Ty); 1424 CharUnits Align = getContext().getDeclAlign(Arg); 1425 Alloca->setAlignment(Align.getQuantity()); 1426 LValue LV = MakeAddrLValue(Alloca, Ty, Align); 1427 llvm::Function::arg_iterator End = ExpandTypeFromArgs(Ty, LV, AI); 1428 EmitParmDecl(*Arg, Alloca, ArgNo); 1429 1430 // Name the arguments used in expansion and increment AI. 1431 unsigned Index = 0; 1432 for (; AI != End; ++AI, ++Index) 1433 AI->setName(Arg->getName() + "." + Twine(Index)); 1434 continue; 1435 } 1436 1437 case ABIArgInfo::Ignore: 1438 // Initialize the local variable appropriately. 1439 if (!hasScalarEvaluationKind(Ty)) 1440 EmitParmDecl(*Arg, CreateMemTemp(Ty), ArgNo); 1441 else 1442 EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType())), 1443 ArgNo); 1444 1445 // Skip increment, no matching LLVM parameter. 1446 continue; 1447 } 1448 1449 ++AI; 1450 } 1451 assert(AI == Fn->arg_end() && "Argument mismatch!"); 1452} 1453 1454static void eraseUnusedBitCasts(llvm::Instruction *insn) { 1455 while (insn->use_empty()) { 1456 llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn); 1457 if (!bitcast) return; 1458 1459 // This is "safe" because we would have used a ConstantExpr otherwise. 1460 insn = cast<llvm::Instruction>(bitcast->getOperand(0)); 1461 bitcast->eraseFromParent(); 1462 } 1463} 1464 1465/// Try to emit a fused autorelease of a return result. 1466static llvm::Value *tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, 1467 llvm::Value *result) { 1468 // We must be immediately followed the cast. 1469 llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock(); 1470 if (BB->empty()) return 0; 1471 if (&BB->back() != result) return 0; 1472 1473 llvm::Type *resultType = result->getType(); 1474 1475 // result is in a BasicBlock and is therefore an Instruction. 1476 llvm::Instruction *generator = cast<llvm::Instruction>(result); 1477 1478 SmallVector<llvm::Instruction*,4> insnsToKill; 1479 1480 // Look for: 1481 // %generator = bitcast %type1* %generator2 to %type2* 1482 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) { 1483 // We would have emitted this as a constant if the operand weren't 1484 // an Instruction. 1485 generator = cast<llvm::Instruction>(bitcast->getOperand(0)); 1486 1487 // Require the generator to be immediately followed by the cast. 1488 if (generator->getNextNode() != bitcast) 1489 return 0; 1490 1491 insnsToKill.push_back(bitcast); 1492 } 1493 1494 // Look for: 1495 // %generator = call i8* @objc_retain(i8* %originalResult) 1496 // or 1497 // %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult) 1498 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator); 1499 if (!call) return 0; 1500 1501 bool doRetainAutorelease; 1502 1503 if (call->getCalledValue() == CGF.CGM.getARCEntrypoints().objc_retain) { 1504 doRetainAutorelease = true; 1505 } else if (call->getCalledValue() == CGF.CGM.getARCEntrypoints() 1506 .objc_retainAutoreleasedReturnValue) { 1507 doRetainAutorelease = false; 1508 1509 // If we emitted an assembly marker for this call (and the 1510 // ARCEntrypoints field should have been set if so), go looking 1511 // for that call. If we can't find it, we can't do this 1512 // optimization. But it should always be the immediately previous 1513 // instruction, unless we needed bitcasts around the call. 1514 if (CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker) { 1515 llvm::Instruction *prev = call->getPrevNode(); 1516 assert(prev); 1517 if (isa<llvm::BitCastInst>(prev)) { 1518 prev = prev->getPrevNode(); 1519 assert(prev); 1520 } 1521 assert(isa<llvm::CallInst>(prev)); 1522 assert(cast<llvm::CallInst>(prev)->getCalledValue() == 1523 CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker); 1524 insnsToKill.push_back(prev); 1525 } 1526 } else { 1527 return 0; 1528 } 1529 1530 result = call->getArgOperand(0); 1531 insnsToKill.push_back(call); 1532 1533 // Keep killing bitcasts, for sanity. Note that we no longer care 1534 // about precise ordering as long as there's exactly one use. 1535 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) { 1536 if (!bitcast->hasOneUse()) break; 1537 insnsToKill.push_back(bitcast); 1538 result = bitcast->getOperand(0); 1539 } 1540 1541 // Delete all the unnecessary instructions, from latest to earliest. 1542 for (SmallVectorImpl<llvm::Instruction*>::iterator 1543 i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i) 1544 (*i)->eraseFromParent(); 1545 1546 // Do the fused retain/autorelease if we were asked to. 1547 if (doRetainAutorelease) 1548 result = CGF.EmitARCRetainAutoreleaseReturnValue(result); 1549 1550 // Cast back to the result type. 1551 return CGF.Builder.CreateBitCast(result, resultType); 1552} 1553 1554/// If this is a +1 of the value of an immutable 'self', remove it. 1555static llvm::Value *tryRemoveRetainOfSelf(CodeGenFunction &CGF, 1556 llvm::Value *result) { 1557 // This is only applicable to a method with an immutable 'self'. 1558 const ObjCMethodDecl *method = 1559 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl); 1560 if (!method) return 0; 1561 const VarDecl *self = method->getSelfDecl(); 1562 if (!self->getType().isConstQualified()) return 0; 1563 1564 // Look for a retain call. 1565 llvm::CallInst *retainCall = 1566 dyn_cast<llvm::CallInst>(result->stripPointerCasts()); 1567 if (!retainCall || 1568 retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain) 1569 return 0; 1570 1571 // Look for an ordinary load of 'self'. 1572 llvm::Value *retainedValue = retainCall->getArgOperand(0); 1573 llvm::LoadInst *load = 1574 dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts()); 1575 if (!load || load->isAtomic() || load->isVolatile() || 1576 load->getPointerOperand() != CGF.GetAddrOfLocalVar(self)) 1577 return 0; 1578 1579 // Okay! Burn it all down. This relies for correctness on the 1580 // assumption that the retain is emitted as part of the return and 1581 // that thereafter everything is used "linearly". 1582 llvm::Type *resultType = result->getType(); 1583 eraseUnusedBitCasts(cast<llvm::Instruction>(result)); 1584 assert(retainCall->use_empty()); 1585 retainCall->eraseFromParent(); 1586 eraseUnusedBitCasts(cast<llvm::Instruction>(retainedValue)); 1587 1588 return CGF.Builder.CreateBitCast(load, resultType); 1589} 1590 1591/// Emit an ARC autorelease of the result of a function. 1592/// 1593/// \return the value to actually return from the function 1594static llvm::Value *emitAutoreleaseOfResult(CodeGenFunction &CGF, 1595 llvm::Value *result) { 1596 // If we're returning 'self', kill the initial retain. This is a 1597 // heuristic attempt to "encourage correctness" in the really unfortunate 1598 // case where we have a return of self during a dealloc and we desperately 1599 // need to avoid the possible autorelease. 1600 if (llvm::Value *self = tryRemoveRetainOfSelf(CGF, result)) 1601 return self; 1602 1603 // At -O0, try to emit a fused retain/autorelease. 1604 if (CGF.shouldUseFusedARCCalls()) 1605 if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result)) 1606 return fused; 1607 1608 return CGF.EmitARCAutoreleaseReturnValue(result); 1609} 1610 1611/// Heuristically search for a dominating store to the return-value slot. 1612static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) { 1613 // If there are multiple uses of the return-value slot, just check 1614 // for something immediately preceding the IP. Sometimes this can 1615 // happen with how we generate implicit-returns; it can also happen 1616 // with noreturn cleanups. 1617 if (!CGF.ReturnValue->hasOneUse()) { 1618 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); 1619 if (IP->empty()) return 0; 1620 llvm::StoreInst *store = dyn_cast<llvm::StoreInst>(&IP->back()); 1621 if (!store) return 0; 1622 if (store->getPointerOperand() != CGF.ReturnValue) return 0; 1623 assert(!store->isAtomic() && !store->isVolatile()); // see below 1624 return store; 1625 } 1626 1627 llvm::StoreInst *store = 1628 dyn_cast<llvm::StoreInst>(CGF.ReturnValue->use_back()); 1629 if (!store) return 0; 1630 1631 // These aren't actually possible for non-coerced returns, and we 1632 // only care about non-coerced returns on this code path. 1633 assert(!store->isAtomic() && !store->isVolatile()); 1634 1635 // Now do a first-and-dirty dominance check: just walk up the 1636 // single-predecessors chain from the current insertion point. 1637 llvm::BasicBlock *StoreBB = store->getParent(); 1638 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock(); 1639 while (IP != StoreBB) { 1640 if (!(IP = IP->getSinglePredecessor())) 1641 return 0; 1642 } 1643 1644 // Okay, the store's basic block dominates the insertion point; we 1645 // can do our thing. 1646 return store; 1647} 1648 1649void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI, 1650 bool EmitRetDbgLoc, 1651 SourceLocation EndLoc) { 1652 // Functions with no result always return void. 1653 if (ReturnValue == 0) { 1654 Builder.CreateRetVoid(); 1655 return; 1656 } 1657 1658 llvm::DebugLoc RetDbgLoc; 1659 llvm::Value *RV = 0; 1660 QualType RetTy = FI.getReturnType(); 1661 const ABIArgInfo &RetAI = FI.getReturnInfo(); 1662 1663 switch (RetAI.getKind()) { 1664 case ABIArgInfo::Indirect: { 1665 switch (getEvaluationKind(RetTy)) { 1666 case TEK_Complex: { 1667 ComplexPairTy RT = 1668 EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy), 1669 EndLoc); 1670 EmitStoreOfComplex(RT, 1671 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy), 1672 /*isInit*/ true); 1673 break; 1674 } 1675 case TEK_Aggregate: 1676 // Do nothing; aggregrates get evaluated directly into the destination. 1677 break; 1678 case TEK_Scalar: 1679 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), 1680 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy), 1681 /*isInit*/ true); 1682 break; 1683 } 1684 break; 1685 } 1686 1687 case ABIArgInfo::Extend: 1688 case ABIArgInfo::Direct: 1689 if (RetAI.getCoerceToType() == ConvertType(RetTy) && 1690 RetAI.getDirectOffset() == 0) { 1691 // The internal return value temp always will have pointer-to-return-type 1692 // type, just do a load. 1693 1694 // If there is a dominating store to ReturnValue, we can elide 1695 // the load, zap the store, and usually zap the alloca. 1696 if (llvm::StoreInst *SI = findDominatingStoreToReturnValue(*this)) { 1697 // Reuse the debug location from the store unless there is 1698 // cleanup code to be emitted between the store and return 1699 // instruction. 1700 if (EmitRetDbgLoc && !AutoreleaseResult) 1701 RetDbgLoc = SI->getDebugLoc(); 1702 // Get the stored value and nuke the now-dead store. 1703 RV = SI->getValueOperand(); 1704 SI->eraseFromParent(); 1705 1706 // If that was the only use of the return value, nuke it as well now. 1707 if (ReturnValue->use_empty() && isa<llvm::AllocaInst>(ReturnValue)) { 1708 cast<llvm::AllocaInst>(ReturnValue)->eraseFromParent(); 1709 ReturnValue = 0; 1710 } 1711 1712 // Otherwise, we have to do a simple load. 1713 } else { 1714 RV = Builder.CreateLoad(ReturnValue); 1715 } 1716 } else { 1717 llvm::Value *V = ReturnValue; 1718 // If the value is offset in memory, apply the offset now. 1719 if (unsigned Offs = RetAI.getDirectOffset()) { 1720 V = Builder.CreateBitCast(V, Builder.getInt8PtrTy()); 1721 V = Builder.CreateConstGEP1_32(V, Offs); 1722 V = Builder.CreateBitCast(V, 1723 llvm::PointerType::getUnqual(RetAI.getCoerceToType())); 1724 } 1725 1726 RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this); 1727 } 1728 1729 // In ARC, end functions that return a retainable type with a call 1730 // to objc_autoreleaseReturnValue. 1731 if (AutoreleaseResult) { 1732 assert(getLangOpts().ObjCAutoRefCount && 1733 !FI.isReturnsRetained() && 1734 RetTy->isObjCRetainableType()); 1735 RV = emitAutoreleaseOfResult(*this, RV); 1736 } 1737 1738 break; 1739 1740 case ABIArgInfo::Ignore: 1741 break; 1742 1743 case ABIArgInfo::Expand: 1744 llvm_unreachable("Invalid ABI kind for return argument"); 1745 } 1746 1747 llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid(); 1748 if (!RetDbgLoc.isUnknown()) 1749 Ret->setDebugLoc(RetDbgLoc); 1750} 1751 1752void CodeGenFunction::EmitDelegateCallArg(CallArgList &args, 1753 const VarDecl *param, 1754 SourceLocation loc) { 1755 // StartFunction converted the ABI-lowered parameter(s) into a 1756 // local alloca. We need to turn that into an r-value suitable 1757 // for EmitCall. 1758 llvm::Value *local = GetAddrOfLocalVar(param); 1759 1760 QualType type = param->getType(); 1761 1762 // For the most part, we just need to load the alloca, except: 1763 // 1) aggregate r-values are actually pointers to temporaries, and 1764 // 2) references to non-scalars are pointers directly to the aggregate. 1765 // I don't know why references to scalars are different here. 1766 if (const ReferenceType *ref = type->getAs<ReferenceType>()) { 1767 if (!hasScalarEvaluationKind(ref->getPointeeType())) 1768 return args.add(RValue::getAggregate(local), type); 1769 1770 // Locals which are references to scalars are represented 1771 // with allocas holding the pointer. 1772 return args.add(RValue::get(Builder.CreateLoad(local)), type); 1773 } 1774 1775 args.add(convertTempToRValue(local, type, loc), type); 1776} 1777 1778static bool isProvablyNull(llvm::Value *addr) { 1779 return isa<llvm::ConstantPointerNull>(addr); 1780} 1781 1782static bool isProvablyNonNull(llvm::Value *addr) { 1783 return isa<llvm::AllocaInst>(addr); 1784} 1785 1786/// Emit the actual writing-back of a writeback. 1787static void emitWriteback(CodeGenFunction &CGF, 1788 const CallArgList::Writeback &writeback) { 1789 const LValue &srcLV = writeback.Source; 1790 llvm::Value *srcAddr = srcLV.getAddress(); 1791 assert(!isProvablyNull(srcAddr) && 1792 "shouldn't have writeback for provably null argument"); 1793 1794 llvm::BasicBlock *contBB = 0; 1795 1796 // If the argument wasn't provably non-null, we need to null check 1797 // before doing the store. 1798 bool provablyNonNull = isProvablyNonNull(srcAddr); 1799 if (!provablyNonNull) { 1800 llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback"); 1801 contBB = CGF.createBasicBlock("icr.done"); 1802 1803 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); 1804 CGF.Builder.CreateCondBr(isNull, contBB, writebackBB); 1805 CGF.EmitBlock(writebackBB); 1806 } 1807 1808 // Load the value to writeback. 1809 llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary); 1810 1811 // Cast it back, in case we're writing an id to a Foo* or something. 1812 value = CGF.Builder.CreateBitCast(value, 1813 cast<llvm::PointerType>(srcAddr->getType())->getElementType(), 1814 "icr.writeback-cast"); 1815 1816 // Perform the writeback. 1817 1818 // If we have a "to use" value, it's something we need to emit a use 1819 // of. This has to be carefully threaded in: if it's done after the 1820 // release it's potentially undefined behavior (and the optimizer 1821 // will ignore it), and if it happens before the retain then the 1822 // optimizer could move the release there. 1823 if (writeback.ToUse) { 1824 assert(srcLV.getObjCLifetime() == Qualifiers::OCL_Strong); 1825 1826 // Retain the new value. No need to block-copy here: the block's 1827 // being passed up the stack. 1828 value = CGF.EmitARCRetainNonBlock(value); 1829 1830 // Emit the intrinsic use here. 1831 CGF.EmitARCIntrinsicUse(writeback.ToUse); 1832 1833 // Load the old value (primitively). 1834 llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV, SourceLocation()); 1835 1836 // Put the new value in place (primitively). 1837 CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false); 1838 1839 // Release the old value. 1840 CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime()); 1841 1842 // Otherwise, we can just do a normal lvalue store. 1843 } else { 1844 CGF.EmitStoreThroughLValue(RValue::get(value), srcLV); 1845 } 1846 1847 // Jump to the continuation block. 1848 if (!provablyNonNull) 1849 CGF.EmitBlock(contBB); 1850} 1851 1852static void emitWritebacks(CodeGenFunction &CGF, 1853 const CallArgList &args) { 1854 for (CallArgList::writeback_iterator 1855 i = args.writeback_begin(), e = args.writeback_end(); i != e; ++i) 1856 emitWriteback(CGF, *i); 1857} 1858 1859static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, 1860 const CallArgList &CallArgs) { 1861 assert(CGF.getTarget().getCXXABI().isArgumentDestroyedByCallee()); 1862 ArrayRef<CallArgList::CallArgCleanup> Cleanups = 1863 CallArgs.getCleanupsToDeactivate(); 1864 // Iterate in reverse to increase the likelihood of popping the cleanup. 1865 for (ArrayRef<CallArgList::CallArgCleanup>::reverse_iterator 1866 I = Cleanups.rbegin(), E = Cleanups.rend(); I != E; ++I) { 1867 CGF.DeactivateCleanupBlock(I->Cleanup, I->IsActiveIP); 1868 I->IsActiveIP->eraseFromParent(); 1869 } 1870} 1871 1872static const Expr *maybeGetUnaryAddrOfOperand(const Expr *E) { 1873 if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E->IgnoreParens())) 1874 if (uop->getOpcode() == UO_AddrOf) 1875 return uop->getSubExpr(); 1876 return 0; 1877} 1878 1879/// Emit an argument that's being passed call-by-writeback. That is, 1880/// we are passing the address of 1881static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, 1882 const ObjCIndirectCopyRestoreExpr *CRE) { 1883 LValue srcLV; 1884 1885 // Make an optimistic effort to emit the address as an l-value. 1886 // This can fail if the the argument expression is more complicated. 1887 if (const Expr *lvExpr = maybeGetUnaryAddrOfOperand(CRE->getSubExpr())) { 1888 srcLV = CGF.EmitLValue(lvExpr); 1889 1890 // Otherwise, just emit it as a scalar. 1891 } else { 1892 llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr()); 1893 1894 QualType srcAddrType = 1895 CRE->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType(); 1896 srcLV = CGF.MakeNaturalAlignAddrLValue(srcAddr, srcAddrType); 1897 } 1898 llvm::Value *srcAddr = srcLV.getAddress(); 1899 1900 // The dest and src types don't necessarily match in LLVM terms 1901 // because of the crazy ObjC compatibility rules. 1902 1903 llvm::PointerType *destType = 1904 cast<llvm::PointerType>(CGF.ConvertType(CRE->getType())); 1905 1906 // If the address is a constant null, just pass the appropriate null. 1907 if (isProvablyNull(srcAddr)) { 1908 args.add(RValue::get(llvm::ConstantPointerNull::get(destType)), 1909 CRE->getType()); 1910 return; 1911 } 1912 1913 // Create the temporary. 1914 llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(), 1915 "icr.temp"); 1916 // Loading an l-value can introduce a cleanup if the l-value is __weak, 1917 // and that cleanup will be conditional if we can't prove that the l-value 1918 // isn't null, so we need to register a dominating point so that the cleanups 1919 // system will make valid IR. 1920 CodeGenFunction::ConditionalEvaluation condEval(CGF); 1921 1922 // Zero-initialize it if we're not doing a copy-initialization. 1923 bool shouldCopy = CRE->shouldCopy(); 1924 if (!shouldCopy) { 1925 llvm::Value *null = 1926 llvm::ConstantPointerNull::get( 1927 cast<llvm::PointerType>(destType->getElementType())); 1928 CGF.Builder.CreateStore(null, temp); 1929 } 1930 1931 llvm::BasicBlock *contBB = 0; 1932 llvm::BasicBlock *originBB = 0; 1933 1934 // If the address is *not* known to be non-null, we need to switch. 1935 llvm::Value *finalArgument; 1936 1937 bool provablyNonNull = isProvablyNonNull(srcAddr); 1938 if (provablyNonNull) { 1939 finalArgument = temp; 1940 } else { 1941 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull"); 1942 1943 finalArgument = CGF.Builder.CreateSelect(isNull, 1944 llvm::ConstantPointerNull::get(destType), 1945 temp, "icr.argument"); 1946 1947 // If we need to copy, then the load has to be conditional, which 1948 // means we need control flow. 1949 if (shouldCopy) { 1950 originBB = CGF.Builder.GetInsertBlock(); 1951 contBB = CGF.createBasicBlock("icr.cont"); 1952 llvm::BasicBlock *copyBB = CGF.createBasicBlock("icr.copy"); 1953 CGF.Builder.CreateCondBr(isNull, contBB, copyBB); 1954 CGF.EmitBlock(copyBB); 1955 condEval.begin(CGF); 1956 } 1957 } 1958 1959 llvm::Value *valueToUse = 0; 1960 1961 // Perform a copy if necessary. 1962 if (shouldCopy) { 1963 RValue srcRV = CGF.EmitLoadOfLValue(srcLV, SourceLocation()); 1964 assert(srcRV.isScalar()); 1965 1966 llvm::Value *src = srcRV.getScalarVal(); 1967 src = CGF.Builder.CreateBitCast(src, destType->getElementType(), 1968 "icr.cast"); 1969 1970 // Use an ordinary store, not a store-to-lvalue. 1971 CGF.Builder.CreateStore(src, temp); 1972 1973 // If optimization is enabled, and the value was held in a 1974 // __strong variable, we need to tell the optimizer that this 1975 // value has to stay alive until we're doing the store back. 1976 // This is because the temporary is effectively unretained, 1977 // and so otherwise we can violate the high-level semantics. 1978 if (CGF.CGM.getCodeGenOpts().OptimizationLevel != 0 && 1979 srcLV.getObjCLifetime() == Qualifiers::OCL_Strong) { 1980 valueToUse = src; 1981 } 1982 } 1983 1984 // Finish the control flow if we needed it. 1985 if (shouldCopy && !provablyNonNull) { 1986 llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock(); 1987 CGF.EmitBlock(contBB); 1988 1989 // Make a phi for the value to intrinsically use. 1990 if (valueToUse) { 1991 llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2, 1992 "icr.to-use"); 1993 phiToUse->addIncoming(valueToUse, copyBB); 1994 phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()), 1995 originBB); 1996 valueToUse = phiToUse; 1997 } 1998 1999 condEval.end(CGF); 2000 } 2001 2002 args.addWriteback(srcLV, temp, valueToUse); 2003 args.add(RValue::get(finalArgument), CRE->getType()); 2004} 2005 2006void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E, 2007 QualType type) { 2008 if (const ObjCIndirectCopyRestoreExpr *CRE 2009 = dyn_cast<ObjCIndirectCopyRestoreExpr>(E)) { 2010 assert(getLangOpts().ObjCAutoRefCount); 2011 assert(getContext().hasSameType(E->getType(), type)); 2012 return emitWritebackArg(*this, args, CRE); 2013 } 2014 2015 assert(type->isReferenceType() == E->isGLValue() && 2016 "reference binding to unmaterialized r-value!"); 2017 2018 if (E->isGLValue()) { 2019 assert(E->getObjectKind() == OK_Ordinary); 2020 return args.add(EmitReferenceBindingToExpr(E), type); 2021 } 2022 2023 bool HasAggregateEvalKind = hasAggregateEvaluationKind(type); 2024 2025 // In the Microsoft C++ ABI, aggregate arguments are destructed by the callee. 2026 // However, we still have to push an EH-only cleanup in case we unwind before 2027 // we make it to the call. 2028 if (HasAggregateEvalKind && 2029 CGM.getTarget().getCXXABI().isArgumentDestroyedByCallee()) { 2030 const CXXRecordDecl *RD = type->getAsCXXRecordDecl(); 2031 if (RD && RD->hasNonTrivialDestructor()) { 2032 AggValueSlot Slot = CreateAggTemp(type, "agg.arg.tmp"); 2033 Slot.setExternallyDestructed(); 2034 EmitAggExpr(E, Slot); 2035 RValue RV = Slot.asRValue(); 2036 args.add(RV, type); 2037 2038 pushDestroy(EHCleanup, RV.getAggregateAddr(), type, destroyCXXObject, 2039 /*useEHCleanupForArray*/ true); 2040 // This unreachable is a temporary marker which will be removed later. 2041 llvm::Instruction *IsActive = Builder.CreateUnreachable(); 2042 args.addArgCleanupDeactivation(EHStack.getInnermostEHScope(), IsActive); 2043 return; 2044 } 2045 } 2046 2047 if (HasAggregateEvalKind && isa<ImplicitCastExpr>(E) && 2048 cast<CastExpr>(E)->getCastKind() == CK_LValueToRValue) { 2049 LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr()); 2050 assert(L.isSimple()); 2051 if (L.getAlignment() >= getContext().getTypeAlignInChars(type)) { 2052 args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true); 2053 } else { 2054 // We can't represent a misaligned lvalue in the CallArgList, so copy 2055 // to an aligned temporary now. 2056 llvm::Value *tmp = CreateMemTemp(type); 2057 EmitAggregateCopy(tmp, L.getAddress(), type, L.isVolatile(), 2058 L.getAlignment()); 2059 args.add(RValue::getAggregate(tmp), type); 2060 } 2061 return; 2062 } 2063 2064 args.add(EmitAnyExprToTemp(E), type); 2065} 2066 2067// In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC 2068// optimizer it can aggressively ignore unwind edges. 2069void 2070CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) { 2071 if (CGM.getCodeGenOpts().OptimizationLevel != 0 && 2072 !CGM.getCodeGenOpts().ObjCAutoRefCountExceptions) 2073 Inst->setMetadata("clang.arc.no_objc_arc_exceptions", 2074 CGM.getNoObjCARCExceptionsMetadata()); 2075} 2076 2077/// Emits a call to the given no-arguments nounwind runtime function. 2078llvm::CallInst * 2079CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, 2080 const llvm::Twine &name) { 2081 return EmitNounwindRuntimeCall(callee, ArrayRef<llvm::Value*>(), name); 2082} 2083 2084/// Emits a call to the given nounwind runtime function. 2085llvm::CallInst * 2086CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee, 2087 ArrayRef<llvm::Value*> args, 2088 const llvm::Twine &name) { 2089 llvm::CallInst *call = EmitRuntimeCall(callee, args, name); 2090 call->setDoesNotThrow(); 2091 return call; 2092} 2093 2094/// Emits a simple call (never an invoke) to the given no-arguments 2095/// runtime function. 2096llvm::CallInst * 2097CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, 2098 const llvm::Twine &name) { 2099 return EmitRuntimeCall(callee, ArrayRef<llvm::Value*>(), name); 2100} 2101 2102/// Emits a simple call (never an invoke) to the given runtime 2103/// function. 2104llvm::CallInst * 2105CodeGenFunction::EmitRuntimeCall(llvm::Value *callee, 2106 ArrayRef<llvm::Value*> args, 2107 const llvm::Twine &name) { 2108 llvm::CallInst *call = Builder.CreateCall(callee, args, name); 2109 call->setCallingConv(getRuntimeCC()); 2110 return call; 2111} 2112 2113/// Emits a call or invoke to the given noreturn runtime function. 2114void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee, 2115 ArrayRef<llvm::Value*> args) { 2116 if (getInvokeDest()) { 2117 llvm::InvokeInst *invoke = 2118 Builder.CreateInvoke(callee, 2119 getUnreachableBlock(), 2120 getInvokeDest(), 2121 args); 2122 invoke->setDoesNotReturn(); 2123 invoke->setCallingConv(getRuntimeCC()); 2124 } else { 2125 llvm::CallInst *call = Builder.CreateCall(callee, args); 2126 call->setDoesNotReturn(); 2127 call->setCallingConv(getRuntimeCC()); 2128 Builder.CreateUnreachable(); 2129 } 2130} 2131 2132/// Emits a call or invoke instruction to the given nullary runtime 2133/// function. 2134llvm::CallSite 2135CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, 2136 const Twine &name) { 2137 return EmitRuntimeCallOrInvoke(callee, ArrayRef<llvm::Value*>(), name); 2138} 2139 2140/// Emits a call or invoke instruction to the given runtime function. 2141llvm::CallSite 2142CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee, 2143 ArrayRef<llvm::Value*> args, 2144 const Twine &name) { 2145 llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name); 2146 callSite.setCallingConv(getRuntimeCC()); 2147 return callSite; 2148} 2149 2150llvm::CallSite 2151CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, 2152 const Twine &Name) { 2153 return EmitCallOrInvoke(Callee, ArrayRef<llvm::Value *>(), Name); 2154} 2155 2156/// Emits a call or invoke instruction to the given function, depending 2157/// on the current state of the EH stack. 2158llvm::CallSite 2159CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee, 2160 ArrayRef<llvm::Value *> Args, 2161 const Twine &Name) { 2162 llvm::BasicBlock *InvokeDest = getInvokeDest(); 2163 2164 llvm::Instruction *Inst; 2165 if (!InvokeDest) 2166 Inst = Builder.CreateCall(Callee, Args, Name); 2167 else { 2168 llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont"); 2169 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name); 2170 EmitBlock(ContBB); 2171 } 2172 2173 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC 2174 // optimizer it can aggressively ignore unwind edges. 2175 if (CGM.getLangOpts().ObjCAutoRefCount) 2176 AddObjCARCExceptionMetadata(Inst); 2177 2178 return Inst; 2179} 2180 2181static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo, 2182 llvm::FunctionType *FTy) { 2183 if (ArgNo < FTy->getNumParams()) 2184 assert(Elt->getType() == FTy->getParamType(ArgNo)); 2185 else 2186 assert(FTy->isVarArg()); 2187 ++ArgNo; 2188} 2189 2190void CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV, 2191 SmallVectorImpl<llvm::Value *> &Args, 2192 llvm::FunctionType *IRFuncTy) { 2193 if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) { 2194 unsigned NumElts = AT->getSize().getZExtValue(); 2195 QualType EltTy = AT->getElementType(); 2196 llvm::Value *Addr = RV.getAggregateAddr(); 2197 for (unsigned Elt = 0; Elt < NumElts; ++Elt) { 2198 llvm::Value *EltAddr = Builder.CreateConstGEP2_32(Addr, 0, Elt); 2199 RValue EltRV = convertTempToRValue(EltAddr, EltTy, SourceLocation()); 2200 ExpandTypeToArgs(EltTy, EltRV, Args, IRFuncTy); 2201 } 2202 } else if (const RecordType *RT = Ty->getAs<RecordType>()) { 2203 RecordDecl *RD = RT->getDecl(); 2204 assert(RV.isAggregate() && "Unexpected rvalue during struct expansion"); 2205 LValue LV = MakeAddrLValue(RV.getAggregateAddr(), Ty); 2206 2207 if (RD->isUnion()) { 2208 const FieldDecl *LargestFD = 0; 2209 CharUnits UnionSize = CharUnits::Zero(); 2210 2211 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 2212 i != e; ++i) { 2213 const FieldDecl *FD = *i; 2214 assert(!FD->isBitField() && 2215 "Cannot expand structure with bit-field members."); 2216 CharUnits FieldSize = getContext().getTypeSizeInChars(FD->getType()); 2217 if (UnionSize < FieldSize) { 2218 UnionSize = FieldSize; 2219 LargestFD = FD; 2220 } 2221 } 2222 if (LargestFD) { 2223 RValue FldRV = EmitRValueForField(LV, LargestFD, SourceLocation()); 2224 ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy); 2225 } 2226 } else { 2227 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); 2228 i != e; ++i) { 2229 FieldDecl *FD = *i; 2230 2231 RValue FldRV = EmitRValueForField(LV, FD, SourceLocation()); 2232 ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy); 2233 } 2234 } 2235 } else if (Ty->isAnyComplexType()) { 2236 ComplexPairTy CV = RV.getComplexVal(); 2237 Args.push_back(CV.first); 2238 Args.push_back(CV.second); 2239 } else { 2240 assert(RV.isScalar() && 2241 "Unexpected non-scalar rvalue during struct expansion."); 2242 2243 // Insert a bitcast as needed. 2244 llvm::Value *V = RV.getScalarVal(); 2245 if (Args.size() < IRFuncTy->getNumParams() && 2246 V->getType() != IRFuncTy->getParamType(Args.size())) 2247 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(Args.size())); 2248 2249 Args.push_back(V); 2250 } 2251} 2252 2253 2254RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo, 2255 llvm::Value *Callee, 2256 ReturnValueSlot ReturnValue, 2257 const CallArgList &CallArgs, 2258 const Decl *TargetDecl, 2259 llvm::Instruction **callOrInvoke) { 2260 // FIXME: We no longer need the types from CallArgs; lift up and simplify. 2261 SmallVector<llvm::Value*, 16> Args; 2262 2263 // Handle struct-return functions by passing a pointer to the 2264 // location that we would like to return into. 2265 QualType RetTy = CallInfo.getReturnType(); 2266 const ABIArgInfo &RetAI = CallInfo.getReturnInfo(); 2267 2268 // IRArgNo - Keep track of the argument number in the callee we're looking at. 2269 unsigned IRArgNo = 0; 2270 llvm::FunctionType *IRFuncTy = 2271 cast<llvm::FunctionType>( 2272 cast<llvm::PointerType>(Callee->getType())->getElementType()); 2273 2274 // If the call returns a temporary with struct return, create a temporary 2275 // alloca to hold the result, unless one is given to us. 2276 if (CGM.ReturnTypeUsesSRet(CallInfo)) { 2277 llvm::Value *Value = ReturnValue.getValue(); 2278 if (!Value) 2279 Value = CreateMemTemp(RetTy); 2280 Args.push_back(Value); 2281 checkArgMatches(Value, IRArgNo, IRFuncTy); 2282 } 2283 2284 assert(CallInfo.arg_size() == CallArgs.size() && 2285 "Mismatch between function signature & arguments."); 2286 CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin(); 2287 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); 2288 I != E; ++I, ++info_it) { 2289 const ABIArgInfo &ArgInfo = info_it->info; 2290 RValue RV = I->RV; 2291 2292 CharUnits TypeAlign = getContext().getTypeAlignInChars(I->Ty); 2293 2294 // Insert a padding argument to ensure proper alignment. 2295 if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) { 2296 Args.push_back(llvm::UndefValue::get(PaddingType)); 2297 ++IRArgNo; 2298 } 2299 2300 switch (ArgInfo.getKind()) { 2301 case ABIArgInfo::Indirect: { 2302 if (RV.isScalar() || RV.isComplex()) { 2303 // Make a temporary alloca to pass the argument. 2304 llvm::AllocaInst *AI = CreateMemTemp(I->Ty); 2305 if (ArgInfo.getIndirectAlign() > AI->getAlignment()) 2306 AI->setAlignment(ArgInfo.getIndirectAlign()); 2307 Args.push_back(AI); 2308 2309 LValue argLV = 2310 MakeAddrLValue(Args.back(), I->Ty, TypeAlign); 2311 2312 if (RV.isScalar()) 2313 EmitStoreOfScalar(RV.getScalarVal(), argLV, /*init*/ true); 2314 else 2315 EmitStoreOfComplex(RV.getComplexVal(), argLV, /*init*/ true); 2316 2317 // Validate argument match. 2318 checkArgMatches(AI, IRArgNo, IRFuncTy); 2319 } else { 2320 // We want to avoid creating an unnecessary temporary+copy here; 2321 // however, we need one in three cases: 2322 // 1. If the argument is not byval, and we are required to copy the 2323 // source. (This case doesn't occur on any common architecture.) 2324 // 2. If the argument is byval, RV is not sufficiently aligned, and 2325 // we cannot force it to be sufficiently aligned. 2326 // 3. If the argument is byval, but RV is located in an address space 2327 // different than that of the argument (0). 2328 llvm::Value *Addr = RV.getAggregateAddr(); 2329 unsigned Align = ArgInfo.getIndirectAlign(); 2330 const llvm::DataLayout *TD = &CGM.getDataLayout(); 2331 const unsigned RVAddrSpace = Addr->getType()->getPointerAddressSpace(); 2332 const unsigned ArgAddrSpace = (IRArgNo < IRFuncTy->getNumParams() ? 2333 IRFuncTy->getParamType(IRArgNo)->getPointerAddressSpace() : 0); 2334 if ((!ArgInfo.getIndirectByVal() && I->NeedsCopy) || 2335 (ArgInfo.getIndirectByVal() && TypeAlign.getQuantity() < Align && 2336 llvm::getOrEnforceKnownAlignment(Addr, Align, TD) < Align) || 2337 (ArgInfo.getIndirectByVal() && (RVAddrSpace != ArgAddrSpace))) { 2338 // Create an aligned temporary, and copy to it. 2339 llvm::AllocaInst *AI = CreateMemTemp(I->Ty); 2340 if (Align > AI->getAlignment()) 2341 AI->setAlignment(Align); 2342 Args.push_back(AI); 2343 EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified()); 2344 2345 // Validate argument match. 2346 checkArgMatches(AI, IRArgNo, IRFuncTy); 2347 } else { 2348 // Skip the extra memcpy call. 2349 Args.push_back(Addr); 2350 2351 // Validate argument match. 2352 checkArgMatches(Addr, IRArgNo, IRFuncTy); 2353 } 2354 } 2355 break; 2356 } 2357 2358 case ABIArgInfo::Ignore: 2359 break; 2360 2361 case ABIArgInfo::Extend: 2362 case ABIArgInfo::Direct: { 2363 if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) && 2364 ArgInfo.getCoerceToType() == ConvertType(info_it->type) && 2365 ArgInfo.getDirectOffset() == 0) { 2366 llvm::Value *V; 2367 if (RV.isScalar()) 2368 V = RV.getScalarVal(); 2369 else 2370 V = Builder.CreateLoad(RV.getAggregateAddr()); 2371 2372 // If the argument doesn't match, perform a bitcast to coerce it. This 2373 // can happen due to trivial type mismatches. 2374 if (IRArgNo < IRFuncTy->getNumParams() && 2375 V->getType() != IRFuncTy->getParamType(IRArgNo)) 2376 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRArgNo)); 2377 Args.push_back(V); 2378 2379 checkArgMatches(V, IRArgNo, IRFuncTy); 2380 break; 2381 } 2382 2383 // FIXME: Avoid the conversion through memory if possible. 2384 llvm::Value *SrcPtr; 2385 if (RV.isScalar() || RV.isComplex()) { 2386 SrcPtr = CreateMemTemp(I->Ty, "coerce"); 2387 LValue SrcLV = MakeAddrLValue(SrcPtr, I->Ty, TypeAlign); 2388 if (RV.isScalar()) { 2389 EmitStoreOfScalar(RV.getScalarVal(), SrcLV, /*init*/ true); 2390 } else { 2391 EmitStoreOfComplex(RV.getComplexVal(), SrcLV, /*init*/ true); 2392 } 2393 } else 2394 SrcPtr = RV.getAggregateAddr(); 2395 2396 // If the value is offset in memory, apply the offset now. 2397 if (unsigned Offs = ArgInfo.getDirectOffset()) { 2398 SrcPtr = Builder.CreateBitCast(SrcPtr, Builder.getInt8PtrTy()); 2399 SrcPtr = Builder.CreateConstGEP1_32(SrcPtr, Offs); 2400 SrcPtr = Builder.CreateBitCast(SrcPtr, 2401 llvm::PointerType::getUnqual(ArgInfo.getCoerceToType())); 2402 2403 } 2404 2405 // If the coerce-to type is a first class aggregate, we flatten it and 2406 // pass the elements. Either way is semantically identical, but fast-isel 2407 // and the optimizer generally likes scalar values better than FCAs. 2408 if (llvm::StructType *STy = 2409 dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType())) { 2410 llvm::Type *SrcTy = 2411 cast<llvm::PointerType>(SrcPtr->getType())->getElementType(); 2412 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy); 2413 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy); 2414 2415 // If the source type is smaller than the destination type of the 2416 // coerce-to logic, copy the source value into a temp alloca the size 2417 // of the destination type to allow loading all of it. The bits past 2418 // the source value are left undef. 2419 if (SrcSize < DstSize) { 2420 llvm::AllocaInst *TempAlloca 2421 = CreateTempAlloca(STy, SrcPtr->getName() + ".coerce"); 2422 Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0); 2423 SrcPtr = TempAlloca; 2424 } else { 2425 SrcPtr = Builder.CreateBitCast(SrcPtr, 2426 llvm::PointerType::getUnqual(STy)); 2427 } 2428 2429 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { 2430 llvm::Value *EltPtr = Builder.CreateConstGEP2_32(SrcPtr, 0, i); 2431 llvm::LoadInst *LI = Builder.CreateLoad(EltPtr); 2432 // We don't know what we're loading from. 2433 LI->setAlignment(1); 2434 Args.push_back(LI); 2435 2436 // Validate argument match. 2437 checkArgMatches(LI, IRArgNo, IRFuncTy); 2438 } 2439 } else { 2440 // In the simple case, just pass the coerced loaded value. 2441 Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(), 2442 *this)); 2443 2444 // Validate argument match. 2445 checkArgMatches(Args.back(), IRArgNo, IRFuncTy); 2446 } 2447 2448 break; 2449 } 2450 2451 case ABIArgInfo::Expand: 2452 ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy); 2453 IRArgNo = Args.size(); 2454 break; 2455 } 2456 } 2457 2458 if (!CallArgs.getCleanupsToDeactivate().empty()) 2459 deactivateArgCleanupsBeforeCall(*this, CallArgs); 2460 2461 // If the callee is a bitcast of a function to a varargs pointer to function 2462 // type, check to see if we can remove the bitcast. This handles some cases 2463 // with unprototyped functions. 2464 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Callee)) 2465 if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) { 2466 llvm::PointerType *CurPT=cast<llvm::PointerType>(Callee->getType()); 2467 llvm::FunctionType *CurFT = 2468 cast<llvm::FunctionType>(CurPT->getElementType()); 2469 llvm::FunctionType *ActualFT = CalleeF->getFunctionType(); 2470 2471 if (CE->getOpcode() == llvm::Instruction::BitCast && 2472 ActualFT->getReturnType() == CurFT->getReturnType() && 2473 ActualFT->getNumParams() == CurFT->getNumParams() && 2474 ActualFT->getNumParams() == Args.size() && 2475 (CurFT->isVarArg() || !ActualFT->isVarArg())) { 2476 bool ArgsMatch = true; 2477 for (unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i) 2478 if (ActualFT->getParamType(i) != CurFT->getParamType(i)) { 2479 ArgsMatch = false; 2480 break; 2481 } 2482 2483 // Strip the cast if we can get away with it. This is a nice cleanup, 2484 // but also allows us to inline the function at -O0 if it is marked 2485 // always_inline. 2486 if (ArgsMatch) 2487 Callee = CalleeF; 2488 } 2489 } 2490 2491 unsigned CallingConv; 2492 CodeGen::AttributeListType AttributeList; 2493 CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList, 2494 CallingConv, true); 2495 llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(), 2496 AttributeList); 2497 2498 llvm::BasicBlock *InvokeDest = 0; 2499 if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex, 2500 llvm::Attribute::NoUnwind)) 2501 InvokeDest = getInvokeDest(); 2502 2503 llvm::CallSite CS; 2504 if (!InvokeDest) { 2505 CS = Builder.CreateCall(Callee, Args); 2506 } else { 2507 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont"); 2508 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args); 2509 EmitBlock(Cont); 2510 } 2511 if (callOrInvoke) 2512 *callOrInvoke = CS.getInstruction(); 2513 2514 CS.setAttributes(Attrs); 2515 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); 2516 2517 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC 2518 // optimizer it can aggressively ignore unwind edges. 2519 if (CGM.getLangOpts().ObjCAutoRefCount) 2520 AddObjCARCExceptionMetadata(CS.getInstruction()); 2521 2522 // If the call doesn't return, finish the basic block and clear the 2523 // insertion point; this allows the rest of IRgen to discard 2524 // unreachable code. 2525 if (CS.doesNotReturn()) { 2526 Builder.CreateUnreachable(); 2527 Builder.ClearInsertionPoint(); 2528 2529 // FIXME: For now, emit a dummy basic block because expr emitters in 2530 // generally are not ready to handle emitting expressions at unreachable 2531 // points. 2532 EnsureInsertPoint(); 2533 2534 // Return a reasonable RValue. 2535 return GetUndefRValue(RetTy); 2536 } 2537 2538 llvm::Instruction *CI = CS.getInstruction(); 2539 if (Builder.isNamePreserving() && !CI->getType()->isVoidTy()) 2540 CI->setName("call"); 2541 2542 // Emit any writebacks immediately. Arguably this should happen 2543 // after any return-value munging. 2544 if (CallArgs.hasWritebacks()) 2545 emitWritebacks(*this, CallArgs); 2546 2547 switch (RetAI.getKind()) { 2548 case ABIArgInfo::Indirect: 2549 return convertTempToRValue(Args[0], RetTy, SourceLocation()); 2550 2551 case ABIArgInfo::Ignore: 2552 // If we are ignoring an argument that had a result, make sure to 2553 // construct the appropriate return value for our caller. 2554 return GetUndefRValue(RetTy); 2555 2556 case ABIArgInfo::Extend: 2557 case ABIArgInfo::Direct: { 2558 llvm::Type *RetIRTy = ConvertType(RetTy); 2559 if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) { 2560 switch (getEvaluationKind(RetTy)) { 2561 case TEK_Complex: { 2562 llvm::Value *Real = Builder.CreateExtractValue(CI, 0); 2563 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1); 2564 return RValue::getComplex(std::make_pair(Real, Imag)); 2565 } 2566 case TEK_Aggregate: { 2567 llvm::Value *DestPtr = ReturnValue.getValue(); 2568 bool DestIsVolatile = ReturnValue.isVolatile(); 2569 2570 if (!DestPtr) { 2571 DestPtr = CreateMemTemp(RetTy, "agg.tmp"); 2572 DestIsVolatile = false; 2573 } 2574 BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false); 2575 return RValue::getAggregate(DestPtr); 2576 } 2577 case TEK_Scalar: { 2578 // If the argument doesn't match, perform a bitcast to coerce it. This 2579 // can happen due to trivial type mismatches. 2580 llvm::Value *V = CI; 2581 if (V->getType() != RetIRTy) 2582 V = Builder.CreateBitCast(V, RetIRTy); 2583 return RValue::get(V); 2584 } 2585 } 2586 llvm_unreachable("bad evaluation kind"); 2587 } 2588 2589 llvm::Value *DestPtr = ReturnValue.getValue(); 2590 bool DestIsVolatile = ReturnValue.isVolatile(); 2591 2592 if (!DestPtr) { 2593 DestPtr = CreateMemTemp(RetTy, "coerce"); 2594 DestIsVolatile = false; 2595 } 2596 2597 // If the value is offset in memory, apply the offset now. 2598 llvm::Value *StorePtr = DestPtr; 2599 if (unsigned Offs = RetAI.getDirectOffset()) { 2600 StorePtr = Builder.CreateBitCast(StorePtr, Builder.getInt8PtrTy()); 2601 StorePtr = Builder.CreateConstGEP1_32(StorePtr, Offs); 2602 StorePtr = Builder.CreateBitCast(StorePtr, 2603 llvm::PointerType::getUnqual(RetAI.getCoerceToType())); 2604 } 2605 CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this); 2606 2607 return convertTempToRValue(DestPtr, RetTy, SourceLocation()); 2608 } 2609 2610 case ABIArgInfo::Expand: 2611 llvm_unreachable("Invalid ABI kind for return argument"); 2612 } 2613 2614 llvm_unreachable("Unhandled ABIArgInfo::Kind"); 2615} 2616 2617/* VarArg handling */ 2618 2619llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) { 2620 return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this); 2621} 2622