0
|
1 /*
|
|
2 * Copyright 2000-2007 Sun Microsystems, Inc. All Rights Reserved.
|
|
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 *
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
21 * have any questions.
|
|
22 *
|
|
23 */
|
|
24
|
|
25 //
|
|
26 // Defines all globals flags used by the server compiler.
|
|
27 //
|
|
28
|
|
29 #define C2_FLAGS(develop, develop_pd, product, product_pd, diagnostic, notproduct) \
|
|
30 \
|
|
31 notproduct(intx, CompileZapFirst, 0, \
|
|
32 "If +ZapDeadCompiledLocals, " \
|
|
33 "skip this many before compiling in zap calls") \
|
|
34 \
|
|
35 notproduct(intx, CompileZapLast, -1, \
|
|
36 "If +ZapDeadCompiledLocals, " \
|
|
37 "compile this many after skipping (incl. skip count, -1 = all)") \
|
|
38 \
|
|
39 notproduct(intx, ZapDeadCompiledLocalsFirst, 0, \
|
|
40 "If +ZapDeadCompiledLocals, " \
|
|
41 "skip this many before really doing it") \
|
|
42 \
|
|
43 notproduct(intx, ZapDeadCompiledLocalsLast, -1, \
|
|
44 "If +ZapDeadCompiledLocals, " \
|
|
45 "do this many after skipping (incl. skip count, -1 = all)") \
|
|
46 \
|
|
47 develop(intx, OptoPrologueNops, 0, \
|
|
48 "Insert this many extra nop instructions " \
|
|
49 "in the prologue of every nmethod") \
|
|
50 \
|
|
51 product_pd(intx, InteriorEntryAlignment, \
|
|
52 "Code alignment for interior entry points " \
|
|
53 "in generated code (in bytes)") \
|
|
54 \
|
|
55 product_pd(intx, OptoLoopAlignment, \
|
|
56 "Align inner loops to zero relative to this modulus") \
|
|
57 \
|
|
58 product(intx, MaxLoopPad, (OptoLoopAlignment-1), \
|
|
59 "Align a loop if padding size in bytes is less or equal to this value") \
|
|
60 \
|
|
61 product(intx, NumberOfLoopInstrToAlign, 4, \
|
|
62 "Number of first instructions in a loop to align") \
|
|
63 \
|
|
64 notproduct(intx, IndexSetWatch, 0, \
|
|
65 "Trace all operations on this IndexSet (-1 means all, 0 none)") \
|
|
66 \
|
|
67 develop(intx, OptoNodeListSize, 4, \
|
|
68 "Starting allocation size of Node_List data structures") \
|
|
69 \
|
|
70 develop(intx, OptoBlockListSize, 8, \
|
|
71 "Starting allocation size of Block_List data structures") \
|
|
72 \
|
|
73 develop(intx, OptoPeepholeAt, -1, \
|
|
74 "Apply peephole optimizations to this peephole rule") \
|
|
75 \
|
|
76 notproduct(bool, PrintIdeal, false, \
|
|
77 "Print ideal graph before code generation") \
|
|
78 \
|
|
79 notproduct(bool, PrintOpto, false, \
|
|
80 "Print compiler2 attempts") \
|
|
81 \
|
|
82 notproduct(bool, PrintOptoInlining, false, \
|
|
83 "Print compiler2 inlining decisions") \
|
|
84 \
|
|
85 notproduct(bool, VerifyOpto, false, \
|
|
86 "Apply more time consuming verification during compilation") \
|
|
87 \
|
|
88 notproduct(bool, VerifyOptoOopOffsets, false, \
|
|
89 "Check types of base addresses in field references") \
|
|
90 \
|
|
91 develop(bool, IdealizedNumerics, false, \
|
|
92 "Check performance difference allowing FP " \
|
|
93 "associativity and commutativity...") \
|
|
94 \
|
|
95 develop(bool, OptoBreakpoint, false, \
|
|
96 "insert breakpoint at method entry") \
|
|
97 \
|
|
98 notproduct(bool, OptoBreakpointOSR, false, \
|
|
99 "insert breakpoint at osr method entry") \
|
|
100 \
|
|
101 notproduct(intx, BreakAtNode, 0, \
|
|
102 "Break at construction of this Node (either _idx or _debug_idx)") \
|
|
103 \
|
|
104 notproduct(bool, OptoBreakpointC2R, false, \
|
|
105 "insert breakpoint at runtime stub entry") \
|
|
106 \
|
|
107 notproduct(bool, OptoNoExecute, false, \
|
|
108 "Attempt to parse and compile but do not execute generated code") \
|
|
109 \
|
|
110 notproduct(bool, PrintOptoStatistics, false, \
|
|
111 "Print New compiler statistics") \
|
|
112 \
|
|
113 notproduct(bool, PrintOptoAssembly, false, \
|
|
114 "Print New compiler assembly output") \
|
|
115 \
|
|
116 develop_pd(bool, OptoPeephole, \
|
|
117 "Apply peephole optimizations after register allocation") \
|
|
118 \
|
|
119 develop(bool, OptoRemoveUseless, true, \
|
|
120 "Remove useless nodes after parsing") \
|
|
121 \
|
|
122 notproduct(bool, PrintFrameConverterAssembly, false, \
|
|
123 "Print New compiler assembly output for frame converters") \
|
|
124 \
|
|
125 notproduct(bool, PrintParseStatistics, false, \
|
|
126 "Print nodes, transforms and new values made per bytecode parsed")\
|
|
127 \
|
|
128 notproduct(bool, PrintOptoPeephole, false, \
|
|
129 "Print New compiler peephole replacements") \
|
|
130 \
|
|
131 develop(bool, PrintCFGBlockFreq, false, \
|
|
132 "Print CFG block freqencies") \
|
|
133 \
|
|
134 develop(bool, TraceOptoParse, false, \
|
|
135 "Trace bytecode parse and control-flow merge") \
|
|
136 \
|
|
137 product_pd(intx, LoopUnrollLimit, \
|
|
138 "Unroll loop bodies with node count less than this") \
|
|
139 \
|
|
140 product(intx, LoopUnrollMin, 4, \
|
|
141 "Minimum number of unroll loop bodies before checking progress" \
|
|
142 "of rounds of unroll,optimize,..") \
|
|
143 \
|
|
144 develop(intx, UnrollLimitForProfileCheck, 1, \
|
|
145 "Don't use profile_trip_cnt() to restrict unrolling until " \
|
|
146 "unrolling would push the number of unrolled iterations above " \
|
|
147 "UnrollLimitForProfileCheck. A higher value allows more " \
|
|
148 "unrolling. Zero acts as a very large value." ) \
|
|
149 \
|
|
150 product(intx, MultiArrayExpandLimit, 6, \
|
|
151 "Maximum number of individual allocations in an inline-expanded " \
|
|
152 "multianewarray instruction") \
|
|
153 \
|
|
154 notproduct(bool, TraceProfileTripCount, false, \
|
|
155 "Trace profile loop trip count information") \
|
|
156 \
|
|
157 develop(bool, OptoCoalesce, true, \
|
|
158 "Use Conservative Copy Coalescing in the Register Allocator") \
|
|
159 \
|
|
160 develop(bool, UseUniqueSubclasses, true, \
|
|
161 "Narrow an abstract reference to the unique concrete subclass") \
|
|
162 \
|
|
163 develop(bool, UseExactTypes, true, \
|
|
164 "Use exact types to eliminate array store checks and v-calls") \
|
|
165 \
|
|
166 product(intx, TrackedInitializationLimit, 50, \
|
|
167 "When initializing fields, track up to this many words") \
|
|
168 \
|
|
169 product(bool, ReduceFieldZeroing, true, \
|
|
170 "When initializing fields, try to avoid needless zeroing") \
|
|
171 \
|
|
172 product(bool, ReduceInitialCardMarks, true, \
|
|
173 "When initializing fields, try to avoid needless card marks") \
|
|
174 \
|
|
175 product(bool, ReduceBulkZeroing, true, \
|
|
176 "When bulk-initializing, try to avoid needless zeroing") \
|
|
177 \
|
|
178 develop_pd(intx, RegisterCostAreaRatio, \
|
|
179 "Spill selection in reg allocator: scale area by (X/64K) before " \
|
|
180 "adding cost") \
|
|
181 \
|
|
182 develop_pd(bool, UseCISCSpill, \
|
|
183 "Use ADLC supplied cisc instructions during allocation") \
|
|
184 \
|
|
185 notproduct(bool, VerifyGraphEdges , false, \
|
|
186 "Verify Bi-directional Edges") \
|
|
187 \
|
|
188 notproduct(bool, VerifyDUIterators, true, \
|
|
189 "Verify the safety of all iterations of Bi-directional Edges") \
|
|
190 \
|
|
191 notproduct(bool, VerifyHashTableKeys, true, \
|
|
192 "Verify the immutability of keys in the VN hash tables") \
|
|
193 \
|
|
194 develop_pd(intx, FLOATPRESSURE, \
|
|
195 "Number of float LRG's that constitute high register pressure") \
|
|
196 \
|
|
197 develop_pd(intx, INTPRESSURE, \
|
|
198 "Number of integer LRG's that constitute high register pressure") \
|
|
199 \
|
|
200 notproduct(bool, TraceOptoPipelining, false, \
|
|
201 "Trace pipelining information") \
|
|
202 \
|
|
203 notproduct(bool, TraceOptoOutput, false, \
|
|
204 "Trace pipelining information") \
|
|
205 \
|
|
206 product_pd(bool, OptoScheduling, \
|
|
207 "Instruction Scheduling after register allocation") \
|
|
208 \
|
|
209 product(bool, PartialPeelLoop, true, \
|
|
210 "Partial peel (rotate) loops") \
|
|
211 \
|
|
212 product(intx, PartialPeelNewPhiDelta, 0, \
|
|
213 "Additional phis that can be created by partial peeling") \
|
|
214 \
|
|
215 notproduct(bool, TracePartialPeeling, false, \
|
|
216 "Trace partial peeling (loop rotation) information") \
|
|
217 \
|
|
218 product(bool, PartialPeelAtUnsignedTests, true, \
|
|
219 "Partial peel at unsigned tests if no signed test exists") \
|
|
220 \
|
|
221 product(bool, ReassociateInvariants, true, \
|
|
222 "Enable reassociation of expressions with loop invariants.") \
|
|
223 \
|
|
224 product(bool, LoopUnswitching, true, \
|
|
225 "Enable loop unswitching (a form of invariant test hoisting)") \
|
|
226 \
|
|
227 notproduct(bool, TraceLoopUnswitching, false, \
|
|
228 "Trace loop unswitching") \
|
|
229 \
|
|
230 product(bool, UseSuperWord, true, \
|
|
231 "Transform scalar operations into superword operations") \
|
|
232 \
|
|
233 develop(bool, SuperWordRTDepCheck, false, \
|
|
234 "Enable runtime dependency checks.") \
|
|
235 \
|
|
236 product(bool, TraceSuperWord, false, \
|
|
237 "Trace superword transforms") \
|
|
238 \
|
|
239 product_pd(bool, OptoBundling, \
|
|
240 "Generate nops to fill i-cache lines") \
|
|
241 \
|
|
242 product_pd(intx, ConditionalMoveLimit, \
|
|
243 "Limit of ops to make speculative when using CMOVE") \
|
|
244 \
|
|
245 /* Set BranchOnRegister == false. See 4965987. */ \
|
|
246 product(bool, BranchOnRegister, false, \
|
|
247 "Use Sparc V9 branch-on-register opcodes") \
|
|
248 \
|
|
249 develop(bool, SparcV9RegsHiBitsZero, true, \
|
|
250 "Assume Sparc V9 I&L registers on V8+ systems are zero-extended") \
|
|
251 \
|
|
252 develop(intx, PrintIdealGraphLevel, 0, \
|
|
253 "Print ideal graph to XML file / network interface. " \
|
|
254 "By default attempts to connect to the visualizer on a socket.") \
|
|
255 \
|
|
256 develop(intx, PrintIdealGraphPort, 4444, \
|
|
257 "Ideal graph printer to network port") \
|
|
258 \
|
|
259 develop(ccstr, PrintIdealGraphAddress, "127.0.0.1", \
|
|
260 "IP address to connect to visualizer") \
|
|
261 \
|
|
262 develop(ccstr, PrintIdealGraphFile, NULL, \
|
|
263 "File to dump ideal graph to. If set overrides the " \
|
|
264 "use of the network") \
|
|
265 \
|
|
266 product(bool, UseOldInlining, true, \
|
|
267 "Enable the 1.3 inlining strategy") \
|
|
268 \
|
|
269 product(bool, UseBimorphicInlining, true, \
|
|
270 "Profiling based inlining for two receivers") \
|
|
271 \
|
|
272 product(bool, UseOnlyInlinedBimorphic, true, \
|
|
273 "Don't use BimorphicInlining if can't inline a second method") \
|
|
274 \
|
|
275 product(bool, InsertMemBarAfterArraycopy, true, \
|
|
276 "Insert memory barrier after arraycopy call") \
|
|
277 \
|
|
278 /* controls for tier 1 compilations */ \
|
|
279 \
|
|
280 develop(bool, Tier1CountInvocations, true, \
|
|
281 "Generate code, during tier 1, to update invocation counter") \
|
|
282 \
|
|
283 product(intx, Tier1Inline, false, \
|
|
284 "enable inlining during tier 1") \
|
|
285 \
|
|
286 product(intx, Tier1MaxInlineSize, 8, \
|
|
287 "maximum bytecode size of a method to be inlined, during tier 1") \
|
|
288 \
|
|
289 product(intx, Tier1FreqInlineSize, 35, \
|
|
290 "max bytecode size of a frequent method to be inlined, tier 1") \
|
|
291 \
|
|
292 develop(intx, ImplicitNullCheckThreshold, 3, \
|
|
293 "Don't do implicit null checks if NPE's in a method exceeds limit") \
|
|
294 \
|
|
295 /* controls for loop optimization */ \
|
|
296 product(intx, Tier1LoopOptsCount, 0, \
|
|
297 "Set level of loop optimization for tier 1 compiles") \
|
|
298 \
|
|
299 product(intx, LoopOptsCount, 43, \
|
|
300 "Set level of loop optimization for tier 1 compiles") \
|
|
301 \
|
|
302 /* controls for heat-based inlining */ \
|
|
303 \
|
|
304 develop(intx, NodeCountInliningCutoff, 18000, \
|
|
305 "If parser node generation exceeds limit stop inlining") \
|
|
306 \
|
|
307 develop(intx, NodeCountInliningStep, 1000, \
|
|
308 "Target size of warm calls inlined between optimization passes") \
|
|
309 \
|
|
310 develop(bool, InlineWarmCalls, false, \
|
|
311 "Use a heat-based priority queue to govern inlining") \
|
|
312 \
|
|
313 develop(intx, HotCallCountThreshold, 999999, \
|
|
314 "large numbers of calls (per method invocation) force hotness") \
|
|
315 \
|
|
316 develop(intx, HotCallProfitThreshold, 999999, \
|
|
317 "highly profitable inlining opportunities force hotness") \
|
|
318 \
|
|
319 develop(intx, HotCallTrivialWork, -1, \
|
|
320 "trivial execution time (no larger than this) forces hotness") \
|
|
321 \
|
|
322 develop(intx, HotCallTrivialSize, -1, \
|
|
323 "trivial methods (no larger than this) force calls to be hot") \
|
|
324 \
|
|
325 develop(intx, WarmCallMinCount, -1, \
|
|
326 "number of calls (per method invocation) to enable inlining") \
|
|
327 \
|
|
328 develop(intx, WarmCallMinProfit, -1, \
|
|
329 "number of calls (per method invocation) to enable inlining") \
|
|
330 \
|
|
331 develop(intx, WarmCallMaxWork, 999999, \
|
|
332 "execution time of the largest inlinable method") \
|
|
333 \
|
|
334 develop(intx, WarmCallMaxSize, 999999, \
|
|
335 "size of the largest inlinable method") \
|
|
336 \
|
|
337 product(intx, MaxNodeLimit, 65000, \
|
|
338 "Maximum number of nodes") \
|
|
339 \
|
|
340 product(intx, NodeLimitFudgeFactor, 1000, \
|
|
341 "Fudge Factor for certain optimizations") \
|
|
342 \
|
|
343 product(bool, UseJumpTables, true, \
|
|
344 "Use JumpTables instead of a binary search tree for switches") \
|
|
345 \
|
|
346 product(bool, UseDivMod, true, \
|
|
347 "Use combined DivMod instruction if available") \
|
|
348 \
|
|
349 product(intx, MinJumpTableSize, 18, \
|
|
350 "Minimum number of targets in a generated jump table") \
|
|
351 \
|
|
352 product(intx, MaxJumpTableSize, 65000, \
|
|
353 "Maximum number of targets in a generated jump table") \
|
|
354 \
|
|
355 product(intx, MaxJumpTableSparseness, 5, \
|
|
356 "Maximum sparseness for jumptables") \
|
|
357 \
|
|
358 product(bool, EliminateLocks, true, \
|
|
359 "Coarsen locks when possible") \
|
|
360 \
|
|
361 notproduct(bool, PrintLockStatistics, false, \
|
|
362 "Print precise statistics on the dynamic lock usage") \
|
|
363 \
|
|
364 diagnostic(bool, PrintPreciseBiasedLockingStatistics, false, \
|
|
365 "Print per-lock-site statistics of biased locking in JVM") \
|
|
366 \
|
|
367 notproduct(bool, PrintEliminateLocks, false, \
|
|
368 "Print out when locks are eliminated") \
|
|
369 \
|
|
370 product(bool, DoEscapeAnalysis, false, \
|
|
371 "Perform escape analysis") \
|
|
372 \
|
|
373 notproduct(bool, PrintEscapeAnalysis, false, \
|
|
374 "Print the results of escape analysis") \
|
|
375 \
|
|
376 product(bool, EliminateAllocations, true, \
|
|
377 "Use escape analysis to eliminate allocations") \
|
|
378 \
|
|
379 product(intx, MaxLabelRootDepth, 1100, \
|
|
380 "Maximum times call Label_Root to prevent stack overflow") \
|
|
381
|
|
382 C2_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG)
|