413       : _cg(NULL) { _ss = new stringStream(); }
 414 
 415     stringStream* ss() const { return _ss; }
 416     CallGenerator* cg() const { return _cg; }
 417     void set_cg(CallGenerator* cg) { _cg = cg; }
 418   };
 419 
 420   stringStream* _print_inlining_stream;
 421   GrowableArray<PrintInliningBuffer>* _print_inlining_list;
 422   int _print_inlining_idx;
 423 
 424   // Only keep nodes in the expensive node list that need to be optimized
 425   void cleanup_expensive_nodes(PhaseIterGVN &igvn);
 426   // Use for sorting expensive nodes to bring similar nodes together
 427   static int cmp_expensive_nodes(Node** n1, Node** n2);
 428   // Expensive nodes list already sorted?
 429   bool expensive_nodes_sorted() const;
 430   // Remove the speculative part of types and clean up the graph
 431   void remove_speculative_types(PhaseIterGVN &igvn);
 432 
 433   // Are we within a PreserveJVMState block?
 434   int _preserve_jvm_state;
 435 
 436   void* _replay_inline_data; // Pointer to data loaded from file
 437 
 438   void print_inlining_init();
 439   void print_inlining_reinit();
 440   void print_inlining_commit();
 441   void print_inlining_push();
 442   PrintInliningBuffer& print_inlining_current();
 443 
 444   void log_late_inline_failure(CallGenerator* cg, const char* msg);
 445 
 446  public:
 447 
 448   outputStream* print_inlining_stream() const {
 449     assert(print_inlining() || print_intrinsics(), "PrintInlining off?");
 450     return _print_inlining_stream;
 451   }
 452 
 453   void print_inlining_update(CallGenerator* cg);
 454   void print_inlining_update_delayed(CallGenerator* cg);
 455   void print_inlining_move_to(CallGenerator* cg);

1179   void verify_graph_edges(bool no_dead_code = false) PRODUCT_RETURN;
1180 
1181   // Verify GC barrier patterns
1182   void verify_barriers() PRODUCT_RETURN;
1183 
1184   // End-of-run dumps.
1185   static void print_statistics() PRODUCT_RETURN;
1186 
1187   // Dump formatted assembly
1188   void dump_asm(int *pcs = NULL, uint pc_limit = 0) PRODUCT_RETURN;
1189   void dump_pc(int *pcs, int pc_limit, Node *n);
1190 
1191   // Verify ADLC assumptions during startup
1192   static void adlc_verification() PRODUCT_RETURN;
1193 
1194   // Definitions of pd methods
1195   static void pd_compiler2_init();
1196 
1197   // Auxiliary method for randomized fuzzing/stressing
1198   static bool randomized_select(int count);
1199 
1200   // enter a PreserveJVMState block
1201   void inc_preserve_jvm_state() {
1202     _preserve_jvm_state++;
1203   }
1204 
1205   // exit a PreserveJVMState block
1206   void dec_preserve_jvm_state() {
1207     _preserve_jvm_state--;
1208     assert(_preserve_jvm_state >= 0, "_preserve_jvm_state shouldn't be negative");
1209   }
1210 
1211   bool has_preserve_jvm_state() const {
1212     return _preserve_jvm_state > 0;
1213   }
1214 };
1215 
1216 #endif // SHARE_VM_OPTO_COMPILE_HPP

 413       : _cg(NULL) { _ss = new stringStream(); }
 414 
 415     stringStream* ss() const { return _ss; }
 416     CallGenerator* cg() const { return _cg; }
 417     void set_cg(CallGenerator* cg) { _cg = cg; }
 418   };
 419 
 420   stringStream* _print_inlining_stream;
 421   GrowableArray<PrintInliningBuffer>* _print_inlining_list;
 422   int _print_inlining_idx;
 423 
 424   // Only keep nodes in the expensive node list that need to be optimized
 425   void cleanup_expensive_nodes(PhaseIterGVN &igvn);
 426   // Use for sorting expensive nodes to bring similar nodes together
 427   static int cmp_expensive_nodes(Node** n1, Node** n2);
 428   // Expensive nodes list already sorted?
 429   bool expensive_nodes_sorted() const;
 430   // Remove the speculative part of types and clean up the graph
 431   void remove_speculative_types(PhaseIterGVN &igvn);
 432 



 433   void* _replay_inline_data; // Pointer to data loaded from file
 434 
 435   void print_inlining_init();
 436   void print_inlining_reinit();
 437   void print_inlining_commit();
 438   void print_inlining_push();
 439   PrintInliningBuffer& print_inlining_current();
 440 
 441   void log_late_inline_failure(CallGenerator* cg, const char* msg);
 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);

1176   void verify_graph_edges(bool no_dead_code = false) PRODUCT_RETURN;
1177 
1178   // Verify GC barrier patterns
1179   void verify_barriers() PRODUCT_RETURN;
1180 
1181   // End-of-run dumps.
1182   static void print_statistics() PRODUCT_RETURN;
1183 
1184   // Dump formatted assembly
1185   void dump_asm(int *pcs = NULL, uint pc_limit = 0) PRODUCT_RETURN;
1186   void dump_pc(int *pcs, int pc_limit, Node *n);
1187 
1188   // Verify ADLC assumptions during startup
1189   static void adlc_verification() PRODUCT_RETURN;
1190 
1191   // Definitions of pd methods
1192   static void pd_compiler2_init();
1193 
1194   // Auxiliary method for randomized fuzzing/stressing
1195   static bool randomized_select(int count);















1196 };
1197 
1198 #endif // SHARE_VM_OPTO_COMPILE_HPP