[GlobalISel] Refactory CallLowering handleAssignments for custom <Target>CCState

[xiangzhai]

Summary

Hi LLVM developers,

Motivation:

As Alex suggested , I refactory handleAssignments in the CallLowering, so it is able to override handleAssignments in your <Target>CallLowering to initial your <Target>CCState, for example:

RISCVCCState CCInfo(F.getCallingConv(), F.isVarArg(), MF, ArgLocs,                  
            F.getContext() ...); // Add more custom variables to meet your Target's requirement

And it also need to override assignArg in your <Target>CallLowering, cast CCState to custom <Target>CCState, then do some target-specific treatment.

Please review my patch, and give me some suggestion, thanks for your teaching!

Regards,
Leslie Zhai

[aemerson]

include/llvm/CodeGen/GlobalISel/CallLowering.h

189

Why move the implementation to the header?

[xiangzhai]

include/llvm/CodeGen/GlobalISel/CallLowering.h

105–106

Pass a dummy AssignFn to the ValueHandler constructor and override

ValueHandler::assignArg

As Alex suggested, I pass a nullptr AssignFn for making immediate progress firstly in D41653, but we will change approach prior in D41700.

Please give me some suggestion about this change, thanks for your teaching!

189

Hi Amara,

Thanks for your review!

I just want to keep coding style, so I move the implementation of a Interface, defined as virtual function, to the header file. I also put the implementation of Graph Coloring all in header files https://github.com/xiangzhai/llvm/tree/riscv/include/llvm/CodeGen/GCol

I will revert the implementation back to source file, if not LGTU :)

Regards,
Leslie Zhai

[xiangzhai]

Hi LLVM developers,

As Amara suggested, I revert handleAssignments, only add virtual to be a interface, so it is able to override handleAssignments in your <Target>CallLowering to initial your <Target>CCState.

Please review my patch again, thanks a lot!

Regards,
Leslie Zhai

include/llvm/CodeGen/GlobalISel/CallLowering.h

virtual unsigned assignCustomValue(const ArgInfo &Arg,
       llvm_unreachable("Custom values not supported");
     }
 
     unsigned extendRegister(unsigned ValReg, CCValAssign &VA);
 
     virtual bool assignArg(unsigned ValNo, MVT ValVT, MVT LocVT,
                            CCValAssign::LocInfo LocInfo, const ArgInfo &Info,
                            CCState &State) {
-      return AssignFn(ValNo, ValVT, LocVT, LocInfo, Info.Flags, State);
+      return AssignFn ?
+          AssignFn(ValNo, ValVT, LocVT, LocInfo, Info.Flags, State) : false;
     }
 
     MachineIRBuilder &MIRBuilder;
     MachineRegisterInfo &MRI;
     CCAssignFn *AssignFn;
   };
 
 protected:
   /// Getter for generic TargetLowering class.
   const TargetLowering *getTLI() const {
     return TLI;
   }
 
   /// Getter for target specific TargetLowering class.
   template <class XXXTargetLowering>
     const XXXTargetLowering *getTLI() const {
     return static_cast<const XXXTargetLowering *>(TLI);
   }
 
   template <typename FuncInfoTy>
   void setArgFlags(ArgInfo &Arg, unsigned OpNum, const DataLayout &DL,
                    const FuncInfoTy &FuncInfo) const;
 
-  /// Invoke Handler::assignArg on each of the given \p Args and then use
-  /// \p Callback to move them to the assigned locations.
-  ///
-  /// \return True if everything has succeeded, false otherwise.
-  bool handleAssignments(MachineIRBuilder &MIRBuilder, ArrayRef<ArgInfo> Args,
-                         ValueHandler &Callback) const;
-
 public:
   CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
   virtual ~CallLowering() = default;
 
   /// This hook must be implemented to lower outgoing return values, described
   /// by \p Val, into the specified virtual register \p VReg.
   /// This hook is used by GlobalISel.
   ///
public:
   ///
   /// \return true if the lowering succeeded, false otherwise.
   virtual bool lowerCall(MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv,
                          const MachineOperand &Callee, const ArgInfo &OrigRet,
                          ArrayRef<ArgInfo> OrigArgs) const {
     return false;
   }
 
+  /// Invoke Handler::assignArg on each of the given \p Args and then use
+  /// \p Callback to move them to the assigned locations.
+  ///
+  /// \return True if everything has succeeded, false otherwise.
+  virtual bool handleAssignments(MachineIRBuilder &MIRBuilder,
+                                 ArrayRef<ArgInfo> Args,
+                                 ValueHandler &Handler) const;
+
   /// Lower the given call instruction, including argument and return value
   /// marshalling.
   ///
   /// \p CI is the call/invoke instruction.
   ///
   /// \p ResReg is a register where the call's return value should be stored (or
   /// 0 if there is no return value).
   ///