[Mips] Remove custom "original type" handling (#154082)

Replace Mips custom logic for retaining information about original types
in calling convention lowering by directly querying the OrigTy that is
now available.

There is one change in behavior here: If the return type is a struct
containing fp128 plus additional members, the result is now different,
as we no longer special case to a single fp128 member. I believe this is
fine, because this is a fake ABI anyway: Such cases should actually use
sret, and as such are a frontend responsibility, and Clang will indeed
emit these as sret, not as a return value struct. So this only impacts
manually written IR tests.

Author: nikic

llvm/lib/Target/Mips/MipsCCState.cpp

@@ -12,35 +12,6 @@
 
 using namespace llvm;
 
-/// This function returns true if Ty is fp128, {f128} or i128 which was
-/// originally a fp128.
-bool MipsCCState::originalTypeIsF128(const Type *Ty) {
-  if (Ty->isFP128Ty())
-    return true;
-
-  if (Ty->isStructTy() && Ty->getStructNumElements() == 1 &&
-      Ty->getStructElementType(0)->isFP128Ty())
-    return true;
-
-  return false;
-}
-
-/// Return true if the original type was vXfXX.
-bool MipsCCState::originalEVTTypeIsVectorFloat(EVT Ty) {
-  if (Ty.isVector() && Ty.getVectorElementType().isFloatingPoint())
-    return true;
-
-  return false;
-}
-
-/// Return true if the original type was vXfXX / vXfXX.
-bool MipsCCState::originalTypeIsVectorFloat(const Type *Ty) {
-  if (Ty->isVectorTy() && Ty->isFPOrFPVectorTy())
-    return true;
-
-  return false;
-}
-
 MipsCCState::SpecialCallingConvType
 MipsCCState::getSpecialCallingConvForCallee(const SDNode *Callee,
                                             const MipsSubtarget &Subtarget) {
@@ -57,118 +28,3 @@ MipsCCState::getSpecialCallingConvForCallee(const SDNode *Callee,
   }
   return SpecialCallingConv;
 }
-
-void MipsCCState::PreAnalyzeCallResultForF128(
-    const SmallVectorImpl<ISD::InputArg> &Ins, const Type *RetTy) {
-  for (unsigned i = 0; i < Ins.size(); ++i) {
-    OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
-    OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
-  }
-}
-
-/// Identify lowered values that originated from f128 or float arguments and
-/// record this for use by RetCC_MipsN.
-void MipsCCState::PreAnalyzeCallReturnForF128(
-    const SmallVectorImpl<ISD::OutputArg> &Outs, const Type *RetTy) {
-  for (unsigned i = 0; i < Outs.size(); ++i) {
-    OriginalArgWasF128.push_back(originalTypeIsF128(RetTy));
-    OriginalArgWasFloat.push_back(
-        RetTy->isFloatingPointTy());
-  }
-}
-
-/// Identify lower values that originated from vXfXX and record
-/// this.
-void MipsCCState::PreAnalyzeCallResultForVectorFloat(
-    const SmallVectorImpl<ISD::InputArg> &Ins, const Type *RetTy) {
-  for (unsigned i = 0; i < Ins.size(); ++i) {
-    OriginalRetWasFloatVector.push_back(originalTypeIsVectorFloat(RetTy));
-  }
-}
-
-/// Identify lowered values that originated from vXfXX arguments and record
-/// this.
-void MipsCCState::PreAnalyzeReturnForVectorFloat(
-    const SmallVectorImpl<ISD::OutputArg> &Outs) {
-  for (unsigned i = 0; i < Outs.size(); ++i) {
-    ISD::OutputArg Out = Outs[i];
-    OriginalRetWasFloatVector.push_back(
-        originalEVTTypeIsVectorFloat(Out.ArgVT));
-  }
-}
-
-void MipsCCState::PreAnalyzeReturnValue(EVT ArgVT) {
-  OriginalRetWasFloatVector.push_back(originalEVTTypeIsVectorFloat(ArgVT));
-}
-
-void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy) {
-  OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy));
-  OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
-  OriginalArgWasFloatVector.push_back(ArgTy->isVectorTy());
-}
-
-/// Identify lowered values that originated from f128, float and sret to vXfXX
-/// arguments and record this.
-void MipsCCState::PreAnalyzeCallOperands(
-    const SmallVectorImpl<ISD::OutputArg> &Outs,
-    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.OrigTy));
-    OriginalArgWasFloat.push_back(FuncArg.OrigTy->isFloatingPointTy());
-    OriginalArgWasFloatVector.push_back(FuncArg.OrigTy->isVectorTy());
-  }
-}
-
-void MipsCCState::PreAnalyzeFormalArgument(const Type *ArgTy,
-                                           ISD::ArgFlagsTy Flags) {
-  // SRet arguments cannot originate from f128 or {f128} returns so we just
-  // push false. We have to handle this specially since SRet arguments
-  // aren't mapped to an original argument.
-  if (Flags.isSRet()) {
-    OriginalArgWasF128.push_back(false);
-    OriginalArgWasFloat.push_back(false);
-    OriginalArgWasFloatVector.push_back(false);
-    return;
-  }
-
-  OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy));
-  OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
-
-  // The MIPS vector ABI exhibits a corner case of sorts or quirk; if the
-  // first argument is actually an SRet pointer to a vector, then the next
-  // argument slot is $a2.
-  OriginalArgWasFloatVector.push_back(ArgTy->isVectorTy());
-}
-
-/// Identify lowered values that originated from f128, float and vXfXX arguments
-/// and record this.
-void MipsCCState::PreAnalyzeFormalArgumentsForF128(
-    const SmallVectorImpl<ISD::InputArg> &Ins) {
-  const MachineFunction &MF = getMachineFunction();
-  for (unsigned i = 0; i < Ins.size(); ++i) {
-    Function::const_arg_iterator FuncArg = MF.getFunction().arg_begin();
-
-    // SRet arguments cannot originate from f128 or {f128} returns so we just
-    // push false. We have to handle this specially since SRet arguments
-    // aren't mapped to an original argument.
-    if (Ins[i].Flags.isSRet()) {
-      OriginalArgWasF128.push_back(false);
-      OriginalArgWasFloat.push_back(false);
-      OriginalArgWasFloatVector.push_back(false);
-      continue;
-    }
-
-    assert(Ins[i].getOrigArgIndex() < MF.getFunction().arg_size());
-    std::advance(FuncArg, Ins[i].getOrigArgIndex());
-
-    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
-    // first argument is actually an SRet pointer to a vector, then the next
-    // argument slot is $a2.
-    OriginalArgWasFloatVector.push_back(FuncArg->getType()->isVectorTy());
-  }
-}

llvm/lib/Target/Mips/MipsCCState.h

@@ -26,59 +26,7 @@ class MipsCCState : public CCState {
   getSpecialCallingConvForCallee(const SDNode *Callee,
                                  const MipsSubtarget &Subtarget);
 
-  static bool originalTypeIsF128(const Type *Ty);
-  static bool originalEVTTypeIsVectorFloat(EVT Ty);
-  static bool originalTypeIsVectorFloat(const Type *Ty);
-
-  void PreAnalyzeCallOperand(const Type *ArgTy);
-
-  void PreAnalyzeFormalArgument(const Type *ArgTy, ISD::ArgFlagsTy Flags);
-  void PreAnalyzeReturnValue(EVT ArgVT);
-
 private:
-  /// 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);
-
-  /// Identify lowered values that originated from f128 arguments and record
-  /// this for use by RetCC_MipsN.
-  void PreAnalyzeCallReturnForF128(const SmallVectorImpl<ISD::OutputArg> &Outs, const Type *RetTy);
-
-  /// Identify lowered values that originated from f128 arguments and record
-  /// this.
-  void
-  PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
-                         std::vector<TargetLowering::ArgListEntry> &FuncArgs);
-
-  /// Identify lowered values that originated from f128 arguments and record
-  /// this for use by RetCC_MipsN.
-  void
-  PreAnalyzeFormalArgumentsForF128(const SmallVectorImpl<ISD::InputArg> &Ins);
-
-  void
-  PreAnalyzeCallResultForVectorFloat(const SmallVectorImpl<ISD::InputArg> &Ins,
-                                     const Type *RetTy);
-
-  void PreAnalyzeFormalArgumentsForVectorFloat(
-      const SmallVectorImpl<ISD::InputArg> &Ins);
-
-  void
-  PreAnalyzeReturnForVectorFloat(const SmallVectorImpl<ISD::OutputArg> &Outs);
-
-  /// Records whether the value has been lowered from an f128.
-  SmallVector<bool, 4> OriginalArgWasF128;
-
-  /// Records whether the value has been lowered from float.
-  SmallVector<bool, 4> OriginalArgWasFloat;
-
-  /// Records whether the value has been lowered from a floating point vector.
-  SmallVector<bool, 4> OriginalArgWasFloatVector;
-
-  /// Records whether the return value has been lowered from a floating point
-  /// vector.
-  SmallVector<bool, 4> OriginalRetWasFloatVector;
-
   // Used to handle MIPS16-specific calling convention tweaks.
   // FIXME: This should probably be a fully fledged calling convention.
   SpecialCallingConvType SpecialCallingConv;
@@ -89,116 +37,6 @@ 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) {
-    OriginalArgWasF128.clear();
-    OriginalArgWasFloat.clear();
-    OriginalArgWasFloatVector.clear();
-    PreAnalyzeCallOperands(Outs, FuncArgs);
-  }
-
-  void
-  AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
-                      CCAssignFn Fn,
-                      std::vector<TargetLowering::ArgListEntry> &FuncArgs) {
-    PreAnalyzeCallOperands(Outs, Fn, FuncArgs);
-    CCState::AnalyzeCallOperands(Outs, Fn);
-  }
-
-  // The AnalyzeCallOperands in the base class is not usable since we must
-  // provide a means of accessing ArgListEntry::IsFixed. Delete them from this
-  // class. This doesn't stop them being used via the base class though.
-  void AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
-                           CCAssignFn Fn) = delete;
-  void AnalyzeCallOperands(const SmallVectorImpl<MVT> &Outs,
-                           SmallVectorImpl<ISD::ArgFlagsTy> &Flags,
-                           CCAssignFn Fn) = delete;
-
-  void PreAnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
-                                 CCAssignFn Fn) {
-    OriginalArgWasFloat.clear();
-    OriginalArgWasF128.clear();
-    OriginalArgWasFloatVector.clear();
-    PreAnalyzeFormalArgumentsForF128(Ins);
-  }
-
-  void AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
-                              CCAssignFn Fn) {
-    PreAnalyzeFormalArguments(Ins, Fn);
-    CCState::AnalyzeFormalArguments(Ins, Fn);
-  }
-
-  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) {
-    OriginalArgWasFloat.clear();
-    OriginalArgWasF128.clear();
-    OriginalArgWasFloatVector.clear();
-    PreAnalyzeCallResultForF128(Ins, RetTy);
-    PreAnalyzeCallResultForVectorFloat(Ins, RetTy);
-  }
-
-  void AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
-                         CCAssignFn Fn, const Type *RetTy) {
-    PreAnalyzeCallResult(Ins, Fn, RetTy);
-    CCState::AnalyzeCallResult(Ins, Fn);
-  }
-
-  void PreAnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
-                        CCAssignFn Fn) {
-    const MachineFunction &MF = getMachineFunction();
-    OriginalArgWasFloat.clear();
-    OriginalArgWasF128.clear();
-    OriginalArgWasFloatVector.clear();
-    PreAnalyzeCallReturnForF128(Outs, MF.getFunction().getReturnType());
-    PreAnalyzeReturnForVectorFloat(Outs);
-  }
-
-  void AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
-                     CCAssignFn Fn) {
-    PreAnalyzeReturn(Outs, Fn);
-    CCState::AnalyzeReturn(Outs, Fn);
-  }
-
-  bool CheckReturn(const SmallVectorImpl<ISD::OutputArg> &ArgsFlags,
-                   CCAssignFn Fn) {
-    const MachineFunction &MF = getMachineFunction();
-    PreAnalyzeCallReturnForF128(ArgsFlags, MF.getFunction().getReturnType());
-    PreAnalyzeReturnForVectorFloat(ArgsFlags);
-    bool Return = CCState::CheckReturn(ArgsFlags, Fn);
-    OriginalArgWasFloat.clear();
-    OriginalArgWasF128.clear();
-    OriginalArgWasFloatVector.clear();
-    return Return;
-  }
-
-  bool CheckCallReturn(const SmallVectorImpl<ISD::OutputArg> &ArgsFlags,
-                   CCAssignFn Fn, const Type *RetTy) {
-    PreAnalyzeCallReturnForF128(ArgsFlags, RetTy);
-    PreAnalyzeReturnForVectorFloat(ArgsFlags);
-    bool Return = CCState::CheckReturn(ArgsFlags, Fn);
-    OriginalArgWasFloat.clear();
-    OriginalArgWasF128.clear();
-    OriginalArgWasFloatVector.clear();
-    return Return;
-  }
-  bool WasOriginalArgF128(unsigned ValNo) { return OriginalArgWasF128[ValNo]; }
-  bool WasOriginalArgFloat(unsigned ValNo) {
-      return OriginalArgWasFloat[ValNo];
-  }
-  bool WasOriginalArgVectorFloat(unsigned ValNo) const {
-    return OriginalArgWasFloatVector[ValNo];
-  }
-  bool WasOriginalRetVectorFloat(unsigned ValNo) const {
-    return OriginalRetWasFloatVector[ValNo];
-  }
   SpecialCallingConvType getSpecialCallingConv() { return SpecialCallingConv; }
 };
 }