8372634: C2: Materialize type information from instanceof checks

Reviewed-by: dlong, qamai, roland

Author: Vladimir Ivanov

src/hotspot/share/compiler/compilerDirectives.cpp

@@ -561,6 +561,20 @@ bool DirectiveSet::should_not_inline(ciMethod* inlinee) {
   return false;
 }
 
+bool DirectiveSet::should_delay_inline(ciMethod* inlinee) {
+  inlinee->check_is_loaded();
+  VM_ENTRY_MARK;
+  methodHandle mh(THREAD, inlinee->get_Method());
+
+  if (_inlinematchers != nullptr) {
+    return matches_inline(mh, InlineMatcher::delay_inline);
+  }
+  if (!CompilerDirectivesIgnoreCompileCommandsOption) {
+    return CompilerOracle::should_delay_inline(mh);
+  }
+  return false;
+}
+
 bool DirectiveSet::parse_and_add_inline(char* str, const char*& error_msg) {
   InlineMatcher* m = InlineMatcher::parse_inline_pattern(str, error_msg);
   if (m != nullptr) {

src/hotspot/share/compiler/compilerDirectives.hpp

@@ -142,6 +142,7 @@ class DirectiveSet : public CHeapObj<mtCompiler> {
   void append_inline(InlineMatcher* m);
   bool should_inline(ciMethod* inlinee);
   bool should_not_inline(ciMethod* inlinee);
+  bool should_delay_inline(ciMethod* inlinee);
   void print_inline(outputStream* st);
   DirectiveSet* compilecommand_compatibility_init(const methodHandle& method);
   bool is_exclusive_copy() { return _directive == nullptr; }

src/hotspot/share/compiler/compilerOracle.cpp

@@ -480,6 +480,10 @@ bool CompilerOracle::should_not_inline(const methodHandle& method) {
   return check_predicate(CompileCommandEnum::DontInline, method) || check_predicate(CompileCommandEnum::Exclude, method);
 }
 
+bool CompilerOracle::should_delay_inline(const methodHandle& method) {
+  return (check_predicate(CompileCommandEnum::DelayInline, method));
+}
+
 bool CompilerOracle::should_print(const methodHandle& method) {
   return check_predicate(CompileCommandEnum::Print, method);
 }

src/hotspot/share/compiler/compilerOracle.hpp

@@ -51,6 +51,7 @@ class methodHandle;
   option(Log, "log", Bool) \
   option(Print, "print", Bool) \
   option(Inline,  "inline", Bool) \
+  option(DelayInline,  "delayinline", Bool) \
   option(DontInline,  "dontinline", Bool) \
   option(Blackhole,  "blackhole", Bool) \
   option(CompileOnly, "compileonly", Bool)\
@@ -150,6 +151,9 @@ class CompilerOracle : AllStatic {
   // Tells whether we want to disallow inlining of this method
   static bool should_not_inline(const methodHandle& method);
 
+  // Tells whether we want to delay inlining of this method
+  static bool should_delay_inline(const methodHandle& method);
+
   // Tells whether this method changes Thread.currentThread()
   static bool changes_current_thread(const methodHandle& method);
 

src/hotspot/share/compiler/methodMatcher.hpp

@@ -100,6 +100,7 @@ class InlineMatcher : public MethodMatcher {
   enum InlineType {
       unknown_inline,
       dont_inline,
+      delay_inline,
       force_inline
     };
 

src/hotspot/share/opto/compile.hpp

@@ -984,7 +984,8 @@ class Compile : public Phase {
                                    JVMState* jvms, bool allow_inline, float profile_factor, ciKlass* speculative_receiver_type = nullptr,
                                    bool allow_intrinsics = true);
   bool should_delay_inlining(ciMethod* call_method, JVMState* jvms) {
-    return should_delay_string_inlining(call_method, jvms) ||
+    return C->directive()->should_delay_inline(call_method) ||
+           should_delay_string_inlining(call_method, jvms) ||
            should_delay_boxing_inlining(call_method, jvms) ||
            should_delay_vector_inlining(call_method, jvms);
   }

src/hotspot/share/opto/doCall.cpp

@@ -192,7 +192,7 @@ CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool
     // Try inlining a bytecoded method:
     if (!call_does_dispatch) {
       InlineTree* ilt = InlineTree::find_subtree_from_root(this->ilt(), jvms->caller(), jvms->method());
-      bool should_delay = C->should_delay_inlining();
+      bool should_delay = C->should_delay_inlining() || C->directive()->should_delay_inline(callee);
       if (ilt->ok_to_inline(callee, jvms, profile, should_delay)) {
         CallGenerator* cg = CallGenerator::for_inline(callee, expected_uses);
         // For optimized virtual calls assert at runtime that receiver object

src/hotspot/share/opto/parse2.cpp

@@ -41,6 +41,7 @@
 #include "opto/opaquenode.hpp"
 #include "opto/parse.hpp"
 #include "opto/runtime.hpp"
+#include "opto/subtypenode.hpp"
 #include "runtime/deoptimization.hpp"
 #include "runtime/sharedRuntime.hpp"
 
@@ -1719,38 +1720,108 @@ static Node* extract_obj_from_klass_load(PhaseGVN* gvn, Node* n) {
   return obj;
 }
 
+// Matches exact and inexact type check IR shapes during parsing.
+// On successful match, returns type checked object node and its type after successful check
+// as out parameters.
+static bool match_type_check(PhaseGVN& gvn,
+                             BoolTest::mask btest,
+                             Node* con, const Type* tcon,
+                             Node* val, const Type* tval,
+                             Node** obj, const TypeOopPtr** cast_type) { // out-parameters
+  // Look for opportunities to sharpen the type of a node whose klass is compared with a constant klass.
+  // The constant klass being tested against can come from many bytecode instructions (implicitly or explicitly),
+  // and also from profile data used by speculative casts.
+  if (btest == BoolTest::eq && tcon->isa_klassptr()) {
+    // Found:
+    //   Bool(CmpP(LoadKlass(obj._klass), ConP(Foo.klass)), [eq])
+    // or the narrowOop equivalent.
+    (*obj) = extract_obj_from_klass_load(&gvn, val);
+    (*cast_type) = tcon->isa_klassptr()->as_instance_type();
+    return true; // found
+  }
+
+  // Match an instanceof check.
+  // During parsing its IR shape is not canonicalized yet.
+  //
+  //             obj superklass
+  //              |    |
+  //           SubTypeCheck
+  //                |
+  //               Bool [eq] / [ne]
+  //                |
+  //                If
+  //               / \
+  //              T   F
+  //               \ /
+  //              Region
+  //                 \  ConI ConI
+  //                  \  |  /
+  //          val ->    Phi  ConI  <- con
+  //                     \  /
+  //                     CmpI
+  //                      |
+  //                    Bool [btest]
+  //                      |
+  //
+  if (tval->isa_int() && val->is_Phi() && val->in(0)->as_Region()->is_diamond()) {
+    RegionNode* diamond = val->in(0)->as_Region();
+    IfNode* if1 = diamond->in(1)->in(0)->as_If();
+    BoolNode* b1 = if1->in(1)->isa_Bool();
+    if (b1 != nullptr && b1->in(1)->isa_SubTypeCheck()) {
+      assert(b1->_test._test == BoolTest::eq ||
+             b1->_test._test == BoolTest::ne, "%d", b1->_test._test);
+
+      ProjNode* success_proj = if1->proj_out(b1->_test._test == BoolTest::eq ? 1 : 0);
+      int idx = diamond->find_edge(success_proj);
+      assert(idx == 1 || idx == 2, "");
+      Node* vcon = val->in(idx);
+
+      assert(val->find_edge(con) > 0, "");
+      if ((btest == BoolTest::eq && vcon == con) || (btest == BoolTest::ne && vcon != con)) {
+        SubTypeCheckNode* sub = b1->in(1)->as_SubTypeCheck();
+        Node* obj_or_subklass = sub->in(SubTypeCheckNode::ObjOrSubKlass);
+        Node* superklass = sub->in(SubTypeCheckNode::SuperKlass);
+
+        if (gvn.type(obj_or_subklass)->isa_oopptr()) {
+          const TypeKlassPtr* klass_ptr_type = gvn.type(superklass)->is_klassptr();
+          const TypeKlassPtr* improved_klass_ptr_type = klass_ptr_type->try_improve();
+
+          (*obj) = obj_or_subklass;
+          (*cast_type) = improved_klass_ptr_type->cast_to_exactness(false)->as_instance_type();
+          return true; // found
+        }
+      }
+    }
+  }
+  return false; // not found
+}
+
 void Parse::sharpen_type_after_if(BoolTest::mask btest,
                                   Node* con, const Type* tcon,
                                   Node* val, const Type* tval) {
-  // Look for opportunities to sharpen the type of a node
-  // whose klass is compared with a constant klass.
-  if (btest == BoolTest::eq && tcon->isa_klassptr()) {
-    Node* obj = extract_obj_from_klass_load(&_gvn, val);
-    const TypeOopPtr* con_type = tcon->isa_klassptr()->as_instance_type();
-    if (obj != nullptr && (con_type->isa_instptr() || con_type->isa_aryptr())) {
-       // Found:
-       //   Bool(CmpP(LoadKlass(obj._klass), ConP(Foo.klass)), [eq])
-       // or the narrowOop equivalent.
-       const Type* obj_type = _gvn.type(obj);
-       const TypeOopPtr* tboth = obj_type->join_speculative(con_type)->isa_oopptr();
-       if (tboth != nullptr && tboth->klass_is_exact() && tboth != obj_type &&
-           tboth->higher_equal(obj_type)) {
-          // obj has to be of the exact type Foo if the CmpP succeeds.
-          int obj_in_map = map()->find_edge(obj);
-          JVMState* jvms = this->jvms();
-          if (obj_in_map >= 0 &&
-              (jvms->is_loc(obj_in_map) || jvms->is_stk(obj_in_map))) {
-            TypeNode* ccast = new CheckCastPPNode(control(), obj, tboth);
-            const Type* tcc = ccast->as_Type()->type();
-            assert(tcc != obj_type && tcc->higher_equal(obj_type), "must improve");
-            // Delay transform() call to allow recovery of pre-cast value
-            // at the control merge.
-            _gvn.set_type_bottom(ccast);
-            record_for_igvn(ccast);
-            // Here's the payoff.
-            replace_in_map(obj, ccast);
-          }
-       }
+  Node* obj = nullptr;
+  const TypeOopPtr* cast_type = nullptr;
+  // Insert a cast node with a narrowed type after a successful type check.
+  if (match_type_check(_gvn, btest, con, tcon, val, tval,
+                       &obj, &cast_type)) {
+    assert(obj != nullptr && cast_type != nullptr, "missing type check info");
+    const Type* obj_type = _gvn.type(obj);
+    const TypeOopPtr* tboth = obj_type->join_speculative(cast_type)->isa_oopptr();
+    if (tboth != nullptr && tboth != obj_type && tboth->higher_equal(obj_type)) {
+      int obj_in_map = map()->find_edge(obj);
+      JVMState* jvms = this->jvms();
+      if (obj_in_map >= 0 &&
+          (jvms->is_loc(obj_in_map) || jvms->is_stk(obj_in_map))) {
+        TypeNode* ccast = new CheckCastPPNode(control(), obj, tboth);
+        const Type* tcc = ccast->as_Type()->type();
+        assert(tcc != obj_type && tcc->higher_equal(obj_type), "must improve");
+        // Delay transform() call to allow recovery of pre-cast value
+        // at the control merge.
+        _gvn.set_type_bottom(ccast);
+        record_for_igvn(ccast);
+        // Here's the payoff.
+        replace_in_map(obj, ccast);
+      }
     }
   }