Mercurial > hg > truffle

annotate src/share/vm/opto/c2_globals.hpp @ 10278:6f3fd5150b67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6934604: enable parts of EliminateAutoBox by default Summary: Resurrected autobox elimination code and enabled part of it by default. Reviewed-by: roland, twisti
author kvn
date Wed, 08 May 2013 15:08:01 -0700
parents 571076d3c79d
children 693e4d04fd09 d2907f74462e
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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 \
10278
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 8691
diff changeset
445 product(bool, EliminateAutoBox, true, \
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 8691
diff changeset
446 "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
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 \
10278
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 8691
diff changeset
451 experimental(bool, AggressiveUnboxing, false, \
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 8691
diff changeset
452 "Control optimizations for aggressive boxing elimination") \
6f3fd5150b67 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 8691
diff changeset
453 \
930
357d4e2eb4dd 6873799: enable escape analysis by default
kvn
parents: 673
diff changeset
454 product(bool, DoEscapeAnalysis, true, \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
455 "Perform escape analysis") \
a61af66fc99e Initial load
duke
parents:
diff changeset
456 \
6895
006174cfe979 7163534: VM could crashes assert(false) failed: infinite EA connection graph build
kvn
parents: 6794
diff changeset
457 develop(bool, ExitEscapeAnalysisOnTimeout, true, \
006174cfe979 7163534: VM could crashes assert(false) failed: infinite EA connection graph build
kvn
parents: 6794
diff changeset
458 "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
459 \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
460 notproduct(bool, PrintEscapeAnalysis, false, \
a61af66fc99e Initial load
duke
parents:
diff changeset
461 "Print the results of escape analysis") \
a61af66fc99e Initial load
duke
parents:
diff changeset
462 \
a61af66fc99e Initial load
duke
parents:
diff changeset
463 product(bool, EliminateAllocations, true, \
a61af66fc99e Initial load
duke
parents:
diff changeset
464 "Use escape analysis to eliminate allocations") \
a61af66fc99e Initial load
duke
parents:
diff changeset
465 \
65
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 17
diff changeset
466 notproduct(bool, PrintEliminateAllocations, false, \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 17
diff changeset
467 "Print out when allocations are eliminated") \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 17
diff changeset
468 \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 17
diff changeset
469 product(intx, EliminateAllocationArraySizeLimit, 64, \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 17
diff changeset
470 "Array size (number of elements) limit for scalar replacement") \
99269dbf4ba8 6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents: 17
diff changeset
471 \
4113
8c57262447d3 7105605: Use EA info to optimize pointers compare
kvn
parents: 4039
diff changeset
472 product(bool, OptimizePtrCompare, true, \
8c57262447d3 7105605: Use EA info to optimize pointers compare
kvn
parents: 4039
diff changeset
473 "Use escape analysis to optimize pointers compare") \
8c57262447d3 7105605: Use EA info to optimize pointers compare
kvn
parents: 4039
diff changeset
474 \
8c57262447d3 7105605: Use EA info to optimize pointers compare
kvn
parents: 4039
diff changeset
475 notproduct(bool, PrintOptimizePtrCompare, false, \
8c57262447d3 7105605: Use EA info to optimize pointers compare
kvn
parents: 4039
diff changeset
476 "Print information about optimized pointers compare") \
8c57262447d3 7105605: Use EA info to optimize pointers compare
kvn
parents: 4039
diff changeset
477 \
5948
ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents: 4777
diff changeset
478 notproduct(bool, VerifyConnectionGraph , true, \
ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents: 4777
diff changeset
479 "Verify Connection Graph construction in Escape Analysis") \
ee138854b3a6 7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents: 4777
diff changeset
480 \
673
fbc12e71c476 6810845: Performance regression in mpegaudio on x64
kvn
parents: 579
diff changeset
481 product(bool, UseOptoBiasInlining, true, \
420
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 418
diff changeset
482 "Generate biased locking code in C2 ideal graph") \
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 418
diff changeset
483 \
4039
5bda8dae4e14 7103784: enable some flags by default
never
parents: 3960
diff changeset
484 product(bool, OptimizeStringConcat, true, \
1080
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 930
diff changeset
485 "Optimize the construction of Strings by StringBuilder") \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 930
diff changeset
486 \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 930
diff changeset
487 notproduct(bool, PrintOptimizeStringConcat, false, \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 930
diff changeset
488 "Print information about transformations performed on Strings") \
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 930
diff changeset
489 \
253
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 245
diff changeset
490 product(intx, ValueSearchLimit, 1000, \
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 245
diff changeset
491 "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
492 \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
493 product(intx, MaxLabelRootDepth, 1100, \
a61af66fc99e Initial load
duke
parents:
diff changeset
494 "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
495 \
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 65
diff changeset
496 diagnostic(intx, DominatorSearchLimit, 1000, \
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 65
diff changeset
497 "Iterations limit in Node::dominates") \
418
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(bool, BlockLayoutByFrequency, true, \
72c5366e5d86 6743900: frequency based block layout
rasbold
parents: 257
diff changeset
500 "Use edge frequencies to drive block ordering") \
72c5366e5d86 6743900: frequency based block layout
rasbold
parents: 257
diff changeset
501 \
72c5366e5d86 6743900: frequency based block layout
rasbold
parents: 257
diff changeset
502 product(intx, BlockLayoutMinDiamondPercentage, 20, \
72c5366e5d86 6743900: frequency based block layout
rasbold
parents: 257
diff changeset
503 "Miniumum %% of a successor (predecessor) for which block layout "\
72c5366e5d86 6743900: frequency based block layout
rasbold
parents: 257
diff changeset
504 "a will allow a fork (join) in a single chain") \
72c5366e5d86 6743900: frequency based block layout
rasbold
parents: 257
diff changeset
505 \
673
fbc12e71c476 6810845: Performance regression in mpegaudio on x64
kvn
parents: 579
diff changeset
506 product(bool, BlockLayoutRotateLoops, true, \
418
72c5366e5d86 6743900: frequency based block layout
rasbold
parents: 257
diff changeset
507 "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
508 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
509 develop(bool, InlineReflectionGetCallerClass, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
510 "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
511 "of base library DLL") \
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, InlineObjectCopy, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
514 "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
515 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
516 develop(bool, SpecialStringCompareTo, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
517 "special version of string compareTo") \
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, SpecialStringIndexOf, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
520 "special version of string indexOf") \
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, SpecialStringEquals, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
523 "special version of string equals") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
524 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
525 develop(bool, SpecialArraysEquals, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
526 "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
527 \
7637
b30b3c2a0cf2 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 7473
diff changeset
528 product(bool, SpecialEncodeISOArray, true, \
b30b3c2a0cf2 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 7473
diff changeset
529 "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
530 \
6633
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
531 develop(bool, BailoutToInterpreterForThrows, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
532 "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
533 "deopt and intp.") \
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, ConvertCmpD2CmpF, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
536 "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
537 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
538 develop(bool, ConvertFloat2IntClipping, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
539 "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
540 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
541 develop(bool, Use24BitFPMode, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
542 "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
543 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
544 develop(bool, Use24BitFP, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
545 "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
546 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
547 develop(bool, MonomorphicArrayCheck, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
548 "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
549 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
550 notproduct(bool, TracePhaseCCP, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
551 "Print progress during Conditional Constant Propagation") \
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 develop(bool, PrintDominators, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
554 "Print out dominator trees for GVN") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
555 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
556 notproduct(bool, TraceSpilling, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
557 "Trace spilling") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
558 \
6793
9d89c76b0505 7198499: TraceTypeProfile as diagnostic option
twisti
parents: 6633
diff changeset
559 diagnostic(bool, TraceTypeProfile, false, \
6633
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
560 "Trace type profile") \
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 develop(bool, PoisonOSREntry, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
563 "Detect abnormal calls to OSR code") \
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 product(bool, UseCondCardMark, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
566 "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
567 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
568 develop(bool, SoftMatchFailure, trueInProduct, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
569 "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
570 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
571 develop(bool, InlineAccessors, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
572 "inline accessor methods (get/set)") \
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 product(intx, TypeProfileMajorReceiverPercent, 90, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
575 "% 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
576 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
577 notproduct(bool, TimeCompiler2, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
578 "detailed time the compiler (requires +TimeCompiler)") \
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(bool, PrintIntrinsics, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
581 "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
582 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
583 diagnostic(ccstrlist, DisableIntrinsic, "", \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
584 "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
585 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
586 develop(bool, StressReflectiveCode, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
587 "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
588 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
589 diagnostic(bool, DebugInlinedCalls, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
590 "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
591 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
592 notproduct(bool, VerifyLoopOptimizations, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
593 "verify major loop optimizations") \
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 diagnostic(bool, ProfileDynamicTypes, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
596 "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
597 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
598 develop(bool, TraceIterativeGVN, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
599 "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
600 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
601 develop(bool, VerifyIterativeGVN, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
602 "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
603 "Value Numbering") \
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, TraceCISCSpill, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
606 "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
607 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
608 product(bool, SplitIfBlocks, true, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
609 "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
610 "some branches") \
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 develop(intx, FreqCountInvocations, 1, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
613 "Scaling factor for branch frequencies (deprecated)") \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
614 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
615 product(intx, AliasLevel, 3, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
616 "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
617 "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
618 \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
619 develop(bool, VerifyAliases, false, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 6183
diff changeset
620 "perform extra checks on the results of alias analysis") \
7473
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 product(bool, IncrementalInline, true, \
d092d1b31229 8005071: Incremental inlining for JSR 292
roland
parents: 7196
diff changeset
623 "do post parse inlining") \
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 develop(bool, AlwaysIncrementalInline, false, \
d092d1b31229 8005071: Incremental inlining for JSR 292
roland
parents: 7196
diff changeset
626 "do all inlining incrementally") \
d092d1b31229 8005071: Incremental inlining for JSR 292
roland
parents: 7196
diff changeset
627 \
d092d1b31229 8005071: Incremental inlining for JSR 292
roland
parents: 7196
diff changeset
628 product(intx, LiveNodeCountInliningCutoff, 20000, \
d092d1b31229 8005071: Incremental inlining for JSR 292
roland
parents: 7196
diff changeset
629 "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
630 \
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 7637
diff changeset
631 diagnostic(bool, OptimizeExpensiveOps, true, \
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 7637
diff changeset
632 "Find best control for expensive operations") \
7473
d092d1b31229 8005071: Incremental inlining for JSR 292
roland
parents: 7196
diff changeset
633
0
a61af66fc99e Initial load
duke
parents:
diff changeset
634
1080
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 930
diff changeset
635 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
636
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1763
diff changeset
637 #endif // SHARE_VM_OPTO_C2_GLOBALS_HPP