Move lib/Codegen/RegAlloc into lib/Target/Sparc, as it is sparc specific

llvm-svn: 10728

1 files changed, 184 insertions, 0 deletions

diff --git a/llvm/lib/Target/Sparc/RegAlloc/LiveRange.h b/llvm/lib/Target/Sparc/RegAlloc/LiveRange.h
new file mode 100644
index 00000000000..d6e2cf63072
--- /dev/null
+++ b/llvm/lib/Target/Sparc/RegAlloc/LiveRange.h
@@ -0,0 +1,184 @@
+//===-- LiveRange.h - Store info about a live range -------------*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// Implements a live range using a ValueSet. A LiveRange is a simple set
+// of Values. 
+//
+// 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 LIVERANGE_H
+#define LIVERANGE_H
+
+#include "llvm/Value.h"
+#include "llvm/CodeGen/ValueSet.h"
+
+namespace llvm {
+
+class RegClass;
+class IGNode;
+
+class LiveRange : public ValueSet {
+  RegClass *MyRegClass;       // register class (e.g., int, FP) for this LR
+
+  /// doesSpanAcrossCalls - Does this live range span across calls? 
+  /// This information is used by graph coloring algo to avoid allocating
+  /// volatile colors to live ranges that span across calls (since they have to
+  /// be saved/restored)
+  ///
+  bool doesSpanAcrossCalls;
+
+  IGNode *UserIGNode;         // IGNode which uses this LR
+  int Color;                  // color assigned to this live range
+  bool mustSpill;             // whether this LR must be spilt
+
+  /// mustSaveAcrossCalls - whether this LR must be saved accross calls
+  /// ***TODO REMOVE this
+  ///
+  bool mustSaveAcrossCalls;        
+  
+  /// SuggestedColor - if this LR has a suggested color, can it be
+  /// really alloated?  A suggested color cannot be allocated when the
+  /// suggested color is volatile and when there are call
+  /// interferences.
+  ///
+  int SuggestedColor;        // The suggested color for this LR
+
+  /// CanUseSuggestedCol - It is possible that a suggested color for
+  /// this live range is not available before graph coloring (e.g., it
+  /// can be allocated to another live range which interferes with
+  /// this)
+  /// 
+  bool CanUseSuggestedCol;
+
+  /// SpilledStackOffsetFromFP - If this LR is spilled, its stack
+  /// offset from *FP*. The spilled offsets must always be relative to
+  /// the FP.
+  ///
+  int SpilledStackOffsetFromFP;
+
+  /// HasSpillOffset 0 Whether this live range has a spill offset
+  ///
+  bool HasSpillOffset;
+
+  /// The spill cost of this live range. Calculated using loop depth of
+  /// each reference to each Value in the live range
+  ///
+  unsigned SpillCost;
+
+public:
+  LiveRange() {
+    Color = SuggestedColor = -1;        // not yet colored 
+    mustSpill = mustSaveAcrossCalls = false;
+    MyRegClass = 0;
+    UserIGNode = 0;
+    doesSpanAcrossCalls = false;
+    CanUseSuggestedCol = true;
+    HasSpillOffset = false;
+    SpillCost = 0;
+  }
+
+  void setRegClass(RegClass *RC) { MyRegClass = RC; }
+
+  RegClass *getRegClass() const { assert(MyRegClass); return MyRegClass; }
+  unsigned getRegClassID() const;
+
+  bool hasColor() const { return Color != -1; }
+  
+  unsigned getColor() const { assert(Color != -1); return (unsigned)Color; }
+
+  void setColor(unsigned Col) { Color = (int)Col; }
+
+  inline void setCallInterference() { 
+    doesSpanAcrossCalls = 1;
+  }
+  inline void clearCallInterference() { 
+    doesSpanAcrossCalls = 0;
+  }
+
+  inline bool isCallInterference() const { 
+    return doesSpanAcrossCalls == 1; 
+  } 
+
+  inline void markForSpill() { mustSpill = true; }
+
+  inline bool isMarkedForSpill() const { return mustSpill; }
+
+  inline void setSpillOffFromFP(int StackOffset) {
+    assert(mustSpill && "This LR is not spilled");
+    SpilledStackOffsetFromFP = StackOffset;
+    HasSpillOffset = true;
+  }
+
+  inline void modifySpillOffFromFP(int StackOffset) {
+    assert(mustSpill && "This LR is not spilled");
+    SpilledStackOffsetFromFP = StackOffset;
+    HasSpillOffset = true;
+  }
+
+  inline bool hasSpillOffset() const {
+    return HasSpillOffset;
+  }
+
+  inline int getSpillOffFromFP() const {
+    assert(HasSpillOffset && "This LR is not spilled");
+    return SpilledStackOffsetFromFP;
+  }
+
+  inline void markForSaveAcrossCalls() { mustSaveAcrossCalls = true; }
+  
+  inline void setUserIGNode(IGNode *IGN) {
+    assert(!UserIGNode); UserIGNode = IGN;
+  }
+
+  // getUserIGNode - NULL if the user is not allocated
+  inline IGNode *getUserIGNode() const { return UserIGNode; }
+
+  inline const Type *getType() const {
+    return (*begin())->getType();  // set's don't have a front
+  }
+  
+  inline void setSuggestedColor(int Col) {
+    if (SuggestedColor == -1)
+      SuggestedColor = Col;
+  }
+
+  inline unsigned getSuggestedColor() const {
+    assert(SuggestedColor != -1);      // only a valid color is obtained
+    return (unsigned)SuggestedColor;
+  }
+
+  inline bool hasSuggestedColor() const {
+    return SuggestedColor != -1;
+  }
+
+  inline bool isSuggestedColorUsable() const {
+    assert(hasSuggestedColor() && "No suggested color");
+    return CanUseSuggestedCol;
+  }
+
+  inline void setSuggestedColorUsable(bool val) {
+    assert(hasSuggestedColor() && "No suggested color");
+    CanUseSuggestedCol = val;
+  }
+
+  inline void addSpillCost(unsigned cost) {
+    SpillCost += cost;
+  }
+
+  inline unsigned getSpillCost() const {
+    return SpillCost;
+  }
+};
+
+} // End llvm namespace
+
+#endif