src/share/vm/opto/compile.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/opto

src/share/vm/opto/compile.hpp

Print this page
rev 6132 : 8007988: PrintInlining output is inconsistent with incremental inlining
Summary: fix duplicate and conflicting inlining output
Reviewed-by:
rev 6133 : 8005079: fix LogCompilation for incremental inlining
Summary: report late inlining as part of the rest of the inlining output
Reviewed-by:
rev 6134 : imported patch logcompilation-reviews
rev 6135 : [mq]: logcompilation-reviews2


 423   // Only keep nodes in the expensive node list that need to be optimized
 424   void cleanup_expensive_nodes(PhaseIterGVN &igvn);
 425   // Use for sorting expensive nodes to bring similar nodes together
 426   static int cmp_expensive_nodes(Node** n1, Node** n2);
 427   // Expensive nodes list already sorted?
 428   bool expensive_nodes_sorted() const;
 429   // Remove the speculative part of types and clean up the graph
 430   void remove_speculative_types(PhaseIterGVN &igvn);
 431 
 432   // Are we within a PreserveJVMState block?
 433   int _preserve_jvm_state;
 434 
 435   void* _replay_inline_data; // Pointer to data loaded from file
 436 
 437   void print_inlining_init();
 438   void print_inlining_reinit();
 439   void print_inlining_commit();
 440   void print_inlining_push();
 441   PrintInliningBuffer& print_inlining_current();
 442 


 443  public:
 444 
 445   outputStream* print_inlining_stream() const {
 446     assert(print_inlining() || print_intrinsics(), "PrintInlining off?");
 447     return _print_inlining_stream;
 448   }
 449 
 450   void print_inlining_update(CallGenerator* cg);
 451   void print_inlining_update_delayed(CallGenerator* cg);
 452   void print_inlining_move_to(CallGenerator* cg);
 453   void print_inlining_assert_ready();
 454   void print_inlining_reset();
 455 
 456   void print_inlining(ciMethod* method, int inline_level, int bci, const char* msg = NULL) {
 457     stringStream ss;
 458     CompileTask::print_inlining(&ss, method, inline_level, bci, msg);
 459     print_inlining_stream()->print(ss.as_string());
 460   }




 461 
 462   void* replay_inline_data() const { return _replay_inline_data; }
 463 
 464   // Dump inlining replay data to the stream.
 465   void dump_inline_data(outputStream* out);
 466 
 467  private:
 468   // Matching, CFG layout, allocation, code generation
 469   PhaseCFG*             _cfg;                   // Results of CFG finding
 470   bool                  _select_24_bit_instr;   // We selected an instruction with a 24-bit result
 471   bool                  _in_24_bit_fp_mode;     // We are emitting instructions with 24-bit results
 472   int                   _java_calls;            // Number of java calls in the method
 473   int                   _inner_loops;           // Number of inner loops in the method
 474   Matcher*              _matcher;               // Engine to map ideal to machine instructions
 475   PhaseRegAlloc*        _regalloc;              // Results of register allocation.
 476   int                   _frame_slots;           // Size of total frame in stack slots
 477   CodeOffsets           _code_offsets;          // Offsets into the code for various interesting entries
 478   RegMask               _FIRST_STACK_mask;      // All stack slots usable for spills (depends on frame layout)
 479   Arena*                _indexSet_arena;        // control IndexSet allocation within PhaseChaitin
 480   void*                 _indexSet_free_block_list; // free list of IndexSet bit blocks




 423   // Only keep nodes in the expensive node list that need to be optimized
 424   void cleanup_expensive_nodes(PhaseIterGVN &igvn);
 425   // Use for sorting expensive nodes to bring similar nodes together
 426   static int cmp_expensive_nodes(Node** n1, Node** n2);
 427   // Expensive nodes list already sorted?
 428   bool expensive_nodes_sorted() const;
 429   // Remove the speculative part of types and clean up the graph
 430   void remove_speculative_types(PhaseIterGVN &igvn);
 431 
 432   // Are we within a PreserveJVMState block?
 433   int _preserve_jvm_state;
 434 
 435   void* _replay_inline_data; // Pointer to data loaded from file
 436 
 437   void print_inlining_init();
 438   void print_inlining_reinit();
 439   void print_inlining_commit();
 440   void print_inlining_push();
 441   PrintInliningBuffer& print_inlining_current();
 442 
 443   void log_late_inline_failure(CallGenerator* cg, const char* msg);
 444 
 445  public:
 446 
 447   outputStream* print_inlining_stream() const {
 448     assert(print_inlining() || print_intrinsics(), "PrintInlining off?");
 449     return _print_inlining_stream;
 450   }
 451 
 452   void print_inlining_update(CallGenerator* cg);
 453   void print_inlining_update_delayed(CallGenerator* cg);
 454   void print_inlining_move_to(CallGenerator* cg);
 455   void print_inlining_assert_ready();
 456   void print_inlining_reset();
 457 
 458   void print_inlining(ciMethod* method, int inline_level, int bci, const char* msg = NULL) {
 459     stringStream ss;
 460     CompileTask::print_inlining(&ss, method, inline_level, bci, msg);
 461     print_inlining_stream()->print(ss.as_string());
 462   }
 463 
 464   void log_late_inline(CallGenerator* cg);
 465   void log_inline_id(CallGenerator* cg);
 466   void log_inline_failure(const char* msg);
 467 
 468   void* replay_inline_data() const { return _replay_inline_data; }
 469 
 470   // Dump inlining replay data to the stream.
 471   void dump_inline_data(outputStream* out);
 472 
 473  private:
 474   // Matching, CFG layout, allocation, code generation
 475   PhaseCFG*             _cfg;                   // Results of CFG finding
 476   bool                  _select_24_bit_instr;   // We selected an instruction with a 24-bit result
 477   bool                  _in_24_bit_fp_mode;     // We are emitting instructions with 24-bit results
 478   int                   _java_calls;            // Number of java calls in the method
 479   int                   _inner_loops;           // Number of inner loops in the method
 480   Matcher*              _matcher;               // Engine to map ideal to machine instructions
 481   PhaseRegAlloc*        _regalloc;              // Results of register allocation.
 482   int                   _frame_slots;           // Size of total frame in stack slots
 483   CodeOffsets           _code_offsets;          // Offsets into the code for various interesting entries
 484   RegMask               _FIRST_STACK_mask;      // All stack slots usable for spills (depends on frame layout)
 485   Arena*                _indexSet_arena;        // control IndexSet allocation within PhaseChaitin
 486   void*                 _indexSet_free_block_list; // free list of IndexSet bit blocks


src/share/vm/opto/compile.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File