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

annotate src/share/vm/opto/c2_globals.hpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	45467c53f178
children	cd5d10655495

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10999 693e4d04fd09 8014959: assert(Compile::current()->live_nodes() < (uint)MaxNodeLimit) failed: Live Node limit exceeded limit drchase parents: 10278 diff changeset	2 * Copyright (c) 2000, 2013, 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
14391 d2907f74462e 8016586: PPC64 (part 3): basic changes for PPC64 goetz parents: 10278 diff changeset	38 #ifdef TARGET_ARCH_ppc
d2907f74462e 8016586: PPC64 (part 3): basic changes for PPC64 goetz parents: 10278 diff changeset	39 # include "c2_globals_ppc.hpp"
d2907f74462e 8016586: PPC64 (part 3): basic changes for PPC64 goetz parents: 10278 diff changeset	40 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	41 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	42 # include "c2_globals_linux.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_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	45 # include "c2_globals_solaris.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	46 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	47 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	48 # include "c2_globals_windows.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	49 #endif
14411 bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 14393 diff changeset	50 #ifdef TARGET_OS_FAMILY_aix
bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 14393 diff changeset	51 # include "c2_globals_aix.hpp"
bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 14393 diff changeset	52 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3345 diff changeset	53 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3345 diff changeset	54 # include "c2_globals_bsd.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3345 diff changeset	55 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	56
0 a61af66fc99e Initial load duke parents: diff changeset	57 //
a61af66fc99e Initial load duke parents: diff changeset	58 // Defines all globals flags used by the server compiler.
a61af66fc99e Initial load duke parents: diff changeset	59 //
a61af66fc99e Initial load duke parents: diff changeset	60
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	61 #define C2_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct) \
0 a61af66fc99e Initial load duke parents: diff changeset	62 \
8691 571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	63 develop(bool, StressLCM, false, \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	64 "Randomize instruction scheduling in LCM") \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	65 \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	66 develop(bool, StressGCM, false, \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	67 "Randomize instruction scheduling in GCM") \
571076d3c79d 8009120: Fuzz instruction scheduling in HotSpot compilers shade parents: 8048 diff changeset	68 \
0 a61af66fc99e Initial load duke parents: diff changeset	69 notproduct(intx, CompileZapFirst, 0, \
a61af66fc99e Initial load duke parents: diff changeset	70 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	71 "skip this many before compiling in zap calls") \
a61af66fc99e Initial load duke parents: diff changeset	72 \
a61af66fc99e Initial load duke parents: diff changeset	73 notproduct(intx, CompileZapLast, -1, \
a61af66fc99e Initial load duke parents: diff changeset	74 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	75 "compile this many after skipping (incl. skip count, -1 = all)") \
a61af66fc99e Initial load duke parents: diff changeset	76 \
a61af66fc99e Initial load duke parents: diff changeset	77 notproduct(intx, ZapDeadCompiledLocalsFirst, 0, \
a61af66fc99e Initial load duke parents: diff changeset	78 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	79 "skip this many before really doing it") \
a61af66fc99e Initial load duke parents: diff changeset	80 \
a61af66fc99e Initial load duke parents: diff changeset	81 notproduct(intx, ZapDeadCompiledLocalsLast, -1, \
a61af66fc99e Initial load duke parents: diff changeset	82 "If +ZapDeadCompiledLocals, " \
a61af66fc99e Initial load duke parents: diff changeset	83 "do this many after skipping (incl. skip count, -1 = all)") \
a61af66fc99e Initial load duke parents: diff changeset	84 \
a61af66fc99e Initial load duke parents: diff changeset	85 develop(intx, OptoPrologueNops, 0, \
a61af66fc99e Initial load duke parents: diff changeset	86 "Insert this many extra nop instructions " \
a61af66fc99e Initial load duke parents: diff changeset	87 "in the prologue of every nmethod") \
a61af66fc99e Initial load duke parents: diff changeset	88 \
a61af66fc99e Initial load duke parents: diff changeset	89 product_pd(intx, InteriorEntryAlignment, \
a61af66fc99e Initial load duke parents: diff changeset	90 "Code alignment for interior entry points " \
a61af66fc99e Initial load duke parents: diff changeset	91 "in generated code (in bytes)") \
a61af66fc99e Initial load duke parents: diff changeset	92 \
a61af66fc99e Initial load duke parents: diff changeset	93 product(intx, MaxLoopPad, (OptoLoopAlignment-1), \
a61af66fc99e Initial load duke parents: diff changeset	94 "Align a loop if padding size in bytes is less or equal to this value") \
a61af66fc99e Initial load duke parents: diff changeset	95 \
6179 8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	96 product(intx, MaxVectorSize, 32, \
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	97 "Max vector size in bytes, " \
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	98 "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	99 \
6794 8ae8f9dd7099 7199010: incorrect vector alignment kvn parents: 6793 diff changeset	100 product(bool, AlignVector, true, \
6179 8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	101 "Perform vector store/load alignment in loop") \
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 5948 diff changeset	102 \
0 a61af66fc99e Initial load duke parents: diff changeset	103 product(intx, NumberOfLoopInstrToAlign, 4, \
a61af66fc99e Initial load duke parents: diff changeset	104 "Number of first instructions in a loop to align") \
a61af66fc99e Initial load duke parents: diff changeset	105 \
a61af66fc99e Initial load duke parents: diff changeset	106 notproduct(intx, IndexSetWatch, 0, \
a61af66fc99e Initial load duke parents: diff changeset	107 "Trace all operations on this IndexSet (-1 means all, 0 none)") \
a61af66fc99e Initial load duke parents: diff changeset	108 \
a61af66fc99e Initial load duke parents: diff changeset	109 develop(intx, OptoNodeListSize, 4, \
a61af66fc99e Initial load duke parents: diff changeset	110 "Starting allocation size of Node_List data structures") \
a61af66fc99e Initial load duke parents: diff changeset	111 \
a61af66fc99e Initial load duke parents: diff changeset	112 develop(intx, OptoBlockListSize, 8, \
a61af66fc99e Initial load duke parents: diff changeset	113 "Starting allocation size of Block_List data structures") \
a61af66fc99e Initial load duke parents: diff changeset	114 \
a61af66fc99e Initial load duke parents: diff changeset	115 develop(intx, OptoPeepholeAt, -1, \
a61af66fc99e Initial load duke parents: diff changeset	116 "Apply peephole optimizations to this peephole rule") \
a61af66fc99e Initial load duke parents: diff changeset	117 \
a61af66fc99e Initial load duke parents: diff changeset	118 notproduct(bool, PrintIdeal, false, \
a61af66fc99e Initial load duke parents: diff changeset	119 "Print ideal graph before code generation") \
a61af66fc99e Initial load duke parents: diff changeset	120 \
a61af66fc99e Initial load duke parents: diff changeset	121 notproduct(bool, PrintOpto, false, \
a61af66fc99e Initial load duke parents: diff changeset	122 "Print compiler2 attempts") \
a61af66fc99e Initial load duke parents: diff changeset	123 \
a61af66fc99e Initial load duke parents: diff changeset	124 notproduct(bool, PrintOptoInlining, false, \
a61af66fc99e Initial load duke parents: diff changeset	125 "Print compiler2 inlining decisions") \
a61af66fc99e Initial load duke parents: diff changeset	126 \
a61af66fc99e Initial load duke parents: diff changeset	127 notproduct(bool, VerifyOpto, false, \
a61af66fc99e Initial load duke parents: diff changeset	128 "Apply more time consuming verification during compilation") \
a61af66fc99e Initial load duke parents: diff changeset	129 \
7196 2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	130 notproduct(bool, VerifyIdealNodeCount, false, \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	131 "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	132 \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	133 notproduct(bool, PrintIdealNodeCount, false, \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	134 "Print liveness counts of ideal nodes") \
2aff40cb4703 7092905: C2: Keep track of the number of dead nodes bharadwaj parents: 6895 diff changeset	135 \
0 a61af66fc99e Initial load duke parents: diff changeset	136 notproduct(bool, VerifyOptoOopOffsets, false, \
a61af66fc99e Initial load duke parents: diff changeset	137 "Check types of base addresses in field references") \
a61af66fc99e Initial load duke parents: diff changeset	138 \
a61af66fc99e Initial load duke parents: diff changeset	139 develop(bool, IdealizedNumerics, false, \
a61af66fc99e Initial load duke parents: diff changeset	140 "Check performance difference allowing FP " \
a61af66fc99e Initial load duke parents: diff changeset	141 "associativity and commutativity...") \
a61af66fc99e Initial load duke parents: diff changeset	142 \
a61af66fc99e Initial load duke parents: diff changeset	143 develop(bool, OptoBreakpoint, false, \
a61af66fc99e Initial load duke parents: diff changeset	144 "insert breakpoint at method entry") \
a61af66fc99e Initial load duke parents: diff changeset	145 \
a61af66fc99e Initial load duke parents: diff changeset	146 notproduct(bool, OptoBreakpointOSR, false, \
a61af66fc99e Initial load duke parents: diff changeset	147 "insert breakpoint at osr method entry") \
a61af66fc99e Initial load duke parents: diff changeset	148 \
a61af66fc99e Initial load duke parents: diff changeset	149 notproduct(intx, BreakAtNode, 0, \
a61af66fc99e Initial load duke parents: diff changeset	150 "Break at construction of this Node (either _idx or _debug_idx)") \
a61af66fc99e Initial load duke parents: diff changeset	151 \
a61af66fc99e Initial load duke parents: diff changeset	152 notproduct(bool, OptoBreakpointC2R, false, \
a61af66fc99e Initial load duke parents: diff changeset	153 "insert breakpoint at runtime stub entry") \
a61af66fc99e Initial load duke parents: diff changeset	154 \
a61af66fc99e Initial load duke parents: diff changeset	155 notproduct(bool, OptoNoExecute, false, \
a61af66fc99e Initial load duke parents: diff changeset	156 "Attempt to parse and compile but do not execute generated code") \
a61af66fc99e Initial load duke parents: diff changeset	157 \
a61af66fc99e Initial load duke parents: diff changeset	158 notproduct(bool, PrintOptoStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	159 "Print New compiler statistics") \
a61af66fc99e Initial load duke parents: diff changeset	160 \
a61af66fc99e Initial load duke parents: diff changeset	161 notproduct(bool, PrintOptoAssembly, false, \
a61af66fc99e Initial load duke parents: diff changeset	162 "Print New compiler assembly output") \
a61af66fc99e Initial load duke parents: diff changeset	163 \
a61af66fc99e Initial load duke parents: diff changeset	164 develop_pd(bool, OptoPeephole, \
a61af66fc99e Initial load duke parents: diff changeset	165 "Apply peephole optimizations after register allocation") \
a61af66fc99e Initial load duke parents: diff changeset	166 \
a61af66fc99e Initial load duke parents: diff changeset	167 develop(bool, OptoRemoveUseless, true, \
a61af66fc99e Initial load duke parents: diff changeset	168 "Remove useless nodes after parsing") \
a61af66fc99e Initial load duke parents: diff changeset	169 \
a61af66fc99e Initial load duke parents: diff changeset	170 notproduct(bool, PrintFrameConverterAssembly, false, \
a61af66fc99e Initial load duke parents: diff changeset	171 "Print New compiler assembly output for frame converters") \
a61af66fc99e Initial load duke parents: diff changeset	172 \
a61af66fc99e Initial load duke parents: diff changeset	173 notproduct(bool, PrintParseStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	174 "Print nodes, transforms and new values made per bytecode parsed")\
a61af66fc99e Initial load duke parents: diff changeset	175 \
a61af66fc99e Initial load duke parents: diff changeset	176 notproduct(bool, PrintOptoPeephole, false, \
a61af66fc99e Initial load duke parents: diff changeset	177 "Print New compiler peephole replacements") \
a61af66fc99e Initial load duke parents: diff changeset	178 \
a61af66fc99e Initial load duke parents: diff changeset	179 develop(bool, PrintCFGBlockFreq, false, \
a61af66fc99e Initial load duke parents: diff changeset	180 "Print CFG block freqencies") \
a61af66fc99e Initial load duke parents: diff changeset	181 \
a61af66fc99e Initial load duke parents: diff changeset	182 develop(bool, TraceOptoParse, false, \
a61af66fc99e Initial load duke parents: diff changeset	183 "Trace bytecode parse and control-flow merge") \
a61af66fc99e Initial load duke parents: diff changeset	184 \
a61af66fc99e Initial load duke parents: diff changeset	185 product_pd(intx, LoopUnrollLimit, \
a61af66fc99e Initial load duke parents: diff changeset	186 "Unroll loop bodies with node count less than this") \
a61af66fc99e Initial load duke parents: diff changeset	187 \
12027 bcc4f6f54d83 8022993: Convert MAX_UNROLL constant to LoopMaxUnroll C2 flag kvn parents: 10999 diff changeset	188 product(intx, LoopMaxUnroll, 16, \
bcc4f6f54d83 8022993: Convert MAX_UNROLL constant to LoopMaxUnroll C2 flag kvn parents: 10999 diff changeset	189 "Maximum number of unrolls for main loop") \
bcc4f6f54d83 8022993: Convert MAX_UNROLL constant to LoopMaxUnroll C2 flag kvn parents: 10999 diff changeset	190 \
0 a61af66fc99e Initial load duke parents: diff changeset	191 product(intx, LoopUnrollMin, 4, \
a61af66fc99e Initial load duke parents: diff changeset	192 "Minimum number of unroll loop bodies before checking progress" \
a61af66fc99e Initial load duke parents: diff changeset	193 "of rounds of unroll,optimize,..") \
a61af66fc99e Initial load duke parents: diff changeset	194 \
a61af66fc99e Initial load duke parents: diff changeset	195 develop(intx, UnrollLimitForProfileCheck, 1, \
a61af66fc99e Initial load duke parents: diff changeset	196 "Don't use profile_trip_cnt() to restrict unrolling until " \
a61af66fc99e Initial load duke parents: diff changeset	197 "unrolling would push the number of unrolled iterations above " \
a61af66fc99e Initial load duke parents: diff changeset	198 "UnrollLimitForProfileCheck. A higher value allows more " \
a61af66fc99e Initial load duke parents: diff changeset	199 "unrolling. Zero acts as a very large value." ) \
a61af66fc99e Initial load duke parents: diff changeset	200 \
a61af66fc99e Initial load duke parents: diff changeset	201 product(intx, MultiArrayExpandLimit, 6, \
a61af66fc99e Initial load duke parents: diff changeset	202 "Maximum number of individual allocations in an inline-expanded " \
a61af66fc99e Initial load duke parents: diff changeset	203 "multianewarray instruction") \
a61af66fc99e Initial load duke parents: diff changeset	204 \
a61af66fc99e Initial load duke parents: diff changeset	205 notproduct(bool, TraceProfileTripCount, false, \
a61af66fc99e Initial load duke parents: diff changeset	206 "Trace profile loop trip count information") \
a61af66fc99e Initial load duke parents: diff changeset	207 \
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	208 product(bool, UseLoopPredicate, true, \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	209 "Generate a predicate to select fast/slow loop versions") \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	210 \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	211 develop(bool, TraceLoopPredicate, false, \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	212 "Trace generation of loop predicates") \
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1081 diff changeset	213 \
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2192 diff changeset	214 develop(bool, TraceLoopOpts, false, \
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2192 diff changeset	215 "Trace executed loop optimizations") \
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2192 diff changeset	216 \
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	217 diagnostic(bool, LoopLimitCheck, true, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	218 "Generate a loop limits check for overflow") \
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 develop(bool, TraceLoopLimitCheck, false, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	221 "Trace generation of loop limits checks") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	222 \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	223 diagnostic(bool, RangeLimitCheck, true, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	224 "Additional overflow checks during range check elimination") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	225 \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	226 develop(bool, TraceRangeLimitCheck, false, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	227 "Trace additional overflow checks in RCE") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	228 \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	229 diagnostic(bool, UnrollLimitCheck, true, \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	230 "Additional overflow checks during loop unroll") \
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	231 \
14437 15120a36272d 8028767: PPC64: (part 121): smaller shared changes needed to build C2 goetz parents: 14428 diff changeset	232 /* OptimizeFill not yet supported on PowerPC. */ \
15120a36272d 8028767: PPC64: (part 121): smaller shared changes needed to build C2 goetz parents: 14428 diff changeset	233 product(bool, OptimizeFill, true PPC64_ONLY(&& false), \
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	234 "convert fill/copy loops into intrinsic") \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	235 \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	236 develop(bool, TraceOptimizeFill, false, \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	237 "print detailed information about fill conversion") \
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1730 diff changeset	238 \
0 a61af66fc99e Initial load duke parents: diff changeset	239 develop(bool, OptoCoalesce, true, \
a61af66fc99e Initial load duke parents: diff changeset	240 "Use Conservative Copy Coalescing in the Register Allocator") \
a61af66fc99e Initial load duke parents: diff changeset	241 \
a61af66fc99e Initial load duke parents: diff changeset	242 develop(bool, UseUniqueSubclasses, true, \
a61af66fc99e Initial load duke parents: diff changeset	243 "Narrow an abstract reference to the unique concrete subclass") \
a61af66fc99e Initial load duke parents: diff changeset	244 \
a61af66fc99e Initial load duke parents: diff changeset	245 develop(bool, UseExactTypes, true, \
a61af66fc99e Initial load duke parents: diff changeset	246 "Use exact types to eliminate array store checks and v-calls") \
a61af66fc99e Initial load duke parents: diff changeset	247 \
a61af66fc99e Initial load duke parents: diff changeset	248 product(intx, TrackedInitializationLimit, 50, \
a61af66fc99e Initial load duke parents: diff changeset	249 "When initializing fields, track up to this many words") \
a61af66fc99e Initial load duke parents: diff changeset	250 \
a61af66fc99e Initial load duke parents: diff changeset	251 product(bool, ReduceFieldZeroing, true, \
a61af66fc99e Initial load duke parents: diff changeset	252 "When initializing fields, try to avoid needless zeroing") \
a61af66fc99e Initial load duke parents: diff changeset	253 \
a61af66fc99e Initial load duke parents: diff changeset	254 product(bool, ReduceInitialCardMarks, true, \
a61af66fc99e Initial load duke parents: diff changeset	255 "When initializing fields, try to avoid needless card marks") \
a61af66fc99e Initial load duke parents: diff changeset	256 \
a61af66fc99e Initial load duke parents: diff changeset	257 product(bool, ReduceBulkZeroing, true, \
a61af66fc99e Initial load duke parents: diff changeset	258 "When bulk-initializing, try to avoid needless zeroing") \
a61af66fc99e Initial load duke parents: diff changeset	259 \
1730 f55c4f82ab9d 6978249: spill between cpu and fpu registers when those moves are fast never parents: 1685 diff changeset	260 product(bool, UseFPUForSpilling, false, \
f55c4f82ab9d 6978249: spill between cpu and fpu registers when those moves are fast never parents: 1685 diff changeset	261 "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	262 \
0 a61af66fc99e Initial load duke parents: diff changeset	263 develop_pd(intx, RegisterCostAreaRatio, \
a61af66fc99e Initial load duke parents: diff changeset	264 "Spill selection in reg allocator: scale area by (X/64K) before " \
a61af66fc99e Initial load duke parents: diff changeset	265 "adding cost") \
a61af66fc99e Initial load duke parents: diff changeset	266 \
a61af66fc99e Initial load duke parents: diff changeset	267 develop_pd(bool, UseCISCSpill, \
a61af66fc99e Initial load duke parents: diff changeset	268 "Use ADLC supplied cisc instructions during allocation") \
a61af66fc99e Initial load duke parents: diff changeset	269 \
a61af66fc99e Initial load duke parents: diff changeset	270 notproduct(bool, VerifyGraphEdges , false, \
a61af66fc99e Initial load duke parents: diff changeset	271 "Verify Bi-directional Edges") \
a61af66fc99e Initial load duke parents: diff changeset	272 \
a61af66fc99e Initial load duke parents: diff changeset	273 notproduct(bool, VerifyDUIterators, true, \
a61af66fc99e Initial load duke parents: diff changeset	274 "Verify the safety of all iterations of Bi-directional Edges") \
a61af66fc99e Initial load duke parents: diff changeset	275 \
a61af66fc99e Initial load duke parents: diff changeset	276 notproduct(bool, VerifyHashTableKeys, true, \
a61af66fc99e Initial load duke parents: diff changeset	277 "Verify the immutability of keys in the VN hash tables") \
a61af66fc99e Initial load duke parents: diff changeset	278 \
550 96964ebdb154 6782232: assert("CreateEx must be first instruction in block" ) kvn parents: 434 diff changeset	279 notproduct(bool, VerifyRegisterAllocator , false, \
96964ebdb154 6782232: assert("CreateEx must be first instruction in block" ) kvn parents: 434 diff changeset	280 "Verify Register Allocator") \
96964ebdb154 6782232: assert("CreateEx must be first instruction in block" ) kvn parents: 434 diff changeset	281 \
0 a61af66fc99e Initial load duke parents: diff changeset	282 develop_pd(intx, FLOATPRESSURE, \
a61af66fc99e Initial load duke parents: diff changeset	283 "Number of float LRG's that constitute high register pressure") \
a61af66fc99e Initial load duke parents: diff changeset	284 \
a61af66fc99e Initial load duke parents: diff changeset	285 develop_pd(intx, INTPRESSURE, \
a61af66fc99e Initial load duke parents: diff changeset	286 "Number of integer LRG's that constitute high register pressure") \
a61af66fc99e Initial load duke parents: diff changeset	287 \
a61af66fc99e Initial load duke parents: diff changeset	288 notproduct(bool, TraceOptoPipelining, false, \
a61af66fc99e Initial load duke parents: diff changeset	289 "Trace pipelining information") \
a61af66fc99e Initial load duke parents: diff changeset	290 \
a61af66fc99e Initial load duke parents: diff changeset	291 notproduct(bool, TraceOptoOutput, false, \
a61af66fc99e Initial load duke parents: diff changeset	292 "Trace pipelining information") \
a61af66fc99e Initial load duke parents: diff changeset	293 \
a61af66fc99e Initial load duke parents: diff changeset	294 product_pd(bool, OptoScheduling, \
a61af66fc99e Initial load duke parents: diff changeset	295 "Instruction Scheduling after register allocation") \
a61af66fc99e Initial load duke parents: diff changeset	296 \
a61af66fc99e Initial load duke parents: diff changeset	297 product(bool, PartialPeelLoop, true, \
a61af66fc99e Initial load duke parents: diff changeset	298 "Partial peel (rotate) loops") \
a61af66fc99e Initial load duke parents: diff changeset	299 \
a61af66fc99e Initial load duke parents: diff changeset	300 product(intx, PartialPeelNewPhiDelta, 0, \
a61af66fc99e Initial load duke parents: diff changeset	301 "Additional phis that can be created by partial peeling") \
a61af66fc99e Initial load duke parents: diff changeset	302 \
a61af66fc99e Initial load duke parents: diff changeset	303 notproduct(bool, TracePartialPeeling, false, \
a61af66fc99e Initial load duke parents: diff changeset	304 "Trace partial peeling (loop rotation) information") \
a61af66fc99e Initial load duke parents: diff changeset	305 \
a61af66fc99e Initial load duke parents: diff changeset	306 product(bool, PartialPeelAtUnsignedTests, true, \
a61af66fc99e Initial load duke parents: diff changeset	307 "Partial peel at unsigned tests if no signed test exists") \
a61af66fc99e Initial load duke parents: diff changeset	308 \
a61af66fc99e Initial load duke parents: diff changeset	309 product(bool, ReassociateInvariants, true, \
a61af66fc99e Initial load duke parents: diff changeset	310 "Enable reassociation of expressions with loop invariants.") \
a61af66fc99e Initial load duke parents: diff changeset	311 \
a61af66fc99e Initial load duke parents: diff changeset	312 product(bool, LoopUnswitching, true, \
a61af66fc99e Initial load duke parents: diff changeset	313 "Enable loop unswitching (a form of invariant test hoisting)") \
a61af66fc99e Initial load duke parents: diff changeset	314 \
a61af66fc99e Initial load duke parents: diff changeset	315 notproduct(bool, TraceLoopUnswitching, false, \
a61af66fc99e Initial load duke parents: diff changeset	316 "Trace loop unswitching") \
a61af66fc99e Initial load duke parents: diff changeset	317 \
a61af66fc99e Initial load duke parents: diff changeset	318 product(bool, UseSuperWord, true, \
a61af66fc99e Initial load duke parents: diff changeset	319 "Transform scalar operations into superword operations") \
a61af66fc99e Initial load duke parents: diff changeset	320 \
a61af66fc99e Initial load duke parents: diff changeset	321 develop(bool, SuperWordRTDepCheck, false, \
a61af66fc99e Initial load duke parents: diff changeset	322 "Enable runtime dependency checks.") \
a61af66fc99e Initial load duke parents: diff changeset	323 \
6183 6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	324 notproduct(bool, TraceSuperWord, false, \
0 a61af66fc99e Initial load duke parents: diff changeset	325 "Trace superword transforms") \
a61af66fc99e Initial load duke parents: diff changeset	326 \
6183 6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	327 notproduct(bool, TraceNewVectors, false, \
6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	328 "Trace creation of Vector nodes") \
6f8f439e247d 7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear() kvn parents: 6179 diff changeset	329 \
0 a61af66fc99e Initial load duke parents: diff changeset	330 product_pd(bool, OptoBundling, \
a61af66fc99e Initial load duke parents: diff changeset	331 "Generate nops to fill i-cache lines") \
a61af66fc99e Initial load duke parents: diff changeset	332 \
a61af66fc99e Initial load duke parents: diff changeset	333 product_pd(intx, ConditionalMoveLimit, \
a61af66fc99e Initial load duke parents: diff changeset	334 "Limit of ops to make speculative when using CMOVE") \
a61af66fc99e Initial load duke parents: diff changeset	335 \
a61af66fc99e Initial load duke parents: diff changeset	336 /* Set BranchOnRegister == false. See 4965987. */ \
a61af66fc99e Initial load duke parents: diff changeset	337 product(bool, BranchOnRegister, false, \
a61af66fc99e Initial load duke parents: diff changeset	338 "Use Sparc V9 branch-on-register opcodes") \
a61af66fc99e Initial load duke parents: diff changeset	339 \
a61af66fc99e Initial load duke parents: diff changeset	340 develop(bool, SparcV9RegsHiBitsZero, true, \
a61af66fc99e Initial load duke parents: diff changeset	341 "Assume Sparc V9 I&L registers on V8+ systems are zero-extended") \
a61af66fc99e Initial load duke parents: diff changeset	342 \
2008 2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	343 product(bool, UseRDPCForConstantTableBase, false, \
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	344 "Use Sparc RDPC instruction for the constant table base.") \
2f644f85485d 6961690: load oops from constant table on SPARC twisti parents: 1972 diff changeset	345 \
0 a61af66fc99e Initial load duke parents: diff changeset	346 develop(intx, PrintIdealGraphLevel, 0, \
a61af66fc99e Initial load duke parents: diff changeset	347 "Print ideal graph to XML file / network interface. " \
a61af66fc99e Initial load duke parents: diff changeset	348 "By default attempts to connect to the visualizer on a socket.") \
a61af66fc99e Initial load duke parents: diff changeset	349 \
a61af66fc99e Initial load duke parents: diff changeset	350 develop(intx, PrintIdealGraphPort, 4444, \
a61af66fc99e Initial load duke parents: diff changeset	351 "Ideal graph printer to network port") \
a61af66fc99e Initial load duke parents: diff changeset	352 \
434 de78b80cedec 6772413: code cleanup kvn parents: 420 diff changeset	353 notproduct(ccstr, PrintIdealGraphAddress, "127.0.0.1", \
0 a61af66fc99e Initial load duke parents: diff changeset	354 "IP address to connect to visualizer") \
a61af66fc99e Initial load duke parents: diff changeset	355 \
434 de78b80cedec 6772413: code cleanup kvn parents: 420 diff changeset	356 notproduct(ccstr, PrintIdealGraphFile, NULL, \
0 a61af66fc99e Initial load duke parents: diff changeset	357 "File to dump ideal graph to. If set overrides the " \
a61af66fc99e Initial load duke parents: diff changeset	358 "use of the network") \
a61af66fc99e Initial load duke parents: diff changeset	359 \
a61af66fc99e Initial load duke parents: diff changeset	360 product(bool, UseBimorphicInlining, true, \
a61af66fc99e Initial load duke parents: diff changeset	361 "Profiling based inlining for two receivers") \
a61af66fc99e Initial load duke parents: diff changeset	362 \
a61af66fc99e Initial load duke parents: diff changeset	363 product(bool, UseOnlyInlinedBimorphic, true, \
a61af66fc99e Initial load duke parents: diff changeset	364 "Don't use BimorphicInlining if can't inline a second method") \
a61af66fc99e Initial load duke parents: diff changeset	365 \
a61af66fc99e Initial load duke parents: diff changeset	366 product(bool, InsertMemBarAfterArraycopy, true, \
a61af66fc99e Initial load duke parents: diff changeset	367 "Insert memory barrier after arraycopy call") \
a61af66fc99e Initial load duke parents: diff changeset	368 \
1685 0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	369 develop(bool, SubsumeLoads, true, \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	370 "Attempt to compile while subsuming loads into machine instructions.") \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	371 \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	372 develop(bool, StressRecompilation, false, \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	373 "Recompile each compiled method without subsuming loads or escape analysis.") \
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	374 \
0 a61af66fc99e Initial load duke parents: diff changeset	375 develop(intx, ImplicitNullCheckThreshold, 3, \
a61af66fc99e Initial load duke parents: diff changeset	376 "Don't do implicit null checks if NPE's in a method exceeds limit") \
a61af66fc99e Initial load duke parents: diff changeset	377 \
a61af66fc99e Initial load duke parents: diff changeset	378 product(intx, LoopOptsCount, 43, \
a61af66fc99e Initial load duke parents: diff changeset	379 "Set level of loop optimization for tier 1 compiles") \
a61af66fc99e Initial load duke parents: diff changeset	380 \
a61af66fc99e Initial load duke parents: diff changeset	381 /* controls for heat-based inlining */ \
a61af66fc99e Initial load duke parents: diff changeset	382 \
a61af66fc99e Initial load duke parents: diff changeset	383 develop(intx, NodeCountInliningCutoff, 18000, \
a61af66fc99e Initial load duke parents: diff changeset	384 "If parser node generation exceeds limit stop inlining") \
a61af66fc99e Initial load duke parents: diff changeset	385 \
a61af66fc99e Initial load duke parents: diff changeset	386 develop(intx, NodeCountInliningStep, 1000, \
a61af66fc99e Initial load duke parents: diff changeset	387 "Target size of warm calls inlined between optimization passes") \
a61af66fc99e Initial load duke parents: diff changeset	388 \
a61af66fc99e Initial load duke parents: diff changeset	389 develop(bool, InlineWarmCalls, false, \
a61af66fc99e Initial load duke parents: diff changeset	390 "Use a heat-based priority queue to govern inlining") \
a61af66fc99e Initial load duke parents: diff changeset	391 \
a61af66fc99e Initial load duke parents: diff changeset	392 develop(intx, HotCallCountThreshold, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	393 "large numbers of calls (per method invocation) force hotness") \
a61af66fc99e Initial load duke parents: diff changeset	394 \
a61af66fc99e Initial load duke parents: diff changeset	395 develop(intx, HotCallProfitThreshold, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	396 "highly profitable inlining opportunities force hotness") \
a61af66fc99e Initial load duke parents: diff changeset	397 \
a61af66fc99e Initial load duke parents: diff changeset	398 develop(intx, HotCallTrivialWork, -1, \
a61af66fc99e Initial load duke parents: diff changeset	399 "trivial execution time (no larger than this) forces hotness") \
a61af66fc99e Initial load duke parents: diff changeset	400 \
a61af66fc99e Initial load duke parents: diff changeset	401 develop(intx, HotCallTrivialSize, -1, \
a61af66fc99e Initial load duke parents: diff changeset	402 "trivial methods (no larger than this) force calls to be hot") \
a61af66fc99e Initial load duke parents: diff changeset	403 \
a61af66fc99e Initial load duke parents: diff changeset	404 develop(intx, WarmCallMinCount, -1, \
a61af66fc99e Initial load duke parents: diff changeset	405 "number of calls (per method invocation) to enable inlining") \
a61af66fc99e Initial load duke parents: diff changeset	406 \
a61af66fc99e Initial load duke parents: diff changeset	407 develop(intx, WarmCallMinProfit, -1, \
a61af66fc99e Initial load duke parents: diff changeset	408 "number of calls (per method invocation) to enable inlining") \
a61af66fc99e Initial load duke parents: diff changeset	409 \
a61af66fc99e Initial load duke parents: diff changeset	410 develop(intx, WarmCallMaxWork, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	411 "execution time of the largest inlinable method") \
a61af66fc99e Initial load duke parents: diff changeset	412 \
a61af66fc99e Initial load duke parents: diff changeset	413 develop(intx, WarmCallMaxSize, 999999, \
a61af66fc99e Initial load duke parents: diff changeset	414 "size of the largest inlinable method") \
a61af66fc99e Initial load duke parents: diff changeset	415 \
10999 693e4d04fd09 8014959: assert(Compile::current()->live_nodes() < (uint)MaxNodeLimit) failed: Live Node limit exceeded limit drchase parents: 10278 diff changeset	416 product(intx, MaxNodeLimit, 80000, \
0 a61af66fc99e Initial load duke parents: diff changeset	417 "Maximum number of nodes") \
a61af66fc99e Initial load duke parents: diff changeset	418 \
10999 693e4d04fd09 8014959: assert(Compile::current()->live_nodes() < (uint)MaxNodeLimit) failed: Live Node limit exceeded limit drchase parents: 10278 diff changeset	419 product(intx, NodeLimitFudgeFactor, 2000, \
0 a61af66fc99e Initial load duke parents: diff changeset	420 "Fudge Factor for certain optimizations") \
a61af66fc99e Initial load duke parents: diff changeset	421 \
a61af66fc99e Initial load duke parents: diff changeset	422 product(bool, UseJumpTables, true, \
a61af66fc99e Initial load duke parents: diff changeset	423 "Use JumpTables instead of a binary search tree for switches") \
a61af66fc99e Initial load duke parents: diff changeset	424 \
a61af66fc99e Initial load duke parents: diff changeset	425 product(bool, UseDivMod, true, \
a61af66fc99e Initial load duke parents: diff changeset	426 "Use combined DivMod instruction if available") \
a61af66fc99e Initial load duke parents: diff changeset	427 \
12192 34bd5e86aadb 8010941: MinJumpTableSize is set to 18, investigate if that's still optimal adlertz parents: 12190 diff changeset	428 product_pd(intx, MinJumpTableSize, \
0 a61af66fc99e Initial load duke parents: diff changeset	429 "Minimum number of targets in a generated jump table") \
a61af66fc99e Initial load duke parents: diff changeset	430 \
a61af66fc99e Initial load duke parents: diff changeset	431 product(intx, MaxJumpTableSize, 65000, \
a61af66fc99e Initial load duke parents: diff changeset	432 "Maximum number of targets in a generated jump table") \
a61af66fc99e Initial load duke parents: diff changeset	433 \
a61af66fc99e Initial load duke parents: diff changeset	434 product(intx, MaxJumpTableSparseness, 5, \
a61af66fc99e Initial load duke parents: diff changeset	435 "Maximum sparseness for jumptables") \
a61af66fc99e Initial load duke parents: diff changeset	436 \
a61af66fc99e Initial load duke parents: diff changeset	437 product(bool, EliminateLocks, true, \
a61af66fc99e Initial load duke parents: diff changeset	438 "Coarsen locks when possible") \
a61af66fc99e Initial load duke parents: diff changeset	439 \
4777 e9a5e0a812c8 7125896: Eliminate nested locks kvn parents: 4113 diff changeset	440 product(bool, EliminateNestedLocks, true, \
e9a5e0a812c8 7125896: Eliminate nested locks kvn parents: 4113 diff changeset	441 "Eliminate nested locks of the same object when possible") \
e9a5e0a812c8 7125896: Eliminate nested locks kvn parents: 4113 diff changeset	442 \
0 a61af66fc99e Initial load duke parents: diff changeset	443 notproduct(bool, PrintLockStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	444 "Print precise statistics on the dynamic lock usage") \
a61af66fc99e Initial load duke parents: diff changeset	445 \
a61af66fc99e Initial load duke parents: diff changeset	446 diagnostic(bool, PrintPreciseBiasedLockingStatistics, false, \
a61af66fc99e Initial load duke parents: diff changeset	447 "Print per-lock-site statistics of biased locking in JVM") \
a61af66fc99e Initial load duke parents: diff changeset	448 \
a61af66fc99e Initial load duke parents: diff changeset	449 notproduct(bool, PrintEliminateLocks, false, \
a61af66fc99e Initial load duke parents: diff changeset	450 "Print out when locks are eliminated") \
a61af66fc99e Initial load duke parents: diff changeset	451 \
10278 6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default kvn parents: 8691 diff changeset	452 product(bool, EliminateAutoBox, true, \
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default kvn parents: 8691 diff changeset	453 "Control optimizations for autobox elimination") \
17 ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	454 \
12190 edb5ab0f3fe5 8001107: @Stable annotation for constant folding of lazily evaluated variables vlivanov parents: 12027 diff changeset	455 experimental(bool, UseImplicitStableValues, false, \
edb5ab0f3fe5 8001107: @Stable annotation for constant folding of lazily evaluated variables vlivanov parents: 12027 diff changeset	456 "Mark well-known stable fields as such (e.g. String.value)") \
edb5ab0f3fe5 8001107: @Stable annotation for constant folding of lazily evaluated variables vlivanov parents: 12027 diff changeset	457 \
17 ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	458 product(intx, AutoBoxCacheMax, 128, \
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	459 "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	460 \
10278 6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default kvn parents: 8691 diff changeset	461 experimental(bool, AggressiveUnboxing, false, \
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default kvn parents: 8691 diff changeset	462 "Control optimizations for aggressive boxing elimination") \
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default kvn parents: 8691 diff changeset	463 \
14428 044b28168e20 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation goetz parents: 14422 diff changeset	464 develop(bool, TracePostallocExpand, false, "Trace expanding nodes after" \
044b28168e20 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation goetz parents: 14422 diff changeset	465 " register allocation.") \
044b28168e20 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation goetz parents: 14422 diff changeset	466 \
930 357d4e2eb4dd 6873799: enable escape analysis by default kvn parents: 673 diff changeset	467 product(bool, DoEscapeAnalysis, true, \
0 a61af66fc99e Initial load duke parents: diff changeset	468 "Perform escape analysis") \
a61af66fc99e Initial load duke parents: diff changeset	469 \
6895 006174cfe979 7163534: VM could crashes assert(false) failed: infinite EA connection graph build kvn parents: 6794 diff changeset	470 develop(bool, ExitEscapeAnalysisOnTimeout, true, \
006174cfe979 7163534: VM could crashes assert(false) failed: infinite EA connection graph build kvn parents: 6794 diff changeset	471 "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	472 \
0 a61af66fc99e Initial load duke parents: diff changeset	473 notproduct(bool, PrintEscapeAnalysis, false, \
a61af66fc99e Initial load duke parents: diff changeset	474 "Print the results of escape analysis") \
a61af66fc99e Initial load duke parents: diff changeset	475 \
a61af66fc99e Initial load duke parents: diff changeset	476 product(bool, EliminateAllocations, true, \
a61af66fc99e Initial load duke parents: diff changeset	477 "Use escape analysis to eliminate allocations") \
a61af66fc99e Initial load duke parents: diff changeset	478 \
65 99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	479 notproduct(bool, PrintEliminateAllocations, false, \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	480 "Print out when allocations are eliminated") \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	481 \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	482 product(intx, EliminateAllocationArraySizeLimit, 64, \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	483 "Array size (number of elements) limit for scalar replacement") \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code kvn parents: 17 diff changeset	484 \
4113 8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	485 product(bool, OptimizePtrCompare, true, \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	486 "Use escape analysis to optimize pointers compare") \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	487 \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	488 notproduct(bool, PrintOptimizePtrCompare, false, \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	489 "Print information about optimized pointers compare") \
8c57262447d3 7105605: Use EA info to optimize pointers compare kvn parents: 4039 diff changeset	490 \
5948 ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build kvn parents: 4777 diff changeset	491 notproduct(bool, VerifyConnectionGraph , true, \
ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build kvn parents: 4777 diff changeset	492 "Verify Connection Graph construction in Escape Analysis") \
ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build kvn parents: 4777 diff changeset	493 \
673 fbc12e71c476 6810845: Performance regression in mpegaudio on x64 kvn parents: 579 diff changeset	494 product(bool, UseOptoBiasInlining, true, \
420 a1980da045cc 6462850: generate biased locking code in C2 ideal graph kvn parents: 418 diff changeset	495 "Generate biased locking code in C2 ideal graph") \
a1980da045cc 6462850: generate biased locking code in C2 ideal graph kvn parents: 418 diff changeset	496 \
4039 5bda8dae4e14 7103784: enable some flags by default never parents: 3960 diff changeset	497 product(bool, OptimizeStringConcat, true, \
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	498 "Optimize the construction of Strings by StringBuilder") \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	499 \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	500 notproduct(bool, PrintOptimizeStringConcat, false, \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	501 "Print information about transformations performed on Strings") \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	502 \
253 b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 245 diff changeset	503 product(intx, ValueSearchLimit, 1000, \
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.") kvn parents: 245 diff changeset	504 "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	505 \
0 a61af66fc99e Initial load duke parents: diff changeset	506 product(intx, MaxLabelRootDepth, 1100, \
a61af66fc99e Initial load duke parents: diff changeset	507 "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	508 \
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates kvn parents: 65 diff changeset	509 diagnostic(intx, DominatorSearchLimit, 1000, \
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates kvn parents: 65 diff changeset	510 "Iterations limit in Node::dominates") \
418 72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	511 \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	512 product(bool, BlockLayoutByFrequency, true, \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	513 "Use edge frequencies to drive block ordering") \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	514 \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	515 product(intx, BlockLayoutMinDiamondPercentage, 20, \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	516 "Miniumum %% of a successor (predecessor) for which block layout "\
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	517 "a will allow a fork (join) in a single chain") \
72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	518 \
673 fbc12e71c476 6810845: Performance regression in mpegaudio on x64 kvn parents: 579 diff changeset	519 product(bool, BlockLayoutRotateLoops, true, \
418 72c5366e5d86 6743900: frequency based block layout rasbold parents: 257 diff changeset	520 "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	521 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	522 develop(bool, InlineReflectionGetCallerClass, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	523 "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	524 "of base library DLL") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	525 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	526 develop(bool, InlineObjectCopy, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	527 "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	528 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	529 develop(bool, SpecialStringCompareTo, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	530 "special version of string compareTo") \
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, SpecialStringIndexOf, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	533 "special version of string indexOf") \
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, SpecialStringEquals, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	536 "special version of string equals") \
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, SpecialArraysEquals, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	539 "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	540 \
7637 b30b3c2a0cf2 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86 kvn parents: 7473 diff changeset	541 product(bool, SpecialEncodeISOArray, true, \
b30b3c2a0cf2 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86 kvn parents: 7473 diff changeset	542 "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	543 \
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	544 develop(bool, BailoutToInterpreterForThrows, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	545 "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	546 "deopt and intp.") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	547 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	548 develop(bool, ConvertCmpD2CmpF, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	549 "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	550 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	551 develop(bool, ConvertFloat2IntClipping, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	552 "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	553 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	554 develop(bool, Use24BitFPMode, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	555 "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	556 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	557 develop(bool, Use24BitFP, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	558 "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	559 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	560 develop(bool, MonomorphicArrayCheck, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	561 "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	562 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	563 notproduct(bool, TracePhaseCCP, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	564 "Print progress during Conditional Constant Propagation") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	565 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	566 develop(bool, PrintDominators, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	567 "Print out dominator trees for GVN") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	568 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	569 notproduct(bool, TraceSpilling, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	570 "Trace spilling") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	571 \
6793 9d89c76b0505 7198499: TraceTypeProfile as diagnostic option twisti parents: 6633 diff changeset	572 diagnostic(bool, TraceTypeProfile, false, \
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	573 "Trace type profile") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	574 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	575 develop(bool, PoisonOSREntry, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	576 "Detect abnormal calls to OSR code") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	577 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	578 product(bool, UseCondCardMark, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	579 "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	580 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	581 develop(bool, SoftMatchFailure, trueInProduct, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	582 "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	583 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	584 develop(bool, InlineAccessors, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	585 "inline accessor methods (get/set)") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	586 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	587 product(intx, TypeProfileMajorReceiverPercent, 90, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	588 "% 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	589 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	590 notproduct(bool, TimeCompiler2, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	591 "detailed time the compiler (requires +TimeCompiler)") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	592 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	593 diagnostic(bool, PrintIntrinsics, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	594 "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	595 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	596 diagnostic(ccstrlist, DisableIntrinsic, "", \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	597 "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	598 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	599 develop(bool, StressReflectiveCode, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	600 "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	601 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	602 diagnostic(bool, DebugInlinedCalls, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	603 "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	604 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	605 notproduct(bool, VerifyLoopOptimizations, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	606 "verify major loop optimizations") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	607 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	608 diagnostic(bool, ProfileDynamicTypes, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	609 "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	610 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	611 develop(bool, TraceIterativeGVN, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	612 "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	613 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	614 develop(bool, VerifyIterativeGVN, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	615 "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	616 "Value Numbering") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	617 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	618 notproduct(bool, TraceCISCSpill, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	619 "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	620 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	621 product(bool, SplitIfBlocks, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	622 "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	623 "some branches") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	624 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	625 develop(intx, FreqCountInvocations, 1, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	626 "Scaling factor for branch frequencies (deprecated)") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	627 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	628 product(intx, AliasLevel, 3, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	629 "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	630 "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	631 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	632 develop(bool, VerifyAliases, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6183 diff changeset	633 "perform extra checks on the results of alias analysis") \
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	634 \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	635 product(bool, IncrementalInline, true, \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	636 "do post parse inlining") \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	637 \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	638 develop(bool, AlwaysIncrementalInline, false, \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	639 "do all inlining incrementally") \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	640 \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	641 product(intx, LiveNodeCountInliningCutoff, 20000, \
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7196 diff changeset	642 "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	643 \
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 7637 diff changeset	644 diagnostic(bool, OptimizeExpensiveOps, true, \
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 7637 diff changeset	645 "Find best control for expensive operations") \
12323 c9ccd7b85f20 8024924: Intrinsify java.lang.Math.addExact rbackman parents: 12192 diff changeset	646 \
13421 9949533a8623 8028997: mathexact intrinsics are unstable rbackman parents: 12966 diff changeset	647 experimental(bool, UseMathExactIntrinsics, false, \
12956 3213ba4d3dff 8024069: replace_in_map() should operate on parent maps roland parents: 12323 diff changeset	648 "Enables intrinsification of various java.lang.Math functions") \
3213ba4d3dff 8024069: replace_in_map() should operate on parent maps roland parents: 12323 diff changeset	649 \
3213ba4d3dff 8024069: replace_in_map() should operate on parent maps roland parents: 12323 diff changeset	650 experimental(bool, ReplaceInParentMaps, false, \
12966 b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12956 diff changeset	651 "Propagate type improvements in callers of inlinee if possible") \
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12956 diff changeset	652 \
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12956 diff changeset	653 experimental(bool, UseTypeSpeculation, false, \
14440 41b780b43b74 8029015: PPC64 (part 216): opto: trap based null and range checks goetz parents: 14437 diff changeset	654 "Speculatively propagate types from profiles") \
41b780b43b74 8029015: PPC64 (part 216): opto: trap based null and range checks goetz parents: 14437 diff changeset	655 \
41b780b43b74 8029015: PPC64 (part 216): opto: trap based null and range checks goetz parents: 14437 diff changeset	656 product_pd(bool, TrapBasedRangeChecks, \
41b780b43b74 8029015: PPC64 (part 216): opto: trap based null and range checks goetz parents: 14437 diff changeset	657 "Generate code for range checks that uses a cmp and trap " \
41b780b43b74 8029015: PPC64 (part 216): opto: trap based null and range checks goetz parents: 14437 diff changeset	658 "instruction raising SIGTRAP. Used on PPC64.") \
0 a61af66fc99e Initial load duke parents: diff changeset	659
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 930 diff changeset	660 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	661
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	662 #endif // SHARE_VM_OPTO_C2_GLOBALS_HPP

Mercurial > hg > truffle

annotate src/share/vm/opto/c2_globals.hpp @ 14649:f6301b007a16