*** old/src/share/vm/compiler/compileBroker.hpp	Fri Sep  5 12:58:04 2014
--- new/src/share/vm/compiler/compileBroker.hpp	Fri Sep  5 12:58:04 2014

*** 109,126 ****
--- 109,126 ----
    void         set_is_free(bool val)             { _is_free = val; }
  
  private:
    static void  print_compilation_impl(outputStream* st, Method* method, int compile_id, int comp_level,
                                        bool is_osr_method = false, int osr_bci = -1, bool is_blocking = false,
!                                       const char* msg = NULL, bool short_form = false, bool cr = true);
  
  public:
!   void         print_compilation(outputStream* st = tty, const char* msg = NULL, bool short_form = false, bool cr = true);
!   static void  print_compilation(outputStream* st, const nmethod* nm, const char* msg = NULL, bool short_form = false) {
!   static void  print_compilation(outputStream* st, const nmethod* nm, const char* msg = NULL, bool short_form = false, bool cr = true) {
      print_compilation_impl(st, nm->method(), nm->compile_id(), nm->comp_level(),
                             nm->is_osr_method(), nm->is_osr_method() ? nm->osr_entry_bci() : -1, /*is_blocking*/ false,
!                            msg, short_form, cr);
    }
  
    static void  print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg = NULL);
    static void  print_inlining(ciMethod* method, int inline_level, int bci, const char* msg = NULL) {
      print_inlining(tty, method, inline_level, bci, msg);

*** 129,140 ****
--- 129,139 ----
    // Redefine Classes support
    void mark_on_stack();
  
    static void  print_inline_indent(int inline_level, outputStream* st = tty);
  
!   void         print_tty();
    void         print_line();
    void         print_line_on_error(outputStream* st, char* buf, int buflen);
  
    void         log_task(xmlStream* log);
    void         log_task_queued();
    void         log_task_start(CompileLog* log);

*** 232,242 ****
--- 231,242 ----
  
  
    // Redefine Classes support
    void mark_on_stack();
    void free_all();
    NOT_PRODUCT (void print();)
+   void print_tty();
+   void print(outputStream* st = tty);
  
    ~CompileQueue() {
      assert (is_empty(), " Compile Queue must be empty");
    }
  };

*** 339,349 ****
--- 339,349 ----
  
    static CompilerThread* make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, AbstractCompiler* comp, TRAPS);
    static void init_compiler_threads(int c1_compiler_count, int c2_compiler_count);
    static bool compilation_is_complete  (methodHandle method, int osr_bci, int comp_level);
    static bool compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level);
-   static bool is_compile_blocking      ();
    static void preload_classes          (methodHandle method, TRAPS);
  
    static CompileTask* create_compile_task(CompileQueue* queue,
                                            int           compile_id,
                                            methodHandle  method,

*** 367,381 ****
--- 367,378 ----
                                    int comp_level,
                                    methodHandle hot_method,
                                    int hot_count,
                                    const char* comment,
                                    Thread* thread);
    static CompileQueue* compile_queue(int comp_level) {
!     if (is_c2_compile(comp_level)) return _c2_compile_queue;
      if (is_c1_compile(comp_level)) return _c1_compile_queue;
      return NULL;
    }
+ 
!   static CompileQueue* compile_queue(int comp_level);
    static bool init_compiler_runtime();
    static void shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread);
  
   public:
    enum {

*** 388,397 ****
--- 385,395 ----
      if (is_c1_compile(comp_level)) return _compilers[0]; // C1
      return NULL;
    }
  
    static bool compilation_is_in_queue(methodHandle method);
+   static void print_compile_queues(outputStream* st);
    static int queue_size(int comp_level) {
      CompileQueue *q = compile_queue(comp_level);
      return q != NULL ? q->size() : 0;
    }
    static void compilation_init();