< prev index next >

src/hotspot/share/opto/phasetype.hpp

Print this page




  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_OPTO_PHASETYPE_HPP
  26 #define SHARE_OPTO_PHASETYPE_HPP
  27 
  28 enum CompilerPhaseType {
  29   PHASE_BEFORE_STRINGOPTS,
  30   PHASE_AFTER_STRINGOPTS,
  31   PHASE_BEFORE_REMOVEUSELESS,
  32   PHASE_AFTER_PARSING,
  33   PHASE_ITER_GVN1,





  34   PHASE_PHASEIDEAL_BEFORE_EA,


  35   PHASE_ITER_GVN_AFTER_EA,
  36   PHASE_ITER_GVN_AFTER_ELIMINATION,
  37   PHASE_PHASEIDEALLOOP1,
  38   PHASE_PHASEIDEALLOOP2,
  39   PHASE_PHASEIDEALLOOP3,
  40   PHASE_CPP1,
  41   PHASE_ITER_GVN2,
  42   PHASE_PHASEIDEALLOOP_ITERATIONS,
  43   PHASE_OPTIMIZE_FINISHED,

  44   PHASE_GLOBAL_CODE_MOTION,
  45   PHASE_FINAL_CODE,
  46   PHASE_AFTER_EA,
  47   PHASE_BEFORE_CLOOPS,
  48   PHASE_AFTER_CLOOPS,
  49   PHASE_BEFORE_BEAUTIFY_LOOPS,
  50   PHASE_AFTER_BEAUTIFY_LOOPS,
  51   PHASE_BEFORE_MATCHING,
  52   PHASE_MATCHING,
  53   PHASE_INCREMENTAL_INLINE,

  54   PHASE_INCREMENTAL_BOXING_INLINE,
  55   PHASE_CALL_CATCH_CLEANUP,
  56   PHASE_INSERT_BARRIER,
  57   PHASE_MACRO_EXPANSION,
  58   PHASE_BARRIER_EXPANSION,
  59   PHASE_ADD_UNSAFE_BARRIER,
  60   PHASE_END,
  61   PHASE_FAILURE,
  62   PHASE_DEBUG,
  63 
  64   PHASE_NUM_TYPES
  65 };
  66 
  67 class CompilerPhaseTypeHelper {
  68   public:
  69   static const char* to_string(CompilerPhaseType cpt) {
  70     switch (cpt) {
  71       case PHASE_BEFORE_STRINGOPTS:          return "Before StringOpts";
  72       case PHASE_AFTER_STRINGOPTS:           return "After StringOpts";
  73       case PHASE_BEFORE_REMOVEUSELESS:       return "Before RemoveUseless";
  74       case PHASE_AFTER_PARSING:              return "After Parsing";
  75       case PHASE_ITER_GVN1:                  return "Iter GVN 1";





  76       case PHASE_PHASEIDEAL_BEFORE_EA:       return "PhaseIdealLoop before EA";


  77       case PHASE_ITER_GVN_AFTER_EA:          return "Iter GVN after EA";
  78       case PHASE_ITER_GVN_AFTER_ELIMINATION: return "Iter GVN after eliminating allocations and locks";
  79       case PHASE_PHASEIDEALLOOP1:            return "PhaseIdealLoop 1";
  80       case PHASE_PHASEIDEALLOOP2:            return "PhaseIdealLoop 2";
  81       case PHASE_PHASEIDEALLOOP3:            return "PhaseIdealLoop 3";
  82       case PHASE_CPP1:                       return "PhaseCPP 1";
  83       case PHASE_ITER_GVN2:                  return "Iter GVN 2";
  84       case PHASE_PHASEIDEALLOOP_ITERATIONS:  return "PhaseIdealLoop iterations";
  85       case PHASE_OPTIMIZE_FINISHED:          return "Optimize finished";

  86       case PHASE_GLOBAL_CODE_MOTION:         return "Global code motion";
  87       case PHASE_FINAL_CODE:                 return "Final Code";
  88       case PHASE_AFTER_EA:                   return "After Escape Analysis";
  89       case PHASE_BEFORE_CLOOPS:              return "Before CountedLoop";
  90       case PHASE_AFTER_CLOOPS:               return "After CountedLoop";
  91       case PHASE_BEFORE_BEAUTIFY_LOOPS:      return "Before beautify loops";
  92       case PHASE_AFTER_BEAUTIFY_LOOPS:       return "After beautify loops";
  93       case PHASE_BEFORE_MATCHING:            return "Before matching";
  94       case PHASE_MATCHING:                   return "After matching";
  95       case PHASE_INCREMENTAL_INLINE:         return "Incremental Inline";

  96       case PHASE_INCREMENTAL_BOXING_INLINE:  return "Incremental Boxing Inline";
  97       case PHASE_CALL_CATCH_CLEANUP:         return "Call catch cleanup";
  98       case PHASE_INSERT_BARRIER:             return "Insert barrier";
  99       case PHASE_MACRO_EXPANSION:            return "Macro expand";
 100       case PHASE_BARRIER_EXPANSION:          return "Barrier expand";
 101       case PHASE_ADD_UNSAFE_BARRIER:         return "Add barrier to unsafe op";
 102       case PHASE_END:                        return "End";
 103       case PHASE_FAILURE:                    return "Failure";
 104       case PHASE_DEBUG:                      return "Debug";
 105       default:
 106         ShouldNotReachHere();
 107         return NULL;
 108     }
 109   }
 110 };
 111 
 112 #endif // SHARE_OPTO_PHASETYPE_HPP


  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_OPTO_PHASETYPE_HPP
  26 #define SHARE_OPTO_PHASETYPE_HPP
  27 
  28 enum CompilerPhaseType {
  29   PHASE_BEFORE_STRINGOPTS,
  30   PHASE_AFTER_STRINGOPTS,
  31   PHASE_BEFORE_REMOVEUSELESS,
  32   PHASE_AFTER_PARSING,
  33   PHASE_ITER_GVN1,
  34   PHASE_EXPAND_VUNBOX,
  35   PHASE_SCALARIZE_VBOX,
  36   PHASE_INLINE_VECTOR_REBOX,
  37   PHASE_EXPAND_VBOX,
  38   PHASE_ELIMINATE_VBOX_ALLOC,
  39   PHASE_PHASEIDEAL_BEFORE_EA,
  40   PHASE_ITER_GVN_AFTER_VECTOR,
  41   PHASE_ITER_GVN_BEFORE_EA,
  42   PHASE_ITER_GVN_AFTER_EA,
  43   PHASE_ITER_GVN_AFTER_ELIMINATION,
  44   PHASE_PHASEIDEALLOOP1,
  45   PHASE_PHASEIDEALLOOP2,
  46   PHASE_PHASEIDEALLOOP3,
  47   PHASE_CPP1,
  48   PHASE_ITER_GVN2,
  49   PHASE_PHASEIDEALLOOP_ITERATIONS,
  50   PHASE_OPTIMIZE_FINISHED,
  51   PHASE_AFTER_MATCHING,
  52   PHASE_GLOBAL_CODE_MOTION,
  53   PHASE_FINAL_CODE,
  54   PHASE_AFTER_EA,
  55   PHASE_BEFORE_CLOOPS,
  56   PHASE_AFTER_CLOOPS,
  57   PHASE_BEFORE_BEAUTIFY_LOOPS,
  58   PHASE_AFTER_BEAUTIFY_LOOPS,
  59   PHASE_BEFORE_MATCHING,
  60   PHASE_MATCHING,
  61   PHASE_INCREMENTAL_INLINE,
  62   PHASE_INCREMENTAL_INLINE_STEP,
  63   PHASE_INCREMENTAL_BOXING_INLINE,
  64   PHASE_CALL_CATCH_CLEANUP,
  65   PHASE_INSERT_BARRIER,
  66   PHASE_MACRO_EXPANSION,
  67   PHASE_BARRIER_EXPANSION,
  68   PHASE_ADD_UNSAFE_BARRIER,
  69   PHASE_END,
  70   PHASE_FAILURE,
  71   PHASE_DEBUG,
  72 
  73   PHASE_NUM_TYPES
  74 };
  75 
  76 class CompilerPhaseTypeHelper {
  77   public:
  78   static const char* to_string(CompilerPhaseType cpt) {
  79     switch (cpt) {
  80       case PHASE_BEFORE_STRINGOPTS:          return "Before StringOpts";
  81       case PHASE_AFTER_STRINGOPTS:           return "After StringOpts";
  82       case PHASE_BEFORE_REMOVEUSELESS:       return "Before RemoveUseless";
  83       case PHASE_AFTER_PARSING:              return "After Parsing";
  84       case PHASE_ITER_GVN1:                  return "Iter GVN 1";
  85       case PHASE_EXPAND_VUNBOX:              return "Expand VectorUnbox";
  86       case PHASE_SCALARIZE_VBOX:             return "Scalarize VectorBox";
  87       case PHASE_INLINE_VECTOR_REBOX:        return "Inline Vector Rebox Calls";
  88       case PHASE_EXPAND_VBOX:                return "Expand VectorBox";
  89       case PHASE_ELIMINATE_VBOX_ALLOC:       return "Eliminate VectorBoxAllocate";
  90       case PHASE_PHASEIDEAL_BEFORE_EA:       return "PhaseIdealLoop before EA";
  91       case PHASE_ITER_GVN_AFTER_VECTOR:      return "Iter GVN after vector box elimination";
  92       case PHASE_ITER_GVN_BEFORE_EA:         return "Iter GVN before EA";
  93       case PHASE_ITER_GVN_AFTER_EA:          return "Iter GVN after EA";
  94       case PHASE_ITER_GVN_AFTER_ELIMINATION: return "Iter GVN after eliminating allocations and locks";
  95       case PHASE_PHASEIDEALLOOP1:            return "PhaseIdealLoop 1";
  96       case PHASE_PHASEIDEALLOOP2:            return "PhaseIdealLoop 2";
  97       case PHASE_PHASEIDEALLOOP3:            return "PhaseIdealLoop 3";
  98       case PHASE_CPP1:                       return "PhaseCPP 1";
  99       case PHASE_ITER_GVN2:                  return "Iter GVN 2";
 100       case PHASE_PHASEIDEALLOOP_ITERATIONS:  return "PhaseIdealLoop iterations";
 101       case PHASE_OPTIMIZE_FINISHED:          return "Optimize finished";
 102       case PHASE_AFTER_MATCHING:             return "After Matching";
 103       case PHASE_GLOBAL_CODE_MOTION:         return "Global code motion";
 104       case PHASE_FINAL_CODE:                 return "Final Code";
 105       case PHASE_AFTER_EA:                   return "After Escape Analysis";
 106       case PHASE_BEFORE_CLOOPS:              return "Before CountedLoop";
 107       case PHASE_AFTER_CLOOPS:               return "After CountedLoop";
 108       case PHASE_BEFORE_BEAUTIFY_LOOPS:      return "Before beautify loops";
 109       case PHASE_AFTER_BEAUTIFY_LOOPS:       return "After beautify loops";
 110       case PHASE_BEFORE_MATCHING:            return "Before matching";
 111       case PHASE_MATCHING:                   return "After matching";
 112       case PHASE_INCREMENTAL_INLINE:         return "Incremental Inline";
 113       case PHASE_INCREMENTAL_INLINE_STEP:    return "Incremental Inline Step";
 114       case PHASE_INCREMENTAL_BOXING_INLINE:  return "Incremental Boxing Inline";
 115       case PHASE_CALL_CATCH_CLEANUP:         return "Call catch cleanup";
 116       case PHASE_INSERT_BARRIER:             return "Insert barrier";
 117       case PHASE_MACRO_EXPANSION:            return "Macro expand";
 118       case PHASE_BARRIER_EXPANSION:          return "Barrier expand";
 119       case PHASE_ADD_UNSAFE_BARRIER:         return "Add barrier to unsafe op";
 120       case PHASE_END:                        return "End";
 121       case PHASE_FAILURE:                    return "Failure";
 122       case PHASE_DEBUG:                      return "Debug";
 123       default:
 124         ShouldNotReachHere();
 125         return NULL;
 126     }
 127   }
 128 };
 129 
 130 #endif // SHARE_OPTO_PHASETYPE_HPP
< prev index next >