[llvm] [CodeGen][Mips] Remove fp128 libcall list (PR #153798)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 15 05:40:23 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-selectiondag
@llvm/pr-subscribers-backend-mips
Author: Nikita Popov (nikic)
<details>
<summary>Changes</summary>
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.
---
Patch is 42.32 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/153798.diff
9 Files Affected:
- (modified) llvm/include/llvm/CodeGen/TargetLowering.h (+27-2)
- (modified) llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp (+15-3)
- (modified) llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp (+17-7)
- (modified) llvm/lib/Target/Mips/MipsCCState.cpp (+13-43)
- (modified) llvm/lib/Target/Mips/MipsCCState.h (+17-26)
- (modified) llvm/lib/Target/Mips/MipsCallLowering.cpp (+9-26)
- (modified) llvm/lib/Target/Mips/MipsFastISel.cpp (+1-3)
- (modified) llvm/lib/Target/Mips/MipsISelLowering.cpp (+2-6)
- (modified) llvm/test/CodeGen/Mips/fmuladd-soft-float.ll (+143-131)
``````````diff
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index ed7495694cc70..bbd720dfc451d 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -301,6 +301,9 @@ class LLVM_ABI TargetLoweringBase {
public:
Value *Val = nullptr;
SDValue Node = SDValue();
+ /// Original unlegalized argument type.
+ Type *OrigTy = nullptr;
+ /// Same as OrigTy, or partially legalized for soft float libcalls.
Type *Ty = nullptr;
bool IsSExt : 1;
bool IsZExt : 1;
@@ -4672,6 +4675,9 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
/// implementation.
struct CallLoweringInfo {
SDValue Chain;
+ /// Original unlegalized return type.
+ Type *OrigRetTy = nullptr;
+ /// Same as OrigRetTy, or partially legalized for soft float libcalls.
Type *RetTy = nullptr;
bool RetSExt : 1;
bool RetZExt : 1;
@@ -4726,11 +4732,20 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
// setCallee with target/module-specific attributes
CallLoweringInfo &setLibCallee(CallingConv::ID CC, Type *ResultType,
SDValue Target, ArgListTy &&ArgsList) {
+ return setLibCallee(CC, ResultType, ResultType, Target,
+ std::move(ArgsList));
+ }
+
+ CallLoweringInfo &setLibCallee(CallingConv::ID CC, Type *ResultType,
+ Type *OrigResultType, SDValue Target,
+ ArgListTy &&ArgsList) {
+ OrigRetTy = OrigResultType;
RetTy = ResultType;
Callee = Target;
CallConv = CC;
NumFixedArgs = ArgsList.size();
Args = std::move(ArgsList);
+ initOrigArgTys();
DAG.getTargetLoweringInfo().markLibCallAttributes(
&(DAG.getMachineFunction()), CC, Args);
@@ -4740,7 +4755,7 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
CallLoweringInfo &setCallee(CallingConv::ID CC, Type *ResultType,
SDValue Target, ArgListTy &&ArgsList,
AttributeSet ResultAttrs = {}) {
- RetTy = ResultType;
+ RetTy = OrigRetTy = ResultType;
IsInReg = ResultAttrs.hasAttribute(Attribute::InReg);
RetSExt = ResultAttrs.hasAttribute(Attribute::SExt);
RetZExt = ResultAttrs.hasAttribute(Attribute::ZExt);
@@ -4750,13 +4765,14 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
CallConv = CC;
NumFixedArgs = ArgsList.size();
Args = std::move(ArgsList);
+ initOrigArgTys();
return *this;
}
CallLoweringInfo &setCallee(Type *ResultType, FunctionType *FTy,
SDValue Target, ArgListTy &&ArgsList,
const CallBase &Call) {
- RetTy = ResultType;
+ RetTy = OrigRetTy = ResultType;
IsInReg = Call.hasRetAttr(Attribute::InReg);
DoesNotReturn =
@@ -4773,6 +4789,7 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
CallConv = Call.getCallingConv();
NumFixedArgs = FTy->getNumParams();
Args = std::move(ArgsList);
+ initOrigArgTys();
CB = &Call;
@@ -4852,6 +4869,14 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
ArgListTy &getArgs() {
return Args;
}
+
+ private:
+ void initOrigArgTys() {
+ for (ArgListEntry &Arg : Args) {
+ if (!Arg.OrigTy)
+ Arg.OrigTy = Arg.Ty;
+ }
+ }
};
/// This structure is used to pass arguments to makeLibCall function.
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
index 2eaab02130699..52e7f0feffbf3 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
@@ -11031,6 +11031,12 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
for (Type *Ty : RetOrigTys)
RetTys.push_back(getValueType(DL, Ty));
+ if (CLI.RetTy != CLI.OrigRetTy) {
+ assert(RetOrigTys.size() == 1 &&
+ "Only supported for non-aggregate returns");
+ RetOrigTys[0] = CLI.OrigRetTy;
+ }
+
if (CLI.IsPostTypeLegalization) {
// If we are lowering a libcall after legalization, split the return type.
SmallVector<Type *, 4> OldRetOrigTys;
@@ -11076,7 +11082,7 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
DemoteStackSlot = CLI.DAG.getFrameIndex(DemoteStackIdx, getFrameIndexTy(DL));
ArgListEntry Entry;
Entry.Node = DemoteStackSlot;
- Entry.Ty = StackSlotPtrType;
+ Entry.Ty = Entry.OrigTy = StackSlotPtrType;
Entry.IsSExt = false;
Entry.IsZExt = false;
Entry.IsInReg = false;
@@ -11093,7 +11099,7 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
CLI.getArgs().insert(CLI.getArgs().begin(), Entry);
CLI.NumFixedArgs += 1;
CLI.getArgs()[0].IndirectType = CLI.RetTy;
- CLI.RetTy = Type::getVoidTy(Context);
+ CLI.RetTy = CLI.OrigRetTy = Type::getVoidTy(Context);
// sret demotion isn't compatible with tail-calls, since the sret argument
// points into the callers stack frame.
@@ -11161,6 +11167,12 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
for (unsigned Value = 0, NumValues = ArgTys.size(); Value != NumValues;
++Value) {
Type *ArgTy = ArgTys[Value];
+ Type *OrigArgTy = ArgTy;
+ if (Args[i].Ty != Args[i].OrigTy) {
+ assert(Value == 0 && "Only supported for non-aggregate arguments");
+ OrigArgTy = Args[i].OrigTy;
+ }
+
EVT VT = getValueType(DL, ArgTy);
SDValue Op = SDValue(Args[i].Node.getNode(),
Args[i].Node.getResNo() + Value);
@@ -11294,7 +11306,7 @@ TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
// For scalable vectors the scalable part is currently handled
// by individual targets, so we just use the known minimum size here.
ISD::OutputArg MyFlags(
- Flags, Parts[j].getValueType().getSimpleVT(), VT, ArgTy, i,
+ Flags, Parts[j].getValueType().getSimpleVT(), VT, OrigArgTy, i,
j * Parts[j].getValueType().getStoreSize().getKnownMinValue());
if (NumParts > 1 && j == 0)
MyFlags.Flags.setSplit();
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index 911bbabc42aa3..1377aef860754 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -167,9 +167,16 @@ TargetLowering::makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT,
for (unsigned i = 0; i < Ops.size(); ++i) {
SDValue NewOp = Ops[i];
Entry.Node = NewOp;
- Entry.Ty = i < OpsTypeOverrides.size() && OpsTypeOverrides[i]
- ? OpsTypeOverrides[i]
- : Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
+ if (i < OpsTypeOverrides.size() && OpsTypeOverrides[i])
+ Entry.Ty = Entry.OrigTy = OpsTypeOverrides[i];
+ else {
+ Entry.Ty = Entry.OrigTy =
+ Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
+ if (CallOptions.IsSoften)
+ Entry.OrigTy =
+ CallOptions.OpsVTBeforeSoften[i].getTypeForEVT(*DAG.getContext());
+ }
+
Entry.IsSExt =
shouldSignExtendTypeInLibCall(Entry.Ty, CallOptions.IsSigned);
Entry.IsZExt = !Entry.IsSExt;
@@ -189,18 +196,21 @@ TargetLowering::makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT,
DAG.getExternalSymbol(LibcallName, getPointerTy(DAG.getDataLayout()));
Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
+ Type *OrigRetTy = RetTy;
TargetLowering::CallLoweringInfo CLI(DAG);
bool signExtend = shouldSignExtendTypeInLibCall(RetTy, CallOptions.IsSigned);
bool zeroExtend = !signExtend;
- if (CallOptions.IsSoften &&
- !shouldExtendTypeInLibCall(CallOptions.RetVTBeforeSoften)) {
- signExtend = zeroExtend = false;
+ if (CallOptions.IsSoften) {
+ OrigRetTy = CallOptions.RetVTBeforeSoften.getTypeForEVT(*DAG.getContext());
+ if (!shouldExtendTypeInLibCall(CallOptions.RetVTBeforeSoften))
+ signExtend = zeroExtend = false;
}
CLI.setDebugLoc(dl)
.setChain(InChain)
- .setLibCallee(getLibcallCallingConv(LC), RetTy, Callee, std::move(Args))
+ .setLibCallee(getLibcallCallingConv(LC), RetTy, OrigRetTy, Callee,
+ std::move(Args))
.setNoReturn(CallOptions.DoesNotReturn)
.setDiscardResult(!CallOptions.IsReturnValueUsed)
.setIsPostTypeLegalization(CallOptions.IsPostTypeLegalization)
diff --git a/llvm/lib/Target/Mips/MipsCCState.cpp b/llvm/lib/Target/Mips/MipsCCState.cpp
index d600343860b0b..d7b5633d7077e 100644
--- a/llvm/lib/Target/Mips/MipsCCState.cpp
+++ b/llvm/lib/Target/Mips/MipsCCState.cpp
@@ -12,31 +12,9 @@
using namespace llvm;
-bool MipsCCState::isF128SoftLibCall(const char *CallSym) {
- const char *const LibCalls[] = {
- "__addtf3", "__divtf3", "__eqtf2", "__extenddftf2",
- "__extendsftf2", "__fixtfdi", "__fixtfsi", "__fixtfti",
- "__fixunstfdi", "__fixunstfsi", "__fixunstfti", "__floatditf",
- "__floatsitf", "__floattitf", "__floatunditf", "__floatunsitf",
- "__floatuntitf", "__getf2", "__gttf2", "__letf2",
- "__lttf2", "__multf3", "__netf2", "__powitf2",
- "__subtf3", "__trunctfdf2", "__trunctfsf2", "__unordtf2",
- "ceill", "copysignl", "cosl", "exp2l",
- "expl", "floorl", "fmal", "fmaxl",
- "fmodl", "frexpl", "log10l", "log2l",
- "logl", "nearbyintl", "powl", "rintl",
- "roundl", "sincosl", "sinl", "sqrtl",
- "truncl"};
-
- // Check that LibCalls is sorted alphabetically.
- auto Comp = [](const char *S1, const char *S2) { return strcmp(S1, S2) < 0; };
- assert(llvm::is_sorted(LibCalls, Comp));
- return llvm::binary_search(LibCalls, CallSym, Comp);
-}
-
/// This function returns true if Ty is fp128, {f128} or i128 which was
/// originally a fp128.
-bool MipsCCState::originalTypeIsF128(const Type *Ty, const char *Func) {
+bool MipsCCState::originalTypeIsF128(const Type *Ty) {
if (Ty->isFP128Ty())
return true;
@@ -44,10 +22,7 @@ bool MipsCCState::originalTypeIsF128(const Type *Ty, const char *Func) {
Ty->getStructElementType(0)->isFP128Ty())
return true;
- // If the Ty is i128 and the function being called is a long double emulation
- // routine, then the original type is f128.
- // FIXME: This is unsound because these functions could be indirectly called
- return (Func && Ty->isIntegerTy(128) && isF128SoftLibCall(Func));
+ return false;
}
/// Return true if the original type was vXfXX.
@@ -84,11 +59,9 @@ MipsCCState::getSpecialCallingConvForCallee(const SDNode *Callee,
}
void MipsCCState::PreAnalyzeCallResultForF128(
- const SmallVectorImpl<ISD::InputArg> &Ins,
- const Type *RetTy, const char *Call) {
+ const SmallVectorImpl<ISD::InputArg> &Ins, const Type *RetTy) {
for (unsigned i = 0; i < Ins.size(); ++i) {
- OriginalArgWasF128.push_back(
- originalTypeIsF128(RetTy, Call));
+ OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
}
}
@@ -98,8 +71,7 @@ void MipsCCState::PreAnalyzeCallResultForF128(
void MipsCCState::PreAnalyzeCallReturnForF128(
const SmallVectorImpl<ISD::OutputArg> &Outs, const Type *RetTy) {
for (unsigned i = 0; i < Outs.size(); ++i) {
- OriginalArgWasF128.push_back(
- originalTypeIsF128(RetTy, nullptr));
+ OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
OriginalArgWasFloat.push_back(
RetTy->isFloatingPointTy());
}
@@ -129,8 +101,8 @@ void MipsCCState::PreAnalyzeReturnValue(EVT ArgVT) {
OriginalRetWasFloatVector.push_back(originalEVTTypeIsVectorFloat(ArgVT));
}
-void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy, const char *Func) {
- OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy, Func));
+void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy) {
+ OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy));
OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
OriginalArgWasFloatVector.push_back(ArgTy->isVectorTy());
}
@@ -139,14 +111,13 @@ void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy, const char *Func) {
/// arguments and record this.
void MipsCCState::PreAnalyzeCallOperands(
const SmallVectorImpl<ISD::OutputArg> &Outs,
- std::vector<TargetLowering::ArgListEntry> &FuncArgs,
- const char *Func) {
+ std::vector<TargetLowering::ArgListEntry> &FuncArgs) {
for (unsigned i = 0; i < Outs.size(); ++i) {
TargetLowering::ArgListEntry FuncArg = FuncArgs[Outs[i].OrigArgIndex];
- OriginalArgWasF128.push_back(originalTypeIsF128(FuncArg.Ty, Func));
- OriginalArgWasFloat.push_back(FuncArg.Ty->isFloatingPointTy());
- OriginalArgWasFloatVector.push_back(FuncArg.Ty->isVectorTy());
+ OriginalArgWasF128.push_back(originalTypeIsF128(FuncArg.OrigTy));
+ OriginalArgWasFloat.push_back(FuncArg.OrigTy->isFloatingPointTy());
+ OriginalArgWasFloatVector.push_back(FuncArg.OrigTy->isVectorTy());
}
}
@@ -162,7 +133,7 @@ void MipsCCState::PreAnalyzeFormalArgument(const Type *ArgTy,
return;
}
- OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy, nullptr));
+ OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy));
OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
// The MIPS vector ABI exhibits a corner case of sorts or quirk; if the
@@ -192,8 +163,7 @@ void MipsCCState::PreAnalyzeFormalArgumentsForF128(
assert(Ins[i].getOrigArgIndex() < MF.getFunction().arg_size());
std::advance(FuncArg, Ins[i].getOrigArgIndex());
- OriginalArgWasF128.push_back(
- originalTypeIsF128(FuncArg->getType(), nullptr));
+ OriginalArgWasF128.push_back(originalTypeIsF128(FuncArg->getType()));
OriginalArgWasFloat.push_back(FuncArg->getType()->isFloatingPointTy());
// The MIPS vector ABI exhibits a corner case of sorts or quirk; if the
diff --git a/llvm/lib/Target/Mips/MipsCCState.h b/llvm/lib/Target/Mips/MipsCCState.h
index 30b68e8a9c969..4d985518ce7c5 100644
--- a/llvm/lib/Target/Mips/MipsCCState.h
+++ b/llvm/lib/Target/Mips/MipsCCState.h
@@ -26,17 +26,11 @@ class MipsCCState : public CCState {
getSpecialCallingConvForCallee(const SDNode *Callee,
const MipsSubtarget &Subtarget);
- /// This function returns true if CallSym is a long double emulation routine.
- ///
- /// FIXME: Changing the ABI based on the callee name is unsound. The lib func
- /// address could be captured.
- static bool isF128SoftLibCall(const char *CallSym);
-
- static bool originalTypeIsF128(const Type *Ty, const char *Func);
+ static bool originalTypeIsF128(const Type *Ty);
static bool originalEVTTypeIsVectorFloat(EVT Ty);
static bool originalTypeIsVectorFloat(const Type *Ty);
- void PreAnalyzeCallOperand(const Type *ArgTy, const char *Func);
+ void PreAnalyzeCallOperand(const Type *ArgTy);
void PreAnalyzeFormalArgument(const Type *ArgTy, ISD::ArgFlagsTy Flags);
void PreAnalyzeReturnValue(EVT ArgVT);
@@ -45,7 +39,7 @@ class MipsCCState : public CCState {
/// Identify lowered values that originated from f128 arguments and record
/// this for use by RetCC_MipsN.
void PreAnalyzeCallResultForF128(const SmallVectorImpl<ISD::InputArg> &Ins,
- const Type *RetTy, const char * Func);
+ const Type *RetTy);
/// Identify lowered values that originated from f128 arguments and record
/// this for use by RetCC_MipsN.
@@ -55,8 +49,7 @@ class MipsCCState : public CCState {
/// this.
void
PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
- std::vector<TargetLowering::ArgListEntry> &FuncArgs,
- const char *Func);
+ std::vector<TargetLowering::ArgListEntry> &FuncArgs);
/// Identify lowered values that originated from f128 arguments and record
/// this for use by RetCC_MipsN.
@@ -96,21 +89,21 @@ class MipsCCState : public CCState {
SpecialCallingConvType SpecialCC = NoSpecialCallingConv)
: CCState(CC, isVarArg, MF, locs, C), SpecialCallingConv(SpecialCC) {}
- void PreAnalyzeCallOperands(
- const SmallVectorImpl<ISD::OutputArg> &Outs, CCAssignFn Fn,
- std::vector<TargetLowering::ArgListEntry> &FuncArgs, const char *Func) {
+ void
+ PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
+ CCAssignFn Fn,
+ std::vector<TargetLowering::ArgListEntry> &FuncArgs) {
OriginalArgWasF128.clear();
OriginalArgWasFloat.clear();
OriginalArgWasFloatVector.clear();
- PreAnalyzeCallOperands(Outs, FuncArgs, Func);
+ PreAnalyzeCallOperands(Outs, FuncArgs);
}
void
AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
CCAssignFn Fn,
- std::vector<TargetLowering::ArgListEntry> &FuncArgs,
- const char *Func) {
- PreAnalyzeCallOperands(Outs, Fn, FuncArgs, Func);
+ std::vector<TargetLowering::ArgListEntry> &FuncArgs) {
+ PreAnalyzeCallOperands(Outs, Fn, FuncArgs);
CCState::AnalyzeCallOperands(Outs, Fn);
}
@@ -137,26 +130,24 @@ class MipsCCState : public CCState {
CCState::AnalyzeFormalArguments(Ins, Fn);
}
- void PreAnalyzeCallResult(const Type *RetTy, const char *Func) {
- OriginalArgWasF128.push_back(originalTypeIsF128(RetTy, Func));
+ void PreAnalyzeCallResult(const Type *RetTy) {
+ OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
OriginalRetWasFloatVector.push_back(originalTypeIsVectorFloat(RetTy));
}
void PreAnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
- CCAssignFn Fn, const Type *RetTy,
- const char *Func) {
+ CCAssignFn Fn, const Type *RetTy) {
OriginalArgWasFloat.clear();
OriginalArgWasF128.clear();
OriginalArgWasFloatVector.clear();
- PreAnalyzeCallResultForF128(Ins, RetTy, Func);
+ PreAnalyzeCallResultForF128(Ins, RetTy);
PreAnalyzeCallResultForVectorFloat(Ins, RetTy);
}
void AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
- CCAssignFn Fn, const Type *RetTy,
- const char *Func) {
- PreAnalyzeCallResult(Ins, Fn, RetTy, Func);
+ CCAssignFn Fn, const Type *RetTy) {
+ PreAnalyzeCallResult(Ins, Fn, RetTy);
CCState::AnalyzeCallResult(Ins, Fn);
}
diff --git a/llvm/lib/Target/Mips/MipsCallLowering.cpp b/llvm/lib/Target/Mips/MipsCallLowering.cpp
index fa491086b0ac9..5b67346209731 100644
--- a/llvm/lib/Target/Mips/MipsCallLowering.cpp
+++ b/llvm/lib/Target/Mips/MipsCallLowering.cpp
@@ -27,16 +27,11 @@ MipsCallLowering::MipsCallLowering(const MipsTargetLowering &TLI)
namespace {
struct MipsOutgoingValueAssigner : public CallLowering::OutgoingValueAssigner {
- /// This is the name of the function being called
- /// FIXME: Relying on this is unsound
- const char *Func = nullptr;
-
/// Is this a return value, or an outgoing call operand.
bool IsReturn;
- MipsOutgoingValueAssigner(CCAssignFn *AssignFn_, const char *Func,
- bool IsReturn)
- : OutgoingValueAssigner(AssignFn_), Func(Func), IsReturn(IsReturn) {}
+ MipsOutgoingValueAssigner(CCAssignFn *AssignFn_, bool IsReturn)
+ : OutgoingValueAssigner(AssignFn_), IsReturn(IsReturn) {}
bool assignArg(unsigned ValNo, EVT OrigVT, MVT ValVT, MVT LocVT,
CCValAssign::LocInfo LocInfo,
@@ -47,7 +42,7 @@ struct MipsOutgoingValueAssigner : public CallLowering::OutgoingValueAssigner {
if (IsReturn)
State.PreAnalyzeReturnValue(EVT::getEVT(Info.Ty));
else
- ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/153798
More information about the llvm-commits
mailing list