author | roland |
Fri, 17 Aug 2018 17:13:12 +0200 | |
changeset 51521 | 76a51e26d0ac |
parent 50623 | 5209d8a6303e |
child 52979 | 7384e00d5860 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
38273
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
2 |
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5249
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5249
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5249
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_OPTO_C2_GLOBALS_HPP |
26 |
#define SHARE_VM_OPTO_C2_GLOBALS_HPP |
|
27 |
||
28 |
#include "runtime/globals.hpp" |
|
40010 | 29 |
#include "utilities/macros.hpp" |
30 |
||
31 |
#include CPU_HEADER(c2_globals) |
|
32 |
#include OS_HEADER(c2_globals) |
|
7397 | 33 |
|
1 | 34 |
// |
35 |
// Defines all globals flags used by the server compiler. |
|
36 |
// |
|
37 |
||
38273
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
38 |
#define C2_FLAGS(develop, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
39 |
develop_pd, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
40 |
product, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
41 |
product_pd, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
42 |
diagnostic, \ |
39117 | 43 |
diagnostic_pd, \ |
38273
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
44 |
experimental, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
45 |
notproduct, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
46 |
range, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
47 |
constraint, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
48 |
writeable) \ |
1 | 49 |
\ |
39435
73f5a5e113f8
8156803: Turn StressLCM/StressGCM flags to diagnostic
shade
parents:
38289
diff
changeset
|
50 |
diagnostic(bool, StressLCM, false, \ |
15871
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
51 |
"Randomize instruction scheduling in LCM") \ |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
52 |
\ |
39435
73f5a5e113f8
8156803: Turn StressLCM/StressGCM flags to diagnostic
shade
parents:
38289
diff
changeset
|
53 |
diagnostic(bool, StressGCM, false, \ |
15871
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
54 |
"Randomize instruction scheduling in GCM") \ |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
55 |
\ |
50449
acdfeede95ff
8203480: IncompatibleClassChangeError thrown at sites linked to default interface methods
vlivanov
parents:
48309
diff
changeset
|
56 |
develop(bool, StressMethodHandleLinkerInlining, false, \ |
acdfeede95ff
8203480: IncompatibleClassChangeError thrown at sites linked to default interface methods
vlivanov
parents:
48309
diff
changeset
|
57 |
"Stress inlining through method handle linkers") \ |
acdfeede95ff
8203480: IncompatibleClassChangeError thrown at sites linked to default interface methods
vlivanov
parents:
48309
diff
changeset
|
58 |
\ |
1 | 59 |
develop(intx, OptoPrologueNops, 0, \ |
60 |
"Insert this many extra nop instructions " \ |
|
61 |
"in the prologue of every nmethod") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
62 |
range(0, 128) \ |
1 | 63 |
\ |
64 |
product_pd(intx, InteriorEntryAlignment, \ |
|
65 |
"Code alignment for interior entry points " \ |
|
66 |
"in generated code (in bytes)") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
67 |
constraint(InteriorEntryAlignmentConstraintFunc, AfterErgo) \ |
1 | 68 |
\ |
69 |
product(intx, MaxLoopPad, (OptoLoopAlignment-1), \ |
|
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
70 |
"Align a loop if padding size in bytes is less or equal to this " \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
71 |
"value") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
72 |
range(0, max_jint) \ |
1 | 73 |
\ |
30624 | 74 |
product(intx, MaxVectorSize, 64, \ |
13104
657b387034fb
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
12158
diff
changeset
|
75 |
"Max vector size in bytes, " \ |
657b387034fb
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
12158
diff
changeset
|
76 |
"actual size could be less depending on elements type") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
77 |
range(0, max_jint) \ |
13104
657b387034fb
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
12158
diff
changeset
|
78 |
\ |
13885 | 79 |
product(bool, AlignVector, true, \ |
13104
657b387034fb
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
12158
diff
changeset
|
80 |
"Perform vector store/load alignment in loop") \ |
657b387034fb
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
12158
diff
changeset
|
81 |
\ |
1 | 82 |
product(intx, NumberOfLoopInstrToAlign, 4, \ |
83 |
"Number of first instructions in a loop to align") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
84 |
range(0, max_jint) \ |
1 | 85 |
\ |
86 |
notproduct(intx, IndexSetWatch, 0, \ |
|
87 |
"Trace all operations on this IndexSet (-1 means all, 0 none)") \ |
|
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
88 |
range(-1, 0) \ |
1 | 89 |
\ |
90 |
develop(intx, OptoNodeListSize, 4, \ |
|
91 |
"Starting allocation size of Node_List data structures") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
92 |
range(0, max_jint) \ |
1 | 93 |
\ |
94 |
develop(intx, OptoBlockListSize, 8, \ |
|
95 |
"Starting allocation size of Block_List data structures") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
96 |
range(0, max_jint) \ |
1 | 97 |
\ |
98 |
develop(intx, OptoPeepholeAt, -1, \ |
|
99 |
"Apply peephole optimizations to this peephole rule") \ |
|
100 |
\ |
|
101 |
notproduct(bool, PrintIdeal, false, \ |
|
102 |
"Print ideal graph before code generation") \ |
|
103 |
\ |
|
104 |
notproduct(bool, PrintOpto, false, \ |
|
105 |
"Print compiler2 attempts") \ |
|
106 |
\ |
|
107 |
notproduct(bool, PrintOptoInlining, false, \ |
|
108 |
"Print compiler2 inlining decisions") \ |
|
109 |
\ |
|
110 |
notproduct(bool, VerifyOpto, false, \ |
|
111 |
"Apply more time consuming verification during compilation") \ |
|
112 |
\ |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14133
diff
changeset
|
113 |
notproduct(bool, VerifyIdealNodeCount, false, \ |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14133
diff
changeset
|
114 |
"Verify that tracked dead ideal node count is accurate") \ |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14133
diff
changeset
|
115 |
\ |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14133
diff
changeset
|
116 |
notproduct(bool, PrintIdealNodeCount, false, \ |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14133
diff
changeset
|
117 |
"Print liveness counts of ideal nodes") \ |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14133
diff
changeset
|
118 |
\ |
1 | 119 |
notproduct(bool, VerifyOptoOopOffsets, false, \ |
120 |
"Check types of base addresses in field references") \ |
|
121 |
\ |
|
122 |
develop(bool, IdealizedNumerics, false, \ |
|
123 |
"Check performance difference allowing FP " \ |
|
124 |
"associativity and commutativity...") \ |
|
125 |
\ |
|
42063
dca9294d9f59
8166561: [s390] Adaptions needed for s390 port in C1 and C2.
goetz
parents:
40010
diff
changeset
|
126 |
diagnostic_pd(bool, IdealizeClearArrayNode, \ |
dca9294d9f59
8166561: [s390] Adaptions needed for s390 port in C1 and C2.
goetz
parents:
40010
diff
changeset
|
127 |
"Replace ClearArrayNode by subgraph of basic operations.") \ |
dca9294d9f59
8166561: [s390] Adaptions needed for s390 port in C1 and C2.
goetz
parents:
40010
diff
changeset
|
128 |
\ |
1 | 129 |
develop(bool, OptoBreakpoint, false, \ |
130 |
"insert breakpoint at method entry") \ |
|
131 |
\ |
|
132 |
notproduct(bool, OptoBreakpointOSR, false, \ |
|
133 |
"insert breakpoint at osr method entry") \ |
|
134 |
\ |
|
135 |
notproduct(intx, BreakAtNode, 0, \ |
|
136 |
"Break at construction of this Node (either _idx or _debug_idx)") \ |
|
137 |
\ |
|
138 |
notproduct(bool, OptoBreakpointC2R, false, \ |
|
139 |
"insert breakpoint at runtime stub entry") \ |
|
140 |
\ |
|
141 |
notproduct(bool, OptoNoExecute, false, \ |
|
142 |
"Attempt to parse and compile but do not execute generated code") \ |
|
143 |
\ |
|
144 |
notproduct(bool, PrintOptoStatistics, false, \ |
|
145 |
"Print New compiler statistics") \ |
|
146 |
\ |
|
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33447
diff
changeset
|
147 |
diagnostic(bool, PrintOptoAssembly, false, \ |
1 | 148 |
"Print New compiler assembly output") \ |
149 |
\ |
|
150 |
develop_pd(bool, OptoPeephole, \ |
|
151 |
"Apply peephole optimizations after register allocation") \ |
|
152 |
\ |
|
153 |
develop(bool, OptoRemoveUseless, true, \ |
|
154 |
"Remove useless nodes after parsing") \ |
|
155 |
\ |
|
156 |
notproduct(bool, PrintFrameConverterAssembly, false, \ |
|
157 |
"Print New compiler assembly output for frame converters") \ |
|
158 |
\ |
|
159 |
notproduct(bool, PrintParseStatistics, false, \ |
|
160 |
"Print nodes, transforms and new values made per bytecode parsed")\ |
|
161 |
\ |
|
162 |
notproduct(bool, PrintOptoPeephole, false, \ |
|
163 |
"Print New compiler peephole replacements") \ |
|
164 |
\ |
|
165 |
develop(bool, PrintCFGBlockFreq, false, \ |
|
166 |
"Print CFG block freqencies") \ |
|
167 |
\ |
|
168 |
develop(bool, TraceOptoParse, false, \ |
|
169 |
"Trace bytecode parse and control-flow merge") \ |
|
170 |
\ |
|
171 |
product_pd(intx, LoopUnrollLimit, \ |
|
172 |
"Unroll loop bodies with node count less than this") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
173 |
range(0, max_jint / 4) \ |
1 | 174 |
\ |
36066 | 175 |
product_pd(intx, LoopPercentProfileLimit, \ |
176 |
"Unroll loop bodies with % node count of profile limit") \ |
|
177 |
range(10, 100) \ |
|
178 |
\ |
|
19283
4df251ee863c
8022993: Convert MAX_UNROLL constant to LoopMaxUnroll C2 flag
kvn
parents:
18099
diff
changeset
|
179 |
product(intx, LoopMaxUnroll, 16, \ |
4df251ee863c
8022993: Convert MAX_UNROLL constant to LoopMaxUnroll C2 flag
kvn
parents:
18099
diff
changeset
|
180 |
"Maximum number of unrolls for main loop") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
181 |
range(0, max_jint) \ |
19283
4df251ee863c
8022993: Convert MAX_UNROLL constant to LoopMaxUnroll C2 flag
kvn
parents:
18099
diff
changeset
|
182 |
\ |
34162 | 183 |
product_pd(bool, SuperWordLoopUnrollAnalysis, \ |
184 |
"Map number of unrolls for main loop via " \ |
|
185 |
"Superword Level Parallelism analysis") \ |
|
31403 | 186 |
\ |
46061 | 187 |
experimental(bool, PostLoopMultiversioning, false, \ |
37292
64f6ae06310e
8151573: Multiversioning for range check elimination
mcberg
parents:
37287
diff
changeset
|
188 |
"Multi versioned post loops to eliminate range checks") \ |
64f6ae06310e
8151573: Multiversioning for range check elimination
mcberg
parents:
37287
diff
changeset
|
189 |
\ |
31403 | 190 |
notproduct(bool, TraceSuperWordLoopUnrollAnalysis, false, \ |
191 |
"Trace what Superword Level Parallelism analysis applies") \ |
|
192 |
\ |
|
1 | 193 |
product(intx, LoopUnrollMin, 4, \ |
194 |
"Minimum number of unroll loop bodies before checking progress" \ |
|
195 |
"of rounds of unroll,optimize,..") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
196 |
range(0, max_jint) \ |
1 | 197 |
\ |
47623
0a5f1b851890
8189067: SuperWord optimization crashes with "assert(out == prev || prev == __null) failed: no branches off of store slice"
thartmann
parents:
47216
diff
changeset
|
198 |
product(bool, UseSubwordForMaxVector, true, \ |
46692
117b089cb1c3
8175096: Analyse subword in the loop to set maximum vector size
vdeshpande
parents:
46486
diff
changeset
|
199 |
"Use Subword Analysis to set maximum vector size") \ |
117b089cb1c3
8175096: Analyse subword in the loop to set maximum vector size
vdeshpande
parents:
46486
diff
changeset
|
200 |
\ |
48309 | 201 |
product(bool, UseVectorCmov, false, \ |
202 |
"Use Vectorized Cmov") \ |
|
203 |
\ |
|
1 | 204 |
develop(intx, UnrollLimitForProfileCheck, 1, \ |
205 |
"Don't use profile_trip_cnt() to restrict unrolling until " \ |
|
206 |
"unrolling would push the number of unrolled iterations above " \ |
|
207 |
"UnrollLimitForProfileCheck. A higher value allows more " \ |
|
208 |
"unrolling. Zero acts as a very large value." ) \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
209 |
range(0, max_intx) \ |
1 | 210 |
\ |
211 |
product(intx, MultiArrayExpandLimit, 6, \ |
|
212 |
"Maximum number of individual allocations in an inline-expanded " \ |
|
213 |
"multianewarray instruction") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
214 |
range(0, max_jint) \ |
1 | 215 |
\ |
216 |
notproduct(bool, TraceProfileTripCount, false, \ |
|
217 |
"Trace profile loop trip count information") \ |
|
218 |
\ |
|
35084
5b34a4ae0f58
6869327: Add new C2 flag to keep safepoints in counted loops.
aeriksso
parents:
34503
diff
changeset
|
219 |
product(bool, UseCountedLoopSafepoints, false, \ |
5b34a4ae0f58
6869327: Add new C2 flag to keep safepoints in counted loops.
aeriksso
parents:
34503
diff
changeset
|
220 |
"Force counted loops to keep a safepoint") \ |
5b34a4ae0f58
6869327: Add new C2 flag to keep safepoints in counted loops.
aeriksso
parents:
34503
diff
changeset
|
221 |
\ |
4643 | 222 |
product(bool, UseLoopPredicate, true, \ |
223 |
"Generate a predicate to select fast/slow loop versions") \ |
|
224 |
\ |
|
225 |
develop(bool, TraceLoopPredicate, false, \ |
|
226 |
"Trace generation of loop predicates") \ |
|
227 |
\ |
|
8732
16fc1c68714b
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
8107
diff
changeset
|
228 |
develop(bool, TraceLoopOpts, false, \ |
16fc1c68714b
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
8107
diff
changeset
|
229 |
"Trace executed loop optimizations") \ |
16fc1c68714b
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
8107
diff
changeset
|
230 |
\ |
9446 | 231 |
develop(bool, TraceLoopLimitCheck, false, \ |
232 |
"Trace generation of loop limits checks") \ |
|
233 |
\ |
|
234 |
develop(bool, TraceRangeLimitCheck, false, \ |
|
235 |
"Trace additional overflow checks in RCE") \ |
|
236 |
\ |
|
22853
308672304981
8028767: PPC64: (part 121): smaller shared changes needed to build C2
goetz
parents:
22844
diff
changeset
|
237 |
/* OptimizeFill not yet supported on PowerPC. */ \ |
308672304981
8028767: PPC64: (part 121): smaller shared changes needed to build C2
goetz
parents:
22844
diff
changeset
|
238 |
product(bool, OptimizeFill, true PPC64_ONLY(&& false), \ |
6433 | 239 |
"convert fill/copy loops into intrinsic") \ |
240 |
\ |
|
241 |
develop(bool, TraceOptimizeFill, false, \ |
|
242 |
"print detailed information about fill conversion") \ |
|
243 |
\ |
|
1 | 244 |
develop(bool, OptoCoalesce, true, \ |
245 |
"Use Conservative Copy Coalescing in the Register Allocator") \ |
|
246 |
\ |
|
247 |
develop(bool, UseUniqueSubclasses, true, \ |
|
248 |
"Narrow an abstract reference to the unique concrete subclass") \ |
|
249 |
\ |
|
250 |
develop(bool, UseExactTypes, true, \ |
|
251 |
"Use exact types to eliminate array store checks and v-calls") \ |
|
252 |
\ |
|
253 |
product(intx, TrackedInitializationLimit, 50, \ |
|
254 |
"When initializing fields, track up to this many words") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
255 |
range(0, 65535) \ |
1 | 256 |
\ |
257 |
product(bool, ReduceFieldZeroing, true, \ |
|
258 |
"When initializing fields, try to avoid needless zeroing") \ |
|
259 |
\ |
|
260 |
product(bool, ReduceInitialCardMarks, true, \ |
|
261 |
"When initializing fields, try to avoid needless card marks") \ |
|
262 |
\ |
|
263 |
product(bool, ReduceBulkZeroing, true, \ |
|
264 |
"When bulk-initializing, try to avoid needless zeroing") \ |
|
265 |
\ |
|
6272
94a20ad0e9de
6978249: spill between cpu and fpu registers when those moves are fast
never
parents:
6180
diff
changeset
|
266 |
product(bool, UseFPUForSpilling, false, \ |
94a20ad0e9de
6978249: spill between cpu and fpu registers when those moves are fast
never
parents:
6180
diff
changeset
|
267 |
"Spill integer registers to FPU instead of stack when possible") \ |
94a20ad0e9de
6978249: spill between cpu and fpu registers when those moves are fast
never
parents:
6180
diff
changeset
|
268 |
\ |
1 | 269 |
develop_pd(intx, RegisterCostAreaRatio, \ |
270 |
"Spill selection in reg allocator: scale area by (X/64K) before " \ |
|
271 |
"adding cost") \ |
|
272 |
\ |
|
273 |
develop_pd(bool, UseCISCSpill, \ |
|
274 |
"Use ADLC supplied cisc instructions during allocation") \ |
|
275 |
\ |
|
276 |
notproduct(bool, VerifyGraphEdges , false, \ |
|
277 |
"Verify Bi-directional Edges") \ |
|
278 |
\ |
|
279 |
notproduct(bool, VerifyDUIterators, true, \ |
|
280 |
"Verify the safety of all iterations of Bi-directional Edges") \ |
|
281 |
\ |
|
282 |
notproduct(bool, VerifyHashTableKeys, true, \ |
|
283 |
"Verify the immutability of keys in the VN hash tables") \ |
|
284 |
\ |
|
2014
5510e7394f2d
6782232: assert("CreateEx must be first instruction in block" )
kvn
parents:
1553
diff
changeset
|
285 |
notproduct(bool, VerifyRegisterAllocator , false, \ |
5510e7394f2d
6782232: assert("CreateEx must be first instruction in block" )
kvn
parents:
1553
diff
changeset
|
286 |
"Verify Register Allocator") \ |
5510e7394f2d
6782232: assert("CreateEx must be first instruction in block" )
kvn
parents:
1553
diff
changeset
|
287 |
\ |
1 | 288 |
develop_pd(intx, FLOATPRESSURE, \ |
289 |
"Number of float LRG's that constitute high register pressure") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
290 |
range(0, max_jint) \ |
1 | 291 |
\ |
292 |
develop_pd(intx, INTPRESSURE, \ |
|
293 |
"Number of integer LRG's that constitute high register pressure") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
294 |
range(0, max_jint) \ |
1 | 295 |
\ |
296 |
notproduct(bool, TraceOptoPipelining, false, \ |
|
297 |
"Trace pipelining information") \ |
|
298 |
\ |
|
299 |
notproduct(bool, TraceOptoOutput, false, \ |
|
300 |
"Trace pipelining information") \ |
|
301 |
\ |
|
302 |
product_pd(bool, OptoScheduling, \ |
|
303 |
"Instruction Scheduling after register allocation") \ |
|
304 |
\ |
|
33065 | 305 |
product_pd(bool, OptoRegScheduling, \ |
306 |
"Instruction Scheduling before register allocation for pressure") \ |
|
307 |
\ |
|
1 | 308 |
product(bool, PartialPeelLoop, true, \ |
309 |
"Partial peel (rotate) loops") \ |
|
310 |
\ |
|
311 |
product(intx, PartialPeelNewPhiDelta, 0, \ |
|
312 |
"Additional phis that can be created by partial peeling") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
313 |
range(0, max_jint) \ |
1 | 314 |
\ |
315 |
notproduct(bool, TracePartialPeeling, false, \ |
|
316 |
"Trace partial peeling (loop rotation) information") \ |
|
317 |
\ |
|
318 |
product(bool, PartialPeelAtUnsignedTests, true, \ |
|
319 |
"Partial peel at unsigned tests if no signed test exists") \ |
|
320 |
\ |
|
321 |
product(bool, ReassociateInvariants, true, \ |
|
322 |
"Enable reassociation of expressions with loop invariants.") \ |
|
323 |
\ |
|
324 |
product(bool, LoopUnswitching, true, \ |
|
325 |
"Enable loop unswitching (a form of invariant test hoisting)") \ |
|
326 |
\ |
|
327 |
notproduct(bool, TraceLoopUnswitching, false, \ |
|
328 |
"Trace loop unswitching") \ |
|
329 |
\ |
|
30593 | 330 |
product(bool, AllowVectorizeOnDemand, true, \ |
331 |
"Globally supress vectorization set in VectorizeMethod") \ |
|
332 |
\ |
|
1 | 333 |
product(bool, UseSuperWord, true, \ |
334 |
"Transform scalar operations into superword operations") \ |
|
335 |
\ |
|
336 |
develop(bool, SuperWordRTDepCheck, false, \ |
|
337 |
"Enable runtime dependency checks.") \ |
|
338 |
\ |
|
30211 | 339 |
product(bool, SuperWordReductions, true, \ |
340 |
"Enable reductions support in superword.") \ |
|
341 |
\ |
|
33469
30f4811eded0
8139340: SuperWord enhancement to support vector conditional move (CMovVD) on Intel AVX cpu
iveresov
parents:
33455
diff
changeset
|
342 |
product(bool, UseCMoveUnconditionally, false, \ |
30f4811eded0
8139340: SuperWord enhancement to support vector conditional move (CMovVD) on Intel AVX cpu
iveresov
parents:
33455
diff
changeset
|
343 |
"Use CMove (scalar and vector) ignoring profitability test.") \ |
30f4811eded0
8139340: SuperWord enhancement to support vector conditional move (CMovVD) on Intel AVX cpu
iveresov
parents:
33455
diff
changeset
|
344 |
\ |
33166
81352250770f
8136725: Provide utility for creation a counted loop reserve copy (clone)
iveresov
parents:
33163
diff
changeset
|
345 |
product(bool, DoReserveCopyInSuperWord, true, \ |
81352250770f
8136725: Provide utility for creation a counted loop reserve copy (clone)
iveresov
parents:
33163
diff
changeset
|
346 |
"Create reserve copy of graph in SuperWord.") \ |
81352250770f
8136725: Provide utility for creation a counted loop reserve copy (clone)
iveresov
parents:
33163
diff
changeset
|
347 |
\ |
13108
6d27f658925c
7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear()
kvn
parents:
13104
diff
changeset
|
348 |
notproduct(bool, TraceSuperWord, false, \ |
1 | 349 |
"Trace superword transforms") \ |
350 |
\ |
|
13108
6d27f658925c
7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear()
kvn
parents:
13104
diff
changeset
|
351 |
notproduct(bool, TraceNewVectors, false, \ |
6d27f658925c
7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear()
kvn
parents:
13104
diff
changeset
|
352 |
"Trace creation of Vector nodes") \ |
6d27f658925c
7177923: SIGBUS on sparc in compiled code for java.util.Calendar.clear()
kvn
parents:
13104
diff
changeset
|
353 |
\ |
1 | 354 |
product_pd(bool, OptoBundling, \ |
355 |
"Generate nops to fill i-cache lines") \ |
|
356 |
\ |
|
357 |
product_pd(intx, ConditionalMoveLimit, \ |
|
358 |
"Limit of ops to make speculative when using CMOVE") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
359 |
range(0, max_jint) \ |
1 | 360 |
\ |
361 |
/* Set BranchOnRegister == false. See 4965987. */ \ |
|
362 |
product(bool, BranchOnRegister, false, \ |
|
363 |
"Use Sparc V9 branch-on-register opcodes") \ |
|
364 |
\ |
|
365 |
develop(bool, SparcV9RegsHiBitsZero, true, \ |
|
366 |
"Assume Sparc V9 I&L registers on V8+ systems are zero-extended") \ |
|
367 |
\ |
|
7433 | 368 |
product(bool, UseRDPCForConstantTableBase, false, \ |
369 |
"Use Sparc RDPC instruction for the constant table base.") \ |
|
370 |
\ |
|
33454
d97c7a894c66
8132168: Support IdealGraphVisualizer in optimized build
vlivanov
parents:
33447
diff
changeset
|
371 |
notproduct(bool, PrintIdealGraph, false, \ |
1 | 372 |
"Print ideal graph to XML file / network interface. " \ |
373 |
"By default attempts to connect to the visualizer on a socket.") \ |
|
374 |
\ |
|
33454
d97c7a894c66
8132168: Support IdealGraphVisualizer in optimized build
vlivanov
parents:
33447
diff
changeset
|
375 |
notproduct(intx, PrintIdealGraphLevel, 0, \ |
27147 | 376 |
"Level of detail of the ideal graph printout. " \ |
33447
fa16119dcde7
8065151: Support IdealGraphVisualizer in optimized build
vlivanov
parents:
33166
diff
changeset
|
377 |
"System-wide value, 0=nothing is printed, 4=all details printed. "\ |
27147 | 378 |
"Level of detail of printouts can be set on a per-method level " \ |
379 |
"as well by using CompileCommand=option.") \ |
|
33447
fa16119dcde7
8065151: Support IdealGraphVisualizer in optimized build
vlivanov
parents:
33166
diff
changeset
|
380 |
range(0, 4) \ |
27147 | 381 |
\ |
33454
d97c7a894c66
8132168: Support IdealGraphVisualizer in optimized build
vlivanov
parents:
33447
diff
changeset
|
382 |
notproduct(intx, PrintIdealGraphPort, 4444, \ |
1 | 383 |
"Ideal graph printer to network port") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
384 |
range(0, SHRT_MAX) \ |
1 | 385 |
\ |
1553 | 386 |
notproduct(ccstr, PrintIdealGraphAddress, "127.0.0.1", \ |
1 | 387 |
"IP address to connect to visualizer") \ |
388 |
\ |
|
1553 | 389 |
notproduct(ccstr, PrintIdealGraphFile, NULL, \ |
1 | 390 |
"File to dump ideal graph to. If set overrides the " \ |
391 |
"use of the network") \ |
|
392 |
\ |
|
393 |
product(bool, UseBimorphicInlining, true, \ |
|
394 |
"Profiling based inlining for two receivers") \ |
|
395 |
\ |
|
396 |
product(bool, UseOnlyInlinedBimorphic, true, \ |
|
397 |
"Don't use BimorphicInlining if can't inline a second method") \ |
|
398 |
\ |
|
399 |
product(bool, InsertMemBarAfterArraycopy, true, \ |
|
400 |
"Insert memory barrier after arraycopy call") \ |
|
401 |
\ |
|
6180 | 402 |
develop(bool, SubsumeLoads, true, \ |
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
403 |
"Attempt to compile while subsuming loads into machine " \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
404 |
"instructions.") \ |
6180 | 405 |
\ |
406 |
develop(bool, StressRecompilation, false, \ |
|
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
407 |
"Recompile each compiled method without subsuming loads " \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
408 |
"or escape analysis.") \ |
6180 | 409 |
\ |
1 | 410 |
develop(intx, ImplicitNullCheckThreshold, 3, \ |
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
411 |
"Don't do implicit null checks if NPE's in a method exceeds " \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
412 |
"limit") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
413 |
range(0, max_jint) \ |
1 | 414 |
\ |
415 |
product(intx, LoopOptsCount, 43, \ |
|
416 |
"Set level of loop optimization for tier 1 compiles") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
417 |
range(5, 43) \ |
1 | 418 |
\ |
419 |
/* controls for heat-based inlining */ \ |
|
420 |
\ |
|
421 |
develop(intx, NodeCountInliningCutoff, 18000, \ |
|
422 |
"If parser node generation exceeds limit stop inlining") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
423 |
range(0, max_jint) \ |
1 | 424 |
\ |
425 |
develop(intx, NodeCountInliningStep, 1000, \ |
|
426 |
"Target size of warm calls inlined between optimization passes") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
427 |
range(0, max_jint) \ |
1 | 428 |
\ |
429 |
develop(bool, InlineWarmCalls, false, \ |
|
430 |
"Use a heat-based priority queue to govern inlining") \ |
|
431 |
\ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
432 |
/* Max values must not exceed WarmCallInfo::MAX_VALUE(). */ \ |
1 | 433 |
develop(intx, HotCallCountThreshold, 999999, \ |
434 |
"large numbers of calls (per method invocation) force hotness") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
435 |
range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 436 |
\ |
437 |
develop(intx, HotCallProfitThreshold, 999999, \ |
|
438 |
"highly profitable inlining opportunities force hotness") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
439 |
range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 440 |
\ |
441 |
develop(intx, HotCallTrivialWork, -1, \ |
|
442 |
"trivial execution time (no larger than this) forces hotness") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
443 |
range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 444 |
\ |
445 |
develop(intx, HotCallTrivialSize, -1, \ |
|
446 |
"trivial methods (no larger than this) force calls to be hot") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
447 |
range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 448 |
\ |
449 |
develop(intx, WarmCallMinCount, -1, \ |
|
450 |
"number of calls (per method invocation) to enable inlining") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
451 |
range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 452 |
\ |
453 |
develop(intx, WarmCallMinProfit, -1, \ |
|
454 |
"number of calls (per method invocation) to enable inlining") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
455 |
range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 456 |
\ |
457 |
develop(intx, WarmCallMaxWork, 999999, \ |
|
458 |
"execution time of the largest inlinable method") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
459 |
range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 460 |
\ |
461 |
develop(intx, WarmCallMaxSize, 999999, \ |
|
462 |
"size of the largest inlinable method") \ |
|
46486
314aa24e62d6
8179618: Fixes for range of OptoLoopAlignment and Inlining flags
goetz
parents:
42063
diff
changeset
|
463 |
range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10)))) \ |
1 | 464 |
\ |
18099
45973b036c3e
8014959: assert(Compile::current()->live_nodes() < (uint)MaxNodeLimit) failed: Live Node limit exceeded limit
drchase
parents:
17383
diff
changeset
|
465 |
product(intx, MaxNodeLimit, 80000, \ |
1 | 466 |
"Maximum number of nodes") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
467 |
range(1000, max_jint / 3) \ |
1 | 468 |
\ |
18099
45973b036c3e
8014959: assert(Compile::current()->live_nodes() < (uint)MaxNodeLimit) failed: Live Node limit exceeded limit
drchase
parents:
17383
diff
changeset
|
469 |
product(intx, NodeLimitFudgeFactor, 2000, \ |
1 | 470 |
"Fudge Factor for certain optimizations") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
471 |
constraint(NodeLimitFudgeFactorConstraintFunc, AfterErgo) \ |
1 | 472 |
\ |
473 |
product(bool, UseJumpTables, true, \ |
|
474 |
"Use JumpTables instead of a binary search tree for switches") \ |
|
475 |
\ |
|
476 |
product(bool, UseDivMod, true, \ |
|
477 |
"Use combined DivMod instruction if available") \ |
|
478 |
\ |
|
19772
6e60ae28d9f6
8010941: MinJumpTableSize is set to 18, investigate if that's still optimal
adlertz
parents:
19770
diff
changeset
|
479 |
product_pd(intx, MinJumpTableSize, \ |
1 | 480 |
"Minimum number of targets in a generated jump table") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
481 |
range(0, max_intx) \ |
1 | 482 |
\ |
483 |
product(intx, MaxJumpTableSize, 65000, \ |
|
484 |
"Maximum number of targets in a generated jump table") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
485 |
range(0, max_intx) \ |
1 | 486 |
\ |
487 |
product(intx, MaxJumpTableSparseness, 5, \ |
|
488 |
"Maximum sparseness for jumptables") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
489 |
range(0, max_intx / 4) \ |
1 | 490 |
\ |
491 |
product(bool, EliminateLocks, true, \ |
|
492 |
"Coarsen locks when possible") \ |
|
493 |
\ |
|
11445 | 494 |
product(bool, EliminateNestedLocks, true, \ |
495 |
"Eliminate nested locks of the same object when possible") \ |
|
496 |
\ |
|
1 | 497 |
notproduct(bool, PrintLockStatistics, false, \ |
498 |
"Print precise statistics on the dynamic lock usage") \ |
|
499 |
\ |
|
500 |
diagnostic(bool, PrintPreciseBiasedLockingStatistics, false, \ |
|
501 |
"Print per-lock-site statistics of biased locking in JVM") \ |
|
502 |
\ |
|
23491 | 503 |
diagnostic(bool, PrintPreciseRTMLockingStatistics, false, \ |
504 |
"Print per-lock-site statistics of rtm locking in JVM") \ |
|
505 |
\ |
|
1 | 506 |
notproduct(bool, PrintEliminateLocks, false, \ |
507 |
"Print out when locks are eliminated") \ |
|
508 |
\ |
|
24479 | 509 |
product(bool, EliminateAutoBox, true, \ |
17383 | 510 |
"Control optimizations for autobox elimination") \ |
190
e9a0a9dcd4f6
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
1
diff
changeset
|
511 |
\ |
23192 | 512 |
diagnostic(bool, UseImplicitStableValues, true, \ |
19770
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19283
diff
changeset
|
513 |
"Mark well-known stable fields as such (e.g. String.value)") \ |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19283
diff
changeset
|
514 |
\ |
190
e9a0a9dcd4f6
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
1
diff
changeset
|
515 |
product(intx, AutoBoxCacheMax, 128, \ |
e9a0a9dcd4f6
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
1
diff
changeset
|
516 |
"Sets max value cached by the java.lang.Integer autobox cache") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
517 |
range(0, max_jint) \ |
190
e9a0a9dcd4f6
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
1
diff
changeset
|
518 |
\ |
17383 | 519 |
experimental(bool, AggressiveUnboxing, false, \ |
520 |
"Control optimizations for aggressive boxing elimination") \ |
|
521 |
\ |
|
22844
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
522 |
develop(bool, TracePostallocExpand, false, "Trace expanding nodes after" \ |
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
523 |
" register allocation.") \ |
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
524 |
\ |
3685 | 525 |
product(bool, DoEscapeAnalysis, true, \ |
1 | 526 |
"Perform escape analysis") \ |
527 |
\ |
|
27424
77a7f4a2463b
8041984: CompilerThread seems to occupy all CPU in a very rare situation
kvn
parents:
27147
diff
changeset
|
528 |
product(double, EscapeAnalysisTimeout, 20. DEBUG_ONLY(+40.), \ |
77a7f4a2463b
8041984: CompilerThread seems to occupy all CPU in a very rare situation
kvn
parents:
27147
diff
changeset
|
529 |
"Abort EA when it reaches time limit (in sec)") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
530 |
range(0, DBL_MAX) \ |
27424
77a7f4a2463b
8041984: CompilerThread seems to occupy all CPU in a very rare situation
kvn
parents:
27147
diff
changeset
|
531 |
\ |
14133
c2e317724c4c
7163534: VM could crashes assert(false) failed: infinite EA connection graph build
kvn
parents:
13885
diff
changeset
|
532 |
develop(bool, ExitEscapeAnalysisOnTimeout, true, \ |
c2e317724c4c
7163534: VM could crashes assert(false) failed: infinite EA connection graph build
kvn
parents:
13885
diff
changeset
|
533 |
"Exit or throw assert in EA when it reaches time limit") \ |
c2e317724c4c
7163534: VM could crashes assert(false) failed: infinite EA connection graph build
kvn
parents:
13885
diff
changeset
|
534 |
\ |
1 | 535 |
notproduct(bool, PrintEscapeAnalysis, false, \ |
536 |
"Print the results of escape analysis") \ |
|
537 |
\ |
|
538 |
product(bool, EliminateAllocations, true, \ |
|
539 |
"Use escape analysis to eliminate allocations") \ |
|
540 |
\ |
|
238
803c80713999
6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents:
190
diff
changeset
|
541 |
notproduct(bool, PrintEliminateAllocations, false, \ |
803c80713999
6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents:
190
diff
changeset
|
542 |
"Print out when allocations are eliminated") \ |
803c80713999
6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents:
190
diff
changeset
|
543 |
\ |
803c80713999
6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents:
190
diff
changeset
|
544 |
product(intx, EliminateAllocationArraySizeLimit, 64, \ |
803c80713999
6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents:
190
diff
changeset
|
545 |
"Array size (number of elements) limit for scalar replacement") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
546 |
range(0, max_jint) \ |
238
803c80713999
6674588: (Escape Analysis) Improve Escape Analysis code
kvn
parents:
190
diff
changeset
|
547 |
\ |
11189 | 548 |
product(bool, OptimizePtrCompare, true, \ |
549 |
"Use escape analysis to optimize pointers compare") \ |
|
550 |
\ |
|
551 |
notproduct(bool, PrintOptimizePtrCompare, false, \ |
|
552 |
"Print information about optimized pointers compare") \ |
|
553 |
\ |
|
12158
f24f2560da32
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
11445
diff
changeset
|
554 |
notproduct(bool, VerifyConnectionGraph , true, \ |
f24f2560da32
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
11445
diff
changeset
|
555 |
"Verify Connection Graph construction in Escape Analysis") \ |
f24f2560da32
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
11445
diff
changeset
|
556 |
\ |
2340 | 557 |
product(bool, UseOptoBiasInlining, true, \ |
1500
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1498
diff
changeset
|
558 |
"Generate biased locking code in C2 ideal graph") \ |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1498
diff
changeset
|
559 |
\ |
10963 | 560 |
product(bool, OptimizeStringConcat, true, \ |
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3685
diff
changeset
|
561 |
"Optimize the construction of Strings by StringBuilder") \ |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3685
diff
changeset
|
562 |
\ |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3685
diff
changeset
|
563 |
notproduct(bool, PrintOptimizeStringConcat, false, \ |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3685
diff
changeset
|
564 |
"Print information about transformations performed on Strings") \ |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3685
diff
changeset
|
565 |
\ |
961
7fb3b13d4205
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
953
diff
changeset
|
566 |
product(intx, ValueSearchLimit, 1000, \ |
7fb3b13d4205
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
953
diff
changeset
|
567 |
"Recursion limit in PhaseMacroExpand::value_from_mem_phi") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
568 |
range(0, max_jint) \ |
961
7fb3b13d4205
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
953
diff
changeset
|
569 |
\ |
1 | 570 |
product(intx, MaxLabelRootDepth, 1100, \ |
571 |
"Maximum times call Label_Root to prevent stack overflow") \ |
|
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
572 |
range(100, max_jint) \ |
581
02338c8a1bcf
6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents:
238
diff
changeset
|
573 |
\ |
02338c8a1bcf
6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents:
238
diff
changeset
|
574 |
diagnostic(intx, DominatorSearchLimit, 1000, \ |
02338c8a1bcf
6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents:
238
diff
changeset
|
575 |
"Iterations limit in Node::dominates") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
576 |
range(0, max_jint) \ |
1498 | 577 |
\ |
578 |
product(bool, BlockLayoutByFrequency, true, \ |
|
579 |
"Use edge frequencies to drive block ordering") \ |
|
580 |
\ |
|
581 |
product(intx, BlockLayoutMinDiamondPercentage, 20, \ |
|
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
582 |
"Miniumum %% of a successor (predecessor) for which block " \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
583 |
"layout a will allow a fork (join) in a single chain") \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
584 |
range(0, 100) \ |
1498 | 585 |
\ |
2340 | 586 |
product(bool, BlockLayoutRotateLoops, true, \ |
38046
f8383064eaa2
8154135: Loop alignment may be added inside the loop body
roland
parents:
37296
diff
changeset
|
587 |
"Allow back branches to be fall throughs in the block layout") \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
588 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
589 |
diagnostic(bool, InlineReflectionGetCallerClass, true, \ |
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
590 |
"inline sun.reflect.Reflection.getCallerClass(), known to be " \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
591 |
"part of base library DLL") \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
592 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
593 |
diagnostic(bool, InlineObjectCopy, true, \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
594 |
"inline Object.clone and Arrays.copyOf[Range] intrinsics") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
595 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
596 |
diagnostic(bool, SpecialStringCompareTo, true, \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
597 |
"special version of string compareTo") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
598 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
599 |
diagnostic(bool, SpecialStringIndexOf, true, \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
600 |
"special version of string indexOf") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
601 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
602 |
diagnostic(bool, SpecialStringEquals, true, \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
603 |
"special version of string equals") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
604 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
605 |
diagnostic(bool, SpecialArraysEquals, true, \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
606 |
"special version of Arrays.equals(char[],char[])") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
607 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
608 |
diagnostic(bool, SpecialEncodeISOArray, true, \ |
15242
695bb216be99
6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents:
15113
diff
changeset
|
609 |
"special version of ISO_8859_1$Encoder.encodeISOArray") \ |
695bb216be99
6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents:
15113
diff
changeset
|
610 |
\ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
611 |
develop(bool, BailoutToInterpreterForThrows, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
612 |
"Compiled methods which throws/catches exceptions will be " \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
613 |
"deopt and intp.") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
614 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
615 |
develop(bool, ConvertCmpD2CmpF, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
616 |
"Convert cmpD to cmpF when one input is constant in float range") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
617 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
618 |
develop(bool, ConvertFloat2IntClipping, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
619 |
"Convert float2int clipping idiom to integer clipping") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
620 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
621 |
develop(bool, Use24BitFPMode, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
622 |
"Set 24-bit FPU mode on a per-compile basis ") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
623 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
624 |
develop(bool, Use24BitFP, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
625 |
"use FP instructions that produce 24-bit precise results") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
626 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
627 |
develop(bool, MonomorphicArrayCheck, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
628 |
"Uncommon-trap array store checks that require full type check") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
629 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
630 |
notproduct(bool, TracePhaseCCP, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
631 |
"Print progress during Conditional Constant Propagation") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
632 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
633 |
develop(bool, PrintDominators, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
634 |
"Print out dominator trees for GVN") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
635 |
\ |
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33447
diff
changeset
|
636 |
diagnostic(bool, TraceSpilling, false, \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
637 |
"Trace spilling") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
638 |
\ |
13884 | 639 |
diagnostic(bool, TraceTypeProfile, false, \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
640 |
"Trace type profile") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
641 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
642 |
develop(bool, PoisonOSREntry, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
643 |
"Detect abnormal calls to OSR code") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
644 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
645 |
develop(bool, SoftMatchFailure, trueInProduct, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
646 |
"If the DFA fails to match a node, print a message and bail out") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
647 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
648 |
develop(bool, InlineAccessors, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
649 |
"inline accessor methods (get/set)") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
650 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
651 |
product(intx, TypeProfileMajorReceiverPercent, 90, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
652 |
"% of major receiver type to all profiled receivers") \ |
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
653 |
range(0, 100) \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
654 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
655 |
diagnostic(bool, PrintIntrinsics, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
656 |
"prints attempted and successful inlining of intrinsics") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
657 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
658 |
develop(bool, StressReflectiveCode, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
659 |
"Use inexact types at allocations, etc., to test reflection") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
660 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
661 |
diagnostic(bool, DebugInlinedCalls, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
662 |
"If false, restricts profiled locations to the root method only") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
663 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
664 |
notproduct(bool, VerifyLoopOptimizations, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
665 |
"verify major loop optimizations") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
666 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
667 |
diagnostic(bool, ProfileDynamicTypes, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
668 |
"do extra type profiling and use it more aggressively") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
669 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
670 |
develop(bool, TraceIterativeGVN, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
671 |
"Print progress during Iterative Global Value Numbering") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
672 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
673 |
develop(bool, VerifyIterativeGVN, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
674 |
"Verify Def-Use modifications during sparse Iterative Global " \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
675 |
"Value Numbering") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
676 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
677 |
notproduct(bool, TraceCISCSpill, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
678 |
"Trace allocators use of cisc spillable instructions") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
679 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
680 |
product(bool, SplitIfBlocks, true, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
681 |
"Clone compares and control flow through merge points to fold " \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
682 |
"some branches") \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
683 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
684 |
develop(intx, FreqCountInvocations, 1, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
685 |
"Scaling factor for branch frequencies (deprecated)") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
686 |
range(1, max_intx) \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
687 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
688 |
product(intx, AliasLevel, 3, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
689 |
"0 for no aliasing, 1 for oop/field/static/array split, " \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
690 |
"2 for class split, 3 for unique instances") \ |
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
691 |
range(0, 3) \ |
31995
aa4049b4184a
8130459: Add additional validation after heap creation
sangheki
parents:
31584
diff
changeset
|
692 |
constraint(AliasLevelConstraintFunc,AfterErgo) \ |
13521
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
693 |
\ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
694 |
develop(bool, VerifyAliases, false, \ |
97a23be06f4e
6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents:
13108
diff
changeset
|
695 |
"perform extra checks on the results of alias analysis") \ |
15113 | 696 |
\ |
697 |
product(bool, IncrementalInline, true, \ |
|
698 |
"do post parse inlining") \ |
|
699 |
\ |
|
700 |
develop(bool, AlwaysIncrementalInline, false, \ |
|
701 |
"do all inlining incrementally") \ |
|
702 |
\ |
|
27707
f7d26e5b8b5d
8058148: MaxNodeLimit and LiveNodeCountInliningCutoff
vlivanov
parents:
27424
diff
changeset
|
703 |
product(intx, LiveNodeCountInliningCutoff, 40000, \ |
15113 | 704 |
"max number of live nodes in a method") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
705 |
range(0, max_juint / 8) \ |
15618
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15242
diff
changeset
|
706 |
\ |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15242
diff
changeset
|
707 |
diagnostic(bool, OptimizeExpensiveOps, true, \ |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15242
diff
changeset
|
708 |
"Find best control for expensive operations") \ |
20289 | 709 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
710 |
diagnostic(bool, UseMathExactIntrinsics, true, \ |
21089
e1986ff6fe2e
8024069: replace_in_map() should operate on parent maps
roland
parents:
20289
diff
changeset
|
711 |
"Enables intrinsification of various java.lang.Math functions") \ |
e1986ff6fe2e
8024069: replace_in_map() should operate on parent maps
roland
parents:
20289
diff
changeset
|
712 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
713 |
diagnostic(bool, UseMultiplyToLenIntrinsic, false, \ |
26434
09ad55e5f486
8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents:
24946
diff
changeset
|
714 |
"Enables intrinsification of BigInteger.multiplyToLen()") \ |
09ad55e5f486
8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents:
24946
diff
changeset
|
715 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
716 |
diagnostic(bool, UseSquareToLenIntrinsic, false, \ |
31129
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30624
diff
changeset
|
717 |
"Enables intrinsification of BigInteger.squareToLen()") \ |
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30624
diff
changeset
|
718 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
719 |
diagnostic(bool, UseMulAddIntrinsic, false, \ |
31129
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30624
diff
changeset
|
720 |
"Enables intrinsification of BigInteger.mulAdd()") \ |
02ee7609f0e1
8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents:
30624
diff
changeset
|
721 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
722 |
diagnostic(bool, UseMontgomeryMultiplyIntrinsic, false, \ |
31583
eb5bea7b4835
8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents:
31129
diff
changeset
|
723 |
"Enables intrinsification of BigInteger.montgomeryMultiply()") \ |
eb5bea7b4835
8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents:
31129
diff
changeset
|
724 |
\ |
38285
20b85a0ba796
8153655: Make intrinsics flags diagnostic and update intrinsics tests to enable diagnostic options
rraghavan
parents:
38046
diff
changeset
|
725 |
diagnostic(bool, UseMontgomerySquareIntrinsic, false, \ |
31583
eb5bea7b4835
8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents:
31129
diff
changeset
|
726 |
"Enables intrinsification of BigInteger.montgomerySquare()") \ |
eb5bea7b4835
8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents:
31129
diff
changeset
|
727 |
\ |
23208 | 728 |
product(bool, UseTypeSpeculation, true, \ |
22856
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22853
diff
changeset
|
729 |
"Speculatively propagate types from profiles") \ |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22853
diff
changeset
|
730 |
\ |
22928
b2bb101a9ae3
8031754: Type speculation should favor profile data from outermost inlined method
roland
parents:
22911
diff
changeset
|
731 |
diagnostic(bool, UseInlineDepthForSpeculativeTypes, true, \ |
b2bb101a9ae3
8031754: Type speculation should favor profile data from outermost inlined method
roland
parents:
22911
diff
changeset
|
732 |
"Carry inline depth of profile point with speculative type " \ |
b2bb101a9ae3
8031754: Type speculation should favor profile data from outermost inlined method
roland
parents:
22911
diff
changeset
|
733 |
"and give priority to profiling from lower inline depth") \ |
b2bb101a9ae3
8031754: Type speculation should favor profile data from outermost inlined method
roland
parents:
22911
diff
changeset
|
734 |
\ |
22856
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22853
diff
changeset
|
735 |
product_pd(bool, TrapBasedRangeChecks, \ |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22853
diff
changeset
|
736 |
"Generate code for range checks that uses a cmp and trap " \ |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22853
diff
changeset
|
737 |
"instruction raising SIGTRAP. Used on PPC64.") \ |
28396
7fe4347e6792
6700100: optimize inline_native_clone() for small objects with exact klass
roland
parents:
27707
diff
changeset
|
738 |
\ |
7fe4347e6792
6700100: optimize inline_native_clone() for small objects with exact klass
roland
parents:
27707
diff
changeset
|
739 |
product(intx, ArrayCopyLoadStoreMaxElem, 8, \ |
7fe4347e6792
6700100: optimize inline_native_clone() for small objects with exact klass
roland
parents:
27707
diff
changeset
|
740 |
"Maximum number of arraycopy elements inlined as a sequence of" \ |
7fe4347e6792
6700100: optimize inline_native_clone() for small objects with exact klass
roland
parents:
27707
diff
changeset
|
741 |
"loads/stores") \ |
33163
9e128b399e48
8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents:
33065
diff
changeset
|
742 |
range(0, max_intx) \ |
28396
7fe4347e6792
6700100: optimize inline_native_clone() for small objects with exact klass
roland
parents:
27707
diff
changeset
|
743 |
\ |
7fe4347e6792
6700100: optimize inline_native_clone() for small objects with exact klass
roland
parents:
27707
diff
changeset
|
744 |
develop(bool, StressArrayCopyMacroNode, false, \ |
34503
57d1a0e76091
8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents:
34162
diff
changeset
|
745 |
"Perform ArrayCopy load/store replacement during IGVN only") \ |
57d1a0e76091
8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents:
34162
diff
changeset
|
746 |
\ |
57d1a0e76091
8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents:
34162
diff
changeset
|
747 |
develop(bool, RenumberLiveNodes, true, \ |
57d1a0e76091
8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents:
34162
diff
changeset
|
748 |
"Renumber live nodes") \ |
48145 | 749 |
\ |
750 |
product(uintx, LoopStripMiningIter, 0, \ |
|
751 |
"Number of iterations in strip mined loop") \ |
|
752 |
range(0, max_juint) \ |
|
753 |
\ |
|
754 |
product(uintx, LoopStripMiningIterShortLoop, 0, \ |
|
755 |
"Loop with fewer iterations are not strip mined") \ |
|
756 |
range(0, max_juint) \ |
|
50623
5209d8a6303e
8203197: C2: consider all paths in loop body for loop predication
roland
parents:
50449
diff
changeset
|
757 |
\ |
5209d8a6303e
8203197: C2: consider all paths in loop body for loop predication
roland
parents:
50449
diff
changeset
|
758 |
product(bool, UseProfiledLoopPredicate, true, \ |
5209d8a6303e
8203197: C2: consider all paths in loop body for loop predication
roland
parents:
50449
diff
changeset
|
759 |
"move predicates out of loops based on profiling data") \ |
1 | 760 |
|
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
761 |
C2_FLAGS(DECLARE_DEVELOPER_FLAG, \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
762 |
DECLARE_PD_DEVELOPER_FLAG, \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
763 |
DECLARE_PRODUCT_FLAG, \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
764 |
DECLARE_PD_PRODUCT_FLAG, \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
765 |
DECLARE_DIAGNOSTIC_FLAG, \ |
39117 | 766 |
DECLARE_PD_DIAGNOSTIC_FLAG, \ |
31371
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
767 |
DECLARE_EXPERIMENTAL_FLAG, \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
768 |
DECLARE_NOTPRODUCT_FLAG, \ |
311143309e73
8122937: [JEP 245] Validate JVM Command-Line Flag Arguments.
gziemski
parents:
31129
diff
changeset
|
769 |
IGNORE_RANGE, \ |
38273
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
770 |
IGNORE_CONSTRAINT, \ |
2634194d7555
8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents:
38046
diff
changeset
|
771 |
IGNORE_WRITEABLE) |
7397 | 772 |
|
773 |
#endif // SHARE_VM_OPTO_C2_GLOBALS_HPP |