Subzero : Live Range Splitting after initial Register Allocation

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 83 matching lines @@
 RegNumT::BaseType RegNumT::Limit = 0;
 
 bool operator<(const RegWeight &A, const RegWeight &B) {
   return A.getWeight() < B.getWeight();
 }
 bool operator<=(const RegWeight &A, const RegWeight &B) { return !(B < A); }
 bool operator==(const RegWeight &A, const RegWeight &B) {
   return !(B < A) && !(A < B);
 }
 
-void LiveRange::addSegment(InstNumberT Start, InstNumberT End) {
-  if (!Range.empty()) {
-    // Check for merge opportunity.
-    InstNumberT CurrentEnd = Range.back().second;
-    assert(Start >= CurrentEnd);
-    if (Start == CurrentEnd) {
-      Range.back().second = End;
-      return;
+void LiveRange::addSegment(InstNumberT Start, InstNumberT End, CfgNode *Node) {
+  if (!getFlags().getGlobalSplitting()) {

[Jim Stichnoth, 2016/07/29 17:04:06]

Remove the '!' and reverse the if/then/else branches.

[manasijm, 2016/08/01 22:20:03]

Done.

+    if (!Range.empty()) {
+      // Check for merge opportunity.
+      InstNumberT CurrentEnd = Range.back().second;
+      assert(Start >= CurrentEnd);
+      if (Start == CurrentEnd) {
+        Range.back().second = End;
+        return;
+      }
     }
+  } else {
+    // Disable merging to make sure a live range 'segment' has a single node.

[Jim Stichnoth, 2016/07/29 17:04:06]

I think you could still merge if the node is the same?  But I don't think that
would ever actually happen in today's code.  Maybe note this in a comment?  e.g.
"Merging could be allowed if the nodes are the same, but this currently never
happens in practice."

[manasijm, 2016/08/01 22:20:03]

Done.

+    assert(NodeMap.find(Start) == NodeMap.end());
+    NodeMap[Start] = Node;
   }
   Range.push_back(RangeElementType(Start, End));
 }
 
 // Returns true if this live range ends before Other's live range starts. This
 // means that the highest instruction number in this live range is less than or
 // equal to the lowest instruction number of the Other live range.
 bool LiveRange::endsBefore(const LiveRange &Other) const {
   // Neither range should be empty, but let's be graceful.
   if (Range.empty() || Other.Range.empty())
@@ skipping 526 matching lines @@
   if (getType() != IceType_i32 && getType() != IceType_i16 &&
       getType() != IceType_i8)
     return false;
   // The Following checks if the signed representation of Value is between
   // -Threshold/2 and +Threshold/2
   bool largerThanThreshold = Threshold / 2 + Value >= Threshold;
   return largerThanThreshold;
 }
 
 } // end of namespace Ice