truffle: src/share/vm/opto/c2_globals.hpp annotate

annotate src/share/vm/opto/c2_globals.hpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	571076d3c79d
children	6f3fd5150b67

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
5948 ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build kvn parents: 4777 diff changeset	2 * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1365 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1365 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1365 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	25 #ifndef SHARE_VM_OPTO_C2_GLOBALS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	26 #define SHARE_VM_OPTO_C2_GLOBALS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	28 #include "runtime/globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	29 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	30 # include "c2_globals_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	31 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	32 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	33 # include "c2_globals_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	34 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	35 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	36 # include "c2_globals_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2008 diff changeset	37 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	38 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	39 # include "c2_globals_linux.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	40 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	41 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	42 # include "c2_globals_solaris.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	43 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	44 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	45 # include "c2_globals_windows.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	46 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3345 diff changeset	47 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3345 diff changeset	48 # include "c2_globals_bsd.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3345 diff changeset	49 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	50
0 a61af66fc99e Initial load duke parents: diff changeset	51 //
a61af66fc99e Initial load duke parents: diff changeset	52 // Defines all globals flags used by the server compiler.
a61af66fc99e Initial load duke parents: diff changeset	53 //
a61af66fc99e Initial load duke parents: diff changeset	54
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	55 #define C2_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct) \
0 a61af66fc99e Initial load duke parents: diff changeset	56 \
8691 571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	57 develop(bool, StressLCM, false, \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	58 "Randomize instruction scheduling in LCM") \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	59 \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	60 develop(bool, StressGCM, false, \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	61 "Randomize instruction scheduling in GCM") \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	62 \
0 a61af66fc99e Initial load duke parents: diff changeset	63 notproduct(intx, CompileZapFirst, 0, \
a61af66fc99e Initial load duke parents: diff changeset	64 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	65 "skip this many before compiling in zap calls") \
a61af66fc99e Initial load duke parents: diff changeset	66 \
a61af66fc99e Initial load duke parents: diff changeset	67 notproduct(intx, CompileZapLast, -1, \
a61af66fc99e Initial load duke parents: diff changeset	68 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	69 "compile this many after skipping (incl. skip count, -1 = all)") \
a61af66fc99e Initial load duke parents: diff changeset	70 \
a61af66fc99e Initial load duke parents: diff changeset	71 notproduct(intx, ZapDeadCompiledLocalsFirst, 0, \
a61af66fc99e Initial load duke parents: diff changeset	72 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	73 "skip this many before really doing it") \
a61af66fc99e Initial load duke parents: diff changeset	74 \
a61af66fc99e Initial load duke parents: diff changeset	75 notproduct(intx, ZapDeadCompiledLocalsLast, -1, \
a61af66fc99e Initial load duke parents: diff changeset	76 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	77 "do this many after skipping (incl. skip count, -1 = all)") \
a61af66fc99e Initial load duke parents: diff changeset	78 \
a61af66fc99e Initial load duke parents: diff changeset	79 develop(intx, OptoPrologueNops, 0, \
a61af66fc99e Initial load duke parents: diff changeset	80 "Insert this many extra nop instructions " \
a61af66fc99e Initial load duke parents: diff changeset	81 "in the prologue of every nmethod") \
a61af66fc99e Initial load duke parents: diff changeset	82 \
a61af66fc99e Initial load duke parents: diff changeset	83 product_pd(intx, InteriorEntryAlignment, \
a61af66fc99e Initial load duke parents: diff changeset	84 "Code alignment for interior entry points " \
a61af66fc99e Initial load duke parents: diff changeset	85 "in generated code (in bytes)") \
a61af66fc99e Initial load duke parents: diff changeset	86 \
a61af66fc99e Initial load duke parents: diff changeset	87 product(intx, MaxLoopPad, (OptoLoopAlignment-1), \
a61af66fc99e Initial load duke parents: diff changeset	88 "Align a loop if padding size in bytes is less or equal to this value") \
a61af66fc99e Initial load duke parents: diff changeset	89 \
6179 8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	90 product(intx, MaxVectorSize, 32, \
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	91 "Max vector size in bytes, " \
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	92 "actual size could be less depending on elements type") \
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	93 \
6794 8ae8f9dd7099 7199010: incorrect vector alignment kvn parents: 6793 diff changeset	94 product(bool, AlignVector, true, \
6179 8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	95 "Perform vector store/load alignment in loop") \
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	96 \
0 a61af66fc99e Initial load duke parents: diff changeset	97 product(intx, NumberOfLoopInstrToAlign, 4, \
a61af66fc99e Initial load duke parents: diff changeset	98 "Number of first instructions in a loop to align") \
a61af66fc99e Initial load duke parents: diff changeset	99 \
a61af66fc99e Initial load duke parents: diff changeset	100 notproduct(intx, IndexSetWatch, 0, \
a61af66fc99e Initial load duke parents: diff changeset	101 "Trace all operations on this IndexSet (-1 means all, 0 none)") \
a61af66fc99e Initial load duke parents: diff changeset	102 \
a61af66fc99e Initial load duke parents: diff changeset	103 develop(intx, OptoNodeListSize, 4, \
a61af66fc99e Initial load duke parents: diff changeset	104 "Starting allocation size of Node_List data structures") \
a61af66fc99e Initial load duke parents: diff changeset	105 \
a61af66fc99e Initial load duke parents: diff changeset	106 develop(intx, OptoBlockListSize, 8, \
a61af66fc99e Initial load duke parents: diff changeset	107 "Starting allocation size of Block_List data structures") \
a61af66fc99e Initial load duke parents: diff changeset	108 \
a61af66fc99e Initial load duke parents: diff changeset	109 develop(intx, OptoPeepholeAt, -1, \
a61af66fc99e Initial load duke parents: diff changeset	110 "Apply peephole optimizations to this peephole rule") \
a61af66fc99e Initial load duke parents: diff changeset	111 \
a61af66fc99e Initial load duke parents: diff changeset	112 notproduct(bool, PrintIdeal, false, \
a61af66fc99e Initial load duke parents: diff changeset	113 "Print ideal graph before code generation") \
a61af66fc99e Initial load duke parents: diff changeset	114 \
a61af66fc99e Initial load duke parents: diff changeset	115 notproduct(bool, PrintOpto, false, \
a61af66fc99e Initial load duke parents: diff changeset	116 "Print compiler2 attempts") \
a61af66fc99e Initial load duke parents: diff changeset	117 \
a61af66fc99e Initial load duke parents: diff changeset	118 notproduct(bool, PrintOptoInlining, false, \
a61af66fc99e Initial load duke parents: diff changeset	119 "Print compiler2 inlining decisions") \
a61af66fc99e Initial load duke parents: diff changeset	120 \
a61af66fc99e Initial load duke parents: diff changeset	121 notproduct(bool, VerifyOpto, false, \
a61af66fc99e Initial load duke parents: diff changeset	122 "Apply more time consuming verification during compilation") \
a61af66fc99e Initial load duke parents: diff changeset	123 \
7196 2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	124 notproduct(bool, VerifyIdealNodeCount, false, \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	125 "Verify that tracked dead ideal node count is accurate") \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	126 \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	127 notproduct(bool, PrintIdealNodeCount, false, \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	128 "Print liveness counts of ideal nodes") \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	129 \
0 a61af66fc99e Initial load duke parents: diff changeset	130 notproduct(bool, VerifyOptoOopOffsets, false, \
a61af66fc99e Initial load duke parents: diff changeset	131 "Check types of base addresses in field references") \
a61af66fc99e Initial load duke parents: diff changeset	132 \
a61af66fc99e Initial load duke parents: diff changeset	133 develop(bool, IdealizedNumerics, false, \
a61af66fc99e Initial load duke parents: diff changeset	134 "Check performance difference allowing FP " \
a61af66fc99e Initial load duke parents: diff changeset	135 "associativity and commutativity...") \
a61af66fc99e Initial load duke parents: diff changeset	136 \
a61af66fc99e Initial load duke parents: diff changeset	137 develop(bool, OptoBreakpoint, false, \
a61af66fc99e Initial load duke parents: diff changeset	138 "insert breakpoint at method entry") \
a61af66fc99e Initial load duke parents: diff changeset	139 \
a61af66fc99e Initial load duke parents: diff changeset	140 notproduct(bool, OptoBreakpointOSR, false, \
a61af66fc99e Initial load duke parents: diff changeset	141 "insert breakpoint at osr method entry") \
a61af66fc99e Initial load duke parents: diff changeset	142 \
a61af66fc99e Initial load duke parents: diff changeset	143 notproduct(intx, BreakAtNode, 0, \
a61af66fc99e Initial load duke parents: diff changeset	144 "Break at construction of this Node (either _idx or _debug_idx)") \
a61af66fc99e Initial load duke parents: diff changeset	145 \
a61af66fc99e Initial load duke parents: diff changeset	146 notproduct(bool, OptoBreakpointC2R, false, \
a61af66fc99e Initial load duke parents: diff changeset	147 "insert breakpoint at runtime stub entry") \
a61af66fc99e Initial load duke parents: diff changeset	148 \
a61af66fc99e Initial load duke parents: diff changeset	149 notproduct(bool, OptoNoExecute, false, \
a61af66fc99e Initial load duke parents: diff changeset	150 "Attempt to parse and compile but do not execute generated code") \
a61af66fc99e Initial load duke parents: diff changeset	151 \
a61af66fc99e Initial load duke parents: diff changeset	152 notproduct(bool, PrintOptoStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	153 "Print New compiler statistics") \
a61af66fc99e Initial load duke parents: diff changeset	154 \
a61af66fc99e Initial load duke parents: diff changeset	155 notproduct(bool, PrintOptoAssembly, false, \
a61af66fc99e Initial load duke parents: diff changeset	156 "Print New compiler assembly output") \
a61af66fc99e Initial load duke parents: diff changeset	157 \
a61af66fc99e Initial load duke parents: diff changeset	158 develop_pd(bool, OptoPeephole, \
a61af66fc99e Initial load duke parents: diff changeset	159 "Apply peephole optimizations after register allocation") \
a61af66fc99e Initial load duke parents: diff changeset	160 \
a61af66fc99e Initial load duke parents: diff changeset	161 develop(bool, OptoRemoveUseless, true, \
a61af66fc99e Initial load duke parents: diff changeset	162 "Remove useless nodes after parsing") \
a61af66fc99e Initial load duke parents: diff changeset	163 \
a61af66fc99e Initial load duke parents: diff changeset	164 notproduct(bool, PrintFrameConverterAssembly, false, \
a61af66fc99e Initial load duke parents: diff changeset	165 "Print New compiler assembly output for frame converters") \
a61af66fc99e Initial load duke parents: diff changeset	166 \
a61af66fc99e Initial load duke parents: diff changeset	167 notproduct(bool, PrintParseStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	168 "Print nodes, transforms and new values made per bytecode parsed")\
a61af66fc99e Initial load duke parents: diff changeset	169 \
a61af66fc99e Initial load duke parents: diff changeset	170 notproduct(bool, PrintOptoPeephole, false, \
a61af66fc99e Initial load duke parents: diff changeset	171 "Print New compiler peephole replacements") \
a61af66fc99e Initial load duke parents: diff changeset	172 \
a61af66fc99e Initial load duke parents: diff changeset	173 develop(bool, PrintCFGBlockFreq, false, \
a61af66fc99e Initial load duke parents: diff changeset	174 "Print CFG block freqencies") \
a61af66fc99e Initial load duke parents: diff changeset	175 \
a61af66fc99e Initial load duke parents: diff changeset	176 develop(bool, TraceOptoParse, false, \
a61af66fc99e Initial load duke parents: diff changeset	177 "Trace bytecode parse and control-flow merge") \
a61af66fc99e Initial load duke parents: diff changeset	178 \
a61af66fc99e Initial load duke parents: diff changeset	179 product_pd(intx, LoopUnrollLimit, \
a61af66fc99e Initial load duke parents: diff changeset	180 "Unroll loop bodies with node count less than this") \
a61af66fc99e Initial load duke parents: diff changeset	181 \
a61af66fc99e Initial load duke parents: diff changeset	182 product(intx, LoopUnrollMin, 4, \
a61af66fc99e Initial load duke parents: diff changeset	183 "Minimum number of unroll loop bodies before checking progress" \
a61af66fc99e Initial load duke parents: diff changeset	184 "of rounds of unroll,optimize,..") \
a61af66fc99e Initial load duke parents: diff changeset	185 \
a61af66fc99e Initial load duke parents: diff changeset	186 develop(intx, UnrollLimitForProfileCheck, 1, \
a61af66fc99e Initial load duke parents: diff changeset	187 "Don't use profile_trip_cnt() to restrict unrolling until " \
a61af66fc99e Initial load duke parents: diff changeset	188 "unrolling would push the number of unrolled iterations above " \
a61af66fc99e Initial load duke parents: diff changeset	189 "UnrollLimitForProfileCheck. A higher value allows more " \
a61af66fc99e Initial load duke parents: diff changeset	190 "unrolling. Zero acts as a very large value." ) \
a61af66fc99e Initial load duke parents: diff changeset	191 \
a61af66fc99e Initial load duke parents: diff changeset	192 product(intx, MultiArrayExpandLimit, 6, \
a61af66fc99e Initial load duke parents: diff changeset	193 "Maximum number of individual allocations in an inline-expanded " \
a61af66fc99e Initial load duke parents: diff changeset	194 "multianewarray instruction") \
a61af66fc99e Initial load duke parents: diff changeset	195 \
a61af66fc99e Initial load duke parents: diff changeset	196 notproduct(bool, TraceProfileTripCount, false, \
a61af66fc99e Initial load duke parents: diff changeset	197 "Trace profile loop trip count information") \
a61af66fc99e Initial load duke parents: diff changeset	198 \
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	199 product(bool, UseLoopPredicate, true, \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	200 "Generate a predicate to select fast/slow loop versions") \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	201 \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	202 develop(bool, TraceLoopPredicate, false, \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	203 "Trace generation of loop predicates") \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	204 \
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2192 diff changeset	205 develop(bool, TraceLoopOpts, false, \
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2192 diff changeset	206 "Trace executed loop optimizations") \
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2192 diff changeset	207 \
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	208 diagnostic(bool, LoopLimitCheck, true, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	209 "Generate a loop limits check for overflow") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	210 \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	211 develop(bool, TraceLoopLimitCheck, false, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	212 "Trace generation of loop limits checks") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	213 \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	214 diagnostic(bool, RangeLimitCheck, true, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	215 "Additional overflow checks during range check elimination") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	216 \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	217 develop(bool, TraceRangeLimitCheck, false, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	218 "Trace additional overflow checks in RCE") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	219 \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	220 diagnostic(bool, UnrollLimitCheck, true, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	221 "Additional overflow checks during loop unroll") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	222 \
4039 5bda8dae4e14 7103784: enable some flags by default never parents: 3960 diff changeset	223 product(bool, OptimizeFill, true, \
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	224 "convert fill/copy loops into intrinsic") \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	225 \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	226 develop(bool, TraceOptimizeFill, false, \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	227 "print detailed information about fill conversion") \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	228 \
0 a61af66fc99e Initial load duke parents: diff changeset	229 develop(bool, OptoCoalesce, true, \
a61af66fc99e Initial load duke parents: diff changeset	230 "Use Conservative Copy Coalescing in the Register Allocator") \
a61af66fc99e Initial load duke parents: diff changeset	231 \
a61af66fc99e Initial load duke parents: diff changeset	232 develop(bool, UseUniqueSubclasses, true, \
a61af66fc99e Initial load duke parents: diff changeset	233 "Narrow an abstract reference to the unique concrete subclass") \
a61af66fc99e Initial load duke parents: diff changeset	234 \
a61af66fc99e Initial load duke parents: diff changeset	235 develop(bool, UseExactTypes, true, \
a61af66fc99e Initial load duke parents: diff changeset	236 "Use exact types to eliminate array store checks and v-calls") \
a61af66fc99e Initial load duke parents: diff changeset	237 \
a61af66fc99e Initial load duke parents: diff changeset	238 product(intx, TrackedInitializationLimit, 50, \
a61af66fc99e Initial load duke parents: diff changeset	239 "When initializing fields, track up to this many words") \
a61af66fc99e Initial load duke parents: diff changeset	240 \
a61af66fc99e Initial load duke parents: diff changeset	241 product(bool, ReduceFieldZeroing, true, \
a61af66fc99e Initial load duke parents: diff changeset	242 "When initializing fields, try to avoid needless zeroing") \
a61af66fc99e Initial load duke parents: diff changeset	243 \
a61af66fc99e Initial load duke parents: diff changeset	244 product(bool, ReduceInitialCardMarks, true, \
a61af66fc99e Initial load duke parents: diff changeset	245 "When initializing fields, try to avoid needless card marks") \
a61af66fc99e Initial load duke parents: diff changeset	246 \
a61af66fc99e Initial load duke parents: diff changeset	247 product(bool, ReduceBulkZeroing, true, \
a61af66fc99e Initial load duke parents: diff changeset	248 "When bulk-initializing, try to avoid needless zeroing") \
a61af66fc99e Initial load duke parents: diff changeset	249 \
1730 f55c4f82ab9d 6978249: spill between cpu and fpu registers when those moves are fast never parents: 1685 diff changeset	250 product(bool, UseFPUForSpilling, false, \
f55c4f82ab9d 6978249: spill between cpu and fpu registers when those moves are fast never parents: 1685 diff changeset	251 "Spill integer registers to FPU instead of stack when possible") \
f55c4f82ab9d 6978249: spill between cpu and fpu registers when those moves are fast never parents: 1685 diff changeset	252 \
0 a61af66fc99e Initial load duke parents: diff changeset	253 develop_pd(intx, RegisterCostAreaRatio, \
a61af66fc99e Initial load duke parents: diff changeset	254 "Spill selection in reg allocator: scale area by (X/64K) before " \
a61af66fc99e Initial load duke parents: diff changeset	255 "adding cost") \
a61af66fc99e Initial load duke parents: diff changeset	256 \
a61af66fc99e Initial load duke parents: diff changeset	257 develop_pd(bool, UseCISCSpill, \
a61af66fc99e Initial load duke parents: diff changeset	258 "Use ADLC supplied cisc instructions during allocation") \
a61af66fc99e Initial load duke parents: diff changeset	259 \
a61af66fc99e Initial load duke parents: diff changeset	260 notproduct(bool, VerifyGraphEdges , false, \
a61af66fc99e Initial load duke parents: diff changeset	261 "Verify Bi-directional Edges") \
a61af66fc99e Initial load duke parents: diff changeset	262 \
a61af66fc99e Initial load duke parents: diff changeset	263 notproduct(bool, VerifyDUIterators, true, \
a61af66fc99e Initial load duke parents: diff changeset	264 "Verify the safety of all iterations of Bi-directional Edges") \
a61af66fc99e Initial load duke parents: diff changeset	265 \
a61af66fc99e Initial load duke parents: diff changeset	266 notproduct(bool, VerifyHashTableKeys, true, \
a61af66fc99e Initial load duke parents: diff changeset	267 "Verify the immutability of keys in the VN hash tables") \
a61af66fc99e Initial load duke parents: diff changeset	268 \
550 96964ebdb154 6782232: assert("CreateEx must be first instruction in block" ) kvn parents: 434 diff changeset	269 notproduct(bool, VerifyRegisterAllocator , false, \
96964ebdb154 6782232: assert("CreateEx must be first instruction in block" ) kvn parents: 434 diff changeset	270 "Verify Register Allocator") \
96964ebdb154 6782232: assert("CreateEx must be first instruction in block" ) kvn parents: 434 diff changeset	271 \
0 a61af66fc99e Initial load duke parents: diff changeset	272 develop_pd(intx, FLOATPRESSURE, \
a61af66fc99e Initial load duke parents: diff changeset	273 "Number of float LRG's that constitute high register pressure") \
a61af66fc99e Initial load duke parents: diff changeset	274 \
a61af66fc99e Initial load duke parents: diff changeset	275 develop_pd(intx, INTPRESSURE, \
a61af66fc99e Initial load duke parents: diff changeset	276 "Number of integer LRG's that constitute high register pressure") \
a61af66fc99e Initial load duke parents: diff changeset	277 \
a61af66fc99e Initial load duke parents: diff changeset	278 notproduct(bool, TraceOptoPipelining, false, \
a61af66fc99e Initial load duke parents: diff changeset	279 "Trace pipelining information") \
a61af66fc99e Initial load duke parents: diff changeset	280 \
a61af66fc99e Initial load duke parents: diff changeset	281 notproduct(bool, TraceOptoOutput, false, \
a61af66fc99e Initial load duke parents: diff changeset	282 "Trace pipelining information") \
a61af66fc99e Initial load duke parents: diff changeset	283 \
a61af66fc99e Initial load duke parents: diff changeset	284 product_pd(bool, OptoScheduling, \
a61af66fc99e Initial load duke parents: diff changeset	285 "Instruction Scheduling after register allocation") \
a61af66fc99e Initial load duke parents: diff changeset	286 \
a61af66fc99e Initial load duke parents: diff changeset	287 product(bool, PartialPeelLoop, true, \
a61af66fc99e Initial load duke parents: diff changeset	288 "Partial peel (rotate) loops") \
a61af66fc99e Initial load duke parents: diff changeset	289 \
a61af66fc99e Initial load duke parents: diff changeset	290 product(intx, PartialPeelNewPhiDelta, 0, \
a61af66fc99e Initial load duke parents: diff changeset	291 "Additional phis that can be created by partial peeling") \
a61af66fc99e Initial load duke parents: diff changeset	292 \
a61af66fc99e Initial load duke parents: diff changeset	293 notproduct(bool, TracePartialPeeling, false, \
a61af66fc99e Initial load duke parents: diff changeset	294 "Trace partial peeling (loop rotation) information") \
a61af66fc99e Initial load duke parents: diff changeset	295 \
a61af66fc99e Initial load duke parents: diff changeset	296 product(bool, PartialPeelAtUnsignedTests, true, \
a61af66fc99e Initial load duke parents: diff changeset	297 "Partial peel at unsigned tests if no signed test exists") \
a61af66fc99e Initial load duke parents: diff changeset	298 \
a61af66fc99e Initial load duke parents: diff changeset	299 product(bool, ReassociateInvariants, true, \
a61af66fc99e Initial load duke parents: diff changeset	300 "Enable reassociation of expressions with loop invariants.") \
a61af66fc99e Initial load duke parents: diff changeset	301 \
a61af66fc99e Initial load duke parents: diff changeset	302 product(bool, LoopUnswitching, true, \
a61af66fc99e Initial load duke parents: diff changeset	303 "Enable loop unswitching (a form of invariant test hoisting)") \
a61af66fc99e Initial load duke parents: diff changeset	304 \
a61af66fc99e Initial load duke parents: diff changeset	305 notproduct(bool, TraceLoopUnswitching, false, \
a61af66fc99e Initial load duke parents: diff changeset	306 "Trace loop unswitching") \
a61af66fc99e Initial load duke parents: diff changeset	307 \
a61af66fc99e Initial load duke parents: diff changeset	308 product(bool, UseSuperWord, true, \
a61af66fc99e Initial load duke parents: diff changeset	309 "Transform scalar operations into superword operations") \
a61af66fc99e Initial load duke parents: diff changeset	310 \
a61af66fc99e Initial load duke parents: diff changeset	311 develop(bool, SuperWordRTDepCheck, false, \
a61af66fc99e Initial load duke parents: diff changeset	312 "Enable runtime dependency checks.") \
a61af66fc99e Initial load duke parents: diff changeset	313 \
6183 6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	314 notproduct(bool, TraceSuperWord, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	315 "Trace superword transforms") \
a61af66fc99e Initial load duke parents: diff changeset	316 \
6183 6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	317 notproduct(bool, TraceNewVectors, false, \
6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	318 "Trace creation of Vector nodes") \
6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	319 \
0 a61af66fc99e Initial load duke parents: diff changeset	320 product_pd(bool, OptoBundling, \
a61af66fc99e Initial load duke parents: diff changeset	321 "Generate nops to fill i-cache lines") \
a61af66fc99e Initial load duke parents: diff changeset	322 \
a61af66fc99e Initial load duke parents: diff changeset	323 product_pd(intx, ConditionalMoveLimit, \
a61af66fc99e Initial load duke parents: diff changeset	324 "Limit of ops to make speculative when using CMOVE") \
a61af66fc99e Initial load duke parents: diff changeset	325 \
a61af66fc99e Initial load duke parents: diff changeset	326 /* Set BranchOnRegister == false. See 4965987. */ \
a61af66fc99e Initial load duke parents: diff changeset	327 product(bool, BranchOnRegister, false, \
a61af66fc99e Initial load duke parents: diff changeset	328 "Use Sparc V9 branch-on-register opcodes") \
a61af66fc99e Initial load duke parents: diff changeset	329 \
a61af66fc99e Initial load duke parents: diff changeset	330 develop(bool, SparcV9RegsHiBitsZero, true, \
a61af66fc99e Initial load duke parents: diff changeset	331 "Assume Sparc V9 I&L registers on V8+ systems are zero-extended") \
a61af66fc99e Initial load duke parents: diff changeset	332 \
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	333 product(bool, UseRDPCForConstantTableBase, false, \
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	334 "Use Sparc RDPC instruction for the constant table base.") \
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	335 \
0 a61af66fc99e Initial load duke parents: diff changeset	336 develop(intx, PrintIdealGraphLevel, 0, \
a61af66fc99e Initial load duke parents: diff changeset	337 "Print ideal graph to XML file / network interface. " \
a61af66fc99e Initial load duke parents: diff changeset	338 "By default attempts to connect to the visualizer on a socket.") \
a61af66fc99e Initial load duke parents: diff changeset	339 \
a61af66fc99e Initial load duke parents: diff changeset	340 develop(intx, PrintIdealGraphPort, 4444, \
a61af66fc99e Initial load duke parents: diff changeset	341 "Ideal graph printer to network port") \
a61af66fc99e Initial load duke parents: diff changeset	342 \
434 de78b80cedec 6772413: code cleanup kvn parents: 420 diff changeset	343 notproduct(ccstr, PrintIdealGraphAddress, "127.0.0.1", \
0 a61af66fc99e Initial load duke parents: diff changeset	344 "IP address to connect to visualizer") \
a61af66fc99e Initial load duke parents: diff changeset	345 \
434 de78b80cedec 6772413: code cleanup kvn parents: 420 diff changeset	346 notproduct(ccstr, PrintIdealGraphFile, NULL, \
0 a61af66fc99e Initial load duke parents: diff changeset	347 "File to dump ideal graph to. If set overrides the " \
a61af66fc99e Initial load duke parents: diff changeset	348 "use of the network") \
a61af66fc99e Initial load duke parents: diff changeset	349 \
a61af66fc99e Initial load duke parents: diff changeset	350 product(bool, UseOldInlining, true, \
a61af66fc99e Initial load duke parents: diff changeset	351 "Enable the 1.3 inlining strategy") \
a61af66fc99e Initial load duke parents: diff changeset	352 \
a61af66fc99e Initial load duke parents: diff changeset	353 product(bool, UseBimorphicInlining, true, \
a61af66fc99e Initial load duke parents: diff changeset	354 "Profiling based inlining for two receivers") \
a61af66fc99e Initial load duke parents: diff changeset	355 \
a61af66fc99e Initial load duke parents: diff changeset	356 product(bool, UseOnlyInlinedBimorphic, true, \
a61af66fc99e Initial load duke parents: diff changeset	357 "Don't use BimorphicInlining if can't inline a second method") \
a61af66fc99e Initial load duke parents: diff changeset	358 \
a61af66fc99e Initial load duke parents: diff changeset	359 product(bool, InsertMemBarAfterArraycopy, true, \
a61af66fc99e Initial load duke parents: diff changeset	360 "Insert memory barrier after arraycopy call") \
a61af66fc99e Initial load duke parents: diff changeset	361 \
1685 0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	362 develop(bool, SubsumeLoads, true, \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	363 "Attempt to compile while subsuming loads into machine instructions.") \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	364 \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	365 develop(bool, StressRecompilation, false, \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	366 "Recompile each compiled method without subsuming loads or escape analysis.") \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	367 \
0 a61af66fc99e Initial load duke parents: diff changeset	368 develop(intx, ImplicitNullCheckThreshold, 3, \
a61af66fc99e Initial load duke parents: diff changeset	369 "Don't do implicit null checks if NPE's in a method exceeds limit") \
a61af66fc99e Initial load duke parents: diff changeset	370 \
a61af66fc99e Initial load duke parents: diff changeset	371 product(intx, LoopOptsCount, 43, \
a61af66fc99e Initial load duke parents: diff changeset	372 "Set level of loop optimization for tier 1 compiles") \
a61af66fc99e Initial load duke parents: diff changeset	373 \
a61af66fc99e Initial load duke parents: diff changeset	374 /* controls for heat-based inlining */ \
a61af66fc99e Initial load duke parents: diff changeset	375 \
a61af66fc99e Initial load duke parents: diff changeset	376 develop(intx, NodeCountInliningCutoff, 18000, \
a61af66fc99e Initial load duke parents: diff changeset	377 "If parser node generation exceeds limit stop inlining") \
a61af66fc99e Initial load duke parents: diff changeset	378 \
a61af66fc99e Initial load duke parents: diff changeset	379 develop(intx, NodeCountInliningStep, 1000, \
a61af66fc99e Initial load duke parents: diff changeset	380 "Target size of warm calls inlined between optimization passes") \
a61af66fc99e Initial load duke parents: diff changeset	381 \
a61af66fc99e Initial load duke parents: diff changeset	382 develop(bool, InlineWarmCalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	383 "Use a heat-based priority queue to govern inlining") \
a61af66fc99e Initial load duke parents: diff changeset	384 \
a61af66fc99e Initial load duke parents: diff changeset	385 develop(intx, HotCallCountThreshold, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	386 "large numbers of calls (per method invocation) force hotness") \
a61af66fc99e Initial load duke parents: diff changeset	387 \
a61af66fc99e Initial load duke parents: diff changeset	388 develop(intx, HotCallProfitThreshold, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	389 "highly profitable inlining opportunities force hotness") \
a61af66fc99e Initial load duke parents: diff changeset	390 \
a61af66fc99e Initial load duke parents: diff changeset	391 develop(intx, HotCallTrivialWork, -1, \
a61af66fc99e Initial load duke parents: diff changeset	392 "trivial execution time (no larger than this) forces hotness") \
a61af66fc99e Initial load duke parents: diff changeset	393 \
a61af66fc99e Initial load duke parents: diff changeset	394 develop(intx, HotCallTrivialSize, -1, \
a61af66fc99e Initial load duke parents: diff changeset	395 "trivial methods (no larger than this) force calls to be hot") \
a61af66fc99e Initial load duke parents: diff changeset	396 \
a61af66fc99e Initial load duke parents: diff changeset	397 develop(intx, WarmCallMinCount, -1, \
a61af66fc99e Initial load duke parents: diff changeset	398 "number of calls (per method invocation) to enable inlining") \
a61af66fc99e Initial load duke parents: diff changeset	399 \
a61af66fc99e Initial load duke parents: diff changeset	400 develop(intx, WarmCallMinProfit, -1, \
a61af66fc99e Initial load duke parents: diff changeset	401 "number of calls (per method invocation) to enable inlining") \
a61af66fc99e Initial load duke parents: diff changeset	402 \
a61af66fc99e Initial load duke parents: diff changeset	403 develop(intx, WarmCallMaxWork, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	404 "execution time of the largest inlinable method") \
a61af66fc99e Initial load duke parents: diff changeset	405 \
a61af66fc99e Initial load duke parents: diff changeset	406 develop(intx, WarmCallMaxSize, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	407 "size of the largest inlinable method") \
a61af66fc99e Initial load duke parents: diff changeset	408 \
a61af66fc99e Initial load duke parents: diff changeset	409 product(intx, MaxNodeLimit, 65000, \
a61af66fc99e Initial load duke parents: diff changeset	410 "Maximum number of nodes") \
a61af66fc99e Initial load duke parents: diff changeset	411 \
a61af66fc99e Initial load duke parents: diff changeset	412 product(intx, NodeLimitFudgeFactor, 1000, \
a61af66fc99e Initial load duke parents: diff changeset	413 "Fudge Factor for certain optimizations") \
a61af66fc99e Initial load duke parents: diff changeset	414 \
a61af66fc99e Initial load duke parents: diff changeset	415 product(bool, UseJumpTables, true, \
a61af66fc99e Initial load duke parents: diff changeset	416 "Use JumpTables instead of a binary search tree for switches") \
a61af66fc99e Initial load duke parents: diff changeset	417 \
a61af66fc99e Initial load duke parents: diff changeset	418 product(bool, UseDivMod, true, \
a61af66fc99e Initial load duke parents: diff changeset	419 "Use combined DivMod instruction if available") \
a61af66fc99e Initial load duke parents: diff changeset	420 \
a61af66fc99e Initial load duke parents: diff changeset	421 product(intx, MinJumpTableSize, 18, \
a61af66fc99e Initial load duke parents: diff changeset	422 "Minimum number of targets in a generated jump table") \
a61af66fc99e Initial load duke parents: diff changeset	423 \
a61af66fc99e Initial load duke parents: diff changeset	424 product(intx, MaxJumpTableSize, 65000, \
a61af66fc99e Initial load duke parents: diff changeset	425 "Maximum number of targets in a generated jump table") \
a61af66fc99e Initial load duke parents: diff changeset	426 \
a61af66fc99e Initial load duke parents: diff changeset	427 product(intx, MaxJumpTableSparseness, 5, \
a61af66fc99e Initial load duke parents: diff changeset	428 "Maximum sparseness for jumptables") \
a61af66fc99e Initial load duke parents: diff changeset	429 \
a61af66fc99e Initial load duke parents: diff changeset	430 product(bool, EliminateLocks, true, \
a61af66fc99e Initial load duke parents: diff changeset	431 "Coarsen locks when possible") \
a61af66fc99e Initial load duke parents: diff changeset	432 \
4777 e9a5e0a812c8 7125896: Eliminate nested locks kvn parents: 4113 diff changeset	433 product(bool, EliminateNestedLocks, true, \
e9a5e0a812c8 7125896: Eliminate nested locks kvn parents: 4113 diff changeset	434 "Eliminate nested locks of the same object when possible") \
e9a5e0a812c8 7125896: Eliminate nested locks kvn parents: 4113 diff changeset	435 \
0 a61af66fc99e Initial load duke parents: diff changeset	436 notproduct(bool, PrintLockStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	437 "Print precise statistics on the dynamic lock usage") \
a61af66fc99e Initial load duke parents: diff changeset	438 \
a61af66fc99e Initial load duke parents: diff changeset	439 diagnostic(bool, PrintPreciseBiasedLockingStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	440 "Print per-lock-site statistics of biased locking in JVM") \
a61af66fc99e Initial load duke parents: diff changeset	441 \
a61af66fc99e Initial load duke parents: diff changeset	442 notproduct(bool, PrintEliminateLocks, false, \
a61af66fc99e Initial load duke parents: diff changeset	443 "Print out when locks are eliminated") \
a61af66fc99e Initial load duke parents: diff changeset	444 \
17 ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	445 diagnostic(bool, EliminateAutoBox, false, \
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	446 "Private flag to control optimizations for autobox elimination") \
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	447 \
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	448 product(intx, AutoBoxCacheMax, 128, \
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	449 "Sets max value cached by the java.lang.Integer autobox cache") \
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	450 \
930 357d4e2eb4dd 6873799: enable escape analysis by default kvn parents: 673 diff changeset	451 product(bool, DoEscapeAnalysis, true, \
0 a61af66fc99e Initial load duke parents: diff changeset	452 "Perform escape analysis") \
a61af66fc99e Initial load duke parents: diff changeset	453 \
6895 006174cfe979 7163534: VM could crashes assert(false) failed: infinite EA connection graph build kvn parents: 6794 diff changeset	454 develop(bool, ExitEscapeAnalysisOnTimeout, true, \
006174cfe979 7163534: VM could crashes assert(false) failed: infinite EA connection graph build kvn parents: 6794 diff changeset	455 "Exit or throw assert in EA when it reaches time limit") \
006174cfe979 7163534: VM could crashes assert(false) failed: infinite EA connection graph build kvn parents: 6794 diff changeset	456 \
0 a61af66fc99e Initial load duke parents: diff changeset	457 notproduct(bool, PrintEscapeAnalysis, false, \
a61af66fc99e Initial load duke parents: diff changeset	458 "Print the results of escape analysis") \
a61af66fc99e Initial load duke parents: diff changeset	459 \
a61af66fc99e Initial load duke parents: diff changeset	460 product(bool, EliminateAllocations, true, \
a61af66fc99e Initial load duke parents: diff changeset	461 "Use escape analysis to eliminate allocations") \
a61af66fc99e Initial load duke parents: diff changeset	462 \
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	463 notproduct(bool, PrintEliminateAllocations, false, \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	464 "Print out when allocations are eliminated") \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	465 \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	466 product(intx, EliminateAllocationArraySizeLimit, 64, \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	467 "Array size (number of elements) limit for scalar replacement") \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	468 \
4113 8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	469 product(bool, OptimizePtrCompare, true, \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	470 "Use escape analysis to optimize pointers compare") \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	471 \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	472 notproduct(bool, PrintOptimizePtrCompare, false, \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	473 "Print information about optimized pointers compare") \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	474 \
5948 ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build kvn parents: 4777 diff changeset	475 notproduct(bool, VerifyConnectionGraph , true, \
ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build kvn parents: 4777 diff changeset	476 "Verify Connection Graph construction in Escape Analysis") \
ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build kvn parents: 4777 diff changeset	477 \
673 fbc12e71c476 6810845: Performance regression in mpegaudio on x64 kvn parents: 579 diff changeset	478 product(bool, UseOptoBiasInlining, true, \
420 a1980da045cc 6462850: generate biased locking code in C2 ideal graph kvn parents: 418 diff changeset	479 "Generate biased locking code in C2 ideal graph") \
a1980da045cc 6462850: generate biased locking code in C2 ideal graph kvn parents: 418 diff changeset	480 \
4039 5bda8dae4e14 7103784: enable some flags by default never parents: 3960 diff changeset	481 product(bool, OptimizeStringConcat, true, \
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	482 "Optimize the construction of Strings by StringBuilder") \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	483 \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	484 notproduct(bool, PrintOptimizeStringConcat, false, \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	485 "Print information about transformations performed on Strings") \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	486 \
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 245 diff changeset	487 product(intx, ValueSearchLimit, 1000, \
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 245 diff changeset	488 "Recursion limit in PhaseMacroExpand::value_from_mem_phi") \
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 245 diff changeset	489 \
0 a61af66fc99e Initial load duke parents: diff changeset	490 product(intx, MaxLabelRootDepth, 1100, \
a61af66fc99e Initial load duke parents: diff changeset	491 "Maximum times call Label_Root to prevent stack overflow") \
155 723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates kvn parents: 65 diff changeset	492 \
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates kvn parents: 65 diff changeset	493 diagnostic(intx, DominatorSearchLimit, 1000, \
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates kvn parents: 65 diff changeset	494 "Iterations limit in Node::dominates") \
418 72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	495 \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	496 product(bool, BlockLayoutByFrequency, true, \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	497 "Use edge frequencies to drive block ordering") \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	498 \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	499 product(intx, BlockLayoutMinDiamondPercentage, 20, \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	500 "Miniumum %% of a successor (predecessor) for which block layout "\
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	501 "a will allow a fork (join) in a single chain") \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	502 \
673 fbc12e71c476 6810845: Performance regression in mpegaudio on x64 kvn parents: 579 diff changeset	503 product(bool, BlockLayoutRotateLoops, true, \
418 72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	504 "Allow back branches to be fall throughs in the block layour") \
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	505 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	506 develop(bool, InlineReflectionGetCallerClass, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	507 "inline sun.reflect.Reflection.getCallerClass(), known to be part "\
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	508 "of base library DLL") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	509 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	510 develop(bool, InlineObjectCopy, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	511 "inline Object.clone and Arrays.copyOf[Range] intrinsics") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	512 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	513 develop(bool, SpecialStringCompareTo, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	514 "special version of string compareTo") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	515 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	516 develop(bool, SpecialStringIndexOf, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	517 "special version of string indexOf") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	518 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	519 develop(bool, SpecialStringEquals, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	520 "special version of string equals") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	521 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	522 develop(bool, SpecialArraysEquals, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	523 "special version of Arrays.equals(char[],char[])") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	524 \
7637 b30b3c2a0cf2 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86 kvn parents: 7473 diff changeset	525 product(bool, SpecialEncodeISOArray, true, \
b30b3c2a0cf2 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86 kvn parents: 7473 diff changeset	526 "special version of ISO_8859_1$Encoder.encodeISOArray") \
b30b3c2a0cf2 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86 kvn parents: 7473 diff changeset	527 \
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	528 develop(bool, BailoutToInterpreterForThrows, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	529 "Compiled methods which throws/catches exceptions will be " \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	530 "deopt and intp.") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	531 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	532 develop(bool, ConvertCmpD2CmpF, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	533 "Convert cmpD to cmpF when one input is constant in float range") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	534 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	535 develop(bool, ConvertFloat2IntClipping, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	536 "Convert float2int clipping idiom to integer clipping") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	537 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	538 develop(bool, Use24BitFPMode, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	539 "Set 24-bit FPU mode on a per-compile basis ") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	540 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	541 develop(bool, Use24BitFP, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	542 "use FP instructions that produce 24-bit precise results") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	543 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	544 develop(bool, MonomorphicArrayCheck, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	545 "Uncommon-trap array store checks that require full type check") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	546 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	547 notproduct(bool, TracePhaseCCP, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	548 "Print progress during Conditional Constant Propagation") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	549 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	550 develop(bool, PrintDominators, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	551 "Print out dominator trees for GVN") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	552 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	553 notproduct(bool, TraceSpilling, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	554 "Trace spilling") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	555 \
6793 9d89c76b0505 7198499: TraceTypeProfile as diagnostic option twisti parents: 6633 diff changeset	556 diagnostic(bool, TraceTypeProfile, false, \
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	557 "Trace type profile") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	558 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	559 develop(bool, PoisonOSREntry, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	560 "Detect abnormal calls to OSR code") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	561 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	562 product(bool, UseCondCardMark, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	563 "Check for already marked card before updating card table") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	564 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	565 develop(bool, SoftMatchFailure, trueInProduct, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	566 "If the DFA fails to match a node, print a message and bail out") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	567 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	568 develop(bool, InlineAccessors, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	569 "inline accessor methods (get/set)") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	570 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	571 product(intx, TypeProfileMajorReceiverPercent, 90, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	572 "% of major receiver type to all profiled receivers") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	573 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	574 notproduct(bool, TimeCompiler2, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	575 "detailed time the compiler (requires +TimeCompiler)") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	576 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	577 diagnostic(bool, PrintIntrinsics, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	578 "prints attempted and successful inlining of intrinsics") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	579 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	580 diagnostic(ccstrlist, DisableIntrinsic, "", \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	581 "do not expand intrinsics whose (internal) names appear here") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	582 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	583 develop(bool, StressReflectiveCode, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	584 "Use inexact types at allocations, etc., to test reflection") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	585 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	586 diagnostic(bool, DebugInlinedCalls, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	587 "If false, restricts profiled locations to the root method only") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	588 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	589 notproduct(bool, VerifyLoopOptimizations, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	590 "verify major loop optimizations") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	591 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	592 diagnostic(bool, ProfileDynamicTypes, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	593 "do extra type profiling and use it more aggressively") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	594 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	595 develop(bool, TraceIterativeGVN, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	596 "Print progress during Iterative Global Value Numbering") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	597 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	598 develop(bool, VerifyIterativeGVN, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	599 "Verify Def-Use modifications during sparse Iterative Global " \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	600 "Value Numbering") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	601 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	602 notproduct(bool, TraceCISCSpill, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	603 "Trace allocators use of cisc spillable instructions") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	604 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	605 product(bool, SplitIfBlocks, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	606 "Clone compares and control flow through merge points to fold " \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	607 "some branches") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	608 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	609 develop(intx, FreqCountInvocations, 1, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	610 "Scaling factor for branch frequencies (deprecated)") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	611 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	612 product(intx, AliasLevel, 3, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	613 "0 for no aliasing, 1 for oop/field/static/array split, " \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	614 "2 for class split, 3 for unique instances") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	615 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	616 develop(bool, VerifyAliases, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	617 "perform extra checks on the results of alias analysis") \
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	618 \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	619 product(bool, IncrementalInline, true, \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	620 "do post parse inlining") \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	621 \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	622 develop(bool, AlwaysIncrementalInline, false, \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	623 "do all inlining incrementally") \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	624 \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	625 product(intx, LiveNodeCountInliningCutoff, 20000, \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	626 "max number of live nodes in a method") \
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 7637 diff changeset	627 \
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 7637 diff changeset	628 diagnostic(bool, OptimizeExpensiveOps, true, \
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 7637 diff changeset	629 "Find best control for expensive operations") \
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	630
0 a61af66fc99e Initial load duke parents: diff changeset	631
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	632 C2_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG)
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	633
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	634 #endif // SHARE_VM_OPTO_C2_GLOBALS_HPP

Mercurial > hg > truffle

annotate src/share/vm/opto/c2_globals.hpp @ 9126:bc26f978b0ce