8347901: C2 should remove unused leaf / pure runtime calls

src/hotspot/share/opto/callnode.cpp

@@ -1315,7 +1315,7 @@ bool CallLeafPureNode::is_dead() const {
  * We use this to delete a pure function that is not used: by replacing the call with
  * such a tuple, we let output Proj's idealization pick the corresponding input of the
  * pure call, so jumping over it, and effectively, removing the call from the graph.
- * This avoids doing the graph surgery manually, but leave that to IGVN
+ * This avoids doing the graph surgery manually, but leaves that to IGVN
  * that is specialized for doing that right. We need also tuple components for output
  * values of the function to respect the return arity, and in case there is a projection
  * that would pick an output (which shouldn't happen at the moment).
@@ -1339,11 +1339,15 @@ TupleNode* CallLeafPureNode::make_tuple_of_input_state_and_top_return_values(con
 }
 
 Node* CallLeafPureNode::Ideal(PhaseGVN* phase, bool can_reshape) {
-  if (is_dead()) { // dead node
+  if (is_dead()) {
     return nullptr;
   }
 
+  // We need to wait until IGVN because during parsing, usages might still be missing
+  // and we would remove the call immediately.
   if (can_reshape && is_unused()) {
+    // The result is not used. We remove the call by replacing it with a tuple, that
+    // is later disintegrated by the projections.
     return make_tuple_of_input_state_and_top_return_values(phase->C);
   }
 

src/hotspot/share/opto/callnode.hpp

@@ -913,6 +913,17 @@ class CallLeafNode : public CallRuntimeNode {
 #endif
 };
 
+/* A pure function call, they are assumed not to be safepoints, not to read or write memory,
+ * have no exception... They just take parameters, return a value without side effect. It is
+ * always correct to create some, or remove them, if the result is not used.
+ *
+ * They still have control input to allow easy lowering into other kind of calls that require
+ * a control, but this is more a technical than a moral constraint.
+ *
+ * Pure calls must have only control and data input and output: I/O, Memory and so on must be top.
+ * Nevertheless, pure calls can typically be expensive math operations so care must be taken
+ * when letting the node float.
+ */
 class CallLeafPureNode : public CallLeafNode {
 protected:
   bool is_unused() const;

src/hotspot/share/opto/divnode.cpp

@@ -1517,19 +1517,17 @@ const Type* UModLNode::Value(PhaseGVN* phase) const {
 }
 
 Node* ModFNode::Ideal(PhaseGVN* phase, bool can_reshape) {
-  if (!can_reshape) {
-    return nullptr;
+  Node* super = CallLeafPureNode::Ideal(phase, can_reshape);
+  if (super != nullptr) {
+    return super;
   }
-  if (is_dead()) { // dead node
+
+  if (!can_reshape) {
     return nullptr;
   }
 
   PhaseIterGVN* igvn = phase->is_IterGVN();
 
-  if (is_unused()) {
-    return make_tuple_of_input_state_and_top_return_values(igvn->C);
-  }
-
   // Either input is TOP ==> the result is TOP
   const Type* t1 = phase->type(dividend());
   const Type* t2 = phase->type(divisor());
@@ -1571,19 +1569,17 @@ Node* ModFNode::Ideal(PhaseGVN* phase, bool can_reshape) {
 }
 
 Node* ModDNode::Ideal(PhaseGVN* phase, bool can_reshape) {
-  if (!can_reshape) {
-    return nullptr;
+  Node* super = CallLeafPureNode::Ideal(phase, can_reshape);
+  if (super != nullptr) {
+    return super;
   }
-  if (is_dead()) { // dead node
+
+  if (!can_reshape) {
     return nullptr;
   }
 
   PhaseIterGVN* igvn = phase->is_IterGVN();
 
-  if (is_unused()) {
-    return make_tuple_of_input_state_and_top_return_values(igvn->C);
-  }
-
   // Either input is TOP ==> the result is TOP
   const Type* t1 = phase->type(dividend());
   const Type* t2 = phase->type(divisor());