src/hotspot/share/opto/cfgnode.hpp

*** 178,10 ***
--- 178,13 ---
    static Node* clone_through_phi(Node* root_phi, const Type* t, uint c, PhaseIterGVN* igvn);
    static Node* merge_through_phi(Node* root_phi, PhaseIterGVN* igvn);
  
    bool must_wait_for_region_in_irreducible_loop(PhaseGVN* phase) const;
  
+   bool can_push_inline_types_down(PhaseGVN* phase, bool can_reshape, ciInlineKlass*& inline_klass);
+   InlineTypeNode* push_inline_types_down(PhaseGVN* phase, bool can_reshape, ciInlineKlass* inline_klass);
+ 
    bool is_split_through_mergemem_terminating() const;
  
  public:
    // Node layout (parallels RegionNode):
    enum { Region,                // Control input is the Phi's region.

*** 227,10 ***
--- 230,11 ---
      if (uin == nullptr) {
        uin = unique_input(phase, true);
      }
      return uin;
    }
+   Node* unique_input_recursive(PhaseGVN* phase);
  
    // Check for a simple dead loop.
    enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop };
    LoopSafety simple_data_loop_check(Node *in) const;
    // Is it unsafe data loop? It becomes a dead loop if this phi node removed.

*** 253,10 ***
--- 257,17 ---
             inst_index()  == index  &&
             inst_offset() == offset &&
             type()->higher_equal(tp);
    }
  
+   bool can_be_inline_type() const {
+     return EnableValhalla && _type->isa_instptr() && _type->is_instptr()->can_be_inline_type();
+   }
+ 
+   Node* try_push_inline_types_down(PhaseGVN* phase, bool can_reshape);
+   DEBUG_ONLY(bool can_push_inline_types_down(PhaseGVN* phase);)
+ 
    virtual const Type* Value(PhaseGVN* phase) const;
    virtual Node* Identity(PhaseGVN* phase);
    virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
    virtual const RegMask &out_RegMask() const;
    virtual const RegMask &in_RegMask(uint) const;

*** 446,10 ***
--- 457,12 ---
    // Takes the type of val and filters it through the test represented
    // by if_proj and returns a more refined type if one is produced.
    // Returns null is it couldn't improve the type.
    static const TypeInt* filtered_int_type(PhaseGVN* phase, Node* val, Node* if_proj);
  
+   bool is_flat_array_check(PhaseTransform* phase, Node** array = nullptr);
+ 
    AssertionPredicateType assertion_predicate_type() const {
      return _assertion_predicate_type;
    }
  
  #ifndef PRODUCT

*** 729,10 ***
--- 742,11 ---
  // the effects on its arguments, and would be finally matched to nothing.
  class BlackholeNode : public MultiNode {
  public:
    BlackholeNode(Node* ctrl) : MultiNode(1) {
      init_req(TypeFunc::Control, ctrl);
+     init_class_id(Class_Blackhole);
    }
    virtual int   Opcode() const;
    virtual uint ideal_reg() const { return 0; } // not matched in the AD file
    virtual const Type* bottom_type() const { return TypeTuple::MEMBAR; }
    virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);