LLVM  3.7.0
AMDGPUFrameLowering.cpp
Go to the documentation of this file.
1 //===----------------------- AMDGPUFrameLowering.cpp ----------------------===//
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 // Interface to describe a layout of a stack frame on a AMDIL target machine
11 //
12 //===----------------------------------------------------------------------===//
13 #include "AMDGPUFrameLowering.h"
14 #include "AMDGPURegisterInfo.h"
18 #include "llvm/IR/Instructions.h"
19 
20 using namespace llvm;
22  int LAO, unsigned TransAl)
23  : TargetFrameLowering(D, StackAl, LAO, TransAl) { }
24 
26 
28 
29  // XXX: Hardcoding to 1 for now.
30  //
31  // I think the StackWidth should stored as metadata associated with the
32  // MachineFunction. This metadata can either be added by a frontend, or
33  // calculated by a R600 specific LLVM IR pass.
34  //
35  // The StackWidth determines how stack objects are laid out in memory.
36  // For a vector stack variable, like: int4 stack[2], the data will be stored
37  // in the following ways depending on the StackWidth.
38  //
39  // StackWidth = 1:
40  //
41  // T0.X = stack[0].x
42  // T1.X = stack[0].y
43  // T2.X = stack[0].z
44  // T3.X = stack[0].w
45  // T4.X = stack[1].x
46  // T5.X = stack[1].y
47  // T6.X = stack[1].z
48  // T7.X = stack[1].w
49  //
50  // StackWidth = 2:
51  //
52  // T0.X = stack[0].x
53  // T0.Y = stack[0].y
54  // T1.X = stack[0].z
55  // T1.Y = stack[0].w
56  // T2.X = stack[1].x
57  // T2.Y = stack[1].y
58  // T3.X = stack[1].z
59  // T3.Y = stack[1].w
60  //
61  // StackWidth = 4:
62  // T0.X = stack[0].x
63  // T0.Y = stack[0].y
64  // T0.Z = stack[0].z
65  // T0.W = stack[0].w
66  // T1.X = stack[1].x
67  // T1.Y = stack[1].y
68  // T1.Z = stack[1].z
69  // T1.W = stack[1].w
70  return 1;
71 }
72 
73 /// \returns The number of registers allocated for \p FI.
75  int FI) const {
76  const MachineFrameInfo *MFI = MF.getFrameInfo();
77  // Start the offset at 2 so we don't overwrite work group information.
78  // XXX: We should only do this when the shader actually uses this
79  // information.
80  unsigned OffsetBytes = 2 * (getStackWidth(MF) * 4);
81  int UpperBound = FI == -1 ? MFI->getNumObjects() : FI;
82 
83  for (int i = MFI->getObjectIndexBegin(); i < UpperBound; ++i) {
84  OffsetBytes = RoundUpToAlignment(OffsetBytes, MFI->getObjectAlignment(i));
85  OffsetBytes += MFI->getObjectSize(i);
86  // Each register holds 4 bytes, so we must always align the offset to at
87  // least 4 bytes, so that 2 frame objects won't share the same register.
88  OffsetBytes = RoundUpToAlignment(OffsetBytes, 4);
89  }
90 
91  if (FI != -1)
92  OffsetBytes = RoundUpToAlignment(OffsetBytes, MFI->getObjectAlignment(FI));
93 
94  return OffsetBytes / (getStackWidth(MF) * 4);
95 }
96 
98 AMDGPUFrameLowering::getCalleeSavedSpillSlots(unsigned &NumEntries) const {
99  NumEntries = 0;
100  return nullptr;
101 }
103  MachineBasicBlock &MBB) const {}
104 void
106  MachineBasicBlock &MBB) const {
107 }
108 
109 bool
111  return false;
112 }
unsigned getNumObjects() const
Return the number of objects.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
Interface to describe a layout of a stack frame on a AMDIL target machine.
TargetRegisterInfo interface that is implemented by all hw codegen targets.
int getObjectIndexBegin() const
Return the minimum frame object index.
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register...
AMDGPUFrameLowering(StackDirection D, unsigned StackAl, int LAO, unsigned TransAl=1)
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
unsigned getObjectAlignment(int ObjectIdx) const
Return the alignment of the specified stack object.
Information about stack frame layout on the target.
const SpillSlot * getCalleeSavedSpillSlots(unsigned &NumEntries) const override
getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs, that contains an entry...
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
unsigned getStackWidth(const MachineFunction &MF) const
MachineFrameInfo * getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
int getFrameIndexOffset(const MachineFunction &MF, int FI) const override
uint64_t RoundUpToAlignment(uint64_t Value, uint64_t Align)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:609
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.