llvm/lib/Target/Mips/MipsCCState.h

   1 //===---- MipsCCState.h - CCState with Mips specific extensions -----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef MIPSCCSTATE_H
  10 #define MIPSCCSTATE_H
  11
  12 #include "MipsISelLowering.h"
  13 #include "llvm/ADT/SmallVector.h"
  14 #include "llvm/CodeGen/CallingConvLower.h"
  15
  16 namespace llvm {
  17 class SDNode;
  18 class MipsSubtarget;
  19
  20 class MipsCCState : public CCState {
  21 public:
  22   enum SpecialCallingConvType { Mips16RetHelperConv, NoSpecialCallingConv };
  23
  24   /// Determine the SpecialCallingConvType for the given callee
  25   static SpecialCallingConvType
  26   getSpecialCallingConvForCallee(const SDNode *Callee,
  27                                  const MipsSubtarget &Subtarget);
  28
  29   /// This function returns true if CallSym is a long double emulation routine.
  30   ///
  31   /// FIXME: Changing the ABI based on the callee name is unsound. The lib func
  32   /// address could be captured.
  33   static bool isF128SoftLibCall(const char *CallSym);
  34
  35   static bool originalTypeIsF128(const Type *Ty, const char *Func);
  36   static bool originalEVTTypeIsVectorFloat(EVT Ty);
  37   static bool originalTypeIsVectorFloat(const Type *Ty);
  38
  39   void PreAnalyzeCallOperand(const Type *ArgTy, bool IsFixed, const char *Func);
  40
  41   void PreAnalyzeFormalArgument(const Type *ArgTy, ISD::ArgFlagsTy Flags);
  42   void PreAnalyzeReturnValue(EVT ArgVT);
  43
  44 private:
  45   /// Identify lowered values that originated from f128 arguments and record
  46   /// this for use by RetCC_MipsN.
  47   void PreAnalyzeCallResultForF128(const SmallVectorImpl<ISD::InputArg> &Ins,
  48                                    const Type *RetTy, const char * Func);
  49
  50   /// Identify lowered values that originated from f128 arguments and record
  51   /// this for use by RetCC_MipsN.
  52   void PreAnalyzeReturnForF128(const SmallVectorImpl<ISD::OutputArg> &Outs);
  53
  54   /// Identify lowered values that originated from f128 arguments and record
  55   /// this.
  56   void
  57   PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
  58                          std::vector<TargetLowering::ArgListEntry> &FuncArgs,
  59                          const char *Func);
  60
  61   /// Identify lowered values that originated from f128 arguments and record
  62   /// this for use by RetCC_MipsN.
  63   void
  64   PreAnalyzeFormalArgumentsForF128(const SmallVectorImpl<ISD::InputArg> &Ins);
  65
  66   void
  67   PreAnalyzeCallResultForVectorFloat(const SmallVectorImpl<ISD::InputArg> &Ins,
  68                                      const Type *RetTy);
  69
  70   void PreAnalyzeFormalArgumentsForVectorFloat(
  71       const SmallVectorImpl<ISD::InputArg> &Ins);
  72
  73   void
  74   PreAnalyzeReturnForVectorFloat(const SmallVectorImpl<ISD::OutputArg> &Outs);
  75
  76   /// Records whether the value has been lowered from an f128.
  77   SmallVector<bool, 4> OriginalArgWasF128;
  78
  79   /// Records whether the value has been lowered from float.
  80   SmallVector<bool, 4> OriginalArgWasFloat;
  81
  82   /// Records whether the value has been lowered from a floating point vector.
  83   SmallVector<bool, 4> OriginalArgWasFloatVector;
  84
  85   /// Records whether the return value has been lowered from a floating point
  86   /// vector.
  87   SmallVector<bool, 4> OriginalRetWasFloatVector;
  88
  89   /// Records whether the value was a fixed argument.
  90   /// See ISD::OutputArg::IsFixed,
  91   SmallVector<bool, 4> CallOperandIsFixed;
  92
  93   // Used to handle MIPS16-specific calling convention tweaks.
  94   // FIXME: This should probably be a fully fledged calling convention.
  95   SpecialCallingConvType SpecialCallingConv;
  96
  97 public:
  98   MipsCCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF,
  99               SmallVectorImpl<CCValAssign> &locs, LLVMContext &C,
 100               SpecialCallingConvType SpecialCC = NoSpecialCallingConv)
 101       : CCState(CC, isVarArg, MF, locs, C), SpecialCallingConv(SpecialCC) {}
 102
 103   void PreAnalyzeCallOperands(
 104       const SmallVectorImpl<ISD::OutputArg> &Outs, CCAssignFn Fn,
 105       std::vector<TargetLowering::ArgListEntry> &FuncArgs, const char *Func) {
 106     OriginalArgWasF128.clear();
 107     OriginalArgWasFloat.clear();
 108     OriginalArgWasFloatVector.clear();
 109     CallOperandIsFixed.clear();
 110     PreAnalyzeCallOperands(Outs, FuncArgs, Func);
 111   }
 112
 113   void
 114   AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
 115                       CCAssignFn Fn,
 116                       std::vector<TargetLowering::ArgListEntry> &FuncArgs,
 117                       const char *Func) {
 118     PreAnalyzeCallOperands(Outs, Fn, FuncArgs, Func);
 119     CCState::AnalyzeCallOperands(Outs, Fn);
 120   }
 121
 122   // The AnalyzeCallOperands in the base class is not usable since we must
 123   // provide a means of accessing ArgListEntry::IsFixed. Delete them from this
 124   // class. This doesn't stop them being used via the base class though.
 125   void AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
 126                            CCAssignFn Fn) = delete;
 127   void AnalyzeCallOperands(const SmallVectorImpl<MVT> &Outs,
 128                            SmallVectorImpl<ISD::ArgFlagsTy> &Flags,
 129                            CCAssignFn Fn) = delete;
 130
 131   void PreAnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
 132                                  CCAssignFn Fn) {
 133     OriginalArgWasFloat.clear();
 134     OriginalArgWasF128.clear();
 135     OriginalArgWasFloatVector.clear();
 136     PreAnalyzeFormalArgumentsForF128(Ins);
 137   }
 138
 139   void AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
 140                               CCAssignFn Fn) {
 141     PreAnalyzeFormalArguments(Ins, Fn);
 142     CCState::AnalyzeFormalArguments(Ins, Fn);
 143   }
 144
 145   void PreAnalyzeCallResult(const Type *RetTy, const char *Func) {
 146     OriginalArgWasF128.push_back(originalTypeIsF128(RetTy, Func));
 147     OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
 148     OriginalRetWasFloatVector.push_back(originalTypeIsVectorFloat(RetTy));
 149   }
 150
 151   void PreAnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
 152                             CCAssignFn Fn, const Type *RetTy,
 153                             const char *Func) {
 154     OriginalArgWasFloat.clear();
 155     OriginalArgWasF128.clear();
 156     OriginalArgWasFloatVector.clear();
 157     PreAnalyzeCallResultForF128(Ins, RetTy, Func);
 158     PreAnalyzeCallResultForVectorFloat(Ins, RetTy);
 159   }
 160
 161   void AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
 162                          CCAssignFn Fn, const Type *RetTy,
 163                          const char *Func) {
 164     PreAnalyzeCallResult(Ins, Fn, RetTy, Func);
 165     CCState::AnalyzeCallResult(Ins, Fn);
 166   }
 167
 168   void PreAnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
 169                         CCAssignFn Fn) {
 170     OriginalArgWasFloat.clear();
 171     OriginalArgWasF128.clear();
 172     OriginalArgWasFloatVector.clear();
 173     PreAnalyzeReturnForF128(Outs);
 174     PreAnalyzeReturnForVectorFloat(Outs);
 175   }
 176
 177   void AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
 178                      CCAssignFn Fn) {
 179     PreAnalyzeReturn(Outs, Fn);
 180     CCState::AnalyzeReturn(Outs, Fn);
 181   }
 182
 183   bool CheckReturn(const SmallVectorImpl<ISD::OutputArg> &ArgsFlags,
 184                    CCAssignFn Fn) {
 185     PreAnalyzeReturnForF128(ArgsFlags);
 186     PreAnalyzeReturnForVectorFloat(ArgsFlags);
 187     bool Return = CCState::CheckReturn(ArgsFlags, Fn);
 188     OriginalArgWasFloat.clear();
 189     OriginalArgWasF128.clear();
 190     OriginalArgWasFloatVector.clear();
 191     return Return;
 192   }
 193
 194   bool WasOriginalArgF128(unsigned ValNo) { return OriginalArgWasF128[ValNo]; }
 195   bool WasOriginalArgFloat(unsigned ValNo) {
 196       return OriginalArgWasFloat[ValNo];
 197   }
 198   bool WasOriginalArgVectorFloat(unsigned ValNo) const {
 199     return OriginalArgWasFloatVector[ValNo];
 200   }
 201   bool WasOriginalRetVectorFloat(unsigned ValNo) const {
 202     return OriginalRetWasFloatVector[ValNo];
 203   }
 204   bool IsCallOperandFixed(unsigned ValNo) { return CallOperandIsFixed[ValNo]; }
 205   SpecialCallingConvType getSpecialCallingConv() { return SpecialCallingConv; }
 206 };
 207 }
 208
 209 #endif