diff --git a/src/hotspot/share/opto/c2_globals.hpp b/src/hotspot/share/opto/c2_globals.hpp index 9a398e0dbb5..dc629de1bdf 100644 --- a/src/hotspot/share/opto/c2_globals.hpp +++ b/src/hotspot/share/opto/c2_globals.hpp @@ -365,10 +365,10 @@ "Level of detail of the ideal graph printout. " \ "System-wide value, -1=printing is disabled, " \ "0=print nothing except IGVPrintLevel directives, " \ - "5=all details printed. " \ + "6=all details printed. " \ "Level of detail of printouts can be set on a per-method level " \ "as well by using CompileCommand=option.") \ - range(-1, 5) \ + range(-1, 6) \ \ notproduct(intx, PrintIdealGraphPort, 4444, \ "Ideal graph printer to network port") \ diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp index 8a5e98eda92..3e81ed7014b 100644 --- a/src/hotspot/share/opto/compile.cpp +++ b/src/hotspot/share/opto/compile.cpp @@ -1041,6 +1041,10 @@ void Compile::Init(bool aliasing) { Copy::zero_to_bytes(_trap_hist, sizeof(_trap_hist)); set_decompile_count(0); +#ifndef PRODUCT + Copy::zero_to_bytes(_igv_phase_iter, sizeof(_igv_phase_iter)); +#endif + set_do_freq_based_layout(_directive->BlockLayoutByFrequencyOption); _loop_opts_cnt = LoopOptsCount; set_do_inlining(Inline); @@ -2397,6 +2401,7 @@ void Compile::Optimize() { if (failing()) return; // Conditional Constant Propagation; + print_method(PHASE_BEFORE_CCP1, 2); PhaseCCP ccp( &igvn ); assert( true, "Break here to ccp.dump_nodes_and_types(_root,999,1)"); { @@ -2972,6 +2977,8 @@ void Compile::Code_Gen() { if (failing()) { return; } + + print_method(PHASE_REGISTER_ALLOCATION, 2); } // Prior to register allocation we kept empty basic blocks in case the @@ -2989,6 +2996,7 @@ void Compile::Code_Gen() { cfg.fixup_flow(); cfg.remove_unreachable_blocks(); cfg.verify_dominator_tree(); + print_method(PHASE_BLOCK_ORDERING, 3); } // Apply peephole optimizations @@ -2996,12 +3004,14 @@ void Compile::Code_Gen() { TracePhase tp("peephole", &timers[_t_peephole]); PhasePeephole peep( _regalloc, cfg); peep.do_transform(); + print_method(PHASE_PEEPHOLE, 3); } // Do late expand if CPU requires this. if (Matcher::require_postalloc_expand) { TracePhase tp("postalloc_expand", &timers[_t_postalloc_expand]); cfg.postalloc_expand(_regalloc); + print_method(PHASE_POSTALLOC_EXPAND, 3); } // Convert Nodes to instruction bits in a buffer @@ -5102,6 +5112,10 @@ void Compile::print_method(CompilerPhaseType cpt, int level, Node* n) { ResourceMark rm; stringStream ss; ss.print_raw(CompilerPhaseTypeHelper::to_description(cpt)); + int iter = ++_igv_phase_iter[cpt]; + if (iter > 1) { + ss.print(" %d", iter); + } if (n != nullptr) { ss.print(": %d %s ", n->_idx, NodeClassNames[n->Opcode()]); } diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp index af4eb6b1ee0..01d0d727aa7 100644 --- a/src/hotspot/share/opto/compile.hpp +++ b/src/hotspot/share/opto/compile.hpp @@ -343,6 +343,7 @@ class Compile : public Phase { bool _print_intrinsics; // True if we should print intrinsics for this compilation #ifndef PRODUCT uint _igv_idx; // Counter for IGV node identifiers + uint _igv_phase_iter[PHASE_NUM_TYPES]; // Counters for IGV phase iterations bool _trace_opto_output; bool _parsed_irreducible_loop; // True if ciTypeFlow detected irreducible loops during parsing #endif @@ -531,6 +532,7 @@ private: #ifndef PRODUCT IdealGraphPrinter* igv_printer() { return _igv_printer; } + void reset_igv_phase_iter(CompilerPhaseType cpt) { _igv_phase_iter[cpt] = 0; } #endif void log_late_inline(CallGenerator* cg); diff --git a/src/hotspot/share/opto/loopPredicate.cpp b/src/hotspot/share/opto/loopPredicate.cpp index d569bfcfab5..e4f6345c679 100644 --- a/src/hotspot/share/opto/loopPredicate.cpp +++ b/src/hotspot/share/opto/loopPredicate.cpp @@ -1180,6 +1180,7 @@ bool PhaseIdealLoop::loop_predication_impl_helper(IdealLoopTree* loop, IfProjNod } BoolNode* bol = test->as_Bool(); if (invar.is_invariant(bol)) { + C->print_method(PHASE_BEFORE_LOOP_PREDICATION_IC, 4, iff); // Invariant test new_predicate_proj = create_new_if_for_predicate(parse_predicate_proj, nullptr, reason, @@ -1197,6 +1198,9 @@ bool PhaseIdealLoop::loop_predication_impl_helper(IdealLoopTree* loop, IfProjNod IfNode* new_predicate_iff = new_predicate_proj->in(0)->as_If(); _igvn.hash_delete(new_predicate_iff); new_predicate_iff->set_req(1, new_predicate_bol); + + C->print_method(PHASE_AFTER_LOOP_PREDICATION_IC, 4, new_predicate_proj->in(0)); + #ifndef PRODUCT if (TraceLoopPredicate) { tty->print("Predicate invariant if%s: %d ", negated ? " negated" : "", new_predicate_iff->_idx); @@ -1207,6 +1211,7 @@ bool PhaseIdealLoop::loop_predication_impl_helper(IdealLoopTree* loop, IfProjNod } #endif } else if (cl != nullptr && loop->is_range_check_if(if_success_proj, this, invar DEBUG_ONLY(COMMA parse_predicate_proj))) { + C->print_method(PHASE_BEFORE_LOOP_PREDICATION_RC, 4, iff); // Range check for counted loops assert(if_success_proj->is_IfTrue(), "trap must be on false projection for a range check"); const Node* cmp = bol->in(1)->as_Cmp(); @@ -1270,6 +1275,8 @@ bool PhaseIdealLoop::loop_predication_impl_helper(IdealLoopTree* loop, IfProjNod new_predicate_proj = add_template_assertion_predicate(iff, loop, if_success_proj, parse_predicate_proj, upper_bound_proj, scale, offset, init, limit, stride, rng, overflow, reason); + C->print_method(PHASE_AFTER_LOOP_PREDICATION_RC, 4, new_predicate_proj->in(0)); + #ifndef PRODUCT if (TraceLoopOpts && !TraceLoopPredicate) { tty->print("Predicate RC "); diff --git a/src/hotspot/share/opto/loopTransform.cpp b/src/hotspot/share/opto/loopTransform.cpp index 22386b144c2..3c323d7a2dc 100644 --- a/src/hotspot/share/opto/loopTransform.cpp +++ b/src/hotspot/share/opto/loopTransform.cpp @@ -703,6 +703,9 @@ void PhaseIdealLoop::do_peeling(IdealLoopTree *loop, Node_List &old_new) { } #endif LoopNode* head = loop->_head->as_Loop(); + + C->print_method(PHASE_BEFORE_LOOP_PEELING, 4, head); + bool counted_loop = head->is_CountedLoop(); if (counted_loop) { CountedLoopNode *cl = head->as_CountedLoop(); @@ -795,6 +798,8 @@ void PhaseIdealLoop::do_peeling(IdealLoopTree *loop, Node_List &old_new) { peeled_dom_test_elim(loop,old_new); loop->record_for_igvn(); + + C->print_method(PHASE_AFTER_LOOP_PEELING, 4, new_head); } //------------------------------policy_maximally_unroll------------------------ @@ -1629,6 +1634,8 @@ void PhaseIdealLoop::insert_pre_post_loops(IdealLoopTree *loop, Node_List &old_n CountedLoopEndNode *main_end = main_head->loopexit(); assert(main_end->outcnt() == 2, "1 true, 1 false path only"); + C->print_method(PHASE_BEFORE_PRE_MAIN_POST, 4, main_head); + Node *pre_header= main_head->in(LoopNode::EntryControl); Node *init = main_head->init_trip(); Node *incr = main_end ->incr(); @@ -1825,6 +1832,8 @@ void PhaseIdealLoop::insert_pre_post_loops(IdealLoopTree *loop, Node_List &old_n // finds some, but we _know_ they are all useless. peeled_dom_test_elim(loop,old_new); loop->record_for_igvn(); + + C->print_method(PHASE_AFTER_PRE_MAIN_POST, 4, main_head); } //------------------------------insert_vector_post_loop------------------------ @@ -2127,6 +2136,9 @@ void PhaseIdealLoop::do_unroll(IdealLoopTree *loop, Node_List &old_new, bool adj assert(LoopUnrollLimit, ""); CountedLoopNode *loop_head = loop->_head->as_CountedLoop(); CountedLoopEndNode *loop_end = loop_head->loopexit(); + + C->print_method(PHASE_BEFORE_LOOP_UNROLLING, 4, loop_head); + #ifndef PRODUCT if (PrintOpto && VerifyLoopOptimizations) { tty->print("Unrolling "); @@ -2374,6 +2386,8 @@ void PhaseIdealLoop::do_unroll(IdealLoopTree *loop, Node_List &old_new, bool adj } } #endif + + C->print_method(PHASE_AFTER_LOOP_UNROLLING, 4, clone_head); } //------------------------------do_maximally_unroll---------------------------- @@ -3003,6 +3017,8 @@ void PhaseIdealLoop::do_range_check(IdealLoopTree *loop, Node_List &old_new) { // stride_con and scale_con can be negative which will flip about the // sense of the test. + C->print_method(PHASE_BEFORE_RANGE_CHECK_ELIMINATION, 4, iff); + // Perform the limit computations in jlong to avoid overflow jlong lscale_con = scale_con; Node* int_offset = offset; @@ -3103,6 +3119,9 @@ void PhaseIdealLoop::do_range_check(IdealLoopTree *loop, Node_List &old_new) { --imax; } } + + C->print_method(PHASE_AFTER_RANGE_CHECK_ELIMINATION, 4, cl); + } // End of is IF } if (loop_entry != cl->skip_strip_mined()->in(LoopNode::EntryControl)) { diff --git a/src/hotspot/share/opto/loopUnswitch.cpp b/src/hotspot/share/opto/loopUnswitch.cpp index 98725cb5fe6..87c71bf16ff 100644 --- a/src/hotspot/share/opto/loopUnswitch.cpp +++ b/src/hotspot/share/opto/loopUnswitch.cpp @@ -134,6 +134,8 @@ void PhaseIdealLoop::do_unswitching(IdealLoopTree *loop, Node_List &old_new) { } #endif + C->print_method(PHASE_BEFORE_LOOP_UNSWITCHING, 4, head); + // Need to revert back to normal loop if (head->is_CountedLoop() && !head->as_CountedLoop()->is_normal_loop()) { head->as_CountedLoop()->set_normal_loop(); @@ -200,6 +202,8 @@ void PhaseIdealLoop::do_unswitching(IdealLoopTree *loop, Node_List &old_new) { } #endif + C->print_method(PHASE_AFTER_LOOP_UNSWITCHING, 4, head_clone); + C->set_major_progress(); } diff --git a/src/hotspot/share/opto/loopopts.cpp b/src/hotspot/share/opto/loopopts.cpp index ea1bdc933d0..aec1640e025 100644 --- a/src/hotspot/share/opto/loopopts.cpp +++ b/src/hotspot/share/opto/loopopts.cpp @@ -1446,7 +1446,12 @@ void PhaseIdealLoop::split_if_with_blocks_post(Node *n) { } // Now split the IF + C->print_method(PHASE_BEFORE_SPLIT_IF, 4, iff); + if ((PrintOpto && VerifyLoopOptimizations) || TraceLoopOpts) { + tty->print_cr("Split-If"); + } do_split_if(iff); + C->print_method(PHASE_AFTER_SPLIT_IF, 4, iff); return; } @@ -3625,6 +3630,9 @@ bool PhaseIdealLoop::partial_peel( IdealLoopTree *loop, Node_List &old_new ) { } } #endif + + C->print_method(PHASE_BEFORE_PARTIAL_PEELING, 4, head); + VectorSet peel; VectorSet not_peel; Node_List peel_list; @@ -3919,6 +3927,9 @@ bool PhaseIdealLoop::partial_peel( IdealLoopTree *loop, Node_List &old_new ) { } } #endif + + C->print_method(PHASE_AFTER_PARTIAL_PEELING, 4, new_head_clone); + return true; } diff --git a/src/hotspot/share/opto/parse2.cpp b/src/hotspot/share/opto/parse2.cpp index 24fecff3734..1528615987b 100644 --- a/src/hotspot/share/opto/parse2.cpp +++ b/src/hotspot/share/opto/parse2.cpp @@ -2779,7 +2779,7 @@ void Parse::do_one_bytecode() { } #ifndef PRODUCT - constexpr int perBytecode = 5; + constexpr int perBytecode = 6; if (C->should_print_igv(perBytecode)) { IdealGraphPrinter* printer = C->igv_printer(); char buffer[256]; diff --git a/src/hotspot/share/opto/phaseX.cpp b/src/hotspot/share/opto/phaseX.cpp index 88e4a8d6695..866fd1b9352 100644 --- a/src/hotspot/share/opto/phaseX.cpp +++ b/src/hotspot/share/opto/phaseX.cpp @@ -894,7 +894,7 @@ void PhaseIterGVN::verify_step(Node* n) { void PhaseIterGVN::trace_PhaseIterGVN(Node* n, Node* nn, const Type* oldtype) { const Type* newtype = type_or_null(n); if (nn != n || oldtype != newtype) { - C->print_method(PHASE_AFTER_ITER_GVN_STEP, 4, n); + C->print_method(PHASE_AFTER_ITER_GVN_STEP, 5, n); } if (TraceIterativeGVN) { uint wlsize = _worklist.size(); @@ -1025,6 +1025,7 @@ void PhaseIterGVN::trace_PhaseIterGVN_verbose(Node* n, int num_processed) { void PhaseIterGVN::optimize() { DEBUG_ONLY(uint num_processed = 0;) NOT_PRODUCT(init_verifyPhaseIterGVN();) + NOT_PRODUCT(C->reset_igv_phase_iter(PHASE_AFTER_ITER_GVN_STEP);) C->print_method(PHASE_BEFORE_ITER_GVN, 3); if (StressIGVN) { shuffle_worklist(); diff --git a/src/hotspot/share/opto/phasetype.hpp b/src/hotspot/share/opto/phasetype.hpp index c21f2b50418..43a6491fee5 100644 --- a/src/hotspot/share/opto/phasetype.hpp +++ b/src/hotspot/share/opto/phasetype.hpp @@ -28,51 +28,77 @@ #include "utilities/bitMap.inline.hpp" #define COMPILER_PHASES(flags) \ - flags(BEFORE_STRINGOPTS, "Before StringOpts") \ - flags(AFTER_STRINGOPTS, "After StringOpts") \ - flags(BEFORE_REMOVEUSELESS, "Before RemoveUseless") \ - flags(AFTER_PARSING, "After Parsing") \ - flags(BEFORE_ITER_GVN, "Before Iter GVN") \ - flags(ITER_GVN1, "Iter GVN 1") \ - flags(AFTER_ITER_GVN_STEP, "After Iter GVN Step") \ - flags(AFTER_ITER_GVN, "After Iter GVN") \ - flags(INCREMENTAL_INLINE_STEP, "Incremental Inline Step") \ - flags(INCREMENTAL_INLINE_CLEANUP, "Incremental Inline Cleanup") \ - flags(INCREMENTAL_INLINE, "Incremental Inline") \ - flags(INCREMENTAL_BOXING_INLINE, "Incremental Boxing Inline") \ - flags(EXPAND_VUNBOX, "Expand VectorUnbox") \ - flags(SCALARIZE_VBOX, "Scalarize VectorBox") \ - flags(INLINE_VECTOR_REBOX, "Inline Vector Rebox Calls") \ - flags(EXPAND_VBOX, "Expand VectorBox") \ - flags(ELIMINATE_VBOX_ALLOC, "Eliminate VectorBoxAllocate") \ - flags(ITER_GVN_BEFORE_EA, "Iter GVN before EA") \ - flags(ITER_GVN_AFTER_VECTOR, "Iter GVN after vector box elimination") \ - flags(BEFORE_BEAUTIFY_LOOPS, "Before beautify loops") \ - flags(AFTER_BEAUTIFY_LOOPS, "After beautify loops") \ - flags(BEFORE_CLOOPS, "Before CountedLoop") \ - flags(AFTER_CLOOPS, "After CountedLoop") \ - flags(PHASEIDEAL_BEFORE_EA, "PhaseIdealLoop before EA") \ - flags(AFTER_EA, "After Escape Analysis") \ - flags(ITER_GVN_AFTER_EA, "Iter GVN after EA") \ - flags(ITER_GVN_AFTER_ELIMINATION, "Iter GVN after eliminating allocations and locks") \ - flags(PHASEIDEALLOOP1, "PhaseIdealLoop 1") \ - flags(PHASEIDEALLOOP2, "PhaseIdealLoop 2") \ - flags(PHASEIDEALLOOP3, "PhaseIdealLoop 3") \ - flags(CCP1, "PhaseCCP 1") \ - flags(ITER_GVN2, "Iter GVN 2") \ - flags(PHASEIDEALLOOP_ITERATIONS, "PhaseIdealLoop iterations") \ - flags(MACRO_EXPANSION, "Macro expand") \ - flags(BARRIER_EXPANSION, "Barrier expand") \ - flags(OPTIMIZE_FINISHED, "Optimize finished") \ - flags(BEFORE_MATCHING, "Before matching") \ - flags(MATCHING, "After matching") \ - flags(GLOBAL_CODE_MOTION, "Global code motion") \ - flags(MACH_ANALYSIS, "After mach analysis") \ - flags(FINAL_CODE, "Final Code") \ - flags(END, "End") \ - flags(FAILURE, "Failure") \ - flags(ALL, "All") \ - flags(DEBUG, "Debug") + flags(BEFORE_STRINGOPTS, "Before StringOpts") \ + flags(AFTER_STRINGOPTS, "After StringOpts") \ + flags(BEFORE_REMOVEUSELESS, "Before RemoveUseless") \ + flags(AFTER_PARSING, "After Parsing") \ + flags(BEFORE_ITER_GVN, "Before Iter GVN") \ + flags(ITER_GVN1, "Iter GVN 1") \ + flags(AFTER_ITER_GVN_STEP, "After Iter GVN Step") \ + flags(AFTER_ITER_GVN, "After Iter GVN") \ + flags(INCREMENTAL_INLINE_STEP, "Incremental Inline Step") \ + flags(INCREMENTAL_INLINE_CLEANUP, "Incremental Inline Cleanup") \ + flags(INCREMENTAL_INLINE, "Incremental Inline") \ + flags(INCREMENTAL_BOXING_INLINE, "Incremental Boxing Inline") \ + flags(EXPAND_VUNBOX, "Expand VectorUnbox") \ + flags(SCALARIZE_VBOX, "Scalarize VectorBox") \ + flags(INLINE_VECTOR_REBOX, "Inline Vector Rebox Calls") \ + flags(EXPAND_VBOX, "Expand VectorBox") \ + flags(ELIMINATE_VBOX_ALLOC, "Eliminate VectorBoxAllocate") \ + flags(ITER_GVN_BEFORE_EA, "Iter GVN before EA") \ + flags(ITER_GVN_AFTER_VECTOR, "Iter GVN after vector box elimination") \ + flags(BEFORE_BEAUTIFY_LOOPS, "Before beautify loops") \ + flags(AFTER_BEAUTIFY_LOOPS, "After beautify loops") \ + flags(BEFORE_LOOP_UNROLLING, "Before Loop Unrolling") \ + flags(AFTER_LOOP_UNROLLING, "After Loop Unrolling") \ + flags(BEFORE_SPLIT_IF, "Before Split-If") \ + flags(AFTER_SPLIT_IF, "After Split-If") \ + flags(BEFORE_LOOP_PREDICATION_IC, "Before Loop Predication IC") \ + flags(AFTER_LOOP_PREDICATION_IC, "After Loop Predication IC") \ + flags(BEFORE_LOOP_PREDICATION_RC, "Before Loop Predication RC") \ + flags(AFTER_LOOP_PREDICATION_RC, "After Loop Predication RC") \ + flags(BEFORE_PARTIAL_PEELING, "Before Partial Peeling") \ + flags(AFTER_PARTIAL_PEELING, "After Partial Peeling") \ + flags(BEFORE_LOOP_PEELING, "Before Loop Peeling") \ + flags(AFTER_LOOP_PEELING, "After Loop Peeling") \ + flags(BEFORE_LOOP_UNSWITCHING, "Before Loop Unswitching") \ + flags(AFTER_LOOP_UNSWITCHING, "After Loop Unswitching") \ + flags(BEFORE_RANGE_CHECK_ELIMINATION, "Before Range Check Elimination") \ + flags(AFTER_RANGE_CHECK_ELIMINATION, "After Range Check Elimination") \ + flags(BEFORE_PRE_MAIN_POST, "Before Pre/Main/Post Loops") \ + flags(AFTER_PRE_MAIN_POST, "After Pre/Main/Post Loops") \ + flags(SUPERWORD1_BEFORE_SCHEDULE, "Superword 1, Before Schedule") \ + flags(SUPERWORD2_BEFORE_OUTPUT, "Superword 2, Before Output") \ + flags(SUPERWORD3_AFTER_OUTPUT, "Superword 3, After Output") \ + flags(BEFORE_CLOOPS, "Before CountedLoop") \ + flags(AFTER_CLOOPS, "After CountedLoop") \ + flags(PHASEIDEAL_BEFORE_EA, "PhaseIdealLoop before EA") \ + flags(AFTER_EA, "After Escape Analysis") \ + flags(ITER_GVN_AFTER_EA, "Iter GVN after EA") \ + flags(ITER_GVN_AFTER_ELIMINATION, "Iter GVN after eliminating allocations and locks") \ + flags(PHASEIDEALLOOP1, "PhaseIdealLoop 1") \ + flags(PHASEIDEALLOOP2, "PhaseIdealLoop 2") \ + flags(PHASEIDEALLOOP3, "PhaseIdealLoop 3") \ + flags(BEFORE_CCP1, "Before PhaseCCP 1") \ + flags(CCP1, "PhaseCCP 1") \ + flags(ITER_GVN2, "Iter GVN 2") \ + flags(PHASEIDEALLOOP_ITERATIONS, "PhaseIdealLoop iterations") \ + flags(MACRO_EXPANSION, "Macro expand") \ + flags(BARRIER_EXPANSION, "Barrier expand") \ + flags(OPTIMIZE_FINISHED, "Optimize finished") \ + flags(BEFORE_MATCHING, "Before matching") \ + flags(MATCHING, "After matching") \ + flags(GLOBAL_CODE_MOTION, "Global code motion") \ + flags(REGISTER_ALLOCATION, "Register Allocation") \ + flags(BLOCK_ORDERING, "Block Ordering") \ + flags(PEEPHOLE, "Peephole") \ + flags(POSTALLOC_EXPAND, "Post-Allocation Expand") \ + flags(MACH_ANALYSIS, "After mach analysis") \ + flags(FINAL_CODE, "Final Code") \ + flags(END, "End") \ + flags(FAILURE, "Failure") \ + flags(ALL, "All") \ + flags(DEBUG, "Debug") #define table_entry(name, description) PHASE_##name, enum CompilerPhaseType { diff --git a/src/hotspot/share/opto/split_if.cpp b/src/hotspot/share/opto/split_if.cpp index 5b6462307bb..655434c4f4b 100644 --- a/src/hotspot/share/opto/split_if.cpp +++ b/src/hotspot/share/opto/split_if.cpp @@ -591,12 +591,6 @@ void PhaseIdealLoop::handle_use( Node *use, Node *def, small_cache *cache, Node // Found an If getting its condition-code input from a Phi in the same block. // Split thru the Region. void PhaseIdealLoop::do_split_if(Node* iff, RegionNode** new_false_region, RegionNode** new_true_region) { - if (PrintOpto && VerifyLoopOptimizations) { - tty->print_cr("Split-if"); - } - if (TraceLoopOpts) { - tty->print_cr("SplitIf"); - } C->set_major_progress(); RegionNode *region = iff->in(0)->as_Region(); diff --git a/src/hotspot/share/opto/superword.cpp b/src/hotspot/share/opto/superword.cpp index dd3f1d10dee..c3f0a60af20 100644 --- a/src/hotspot/share/opto/superword.cpp +++ b/src/hotspot/share/opto/superword.cpp @@ -2381,6 +2381,9 @@ void SuperWord::schedule() { } #endif + CountedLoopNode* cl = lpt()->_head->as_CountedLoop(); + _phase->C->print_method(PHASE_SUPERWORD1_BEFORE_SCHEDULE, 4, cl); + // (4) Use the memops_schedule to re-order the memops in all slices. schedule_reorder_memops(memops_schedule); } @@ -2488,6 +2491,7 @@ bool SuperWord::output() { lpt()->dump_head(); } #endif + _phase->C->print_method(PHASE_SUPERWORD2_BEFORE_OUTPUT, 4, cl); // Ensure main loop's initial value is properly aligned // (iv_initial_value + min_iv_offset) % vector_width_in_bytes() == 0 @@ -2808,6 +2812,8 @@ bool SuperWord::output() { } } + _phase->C->print_method(PHASE_SUPERWORD3_AFTER_OUTPUT, 4, cl); + return true; } diff --git a/src/utils/IdealGraphVisualizer/README.md b/src/utils/IdealGraphVisualizer/README.md index f930ea604a4..83c9ee5889b 100644 --- a/src/utils/IdealGraphVisualizer/README.md +++ b/src/utils/IdealGraphVisualizer/README.md @@ -28,10 +28,11 @@ Ideal graphs are dumped at the following points: * `N=0`: no output (default) * `N=1`: after parsing, before matching, and final code (also for failed compilations, if available) -* `N=2`: additionally, after every major phase (including loop opts) +* `N=2`: additionally, after every major phase * `N=3`: additionally, after every minor phase -* `N=4`: additionally, after every effective IGVN step (slow) -* `N=5`: additionally, after parsing every bytecode (very slow) +* `N=4`: additionally, after every loop optimization +* `N=5`: additionally, after every effective IGVN step (slow) +* `N=6`: additionally, after parsing every bytecode (very slow) By default the JVM expects that it will connect to a visualizer on the local host on port 4444. This can be configured using the options diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java b/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java index 6f5149a79ba..26a271949e7 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/CompilePhase.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -60,6 +60,27 @@ public enum CompilePhase { ITER_GVN_AFTER_VECTOR("Iter GVN after vector box elimination"), BEFORE_BEAUTIFY_LOOPS("Before beautify loops"), AFTER_BEAUTIFY_LOOPS("After beautify loops"), + BEFORE_LOOP_UNROLLING("Before Loop Unrolling"), + AFTER_LOOP_UNROLLING("After Loop Unrolling"), + BEFORE_SPLIT_IF("Before Split-If"), + AFTER_SPLIT_IF("After Split-If"), + BEFORE_LOOP_PREDICATION_IC("Before Loop Predication IC"), + AFTER_LOOP_PREDICATION_IC("After Loop Predication IC"), + BEFORE_LOOP_PREDICATION_RC("Before Loop Predication RC"), + AFTER_LOOP_PREDICATION_RC("After Loop Predication RC"), + BEFORE_PARTIAL_PEELING("Before Partial Peeling"), + AFTER_PARTIAL_PEELING("After Partial Peeling"), + BEFORE_LOOP_PEELING("Before Loop Peeling"), + AFTER_LOOP_PEELING("After Loop Peeling"), + BEFORE_LOOP_UNSWITCHING("Before Loop Unswitching"), + AFTER_LOOP_UNSWITCHING("After Loop Unswitching"), + BEFORE_RANGE_CHECK_ELIMINATION("Before Range Check Elimination"), + AFTER_RANGE_CHECK_ELIMINATION("After Range Check Elimination"), + BEFORE_PRE_MAIN_POST("Before Pre/Main/Post Loops"), + AFTER_PRE_MAIN_POST("After Pre/Main/Post Loops"), + SUPERWORD1_BEFORE_SCHEDULE("Superword 1, Before Schedule"), + SUPERWORD2_BEFORE_OUTPUT("Superword 2, Before Output"), + SUPERWORD3_AFTER_OUTPUT("Superword 3, After Output"), // Match on very first BEFORE_CLOOPS phase (there could be multiple phases for multiple loops in the code). BEFORE_CLOOPS("Before CountedLoop", RegexType.IDEAL_INDEPENDENT, ActionOnRepeat.KEEP_FIRST), AFTER_CLOOPS("After CountedLoop"), @@ -70,6 +91,7 @@ public enum CompilePhase { PHASEIDEALLOOP1("PhaseIdealLoop 1"), PHASEIDEALLOOP2("PhaseIdealLoop 2"), PHASEIDEALLOOP3("PhaseIdealLoop 3"), + BEFORE_CCP1("Before PhaseCCP 1"), CCP1("PhaseCCP 1"), ITER_GVN2("Iter GVN 2"), PHASEIDEALLOOP_ITERATIONS("PhaseIdealLoop iterations"), @@ -79,8 +101,12 @@ public enum CompilePhase { PRINT_IDEAL("PrintIdeal"), BEFORE_MATCHING("Before matching"), MATCHING("After matching", RegexType.MACH), - MACH_ANALYSIS("After mach analysis", RegexType.MACH), GLOBAL_CODE_MOTION("Global code motion", RegexType.MACH), + REGISTER_ALLOCATION("Register Allocation", RegexType.MACH), + BLOCK_ORDERING("Block Ordering", RegexType.MACH), + PEEPHOLE("Peephole", RegexType.MACH), + POSTALLOC_EXPAND("Post-Allocation Expand", RegexType.MACH), + MACH_ANALYSIS("After mach analysis", RegexType.MACH), FINAL_CODE("Final Code", RegexType.MACH), END("End"), diff --git a/test/jdk/jdk/jfr/event/compiler/TestCompilerPhase.java b/test/jdk/jdk/jfr/event/compiler/TestCompilerPhase.java index 0df2b5802cf..9c571a514e6 100644 --- a/test/jdk/jdk/jfr/event/compiler/TestCompilerPhase.java +++ b/test/jdk/jdk/jfr/event/compiler/TestCompilerPhase.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -78,7 +78,7 @@ public class TestCompilerPhase { System.out.println("Event:" + event); Events.assertField(event, "phase").notEmpty(); Events.assertField(event, "compileId").atLeast(0); - Events.assertField(event, "phaseLevel").atLeast((short)0).atMost((short)4); + Events.assertField(event, "phaseLevel").atLeast((short)0).atMost((short)5); Events.assertEventThread(event); } }