8348645: IGV: visualize live ranges

Reviewed-by: thartmann, dfenacci

Author: robcasloz

src/hotspot/share/opto/idealGraphPrinter.cpp

@@ -80,6 +80,10 @@ const char *IdealGraphPrinter::BLOCK_ELEMENT = "block";
 const char *IdealGraphPrinter::SUCCESSORS_ELEMENT = "successors";
 const char *IdealGraphPrinter::SUCCESSOR_ELEMENT = "successor";
 const char *IdealGraphPrinter::ASSEMBLY_ELEMENT = "assembly";
+const char *IdealGraphPrinter::LIVEOUT_ELEMENT = "liveOut";
+const char *IdealGraphPrinter::LIVE_RANGE_ELEMENT = "lrg";
+const char *IdealGraphPrinter::LIVE_RANGE_ID_PROPERTY = "id";
+const char *IdealGraphPrinter::LIVE_RANGES_ELEMENT = "liveRanges";
 
 int IdealGraphPrinter::_file_count = 0;
 
@@ -815,6 +819,12 @@ Node* IdealGraphPrinter::get_load_node(const Node* node) {
   return load;
 }
 
+bool IdealGraphPrinter::has_liveness_info() const {
+  return _chaitin &&
+    _chaitin != (PhaseChaitin *)((intptr_t)0xdeadbeef) &&
+    _chaitin->get_live() != nullptr;
+}
+
 void IdealGraphPrinter::walk_nodes(Node* start, bool edges) {
   VectorSet visited;
   GrowableArray<Node *> nodeStack(Thread::current()->resource_area(), 0, 0, nullptr);
@@ -911,6 +921,19 @@ void IdealGraphPrinter::print(const char* name, Node* node, GrowableArray<const
       }
       tail(NODES_ELEMENT);
 
+      if (has_liveness_info()) {
+        head(LIVEOUT_ELEMENT);
+        const IndexSet* liveout = _chaitin->get_live()->live(block);
+        IndexSetIterator lrgs(liveout);
+        uint lrg;
+        while ((lrg = lrgs.next()) != 0) {
+          begin_elem(LIVE_RANGE_ELEMENT);
+          print_attr(LIVE_RANGE_ID_PROPERTY, lrg);
+          end_elem();
+        }
+        tail(LIVEOUT_ELEMENT);
+      }
+
       tail(BLOCK_ELEMENT);
     }
     tail(CONTROL_FLOW_ELEMENT);
@@ -934,6 +957,91 @@ void IdealGraphPrinter::print(const char* name, Node* node, GrowableArray<const
     tail(STATE_ELEMENT);
     tail(GRAPH_STATES_ELEMENT);
   }
+
+  if (has_liveness_info()) {
+    head(LIVE_RANGES_ELEMENT);
+    for (uint i = 1; i < _chaitin->_lrg_map.max_lrg_id(); i++) {
+      begin_head(LIVE_RANGE_ELEMENT);
+      print_attr(LIVE_RANGE_ID_PROPERTY, i);
+      end_head();
+      head(PROPERTIES_ELEMENT);
+      const LRG& lrg = _chaitin->lrgs(i);
+      buffer[0] = 0;
+      stringStream lrg_mask_stream(buffer, sizeof(buffer) - 1);
+      lrg.mask().dump(&lrg_mask_stream);
+      print_prop("mask", buffer);
+      print_prop("mask_size", lrg.mask_size());
+      if (lrg._degree_valid) {
+        print_prop("degree", lrg.degree());
+      }
+      print_prop("num_regs", lrg.num_regs());
+      print_prop("reg_pressure", lrg.reg_pressure());
+      print_prop("cost", lrg._cost);
+      print_prop("area", lrg._area);
+      print_prop("score", lrg.score());
+      if (lrg._risk_bias != 0) {
+        print_prop("risk_bias", lrg._risk_bias);
+      }
+      if (lrg._copy_bias != 0) {
+        print_prop("copy_bias", lrg._copy_bias);
+      }
+      if (lrg.is_singledef()) {
+        print_prop("is_singledef", TRUE_VALUE);
+      }
+      if (lrg.is_multidef()) {
+        print_prop("is_multidef", TRUE_VALUE);
+      }
+      if (lrg._is_oop) {
+        print_prop("is_oop", TRUE_VALUE);
+      }
+      if (lrg._is_float) {
+        print_prop("is_float", TRUE_VALUE);
+      }
+      if (lrg._is_vector) {
+        print_prop("is_vector", TRUE_VALUE);
+      }
+      if (lrg._is_predicate) {
+        print_prop("is_predicate", TRUE_VALUE);
+      }
+      if (lrg._is_scalable) {
+        print_prop("is_scalable", TRUE_VALUE);
+      }
+      if (lrg._was_spilled1) {
+        print_prop("was_spilled1", TRUE_VALUE);
+      }
+      if (lrg._was_spilled2) {
+        print_prop("was_spilled2", TRUE_VALUE);
+      }
+      if (lrg._direct_conflict) {
+        print_prop("direct_conflict", TRUE_VALUE);
+      }
+      if (lrg._fat_proj) {
+        print_prop("fat_proj", TRUE_VALUE);
+      }
+      if (lrg._was_lo) {
+        print_prop("_was_lo", TRUE_VALUE);
+      }
+      if (lrg._has_copy) {
+        print_prop("has_copy", TRUE_VALUE);
+      }
+      if (lrg._at_risk) {
+        print_prop("at_risk", TRUE_VALUE);
+      }
+      if (lrg._must_spill) {
+        print_prop("must_spill", TRUE_VALUE);
+      }
+      if (lrg._is_bound) {
+        print_prop("is_bound", TRUE_VALUE);
+      }
+      if (lrg._msize_valid && lrg._degree_valid && lrg.lo_degree()) {
+        print_prop("trivial", TRUE_VALUE);
+      }
+      tail(PROPERTIES_ELEMENT);
+      tail(LIVE_RANGE_ELEMENT);
+    }
+    tail(LIVE_RANGES_ELEMENT);
+  }
+
   tail(GRAPH_ELEMENT);
   _xml->flush();
 }

src/hotspot/share/opto/idealGraphPrinter.hpp

@@ -91,6 +91,10 @@ class IdealGraphPrinter : public CHeapObj<mtCompiler> {
   static const char *METHOD_BCI_PROPERTY;
   static const char *METHOD_SHORT_NAME_PROPERTY;
   static const char *ASSEMBLY_ELEMENT;
+  static const char *LIVEOUT_ELEMENT;
+  static const char *LIVE_RANGE_ELEMENT;
+  static const char *LIVE_RANGE_ID_PROPERTY;
+  static const char *LIVE_RANGES_ELEMENT;
 
   static int _file_count;
   networkStream *_network_stream;
@@ -114,6 +118,7 @@ class IdealGraphPrinter : public CHeapObj<mtCompiler> {
   ciField* get_field(const Node* node);
   ciField* find_source_field_of_array_access(const Node* node, uint& depth);
   static Node* get_load_node(const Node* node);
+  bool has_liveness_info() const;
   void walk_nodes(Node* start, bool edges);
   void begin_elem(const char *s);
   void end_elem();

src/utils/IdealGraphVisualizer/Bytecodes/src/main/java/com/sun/hotspot/igv/bytecodes/SelectBytecodesAction.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -41,7 +41,7 @@ protected void performAction(Node[] activatedNodes) {
         SelectBytecodesCookie c = activatedNodes[0].getCookie(SelectBytecodesCookie.class);
         InputGraphProvider p = LookupHistory.getLast(InputGraphProvider.class);
         if (p != null) {
-            p.clearSelectedNodes();
+            p.clearSelectedElements();
             p.addSelectedNodes(c.getNodes(), true);
             p.centerSelectedNodes();
         }

src/utils/IdealGraphVisualizer/Data/src/main/java/com/sun/hotspot/igv/data/InputBlock.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -35,6 +35,7 @@ public class InputBlock {
     private final String name;
     private final InputGraph graph;
     private final Set<InputBlock> successors;
+    private Set<Integer> liveOut;
     private boolean artificial;
 
     @Override
@@ -70,6 +71,15 @@ public boolean equals(Object o) {
             }
         }
 
+        if (this.liveOut.size() != b.liveOut.size()) {
+            return false;
+        }
+        for (int liveRangeId : this.liveOut) {
+            if (!b.liveOut.contains(liveRangeId)) {
+                return false;
+            }
+        }
+
         return true;
     }
 
@@ -78,6 +88,7 @@ public boolean equals(Object o) {
         this.name = name;
         nodes = new ArrayList<>();
         successors = new LinkedHashSet<>(2);
+        liveOut = new HashSet<Integer>(0);
         artificial = false;
     }
 
@@ -99,6 +110,14 @@ public void addNode(int id) {
         nodes.add(node);
     }
 
+    public void addLiveOut(int liveRangeId) {
+        liveOut.add(liveRangeId);
+    }
+
+    public Set<Integer> getLiveOut() {
+        return Collections.unmodifiableSet(liveOut);
+    }
+
     public Set<InputBlock> getSuccessors() {
         return Collections.unmodifiableSet(successors);
     }

src/utils/IdealGraphVisualizer/Data/src/main/java/com/sun/hotspot/igv/data/InputGraph.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -38,6 +38,11 @@ public class InputGraph extends Properties.Entity implements FolderElement {
     private final Map<String, InputBlock> blocks;
     private final List<InputBlockEdge> blockEdges;
     private final Map<Integer, InputBlock> nodeToBlock;
+    private final Map<Integer, InputLiveRange> liveRanges;
+    private Map<Integer, LivenessInfo> livenessInfo;
+    private Map<Integer, Set<InputNode>> relatedNodes;
+    private Map<Integer, Set<InputNode>> defNodes;
+    private Map<Integer, Set<InputNode>> useNodes;
     private final boolean isDiffGraph;
     private final InputGraph firstGraph;
     private final InputGraph secondGraph;
@@ -58,6 +63,11 @@ private InputGraph(String name, InputGraph firstGraph, InputGraph secondGraph) {
         nodes = new LinkedHashMap<>();
         edges = new ArrayList<>();
         blocks = new LinkedHashMap<>();
+        liveRanges = new LinkedHashMap<>();
+        livenessInfo = new LinkedHashMap<>();
+        relatedNodes = new LinkedHashMap<>();
+        defNodes = new LinkedHashMap<>();
+        useNodes = new LinkedHashMap<>();
         blockEdges = new ArrayList<>();
         nodeToBlock = new LinkedHashMap<>();
         isDiffGraph = firstGraph != null && secondGraph != null;
@@ -304,12 +314,66 @@ public Group getGroup() {
         return parentGroup;
     }
 
+    public void addLiveRange(InputLiveRange lrg) {
+        liveRanges.put(lrg.getId(), lrg);
+        relatedNodes.put(lrg.getId(), new HashSet<>());
+        defNodes.put(lrg.getId(), new HashSet<>());
+        useNodes.put(lrg.getId(), new HashSet<>());
+    }
+
+    public InputLiveRange getLiveRange(int liveRangeId) {
+        return liveRanges.get(liveRangeId);
+    }
+
+    public Collection<InputLiveRange> getLiveRanges() {
+        return Collections.unmodifiableCollection(liveRanges.values());
+    }
+
+    public void addLivenessInfo(InputNode node, LivenessInfo info) {
+        livenessInfo.put(node.getId(), info);
+        if (info.def != null) {
+            relatedNodes.get(info.def).add(node);
+            defNodes.get(info.def).add(node);
+        }
+        if (info.use != null) {
+            for (int lrg : info.use) {
+                relatedNodes.get(lrg).add(node);
+                useNodes.get(lrg).add(node);
+            }
+        }
+        if (info.join != null) {
+            for (int lrg : info.join) {
+                relatedNodes.get(lrg).add(node);
+                useNodes.get(lrg).add(node);
+            }
+        }
+    }
+
+    public LivenessInfo getLivenessInfoForNode(InputNode node) {
+        return livenessInfo.get(node.getId());
+    }
+
+    public Set<InputNode> getRelatedNodes(int liveRangeId) {
+        return relatedNodes.get(liveRangeId);
+    }
+
+    public Set<InputNode> getDefNodes(int liveRangeId) {
+        return defNodes.get(liveRangeId);
+    }
+
+    public Set<InputNode> getUseNodes(int liveRangeId) {
+        return useNodes.get(liveRangeId);
+    }
+
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append("Graph ").append(getName()).append(" ").append(getProperties().toString()).append("\n");
         for (InputNode n : nodes.values()) {
             sb.append(n.toString());
+            if (livenessInfo.containsKey(n.getId())) {
+                sb.append(" " + livenessInfo.get(n.getId()).toString());
+            }
             sb.append("\n");
         }
 
@@ -323,6 +387,11 @@ public String toString() {
             sb.append("\n");
         }
 
+        for (InputLiveRange l : liveRanges.values()) {
+            sb.append(l.toString());
+            sb.append("\n");
+        }
+
         return sb.toString();
     }