*** old/src/share/vm/opto/compile.hpp	Thu Oct  8 14:07:19 2015
--- new/src/share/vm/opto/compile.hpp	Thu Oct  8 14:07:19 2015

*** 389,398 ****
--- 389,399 ----
    RTMState              _rtm_state;             // State of Restricted Transactional Memory usage
  
    // Compilation environment.
    Arena                 _comp_arena;            // Arena with lifetime equivalent to Compile
    ciEnv*                _env;                   // CI interface
+   DirectiveSet*         _directive;             // Compiler directive
    CompileLog*           _log;                   // from CompilerThread
    const char*           _failure_reason;        // for record_failure/failing pattern
    GrowableArray<CallGenerator*>* _intrinsics;   // List of intrinsics.
    GrowableArray<Node*>* _macro_nodes;           // List of nodes which need to be expanded before matching.
    GrowableArray<Node*>* _predicate_opaqs;       // List of Opaque1 nodes for the loop predicates.

*** 525,534 ****
--- 526,539 ----
      stringStream ss;
      CompileTask::print_inlining_inner(&ss, method, inline_level, bci, msg);
      print_inlining_stream()->print("%s", ss.as_string());
    }
  
+ #ifndef PRODUCT
+   IdealGraphPrinter* printer() { return _printer; }
+ #endif
+ 
    void log_late_inline(CallGenerator* cg);
    void log_inline_id(CallGenerator* cg);
    void log_inline_failure(const char* msg);
  
    void* replay_inline_data() const { return _replay_inline_data; }

*** 576,585 ****
--- 581,591 ----
      return (Compile*) ciEnv::current()->compiler_data();
    }
  
    // ID for this compilation.  Useful for setting breakpoints in the debugger.
    int               compile_id() const          { return _compile_id; }
+   DirectiveSet*     directive() const           { return _directive; }
  
    // Does this compilation allow instructions to subsume loads?  User
    // instructions that subsume a load may result in an unschedulable
    // instruction sequence.
    bool              subsume_loads() const       { return _subsume_loads; }

*** 669,682 ****
--- 675,685 ----
  
    // check the CompilerOracle for special behaviours for this compile
    bool          method_has_option(const char * option) {
      return method() != NULL && method()->has_option(option);
    }
    template<typename T>
    bool          method_has_option_value(const char * option, T& value) {
      return method() != NULL && method()->has_option_value(option, value);
    }
+ 
  #ifndef PRODUCT
    bool          trace_opto_output() const       { return _trace_opto_output; }
    bool              parsed_irreducible_loop() const { return _parsed_irreducible_loop; }
    void          set_parsed_irreducible_loop(bool z) { _parsed_irreducible_loop = z; }
    int _in_dump_cnt;  // Required for dumping ir nodes.

*** 690,701 ****
--- 693,704 ----
  
    Ticks _latest_stage_start_counter;
  
    void begin_method() {
  #ifndef PRODUCT
!     if (_printer && _printer->should_print(_method)) {
-       _printer->begin_method(this);
!     if (_printer && _printer->should_print(1)) {
!       _printer->begin_method();
      }
  #endif
      C->_latest_stage_start_counter.stamp();
    }
  

*** 709,720 ****
--- 712,723 ----
        event.commit();
      }
  
  
  #ifndef PRODUCT
!     if (_printer && _printer->should_print(_method)) {
-       _printer->print_method(this, CompilerPhaseTypeHelper::to_string(cpt), level);
!     if (_printer && _printer->should_print(level)) {
!       _printer->print_method(CompilerPhaseTypeHelper::to_string(cpt), level);
      }
  #endif
      C->_latest_stage_start_counter.stamp();
    }
  

*** 726,736 ****
--- 729,739 ----
        event.set_compileID(C->_compile_id);
        event.set_phaseLevel(level);
        event.commit();
      }
  #ifndef PRODUCT
!     if (_printer && _printer->should_print(_method)) {
!     if (_printer && _printer->should_print(level)) {
        _printer->end_method();
      }
  #endif
    }
  

*** 1105,1123 ****
--- 1108,1126 ----
    // For normal compilations, entry_bci is InvocationEntryBci.  For on stack
    // replacement, entry_bci indicates the bytecode for which to compile a
    // continuation.
    Compile(ciEnv* ci_env, C2Compiler* compiler, ciMethod* target,
            int entry_bci, bool subsume_loads, bool do_escape_analysis,
!           bool eliminate_boxing, DirectiveSet* directive);
  
    // Second major entry point.  From the TypeFunc signature, generate code
    // to pass arguments from the Java calling convention to the C calling
    // convention.
    Compile(ciEnv* ci_env, const TypeFunc *(*gen)(),
            address stub_function, const char *stub_name,
            int is_fancy_jump, bool pass_tls,
!           bool save_arg_registers, bool return_pc, DirectiveSet* directive);
  
    // From the TypeFunc signature, generate code to pass arguments
    // from Compiled calling convention to Interpreter's calling convention
    void Generate_Compiled_To_Interpreter_Graph(const TypeFunc *tf, address interpreter_entry);