src/hotspot/share/opto/compile.hpp

*** 46,10 ***
--- 46,11 ---
  #include "runtime/vmThread.hpp"
  #include "utilities/ticks.hpp"
  
  class AbstractLockNode;
  class AddPNode;
+ class AllocateNode;
  class Block;
  class Bundle;
  class CallGenerator;
  class CallStaticJavaNode;
  class CloneMap;

*** 69,10 ***
--- 70,11 ---
  class Node_Notes;
  class NodeHash;
  class NodeCloneInfo;
  class OptoReg;
  class ParsePredicateNode;
+ class PartialEscapeAnalysis;
  class PhaseCFG;
  class PhaseGVN;
  class PhaseIterGVN;
  class PhaseRegAlloc;
  class PhaseCCP;

*** 96,10 ***
--- 98,12 ---
  class nmethod;
  class Node_Stack;
  struct Final_Reshape_Counts;
  class VerifyMeetResult;
  
+ typedef AllocateNode* ObjID;
+ 
  enum LoopOptsMode {
    LoopOptsDefault,
    LoopOptsNone,
    LoopOptsMaxUnroll,
    LoopOptsShenandoahExpand,

*** 357,10 ***
--- 361,11 ---
    int                   _loop_opts_cnt;         // loop opts round
    uint                  _stress_seed;           // Seed for stress testing
  
    // Compilation environment.
    Arena                 _comp_arena;            // Arena with lifetime equivalent to Compile
+   Arena*                _parser_arena;          // Arena with lifttime equivalent to the top-level parser.
    void*                 _barrier_set_state;     // Potential GC barrier state for Compile
    ciEnv*                _env;                   // CI interface
    DirectiveSet*         _directive;             // Compiler directive
    CompileLog*           _log;                   // from CompilerThread
    const char*           _failure_reason;        // for record_failure/failing pattern

*** 371,10 ***
--- 376,11 ---
    GrowableArray<Node*>  _template_assertion_predicate_opaqs; // List of Opaque4 nodes for Template Assertion Predicates.
    GrowableArray<Node*>  _expensive_nodes;       // List of nodes that are expensive to compute and that we'd better not let the GVN freely common
    GrowableArray<Node*>  _for_post_loop_igvn;    // List of nodes for IGVN after loop opts are over
    GrowableArray<UnstableIfTrap*> _unstable_if_traps;        // List of ifnodes after IGVN
    GrowableArray<Node_List*> _coarsened_locks;   // List of coarsened Lock and Unlock nodes
+   PartialEscapeAnalysis* _pea;
    ConnectionGraph*      _congraph;
  #ifndef PRODUCT
    IdealGraphPrinter*    _igv_printer;
    static IdealGraphPrinter* _debug_file_printer;
    static IdealGraphPrinter* _debug_network_printer;

*** 779,10 ***
--- 785,15 ---
    }
    void add_coarsened_locks(GrowableArray<AbstractLockNode*>& locks);
    void remove_coarsened_lock(Node* n);
    bool coarsened_locks_consistent();
  
+   PartialEscapeAnalysis* PEA() const {
+     assert(!DoPartialEscapeAnalysis || _pea != nullptr, "sanity check");
+     return _pea;
+   }
+ 
    bool       post_loop_opts_phase() { return _post_loop_opts_phase;  }
    void   set_post_loop_opts_phase() { _post_loop_opts_phase = true;  }
    void reset_post_loop_opts_phase() { _post_loop_opts_phase = false; }
  
    void record_for_post_loop_opts_igvn(Node* n);

*** 805,10 ***
--- 816,11 ---
    // Sort expensive nodes to locate similar expensive nodes
    void sort_expensive_nodes();
  
    // Compilation environment.
    Arena*      comp_arena()           { return &_comp_arena; }
+   Arena*      parser_arena()         { return comp_arena(); } // for the time being, just return comp_arena.
    ciEnv*      env() const            { return _env; }
    CompileLog* log() const            { return _log; }
    bool        failing() const        { return _env->failing() || _failure_reason != nullptr; }
    const char* failure_reason() const { return (_env->failing()) ? _env->failure_reason() : _failure_reason; }
    const CompilationFailureInfo* first_failure_details() const { return _first_failure_details; }