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