blob: 815d6f71c3be69749d11c8f265c2a7ace2505a11 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
//===----------------------- AMDGPUFrameLowering.cpp ----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//==-----------------------------------------------------------------------===//
//
// Interface to describe a layout of a stack frame on a AMDIL target machine
//
//===----------------------------------------------------------------------===//
#include "AMDGPUFrameLowering.h"
#include "AMDGPURegisterInfo.h"
#include "R600MachineFunctionInfo.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/IR/Instructions.h"
using namespace llvm;
AMDGPUFrameLowering::AMDGPUFrameLowering(StackDirection D, unsigned StackAl,
int LAO, unsigned TransAl)
: TargetFrameLowering(D, StackAl, LAO, TransAl) { }
AMDGPUFrameLowering::~AMDGPUFrameLowering() { }
unsigned AMDGPUFrameLowering::getStackWidth(const MachineFunction &MF) const {
// XXX: Hardcoding to 1 for now.
//
// I think the StackWidth should stored as metadata associated with the
// MachineFunction. This metadata can either be added by a frontend, or
// calculated by a R600 specific LLVM IR pass.
//
// The StackWidth determines how stack objects are laid out in memory.
// For a vector stack variable, like: int4 stack[2], the data will be stored
// in the following ways depending on the StackWidth.
//
// StackWidth = 1:
//
// T0.X = stack[0].x
// T1.X = stack[0].y
// T2.X = stack[0].z
// T3.X = stack[0].w
// T4.X = stack[1].x
// T5.X = stack[1].y
// T6.X = stack[1].z
// T7.X = stack[1].w
//
// StackWidth = 2:
//
// T0.X = stack[0].x
// T0.Y = stack[0].y
// T1.X = stack[0].z
// T1.Y = stack[0].w
// T2.X = stack[1].x
// T2.Y = stack[1].y
// T3.X = stack[1].z
// T3.Y = stack[1].w
//
// StackWidth = 4:
// T0.X = stack[0].x
// T0.Y = stack[0].y
// T0.Z = stack[0].z
// T0.W = stack[0].w
// T1.X = stack[1].x
// T1.Y = stack[1].y
// T1.Z = stack[1].z
// T1.W = stack[1].w
return 1;
}
/// \returns The number of registers allocated for \p FI.
int AMDGPUFrameLowering::getFrameIndexOffset(const MachineFunction &MF,
int FI) const {
const MachineFrameInfo *MFI = MF.getFrameInfo();
unsigned Offset = 0;
int UpperBound = FI == -1 ? MFI->getNumObjects() : FI;
for (int i = MFI->getObjectIndexBegin(); i < UpperBound; ++i) {
const AllocaInst *Alloca = MFI->getObjectAllocation(i);
unsigned ArrayElements;
const Type *AllocaType = Alloca->getAllocatedType();
const Type *ElementType;
if (AllocaType->isArrayTy()) {
ArrayElements = AllocaType->getArrayNumElements();
ElementType = AllocaType->getArrayElementType();
} else {
ArrayElements = 1;
ElementType = AllocaType;
}
unsigned VectorElements;
if (ElementType->isVectorTy()) {
VectorElements = ElementType->getVectorNumElements();
} else {
VectorElements = 1;
}
Offset += (VectorElements / getStackWidth(MF)) * ArrayElements;
}
return Offset;
}
const TargetFrameLowering::SpillSlot *
AMDGPUFrameLowering::getCalleeSavedSpillSlots(unsigned &NumEntries) const {
NumEntries = 0;
return 0;
}
void
AMDGPUFrameLowering::emitPrologue(MachineFunction &MF) const {
}
void
AMDGPUFrameLowering::emitEpilogue(MachineFunction &MF,
MachineBasicBlock &MBB) const {
}
bool
AMDGPUFrameLowering::hasFP(const MachineFunction &MF) const {
return false;
}
|
