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