*** old/src/share/vm/opto/compile.hpp	Fri Sep 25 16:23:22 2015
--- new/src/share/vm/opto/compile.hpp	Fri Sep 25 16:23:22 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*         _dirset;                // Compiler directives
    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.

*** 576,585 ****
--- 577,587 ----
      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*     dirset() const              { return _dirset; }
  
    // 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 ****
--- 671,681 ----
  
    // 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,700 ****
--- 689,699 ----
  
    Ticks _latest_stage_start_counter;
  
    void begin_method() {
  #ifndef PRODUCT
!     if (_printer && _printer->should_print(_method)) {
!     if (_printer && _printer->should_print(1)) {
        _printer->begin_method(this);
      }
  #endif
      C->_latest_stage_start_counter.stamp();
    }

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

*** 726,736 ****
--- 725,735 ----
        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 ****
--- 1104,1122 ----
    // 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* dirset);
  
    // 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* dirset);
  
    // 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);