--Ruchira

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@504 91177308-0d34-0410-b5e6-96231b3b80d8

lib/CodeGen/RegAlloc/LiveRange.h

@@ -0,0 +1,110 @@
+/* Title:   LiveRange.h
+   Author:  Ruchira Sasanka
+   Date:    July 25, 01
+   Purpose: To keep info about a live range. 
+   Asuumptions:
+
+   Since the Value pointed by a use is the same as of its def, it is sufficient
+   to keep only defs in a LiveRange.
+*/
+
+#ifndef LIVE_RANGE_H
+#define LIVE_RANGE_H
+
+#include "llvm/Analysis/LiveVar/ValueSet.h"
+#include "llvm/Type.h"
+
+
+
+
+class RegClass;
+class IGNode;
+
+
+class LiveRange : public ValueSet
+{
+ private:
+
+  RegClass *MyRegClass;       // register classs (e.g., int, FP) for this LR
+
+  // a list of call instructions that interferes with this live range
+  vector<const Instruction *> CallInterferenceList;  
+
+  IGNode *UserIGNode;         // IGNode which uses this LR
+  int Color;                  // color assigned to this live range
+  bool mustSpill;             // whether this LR must be spilt
+
+  // whether this LR must be saved accross calls
+  bool mustSaveAcrossCalls;        
+
+  // bool mustLoadFromStack;     // must load from stack at start of method
+
+ public:
+
+
+  ~LiveRange() {}             // empty destructor 
+
+  void setRegClass(RegClass *const RC) 
+    { MyRegClass = RC; }
+
+  inline RegClass *const getRegClass() const 
+    { assert(MyRegClass); return MyRegClass; } 
+
+  inline bool hasColor() const 
+    { return Color != -1; }
+
+  inline unsigned int getColor() const 
+    { assert( Color != -1); return (unsigned) Color ; }
+
+  inline void setColor(unsigned int Col) 
+    { Color = (int) Col ; }
+
+  
+  inline void addCallInterference(const Instruction *const  Inst) 
+    { CallInterferenceList.push_back( Inst ); }
+
+  inline const Instruction *const getCallInterference(const unsigned i) const {
+    assert( i < CallInterferenceList.size() ); 
+    return CallInterferenceList[i];  
+  }
+
+  inline unsigned int getNumOfCallInterferences() const 
+    { return CallInterferenceList.size(); } 
+
+  
+  inline void markForSpill() { mustSpill = true; }
+
+  inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; }
+
+  // inline void markForLoadFromStack() { mustLoadFromStack = true; 
+
+
+  inline void setUserIGNode( IGNode *const IGN) 
+    { assert( !UserIGNode); UserIGNode = IGN; }
+
+  inline IGNode * getUserIGNode() const 
+    { return UserIGNode; }    // NULL if the user is not allocated
+
+  inline Type::PrimitiveID getTypeID() const {
+    const Value *val = *begin();
+    assert(val && "Can't find type - Live range is empty" );
+    return (val->getType())->getPrimitiveID();
+  }
+
+
+  inline LiveRange() : ValueSet() , CallInterferenceList() 
+    {
+      Color = -1;                 // not yet colored 
+      mustSpill = mustSaveAcrossCalls = false;
+      MyRegClass = NULL;
+      UserIGNode = NULL;
+    }
+
+};
+
+
+
+
+
+#endif
+

lib/CodeGen/RegAlloc/LiveRangeInfo.h

@@ -0,0 +1,87 @@
+/* Title:   LiveRangeInfo.h
+   Author:  Ruchira Sasanka
+   Date:    Jun 30, 01
+   Purpose: 
+
+   This file constructs and keeps the LiveRang map 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"
+
+/*
+ #ifndef size_type 
+ #define size_type (unsigned int)
+ #endif
+*/
+
+
+typedef hash_map <const Value *,  LiveRange *, hashFuncValue> LiveRangeMapType;
+
+
+class LiveRangeInfo 
+{
+
+private:
+
+  const Method *const Meth;         // Method for which live range info is held
+
+  LiveRangeMapType  LiveRangeMap;   // A map from Value * to LiveRange * 
+                                    // created by constructLiveRanges
+
+  void unionAndUpdateLRs(LiveRange *L1, LiveRange *L2);
+
+  void addInterference(const Instruction *const Inst, 
+		       const LiveVarSet *const LVSet);
+  
+
+public:
+  
+  LiveRangeInfo(const Method *const M);
+
+  void constructLiveRanges();
+
+  inline const LiveRangeMapType *const getLiveRangeMap() const 
+    { return &LiveRangeMap; }
+
+  inline LiveRange *getLiveRangeForValue( const Value *const Val) 
+    { return LiveRangeMap[ Val ]; }
+
+
+
+
+  void coalesceLRs();  
+
+  void printLiveRanges();
+
+};
+
+
+
+
+#endif 

lib/Target/SparcV9/RegAlloc/LiveRange.h

@@ -0,0 +1,110 @@
+/* Title:   LiveRange.h
+   Author:  Ruchira Sasanka
+   Date:    July 25, 01
+   Purpose: To keep info about a live range. 
+   Asuumptions:
+
+   Since the Value pointed by a use is the same as of its def, it is sufficient
+   to keep only defs in a LiveRange.
+*/
+
+#ifndef LIVE_RANGE_H
+#define LIVE_RANGE_H
+
+#include "llvm/Analysis/LiveVar/ValueSet.h"
+#include "llvm/Type.h"
+
+
+
+
+class RegClass;
+class IGNode;
+
+
+class LiveRange : public ValueSet
+{
+ private:
+
+  RegClass *MyRegClass;       // register classs (e.g., int, FP) for this LR
+
+  // a list of call instructions that interferes with this live range
+  vector<const Instruction *> CallInterferenceList;  
+
+  IGNode *UserIGNode;         // IGNode which uses this LR
+  int Color;                  // color assigned to this live range
+  bool mustSpill;             // whether this LR must be spilt
+
+  // whether this LR must be saved accross calls
+  bool mustSaveAcrossCalls;        
+
+  // bool mustLoadFromStack;     // must load from stack at start of method
+
+ public:
+
+
+  ~LiveRange() {}             // empty destructor 
+
+  void setRegClass(RegClass *const RC) 
+    { MyRegClass = RC; }
+
+  inline RegClass *const getRegClass() const 
+    { assert(MyRegClass); return MyRegClass; } 
+
+  inline bool hasColor() const 
+    { return Color != -1; }
+
+  inline unsigned int getColor() const 
+    { assert( Color != -1); return (unsigned) Color ; }
+
+  inline void setColor(unsigned int Col) 
+    { Color = (int) Col ; }
+
+  
+  inline void addCallInterference(const Instruction *const  Inst) 
+    { CallInterferenceList.push_back( Inst ); }
+
+  inline const Instruction *const getCallInterference(const unsigned i) const {
+    assert( i < CallInterferenceList.size() ); 
+    return CallInterferenceList[i];  
+  }
+
+  inline unsigned int getNumOfCallInterferences() const 
+    { return CallInterferenceList.size(); } 
+
+  
+  inline void markForSpill() { mustSpill = true; }
+
+  inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; }
+
+  // inline void markForLoadFromStack() { mustLoadFromStack = true; 
+
+
+  inline void setUserIGNode( IGNode *const IGN) 
+    { assert( !UserIGNode); UserIGNode = IGN; }
+
+  inline IGNode * getUserIGNode() const 
+    { return UserIGNode; }    // NULL if the user is not allocated
+
+  inline Type::PrimitiveID getTypeID() const {
+    const Value *val = *begin();
+    assert(val && "Can't find type - Live range is empty" );
+    return (val->getType())->getPrimitiveID();
+  }
+
+
+  inline LiveRange() : ValueSet() , CallInterferenceList() 
+    {
+      Color = -1;                 // not yet colored 
+      mustSpill = mustSaveAcrossCalls = false;
+      MyRegClass = NULL;
+      UserIGNode = NULL;
+    }
+
+};
+
+
+
+
+
+#endif
+

lib/Target/SparcV9/RegAlloc/LiveRangeInfo.h

@@ -0,0 +1,87 @@
+/* Title:   LiveRangeInfo.h
+   Author:  Ruchira Sasanka
+   Date:    Jun 30, 01
+   Purpose: 
+
+   This file constructs and keeps the LiveRang map 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"
+
+/*
+ #ifndef size_type 
+ #define size_type (unsigned int)
+ #endif
+*/
+
+
+typedef hash_map <const Value *,  LiveRange *, hashFuncValue> LiveRangeMapType;
+
+
+class LiveRangeInfo 
+{
+
+private:
+
+  const Method *const Meth;         // Method for which live range info is held
+
+  LiveRangeMapType  LiveRangeMap;   // A map from Value * to LiveRange * 
+                                    // created by constructLiveRanges
+
+  void unionAndUpdateLRs(LiveRange *L1, LiveRange *L2);
+
+  void addInterference(const Instruction *const Inst, 
+		       const LiveVarSet *const LVSet);
+  
+
+public:
+  
+  LiveRangeInfo(const Method *const M);
+
+  void constructLiveRanges();
+
+  inline const LiveRangeMapType *const getLiveRangeMap() const 
+    { return &LiveRangeMap; }
+
+  inline LiveRange *getLiveRangeForValue( const Value *const Val) 
+    { return LiveRangeMap[ Val ]; }
+
+
+
+
+  void coalesceLRs();  
+
+  void printLiveRanges();
+
+};
+
+
+
+
+#endif