blob: 9e7ef06fe280f9d27a9bea2df02d9600fba9d312 (
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
123
124
125
126
127
128
129
130
131
132
133
134
|
/* Title: LiveRangeInfo.h -*- C++ -*-
Author: Ruchira Sasanka
Date: Jun 30, 01
Purpose:
This file contains the class LiveRangeInfo which constructs and keeps
the LiveRangMap which contains all the live ranges used in a method.
Assumptions:
All variables (llvm Values) are defined before they are used. However, a
constant may not be defined in the machine instruction stream if it can be
used as an immediate value within a machine instruction. However, register
allocation does not have to worry about immediate constants since they
do not require registers.
Since an llvm Value has a list of uses associated, it is sufficient to
record only the defs in a Live Range.
*/
#ifndef LIVE_RANGE_INFO_H
#define LIVE_RANGE_INFO_H
#include "llvm/Type.h"
#include "llvm/Method.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Analysis/LiveVar/LiveVarSet.h"
#include "llvm/CodeGen/IGNode.h"
#include "llvm/CodeGen/LiveRange.h"
#include "llvm/CodeGen/RegClass.h"
typedef std::hash_map<const Value*, LiveRange*> LiveRangeMapType;
typedef std::vector<const MachineInstr*> CallRetInstrListType;
//----------------------------------------------------------------------------
// Class LiveRangeInfo
//
// Constructs and keeps the LiveRangMap which contains all the live
// ranges used in a method. Also contain methods to coalesce live ranges.
//----------------------------------------------------------------------------
class LiveRangeInfo
{
private:
const Method *const Meth; // Method for which live range info is held
LiveRangeMapType LiveRangeMap; // A map from Value * to LiveRange * to
// record all live ranges in a method
// created by constructLiveRanges
const TargetMachine& TM; // target machine description
std::vector<RegClass *> & RegClassList;// vector containing register classess
const MachineRegInfo& MRI; // machine reg info
CallRetInstrListType CallRetInstrList; // a list of all call/ret instrs
//------------ Private methods (see LiveRangeInfo.cpp for description)-------
void unionAndUpdateLRs(LiveRange *L1, LiveRange *L2);
void addInterference(const Instruction *const Inst,
const LiveVarSet *const LVSet);
void suggestRegs4CallRets();
const Method* getMethod() { return Meth; }
public:
LiveRangeInfo(const Method *const M,
const TargetMachine& tm,
std::vector<RegClass *> & RCList);
// Destructor to destroy all LiveRanges in the LiveRange Map
~LiveRangeInfo();
// Main entry point for live range construction
//
void constructLiveRanges();
// This method is used to add a live range created elsewhere (e.g.,
// in machine specific code) to the common live range map
//
inline void addLRToMap(const Value *Val, LiveRange *LR) {
assert( Val && LR && "Val/LR is NULL!\n");
assert( (! LiveRangeMap[ Val ]) && "LR already set in map");
LiveRangeMap[ Val ] = LR;
}
// return the common live range map for this method
//
inline const LiveRangeMapType *const getLiveRangeMap() const
{ return &LiveRangeMap; }
// Method sed to get the corresponding live range of a Value
//
inline LiveRange *getLiveRangeForValue( const Value *const Val)
{ return LiveRangeMap[ Val ]; }
// Method used to get the Call and Return instruction list
//
inline CallRetInstrListType &getCallRetInstrList() {
return CallRetInstrList;
}
// Method for coalescing live ranges. Called only after interference info
// is calculated.
//
void coalesceLRs();
// debugging method to print the live ranges
//
void printLiveRanges();
};
#endif
|
