LLVM  9.0.0svn
CallLowering.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/GlobalISel/CallLowering.h - Call lowering ---*- C++ -*-===//
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 /// \file
10 /// This file describes how to lower LLVM calls to machine code calls.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
15 #define LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
16 
17 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/IR/CallSite.h"
21 #include "llvm/IR/CallingConv.h"
24 #include <cstdint>
25 #include <functional>
26 
27 namespace llvm {
28 
29 class DataLayout;
30 class Function;
31 class MachineIRBuilder;
32 class MachineOperand;
33 struct MachinePointerInfo;
34 class MachineRegisterInfo;
35 class TargetLowering;
36 class Type;
37 class Value;
38 
39 class CallLowering {
40  const TargetLowering *TLI;
41 
42  virtual void anchor();
43 public:
44  struct ArgInfo {
45  unsigned Reg;
46  Type *Ty;
48  bool IsFixed;
49 
50  ArgInfo(unsigned Reg, Type *Ty, ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy{},
51  bool IsFixed = true)
52  : Reg(Reg), Ty(Ty), Flags(Flags), IsFixed(IsFixed) {}
53  };
54 
55  /// Argument handling is mostly uniform between the four places that
56  /// make these decisions: function formal arguments, call
57  /// instruction args, call instruction returns and function
58  /// returns. However, once a decision has been made on where an
59  /// arugment should go, exactly what happens can vary slightly. This
60  /// class abstracts the differences.
61  struct ValueHandler {
63  CCAssignFn *AssignFn)
64  : MIRBuilder(MIRBuilder), MRI(MRI), AssignFn(AssignFn) {}
65 
66  virtual ~ValueHandler() = default;
67 
68  /// Materialize a VReg containing the address of the specified
69  /// stack-based object. This is either based on a FrameIndex or
70  /// direct SP manipulation, depending on the context. \p MPO
71  /// should be initialized to an appropriate description of the
72  /// address created.
73  virtual unsigned getStackAddress(uint64_t Size, int64_t Offset,
74  MachinePointerInfo &MPO) = 0;
75 
76  /// The specified value has been assigned to a physical register,
77  /// handle the appropriate COPY (either to or from) and mark any
78  /// relevant uses/defines as needed.
79  virtual void assignValueToReg(unsigned ValVReg, unsigned PhysReg,
80  CCValAssign &VA) = 0;
81 
82  /// The specified value has been assigned to a stack
83  /// location. Load or store it there, with appropriate extension
84  /// if necessary.
85  virtual void assignValueToAddress(unsigned ValVReg, unsigned Addr,
86  uint64_t Size, MachinePointerInfo &MPO,
87  CCValAssign &VA) = 0;
88 
89  /// Handle custom values, which may be passed into one or more of \p VAs.
90  /// \return The number of \p VAs that have been assigned after the first
91  /// one, and which should therefore be skipped from further
92  /// processing.
93  virtual unsigned assignCustomValue(const ArgInfo &Arg,
95  // This is not a pure virtual method because not all targets need to worry
96  // about custom values.
97  llvm_unreachable("Custom values not supported");
98  }
99 
100  unsigned extendRegister(unsigned ValReg, CCValAssign &VA);
101 
102  virtual bool assignArg(unsigned ValNo, MVT ValVT, MVT LocVT,
103  CCValAssign::LocInfo LocInfo, const ArgInfo &Info,
104  CCState &State) {
105  return AssignFn(ValNo, ValVT, LocVT, LocInfo, Info.Flags, State);
106  }
107 
111 
112  private:
113  virtual void anchor();
114  };
115 
116 protected:
117  /// Getter for generic TargetLowering class.
118  const TargetLowering *getTLI() const {
119  return TLI;
120  }
121 
122  /// Getter for target specific TargetLowering class.
123  template <class XXXTargetLowering>
124  const XXXTargetLowering *getTLI() const {
125  return static_cast<const XXXTargetLowering *>(TLI);
126  }
127 
128  template <typename FuncInfoTy>
129  void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL,
130  const FuncInfoTy &FuncInfo) const;
131 
132  /// Invoke Handler::assignArg on each of the given \p Args and then use
133  /// \p Callback to move them to the assigned locations.
134  ///
135  /// \return True if everything has succeeded, false otherwise.
137  ValueHandler &Handler) const;
138 
139 public:
140  CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
141  virtual ~CallLowering() = default;
142 
143  /// This hook must be implemented to lower outgoing return values, described
144  /// by \p Val, into the specified virtual registers \p VRegs.
145  /// This hook is used by GlobalISel.
146  ///
147  /// \return True if the lowering succeeds, false otherwise.
148  virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
149  ArrayRef<unsigned> VRegs) const {
150  return false;
151  }
152 
153  /// This hook must be implemented to lower the incoming (formal)
154  /// arguments, described by \p Args, for GlobalISel. Each argument
155  /// must end up in the related virtual register described by VRegs.
156  /// In other words, the first argument should end up in VRegs[0],
157  /// the second in VRegs[1], and so on.
158  /// \p MIRBuilder is set to the proper insertion for the argument
159  /// lowering.
160  ///
161  /// \return True if the lowering succeeded, false otherwise.
162  virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder,
163  const Function &F,
164  ArrayRef<unsigned> VRegs) const {
165  return false;
166  }
167 
168  /// This hook must be implemented to lower the given call instruction,
169  /// including argument and return value marshalling.
170  ///
171  /// \p CallConv is the calling convention to be used for the call.
172  ///
173  /// \p Callee is the destination of the call. It should be either a register,
174  /// globaladdress, or externalsymbol.
175  ///
176  /// \p ResTy is the type returned by the function
177  ///
178  /// \p ResReg is the generic virtual register that the returned
179  /// value should be lowered into.
180  ///
181  /// \p ArgTys is a list of the types each member of \p ArgRegs has; used by
182  /// the target to decide which register/stack slot should be allocated.
183  ///
184  /// \p ArgRegs is a list of virtual registers containing each argument that
185  /// needs to be passed.
186  ///
187  /// \return true if the lowering succeeded, false otherwise.
188  virtual bool lowerCall(MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv,
189  const MachineOperand &Callee, const ArgInfo &OrigRet,
190  ArrayRef<ArgInfo> OrigArgs) const {
191  return false;
192  }
193 
194  /// Lower the given call instruction, including argument and return value
195  /// marshalling.
196  ///
197  /// \p CI is the call/invoke instruction.
198  ///
199  /// \p ResReg is a register where the call's return value should be stored (or
200  /// 0 if there is no return value).
201  ///
202  /// \p ArgRegs is a list of virtual registers containing each argument that
203  /// needs to be passed.
204  ///
205  /// \p GetCalleeReg is a callback to materialize a register for the callee if
206  /// the target determines it cannot jump to the destination based purely on \p
207  /// CI. This might be because \p CI is indirect, or because of the limited
208  /// range of an immediate jump.
209  ///
210  /// \return true if the lowering succeeded, false otherwise.
211  bool lowerCall(MachineIRBuilder &MIRBuilder, ImmutableCallSite CS,
212  unsigned ResReg, ArrayRef<unsigned> ArgRegs,
213  std::function<unsigned()> GetCalleeReg) const;
214 };
215 
216 } // end namespace llvm
217 
218 #endif // LLVM_CODEGEN_GLOBALISEL_CALLLOWERING_H
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:110
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:48
ValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI, CCAssignFn *AssignFn)
Definition: CallLowering.h:62
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MachineRegisterInfo & MRI
Definition: CallLowering.h:109
bool CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
CCAssignFn - This function assigns a location for Val, updating State to reflect the change...
F(f)
ArgInfo(unsigned Reg, Type *Ty, ISD::ArgFlagsTy Flags=ISD::ArgFlagsTy{}, bool IsFixed=true)
Definition: CallLowering.h:50
bool handleAssignments(MachineIRBuilder &MIRBuilder, ArrayRef< ArgInfo > Args, ValueHandler &Handler) const
Invoke Handler::assignArg on each of the given Args and then use Callback to move them to the assigne...
const TargetLowering * getTLI() const
Getter for generic TargetLowering class.
Definition: CallLowering.h:118
virtual bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F, ArrayRef< unsigned > VRegs) const
This hook must be implemented to lower the incoming (formal) arguments, described by Args...
Definition: CallLowering.h:162
const XXXTargetLowering * getTLI() const
Getter for target specific TargetLowering class.
Definition: CallLowering.h:124
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
virtual ~CallLowering()=default
unsigned const MachineRegisterInfo * MRI
Machine Value Type.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
virtual bool lowerCall(MachineIRBuilder &MIRBuilder, CallingConv::ID CallConv, const MachineOperand &Callee, const ArgInfo &OrigRet, ArrayRef< ArgInfo > OrigArgs) const
This hook must be implemented to lower the given call instruction, including argument and return valu...
Definition: CallLowering.h:188
Helper class to build MachineInstr.
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL, const FuncInfoTy &FuncInfo) const
CallLowering(const TargetLowering *TLI)
Definition: CallLowering.h:140
Argument handling is mostly uniform between the four places that make these decisions: function forma...
Definition: CallLowering.h:61
This class contains a discriminated union of information about pointers in memory operands...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
virtual unsigned assignCustomValue(const ArgInfo &Arg, ArrayRef< CCValAssign > VAs)
Handle custom values, which may be passed into one or more of VAs.
Definition: CallLowering.h:93
CCState - This class holds information needed while lowering arguments and return values...
MachineOperand class - Representation of each machine instruction operand.
CCValAssign - Represent assignment of one arg/retval to a location.
virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val, ArrayRef< unsigned > VRegs) const
This hook must be implemented to lower outgoing return values, described by Val, into the specified v...
Definition: CallLowering.h:148
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
Establish a view to a call site for examination.
Definition: CallSite.h:892
virtual bool assignArg(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, const ArgInfo &Info, CCState &State)
Definition: CallLowering.h:102
uint32_t Size
Definition: Profile.cpp:46
LLVM Value Representation.
Definition: Value.h:72
print Print MemDeps of function
constexpr char Args[]
Key for Kernel::Metadata::mArgs.