Skip to content

Commit 238c3dc

Browse files
nikicnikic
authored
[CodeGen][Mips] Remove fp128 libcall list (#153798)
Mips requires fp128 args/returns to be passed differently than i128. It handles this by inspecting the pre-legalization type. However, for soft float libcalls, the original type is currently not provided (it will look like a i128 call). To work around that, MIPS maintains a list of libcalls working on fp128. This patch removes that list by providing the original, pre-softening type to calling convention lowering. This is done by carrying additional information in CallLoweringInfo, as we unfortunately do need both types (we want the un-softened type for OrigTy, but we need the softened type for the actual register assignment etc.) This is in preparation for completely removing all the custom pre-analysis code in the Mips backend and replacing it with use of OrigTy.
1 parent 790bee9 commit 238c3dc

File tree

9 files changed

+236
-253
lines changed

9 files changed

+236
-253
lines changed

‎llvm/include/llvm/CodeGen/TargetLowering.h‎

Lines changed: 19 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -301,6 +301,9 @@ class LLVM_ABI TargetLoweringBase {
301301
public:
302302
Value *Val;
303303
SDValue Node;
304+
/// Original unlegalized argument type.
305+
Type *OrigTy;
306+
/// Same as OrigTy, or partially legalized for soft float libcalls.
304307
Type *Ty;
305308
bool IsSExt : 1;
306309
bool IsZExt : 1;
@@ -321,9 +324,9 @@ class LLVM_ABI TargetLoweringBase {
321324
Type *IndirectType = nullptr;
322325

323326
ArgListEntry(Value *Val, SDValue Node, Type *Ty)
324-
: Val(Val), Node(Node), Ty(Ty), IsSExt(false), IsZExt(false),
325-
IsNoExt(false), IsInReg(false), IsSRet(false), IsNest(false),
326-
IsByVal(false), IsByRef(false), IsInAlloca(false),
327+
: Val(Val), Node(Node), OrigTy(Ty), Ty(Ty), IsSExt(false),
328+
IsZExt(false), IsNoExt(false), IsInReg(false), IsSRet(false),
329+
IsNest(false), IsByVal(false), IsByRef(false), IsInAlloca(false),
327330
IsPreallocated(false), IsReturned(false), IsSwiftSelf(false),
328331
IsSwiftAsync(false), IsSwiftError(false), IsCFGuardTarget(false) {}
329332

@@ -4677,6 +4680,9 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
46774680
/// implementation.
46784681
struct CallLoweringInfo {
46794682
SDValue Chain;
4683+
/// Original unlegalized return type.
4684+
Type *OrigRetTy = nullptr;
4685+
/// Same as OrigRetTy, or partially legalized for soft float libcalls.
46804686
Type *RetTy = nullptr;
46814687
bool RetSExt : 1;
46824688
bool RetZExt : 1;
@@ -4731,6 +4737,14 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
47314737
// setCallee with target/module-specific attributes
47324738
CallLoweringInfo &setLibCallee(CallingConv::ID CC, Type *ResultType,
47334739
SDValue Target, ArgListTy &&ArgsList) {
4740+
return setLibCallee(CC, ResultType, ResultType, Target,
4741+
std::move(ArgsList));
4742+
}
4743+
4744+
CallLoweringInfo &setLibCallee(CallingConv::ID CC, Type *ResultType,
4745+
Type *OrigResultType, SDValue Target,
4746+
ArgListTy &&ArgsList) {
4747+
OrigRetTy = OrigResultType;
47344748
RetTy = ResultType;
47354749
Callee = Target;
47364750
CallConv = CC;
@@ -4745,7 +4759,7 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
47454759
CallLoweringInfo &setCallee(CallingConv::ID CC, Type *ResultType,
47464760
SDValue Target, ArgListTy &&ArgsList,
47474761
AttributeSet ResultAttrs = {}) {
4748-
RetTy = ResultType;
4762+
RetTy = OrigRetTy = ResultType;
47494763
IsInReg = ResultAttrs.hasAttribute(Attribute::InReg);
47504764
RetSExt = ResultAttrs.hasAttribute(Attribute::SExt);
47514765
RetZExt = ResultAttrs.hasAttribute(Attribute::ZExt);
@@ -4761,7 +4775,7 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
47614775
CallLoweringInfo &setCallee(Type *ResultType, FunctionType *FTy,
47624776
SDValue Target, ArgListTy &&ArgsList,
47634777
const CallBase &Call) {
4764-
RetTy = ResultType;
4778+
RetTy = OrigRetTy = ResultType;
47654779

47664780
IsInReg = Call.hasRetAttr(Attribute::InReg);
47674781
DoesNotReturn =

‎llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp‎

Lines changed: 21 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -10998,11 +10998,17 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
1099810998
SmallVector<Type *, 4> RetOrigTys;
1099910999
SmallVector<TypeSize, 4> Offsets;
1100011000
auto &DL = CLI.DAG.getDataLayout();
11001-
ComputeValueTypes(DL, CLI.RetTy, RetOrigTys, &Offsets);
11001+
ComputeValueTypes(DL, CLI.OrigRetTy, RetOrigTys, &Offsets);
1100211002

1100311003
SmallVector<EVT, 4> RetVTs;
11004-
for (Type *Ty : RetOrigTys)
11005-
RetVTs.push_back(getValueType(DL, Ty));
11004+
if (CLI.RetTy != CLI.OrigRetTy) {
11005+
assert(RetOrigTys.size() == 1 &&
11006+
"Only supported for non-aggregate returns");
11007+
RetVTs.push_back(getValueType(DL, CLI.RetTy));
11008+
} else {
11009+
for (Type *Ty : RetOrigTys)
11010+
RetVTs.push_back(getValueType(DL, Ty));
11011+
}
1100611012

1100711013
if (CLI.IsPostTypeLegalization) {
1100811014
// If we are lowering a libcall after legalization, split the return type.
@@ -11053,7 +11059,7 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
1105311059
CLI.getArgs().insert(CLI.getArgs().begin(), Entry);
1105411060
CLI.NumFixedArgs += 1;
1105511061
CLI.getArgs()[0].IndirectType = CLI.RetTy;
11056-
CLI.RetTy = Type::getVoidTy(Context);
11062+
CLI.RetTy = CLI.OrigRetTy = Type::getVoidTy(Context);
1105711063

1105811064
// sret demotion isn't compatible with tail-calls, since the sret argument
1105911065
// points into the callers stack frame.
@@ -11110,17 +11116,23 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
1111011116
CLI.Outs.clear();
1111111117
CLI.OutVals.clear();
1111211118
for (unsigned i = 0, e = Args.size(); i != e; ++i) {
11113-
SmallVector<Type *, 4> ArgTys;
11114-
ComputeValueTypes(DL, Args[i].Ty, ArgTys);
11119+
SmallVector<Type *, 4> OrigArgTys;
11120+
ComputeValueTypes(DL, Args[i].OrigTy, OrigArgTys);
1111511121
// FIXME: Split arguments if CLI.IsPostTypeLegalization
1111611122
Type *FinalType = Args[i].Ty;
1111711123
if (Args[i].IsByVal)
1111811124
FinalType = Args[i].IndirectType;
1111911125
bool NeedsRegBlock = functionArgumentNeedsConsecutiveRegisters(
1112011126
FinalType, CLI.CallConv, CLI.IsVarArg, DL);
11121-
for (unsigned Value = 0, NumValues = ArgTys.size(); Value != NumValues;
11127+
for (unsigned Value = 0, NumValues = OrigArgTys.size(); Value != NumValues;
1112211128
++Value) {
11123-
Type *ArgTy = ArgTys[Value];
11129+
Type *OrigArgTy = OrigArgTys[Value];
11130+
Type *ArgTy = OrigArgTy;
11131+
if (Args[i].Ty != Args[i].OrigTy) {
11132+
assert(Value == 0 && "Only supported for non-aggregate arguments");
11133+
ArgTy = Args[i].Ty;
11134+
}
11135+
1112411136
EVT VT = getValueType(DL, ArgTy);
1112511137
SDValue Op = SDValue(Args[i].Node.getNode(),
1112611138
Args[i].Node.getResNo() + Value);
@@ -11254,7 +11266,7 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
1125411266
// For scalable vectors the scalable part is currently handled
1125511267
// by individual targets, so we just use the known minimum size here.
1125611268
ISD::OutputArg MyFlags(
11257-
Flags, Parts[j].getValueType().getSimpleVT(), VT, ArgTy, i,
11269+
Flags, Parts[j].getValueType().getSimpleVT(), VT, OrigArgTy, i,
1125811270
j * Parts[j].getValueType().getStoreSize().getKnownMinValue());
1125911271
if (NumParts > 1 && j == 0)
1126011272
MyFlags.Flags.setSplit();

‎llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp‎

Lines changed: 11 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -169,6 +169,10 @@ TargetLowering::makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT,
169169
? OpsTypeOverrides[i]
170170
: NewOp.getValueType().getTypeForEVT(*DAG.getContext());
171171
TargetLowering::ArgListEntry Entry(NewOp, Ty);
172+
if (CallOptions.IsSoften)
173+
Entry.OrigTy =
174+
CallOptions.OpsVTBeforeSoften[i].getTypeForEVT(*DAG.getContext());
175+
172176
Entry.IsSExt =
173177
shouldSignExtendTypeInLibCall(Entry.Ty, CallOptions.IsSigned);
174178
Entry.IsZExt = !Entry.IsSExt;
@@ -188,18 +192,21 @@ TargetLowering::makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT,
188192
DAG.getExternalSymbol(LibcallName, getPointerTy(DAG.getDataLayout()));
189193

190194
Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
195+
Type *OrigRetTy = RetTy;
191196
TargetLowering::CallLoweringInfo CLI(DAG);
192197
bool signExtend = shouldSignExtendTypeInLibCall(RetTy, CallOptions.IsSigned);
193198
bool zeroExtend = !signExtend;
194199

195-
if (CallOptions.IsSoften &&
196-
!shouldExtendTypeInLibCall(CallOptions.RetVTBeforeSoften)) {
197-
signExtend = zeroExtend = false;
200+
if (CallOptions.IsSoften) {
201+
OrigRetTy = CallOptions.RetVTBeforeSoften.getTypeForEVT(*DAG.getContext());
202+
if (!shouldExtendTypeInLibCall(CallOptions.RetVTBeforeSoften))
203+
signExtend = zeroExtend = false;
198204
}
199205

200206
CLI.setDebugLoc(dl)
201207
.setChain(InChain)
202-
.setLibCallee(getLibcallCallingConv(LC), RetTy, Callee, std::move(Args))
208+
.setLibCallee(getLibcallCallingConv(LC), RetTy, OrigRetTy, Callee,
209+
std::move(Args))
203210
.setNoReturn(CallOptions.DoesNotReturn)
204211
.setDiscardResult(!CallOptions.IsReturnValueUsed)
205212
.setIsPostTypeLegalization(CallOptions.IsPostTypeLegalization)

‎llvm/lib/Target/Mips/MipsCCState.cpp‎

Lines changed: 13 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -12,42 +12,17 @@
1212

1313
using namespace llvm;
1414

15-
bool MipsCCState::isF128SoftLibCall(const char *CallSym) {
16-
const char *const LibCalls[] = {
17-
"__addtf3", "__divtf3", "__eqtf2", "__extenddftf2",
18-
"__extendsftf2", "__fixtfdi", "__fixtfsi", "__fixtfti",
19-
"__fixunstfdi", "__fixunstfsi", "__fixunstfti", "__floatditf",
20-
"__floatsitf", "__floattitf", "__floatunditf", "__floatunsitf",
21-
"__floatuntitf", "__getf2", "__gttf2", "__letf2",
22-
"__lttf2", "__multf3", "__netf2", "__powitf2",
23-
"__subtf3", "__trunctfdf2", "__trunctfsf2", "__unordtf2",
24-
"ceill", "copysignl", "cosl", "exp2l",
25-
"expl", "floorl", "fmal", "fmaxl",
26-
"fmodl", "frexpl", "log10l", "log2l",
27-
"logl", "nearbyintl", "powl", "rintl",
28-
"roundl", "sincosl", "sinl", "sqrtl",
29-
"truncl"};
30-
31-
// Check that LibCalls is sorted alphabetically.
32-
auto Comp = [](const char *S1, const char *S2) { return strcmp(S1, S2) < 0; };
33-
assert(llvm::is_sorted(LibCalls, Comp));
34-
return llvm::binary_search(LibCalls, CallSym, Comp);
35-
}
36-
3715
/// This function returns true if Ty is fp128, {f128} or i128 which was
3816
/// originally a fp128.
39-
bool MipsCCState::originalTypeIsF128(const Type *Ty, const char *Func) {
17+
bool MipsCCState::originalTypeIsF128(const Type *Ty) {
4018
if (Ty->isFP128Ty())
4119
return true;
4220

4321
if (Ty->isStructTy() && Ty->getStructNumElements() == 1 &&
4422
Ty->getStructElementType(0)->isFP128Ty())
4523
return true;
4624

47-
// If the Ty is i128 and the function being called is a long double emulation
48-
// routine, then the original type is f128.
49-
// FIXME: This is unsound because these functions could be indirectly called
50-
return (Func && Ty->isIntegerTy(128) && isF128SoftLibCall(Func));
25+
return false;
5126
}
5227

5328
/// Return true if the original type was vXfXX.
@@ -84,11 +59,9 @@ MipsCCState::getSpecialCallingConvForCallee(const SDNode *Callee,
8459
}
8560

8661
void MipsCCState::PreAnalyzeCallResultForF128(
87-
const SmallVectorImpl<ISD::InputArg> &Ins,
88-
const Type *RetTy, const char *Call) {
62+
const SmallVectorImpl<ISD::InputArg> &Ins, const Type *RetTy) {
8963
for (unsigned i = 0; i < Ins.size(); ++i) {
90-
OriginalArgWasF128.push_back(
91-
originalTypeIsF128(RetTy, Call));
64+
OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
9265
OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
9366
}
9467
}
@@ -98,8 +71,7 @@ void MipsCCState::PreAnalyzeCallResultForF128(
9871
void MipsCCState::PreAnalyzeCallReturnForF128(
9972
const SmallVectorImpl<ISD::OutputArg> &Outs, const Type *RetTy) {
10073
for (unsigned i = 0; i < Outs.size(); ++i) {
101-
OriginalArgWasF128.push_back(
102-
originalTypeIsF128(RetTy, nullptr));
74+
OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
10375
OriginalArgWasFloat.push_back(
10476
RetTy->isFloatingPointTy());
10577
}
@@ -129,8 +101,8 @@ void MipsCCState::PreAnalyzeReturnValue(EVT ArgVT) {
129101
OriginalRetWasFloatVector.push_back(originalEVTTypeIsVectorFloat(ArgVT));
130102
}
131103

132-
void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy, const char *Func) {
133-
OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy, Func));
104+
void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy) {
105+
OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy));
134106
OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
135107
OriginalArgWasFloatVector.push_back(ArgTy->isVectorTy());
136108
}
@@ -139,14 +111,13 @@ void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy, const char *Func) {
139111
/// arguments and record this.
140112
void MipsCCState::PreAnalyzeCallOperands(
141113
const SmallVectorImpl<ISD::OutputArg> &Outs,
142-
std::vector<TargetLowering::ArgListEntry> &FuncArgs,
143-
const char *Func) {
114+
std::vector<TargetLowering::ArgListEntry> &FuncArgs) {
144115
for (unsigned i = 0; i < Outs.size(); ++i) {
145116
TargetLowering::ArgListEntry FuncArg = FuncArgs[Outs[i].OrigArgIndex];
146117

147-
OriginalArgWasF128.push_back(originalTypeIsF128(FuncArg.Ty, Func));
148-
OriginalArgWasFloat.push_back(FuncArg.Ty->isFloatingPointTy());
149-
OriginalArgWasFloatVector.push_back(FuncArg.Ty->isVectorTy());
118+
OriginalArgWasF128.push_back(originalTypeIsF128(FuncArg.OrigTy));
119+
OriginalArgWasFloat.push_back(FuncArg.OrigTy->isFloatingPointTy());
120+
OriginalArgWasFloatVector.push_back(FuncArg.OrigTy->isVectorTy());
150121
}
151122
}
152123

@@ -162,7 +133,7 @@ void MipsCCState::PreAnalyzeFormalArgument(const Type *ArgTy,
162133
return;
163134
}
164135

165-
OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy, nullptr));
136+
OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy));
166137
OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
167138

168139
// The MIPS vector ABI exhibits a corner case of sorts or quirk; if the
@@ -192,8 +163,7 @@ void MipsCCState::PreAnalyzeFormalArgumentsForF128(
192163
assert(Ins[i].getOrigArgIndex() < MF.getFunction().arg_size());
193164
std::advance(FuncArg, Ins[i].getOrigArgIndex());
194165

195-
OriginalArgWasF128.push_back(
196-
originalTypeIsF128(FuncArg->getType(), nullptr));
166+
OriginalArgWasF128.push_back(originalTypeIsF128(FuncArg->getType()));
197167
OriginalArgWasFloat.push_back(FuncArg->getType()->isFloatingPointTy());
198168

199169
// The MIPS vector ABI exhibits a corner case of sorts or quirk; if the

‎llvm/lib/Target/Mips/MipsCCState.h‎

Lines changed: 17 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -26,17 +26,11 @@ class MipsCCState : public CCState {
2626
getSpecialCallingConvForCallee(const SDNode *Callee,
2727
const MipsSubtarget &Subtarget);
2828

29-
/// This function returns true if CallSym is a long double emulation routine.
30-
///
31-
/// FIXME: Changing the ABI based on the callee name is unsound. The lib func
32-
/// address could be captured.
33-
static bool isF128SoftLibCall(const char *CallSym);
34-
35-
static bool originalTypeIsF128(const Type *Ty, const char *Func);
29+
static bool originalTypeIsF128(const Type *Ty);
3630
static bool originalEVTTypeIsVectorFloat(EVT Ty);
3731
static bool originalTypeIsVectorFloat(const Type *Ty);
3832

39-
void PreAnalyzeCallOperand(const Type *ArgTy, const char *Func);
33+
void PreAnalyzeCallOperand(const Type *ArgTy);
4034

4135
void PreAnalyzeFormalArgument(const Type *ArgTy, ISD::ArgFlagsTy Flags);
4236
void PreAnalyzeReturnValue(EVT ArgVT);
@@ -45,7 +39,7 @@ class MipsCCState : public CCState {
4539
/// Identify lowered values that originated from f128 arguments and record
4640
/// this for use by RetCC_MipsN.
4741
void PreAnalyzeCallResultForF128(const SmallVectorImpl<ISD::InputArg> &Ins,
48-
const Type *RetTy, const char * Func);
42+
const Type *RetTy);
4943

5044
/// Identify lowered values that originated from f128 arguments and record
5145
/// this for use by RetCC_MipsN.
@@ -55,8 +49,7 @@ class MipsCCState : public CCState {
5549
/// this.
5650
void
5751
PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
58-
std::vector<TargetLowering::ArgListEntry> &FuncArgs,
59-
const char *Func);
52+
std::vector<TargetLowering::ArgListEntry> &FuncArgs);
6053

6154
/// Identify lowered values that originated from f128 arguments and record
6255
/// this for use by RetCC_MipsN.
@@ -96,21 +89,21 @@ class MipsCCState : public CCState {
9689
SpecialCallingConvType SpecialCC = NoSpecialCallingConv)
9790
: CCState(CC, isVarArg, MF, locs, C), SpecialCallingConv(SpecialCC) {}
9891

99-
void PreAnalyzeCallOperands(
100-
const SmallVectorImpl<ISD::OutputArg> &Outs, CCAssignFn Fn,
101-
std::vector<TargetLowering::ArgListEntry> &FuncArgs, const char *Func) {
92+
void
93+
PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
94+
CCAssignFn Fn,
95+
std::vector<TargetLowering::ArgListEntry> &FuncArgs) {
10296
OriginalArgWasF128.clear();
10397
OriginalArgWasFloat.clear();
10498
OriginalArgWasFloatVector.clear();
105-
PreAnalyzeCallOperands(Outs, FuncArgs, Func);
99+
PreAnalyzeCallOperands(Outs, FuncArgs);
106100
}
107101

108102
void
109103
AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
110104
CCAssignFn Fn,
111-
std::vector<TargetLowering::ArgListEntry> &FuncArgs,
112-
const char *Func) {
113-
PreAnalyzeCallOperands(Outs, Fn, FuncArgs, Func);
105+
std::vector<TargetLowering::ArgListEntry> &FuncArgs) {
106+
PreAnalyzeCallOperands(Outs, Fn, FuncArgs);
114107
CCState::AnalyzeCallOperands(Outs, Fn);
115108
}
116109

@@ -137,26 +130,24 @@ class MipsCCState : public CCState {
137130
CCState::AnalyzeFormalArguments(Ins, Fn);
138131
}
139132

140-
void PreAnalyzeCallResult(const Type *RetTy, const char *Func) {
141-
OriginalArgWasF128.push_back(originalTypeIsF128(RetTy, Func));
133+
void PreAnalyzeCallResult(const Type *RetTy) {
134+
OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
142135
OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
143136
OriginalRetWasFloatVector.push_back(originalTypeIsVectorFloat(RetTy));
144137
}
145138

146139
void PreAnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
147-
CCAssignFn Fn, const Type *RetTy,
148-
const char *Func) {
140+
CCAssignFn Fn, const Type *RetTy) {
149141
OriginalArgWasFloat.clear();
150142
OriginalArgWasF128.clear();
151143
OriginalArgWasFloatVector.clear();
152-
PreAnalyzeCallResultForF128(Ins, RetTy, Func);
144+
PreAnalyzeCallResultForF128(Ins, RetTy);
153145
PreAnalyzeCallResultForVectorFloat(Ins, RetTy);
154146
}
155147

156148
void AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
157-
CCAssignFn Fn, const Type *RetTy,
158-
const char *Func) {
159-
PreAnalyzeCallResult(Ins, Fn, RetTy, Func);
149+
CCAssignFn Fn, const Type *RetTy) {
150+
PreAnalyzeCallResult(Ins, Fn, RetTy);
160151
CCState::AnalyzeCallResult(Ins, Fn);
161152
}
162153

0 commit comments

Comments
 (0)