27 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/IR/Attributes.h"
29 #include "llvm/IR/CallSite.h"
30 #include "llvm/IR/DataLayout.h"
31 #include "llvm/IR/InlineAsm.h"
32 #include "llvm/IR/Intrinsics.h"
33 #include "llvm/IR/IntrinsicInst.h"
34 #include "llvm/Transforms/Utils/Local.h"
35 using namespace clang;
36 using namespace CodeGen;
48 case CC_AAPCS:
return llvm::CallingConv::ARM_AAPCS;
49 case CC_AAPCS_VFP:
return llvm::CallingConv::ARM_AAPCS_VFP;
102 prefix.append(FTP->param_type_begin(), FTP->param_type_end());
106 FTP->getExtInfo(), required);
123 if (D->
hasAttr<FastCallAttr>())
126 if (D->
hasAttr<ThisCallAttr>())
129 if (D->
hasAttr<VectorCallAttr>())
135 if (PcsAttr *PCS = D->
getAttr<PcsAttr>())
138 if (D->
hasAttr<IntelOclBiccAttr>())
168 *
this,
true, argTypes,
178 assert(!isa<CXXConstructorDecl>(MD) &&
"wrong method for constructors!");
179 assert(!isa<CXXDestructorDecl>(MD) &&
"wrong method for destructors!");
200 if (
auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
210 argTypes.append(FTP->param_type_begin(), FTP->param_type_end());
224 false, argTypes, extInfo,
233 unsigned ExtraArgs) {
236 for (
const auto &Arg : args)
250 false, ArgTypes, Info,
259 if (MD->isInstance())
264 assert(isa<FunctionType>(FTy));
268 if (isa<FunctionNoProtoType>(FTy)) {
271 noProto->getReturnType(),
false,
275 assert(isa<FunctionProtoType>(FTy));
301 for (
const auto *I : MD->
params()) {
309 if (
getContext().getLangOpts().ObjCAutoRefCount &&
310 MD->
hasAttr<NSReturnsRetainedAttr>())
318 false, argTys, einfo, required);
342 assert(MD->
isVirtual() &&
"only virtual memptrs have thunks");
360 ArgTys.push_back(*FTP->param_type_begin());
362 ArgTys.push_back(Context.
IntTy);
377 unsigned numExtraRequiredArgs,
379 assert(args.size() >= numExtraRequiredArgs);
387 if (proto->isVariadic())
388 required =
RequiredArgs(proto->getNumParams() + numExtraRequiredArgs);
396 cast<FunctionNoProtoType>(fnType))) {
402 for (
const auto &arg : args)
418 chainCall ? 1 : 0, chainCall);
437 for (
const auto &Arg : args)
441 false, argTypes, info, required);
451 for (
const auto &Arg : args)
457 false, argTypes, info, required);
465 for (
auto Arg : args)
472 false, argTypes, info, required);
491 assert(std::all_of(argTypes.begin(), argTypes.end(),
497 llvm::FoldingSetNodeID
ID;
499 resultType, argTypes);
501 void *insertPos =
nullptr;
502 CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos);
508 resultType, argTypes, required);
509 FunctionInfos.InsertNode(FI, insertPos);
511 bool inserted = FunctionsBeingProcessed.insert(FI).second;
513 assert(inserted &&
"Recursively being processed?");
526 if (I.info.canHaveCoerceToType() && I.info.getCoerceToType() ==
nullptr)
529 bool erased = FunctionsBeingProcessed.erase(FI); (void)erased;
530 assert(erased &&
"Not in set?");
543 sizeof(ArgInfo) * (argTypes.size() + 1));
545 FI->CallingConvention = llvmCC;
546 FI->EffectiveCallingConvention = llvmCC;
547 FI->ASTCallingConvention = info.
getCC();
548 FI->InstanceMethod = instanceMethod;
549 FI->ChainCall = chainCall;
552 FI->Required = required;
555 FI->ArgStruct =
nullptr;
556 FI->NumArgs = argTypes.size();
557 FI->getArgsBuffer()[0].type = resultType;
558 for (
unsigned i = 0, e = argTypes.size(); i != e; ++i)
559 FI->getArgsBuffer()[i + 1].type = argTypes[i];
569 struct TypeExpansion {
570 enum TypeExpansionKind {
582 const TypeExpansionKind
Kind;
584 TypeExpansion(TypeExpansionKind K) :
Kind(K) {}
585 virtual ~TypeExpansion() {}
588 struct ConstantArrayExpansion : TypeExpansion {
592 ConstantArrayExpansion(
QualType EltTy, uint64_t NumElts)
593 : TypeExpansion(TEK_ConstantArray), EltTy(EltTy), NumElts(NumElts) {}
594 static bool classof(
const TypeExpansion *TE) {
595 return TE->Kind == TEK_ConstantArray;
599 struct RecordExpansion : TypeExpansion {
606 : TypeExpansion(TEK_Record), Bases(Bases), Fields(Fields) {}
607 static bool classof(
const TypeExpansion *TE) {
608 return TE->Kind == TEK_Record;
612 struct ComplexExpansion : TypeExpansion {
616 static bool classof(
const TypeExpansion *TE) {
621 struct NoExpansion : TypeExpansion {
622 NoExpansion() : TypeExpansion(TEK_None) {}
623 static bool classof(
const TypeExpansion *TE) {
624 return TE->Kind == TEK_None;
629 static std::unique_ptr<TypeExpansion>
632 return llvm::make_unique<ConstantArrayExpansion>(
633 AT->getElementType(), AT->getSize().getZExtValue());
640 "Cannot expand structure with flexible array.");
647 for (
const auto *FD : RD->
fields()) {
649 if (FD->isBitField() && FD->getBitWidthValue(Context) == 0)
651 assert(!FD->isBitField() &&
652 "Cannot expand structure with bit-field members.");
654 if (UnionSize < FieldSize) {
655 UnionSize = FieldSize;
660 Fields.push_back(LargestFD);
662 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
663 assert(!CXXRD->isDynamicClass() &&
664 "cannot expand vtable pointers in dynamic classes");
666 Bases.push_back(&BS);
669 for (
const auto *FD : RD->
fields()) {
671 if (FD->isBitField() && FD->getBitWidthValue(Context) == 0)
673 assert(!FD->isBitField() &&
674 "Cannot expand structure with bit-field members.");
675 Fields.push_back(FD);
678 return llvm::make_unique<RecordExpansion>(std::move(Bases),
682 return llvm::make_unique<ComplexExpansion>(CT->getElementType());
684 return llvm::make_unique<NoExpansion>();
689 if (
auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
692 if (
auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
694 for (
auto BS : RExp->Bases)
696 for (
auto FD : RExp->Fields)
700 if (isa<ComplexExpansion>(Exp.get()))
702 assert(isa<NoExpansion>(Exp.get()));
710 if (
auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
711 for (
int i = 0, n = CAExp->NumElts; i < n; i++) {
714 }
else if (
auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
715 for (
auto BS : RExp->Bases)
717 for (
auto FD : RExp->Fields)
719 }
else if (
auto CExp = dyn_cast<ComplexExpansion>(Exp.get())) {
724 assert(isa<NoExpansion>(Exp.get()));
729 void CodeGenFunction::ExpandTypeFromArgs(
732 "Unexpected non-simple lvalue during struct expansion.");
735 if (
auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
736 for (
int i = 0, n = CAExp->NumElts; i < n; i++) {
739 LValue LV = MakeAddrLValue(EltAddr, CAExp->EltTy);
740 ExpandTypeFromArgs(CAExp->EltTy, LV, AI);
742 }
else if (
auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
749 LValue SubLV = MakeAddrLValue(Base, BS->getType());
752 ExpandTypeFromArgs(BS->getType(), SubLV, AI);
754 for (
auto FD : RExp->Fields) {
756 LValue SubLV = EmitLValueForField(LV, FD);
757 ExpandTypeFromArgs(FD->getType(), SubLV, AI);
759 }
else if (
auto CExp = dyn_cast<ComplexExpansion>(Exp.get())) {
763 MakeAddrLValue(RealAddr, CExp->EltTy));
767 MakeAddrLValue(ImagAddr, CExp->EltTy));
769 assert(isa<NoExpansion>(Exp.get()));
774 void CodeGenFunction::ExpandTypeToArgs(
778 if (
auto CAExp = dyn_cast<ConstantArrayExpansion>(Exp.get())) {
780 for (
int i = 0, n = CAExp->NumElts; i < n; i++) {
784 ExpandTypeToArgs(CAExp->EltTy, EltRV, IRFuncTy, IRCallArgs, IRCallArgPos);
786 }
else if (
auto RExp = dyn_cast<RecordExpansion>(Exp.get())) {
796 ExpandTypeToArgs(BS->getType(), BaseRV, IRFuncTy, IRCallArgs,
800 LValue LV = MakeAddrLValue(This, Ty);
801 for (
auto FD : RExp->Fields) {
803 ExpandTypeToArgs(FD->getType(), FldRV, IRFuncTy, IRCallArgs,
806 }
else if (isa<ComplexExpansion>(Exp.get())) {
808 IRCallArgs[IRCallArgPos++] = CV.first;
809 IRCallArgs[IRCallArgPos++] = CV.second;
811 assert(isa<NoExpansion>(Exp.get()));
813 "Unexpected non-scalar rvalue during struct expansion.");
817 if (IRCallArgPos < IRFuncTy->getNumParams() &&
818 V->getType() != IRFuncTy->getParamType(IRCallArgPos))
819 V =
Builder.CreateBitCast(V, IRFuncTy->getParamType(IRCallArgPos));
821 IRCallArgs[IRCallArgPos++] = V;
831 llvm::StructType *SrcSTy,
834 if (SrcSTy->getNumElements() == 0)
return SrcPtr;
836 llvm::Type *FirstElt = SrcSTy->getElementType(0);
842 uint64_t FirstEltSize =
844 if (FirstEltSize < DstSize &&
849 SrcPtr = CGF.
Builder.CreateConstGEP2_32(SrcSTy, SrcPtr, 0, 0,
"coerce.dive");
854 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy))
870 if (Val->getType() == Ty)
873 if (isa<llvm::PointerType>(Val->getType())) {
875 if (isa<llvm::PointerType>(Ty))
876 return CGF.
Builder.CreateBitCast(Val, Ty,
"coerce.val");
882 llvm::Type *DestIntTy = Ty;
883 if (isa<llvm::PointerType>(DestIntTy))
886 if (Val->getType() != DestIntTy) {
888 if (DL.isBigEndian()) {
891 uint64_t SrcSize = DL.getTypeSizeInBits(Val->getType());
892 uint64_t DstSize = DL.getTypeSizeInBits(DestIntTy);
894 if (SrcSize > DstSize) {
895 Val = CGF.
Builder.CreateLShr(Val, SrcSize - DstSize,
"coerce.highbits");
896 Val = CGF.
Builder.CreateTrunc(Val, DestIntTy,
"coerce.val.ii");
898 Val = CGF.
Builder.CreateZExt(Val, DestIntTy,
"coerce.val.ii");
899 Val = CGF.
Builder.CreateShl(Val, DstSize - SrcSize,
"coerce.highbits");
903 Val = CGF.
Builder.CreateIntCast(Val, DestIntTy,
false,
"coerce.val.ii");
907 if (isa<llvm::PointerType>(Ty))
908 Val = CGF.
Builder.CreateIntToPtr(Val, Ty,
"coerce.val.ip");
933 if (llvm::StructType *SrcSTy = dyn_cast<llvm::StructType>(SrcTy)) {
935 SrcTy = cast<llvm::PointerType>(SrcPtr->getType())->
getElementType();
942 if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
943 (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
944 llvm::LoadInst *Load =
950 if (SrcSize >= DstSize) {
958 CGF.
Builder.CreateBitCast(SrcPtr, llvm::PointerType::getUnqual(Ty));
966 llvm::Type *I8PtrTy = CGF.
Builder.getInt8PtrTy();
969 CGF.
Builder.CreateMemCpy(Casted, SrcCasted,
970 llvm::ConstantInt::get(CGF.
IntPtrTy, SrcSize),
983 if (llvm::StructType *STy =
984 dyn_cast<llvm::StructType>(Val->getType())) {
985 const llvm::StructLayout *Layout =
988 for (
unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
991 uint64_t EltOffset = Layout->getElementOffset(i);
1014 llvm::Type *SrcTy = Src->getType();
1017 if (SrcTy == DstTy) {
1025 if (llvm::StructType *DstSTy = dyn_cast<llvm::StructType>(DstTy)) {
1027 DstTy = cast<llvm::PointerType>(DstPtr->getType())->
getElementType();
1032 if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
1033 (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
1043 if (SrcSize <= DstSize) {
1045 CGF.
Builder.CreateBitCast(DstPtr, llvm::PointerType::getUnqual(SrcTy));
1060 llvm::Type *I8PtrTy = CGF.
Builder.getInt8PtrTy();
1063 CGF.
Builder.CreateMemCpy(DstCasted, Casted,
1064 llvm::ConstantInt::get(CGF.
IntPtrTy, DstSize),
1073 class ClangToLLVMArgMapping {
1074 static const unsigned InvalidIndex = ~0U;
1075 unsigned InallocaArgNo;
1077 unsigned TotalIRArgs;
1081 unsigned PaddingArgIndex;
1084 unsigned FirstArgIndex;
1085 unsigned NumberOfArgs;
1088 : PaddingArgIndex(InvalidIndex), FirstArgIndex(InvalidIndex),
1096 bool OnlyRequiredArgs =
false)
1097 : InallocaArgNo(InvalidIndex), SRetArgNo(InvalidIndex), TotalIRArgs(0),
1098 ArgInfo(OnlyRequiredArgs ? FI.getNumRequiredArgs() : FI.arg_size()) {
1099 construct(Context, FI, OnlyRequiredArgs);
1102 bool hasInallocaArg()
const {
return InallocaArgNo != InvalidIndex; }
1103 unsigned getInallocaArgNo()
const {
1104 assert(hasInallocaArg());
1105 return InallocaArgNo;
1108 bool hasSRetArg()
const {
return SRetArgNo != InvalidIndex; }
1109 unsigned getSRetArgNo()
const {
1110 assert(hasSRetArg());
1114 unsigned totalIRArgs()
const {
return TotalIRArgs; }
1116 bool hasPaddingArg(
unsigned ArgNo)
const {
1117 assert(ArgNo < ArgInfo.size());
1118 return ArgInfo[ArgNo].PaddingArgIndex != InvalidIndex;
1120 unsigned getPaddingArgNo(
unsigned ArgNo)
const {
1121 assert(hasPaddingArg(ArgNo));
1122 return ArgInfo[ArgNo].PaddingArgIndex;
1127 std::pair<unsigned, unsigned> getIRArgs(
unsigned ArgNo)
const {
1128 assert(ArgNo < ArgInfo.size());
1129 return std::make_pair(ArgInfo[ArgNo].FirstArgIndex,
1130 ArgInfo[ArgNo].NumberOfArgs);
1135 bool OnlyRequiredArgs);
1140 bool OnlyRequiredArgs) {
1141 unsigned IRArgNo = 0;
1142 bool SwapThisWithSRet =
false;
1147 SRetArgNo = SwapThisWithSRet ? 1 : IRArgNo++;
1158 auto &IRArgs = ArgInfo[ArgNo];
1161 IRArgs.PaddingArgIndex = IRArgNo++;
1167 llvm::StructType *STy = dyn_cast<llvm::StructType>(AI.
getCoerceToType());
1169 IRArgs.NumberOfArgs = STy->getNumElements();
1171 IRArgs.NumberOfArgs = 1;
1176 IRArgs.NumberOfArgs = 1;
1181 IRArgs.NumberOfArgs = 0;
1189 if (IRArgs.NumberOfArgs > 0) {
1190 IRArgs.FirstArgIndex = IRArgNo;
1191 IRArgNo += IRArgs.NumberOfArgs;
1196 if (IRArgNo == 1 && SwapThisWithSRet)
1199 assert(ArgNo == ArgInfo.size());
1202 InallocaArgNo = IRArgNo++;
1204 TotalIRArgs = IRArgNo;
1215 return ReturnTypeUsesSRet(FI) &&
1216 getTargetCodeGenInfo().doesReturnSlotInterfereWithArgs();
1221 switch (BT->getKind()) {
1224 case BuiltinType::Float:
1226 case BuiltinType::Double:
1228 case BuiltinType::LongDouble:
1239 if (BT->getKind() == BuiltinType::LongDouble)
1252 llvm::FunctionType *
1255 bool Inserted = FunctionsBeingProcessed.insert(&FI).second;
1257 assert(Inserted &&
"Recursively being processed?");
1259 llvm::Type *resultType =
nullptr;
1263 llvm_unreachable(
"Invalid ABI kind for return argument");
1276 resultType = llvm::PointerType::get(ty, addressSpace);
1293 ClangToLLVMArgMapping IRFunctionArgs(
getContext(), FI,
true);
1297 if (IRFunctionArgs.hasSRetArg()) {
1301 ArgTypes[IRFunctionArgs.getSRetArgNo()] =
1302 llvm::PointerType::get(Ty, AddressSpace);
1306 if (IRFunctionArgs.hasInallocaArg()) {
1309 ArgTypes[IRFunctionArgs.getInallocaArgNo()] = ArgStruct->getPointerTo();
1316 for (; it != ie; ++it, ++ArgNo) {
1320 if (IRFunctionArgs.hasPaddingArg(ArgNo))
1321 ArgTypes[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
1324 unsigned FirstIRArg, NumIRArgs;
1325 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
1330 assert(NumIRArgs == 0);
1334 assert(NumIRArgs == 1);
1337 ArgTypes[FirstIRArg] = LTy->getPointerTo();
1346 llvm::StructType *st = dyn_cast<llvm::StructType>(argType);
1348 assert(NumIRArgs == st->getNumElements());
1349 for (
unsigned i = 0, e = st->getNumElements(); i != e; ++i)
1350 ArgTypes[FirstIRArg + i] = st->getElementType(i);
1352 assert(NumIRArgs == 1);
1353 ArgTypes[FirstIRArg] = argType;
1359 auto ArgTypesIter = ArgTypes.begin() + FirstIRArg;
1361 assert(ArgTypesIter == ArgTypes.begin() + FirstIRArg + NumIRArgs);
1366 bool Erased = FunctionsBeingProcessed.erase(&FI); (void)Erased;
1367 assert(Erased &&
"Not in set?");
1369 return llvm::FunctionType::get(resultType, ArgTypes, FI.
isVariadic());
1380 if (isa<CXXDestructorDecl>(MD))
1389 const Decl *TargetDecl,
1392 bool AttrOnCallSite) {
1393 llvm::AttrBuilder FuncAttrs;
1394 llvm::AttrBuilder RetAttrs;
1395 bool HasOptnone =
false;
1400 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1404 if (TargetDecl->
hasAttr<ReturnsTwiceAttr>())
1405 FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
1406 if (TargetDecl->
hasAttr<NoThrowAttr>())
1407 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1408 if (TargetDecl->
hasAttr<NoReturnAttr>())
1409 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1410 if (TargetDecl->
hasAttr<NoDuplicateAttr>())
1411 FuncAttrs.addAttribute(llvm::Attribute::NoDuplicate);
1413 if (
const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
1416 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1420 if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->
isVirtual()))
1421 FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
1425 if (TargetDecl->
hasAttr<ConstAttr>()) {
1426 FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
1427 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1428 }
else if (TargetDecl->
hasAttr<PureAttr>()) {
1429 FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
1430 FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
1432 if (TargetDecl->
hasAttr<RestrictAttr>())
1433 RetAttrs.addAttribute(llvm::Attribute::NoAlias);
1434 if (TargetDecl->
hasAttr<ReturnsNonNullAttr>())
1435 RetAttrs.addAttribute(llvm::Attribute::NonNull);
1437 HasOptnone = TargetDecl->
hasAttr<OptimizeNoneAttr>();
1442 if (CodeGenOpts.OptimizeSize)
1443 FuncAttrs.addAttribute(llvm::Attribute::OptimizeForSize);
1444 if (CodeGenOpts.OptimizeSize == 2)
1445 FuncAttrs.addAttribute(llvm::Attribute::MinSize);
1448 if (CodeGenOpts.DisableRedZone)
1449 FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
1450 if (CodeGenOpts.NoImplicitFloat)
1451 FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
1452 if (CodeGenOpts.EnableSegmentedStacks &&
1453 !(TargetDecl && TargetDecl->
hasAttr<NoSplitStackAttr>()))
1454 FuncAttrs.addAttribute(
"split-stack");
1456 if (AttrOnCallSite) {
1458 if (!CodeGenOpts.SimplifyLibCalls)
1459 FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
1460 if (!CodeGenOpts.TrapFuncName.empty())
1461 FuncAttrs.addAttribute(
"trap-func-name", CodeGenOpts.TrapFuncName);
1464 if (!CodeGenOpts.DisableFPElim) {
1465 FuncAttrs.addAttribute(
"no-frame-pointer-elim",
"false");
1466 }
else if (CodeGenOpts.OmitLeafFramePointer) {
1467 FuncAttrs.addAttribute(
"no-frame-pointer-elim",
"false");
1468 FuncAttrs.addAttribute(
"no-frame-pointer-elim-non-leaf");
1470 FuncAttrs.addAttribute(
"no-frame-pointer-elim",
"true");
1471 FuncAttrs.addAttribute(
"no-frame-pointer-elim-non-leaf");
1474 FuncAttrs.addAttribute(
"disable-tail-calls",
1475 llvm::toStringRef(CodeGenOpts.DisableTailCalls));
1476 FuncAttrs.addAttribute(
"less-precise-fpmad",
1477 llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD));
1478 FuncAttrs.addAttribute(
"no-infs-fp-math",
1479 llvm::toStringRef(CodeGenOpts.NoInfsFPMath));
1480 FuncAttrs.addAttribute(
"no-nans-fp-math",
1481 llvm::toStringRef(CodeGenOpts.NoNaNsFPMath));
1482 FuncAttrs.addAttribute(
"unsafe-fp-math",
1483 llvm::toStringRef(CodeGenOpts.UnsafeFPMath));
1484 FuncAttrs.addAttribute(
"use-soft-float",
1485 llvm::toStringRef(CodeGenOpts.SoftFloat));
1486 FuncAttrs.addAttribute(
"stack-protector-buffer-size",
1487 llvm::utostr(CodeGenOpts.SSPBufferSize));
1489 if (!CodeGenOpts.StackRealignment)
1490 FuncAttrs.addAttribute(
"no-realign-stack");
1505 llvm::StringMap<bool> FeatureMap;
1506 for (
auto F :
getTarget().getTargetOpts().Features) {
1507 const char *Name = F.c_str();
1508 bool Enabled = Name[0] ==
'+';
1512 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl);
1514 if (
const auto *TD = FD->
getAttr<TargetAttr>()) {
1515 StringRef FeaturesStr = TD->getFeatures();
1517 FeaturesStr.split(AttrFeatures,
",");
1521 for (
auto &Feature : AttrFeatures) {
1524 Feature = Feature.trim();
1527 if (Feature.startswith(
"arch="))
1528 TargetCPU = Feature.split(
"=").second.trim();
1529 else if (Feature.startswith(
"tune="))
1532 else if (Feature.startswith(
"fpmath="))
1537 else if (Feature.startswith(
"mno-"))
1547 std::vector<std::string> Features;
1548 for (llvm::StringMap<bool>::const_iterator it = FeatureMap.begin(),
1549 ie = FeatureMap.end();
1551 Features.push_back((it->second ?
"+" :
"-") + it->first().str());
1554 if (TargetCPU !=
"")
1555 FuncAttrs.addAttribute(
"target-cpu", TargetCPU);
1556 if (!Features.empty()) {
1557 std::sort(Features.begin(), Features.end());
1558 FuncAttrs.addAttribute(
"target-features",
1559 llvm::join(Features.begin(), Features.end(),
","));
1563 ClangToLLVMArgMapping IRFunctionArgs(
getContext(), FI);
1570 RetAttrs.addAttribute(llvm::Attribute::SExt);
1572 RetAttrs.addAttribute(llvm::Attribute::ZExt);
1576 RetAttrs.addAttribute(llvm::Attribute::InReg);
1584 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1585 .removeAttribute(llvm::Attribute::ReadNone);
1590 llvm_unreachable(
"Invalid ABI kind for return argument");
1596 RetAttrs.addDereferenceableAttr(
getContext().getTypeSizeInChars(PTy)
1598 else if (
getContext().getTargetAddressSpace(PTy) == 0)
1599 RetAttrs.addAttribute(llvm::Attribute::NonNull);
1603 if (RetAttrs.hasAttributes()) {
1604 PAL.push_back(llvm::AttributeSet::get(
1609 if (IRFunctionArgs.hasSRetArg()) {
1610 llvm::AttrBuilder SRETAttrs;
1611 SRETAttrs.addAttribute(llvm::Attribute::StructRet);
1613 SRETAttrs.addAttribute(llvm::Attribute::InReg);
1614 PAL.push_back(llvm::AttributeSet::get(
1615 getLLVMContext(), IRFunctionArgs.getSRetArgNo() + 1, SRETAttrs));
1619 if (IRFunctionArgs.hasInallocaArg()) {
1620 llvm::AttrBuilder Attrs;
1621 Attrs.addAttribute(llvm::Attribute::InAlloca);
1622 PAL.push_back(llvm::AttributeSet::get(
1623 getLLVMContext(), IRFunctionArgs.getInallocaArgNo() + 1, Attrs));
1629 I != E; ++I, ++ArgNo) {
1632 llvm::AttrBuilder Attrs;
1635 if (IRFunctionArgs.hasPaddingArg(ArgNo)) {
1637 PAL.push_back(llvm::AttributeSet::get(
1639 llvm::Attribute::InReg));
1648 Attrs.addAttribute(llvm::Attribute::SExt);
1650 if (getTypes().getABIInfo().shouldSignExtUnsignedType(ParamType))
1651 Attrs.addAttribute(llvm::Attribute::SExt);
1653 Attrs.addAttribute(llvm::Attribute::ZExt);
1658 Attrs.addAttribute(llvm::Attribute::Nest);
1660 Attrs.addAttribute(llvm::Attribute::InReg);
1665 Attrs.addAttribute(llvm::Attribute::InReg);
1668 Attrs.addAttribute(llvm::Attribute::ByVal);
1673 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1674 .removeAttribute(llvm::Attribute::ReadNone);
1683 FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
1684 .removeAttribute(llvm::Attribute::ReadNone);
1691 Attrs.addDereferenceableAttr(
getContext().getTypeSizeInChars(PTy)
1693 else if (
getContext().getTargetAddressSpace(PTy) == 0)
1694 Attrs.addAttribute(llvm::Attribute::NonNull);
1697 if (Attrs.hasAttributes()) {
1698 unsigned FirstIRArg, NumIRArgs;
1699 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
1700 for (
unsigned i = 0; i < NumIRArgs; i++)
1702 FirstIRArg + i + 1, Attrs));
1707 if (FuncAttrs.hasAttributes())
1708 PAL.push_back(llvm::
1710 llvm::AttributeSet::FunctionIndex,
1723 if (value->getType() == varType)
return value;
1725 assert((varType->isIntegerTy() || varType->isFloatingPointTy())
1726 &&
"unexpected promotion type");
1728 if (isa<llvm::IntegerType>(varType))
1729 return CGF.
Builder.CreateTrunc(value, varType,
"arg.unpromote");
1731 return CGF.
Builder.CreateFPCast(value, varType,
"arg.unpromote");
1737 QualType ArgType,
unsigned ArgNo) {
1749 if (
auto ParmNNAttr = PVD->
getAttr<NonNullAttr>())
1756 if (NNAttr->isNonNull(ArgNo))
1765 if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>())
1773 if (
const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
1774 if (FD->hasImplicitReturnZero()) {
1775 QualType RetTy = FD->getReturnType().getUnqualifiedType();
1777 llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
1778 Builder.CreateStore(Zero, ReturnValue);
1785 ClangToLLVMArgMapping IRFunctionArgs(CGM.
getContext(), FI);
1788 FnArgs.reserve(IRFunctionArgs.totalIRArgs());
1789 for (
auto &Arg : Fn->args()) {
1790 FnArgs.push_back(&Arg);
1792 assert(FnArgs.size() == IRFunctionArgs.totalIRArgs());
1797 if (IRFunctionArgs.hasInallocaArg()) {
1798 ArgStruct = FnArgs[IRFunctionArgs.getInallocaArgNo()];
1799 assert(ArgStruct->getType() == FI.
getArgStruct()->getPointerTo());
1803 if (IRFunctionArgs.hasSRetArg()) {
1804 auto AI = FnArgs[IRFunctionArgs.getSRetArgNo()];
1805 AI->setName(
"agg.result");
1806 AI->addAttr(llvm::AttributeSet::get(
getLLVMContext(), AI->getArgNo() + 1,
1807 llvm::Attribute::NoAlias));
1813 enum ValOrPointer { HaveValue = 0, HavePointer = 1 };
1814 typedef llvm::PointerIntPair<llvm::Value *, 1> ValueAndIsPtr;
1816 ArgVals.reserve(Args.size());
1822 assert(FI.
arg_size() == Args.size() &&
1823 "Mismatch between function signature & arguments.");
1826 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
1827 i != e; ++i, ++info_it, ++ArgNo) {
1833 isa<ParmVarDecl>(Arg) && cast<ParmVarDecl>(Arg)->isKNRPromoted();
1835 unsigned FirstIRArg, NumIRArgs;
1836 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
1840 assert(NumIRArgs == 0);
1844 ArgVals.push_back(ValueAndIsPtr(V, HavePointer));
1849 assert(NumIRArgs == 1);
1852 if (!hasScalarEvaluationKind(Ty)) {
1856 llvm::Value *AlignedTemp = CreateMemTemp(Ty,
"coerce");
1863 llvm::Type *I8PtrTy =
Builder.getInt8PtrTy();
1869 llvm::ConstantInt::get(IntPtrTy,
1875 ArgVals.push_back(ValueAndIsPtr(V, HavePointer));
1883 ArgVals.push_back(ValueAndIsPtr(V, HaveValue));
1895 assert(NumIRArgs == 1);
1896 auto AI = FnArgs[FirstIRArg];
1899 if (
const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(Arg)) {
1901 PVD->getFunctionScopeIndex()))
1904 llvm::Attribute::NonNull));
1906 QualType OTy = PVD->getOriginalType();
1907 if (
const auto *ArrTy =
1914 QualType ETy = ArrTy->getElementType();
1915 uint64_t ArrSize = ArrTy->getSize().getZExtValue();
1918 llvm::AttrBuilder Attrs;
1919 Attrs.addDereferenceableAttr(
1920 getContext().getTypeSizeInChars(ETy).getQuantity()*ArrSize);
1922 AI->getArgNo() + 1, Attrs));
1926 llvm::Attribute::NonNull));
1929 }
else if (
const auto *ArrTy =
1938 llvm::Attribute::NonNull));
1941 const auto *AVAttr = PVD->getAttr<AlignValueAttr>();
1943 if (
const auto *TOTy = dyn_cast<TypedefType>(OTy))
1944 AVAttr = TOTy->getDecl()->getAttr<AlignValueAttr>();
1947 EmitScalarExpr(AVAttr->getAlignment());
1948 llvm::ConstantInt *AlignmentCI =
1949 cast<llvm::ConstantInt>(AlignmentValue);
1950 unsigned Alignment =
1951 std::min((
unsigned) AlignmentCI->getZExtValue(),
1952 +llvm::Value::MaximumAlignment);
1954 llvm::AttrBuilder Attrs;
1955 Attrs.addAlignmentAttr(Alignment);
1957 AI->getArgNo() + 1, Attrs));
1964 llvm::Attribute::NoAlias));
1974 dyn_cast_or_null<CXXMethodDecl>(CurCodeDecl)) {
1975 if (MD->
isVirtual() && Arg == CXXABIThisDecl)
1977 adjustThisParameterInVirtualFunctionPrologue(*
this, CurGD, V);
1985 if (V->getType() != LTy)
1986 V =
Builder.CreateBitCast(V, LTy);
1988 ArgVals.push_back(ValueAndIsPtr(V, HaveValue));
1992 llvm::AllocaInst *Alloca = CreateMemTemp(Ty, Arg->
getName());
1996 unsigned AlignmentToUse =
1998 AlignmentToUse = std::max(AlignmentToUse,
1999 (
unsigned)
getContext().getDeclAlign(Arg).getQuantity());
2001 Alloca->setAlignment(AlignmentToUse);
2009 Ptr =
Builder.CreateConstGEP1_32(
Builder.getInt8Ty(), Ptr, Offs);
2010 Ptr =
Builder.CreateBitCast(Ptr,
2017 llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.
getCoerceToType());
2019 STy->getNumElements() > 1) {
2020 uint64_t SrcSize = CGM.
getDataLayout().getTypeAllocSize(STy);
2023 uint64_t DstSize = CGM.
getDataLayout().getTypeAllocSize(DstTy);
2025 if (SrcSize <= DstSize) {
2026 Ptr =
Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(STy));
2028 assert(STy->getNumElements() == NumIRArgs);
2029 for (
unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2030 auto AI = FnArgs[FirstIRArg + i];
2031 AI->setName(Arg->
getName() +
".coerce" + Twine(i));
2033 Builder.CreateStore(AI, EltPtr);
2036 llvm::AllocaInst *TempAlloca =
2038 TempAlloca->setAlignment(AlignmentToUse);
2041 assert(STy->getNumElements() == NumIRArgs);
2042 for (
unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2043 auto AI = FnArgs[FirstIRArg + i];
2044 AI->setName(Arg->
getName() +
".coerce" + Twine(i));
2047 Builder.CreateStore(AI, EltPtr);
2050 Builder.CreateMemCpy(Ptr, TempV, DstSize, AlignmentToUse);
2054 assert(NumIRArgs == 1);
2055 auto AI = FnArgs[FirstIRArg];
2056 AI->setName(Arg->
getName() +
".coerce");
2063 V = EmitLoadOfScalar(V,
false, AlignmentToUse, Ty, Arg->
getLocStart());
2066 ArgVals.push_back(ValueAndIsPtr(V, HaveValue));
2068 ArgVals.push_back(ValueAndIsPtr(V, HavePointer));
2077 llvm::AllocaInst *Alloca = CreateMemTemp(Ty);
2080 LValue LV = MakeAddrLValue(Alloca, Ty, Align);
2081 ArgVals.push_back(ValueAndIsPtr(Alloca, HavePointer));
2083 auto FnArgIter = FnArgs.begin() + FirstIRArg;
2084 ExpandTypeFromArgs(Ty, LV, FnArgIter);
2085 assert(FnArgIter == FnArgs.begin() + FirstIRArg + NumIRArgs);
2086 for (
unsigned i = 0, e = NumIRArgs; i != e; ++i) {
2087 auto AI = FnArgs[FirstIRArg + i];
2088 AI->setName(Arg->
getName() +
"." + Twine(i));
2094 assert(NumIRArgs == 0);
2096 if (!hasScalarEvaluationKind(Ty)) {
2097 ArgVals.push_back(ValueAndIsPtr(CreateMemTemp(Ty), HavePointer));
2100 ArgVals.push_back(ValueAndIsPtr(U, HaveValue));
2107 for (
int I = Args.size() - 1; I >= 0; --I)
2108 EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(),
2111 for (
unsigned I = 0, E = Args.size(); I != E; ++I)
2112 EmitParmDecl(*Args[I], ArgVals[I].getPointer(), ArgVals[I].getInt(),
2118 while (insn->use_empty()) {
2119 llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
2120 if (!bitcast)
return;
2123 insn = cast<llvm::Instruction>(bitcast->getOperand(0));
2124 bitcast->eraseFromParent();
2132 llvm::BasicBlock *BB = CGF.
Builder.GetInsertBlock();
2133 if (BB->empty())
return nullptr;
2134 if (&BB->back() != result)
return nullptr;
2136 llvm::Type *resultType = result->getType();
2139 llvm::Instruction *generator = cast<llvm::Instruction>(result);
2145 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
2148 generator = cast<llvm::Instruction>(bitcast->getOperand(0));
2151 if (generator->getNextNode() != bitcast)
2154 insnsToKill.push_back(bitcast);
2161 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
2162 if (!call)
return nullptr;
2164 bool doRetainAutorelease;
2167 doRetainAutorelease =
true;
2170 doRetainAutorelease =
false;
2178 llvm::Instruction *prev = call->getPrevNode();
2180 if (isa<llvm::BitCastInst>(prev)) {
2181 prev = prev->getPrevNode();
2184 assert(isa<llvm::CallInst>(prev));
2185 assert(cast<llvm::CallInst>(prev)->getCalledValue() ==
2187 insnsToKill.push_back(prev);
2193 result = call->getArgOperand(0);
2194 insnsToKill.push_back(call);
2198 while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
2199 if (!bitcast->hasOneUse())
break;
2200 insnsToKill.push_back(bitcast);
2201 result = bitcast->getOperand(0);
2206 i = insnsToKill.begin(), e = insnsToKill.end(); i != e; ++i)
2207 (*i)->eraseFromParent();
2210 if (doRetainAutorelease)
2214 return CGF.
Builder.CreateBitCast(result, resultType);
2222 dyn_cast_or_null<ObjCMethodDecl>(CGF.
CurCodeDecl);
2223 if (!method)
return nullptr;
2225 if (!self->getType().isConstQualified())
return nullptr;
2228 llvm::CallInst *retainCall =
2229 dyn_cast<llvm::CallInst>(result->stripPointerCasts());
2235 llvm::Value *retainedValue = retainCall->getArgOperand(0);
2236 llvm::LoadInst *load =
2237 dyn_cast<llvm::LoadInst>(retainedValue->stripPointerCasts());
2238 if (!load || load->isAtomic() || load->isVolatile() ||
2245 llvm::Type *resultType = result->getType();
2247 assert(retainCall->use_empty());
2248 retainCall->eraseFromParent();
2251 return CGF.
Builder.CreateBitCast(load, resultType);
2281 llvm::BasicBlock *IP = CGF.
Builder.GetInsertBlock();
2282 if (IP->empty())
return nullptr;
2283 llvm::Instruction *I = &IP->back();
2286 for (llvm::BasicBlock::reverse_iterator II = IP->rbegin(),
2289 if (llvm::IntrinsicInst *Intrinsic =
2290 dyn_cast<llvm::IntrinsicInst>(&*II)) {
2291 if (Intrinsic->getIntrinsicID() == llvm::Intrinsic::lifetime_end) {
2292 const llvm::Value *CastAddr = Intrinsic->getArgOperand(1);
2296 if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II))
2304 llvm::StoreInst *store = dyn_cast<llvm::StoreInst>(I);
2305 if (!store)
return nullptr;
2306 if (store->getPointerOperand() != CGF.
ReturnValue)
return nullptr;
2307 assert(!store->isAtomic() && !store->isVolatile());
2311 llvm::StoreInst *store =
2312 dyn_cast<llvm::StoreInst>(CGF.
ReturnValue->user_back());
2313 if (!store)
return nullptr;
2317 assert(!store->isAtomic() && !store->isVolatile());
2321 llvm::BasicBlock *StoreBB = store->getParent();
2322 llvm::BasicBlock *IP = CGF.
Builder.GetInsertBlock();
2323 while (IP != StoreBB) {
2324 if (!(IP = IP->getSinglePredecessor()))
2336 if (CurCodeDecl && CurCodeDecl->hasAttr<NakedAttr>()) {
2348 llvm::DebugLoc RetDbgLoc;
2357 assert(hasAggregateEvaluationKind(RetTy));
2359 llvm::Function::arg_iterator EI = CurFn->arg_end();
2364 RV =
Builder.CreateLoad(SRet,
"sret");
2369 auto AI = CurFn->arg_begin();
2372 switch (getEvaluationKind(RetTy)) {
2375 EmitLoadOfComplex(MakeNaturalAlignAddrLValue(ReturnValue, RetTy),
2377 EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(AI, RetTy),
2385 EmitStoreOfScalar(
Builder.CreateLoad(ReturnValue),
2386 MakeNaturalAlignAddrLValue(AI, RetTy),
2402 if (llvm::StoreInst *SI =
2407 if (EmitRetDbgLoc && !AutoreleaseResult)
2408 RetDbgLoc = SI->getDebugLoc();
2410 RV = SI->getValueOperand();
2411 SI->eraseFromParent();
2414 if (ReturnValue->use_empty() && isa<llvm::AllocaInst>(ReturnValue)) {
2415 cast<llvm::AllocaInst>(ReturnValue)->eraseFromParent();
2416 ReturnValue =
nullptr;
2421 RV =
Builder.CreateLoad(ReturnValue);
2440 if (AutoreleaseResult) {
2441 assert(getLangOpts().ObjCAutoRefCount &&
2453 llvm_unreachable(
"Invalid ABI kind for return argument");
2456 llvm::Instruction *Ret;
2458 if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute)) {
2459 if (
auto RetNNAttr = CurGD.getDecl()->getAttr<ReturnsNonNullAttr>()) {
2462 RV, llvm::Constant::getNullValue(RV->getType()));
2463 llvm::Constant *StaticData[] = {
2464 EmitCheckSourceLocation(EndLoc),
2465 EmitCheckSourceLocation(RetNNAttr->getLocation()),
2467 EmitCheck(std::make_pair(Cond, SanitizerKind::ReturnsNonnullAttribute),
2468 "nonnull_return", StaticData,
None);
2473 Ret =
Builder.CreateRetVoid();
2477 Ret->setDebugLoc(std::move(RetDbgLoc));
2490 llvm::UndefValue::get(IRTy->getPointerTo()->getPointerTo());
2491 Placeholder = CGF.
Builder.CreateLoad(Placeholder);
2514 if (!hasScalarEvaluationKind(ref->getPointeeType()))
2523 "cannot emit delegate call arguments for inalloca arguments!");
2525 args.
add(convertTempToRValue(local, type, loc), type);
2529 return isa<llvm::ConstantPointerNull>(addr);
2533 return isa<llvm::AllocaInst>(addr);
2542 "shouldn't have writeback for provably null argument");
2544 llvm::BasicBlock *contBB =
nullptr;
2549 if (!provablyNonNull) {
2554 CGF.
Builder.CreateCondBr(isNull, contBB, writebackBB);
2562 value = CGF.
Builder.CreateBitCast(value,
2564 "icr.writeback-cast");
2573 if (writeback.
ToUse) {
2598 if (!provablyNonNull)
2615 I = Cleanups.rbegin(), E = Cleanups.rend(); I != E; ++I) {
2617 I->IsActiveIP->eraseFromParent();
2624 return uop->getSubExpr();
2652 llvm::PointerType *destType =
2675 llvm::ConstantPointerNull::get(
2676 cast<llvm::PointerType>(destType->getElementType()));
2677 CGF.
Builder.CreateStore(null, temp);
2680 llvm::BasicBlock *contBB =
nullptr;
2681 llvm::BasicBlock *originBB =
nullptr;
2687 if (provablyNonNull) {
2688 finalArgument = temp;
2692 finalArgument = CGF.
Builder.CreateSelect(isNull,
2693 llvm::ConstantPointerNull::get(destType),
2694 temp,
"icr.argument");
2699 originBB = CGF.
Builder.GetInsertBlock();
2702 CGF.
Builder.CreateCondBr(isNull, contBB, copyBB);
2704 condEval.
begin(CGF);
2716 src = CGF.
Builder.CreateBitCast(src, destType->getElementType(),
2720 CGF.
Builder.CreateStore(src, temp);
2734 if (shouldCopy && !provablyNonNull) {
2735 llvm::BasicBlock *copyBB = CGF.
Builder.GetInsertBlock();
2740 llvm::PHINode *phiToUse = CGF.
Builder.CreatePHI(valueToUse->getType(), 2,
2742 phiToUse->addIncoming(valueToUse, copyBB);
2743 phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()),
2745 valueToUse = phiToUse;
2756 assert(!StackBase && !StackCleanup.isValid());
2760 StackBase = CGF.
Builder.CreateCall(F, {},
"inalloca.save");
2767 CGF.
Builder.CreateStore(StackBase, StackBaseMem);
2770 assert(StackCleanup.isValid());
2779 CGF.
Builder.CreateCall(F, StackBase);
2787 if (!SanOpts.has(SanitizerKind::NonnullAttribute) || !FD)
2790 unsigned ArgNo = PVD ? PVD->getFunctionScopeIndex() : ParmNum;
2798 Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType()));
2799 llvm::Constant *StaticData[] = {
2800 EmitCheckSourceLocation(ArgLoc),
2801 EmitCheckSourceLocation(NNAttr->getLocation()),
2802 llvm::ConstantInt::get(Int32Ty, ArgNo + 1),
2804 EmitCheck(std::make_pair(Cond, SanitizerKind::NonnullAttribute),
2805 "nonnull_arg", StaticData,
None);
2813 unsigned ParamsToSkip) {
2818 bool HasInAllocaArgs =
false;
2820 I != E && !HasInAllocaArgs; ++I)
2822 if (HasInAllocaArgs) {
2823 assert(
getTarget().getTriple().getArch() == llvm::Triple::x86);
2828 size_t CallArgsStart = Args.size();
2829 for (
int I = ArgTypes.size() - 1; I >= 0; --I) {
2831 EmitCallArg(Args, *Arg, ArgTypes[I]);
2832 EmitNonNullArgCheck(Args.back().RV, ArgTypes[I], Arg->
getExprLoc(),
2833 CalleeDecl, ParamsToSkip + I);
2838 std::reverse(Args.begin() + CallArgsStart, Args.end());
2842 for (
unsigned I = 0, E = ArgTypes.size(); I != E; ++I) {
2844 assert(Arg != ArgEnd);
2845 EmitCallArg(Args, *Arg, ArgTypes[I]);
2846 EmitNonNullArgCheck(Args.back().RV, ArgTypes[I], Arg->
getExprLoc(),
2847 CalleeDecl, ParamsToSkip + I);
2855 : Addr(Addr), Ty(Ty) {}
2874 if ((disabledDebugInfo = isa<CXXDefaultArgExpr>(E) && CGF.
getDebugInfo()))
2878 if (disabledDebugInfo)
2887 = dyn_cast<ObjCIndirectCopyRestoreExpr>(E)) {
2888 assert(getLangOpts().ObjCAutoRefCount);
2894 "reference binding to unmaterialized r-value!");
2898 return args.
add(EmitReferenceBindingToExpr(E), type);
2901 bool HasAggregateEvalKind = hasAggregateEvaluationKind(type);
2906 if (HasAggregateEvalKind &&
2914 Slot = CreateAggTemp(type,
"agg.tmp");
2917 bool DestroyedInCallee =
2920 if (DestroyedInCallee)
2923 EmitAggExpr(E, Slot);
2927 if (DestroyedInCallee) {
2933 llvm::Instruction *IsActive =
Builder.CreateUnreachable();
2939 if (HasAggregateEvalKind && isa<ImplicitCastExpr>(E) &&
2941 LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
2956 args.
add(EmitAnyExprToTemp(E), type);
2959 QualType CodeGenFunction::getVarArgType(
const Expr *Arg) {
2963 if (!
getTarget().getTriple().isOSWindows())
2980 CodeGenFunction::AddObjCARCExceptionMetadata(llvm::Instruction *Inst) {
2983 Inst->setMetadata(
"clang.arc.no_objc_arc_exceptions",
2990 const llvm::Twine &name) {
2991 return EmitNounwindRuntimeCall(callee, None, name);
2998 const llvm::Twine &name) {
2999 llvm::CallInst *call = EmitRuntimeCall(callee, args, name);
3000 call->setDoesNotThrow();
3008 const llvm::Twine &name) {
3009 return EmitRuntimeCall(callee, None, name);
3017 const llvm::Twine &name) {
3018 llvm::CallInst *call =
Builder.CreateCall(callee, args, name);
3019 call->setCallingConv(getRuntimeCC());
3026 if (getInvokeDest()) {
3027 llvm::InvokeInst *invoke =
3029 getUnreachableBlock(),
3032 invoke->setDoesNotReturn();
3033 invoke->setCallingConv(getRuntimeCC());
3035 llvm::CallInst *call =
Builder.CreateCall(callee, args);
3036 call->setDoesNotReturn();
3037 call->setCallingConv(getRuntimeCC());
3046 const Twine &name) {
3047 return EmitRuntimeCallOrInvoke(callee,
None, name);
3054 const Twine &name) {
3055 llvm::CallSite callSite = EmitCallOrInvoke(callee, args, name);
3056 callSite.setCallingConv(getRuntimeCC());
3062 const Twine &Name) {
3063 return EmitCallOrInvoke(Callee,
None, Name);
3071 const Twine &Name) {
3072 llvm::BasicBlock *InvokeDest = getInvokeDest();
3074 llvm::Instruction *Inst;
3076 Inst =
Builder.CreateCall(Callee, Args, Name);
3078 llvm::BasicBlock *ContBB = createBasicBlock(
"invoke.cont");
3079 Inst =
Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, Name);
3086 AddObjCARCExceptionMetadata(Inst);
3088 return llvm::CallSite(Inst);
3101 void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old,
3103 DeferredReplacements.push_back(std::make_pair(Old, New));
3110 const Decl *TargetDecl,
3111 llvm::Instruction **callOrInvoke) {
3119 llvm::FunctionType *IRFuncTy =
3120 cast<llvm::FunctionType>(
3125 llvm::AllocaInst *ArgMemory =
nullptr;
3126 if (llvm::StructType *ArgStruct = CallInfo.
getArgStruct()) {
3128 llvm::AllocaInst *AI;
3130 IP = IP->getNextNode();
3131 AI =
new llvm::AllocaInst(ArgStruct,
"argmem", IP);
3133 AI = CreateTempAlloca(ArgStruct,
"argmem");
3135 AI->setUsedWithInAlloca(
true);
3136 assert(AI->isUsedWithInAlloca() && !AI->isStaticAlloca());
3140 ClangToLLVMArgMapping IRFunctionArgs(CGM.
getContext(), CallInfo);
3146 size_t UnusedReturnSize = 0;
3150 SRetPtr = CreateMemTemp(RetTy);
3151 if (HaveInsertPoint() && ReturnValue.
isUnused()) {
3154 if (EmitLifetimeStart(size, SRetPtr))
3155 UnusedReturnSize = size;
3158 if (IRFunctionArgs.hasSRetArg()) {
3159 IRCallArgs[IRFunctionArgs.getSRetArgNo()] = SRetPtr;
3162 Builder.CreateStructGEP(ArgMemory->getAllocatedType(), ArgMemory,
3164 Builder.CreateStore(SRetPtr, Addr);
3168 assert(CallInfo.
arg_size() == CallArgs.size() &&
3169 "Mismatch between function signature & arguments.");
3172 for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
3173 I != E; ++I, ++info_it, ++ArgNo) {
3180 if (IRFunctionArgs.hasPaddingArg(ArgNo))
3181 IRCallArgs[IRFunctionArgs.getPaddingArgNo(ArgNo)] =
3184 unsigned FirstIRArg, NumIRArgs;
3185 std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
3189 assert(NumIRArgs == 0);
3190 assert(
getTarget().getTriple().getArch() == llvm::Triple::x86);
3193 llvm::Instruction *Placeholder =
3195 CGBuilderTy::InsertPoint IP =
Builder.saveIP();
3196 Builder.SetInsertPoint(Placeholder);
3198 Builder.CreateStructGEP(ArgMemory->getAllocatedType(), ArgMemory,
3201 deferPlaceholderReplacement(Placeholder, Addr);
3205 Builder.CreateStructGEP(ArgMemory->getAllocatedType(), ArgMemory,
3207 unsigned AS = Addr->getType()->getPointerAddressSpace();
3212 if (Addr->getType() != MemType)
3213 Addr =
Builder.CreateBitCast(Addr, MemType);
3214 LValue argLV = MakeAddrLValue(Addr, I->Ty, TypeAlign);
3221 assert(NumIRArgs == 1);
3224 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
3227 IRCallArgs[FirstIRArg] = AI;
3229 LValue argLV = MakeAddrLValue(AI, I->Ty, TypeAlign);
3243 const unsigned RVAddrSpace = Addr->getType()->getPointerAddressSpace();
3244 const unsigned ArgAddrSpace =
3245 (FirstIRArg < IRFuncTy->getNumParams()
3246 ? IRFuncTy->getParamType(FirstIRArg)->getPointerAddressSpace()
3250 llvm::getOrEnforceKnownAlignment(Addr, Align, *TD) < Align) ||
3253 llvm::AllocaInst *AI = CreateMemTemp(I->Ty);
3254 if (Align > AI->getAlignment())
3255 AI->setAlignment(Align);
3256 IRCallArgs[FirstIRArg] = AI;
3260 IRCallArgs[FirstIRArg] = Addr;
3267 assert(NumIRArgs == 0);
3275 assert(NumIRArgs == 1);
3284 V->getType()->isIntegerTy())
3289 if (FirstIRArg < IRFuncTy->getNumParams() &&
3290 V->getType() != IRFuncTy->getParamType(FirstIRArg))
3291 V =
Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg));
3292 IRCallArgs[FirstIRArg] = V;
3300 SrcPtr = CreateMemTemp(I->Ty,
"coerce");
3301 SrcAlign = TypeAlign;
3302 LValue SrcLV = MakeAddrLValue(SrcPtr, I->Ty, TypeAlign);
3307 SrcAlign = TypeAlign;
3313 SrcPtr =
Builder.CreateConstGEP1_32(
Builder.getInt8Ty(), SrcPtr, Offs);
3314 SrcPtr =
Builder.CreateBitCast(SrcPtr,
3321 llvm::StructType *STy =
3326 uint64_t SrcSize = CGM.
getDataLayout().getTypeAllocSize(SrcTy);
3327 uint64_t DstSize = CGM.
getDataLayout().getTypeAllocSize(STy);
3333 if (SrcSize < DstSize) {
3334 llvm::AllocaInst *TempAlloca
3335 = CreateTempAlloca(STy, SrcPtr->getName() +
".coerce");
3336 Builder.CreateMemCpy(TempAlloca, SrcPtr, SrcSize, 0);
3337 SrcPtr = TempAlloca;
3339 SrcPtr =
Builder.CreateBitCast(SrcPtr,
3340 llvm::PointerType::getUnqual(STy));
3343 assert(NumIRArgs == STy->getNumElements());
3344 for (
unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
3346 llvm::LoadInst *LI =
Builder.CreateLoad(EltPtr);
3348 LI->setAlignment(1);
3349 IRCallArgs[FirstIRArg + i] = LI;
3353 assert(NumIRArgs == 1);
3354 IRCallArgs[FirstIRArg] =
3363 unsigned IRArgPos = FirstIRArg;
3364 ExpandTypeToArgs(I->Ty, RV, IRFuncTy, IRCallArgs, IRArgPos);
3365 assert(IRArgPos == FirstIRArg + NumIRArgs);
3378 cast<llvm::PointerType>(Callee->getType())->getAddressSpace();
3379 Callee =
Builder.CreateBitCast(
3380 Callee, getTypes().
GetFunctionType(CallInfo)->getPointerTo(CalleeAS));
3382 llvm::Type *LastParamTy =
3383 IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1);
3384 if (Arg->getType() != LastParamTy) {
3388 llvm::StructType *DeclaredTy = cast<llvm::StructType>(
3390 assert(DeclaredTy->getNumElements() == FullTy->getNumElements());
3391 for (llvm::StructType::element_iterator DI = DeclaredTy->element_begin(),
3392 DE = DeclaredTy->element_end(),
3393 FI = FullTy->element_begin();
3394 DI != DE; ++DI, ++FI)
3397 Arg =
Builder.CreateBitCast(Arg, LastParamTy);
3400 assert(IRFunctionArgs.hasInallocaArg());
3401 IRCallArgs[IRFunctionArgs.getInallocaArgNo()] = Arg;
3410 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Callee))
3411 if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) {
3412 llvm::PointerType *CurPT=cast<llvm::PointerType>(Callee->getType());
3413 llvm::FunctionType *CurFT =
3414 cast<llvm::FunctionType>(CurPT->getElementType());
3415 llvm::FunctionType *ActualFT = CalleeF->getFunctionType();
3417 if (CE->getOpcode() == llvm::Instruction::BitCast &&
3418 ActualFT->getReturnType() == CurFT->getReturnType() &&
3419 ActualFT->getNumParams() == CurFT->getNumParams() &&
3420 ActualFT->getNumParams() == IRCallArgs.size() &&
3421 (CurFT->isVarArg() || !ActualFT->isVarArg())) {
3422 bool ArgsMatch =
true;
3423 for (
unsigned i = 0, e = ActualFT->getNumParams(); i != e; ++i)
3424 if (ActualFT->getParamType(i) != CurFT->getParamType(i)) {
3437 assert(IRCallArgs.size() == IRFuncTy->getNumParams() || IRFuncTy->isVarArg());
3438 for (
unsigned i = 0; i < IRCallArgs.size(); ++i) {
3440 if (IRFunctionArgs.hasInallocaArg() &&
3441 i == IRFunctionArgs.getInallocaArgNo())
3443 if (i < IRFuncTy->getNumParams())
3444 assert(IRCallArgs[i]->getType() == IRFuncTy->getParamType(i));
3451 llvm::AttributeSet Attrs = llvm::AttributeSet::get(
getLLVMContext(),
3454 llvm::BasicBlock *InvokeDest =
nullptr;
3455 if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
3456 llvm::Attribute::NoUnwind) ||
3457 currentFunctionUsesSEHTry())
3458 InvokeDest = getInvokeDest();
3462 CS =
Builder.CreateCall(Callee, IRCallArgs);
3464 llvm::BasicBlock *Cont = createBasicBlock(
"invoke.cont");
3465 CS =
Builder.CreateInvoke(Callee, Cont, InvokeDest, IRCallArgs);
3469 *callOrInvoke = CS.getInstruction();
3471 if (CurCodeDecl && CurCodeDecl->hasAttr<FlattenAttr>() &&
3472 !CS.hasFnAttr(llvm::Attribute::NoInline))
3474 Attrs.addAttribute(
getLLVMContext(), llvm::AttributeSet::FunctionIndex,
3475 llvm::Attribute::AlwaysInline);
3478 if (isSEHTryScope())
3480 Attrs.addAttribute(
getLLVMContext(), llvm::AttributeSet::FunctionIndex,
3481 llvm::Attribute::NoInline);
3483 CS.setAttributes(Attrs);
3484 CS.setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
3489 AddObjCARCExceptionMetadata(CS.getInstruction());
3494 if (CS.doesNotReturn()) {
3495 if (UnusedReturnSize)
3496 EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize),
3500 Builder.ClearInsertionPoint();
3505 EnsureInsertPoint();
3508 return GetUndefRValue(RetTy);
3511 llvm::Instruction *CI = CS.getInstruction();
3512 if (
Builder.isNamePreserving() && !CI->getType()->isVoidTy())
3513 CI->setName(
"call");
3529 if (UnusedReturnSize)
3530 EmitLifetimeEnd(llvm::ConstantInt::get(Int64Ty, UnusedReturnSize),
3538 return GetUndefRValue(RetTy);
3544 switch (getEvaluationKind(RetTy)) {
3552 bool DestIsVolatile = ReturnValue.
isVolatile();
3556 DestPtr = CreateMemTemp(RetTy,
"agg.tmp");
3557 DestIsVolatile =
false;
3559 BuildAggStore(*
this, CI, DestPtr, DestIsVolatile, DestAlign);
3566 if (V->getType() != RetIRTy)
3567 V =
Builder.CreateBitCast(V, RetIRTy);
3571 llvm_unreachable(
"bad evaluation kind");
3575 bool DestIsVolatile = ReturnValue.
isVolatile();
3579 DestPtr = CreateMemTemp(RetTy,
"coerce");
3580 DestIsVolatile =
false;
3587 StorePtr =
Builder.CreateBitCast(StorePtr,
Builder.getInt8PtrTy());
3590 StorePtr =
Builder.CreateBitCast(StorePtr,
3601 llvm_unreachable(
"Invalid ABI kind for return argument");
3604 llvm_unreachable(
"Unhandled ABIArgInfo::Kind");
3607 if (Ret.
isScalar() && TargetDecl) {
3608 if (
const auto *AA = TargetDecl->
getAttr<AssumeAlignedAttr>()) {
3610 if (
const auto *
Offset = AA->getOffset())
3611 OffsetValue = EmitScalarExpr(
Offset);
3613 llvm::Value *Alignment = EmitScalarExpr(AA->getAlignment());
3614 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(Alignment);
3615 EmitAlignmentAssumption(Ret.
getScalarVal(), AlignmentCI->getZExtValue(),
static CanQual< Type > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
bool useObjCFP2RetForComplexLongDouble() const
Check whether _Complex long double should use the "fp2ret" flavor of Objective-C message passing on t...
ExprObjectKind getObjectKind() const
void getExpandedTypes(QualType Ty, SmallVectorImpl< llvm::Type * >::iterator &TI)
void end(CodeGenFunction &CGF)
virtual llvm::Value * EmitVAArg(llvm::Value *VAListAddr, QualType Ty, CodeGen::CodeGenFunction &CGF) const =0
StringRef getName() const
bool useObjCFPRetForRealType(RealType T) const
Check whether the given real type should use the "fpret" flavor of Objective-C message passing on thi...
bool isCanonicalAsParam() const
Determines if this canonical type is furthermore canonical as a parameter. The parameter-canonicaliza...
bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)
Return true iff the given type uses 'sret' when used as a return type.
CodeGenTypes & getTypes()
llvm::Type * ConvertTypeForMem(QualType T)
CanQualType getReturnType() const
ExtInfo withCallingConv(CallingConv cc) const
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
static CanQual< FunctionProtoType > GetFormalType(const CXXMethodDecl *MD)
Returns the canonical formal type of the given C++ method.
CXXCtorType getCtorType() const
unsigned getInAllocaFieldIndex() const
static void emitWriteback(CodeGenFunction &CGF, const CallArgList::Writeback &writeback)
Emit the actual writing-back of a writeback.
ARCEntrypoints & getARCEntrypoints() const
static llvm::Value * emitAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result)
static const CGFunctionInfo & arrangeFreeFunctionLikeCall(CodeGenTypes &CGT, CodeGenModule &CGM, const CallArgList &args, const FunctionType *fnType, unsigned numExtraRequiredArgs, bool chainCall)
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
const TargetInfo & getTarget() const
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, const FunctionDecl *FD, unsigned ParmNum)
Create a check for a function parameter that may potentially be declared as non-null.
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static bool isProvablyNull(llvm::Value *addr)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
CGCXXABI & getCXXABI() const
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
bool hasFlexibleArrayMember() const
ASTContext & getContext() const
const llvm::DataLayout & getDataLayout() const
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
RValue asAggregateRValue() const
static const NonNullAttr * getNonNullAttr(const Decl *FD, const ParmVarDecl *PVD, QualType ArgType, unsigned ArgNo)
static CGFunctionInfo * create(unsigned llvmCC, bool instanceMethod, bool chainCall, const FunctionType::ExtInfo &extInfo, CanQualType resultType, ArrayRef< CanQualType > argTypes, RequiredArgs required)
static int getExpansionSize(QualType Ty, const ASTContext &Context)
bool isFuncTypeConvertible(const FunctionType *FT)
bool isBlockPointerType() const
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
static llvm::Value * CreateCoercedLoad(llvm::Value *SrcPtr, llvm::Type *Ty, CharUnits SrcAlign, CodeGenFunction &CGF)
virtual void computeInfo(CodeGen::CGFunctionInfo &FI) const =0
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, llvm::Value *This)
const CGFunctionInfo & arrangeFreeFunctionDeclaration(QualType ResTy, const FunctionArgList &Args, const FunctionType::ExtInfo &Info, bool isVariadic)
Represents a C++ constructor within a class.
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e.g., it is an unsigned integer type or a vector.
static llvm::Value * emitArgumentDemotion(CodeGenFunction &CGF, const VarDecl *var, llvm::Value *value)
llvm::Value * getAddress() const
void freeArgumentMemory(CodeGenFunction &CGF) const
Default closure variant of a ctor.
llvm::Value * getValue() const
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
bool areArgsDestroyedLeftToRightInCallee() const
llvm::Constant * objc_retainAutoreleasedReturnValue
id objc_retainAutoreleasedReturnValue(id);
void setCoerceToType(llvm::Type *T)
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
static unsigned ClangCallConvToLLVMCallConv(CallingConv CC)
static void EmitInitStoreOfNonAggregate(CodeGenFunction &CGF, RValue Src, LValue Dst)
Store a non-aggregate value to an address to initialize it. For initialization, a non-atomic store wi...
static const CGFunctionInfo & arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod, SmallVectorImpl< CanQualType > &prefix, CanQual< FunctionProtoType > FTP)
bool shouldUseFusedARCCalls()
const CGFunctionInfo & arrangeCXXStructorDeclaration(const CXXMethodDecl *MD, StructorType Type)
llvm::Value * ReturnValue
llvm::Type * ConvertTypeForMem(QualType T)
const CGFunctionInfo & arrangeFreeFunctionType(CanQual< FunctionProtoType > Ty)
ParmVarDecl - Represents a parameter to a function.
bool isObjCRetainableType() const
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
const ArgInfo * const_arg_iterator
static bool isProvablyNonNull(llvm::Value *addr)
virtual bool hasMostDerivedReturn(GlobalDecl GD) const
const_arg_iterator arg_end() const
An object to manage conditionally-evaluated expressions.
ExtInfo withProducesResult(bool producesResult) const
static void emitWritebacks(CodeGenFunction &CGF, const CallArgList &args)
void EmitCallArgs(CallArgList &Args, const T *CallArgTypeInfo, CallExpr::const_arg_iterator ArgBeg, CallExpr::const_arg_iterator ArgEnd, const FunctionDecl *CalleeDecl=nullptr, unsigned ParamsToSkip=0)
EmitCallArgs - Emit call arguments for a function.
void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc)
CGDebugInfo * getDebugInfo()
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
bool isReferenceType() const
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
bool isAnyPointerType() const
StructorType getFromDtorType(CXXDtorType T)
llvm::CallInst * EmitRuntimeCall(llvm::Value *callee, const Twine &name="")
bool getInAllocaSRet() const
Return true if this field of an inalloca struct should be returned to implement a struct return calli...
llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *value)
static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args, const ObjCIndirectCopyRestoreExpr *CRE)
const CGFunctionInfo & arrangeLLVMFunctionInfo(CanQualType returnType, bool instanceMethod, bool chainCall, ArrayRef< CanQualType > argTypes, FunctionType::ExtInfo info, RequiredArgs args)
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee, ArrayRef< llvm::Value * > Args, const Twine &Name="")
void addWriteback(LValue srcLV, llvm::Value *temporary, llvm::Value *toUse)
llvm::StructType * getArgStruct() const
Get the struct type used to represent all the arguments in memory.
llvm::Type * getCoerceToType() const
bool getCanBeFlattened() const
unsigned getRegParm() const
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param IfCond Not a nullptr if if clause was nullptr *otherwise *param PrivateVars List of references to private variables for the task *directive *param PrivateCopies List of private copies for each private variable in *p PrivateVars *param FirstprivateVars List of references to private variables for the *task directive *param FirstprivateCopies List of private copies for each private variable *in p FirstprivateVars *param FirstprivateInits List of references to auto generated variables *used for initialization of a single array element Used if firstprivate *variable is of array type *param Dependences List of dependences for the task construct
const Decl * getDecl() const
void addArgCleanupDeactivation(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *IsActiveIP)
unsigned getEffectiveCallingConvention() const
void EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value * > args)
Emits a call or invoke to the given noreturn runtime function.
unsigned getIndirectAlign() const
static bool hasScalarEvaluationKind(QualType T)
RValue EmitCall(const CGFunctionInfo &FnInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, const Decl *TargetDecl=nullptr, llvm::Instruction **callOrInvoke=nullptr)
CharUnits getAlignment() const
static llvm::Value * tryEmitFusedAutoreleaseOfResult(CodeGenFunction &CGF, llvm::Value *result)
Try to emit a fused autorelease of a return result.
const TargetInfo & getTargetInfo() const
Qualifiers::ObjCLifetime getObjCLifetime() const
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
QualType getReturnType() const
const CXXRecordDecl * getParent() const
field_range fields() const
DisableDebugLocationUpdates(CodeGenFunction &CGF, const Expr *E)
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
llvm::Value * getAggregateAddr() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
const CGFunctionInfo & arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD, QualType receiverType)
bool isVariadic() const
Whether this function is variadic.
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Def If non-NULL, and the type refers to some kind of declaration that can be completed (such as a C s...
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
An ordinary object is located at an address in memory.
QualType getCanonicalTypeInternal() const
void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType)
EmitCallArg - Emit a single call argument.
void begin(CodeGenFunction &CGF)
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
static CanQualType GetThisType(ASTContext &Context, const CXXRecordDecl *RD)
unsigned getNumRequiredArgs() const
llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
ExtInfo getExtInfo() const
CanQualType getCanonicalTypeUnqualified() const
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
const TargetCodeGenInfo & getTargetCodeGenInfo()
writeback_const_range writebacks() const
const TargetInfo & getTarget() const
ArrayRef< CallArgCleanup > getCleanupsToDeactivate() const
void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)
ID
Defines the set of possible language-specific address spaces.
QualType getPointeeType() const
llvm::Value * ToUse
A value to "use" after the writeback, or null.
bool isSignedIntegerOrEnumerationType() const
static AggValueSlot createPlaceholderSlot(CodeGenFunction &CGF, QualType Ty)
CXXDtorType getDtorType() const
CGCXXABI & getCXXABI() const
static bool isInAllocaArgument(CGCXXABI &ABI, QualType type)
static CanQualType GetReturnType(QualType RetTy)
llvm::Value * GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
const CGFunctionInfo & arrangeNullaryFunction()
static void CreateCoercedStore(llvm::Value *Src, llvm::Value *DstPtr, bool DstIsVolatile, CharUnits DstAlign, CodeGenFunction &CGF)
bool usesInAlloca() const
Return true if this function uses inalloca arguments.
Represents a C++ destructor within a class.
const ParmVarDecl * getParamDecl(unsigned i) const
ASTContext & getContext() const
~DisableDebugLocationUpdates()
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
ImplicitParamDecl * getSelfDecl() const
void add(RValue rvalue, QualType type, bool needscopy=false)
static void eraseUnusedBitCasts(llvm::Instruction *insn)
bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI)
static llvm::StoreInst * findDominatingStoreToReturnValue(CodeGenFunction &CGF)
Heuristically search for a dominating store to the return-value slot.
virtual bool HasThisReturn(GlobalDecl GD) const
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
void Profile(llvm::FoldingSetNodeID &ID)
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=None)
llvm::Type * getPaddingType() const
ARCPreciseLifetime_t isARCPreciseLifetime() const
bool isUnsignedIntegerOrEnumerationType() const
static llvm::Value * CoerceIntOrPtrToIntOrPtr(llvm::Value *Val, llvm::Type *Ty, CodeGenFunction &CGF)
CallingConv
CallingConv - Specifies the calling convention that a function uses.
bool hasWritebacks() const
static llvm::Value * EnterStructPointerForCoercedAccess(llvm::Value *SrcPtr, llvm::StructType *SrcSTy, uint64_t DstSize, CodeGenFunction &CGF)
std::string CPU
If given, the name of the target CPU to generate code for.
bool isNothrow(const ASTContext &Ctx, bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification. If this depends on t...
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
llvm::Value * Temporary
The temporary alloca.
bool ReturnTypeUsesFPRet(QualType ResultType)
Return true iff the given type uses 'fpret' when used as a return type.
static const Expr * maybeGetUnaryAddrOfOperand(const Expr *E)
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
void EmitARCIntrinsicUse(ArrayRef< llvm::Value * > values)
unsigned getNumParams() const
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
llvm::Constant * objc_retain
id objc_retain(id);
virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args, const FunctionNoProtoType *fnType) const
bool isConstantSizeType() const
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
Deactive a cleanup that was created in an active state.
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
bool getPaddingInReg() const
Represents a static or instance method of a struct/union/class.
bool isReturnsRetained() const
CanQualType getCanonicalParamType(QualType T) const
Return the canonical parameter type corresponding to the specific potentially non-canonical one...
static RValue getAggregate(llvm::Value *V, bool Volatile=false)
void allocateArgumentMemory(CodeGenFunction &CGF)
const ConstantArrayType * getAsConstantArrayType(QualType T) const
llvm::InlineAsm * retainAutoreleasedReturnValueMarker
virtual void setFeatureEnabled(llvm::StringMap< bool > &Features, StringRef Name, bool Enabled) const
Enable or disable a specific target feature; the feature name must be valid.
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
const CodeGenOptions & getCodeGenOpts() const
const LangOptions & getLangOpts() const
llvm::LLVMContext & getLLVMContext()
QualType getReturnType() const
bool ReturnTypeUsesFP2Ret(QualType ResultType)
Return true iff the given type uses 'fp2ret' when used as a return type.
const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required)
Arrange a call to a C++ method, passing the given arguments.
static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val, llvm::Value *DestPtr, bool DestIsVolatile, CharUnits DestAlign)
CXXCtorType
C++ constructor types.
SourceLocation getExprLoc() const LLVM_READONLY
const CGFunctionInfo & arrangeCXXMethodType(const CXXRecordDecl *RD, const FunctionProtoType *FTP)
const CGFunctionInfo & arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *type)
void setExternallyDestructed(bool destructed=true)
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
bool isSRetAfterThis() const
bool canHaveCoerceToType() const
static const Type * getElementType(const Expr *BaseExpr)
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
unsigned getDirectOffset() const
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
CodeGenFunction::ComplexPairTy ComplexPairTy
CXXDtorType toCXXDtorType(StructorType T)
virtual void buildStructorSignature(const CXXMethodDecl *MD, StructorType T, SmallVectorImpl< CanQualType > &ArgTys)=0
const CGFunctionInfo & arrangeFunctionDeclaration(const FunctionDecl *FD)
bool getProducesResult() const
void ConstructAttributeList(const CGFunctionInfo &Info, const Decl *TargetDecl, AttributeListType &PAL, unsigned &CallingConv, bool AttrOnCallSite)
llvm::IntegerType * IntPtrTy
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
CallingConv getCC() const
SourceLocation getLocStart() const LLVM_READONLY
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, bool Volatile, unsigned Alignment, QualType Ty, llvm::MDNode *TBAAInfo=nullptr, bool isInit=false, QualType TBAABaseTy=QualType(), uint64_t TBAAOffset=0)
const VariableArrayType * getAsVariableArrayType(QualType T) const
static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)
StructorType getFromCtorType(CXXCtorType T)
static bool classof(const OMPClause *T)
TargetOptions & getTargetOpts() const
Retrieve the target options.
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
static llvm::Value * tryRemoveRetainOfSelf(CodeGenFunction &CGF, llvm::Value *result)
If this is a +1 of the value of an immutable 'self', remove it.
Implements C++ ABI-specific code generation functions.
llvm::PointerType * Int8PtrTy
const CGFunctionInfo & arrangeMSMemberPointerThunk(const CXXMethodDecl *MD)
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
static std::unique_ptr< TypeExpansion > getTypeExpansion(QualType Ty, const ASTContext &Context)
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
ABIArgInfo & getReturnInfo()
Represents a base class of a C++ class.
llvm::MDNode * getNoObjCARCExceptionsMetadata()
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
llvm::Type * GetFunctionTypeForVTable(GlobalDecl GD)
llvm::Value * getAddr() const
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Represents a C++ struct/union/class.
BoundNodesTreeBuilder *const Builder
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual const CXXRecordDecl * getThisArgumentTypeForMethod(const CXXMethodDecl *MD)
bool isUsingInAlloca() const
Returns if we're using an inalloca struct to pass arguments in memory.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
llvm::Type * ConvertType(QualType T)
void EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args)
CallingConv getDefaultCallingConvention(bool isVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const =0
Returns how an argument of the given record type should be passed.
LValue EmitLValue(const Expr *E)
llvm::Instruction * getStackBase() const
const TargetInfo & getTarget() const
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
Copying closure variant of a ctor.
Defines the clang::TargetInfo interface.
const_arg_iterator arg_begin() const
bool getIndirectByVal() const
stable_iterator getInnermostEHScope() const
static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows)
bool getHasRegParm() const
const CGFunctionInfo & arrangeMSCtorClosure(const CXXConstructorDecl *CD, CXXCtorType CT)
void pushStackRestore(CleanupKind kind, llvm::Value *SPMem)
unsigned getTargetAddressSpace(QualType T) const
static void deactivateArgCleanupsBeforeCall(CodeGenFunction &CGF, const CallArgList &CallArgs)
const ABIInfo & getABIInfo() const
llvm::Value * EmitVAArg(llvm::Value *VAListAddr, QualType Ty)
static RValue get(llvm::Value *V)
unsigned arg_size() const
llvm::Value * EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, unsigned Alignment, QualType Ty, SourceLocation Loc, llvm::MDNode *TBAAInfo=nullptr, QualType TBAABaseTy=QualType(), uint64_t TBAAOffset=0)
bool isVolatileQualified() const
const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)
static AggValueSlot forAddr(llvm::Value *addr, CharUnits align, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
CXXCtorType toCXXCtorType(StructorType T)
bool getIndirectRealign() const
CharUnits alignmentAtOffset(CharUnits offset)
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
bool isIntegerType() const
Expr * IgnoreParens() LLVM_READONLY
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
const CGFunctionInfo & arrangeCXXConstructorCall(const CallArgList &Args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraArgs)
Arrange a call to a C++ method, passing the given arguments.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.