From d2e0bdc3ff45877aa59ab2ebeb571d4a906af34b Mon Sep 17 00:00:00 2001 From: Daniel Sanders Date: Mon, 1 Dec 2014 17:05:38 +0000 Subject: [PATCH] Merged from r221518: [mips] Remove MipsCC::analyzeCallOperands in favour of CCState::AnalyzeCallOperands. NFC Summary: In addition to the usual f128 workaround, it was also necessary to provide a means of accessing ArgListEntry::IsFixed. Reviewers: theraven, vmedic Reviewed By: vmedic Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D6111 git-svn-id: https://llvm.org/svn/llvm-project/llvm/branches/release_35@223048 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Target/TargetCallingConv.td | 3 + lib/Target/Mips/MipsCallingConv.td | 7 +++ lib/Target/Mips/MipsISelLowering.cpp | 76 ++++++++++-------------- lib/Target/Mips/MipsISelLowering.h | 4 -- 4 files changed, 42 insertions(+), 48 deletions(-) diff --git a/include/llvm/Target/TargetCallingConv.td b/include/llvm/Target/TargetCallingConv.td index d785aa8f453..2e766c448b3 100644 --- a/include/llvm/Target/TargetCallingConv.td +++ b/include/llvm/Target/TargetCallingConv.td @@ -67,6 +67,9 @@ class CCIfSplit : CCIf<"ArgFlags.isSplit()", A> {} /// the specified action. class CCIfSRet : CCIf<"ArgFlags.isSRet()", A> {} +/// CCIfVarArg - If the current function is vararg - apply the action +class CCIfVarArg : CCIf<"State.isVarArg()", A> {} + /// CCIfNotVarArg - If the current function is not vararg - apply the action class CCIfNotVarArg : CCIf<"!State.isVarArg()", A> {} diff --git a/lib/Target/Mips/MipsCallingConv.td b/lib/Target/Mips/MipsCallingConv.td index a1fe969ca7d..f0a5577997a 100644 --- a/lib/Target/Mips/MipsCallingConv.td +++ b/lib/Target/Mips/MipsCallingConv.td @@ -343,6 +343,13 @@ def CC_Mips_VarArg : CallingConv<[ CCDelegateTo ]>; +def CC_Mips : CallingConv<[ + CCIfVarArg< + CCIf<"!static_cast(&State)->IsCallOperandFixed(ValNo)", + CCDelegateTo>>, + CCDelegateTo +]>; + //===----------------------------------------------------------------------===// // Callee-saved register lists. //===----------------------------------------------------------------------===// diff --git a/lib/Target/Mips/MipsISelLowering.cpp b/lib/Target/Mips/MipsISelLowering.cpp index 05f03ffe4f6..fdfd342bae3 100644 --- a/lib/Target/Mips/MipsISelLowering.cpp +++ b/lib/Target/Mips/MipsISelLowering.cpp @@ -117,12 +117,15 @@ private: /// Identify lowered values that originated from f128 arguments and record /// this. - void PreAnalyzeCallOperandsForF128( + void PreAnalyzeCallOperands( const SmallVectorImpl &Outs, - std::vector &FuncArgs, SDNode *CallNode) { - for (unsigned i = 0; i < Outs.size(); ++i) + std::vector &FuncArgs, + const SDNode *CallNode) { + for (unsigned i = 0; i < Outs.size(); ++i) { OriginalArgWasF128.push_back( originalTypeIsF128(FuncArgs[Outs[i].OrigArgIndex].Ty, CallNode)); + CallOperandIsFixed.push_back(Outs[i].IsFixed); + } } /// Identify lowered values that originated from f128 arguments and record @@ -151,21 +154,15 @@ private: /// Records whether the value has been lowered from an f128. SmallVector OriginalArgWasF128; + /// Records whether the value was a fixed argument. + /// See ISD::OutputArg::IsFixed, + SmallVector CallOperandIsFixed; + // Used to handle MIPS16-specific calling convention tweaks. // FIXME: This should probably be a fully fledged calling convention. SpecialCallingConvType SpecialCallingConv; public: - // FIXME: Remove this from a public inteface ASAP. It's a temporary trap door - // to allow analyzeCallOperands to be removed incrementally. - void PreAnalyzeCallOperandsForF128_( - const SmallVectorImpl &Outs, - std::vector &FuncArgs, SDNode *CallNode) { - PreAnalyzeCallOperandsForF128(Outs, FuncArgs, CallNode); - } - // FIXME: Remove this from a public inteface ASAP. It's a temporary trap door - // to clean up after the above functions. - void ClearOriginalArgWasF128() { OriginalArgWasF128.clear(); } MipsCCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF, const TargetMachine &TM, SmallVectorImpl &locs, @@ -173,6 +170,26 @@ public: SpecialCallingConvType SpecialCC = NoSpecialCallingConv) : CCState(CC, isVarArg, MF, TM, locs, C), SpecialCallingConv(SpecialCC) {} + void + AnalyzeCallOperands(const SmallVectorImpl &Outs, + CCAssignFn Fn, + std::vector &FuncArgs, + const SDNode *CallNode) { + PreAnalyzeCallOperands(Outs, FuncArgs, CallNode); + CCState::AnalyzeCallOperands(Outs, Fn); + OriginalArgWasF128.clear(); + CallOperandIsFixed.clear(); + } + + // 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 &Outs, + CCAssignFn Fn) = delete; + void AnalyzeCallOperands(const SmallVectorImpl &Outs, + SmallVectorImpl &Flags, + CCAssignFn Fn) = delete; + void AnalyzeFormalArguments(const SmallVectorImpl &Ins, CCAssignFn Fn) { PreAnalyzeFormalArgumentsForF128(Ins); @@ -204,6 +221,7 @@ public: } bool WasOriginalArgF128(unsigned ValNo) { return OriginalArgWasF128[ValNo]; } + bool IsCallOperandFixed(unsigned ValNo) { return CallOperandIsFixed[ValNo]; } SpecialCallingConvType getSpecialCallingConv() { return SpecialCallingConv; } }; } @@ -2616,9 +2634,7 @@ MipsTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, MipsCCState::getSpecialCallingConvForCallee(Callee.getNode(), Subtarget)); MipsCC MipsCCInfo(CallConv, Subtarget, CCInfo); - CCInfo.PreAnalyzeCallOperandsForF128_(Outs, CLI.getArgs(), Callee.getNode()); - MipsCCInfo.analyzeCallOperands(Outs, CLI.getArgs(), CCInfo); - CCInfo.ClearOriginalArgWasF128(); + CCInfo.AnalyzeCallOperands(Outs, CC_Mips, CLI.getArgs(), Callee.getNode()); // Get a count of how many bytes are to be pushed on the stack. unsigned NextStackOffset = CCInfo.getNextStackOffset(); @@ -3599,34 +3615,6 @@ MipsTargetLowering::MipsCC::MipsCC(CallingConv::ID CC, Info.AllocateStack(reservedArgArea(), 1); } -void MipsTargetLowering::MipsCC::analyzeCallOperands( - const SmallVectorImpl &Args, - std::vector &FuncArgs, CCState &State) { - assert((CallConv != CallingConv::Fast || !State.isVarArg()) && - "CallingConv::Fast shouldn't be used for vararg functions."); - - unsigned NumOpnds = Args.size(); - - for (unsigned I = 0; I != NumOpnds; ++I) { - MVT ArgVT = Args[I].VT; - ISD::ArgFlagsTy ArgFlags = Args[I].Flags; - bool R; - - if (State.isVarArg() && !Args[I].IsFixed) - R = CC_Mips_VarArg(I, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, State); - else - R = CC_Mips_FixedArg(I, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, State); - - if (R) { -#ifndef NDEBUG - dbgs() << "Call operand #" << I << " has unhandled type " - << EVT(ArgVT).getEVTString(); -#endif - llvm_unreachable(nullptr); - } - } -} - unsigned MipsTargetLowering::MipsCC::reservedArgArea() const { return (Subtarget.isABI_O32() && (CallConv != CallingConv::Fast)) ? 16 : 0; } diff --git a/lib/Target/Mips/MipsISelLowering.h b/lib/Target/Mips/MipsISelLowering.h index 1f2c56046a6..bc313464b06 100644 --- a/lib/Target/Mips/MipsISelLowering.h +++ b/lib/Target/Mips/MipsISelLowering.h @@ -347,10 +347,6 @@ namespace llvm { MipsCC(CallingConv::ID CallConv, const MipsSubtarget &Subtarget, CCState &Info); - void analyzeCallOperands(const SmallVectorImpl &Outs, - std::vector &FuncArgs, - CCState &State); - /// reservedArgArea - The size of the area the caller reserves for /// register arguments. This is 16-byte if ABI is O32. unsigned reservedArgArea() const;