1 //===---- MipsCCState.h - CCState with Mips specific extensions -----------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef MIPSCCSTATE_H 11 #define MIPSCCSTATE_H 12 13 #include "MipsISelLowering.h" 14 #include "llvm/ADT/SmallVector.h" 15 #include "llvm/CodeGen/CallingConvLower.h" 16 17 namespace llvm { 18 class SDNode; 19 class MipsSubtarget; 20 21 class MipsCCState : public CCState { 22 public: 23 enum SpecialCallingConvType { Mips16RetHelperConv, NoSpecialCallingConv }; 24 25 /// Determine the SpecialCallingConvType for the given callee 26 static SpecialCallingConvType 27 getSpecialCallingConvForCallee(const SDNode *Callee, 28 const MipsSubtarget &Subtarget); 29 30 private: 31 /// Identify lowered values that originated from f128 arguments and record 32 /// this for use by RetCC_MipsN. 33 void PreAnalyzeCallResultForF128(const SmallVectorImpl<ISD::InputArg> &Ins, 34 const TargetLowering::CallLoweringInfo &CLI); 35 36 /// Identify lowered values that originated from f128 arguments and record 37 /// this for use by RetCC_MipsN. 38 void PreAnalyzeReturnForF128(const SmallVectorImpl<ISD::OutputArg> &Outs); 39 40 /// Identify lowered values that originated from f128 arguments and record 41 /// this. 42 void 43 PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs, 44 std::vector<TargetLowering::ArgListEntry> &FuncArgs, 45 const SDNode *CallNode); 46 47 /// Identify lowered values that originated from f128 arguments and record 48 /// this. 49 void 50 PreAnalyzeFormalArgumentsForF128(const SmallVectorImpl<ISD::InputArg> &Ins); 51 52 /// Records whether the value has been lowered from an f128. 53 SmallVector<bool, 4> OriginalArgWasF128; 54 55 /// Records whether the value has been lowered from float. 56 SmallVector<bool, 4> OriginalArgWasFloat; 57 58 /// Records whether the value was a fixed argument. 59 /// See ISD::OutputArg::IsFixed, 60 SmallVector<bool, 4> CallOperandIsFixed; 61 62 // Used to handle MIPS16-specific calling convention tweaks. 63 // FIXME: This should probably be a fully fledged calling convention. 64 SpecialCallingConvType SpecialCallingConv; 65 66 public: 67 MipsCCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF, 68 SmallVectorImpl<CCValAssign> &locs, LLVMContext &C, 69 SpecialCallingConvType SpecialCC = NoSpecialCallingConv) CCState(CC,isVarArg,MF,locs,C)70 : CCState(CC, isVarArg, MF, locs, C), SpecialCallingConv(SpecialCC) {} 71 72 void AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> & Outs,CCAssignFn Fn,std::vector<TargetLowering::ArgListEntry> & FuncArgs,const SDNode * CallNode)73 AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs, 74 CCAssignFn Fn, 75 std::vector<TargetLowering::ArgListEntry> &FuncArgs, 76 const SDNode *CallNode) { 77 PreAnalyzeCallOperands(Outs, FuncArgs, CallNode); 78 CCState::AnalyzeCallOperands(Outs, Fn); 79 OriginalArgWasF128.clear(); 80 OriginalArgWasFloat.clear(); 81 CallOperandIsFixed.clear(); 82 } 83 84 // The AnalyzeCallOperands in the base class is not usable since we must 85 // provide a means of accessing ArgListEntry::IsFixed. Delete them from this 86 // class. This doesn't stop them being used via the base class though. 87 void AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs, 88 CCAssignFn Fn) = delete; 89 void AnalyzeCallOperands(const SmallVectorImpl<MVT> &Outs, 90 SmallVectorImpl<ISD::ArgFlagsTy> &Flags, 91 CCAssignFn Fn) = delete; 92 AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> & Ins,CCAssignFn Fn)93 void AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins, 94 CCAssignFn Fn) { 95 PreAnalyzeFormalArgumentsForF128(Ins); 96 CCState::AnalyzeFormalArguments(Ins, Fn); 97 OriginalArgWasFloat.clear(); 98 OriginalArgWasF128.clear(); 99 } 100 AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> & Ins,CCAssignFn Fn,const TargetLowering::CallLoweringInfo & CLI)101 void AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins, 102 CCAssignFn Fn, 103 const TargetLowering::CallLoweringInfo &CLI) { 104 PreAnalyzeCallResultForF128(Ins, CLI); 105 CCState::AnalyzeCallResult(Ins, Fn); 106 OriginalArgWasFloat.clear(); 107 OriginalArgWasF128.clear(); 108 } 109 AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> & Outs,CCAssignFn Fn)110 void AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs, 111 CCAssignFn Fn) { 112 PreAnalyzeReturnForF128(Outs); 113 CCState::AnalyzeReturn(Outs, Fn); 114 OriginalArgWasFloat.clear(); 115 OriginalArgWasF128.clear(); 116 } 117 CheckReturn(const SmallVectorImpl<ISD::OutputArg> & ArgsFlags,CCAssignFn Fn)118 bool CheckReturn(const SmallVectorImpl<ISD::OutputArg> &ArgsFlags, 119 CCAssignFn Fn) { 120 PreAnalyzeReturnForF128(ArgsFlags); 121 bool Return = CCState::CheckReturn(ArgsFlags, Fn); 122 OriginalArgWasFloat.clear(); 123 OriginalArgWasF128.clear(); 124 return Return; 125 } 126 WasOriginalArgF128(unsigned ValNo)127 bool WasOriginalArgF128(unsigned ValNo) { return OriginalArgWasF128[ValNo]; } WasOriginalArgFloat(unsigned ValNo)128 bool WasOriginalArgFloat(unsigned ValNo) { 129 return OriginalArgWasFloat[ValNo]; 130 } IsCallOperandFixed(unsigned ValNo)131 bool IsCallOperandFixed(unsigned ValNo) { return CallOperandIsFixed[ValNo]; } getSpecialCallingConv()132 SpecialCallingConvType getSpecialCallingConv() { return SpecialCallingConv; } 133 }; 134 } 135 136 #endif 137