LLVM  10.0.0svn
X86CallLowering.cpp
Go to the documentation of this file.
1 //===- llvm/lib/Target/X86/X86CallLowering.cpp - Call lowering ------------===//
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 implements the lowering of LLVM calls to machine code calls for
11 /// GlobalISel.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "X86CallLowering.h"
16 #include "X86CallingConv.h"
17 #include "X86ISelLowering.h"
18 #include "X86InstrInfo.h"
19 #include "X86RegisterInfo.h"
20 #include "X86Subtarget.h"
21 #include "llvm/ADT/ArrayRef.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/CodeGen/Analysis.h"
38 #include "llvm/IR/Attributes.h"
39 #include "llvm/IR/DataLayout.h"
40 #include "llvm/IR/Function.h"
41 #include "llvm/IR/Value.h"
42 #include "llvm/MC/MCRegisterInfo.h"
45 #include <cassert>
46 #include <cstdint>
47 
48 using namespace llvm;
49 
51  : CallLowering(&TLI) {}
52 
53 bool X86CallLowering::splitToValueTypes(const ArgInfo &OrigArg,
54  SmallVectorImpl<ArgInfo> &SplitArgs,
55  const DataLayout &DL,
57  SplitArgTy PerformArgSplit) const {
58  const X86TargetLowering &TLI = *getTLI<X86TargetLowering>();
59  LLVMContext &Context = OrigArg.Ty->getContext();
60 
61  SmallVector<EVT, 4> SplitVTs;
63  ComputeValueVTs(TLI, DL, OrigArg.Ty, SplitVTs, &Offsets, 0);
64  assert(OrigArg.Regs.size() == 1 && "Can't handle multple regs yet");
65 
66  if (OrigArg.Ty->isVoidTy())
67  return true;
68 
69  EVT VT = SplitVTs[0];
70  unsigned NumParts = TLI.getNumRegisters(Context, VT);
71 
72  if (NumParts == 1) {
73  // replace the original type ( pointer -> GPR ).
74  SplitArgs.emplace_back(OrigArg.Regs[0], VT.getTypeForEVT(Context),
75  OrigArg.Flags, OrigArg.IsFixed);
76  return true;
77  }
78 
79  SmallVector<Register, 8> SplitRegs;
80 
81  EVT PartVT = TLI.getRegisterType(Context, VT);
82  Type *PartTy = PartVT.getTypeForEVT(Context);
83 
84  for (unsigned i = 0; i < NumParts; ++i) {
85  ArgInfo Info =
87  PartTy, OrigArg.Flags};
88  SplitArgs.push_back(Info);
89  SplitRegs.push_back(Info.Regs[0]);
90  }
91 
92  PerformArgSplit(SplitRegs);
93  return true;
94 }
95 
96 namespace {
97 
98 struct OutgoingValueHandler : public CallLowering::ValueHandler {
99  OutgoingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI,
100  MachineInstrBuilder &MIB, CCAssignFn *AssignFn)
101  : ValueHandler(MIRBuilder, MRI, AssignFn), MIB(MIB),
102  DL(MIRBuilder.getMF().getDataLayout()),
103  STI(MIRBuilder.getMF().getSubtarget<X86Subtarget>()) {}
104 
105  Register getStackAddress(uint64_t Size, int64_t Offset,
106  MachinePointerInfo &MPO) override {
107  LLT p0 = LLT::pointer(0, DL.getPointerSizeInBits(0));
108  LLT SType = LLT::scalar(DL.getPointerSizeInBits(0));
109  Register SPReg = MRI.createGenericVirtualRegister(p0);
110  MIRBuilder.buildCopy(SPReg, STI.getRegisterInfo()->getStackRegister());
111 
112  Register OffsetReg = MRI.createGenericVirtualRegister(SType);
113  MIRBuilder.buildConstant(OffsetReg, Offset);
114 
115  Register AddrReg = MRI.createGenericVirtualRegister(p0);
116  MIRBuilder.buildGEP(AddrReg, SPReg, OffsetReg);
117 
118  MPO = MachinePointerInfo::getStack(MIRBuilder.getMF(), Offset);
119  return AddrReg;
120  }
121 
122  void assignValueToReg(Register ValVReg, Register PhysReg,
123  CCValAssign &VA) override {
124  MIB.addUse(PhysReg, RegState::Implicit);
125 
126  Register ExtReg;
127  // If we are copying the value to a physical register with the
128  // size larger than the size of the value itself - build AnyExt
129  // to the size of the register first and only then do the copy.
130  // The example of that would be copying from s32 to xmm0, for which
131  // case ValVT == LocVT == MVT::f32. If LocSize and ValSize are not equal
132  // we expect normal extendRegister mechanism to work.
133  unsigned PhysRegSize =
134  MRI.getTargetRegisterInfo()->getRegSizeInBits(PhysReg, MRI);
135  unsigned ValSize = VA.getValVT().getSizeInBits();
136  unsigned LocSize = VA.getLocVT().getSizeInBits();
137  if (PhysRegSize > ValSize && LocSize == ValSize) {
138  assert((PhysRegSize == 128 || PhysRegSize == 80) && "We expect that to be 128 bit");
139  auto MIB = MIRBuilder.buildAnyExt(LLT::scalar(PhysRegSize), ValVReg);
140  ExtReg = MIB->getOperand(0).getReg();
141  } else
142  ExtReg = extendRegister(ValVReg, VA);
143 
144  MIRBuilder.buildCopy(PhysReg, ExtReg);
145  }
146 
147  void assignValueToAddress(Register ValVReg, Register Addr, uint64_t Size,
148  MachinePointerInfo &MPO, CCValAssign &VA) override {
149  Register ExtReg = extendRegister(ValVReg, VA);
150  auto MMO = MIRBuilder.getMF().getMachineMemOperand(
152  /* Alignment */ 1);
153  MIRBuilder.buildStore(ExtReg, Addr, *MMO);
154  }
155 
156  bool assignArg(unsigned ValNo, MVT ValVT, MVT LocVT,
157  CCValAssign::LocInfo LocInfo,
159  CCState &State) override {
160  bool Res = AssignFn(ValNo, ValVT, LocVT, LocInfo, Flags, State);
161  StackSize = State.getNextStackOffset();
162 
163  static const MCPhysReg XMMArgRegs[] = {X86::XMM0, X86::XMM1, X86::XMM2,
164  X86::XMM3, X86::XMM4, X86::XMM5,
165  X86::XMM6, X86::XMM7};
166  if (!Info.IsFixed)
167  NumXMMRegs = State.getFirstUnallocated(XMMArgRegs);
168 
169  return Res;
170  }
171 
172  uint64_t getStackSize() { return StackSize; }
173  uint64_t getNumXmmRegs() { return NumXMMRegs; }
174 
175 protected:
176  MachineInstrBuilder &MIB;
177  uint64_t StackSize = 0;
178  const DataLayout &DL;
179  const X86Subtarget &STI;
180  unsigned NumXMMRegs = 0;
181 };
182 
183 } // end anonymous namespace
184 
186  MachineIRBuilder &MIRBuilder, const Value *Val,
187  ArrayRef<Register> VRegs) const {
188  assert(((Val && !VRegs.empty()) || (!Val && VRegs.empty())) &&
189  "Return value without a vreg");
190  auto MIB = MIRBuilder.buildInstrNoInsert(X86::RET).addImm(0);
191 
192  if (!VRegs.empty()) {
193  MachineFunction &MF = MIRBuilder.getMF();
194  const Function &F = MF.getFunction();
195  MachineRegisterInfo &MRI = MF.getRegInfo();
196  auto &DL = MF.getDataLayout();
197  LLVMContext &Ctx = Val->getType()->getContext();
198  const X86TargetLowering &TLI = *getTLI<X86TargetLowering>();
199 
200  SmallVector<EVT, 4> SplitEVTs;
201  ComputeValueVTs(TLI, DL, Val->getType(), SplitEVTs);
202  assert(VRegs.size() == SplitEVTs.size() &&
203  "For each split Type there should be exactly one VReg.");
204 
205  SmallVector<ArgInfo, 8> SplitArgs;
206  for (unsigned i = 0; i < SplitEVTs.size(); ++i) {
207  ArgInfo CurArgInfo = ArgInfo{VRegs[i], SplitEVTs[i].getTypeForEVT(Ctx)};
208  setArgFlags(CurArgInfo, AttributeList::ReturnIndex, DL, F);
209  if (!splitToValueTypes(CurArgInfo, SplitArgs, DL, MRI,
210  [&](ArrayRef<Register> Regs) {
211  MIRBuilder.buildUnmerge(Regs, VRegs[i]);
212  }))
213  return false;
214  }
215 
216  OutgoingValueHandler Handler(MIRBuilder, MRI, MIB, RetCC_X86);
217  if (!handleAssignments(MIRBuilder, SplitArgs, Handler))
218  return false;
219  }
220 
221  MIRBuilder.insertInstr(MIB);
222  return true;
223 }
224 
225 namespace {
226 
227 struct IncomingValueHandler : public CallLowering::ValueHandler {
228  IncomingValueHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI,
229  CCAssignFn *AssignFn)
230  : ValueHandler(MIRBuilder, MRI, AssignFn),
231  DL(MIRBuilder.getMF().getDataLayout()) {}
232 
233  bool isIncomingArgumentHandler() const override { return true; }
234 
235  Register getStackAddress(uint64_t Size, int64_t Offset,
236  MachinePointerInfo &MPO) override {
237  auto &MFI = MIRBuilder.getMF().getFrameInfo();
238  int FI = MFI.CreateFixedObject(Size, Offset, true);
239  MPO = MachinePointerInfo::getFixedStack(MIRBuilder.getMF(), FI);
240 
243  MIRBuilder.buildFrameIndex(AddrReg, FI);
244  return AddrReg;
245  }
246 
247  void assignValueToAddress(Register ValVReg, Register Addr, uint64_t Size,
248  MachinePointerInfo &MPO, CCValAssign &VA) override {
249  auto MMO = MIRBuilder.getMF().getMachineMemOperand(
251  1);
252  MIRBuilder.buildLoad(ValVReg, Addr, *MMO);
253  }
254 
255  void assignValueToReg(Register ValVReg, Register PhysReg,
256  CCValAssign &VA) override {
257  markPhysRegUsed(PhysReg);
258 
259  switch (VA.getLocInfo()) {
260  default: {
261  // If we are copying the value from a physical register with the
262  // size larger than the size of the value itself - build the copy
263  // of the phys reg first and then build the truncation of that copy.
264  // The example of that would be copying from xmm0 to s32, for which
265  // case ValVT == LocVT == MVT::f32. If LocSize and ValSize are not equal
266  // we expect this to be handled in SExt/ZExt/AExt case.
267  unsigned PhysRegSize =
268  MRI.getTargetRegisterInfo()->getRegSizeInBits(PhysReg, MRI);
269  unsigned ValSize = VA.getValVT().getSizeInBits();
270  unsigned LocSize = VA.getLocVT().getSizeInBits();
271  if (PhysRegSize > ValSize && LocSize == ValSize) {
272  auto Copy = MIRBuilder.buildCopy(LLT::scalar(PhysRegSize), PhysReg);
273  MIRBuilder.buildTrunc(ValVReg, Copy);
274  return;
275  }
276 
277  MIRBuilder.buildCopy(ValVReg, PhysReg);
278  break;
279  }
280  case CCValAssign::LocInfo::SExt:
281  case CCValAssign::LocInfo::ZExt:
282  case CCValAssign::LocInfo::AExt: {
283  auto Copy = MIRBuilder.buildCopy(LLT{VA.getLocVT()}, PhysReg);
284  MIRBuilder.buildTrunc(ValVReg, Copy);
285  break;
286  }
287  }
288  }
289 
290  /// How the physical register gets marked varies between formal
291  /// parameters (it's a basic-block live-in), and a call instruction
292  /// (it's an implicit-def of the BL).
293  virtual void markPhysRegUsed(unsigned PhysReg) = 0;
294 
295 protected:
296  const DataLayout &DL;
297 };
298 
299 struct FormalArgHandler : public IncomingValueHandler {
300  FormalArgHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI,
301  CCAssignFn *AssignFn)
302  : IncomingValueHandler(MIRBuilder, MRI, AssignFn) {}
303 
304  void markPhysRegUsed(unsigned PhysReg) override {
305  MIRBuilder.getMRI()->addLiveIn(PhysReg);
306  MIRBuilder.getMBB().addLiveIn(PhysReg);
307  }
308 };
309 
310 struct CallReturnHandler : public IncomingValueHandler {
311  CallReturnHandler(MachineIRBuilder &MIRBuilder, MachineRegisterInfo &MRI,
312  CCAssignFn *AssignFn, MachineInstrBuilder &MIB)
313  : IncomingValueHandler(MIRBuilder, MRI, AssignFn), MIB(MIB) {}
314 
315  void markPhysRegUsed(unsigned PhysReg) override {
316  MIB.addDef(PhysReg, RegState::Implicit);
317  }
318 
319 protected:
320  MachineInstrBuilder &MIB;
321 };
322 
323 } // end anonymous namespace
324 
326  MachineIRBuilder &MIRBuilder, const Function &F,
327  ArrayRef<ArrayRef<Register>> VRegs) const {
328  if (F.arg_empty())
329  return true;
330 
331  // TODO: handle variadic function
332  if (F.isVarArg())
333  return false;
334 
335  MachineFunction &MF = MIRBuilder.getMF();
336  MachineRegisterInfo &MRI = MF.getRegInfo();
337  auto DL = MF.getDataLayout();
338 
339  SmallVector<ArgInfo, 8> SplitArgs;
340  unsigned Idx = 0;
341  for (auto &Arg : F.args()) {
342 
343  // TODO: handle not simple cases.
344  if (Arg.hasAttribute(Attribute::ByVal) ||
345  Arg.hasAttribute(Attribute::InReg) ||
346  Arg.hasAttribute(Attribute::StructRet) ||
347  Arg.hasAttribute(Attribute::SwiftSelf) ||
348  Arg.hasAttribute(Attribute::SwiftError) ||
349  Arg.hasAttribute(Attribute::Nest) || VRegs[Idx].size() > 1)
350  return false;
351 
352  ArgInfo OrigArg(VRegs[Idx], Arg.getType());
353  setArgFlags(OrigArg, Idx + AttributeList::FirstArgIndex, DL, F);
354  if (!splitToValueTypes(OrigArg, SplitArgs, DL, MRI,
355  [&](ArrayRef<Register> Regs) {
356  MIRBuilder.buildMerge(VRegs[Idx][0], Regs);
357  }))
358  return false;
359  Idx++;
360  }
361 
362  MachineBasicBlock &MBB = MIRBuilder.getMBB();
363  if (!MBB.empty())
364  MIRBuilder.setInstr(*MBB.begin());
365 
366  FormalArgHandler Handler(MIRBuilder, MRI, CC_X86);
367  if (!handleAssignments(MIRBuilder, SplitArgs, Handler))
368  return false;
369 
370  // Move back to the end of the basic block.
371  MIRBuilder.setMBB(MBB);
372 
373  return true;
374 }
375 
377  CallLoweringInfo &Info) const {
378  MachineFunction &MF = MIRBuilder.getMF();
379  const Function &F = MF.getFunction();
380  MachineRegisterInfo &MRI = MF.getRegInfo();
381  auto &DL = F.getParent()->getDataLayout();
382  const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
383  const TargetInstrInfo &TII = *STI.getInstrInfo();
384  auto TRI = STI.getRegisterInfo();
385 
386  // Handle only Linux C, X86_64_SysV calling conventions for now.
387  if (!STI.isTargetLinux() || !(Info.CallConv == CallingConv::C ||
389  return false;
390 
391  unsigned AdjStackDown = TII.getCallFrameSetupOpcode();
392  auto CallSeqStart = MIRBuilder.buildInstr(AdjStackDown);
393 
394  // Create a temporarily-floating call instruction so we can add the implicit
395  // uses of arg registers.
396  bool Is64Bit = STI.is64Bit();
397  unsigned CallOpc = Info.Callee.isReg()
398  ? (Is64Bit ? X86::CALL64r : X86::CALL32r)
399  : (Is64Bit ? X86::CALL64pcrel32 : X86::CALLpcrel32);
400 
401  auto MIB = MIRBuilder.buildInstrNoInsert(CallOpc)
402  .add(Info.Callee)
403  .addRegMask(TRI->getCallPreservedMask(MF, Info.CallConv));
404 
405  SmallVector<ArgInfo, 8> SplitArgs;
406  for (const auto &OrigArg : Info.OrigArgs) {
407 
408  // TODO: handle not simple cases.
409  if (OrigArg.Flags[0].isByVal())
410  return false;
411 
412  if (OrigArg.Regs.size() > 1)
413  return false;
414 
415  if (!splitToValueTypes(OrigArg, SplitArgs, DL, MRI,
416  [&](ArrayRef<Register> Regs) {
417  MIRBuilder.buildUnmerge(Regs, OrigArg.Regs[0]);
418  }))
419  return false;
420  }
421  // Do the actual argument marshalling.
422  OutgoingValueHandler Handler(MIRBuilder, MRI, MIB, CC_X86);
423  if (!handleAssignments(MIRBuilder, SplitArgs, Handler))
424  return false;
425 
426  bool IsFixed = Info.OrigArgs.empty() ? true : Info.OrigArgs.back().IsFixed;
427  if (STI.is64Bit() && !IsFixed && !STI.isCallingConvWin64(Info.CallConv)) {
428  // From AMD64 ABI document:
429  // For calls that may call functions that use varargs or stdargs
430  // (prototype-less calls or calls to functions containing ellipsis (...) in
431  // the declaration) %al is used as hidden argument to specify the number
432  // of SSE registers used. The contents of %al do not need to match exactly
433  // the number of registers, but must be an ubound on the number of SSE
434  // registers used and is in the range 0 - 8 inclusive.
435 
436  MIRBuilder.buildInstr(X86::MOV8ri)
437  .addDef(X86::AL)
438  .addImm(Handler.getNumXmmRegs());
440  }
441 
442  // Now we can add the actual call instruction to the correct basic block.
443  MIRBuilder.insertInstr(MIB);
444 
445  // If Callee is a reg, since it is used by a target specific
446  // instruction, it must have a register class matching the
447  // constraint of that instruction.
448  if (Info.Callee.isReg())
450  MF, *TRI, MRI, *MF.getSubtarget().getInstrInfo(),
451  *MF.getSubtarget().getRegBankInfo(), *MIB, MIB->getDesc(), Info.Callee,
452  0));
453 
454  // Finally we can copy the returned value back into its virtual-register. In
455  // symmetry with the arguments, the physical register must be an
456  // implicit-define of the call instruction.
457 
458  if (!Info.OrigRet.Ty->isVoidTy()) {
459  if (Info.OrigRet.Regs.size() > 1)
460  return false;
461 
462  SplitArgs.clear();
463  SmallVector<Register, 8> NewRegs;
464 
465  if (!splitToValueTypes(Info.OrigRet, SplitArgs, DL, MRI,
466  [&](ArrayRef<Register> Regs) {
467  NewRegs.assign(Regs.begin(), Regs.end());
468  }))
469  return false;
470 
471  CallReturnHandler Handler(MIRBuilder, MRI, RetCC_X86, MIB);
472  if (!handleAssignments(MIRBuilder, SplitArgs, Handler))
473  return false;
474 
475  if (!NewRegs.empty())
476  MIRBuilder.buildMerge(Info.OrigRet.Regs[0], NewRegs);
477  }
478 
479  CallSeqStart.addImm(Handler.getStackSize())
480  .addImm(0 /* see getFrameTotalSize */)
481  .addImm(0 /* see getFrameAdjustment */);
482 
483  unsigned AdjStackUp = TII.getCallFrameDestroyOpcode();
484  MIRBuilder.buildInstr(AdjStackUp)
485  .addImm(Handler.getStackSize())
486  .addImm(0 /* NumBytesForCalleeToPop */);
487 
488  return true;
489 }
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
Definition: Function.h:176
unsigned getFirstUnallocated(ArrayRef< MCPhysReg > Regs) const
getFirstUnallocated - Return the index of the first unallocated register in the set, or Regs.size() if they are all allocated.
virtual MachineInstrBuilder buildConstant(const DstOp &Res, const ConstantInt &Val)
Build and insert Res = G_CONSTANT Val.
bool is64Bit() const
Is this x86_64? (disregarding specific ABI / programming model)
Definition: X86Subtarget.h:548
const MachineInstrBuilder & add(const MachineOperand &MO) const
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:641
MachineOperand Callee
Destination of the call.
Definition: CallLowering.h:77
static LLT pointer(unsigned AddressSpace, unsigned SizeInBits)
Get a low-level pointer in the given address space.
MachineInstrBuilder buildUnmerge(ArrayRef< LLT > Res, const SrcOp &Op)
Build and insert Res0, ...
LLVMContext & Context
unsigned constrainOperandRegClass(const MachineFunction &MF, const TargetRegisterInfo &TRI, MachineRegisterInfo &MRI, const TargetInstrInfo &TII, const RegisterBankInfo &RBI, MachineInstr &InsertPt, const TargetRegisterClass &RegClass, const MachineOperand &RegMO, unsigned OpIdx)
Constrain the Register operand OpIdx, so that it is now constrained to the TargetRegisterClass passed...
Definition: Utils.cpp:40
This class represents lattice values for constants.
Definition: AllocatorList.h:23
const X86InstrInfo * getInstrInfo() const override
Definition: X86Subtarget.h:507
void addLiveIn(unsigned Reg, unsigned vreg=0)
addLiveIn - Add the specified register as a live-in.
bool handleAssignments(MachineIRBuilder &MIRBuilder, SmallVectorImpl< ArgInfo > &Args, ValueHandler &Handler) const
Invoke Handler::assignArg on each of the given Args and then use Callback to move them to the assigne...
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...
bool lowerCall(MachineIRBuilder &MIRBuilder, CallLoweringInfo &Info) const override
This hook must be implemented to lower the given call instruction, including argument and return valu...
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:1127
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
Definition: DataLayout.h:389
virtual const RegisterBankInfo * getRegBankInfo() const
If the information for the register banks is available, return it.
unsigned const TargetRegisterInfo * TRI
F(f)
block Block Frequency true
bool CC_X86(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
SmallVector< ISD::ArgFlagsTy, 4 > Flags
Definition: CallLowering.h:53
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:129
MVT getRegisterType(MVT VT) const
Return the type of registers that this ValueType will eventually require.
MachineInstrBuilder buildAnyExt(const DstOp &Res, const SrcOp &Op)
Build and insert Res = G_ANYEXT Op0.
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:369
const HexagonInstrInfo * TII
Type * getTypeForEVT(LLVMContext &Context) const
This method returns an LLVM type corresponding to the specified EVT.
Definition: ValueTypes.cpp:264
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
This file contains the simple types necessary to represent the attributes associated with functions a...
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
Definition: CallingConv.h:143
unsigned getStoreSize() const
Return the number of bytes overwritten by a store of the specified value type.
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s, unsigned base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
LocInfo getLocInfo() const
const MachineInstrBuilder & addDef(Register RegNo, unsigned Flags=0, unsigned SubReg=0) const
Add a virtual register definition operand.
unsigned getSizeInBits() const
unsigned getNextStackOffset() const
getNextStackOffset - Return the next stack offset such that all stack slots satisfy their alignment r...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val, ArrayRef< Register > VRegs) const override
This hook behaves as the extended lowerReturn function, but for targets that do not support swifterro...
bool arg_empty() const
Definition: Function.h:729
MachineInstrBuilder buildInstrNoInsert(unsigned Opcode)
Build but don&#39;t insert <empty> = Opcode <empty>.
MachineFunction & getMF()
Getter for the function we currently build.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
void setReg(Register Reg)
Change the register this operand corresponds to.
virtual const TargetInstrInfo * getInstrInfo() const
static LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty, SmallVectorImpl< EVT > &ValueVTs, SmallVectorImpl< uint64_t > *Offsets=nullptr, uint64_t StartingOffset=0)
ComputeValueVTs - Given an LLVM IR type, compute a sequence of EVTs that represent all the individual...
Definition: Analysis.cpp:119
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:19
TargetInstrInfo - Interface to description of machine instruction set.
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
bool isVoidTy() const
Return true if this is &#39;void&#39;.
Definition: Type.h:140
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
const MachineInstrBuilder & addUse(Register RegNo, unsigned Flags=0, unsigned SubReg=0) const
Add a virtual register use operand.
MachineRegisterInfo * getMRI()
Getter for MRI.
const TargetRegisterInfo * getTargetRegisterInfo() const
unsigned const MachineRegisterInfo * MRI
Machine Value Type.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
MachineInstrBuilder buildInstr(unsigned Opcode)
Build and insert <empty> = Opcode <empty>.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
Helper class to build MachineInstr.
void setInstr(MachineInstr &MI)
Set the insertion point to before MI.
const MachineInstrBuilder & addRegMask(const uint32_t *Mask) const
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL, const FuncInfoTy &FuncInfo) const
MachineInstrBuilder buildGEP(const DstOp &Res, const SrcOp &Op0, const SrcOp &Op1)
Build and insert Res = G_GEP Op0, Op1.
Extended Value Type.
Definition: ValueTypes.h:33
MachineInstrBuilder buildCopy(const DstOp &Res, const SrcOp &Op)
Build and insert Res = COPY Op.
MachineInstrBuilder buildTrunc(const DstOp &Res, const SrcOp &Op)
Build and insert Res = G_TRUNC Op.
Argument handling is mostly uniform between the four places that make these decisions: function forma...
Definition: CallLowering.h:112
This class contains a discriminated union of information about pointers in memory operands...
LLT getLLTForType(Type &Ty, const DataLayout &DL)
Construct a low-level type based on an LLVM type.
The memory access writes data.
SmallVector< ArgInfo, 8 > OrigArgs
List of descriptors of the arguments passed to the function.
Definition: CallLowering.h:83
const X86RegisterInfo * getRegisterInfo() const override
Definition: X86Subtarget.h:517
MachineInstrBuilder buildLoad(const DstOp &Res, const SrcOp &Addr, MachineMemOperand &MMO)
Build and insert Res = G_LOAD Addr, MMO.
CCState - This class holds information needed while lowering arguments and return values...
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
CCValAssign - Represent assignment of one arg/retval to a location.
MachineInstrBuilder buildFrameIndex(const DstOp &Res, int Idx)
Build and insert Res = G_FRAME_INDEX Idx.
int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, bool isAliased=false)
Create a new object at a fixed location on the stack.
bool RetCC_X86(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
const Function & getFunction() const
Return the LLVM function that this machine code represents.
This file declares the MachineIRBuilder class.
This file describes how to lower LLVM calls to machine code calls.
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
The memory access reads data.
static MachinePointerInfo getFixedStack(MachineFunction &MF, int FI, int64_t Offset=0)
Return a MachinePointerInfo record that refers to the specified FrameIndex.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
CallingConv::ID CallConv
Calling convention to be used for the call.
Definition: CallLowering.h:73
const MachineBasicBlock & getMBB() const
Getter for the basic block we currently build.
void setMBB(MachineBasicBlock &MBB)
Set the insertion point to the end of MBB.
The memory access always returns the same value (or traps).
MachineInstrBuilder buildStore(const SrcOp &Val, const SrcOp &Addr, MachineMemOperand &MMO)
Build and insert G_STORE Val, Addr, MMO.
uint32_t Size
Definition: Profile.cpp:46
unsigned getNumRegisters(LLVMContext &Context, EVT VT) const
Return the number of registers that this ValueType will eventually require.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MachineInstrBuilder insertInstr(MachineInstrBuilder MIB)
Insert an existing instruction at the insertion point.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:575
LLVM Value Representation.
Definition: Value.h:73
bool isTargetLinux() const
Definition: X86Subtarget.h:766
bool isCallingConvWin64(CallingConv::ID CC) const
Definition: X86Subtarget.h:813
X86CallLowering(const X86TargetLowering &TLI)
MachineInstrBuilder buildMerge(const DstOp &Res, ArrayRef< Register > Ops)
Build and insert Res = G_MERGE_VALUES Op0, ...
SmallVector< Register, 4 > Regs
Definition: CallLowering.h:47
static MachinePointerInfo getStack(MachineFunction &MF, int64_t Offset, uint8_t ID=0)
Stack pointer relative access.
unsigned getRegSizeInBits(const TargetRegisterClass &RC) const
Return the size in bits of a register from class RC.
Register createGenericVirtualRegister(LLT Ty, StringRef Name="")
Create and return a new generic virtual register with low-level type Ty.
bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F, ArrayRef< ArrayRef< Register >> VRegs) const override
This hook must be implemented to lower the incoming (formal) arguments, described by VRegs...
Register getReg() const
getReg - Returns the register number.
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:416
ArgInfo OrigRet
Descriptor for the return type of the function.
Definition: CallLowering.h:80
iterator_range< arg_iterator > args()
Definition: Function.h:719
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:143