1 //===--- CGCall.cpp - Encapsulate calling convention details ----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // These classes wrap the information about a call or function
11 // definition used to handle ABI compliancy.
13 //===----------------------------------------------------------------------===//
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"
33 using namespace clang;
34 using namespace CodeGen;
38 static unsigned ClangCallConvToLLVMCallConv(CallingConv 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
53 /// Derives the 'this' type for codegen purposes, i.e. ignoring method
55 /// FIXME: address space qualification?
56 static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD) {
57 QualType RecTy = Context.getTagDeclType(RD)->getCanonicalTypeInternal();
58 return Context.getPointerType(CanQualType::CreateUnsafe(RecTy));
61 /// Returns the canonical formal type of the given C++ method.
62 static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) {
63 return MD->getType()->getCanonicalTypeUnqualified()
64 .getAs<FunctionProtoType>();
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.
71 static CanQualType GetReturnType(QualType RetTy) {
72 return RetTy->getCanonicalTypeUnqualified().getUnqualifiedType();
75 /// Arrange the argument and result information for a value of the given
76 /// unprototyped freestanding function type.
77 const CGFunctionInfo &
78 CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) {
79 // When translating an unprototyped function type, always use a
81 return arrangeLLVMFunctionInfo(FTNP->getResultType().getUnqualifiedType(),
82 None, FTNP->getExtInfo(), RequiredArgs(0));
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.
88 static 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());
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);
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.
102 static const CGFunctionInfo &arrangeFreeFunctionType(CodeGenTypes &CGT,
103 SmallVectorImpl<CanQualType> &prefix,
104 CanQual<FunctionProtoType> FTP) {
105 return arrangeLLVMFunctionInfo(CGT, prefix, FTP, FTP->getExtInfo());
108 /// Given the formal ext-info of a C++ instance method, adjust it
109 /// according to the C++ ABI in effect.
110 static void adjustCXXMethodInfo(CodeGenTypes &CGT,
111 FunctionType::ExtInfo &extInfo,
113 if (extInfo.getCC() == CC_Default) {
114 CallingConv CC = CGT.getContext().getDefaultCXXMethodCallConv(isVariadic);
115 extInfo = extInfo.withCallingConv(CC);
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.
121 static 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);
129 /// Arrange the argument and result information for a value of the
130 /// given freestanding function type.
131 const CGFunctionInfo &
132 CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) {
133 SmallVector<CanQualType, 16> argTypes;
134 return ::arrangeFreeFunctionType(*this, argTypes, FTP);
137 static CallingConv getCallingConventionForDecl(const Decl *D) {
138 // Set the appropriate calling convention for the Function.
139 if (D->hasAttr<StdCallAttr>())
140 return CC_X86StdCall;
142 if (D->hasAttr<FastCallAttr>())
143 return CC_X86FastCall;
145 if (D->hasAttr<ThisCallAttr>())
146 return CC_X86ThisCall;
148 if (D->hasAttr<PascalAttr>())
151 if (PcsAttr *PCS = D->getAttr<PcsAttr>())
152 return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP);
154 if (D->hasAttr<PnaclCallAttr>())
157 if (D->hasAttr<IntelOclBiccAttr>())
158 return CC_IntelOclBicc;
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.
167 const CGFunctionInfo &
168 CodeGenTypes::arrangeCXXMethodType(const CXXRecordDecl *RD,
169 const FunctionProtoType *FTP) {
170 SmallVector<CanQualType, 16> argTypes;
172 // Add the 'this' pointer.
173 argTypes.push_back(GetThisType(Context, RD));
175 return ::arrangeCXXMethodType(*this, argTypes,
176 FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>());
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.
183 const CGFunctionInfo &
184 CodeGenTypes::arrangeCXXMethodDeclaration(const CXXMethodDecl *MD) {
185 assert(!isa<CXXConstructorDecl>(MD) && "wrong method for contructors!");
186 assert(!isa<CXXDestructorDecl>(MD) && "wrong method for destructors!");
188 CanQual<FunctionProtoType> prototype = GetFormalType(MD);
190 if (MD->isInstance()) {
191 // The abstract case is perfectly fine.
192 return arrangeCXXMethodType(MD->getParent(), prototype.getTypePtr());
195 return arrangeFreeFunctionType(prototype);
198 /// Arrange the argument and result information for a declaration
199 /// or definition to the given constructor variant.
200 const CGFunctionInfo &
201 CodeGenTypes::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;
207 TheCXXABI.BuildConstructorSignature(D, ctorKind, resultType, argTypes);
209 CanQual<FunctionProtoType> FTP = GetFormalType(D);
211 RequiredArgs required = RequiredArgs::forPrototypePlus(FTP, argTypes.size());
213 // Add the formal parameters.
214 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
215 argTypes.push_back(FTP->getArgType(i));
217 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
218 adjustCXXMethodInfo(*this, extInfo, FTP->isVariadic());
219 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo, required);
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.
225 const CGFunctionInfo &
226 CodeGenTypes::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;
232 TheCXXABI.BuildDestructorSignature(D, dtorKind, resultType, argTypes);
234 CanQual<FunctionProtoType> FTP = GetFormalType(D);
235 assert(FTP->getNumArgs() == 0 && "dtor with formal parameters");
236 assert(FTP->isVariadic() == 0 && "dtor with formal parameters");
238 FunctionType::ExtInfo extInfo = FTP->getExtInfo();
239 adjustCXXMethodInfo(*this, extInfo, false);
240 return arrangeLLVMFunctionInfo(resultType, argTypes, extInfo,
244 /// Arrange the argument and result information for the declaration or
245 /// definition of the given function.
246 const CGFunctionInfo &
247 CodeGenTypes::arrangeFunctionDeclaration(const FunctionDecl *FD) {
248 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
249 if (MD->isInstance())
250 return arrangeCXXMethodDeclaration(MD);
252 CanQualType FTy = FD->getType()->getCanonicalTypeUnqualified();
254 assert(isa<FunctionType>(FTy));
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);
264 assert(isa<FunctionProtoType>(FTy));
265 return arrangeFreeFunctionType(FTy.getAs<FunctionProtoType>());
268 /// Arrange the argument and result information for the declaration or
269 /// definition of an Objective-C method.
270 const CGFunctionInfo &
271 CodeGenTypes::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());
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.
283 const CGFunctionInfo &
284 CodeGenTypes::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()));
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()));
295 FunctionType::ExtInfo einfo;
296 einfo = einfo.withCallingConv(getCallingConventionForDecl(MD));
298 if (getContext().getLangOpts().ObjCAutoRefCount &&
299 MD->hasAttr<NSReturnsRetainedAttr>())
300 einfo = einfo.withProducesResult(true);
302 RequiredArgs required =
303 (MD->isVariadic() ? RequiredArgs(argTys.size()) : RequiredArgs::All);
305 return arrangeLLVMFunctionInfo(GetReturnType(MD->getResultType()), argTys,
309 const CGFunctionInfo &
310 CodeGenTypes::arrangeGlobalDeclaration(GlobalDecl GD) {
311 // FIXME: Do we need to handle ObjCMethodDecl?
312 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
314 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
315 return arrangeCXXConstructorDeclaration(CD, GD.getCtorType());
317 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD))
318 return arrangeCXXDestructor(DD, GD.getDtorType());
320 return arrangeFunctionDeclaration(FD);
323 /// Arrange a call as unto a free function, except possibly with an
324 /// additional number of formal parameters considered required.
325 static const CGFunctionInfo &
326 arrangeFreeFunctionLikeCall(CodeGenTypes &CGT,
327 const CallArgList &args,
328 const FunctionType *fnType,
329 unsigned numExtraRequiredArgs) {
330 assert(args.size() >= numExtraRequiredArgs);
332 // In most cases, there are no optional arguments.
333 RequiredArgs required = RequiredArgs::All;
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);
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());
350 return CGT.arrangeFreeFunctionCall(fnType->getResultType(), args,
351 fnType->getExtInfo(), required);
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.
358 const CGFunctionInfo &
359 CodeGenTypes::arrangeFreeFunctionCall(const CallArgList &args,
360 const FunctionType *fnType) {
361 return arrangeFreeFunctionLikeCall(*this, args, fnType, 0);
364 /// A block function call is essentially a free-function call with an
365 /// extra implicit argument.
366 const CGFunctionInfo &
367 CodeGenTypes::arrangeBlockFunctionCall(const CallArgList &args,
368 const FunctionType *fnType) {
369 return arrangeFreeFunctionLikeCall(*this, args, fnType, 1);
372 const CGFunctionInfo &
373 CodeGenTypes::arrangeFreeFunctionCall(QualType resultType,
374 const CallArgList &args,
375 FunctionType::ExtInfo info,
376 RequiredArgs required) {
378 SmallVector<CanQualType, 16> argTypes;
379 for (CallArgList::const_iterator i = args.begin(), e = args.end();
381 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
382 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
386 /// Arrange a call to a C++ method, passing the given arguments.
387 const CGFunctionInfo &
388 CodeGenTypes::arrangeCXXMethodCall(const CallArgList &args,
389 const FunctionProtoType *FPT,
390 RequiredArgs required) {
392 SmallVector<CanQualType, 16> argTypes;
393 for (CallArgList::const_iterator i = args.begin(), e = args.end();
395 argTypes.push_back(Context.getCanonicalParamType(i->Ty));
397 FunctionType::ExtInfo info = FPT->getExtInfo();
398 adjustCXXMethodInfo(*this, info, FPT->isVariadic());
399 return arrangeLLVMFunctionInfo(GetReturnType(FPT->getResultType()),
400 argTypes, info, required);
403 const CGFunctionInfo &
404 CodeGenTypes::arrangeFunctionDeclaration(QualType resultType,
405 const FunctionArgList &args,
406 const FunctionType::ExtInfo &info,
409 SmallVector<CanQualType, 16> argTypes;
410 for (FunctionArgList::const_iterator i = args.begin(), e = args.end();
412 argTypes.push_back(Context.getCanonicalParamType((*i)->getType()));
414 RequiredArgs required =
415 (isVariadic ? RequiredArgs(args.size()) : RequiredArgs::All);
416 return arrangeLLVMFunctionInfo(GetReturnType(resultType), argTypes, info,
420 const CGFunctionInfo &CodeGenTypes::arrangeNullaryFunction() {
421 return arrangeLLVMFunctionInfo(getContext().VoidTy, None,
422 FunctionType::ExtInfo(), RequiredArgs::All);
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.
428 const CGFunctionInfo &
429 CodeGenTypes::arrangeLLVMFunctionInfo(CanQualType resultType,
430 ArrayRef<CanQualType> argTypes,
431 FunctionType::ExtInfo info,
432 RequiredArgs required) {
434 for (ArrayRef<CanQualType>::const_iterator
435 I = argTypes.begin(), E = argTypes.end(); I != E; ++I)
436 assert(I->isCanonicalAsParam());
439 unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
441 // Lookup or create unique function info.
442 llvm::FoldingSetNodeID ID;
443 CGFunctionInfo::Profile(ID, info, required, resultType, argTypes);
446 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
450 // Construct the function info. We co-allocate the ArgInfos.
451 FI = CGFunctionInfo::create(CC, info, resultType, argTypes, required);
452 FunctionInfos.InsertNode(FI, insertPos);
454 bool inserted = FunctionsBeingProcessed.insert(FI); (void)inserted;
455 assert(inserted && "Recursively being processed?");
457 // Compute ABI information.
458 getABIInfo().computeInfo(*FI);
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
463 ABIArgInfo &retInfo = FI->getReturnInfo();
464 if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == 0)
465 retInfo.setCoerceToType(ConvertType(FI->getReturnType()));
467 for (CGFunctionInfo::arg_iterator I = FI->arg_begin(), E = FI->arg_end();
469 if (I->info.canHaveCoerceToType() && I->info.getCoerceToType() == 0)
470 I->info.setCoerceToType(ConvertType(I->type));
472 bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
473 assert(erased && "Not in set?");
478 CGFunctionInfo *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];
503 void 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.");
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();
519 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
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;
531 GetExpandedTypes(LargestFD->getType(), expandedTypes);
533 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
535 assert(!i->isBitField() &&
536 "Cannot expand structure with bit-field members.");
537 GetExpandedTypes(i->getType(), expandedTypes);
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);
545 expandedTypes.push_back(ConvertType(type));
548 llvm::Function::arg_iterator
549 CodeGenFunction::ExpandTypeFromArgs(QualType Ty, LValue LV,
550 llvm::Function::arg_iterator AI) {
551 assert(LV.isSimple() &&
552 "Unexpected non-simple lvalue during struct expansion.");
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);
562 } else if (const RecordType *RT = Ty->getAs<RecordType>()) {
563 RecordDecl *RD = RT->getDecl();
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();
570 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
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;
582 // FIXME: What are the right qualifiers here?
583 LValue SubLV = EmitLValueForField(LV, LargestFD);
584 AI = ExpandTypeFromArgs(LargestFD->getType(), SubLV, AI);
587 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
590 QualType FT = FD->getType();
592 // FIXME: What are the right qualifiers here?
593 LValue SubLV = EmitLValueForField(LV, FD);
594 AI = ExpandTypeFromArgs(FT, SubLV, AI);
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));
604 EmitStoreThroughLValue(RValue::get(AI), LV);
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.
616 EnterStructPointerForCoercedAccess(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;
622 llvm::Type *FirstElt = SrcSTy->getElementType(0);
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))
632 // GEP into the first element.
633 SrcPtr = CGF.Builder.CreateConstGEP2_32(SrcPtr, 0, 0, "coerce.dive");
635 // If the first element is a struct, recurse.
637 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
638 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
639 return EnterStructPointerForCoercedAccess(SrcPtr, SrcSTy, DstSize, CGF);
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.
647 static llvm::Value *CoerceIntOrPtrToIntOrPtr(llvm::Value *Val,
649 CodeGenFunction &CGF) {
650 if (Val->getType() == Ty)
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");
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");
662 llvm::Type *DestIntTy = Ty;
663 if (isa<llvm::PointerType>(DestIntTy))
664 DestIntTy = CGF.IntPtrTy;
666 if (Val->getType() != DestIntTy)
667 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
669 if (isa<llvm::PointerType>(Ty))
670 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
676 /// CreateCoercedLoad - Create a load from \arg SrcPtr interpreted as
677 /// a pointer to an object of type \arg Ty.
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.
682 static llvm::Value *CreateCoercedLoad(llvm::Value *SrcPtr,
684 CodeGenFunction &CGF) {
686 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
688 // If SrcTy and Ty are the same, just do a load.
690 return CGF.Builder.CreateLoad(SrcPtr);
692 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(Ty);
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();
699 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
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);
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.
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);
725 // Otherwise do coercion through memory. This is stupid, but
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),
735 return CGF.Builder.CreateLoad(Tmp);
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
741 // FIXME: Do we need to recurse here?
742 static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val,
743 llvm::Value *DestPtr, bool DestIsVolatile,
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,
757 llvm::StoreInst *SI = CGF.Builder.CreateStore(Val, DestPtr, DestIsVolatile);
763 /// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
764 /// where the source and destination may have different types.
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.
768 static void CreateCoercedStore(llvm::Value *Src,
771 CodeGenFunction &CGF) {
772 llvm::Type *SrcTy = Src->getType();
774 cast<llvm::PointerType>(DstPtr->getType())->getElementType();
775 if (SrcTy == DstTy) {
776 CGF.Builder.CreateStore(Src, DstPtr, DstIsVolatile);
780 uint64_t SrcSize = CGF.CGM.getDataLayout().getTypeAllocSize(SrcTy);
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();
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);
796 uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy);
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);
805 // Otherwise do coercion through memory. This is stupid, but
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.
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),
828 bool CodeGenModule::ReturnTypeUsesSRet(const CGFunctionInfo &FI) {
829 return FI.getReturnInfo().isIndirect();
832 bool CodeGenModule::ReturnTypeUsesFPRet(QualType ResultType) {
833 if (const BuiltinType *BT = ResultType->getAs<BuiltinType>()) {
834 switch (BT->getKind()) {
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);
849 bool 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();
860 llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
861 const CGFunctionInfo &FI = arrangeGlobalDeclaration(GD);
862 return GetFunctionType(FI);
866 CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
868 bool Inserted = FunctionsBeingProcessed.insert(&FI); (void)Inserted;
869 assert(Inserted && "Recursively being processed?");
871 SmallVector<llvm::Type*, 8> argTypes;
872 llvm::Type *resultType = 0;
874 const ABIArgInfo &retAI = FI.getReturnInfo();
875 switch (retAI.getKind()) {
876 case ABIArgInfo::Expand:
877 llvm_unreachable("Invalid ABI kind for return argument");
879 case ABIArgInfo::Extend:
880 case ABIArgInfo::Direct:
881 resultType = retAI.getCoerceToType();
884 case ABIArgInfo::Indirect: {
885 assert(!retAI.getIndirectAlign() && "Align unused on indirect return.");
886 resultType = llvm::Type::getVoidTy(getLLVMContext());
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));
895 case ABIArgInfo::Ignore:
896 resultType = llvm::Type::getVoidTy(getLLVMContext());
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();
907 for (; it != ie; ++it) {
908 const ABIArgInfo &argAI = it->info;
910 // Insert a padding type to ensure proper alignment.
911 if (llvm::Type *PaddingType = argAI.getPaddingType())
912 argTypes.push_back(PaddingType);
914 switch (argAI.getKind()) {
915 case ABIArgInfo::Ignore:
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());
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));
935 argTypes.push_back(argType);
940 case ABIArgInfo::Expand:
941 GetExpandedTypes(it->type, argTypes);
946 bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
947 assert(Erased && "Not in set?");
949 return llvm::FunctionType::get(resultType, argTypes, FI.isVariadic());
952 llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
953 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
954 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
956 if (!isFuncTypeConvertible(FPT))
957 return llvm::StructType::get(getLLVMContext());
959 const CGFunctionInfo *Info;
960 if (isa<CXXDestructorDecl>(MD))
961 Info = &arrangeCXXDestructor(cast<CXXDestructorDecl>(MD), GD.getDtorType());
963 Info = &arrangeCXXMethodDeclaration(MD);
964 return GetFunctionType(*Info);
967 void 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;
975 CallingConv = FI.getEffectiveCallingConvention();
978 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
980 // FIXME: handle sseregparm someday...
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);
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);
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);
1008 if (TargetDecl->hasAttr<MallocAttr>())
1009 RetAttrs.addAttribute(llvm::Attribute::NoAlias);
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);
1021 if (AttrOnCallSite) {
1022 // Attributes that should go on the call site only.
1023 if (!CodeGenOpts.SimplifyLibCalls)
1024 FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
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");
1034 FuncAttrs.addAttribute("no-frame-pointer-elim", "true");
1035 FuncAttrs.addAttribute("no-frame-pointer-elim-non-leaf", "true");
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");
1050 QualType RetTy = FI.getReturnType();
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);
1060 case ABIArgInfo::Direct:
1061 case ABIArgInfo::Ignore:
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));
1073 // sret disables readnone and readonly
1074 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1075 .removeAttribute(llvm::Attribute::ReadNone);
1079 case ABIArgInfo::Expand:
1080 llvm_unreachable("Invalid ABI kind for return argument");
1083 if (RetAttrs.hasAttributes())
1084 PAL.push_back(llvm::
1085 AttributeSet::get(getLLVMContext(),
1086 llvm::AttributeSet::ReturnIndex,
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;
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.
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);
1113 case ABIArgInfo::Direct:
1115 Attrs.addAttribute(llvm::Attribute::InReg);
1117 // FIXME: handle sseregparm someday...
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,
1130 case ABIArgInfo::Indirect:
1132 Attrs.addAttribute(llvm::Attribute::InReg);
1134 if (AI.getIndirectByVal())
1135 Attrs.addAttribute(llvm::Attribute::ByVal);
1137 Attrs.addAlignmentAttr(AI.getIndirectAlign());
1139 // byval disables readnone and readonly.
1140 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1141 .removeAttribute(llvm::Attribute::ReadNone);
1144 case ABIArgInfo::Ignore:
1145 // Skip increment, no matching LLVM parameter.
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();
1159 if (Attrs.hasAttributes())
1160 PAL.push_back(llvm::AttributeSet::get(getLLVMContext(), Index, Attrs));
1163 if (FuncAttrs.hasAttributes())
1164 PAL.push_back(llvm::
1165 AttributeSet::get(getLLVMContext(),
1166 llvm::AttributeSet::FunctionIndex,
1170 /// An argument came in as a promoted argument; demote it back to its
1172 static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF,
1174 llvm::Value *value) {
1175 llvm::Type *varType = CGF.ConvertType(var->getType());
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;
1181 assert((varType->isIntegerTy() || varType->isFloatingPointTy())
1182 && "unexpected promotion type");
1184 if (isa<llvm::IntegerType>(varType))
1185 return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
1187 return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
1190 void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
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);
1206 // FIXME: We no longer need the types from FunctionArgList; lift up and
1209 // Emit allocs for param decls. Give the LLVM Argument nodes names.
1210 llvm::Function::arg_iterator AI = Fn->arg_begin();
1212 // Name the struct return argument.
1213 if (CGM.ReturnTypeUsesSRet(FI)) {
1214 AI->setName("agg.result");
1215 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1217 llvm::Attribute::NoAlias));
1221 assert(FI.arg_size() == Args.size() &&
1222 "Mismatch between function signature & arguments.");
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;
1232 isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
1234 // Skip the dummy padding argument.
1235 if (ArgI.getPaddingType())
1238 switch (ArgI.getKind()) {
1239 case ABIArgInfo::Indirect: {
1240 llvm::Value *V = AI;
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");
1248 // Copy from the incoming argument pointer to the temporary with the
1249 // appropriate alignment.
1251 // FIXME: We should have a common utility for generating an aggregate
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,
1259 llvm::ConstantInt::get(IntPtrTy,
1260 Size.getQuantity()),
1261 ArgI.getIndirectAlign(),
1266 // Load scalar value from indirect argument.
1267 CharUnits Alignment = getContext().getTypeAlignInChars(Ty);
1268 V = EmitLoadOfScalar(V, false, Alignment.getQuantity(), Ty);
1271 V = emitArgumentDemotion(*this, Arg, V);
1273 EmitParmDecl(*Arg, V, ArgNo);
1277 case ABIArgInfo::Extend:
1278 case ABIArgInfo::Direct: {
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;
1287 if (Arg->getType().isRestrictQualified())
1288 AI->addAttr(llvm::AttributeSet::get(getLLVMContext(),
1290 llvm::Attribute::NoAlias));
1292 // Ensure the argument is the correct type.
1293 if (V->getType() != ArgI.getCoerceToType())
1294 V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
1297 V = emitArgumentDemotion(*this, Arg, V);
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);
1307 EmitParmDecl(*Arg, V, ArgNo);
1311 llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->getName());
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());
1320 Alloca->setAlignment(AlignmentToUse);
1321 llvm::Value *V = Alloca;
1322 llvm::Value *Ptr = V; // Pointer to store into.
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()));
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);
1339 cast<llvm::PointerType>(Ptr->getType())->getElementType();
1340 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
1342 if (SrcSize <= DstSize) {
1343 Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy));
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);
1352 llvm::AllocaInst *TempAlloca =
1353 CreateTempAlloca(ArgI.getCoerceToType(), "coerce");
1354 TempAlloca->setAlignment(AlignmentToUse);
1355 llvm::Value *TempV = TempAlloca;
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);
1364 Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse);
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);
1374 // Match to what EmitParmDecl is expecting for this type.
1375 if (CodeGenFunction::hasScalarEvaluationKind(Ty)) {
1376 V = EmitLoadOfScalar(V, false, AlignmentToUse, Ty);
1378 V = emitArgumentDemotion(*this, Arg, V);
1380 EmitParmDecl(*Arg, V, ArgNo);
1381 continue; // Skip ++AI increment, already done.
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
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);
1395 // Name the arguments used in expansion and increment AI.
1397 for (; AI != End; ++AI, ++Index)
1398 AI->setName(Arg->getName() + "." + Twine(Index));
1402 case ABIArgInfo::Ignore:
1403 // Initialize the local variable appropriately.
1404 if (!hasScalarEvaluationKind(Ty))
1405 EmitParmDecl(*Arg, CreateMemTemp(Ty), ArgNo);
1407 EmitParmDecl(*Arg, llvm::UndefValue::get(ConvertType(Arg->getType())),
1410 // Skip increment, no matching LLVM parameter.
1416 assert(AI == Fn->arg_end() && "Argument mismatch!");
1419 static void eraseUnusedBitCasts(llvm::Instruction *insn) {
1420 while (insn->use_empty()) {
1421 llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
1422 if (!bitcast) return;
1424 // This is "safe" because we would have used a ConstantExpr otherwise.
1425 insn = cast<llvm::Instruction>(bitcast->getOperand(0));
1426 bitcast->eraseFromParent();
1430 /// Try to emit a fused autorelease of a return result.
1431 static 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;
1438 llvm::Type *resultType = result->getType();
1440 // result is in a BasicBlock and is therefore an Instruction.
1441 llvm::Instruction *generator = cast<llvm::Instruction>(result);
1443 SmallVector<llvm::Instruction*,4> insnsToKill;
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
1450 generator = cast<llvm::Instruction>(bitcast->getOperand(0));
1452 // Require the generator to be immediately followed by the cast.
1453 if (generator->getNextNode() != bitcast)
1456 insnsToKill.push_back(bitcast);
1460 // %generator = call i8* @objc_retain(i8* %originalResult)
1462 // %generator = call i8* @objc_retainAutoreleasedReturnValue(i8* %originalResult)
1463 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
1464 if (!call) return 0;
1466 bool doRetainAutorelease;
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;
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();
1482 if (isa<llvm::BitCastInst>(prev)) {
1483 prev = prev->getPrevNode();
1486 assert(isa<llvm::CallInst>(prev));
1487 assert(cast<llvm::CallInst>(prev)->getCalledValue() ==
1488 CGF.CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker);
1489 insnsToKill.push_back(prev);
1495 result = call->getArgOperand(0);
1496 insnsToKill.push_back(call);
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);
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();
1511 // Do the fused retain/autorelease if we were asked to.
1512 if (doRetainAutorelease)
1513 result = CGF.EmitARCRetainAutoreleaseReturnValue(result);
1515 // Cast back to the result type.
1516 return CGF.Builder.CreateBitCast(result, resultType);
1519 /// If this is a +1 of the value of an immutable 'self', remove it.
1520 static 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;
1529 // Look for a retain call.
1530 llvm::CallInst *retainCall =
1531 dyn_cast<llvm::CallInst>(result->stripPointerCasts());
1533 retainCall->getCalledValue() != CGF.CGM.getARCEntrypoints().objc_retain)
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))
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));
1553 return CGF.Builder.CreateBitCast(load, resultType);
1556 /// Emit an ARC autorelease of the result of a function.
1558 /// \return the value to actually return from the function
1559 static 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))
1568 // At -O0, try to emit a fused retain/autorelease.
1569 if (CGF.shouldUseFusedARCCalls())
1570 if (llvm::Value *fused = tryEmitFusedAutoreleaseOfResult(CGF, result))
1573 return CGF.EmitARCAutoreleaseReturnValue(result);
1576 /// Heuristically search for a dominating store to the return-value slot.
1577 static 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
1592 llvm::StoreInst *store =
1593 dyn_cast<llvm::StoreInst>(CGF.ReturnValue->use_back());
1594 if (!store) return 0;
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());
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()))
1609 // Okay, the store's basic block dominates the insertion point; we
1610 // can do our thing.
1614 /// Check whether 'this' argument of a callsite matches 'this' of the caller.
1615 static bool checkThisPointer(llvm::Value *ThisArg, llvm::Value *This) {
1616 if (ThisArg == This)
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)
1626 void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
1627 bool EmitRetDbgLoc) {
1628 // Functions with no result always return void.
1629 if (ReturnValue == 0) {
1630 Builder.CreateRetVoid();
1634 llvm::DebugLoc RetDbgLoc;
1635 llvm::Value *RV = 0;
1636 QualType RetTy = FI.getReturnType();
1637 const ABIArgInfo &RetAI = FI.getReturnInfo();
1639 switch (RetAI.getKind()) {
1640 case ABIArgInfo::Indirect: {
1641 switch (getEvaluationKind(RetTy)) {
1644 EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy));
1645 EmitStoreOfComplex(RT,
1646 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy),
1651 // Do nothing; aggregrates get evaluated directly into the destination.
1654 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),
1655 MakeNaturalAlignAddrLValue(CurFn->arg_begin(), RetTy),
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.
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.
1674 RetDbgLoc = SI->getDebugLoc();
1675 // Get the stored value and nuke the now-dead store.
1676 RV = SI->getValueOperand();
1677 SI->eraseFromParent();
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();
1685 // Otherwise, we have to do a simple load.
1687 RV = Builder.CreateLoad(ReturnValue);
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()));
1699 RV = CreateCoercedLoad(V, RetAI.getCoerceToType(), *this);
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);
1713 case ABIArgInfo::Ignore:
1716 case ABIArgInfo::Expand:
1717 llvm_unreachable("Invalid ABI kind for return argument");
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());
1733 llvm::Instruction *Ret = RV ? Builder.CreateRet(RV) : Builder.CreateRetVoid();
1734 if (!RetDbgLoc.isUnknown())
1735 Ret->setDebugLoc(RetDbgLoc);
1738 void 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
1743 llvm::Value *local = GetAddrOfLocalVar(param);
1745 QualType type = param->getType();
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);
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);
1760 args.add(convertTempToRValue(local, type), type);
1763 static bool isProvablyNull(llvm::Value *addr) {
1764 return isa<llvm::ConstantPointerNull>(addr);
1767 static bool isProvablyNonNull(llvm::Value *addr) {
1768 return isa<llvm::AllocaInst>(addr);
1771 /// Emit the actual writing-back of a writeback.
1772 static 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");
1779 llvm::BasicBlock *contBB = 0;
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");
1788 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1789 CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
1790 CGF.EmitBlock(writebackBB);
1793 // Load the value to writeback.
1794 llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
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");
1801 // Perform the writeback.
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);
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);
1815 // Emit the intrinsic use here.
1816 CGF.EmitARCIntrinsicUse(writeback.ToUse);
1818 // Load the old value (primitively).
1819 llvm::Value *oldValue = CGF.EmitLoadOfScalar(srcLV);
1821 // Put the new value in place (primitively).
1822 CGF.EmitStoreOfScalar(value, srcLV, /*init*/ false);
1824 // Release the old value.
1825 CGF.EmitARCRelease(oldValue, srcLV.isARCPreciseLifetime());
1827 // Otherwise, we can just do a normal lvalue store.
1829 CGF.EmitStoreThroughLValue(RValue::get(value), srcLV);
1832 // Jump to the continuation block.
1833 if (!provablyNonNull)
1834 CGF.EmitBlock(contBB);
1837 static 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);
1844 static 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();
1851 /// Emit an argument that's being passed call-by-writeback. That is,
1852 /// we are passing the address of
1853 static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
1854 const ObjCIndirectCopyRestoreExpr *CRE) {
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);
1862 // Otherwise, just emit it as a scalar.
1864 llvm::Value *srcAddr = CGF.EmitScalarExpr(CRE->getSubExpr());
1866 QualType srcAddrType =
1867 CRE->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType();
1868 srcLV = CGF.MakeNaturalAlignAddrLValue(srcAddr, srcAddrType);
1870 llvm::Value *srcAddr = srcLV.getAddress();
1872 // The dest and src types don't necessarily match in LLVM terms
1873 // because of the crazy ObjC compatibility rules.
1875 llvm::PointerType *destType =
1876 cast<llvm::PointerType>(CGF.ConvertType(CRE->getType()));
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)),
1885 // Create the temporary.
1886 llvm::Value *temp = CGF.CreateTempAlloca(destType->getElementType(),
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);
1894 // Zero-initialize it if we're not doing a copy-initialization.
1895 bool shouldCopy = CRE->shouldCopy();
1898 llvm::ConstantPointerNull::get(
1899 cast<llvm::PointerType>(destType->getElementType()));
1900 CGF.Builder.CreateStore(null, temp);
1903 llvm::BasicBlock *contBB = 0;
1904 llvm::BasicBlock *originBB = 0;
1906 // If the address is *not* known to be non-null, we need to switch.
1907 llvm::Value *finalArgument;
1909 bool provablyNonNull = isProvablyNonNull(srcAddr);
1910 if (provablyNonNull) {
1911 finalArgument = temp;
1913 llvm::Value *isNull = CGF.Builder.CreateIsNull(srcAddr, "icr.isnull");
1915 finalArgument = CGF.Builder.CreateSelect(isNull,
1916 llvm::ConstantPointerNull::get(destType),
1917 temp, "icr.argument");
1919 // If we need to copy, then the load has to be conditional, which
1920 // means we need control flow.
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);
1931 llvm::Value *valueToUse = 0;
1933 // Perform a copy if necessary.
1935 RValue srcRV = CGF.EmitLoadOfLValue(srcLV);
1936 assert(srcRV.isScalar());
1938 llvm::Value *src = srcRV.getScalarVal();
1939 src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
1942 // Use an ordinary store, not a store-to-lvalue.
1943 CGF.Builder.CreateStore(src, temp);
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) {
1956 // Finish the control flow if we needed it.
1957 if (shouldCopy && !provablyNonNull) {
1958 llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock();
1959 CGF.EmitBlock(contBB);
1961 // Make a phi for the value to intrinsically use.
1963 llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2,
1965 phiToUse->addIncoming(valueToUse, copyBB);
1966 phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()),
1968 valueToUse = phiToUse;
1974 args.addWriteback(srcLV, temp, valueToUse);
1975 args.add(RValue::get(finalArgument), CRE->getType());
1978 void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
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);
1987 assert(type->isReferenceType() == E->isGLValue() &&
1988 "reference binding to unmaterialized r-value!");
1990 if (E->isGLValue()) {
1991 assert(E->getObjectKind() == OK_Ordinary);
1992 return args.add(EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0),
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);
2005 args.add(EmitAnyExprToTemp(E), type);
2008 // In ObjC ARC mode with no ObjC ARC exception safety, tell the ARC
2009 // optimizer it can aggressively ignore unwind edges.
2011 CodeGenFunction::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());
2018 /// Emits a call to the given no-arguments nounwind runtime function.
2020 CodeGenFunction::EmitNounwindRuntimeCall(llvm::Value *callee,
2021 const llvm::Twine &name) {
2022 return EmitNounwindRuntimeCall(callee, ArrayRef<llvm::Value*>(), name);
2025 /// Emits a call to the given nounwind runtime function.
2027 CodeGenFunction::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();
2035 /// Emits a simple call (never an invoke) to the given no-arguments
2036 /// runtime function.
2038 CodeGenFunction::EmitRuntimeCall(llvm::Value *callee,
2039 const llvm::Twine &name) {
2040 return EmitRuntimeCall(callee, ArrayRef<llvm::Value*>(), name);
2043 /// Emits a simple call (never an invoke) to the given runtime
2046 CodeGenFunction::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());
2054 /// Emits a call or invoke to the given noreturn runtime function.
2055 void CodeGenFunction::EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee,
2056 ArrayRef<llvm::Value*> args) {
2057 if (getInvokeDest()) {
2058 llvm::InvokeInst *invoke =
2059 Builder.CreateInvoke(callee,
2060 getUnreachableBlock(),
2063 invoke->setDoesNotReturn();
2064 invoke->setCallingConv(getRuntimeCC());
2066 llvm::CallInst *call = Builder.CreateCall(callee, args);
2067 call->setDoesNotReturn();
2068 call->setCallingConv(getRuntimeCC());
2069 Builder.CreateUnreachable();
2073 /// Emits a call or invoke instruction to the given nullary runtime
2076 CodeGenFunction::EmitRuntimeCallOrInvoke(llvm::Value *callee,
2077 const Twine &name) {
2078 return EmitRuntimeCallOrInvoke(callee, ArrayRef<llvm::Value*>(), name);
2081 /// Emits a call or invoke instruction to the given runtime function.
2083 CodeGenFunction::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());
2092 CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
2093 const Twine &Name) {
2094 return EmitCallOrInvoke(Callee, ArrayRef<llvm::Value *>(), Name);
2097 /// Emits a call or invoke instruction to the given function, depending
2098 /// on the current state of the EH stack.
2100 CodeGenFunction::EmitCallOrInvoke(llvm::Value *Callee,
2101 ArrayRef<llvm::Value *> Args,
2102 const Twine &Name) {
2103 llvm::BasicBlock *InvokeDest = getInvokeDest();
2105 llvm::Instruction *Inst;
2107 Inst = Builder.CreateCall(Callee, Args, Name);
2109 llvm::BasicBlock *ContBB = createBasicBlock("invoke.cont");
2110 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name);
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);
2122 static void checkArgMatches(llvm::Value *Elt, unsigned &ArgNo,
2123 llvm::FunctionType *FTy) {
2124 if (ArgNo < FTy->getNumParams())
2125 assert(Elt->getType() == FTy->getParamType(ArgNo));
2127 assert(FTy->isVarArg());
2131 void 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);
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);
2148 if (RD->isUnion()) {
2149 const FieldDecl *LargestFD = 0;
2150 CharUnits UnionSize = CharUnits::Zero();
2152 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
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;
2164 RValue FldRV = EmitRValueForField(LV, LargestFD);
2165 ExpandTypeToArgs(LargestFD->getType(), FldRV, Args, IRFuncTy);
2168 for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end();
2172 RValue FldRV = EmitRValueForField(LV, FD);
2173 ExpandTypeToArgs(FD->getType(), FldRV, Args, IRFuncTy);
2176 } else if (Ty->isAnyComplexType()) {
2177 ComplexPairTy CV = RV.getComplexVal();
2178 Args.push_back(CV.first);
2179 Args.push_back(CV.second);
2181 assert(RV.isScalar() &&
2182 "Unexpected non-scalar rvalue during struct expansion.");
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()));
2195 RValue 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;
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();
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());
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();
2220 Value = CreateMemTemp(RetTy);
2221 Args.push_back(Value);
2222 checkArgMatches(Value, IRArgNo, IRFuncTy);
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;
2233 CharUnits TypeAlign = getContext().getTypeAlignInChars(I->Ty);
2235 // Insert a padding argument to ensure proper alignment.
2236 if (llvm::Type *PaddingType = ArgInfo.getPaddingType()) {
2237 Args.push_back(llvm::UndefValue::get(PaddingType));
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());
2251 MakeAddrLValue(Args.back(), I->Ty, TypeAlign);
2254 EmitStoreOfScalar(RV.getScalarVal(), argLV, /*init*/ true);
2256 EmitStoreOfComplex(RV.getComplexVal(), argLV, /*init*/ true);
2258 // Validate argument match.
2259 checkArgMatches(AI, IRArgNo, IRFuncTy);
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);
2284 EmitAggregateCopy(AI, Addr, I->Ty, RV.isVolatileQualified());
2286 // Validate argument match.
2287 checkArgMatches(AI, IRArgNo, IRFuncTy);
2289 // Skip the extra memcpy call.
2290 Args.push_back(Addr);
2292 // Validate argument match.
2293 checkArgMatches(Addr, IRArgNo, IRFuncTy);
2299 case ABIArgInfo::Ignore:
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) {
2309 V = RV.getScalarVal();
2311 V = Builder.CreateLoad(RV.getAggregateAddr());
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));
2320 checkArgMatches(V, IRArgNo, IRFuncTy);
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);
2332 EmitStoreOfComplex(RV.getComplexVal(), SrcLV, /*init*/ true);
2335 SrcPtr = RV.getAggregateAddr();
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()));
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())) {
2352 cast<llvm::PointerType>(SrcPtr->getType())->getElementType();
2353 uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
2354 uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
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;
2366 SrcPtr = Builder.CreateBitCast(SrcPtr,
2367 llvm::PointerType::getUnqual(STy));
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);
2377 // Validate argument match.
2378 checkArgMatches(LI, IRArgNo, IRFuncTy);
2381 // In the simple case, just pass the coerced loaded value.
2382 Args.push_back(CreateCoercedLoad(SrcPtr, ArgInfo.getCoerceToType(),
2385 // Validate argument match.
2386 checkArgMatches(Args.back(), IRArgNo, IRFuncTy);
2392 case ABIArgInfo::Expand:
2393 ExpandTypeToArgs(I->Ty, RV, Args, IRFuncTy);
2394 IRArgNo = Args.size();
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();
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)) {
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
2429 unsigned CallingConv;
2430 CodeGen::AttributeListType AttributeList;
2431 CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList,
2433 llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(),
2436 llvm::BasicBlock *InvokeDest = 0;
2437 if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
2438 llvm::Attribute::NoUnwind))
2439 InvokeDest = getInvokeDest();
2443 CS = Builder.CreateCall(Callee, Args);
2445 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
2446 CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, Args);
2450 *callOrInvoke = CS.getInstruction();
2452 CS.setAttributes(Attrs);
2453 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
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());
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();
2467 // FIXME: For now, emit a dummy basic block because expr emitters in
2468 // generally are not ready to handle emitting expressions at unreachable
2470 EnsureInsertPoint();
2472 // Return a reasonable RValue.
2473 return GetUndefRValue(RetTy);
2476 llvm::Instruction *CI = CS.getInstruction();
2477 if (Builder.isNamePreserving() && !CI->getType()->isVoidTy())
2478 CI->setName("call");
2480 // Emit any writebacks immediately. Arguably this should happen
2481 // after any return-value munging.
2482 if (CallArgs.hasWritebacks())
2483 emitWritebacks(*this, CallArgs);
2485 switch (RetAI.getKind()) {
2486 case ABIArgInfo::Indirect:
2487 return convertTempToRValue(Args[0], RetTy);
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);
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)) {
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));
2504 case TEK_Aggregate: {
2505 llvm::Value *DestPtr = ReturnValue.getValue();
2506 bool DestIsVolatile = ReturnValue.isVolatile();
2509 DestPtr = CreateMemTemp(RetTy, "agg.tmp");
2510 DestIsVolatile = false;
2512 BuildAggStore(*this, CI, DestPtr, DestIsVolatile, false);
2513 return RValue::getAggregate(DestPtr);
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);
2524 llvm_unreachable("bad evaluation kind");
2527 llvm::Value *DestPtr = ReturnValue.getValue();
2528 bool DestIsVolatile = ReturnValue.isVolatile();
2531 DestPtr = CreateMemTemp(RetTy, "coerce");
2532 DestIsVolatile = false;
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()));
2543 CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
2545 return convertTempToRValue(DestPtr, RetTy);
2548 case ABIArgInfo::Expand:
2549 llvm_unreachable("Invalid ABI kind for return argument");
2552 llvm_unreachable("Unhandled ABIArgInfo::Kind");
2555 /* VarArg handling */
2557 llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) {
2558 return CGM.getTypes().getABIInfo().EmitVAArg(VAListAddr, Ty, *this);