8347901: C2 should remove unused leaf / pure runtime calls

src/hotspot/share/opto/callnode.cpp

@@ -1306,7 +1306,20 @@ void CallLeafVectorNode::calling_convention( BasicType* sig_bt, VMRegPair *parm_
 bool CallLeafPureNode::is_unused() const {
   return proj_out_or_null(TypeFunc::Parms) == nullptr;
 }
-// We make a tuple of the global input state + TOP for the output values.
+
+bool CallLeafPureNode::is_dead() const {
+  return proj_out_or_null(TypeFunc::Control) == nullptr;
+}
+
+/* We make a tuple of the global input state + TOP for the output values.
+ * 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
+ * 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).
+ */
 TupleNode* CallLeafPureNode::make_tuple_of_input_state_and_top_return_values(const Compile* C) const {
   // Transparently propagate input state but parameters
   TupleNode* tuple = TupleNode::make(
@@ -1326,7 +1339,7 @@ TupleNode* CallLeafPureNode::make_tuple_of_input_state_and_top_return_values(con
 }
 
 Node* CallLeafPureNode::Ideal(PhaseGVN* phase, bool can_reshape) {
-  if (proj_out_or_null(TypeFunc::Control) == nullptr) { // dead node
+  if (is_dead()) { // dead node
     return nullptr;
   }
 

src/hotspot/share/opto/callnode.hpp

@@ -916,6 +916,7 @@ class CallLeafNode : public CallRuntimeNode {
 class CallLeafPureNode : public CallLeafNode {
 protected:
   bool is_unused() const;
+  bool is_dead() const;
   TupleNode* make_tuple_of_input_state_and_top_return_values(const Compile* C) const;
 
 public:

src/hotspot/share/opto/compile.cpp

@@ -3299,6 +3299,7 @@ void Compile::final_graph_reshaping_main_switch(Node* n, Final_Reshape_Counts& f
     n->subsume_by(n->in(1), this);
     break;
   case Op_CallLeafPure: {
+    // If the pure call is not supported, then lower to a CallLeaf.
     if (!Matcher::match_rule_supported(Op_CallLeafPure)) {
       CallNode* call = n->as_Call();
       CallNode* new_call = new CallLeafNode(call->tf(), call->entry_point(),
@@ -3308,8 +3309,8 @@ void Compile::final_graph_reshaping_main_switch(Node* n, Final_Reshape_Counts& f
       new_call->init_req(TypeFunc::Memory, C->top());
       new_call->init_req(TypeFunc::ReturnAdr, C->top());
       new_call->init_req(TypeFunc::FramePtr, C->top());
-      for (unsigned int i = 0; i < call->tf()->domain()->cnt() - TypeFunc::Parms; i++) {
-        new_call->init_req(TypeFunc::Parms + i, call->in(TypeFunc::Parms + i));
+      for (unsigned int i = TypeFunc::Parms; i < call->tf()->domain()->cnt(); i++) {
+        new_call->init_req(i, call->in(i));
       }
       n->subsume_by(new_call, this);
     }

src/hotspot/share/opto/divnode.cpp

@@ -1520,7 +1520,7 @@ Node* ModFNode::Ideal(PhaseGVN* phase, bool can_reshape) {
   if (!can_reshape) {
     return nullptr;
   }
-  if (proj_out_or_null(TypeFunc::Control) == nullptr) { // dead node
+  if (is_dead()) { // dead node
     return nullptr;
   }
 
@@ -1574,7 +1574,7 @@ Node* ModDNode::Ideal(PhaseGVN* phase, bool can_reshape) {
   if (!can_reshape) {
     return nullptr;
   }
-  if (proj_out_or_null(TypeFunc::Control) == nullptr) { // dead node
+  if (is_dead()) { // dead node
     return nullptr;
   }
 

src/hotspot/share/opto/graphKit.cpp

@@ -1912,6 +1912,8 @@ void GraphKit::set_predefined_output_for_runtime_call(Node* call,
   // no i/o
   set_control(_gvn.transform( new ProjNode(call,TypeFunc::Control) ));
   if (call->is_CallLeafPure()) {
+    // Pure function have only control (for now) and data output, in particular
+    // the don't touch the memory, so we don't want a memory proj that is set after.
     return;
   }
   if (keep_mem) {

src/hotspot/share/opto/multnode.hpp

@@ -106,7 +106,22 @@ class ProjNode : public Node {
   ProjNode* other_if_proj() const;
 };
 
-//------------------------------TupleNode---------------------------------------
+/* Tuples are used to avoid manual graph surgery. When a node with Proj outputs (such as a call)
+ * must be removed and its ouputs replaced by its input, or some other value, we can make its
+ * ::Ideal return a tuple of what we want for each output: the ::Identity of output Proj will
+ * take care to jump over the Tuple and directly pick up the right input of the Tuple.
+ *
+ * For instance, if a function call is proven to have no side effect and return the constant 0,
+ * we can replace it with the 6-tuple:
+ * (control input, IO input, memory input, frame ptr input, return addr input, Con:0)
+ * all the output projections will pick up the input of the now gone call, except for the result
+ * projection that is replaced by 0.
+ *
+ * Using TupleNode avoid manual graph surgery and leave that to our expert surgeon: IGVN.
+ * Since the user of a Tuple are expected to be Proj, when creating a tuple during idealization,
+ * the output Proj should be enqueued for IGVN immediately after, and the tuple should not survive
+ * after the current IGVN.
+ */
 class TupleNode : public MultiNode {
   const TypeTuple* _tf;
 
@@ -124,6 +139,10 @@ class TupleNode : public MultiNode {
   int Opcode() const override;
   const Type* bottom_type() const override { return _tf; }
 
+  /* Give as many `Node*` as you want in the `nn` pack:
+   * TupleNode::make(tf, input1)
+   * TupleNode::make(tf, input1, input2, input3, input4)
+   */
   template <typename... NN>
   static TupleNode* make(const TypeTuple* tf, NN... nn) {
     TupleNode* tn = new TupleNode(tf);