OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [lib/] [gcc/] [or1knd-elf/] [4.8.0/] [plugin/] [include/] [params.def] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
/* params.def - Run-time parameters.
2
   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3
   2011, 2012
4
   Free Software Foundation, Inc.
5
   Written by Mark Mitchell .
6
 
7
This file is part of GCC.
8
 
9
GCC is free software; you can redistribute it and/or modify it under
10
the terms of the GNU General Public License as published by the Free
11
Software Foundation; either version 3, or (at your option) any later
12
version.
13
 
14
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15
WARRANTY; without even the implied warranty of MERCHANTABILITY or
16
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17
for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with GCC; see the file COPYING3.  If not see
21
.  */
22
 
23
/* This file contains definitions for language-independent
24
   parameters.  The DEFPARAM macro takes 6 arguments:
25
 
26
     - The enumeral corresponding to this parameter.
27
 
28
     - The name that can be used to set this parameter using the
29
       command-line option `--param ='.
30
 
31
     - A help string explaining how the parameter is used.
32
 
33
     - A default value for the parameter.
34
 
35
     - The minimum acceptable value for the parameter.
36
 
37
     - The maximum acceptable value for the parameter (if greater than
38
     the minimum).
39
 
40
   Be sure to add an entry to invoke.texi summarizing the parameter.  */
41
 
42
/* When branch is predicted to be taken with probability lower than this
43
   threshold (in percent), then it is considered well predictable. */
44
DEFPARAM (PARAM_PREDICTABLE_BRANCH_OUTCOME,
45
          "predictable-branch-outcome",
46
          "Maximal estimated outcome of branch considered predictable",
47
          2, 0, 50)
48
 
49
DEFPARAM (PARAM_INLINE_MIN_SPEEDUP,
50
          "inline-min-speedup",
51
          "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-isnsns-auto",
52
          10, 0, 0)
53
 
54
/* The single function inlining limit. This is the maximum size
55
   of a function counted in internal gcc instructions (not in
56
   real machine instructions) that is eligible for inlining
57
   by the tree inliner.
58
   The default value is 450.
59
   Only functions marked inline (or methods defined in the class
60
   definition for C++) are affected by this.
61
   There are more restrictions to inlining: If inlined functions
62
   call other functions, the already inlined instructions are
63
   counted and once the recursive inline limit (see
64
   "max-inline-insns" parameter) is exceeded, the acceptable size
65
   gets decreased.  */
66
DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE,
67
          "max-inline-insns-single",
68
          "The maximum number of instructions in a single function eligible for inlining",
69
          400, 0, 0)
70
 
71
/* The single function inlining limit for functions that are
72
   inlined by virtue of -finline-functions (-O3).
73
   This limit should be chosen to be below or equal to the limit
74
   that is applied to functions marked inlined (or defined in the
75
   class declaration in C++) given by the "max-inline-insns-single"
76
   parameter.
77
   The default value is 40.  */
78
DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO,
79
          "max-inline-insns-auto",
80
          "The maximum number of instructions when automatically inlining",
81
          40, 0, 0)
82
 
83
DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE,
84
          "max-inline-insns-recursive",
85
          "The maximum number of instructions inline function can grow to via recursive inlining",
86
          450, 0, 0)
87
 
88
DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO,
89
          "max-inline-insns-recursive-auto",
90
          "The maximum number of instructions non-inline function can grow to via recursive inlining",
91
          450, 0, 0)
92
 
93
DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH,
94
          "max-inline-recursive-depth",
95
          "The maximum depth of recursive inlining for inline functions",
96
          8, 0, 0)
97
 
98
DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO,
99
          "max-inline-recursive-depth-auto",
100
          "The maximum depth of recursive inlining for non-inline functions",
101
          8, 0, 0)
102
 
103
DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY,
104
          "min-inline-recursive-probability",
105
          "Inline recursively only when the probability of call being executed exceeds the parameter",
106
          10, 0, 0)
107
 
108
/* Limit of iterations of early inliner.  This basically bounds number of
109
   nested indirect calls early inliner can resolve.  Deeper chains are still
110
   handled by late inlining.  */
111
DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS,
112
          "max-early-inliner-iterations",
113
          "The maximum number of nested indirect inlining performed by early inliner",
114
          10, 0, 0)
115
 
116
/* Limit on probability of entry BB.  */
117
DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY,
118
          "comdat-sharing-probability",
119
          "Probability that COMDAT function will be shared with different compilation unit",
120
          20, 0, 0)
121
 
122
/* Limit on probability of entry BB.  */
123
DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY,
124
          "partial-inlining-entry-probability",
125
          "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen",
126
          70, 0, 0)
127
 
128
/* Limit the number of expansions created by the variable expansion
129
   optimization to avoid register pressure.  */
130
DEFPARAM (PARAM_MAX_VARIABLE_EXPANSIONS,
131
          "max-variable-expansions-in-unroller",
132
          "If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling",
133
          1, 0, 0)
134
 
135
/* Limit loop autovectorization to loops with large enough iteration count.  */
136
DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND,
137
          "min-vect-loop-bound",
138
          "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization",
139
          1, 1, 0)
140
 
141
/* The maximum number of instructions to consider when looking for an
142
   instruction to fill a delay slot.  If more than this arbitrary
143
   number of instructions is searched, the time savings from filling
144
   the delay slot will be minimal so stop searching.  Increasing
145
   values mean more aggressive optimization, making the compile time
146
   increase with probably small improvement in executable run time.  */
147
DEFPARAM (PARAM_MAX_DELAY_SLOT_INSN_SEARCH,
148
          "max-delay-slot-insn-search",
149
          "The maximum number of instructions to consider to fill a delay slot",
150
          100, 0, 0)
151
 
152
/* When trying to fill delay slots, the maximum number of instructions
153
   to consider when searching for a block with valid live register
154
   information.  Increasing this arbitrarily chosen value means more
155
   aggressive optimization, increasing the compile time.  This
156
   parameter should be removed when the delay slot code is rewritten
157
   to maintain the control-flow graph.  */
158
DEFPARAM(PARAM_MAX_DELAY_SLOT_LIVE_SEARCH,
159
         "max-delay-slot-live-search",
160
         "The maximum number of instructions to consider to find accurate live register information",
161
         333, 0, 0)
162
 
163
/* This parameter limits the number of branch elements that the
164
   scheduler will track anti-dependencies through without resetting
165
   the tracking mechanism.  Large functions with few calls or barriers
166
   can generate lists containing many 1000's of dependencies.  Generally
167
   the compiler either uses all available memory, or runs for far too long.  */
168
DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH,
169
         "max-pending-list-length",
170
         "The maximum length of scheduling's pending operations list",
171
         32, 0, 0)
172
 
173
/* This parameter limits the number of backtracking attempts when using the
174
   haifa scheduler for modulo scheduling.  */
175
DEFPARAM(PARAM_MAX_MODULO_BACKTRACK_ATTEMPTS,
176
         "max-modulo-backtrack-attempts",
177
         "The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop",
178
         40, 0, 0)
179
 
180
DEFPARAM(PARAM_LARGE_FUNCTION_INSNS,
181
         "large-function-insns",
182
         "The size of function body to be considered large",
183
         2700, 0, 0)
184
DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH,
185
         "large-function-growth",
186
         "Maximal growth due to inlining of large function (in percent)",
187
         100, 0, 0)
188
DEFPARAM(PARAM_LARGE_UNIT_INSNS,
189
         "large-unit-insns",
190
         "The size of translation unit to be considered large",
191
         10000, 0, 0)
192
DEFPARAM(PARAM_INLINE_UNIT_GROWTH,
193
         "inline-unit-growth",
194
         "How much can given compilation unit grow because of the inlining (in percent)",
195
         30, 0, 0)
196
DEFPARAM(PARAM_IPCP_UNIT_GROWTH,
197
         "ipcp-unit-growth",
198
         "How much can given compilation unit grow because of the interprocedural constant propagation (in percent)",
199
         10, 0, 0)
200
DEFPARAM(PARAM_EARLY_INLINING_INSNS,
201
         "early-inlining-insns",
202
         "Maximal estimated growth of function body caused by early inlining of single call",
203
         11, 0, 0)
204
DEFPARAM(PARAM_LARGE_STACK_FRAME,
205
         "large-stack-frame",
206
         "The size of stack frame to be considered large",
207
         256, 0, 0)
208
DEFPARAM(PARAM_STACK_FRAME_GROWTH,
209
         "large-stack-frame-growth",
210
         "Maximal stack frame growth due to inlining (in percent)",
211
         1000, 0, 0)
212
 
213
/* The GCSE optimization will be disabled if it would require
214
   significantly more memory than this value.  */
215
DEFPARAM(PARAM_MAX_GCSE_MEMORY,
216
         "max-gcse-memory",
217
         "The maximum amount of memory to be allocated by GCSE",
218
         50 * 1024 * 1024, 0, 0)
219
 
220
/* The GCSE optimization of an expression will avoided if the ratio of
221
   insertions to deletions is greater than this value.  */
222
DEFPARAM(PARAM_MAX_GCSE_INSERTION_RATIO,
223
         "max-gcse-insertion-ratio",
224
         "The maximum ratio of insertions to deletions of expressions in GCSE",
225
         20, 0, 0)
226
 
227
/* This is the threshold ratio when to perform partial redundancy
228
   elimination after reload. We perform partial redundancy elimination
229
   when the following holds:
230
   (Redundant load execution count)
231
   ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION
232
   (Added loads execution count)                                          */
233
DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION,
234
        "gcse-after-reload-partial-fraction",
235
        "The threshold ratio for performing partial redundancy elimination after reload",
236
        3, 0, 0)
237
/* This is the threshold ratio of the critical edges execution count compared to
238
   the redundant loads execution count that permits performing the load
239
   redundancy elimination in gcse after reload.  */
240
DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION,
241
        "gcse-after-reload-critical-fraction",
242
        "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload",
243
        10, 0, 0)
244
 
245
/* GCSE will use GCSE_COST_DISTANCE_RATION as a scaling factor
246
   to calculate maximum distance for which an expression is allowed to move
247
   from its rtx_cost.  */
248
DEFPARAM(PARAM_GCSE_COST_DISTANCE_RATIO,
249
         "gcse-cost-distance-ratio",
250
         "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations",
251
         10, 0, 0)
252
/* GCSE won't restrict distance for which an expression with rtx_cost greater
253
   than COSTS_N_INSN(GCSE_UNRESTRICTED_COST) is allowed to move.  */
254
DEFPARAM(PARAM_GCSE_UNRESTRICTED_COST,
255
         "gcse-unrestricted-cost",
256
         "Cost at which GCSE optimizations will not constraint the distance an expression can travel",
257
         3, 0, 0)
258
 
259
/* How deep from a given basic block the dominator tree should be searched
260
   for expressions to hoist to the block.  The value of 0 will avoid limiting
261
   the search.  */
262
DEFPARAM(PARAM_MAX_HOIST_DEPTH,
263
         "max-hoist-depth",
264
         "Maximum depth of search in the dominator tree for expressions to hoist",
265
         30, 0, 0)
266
 
267
/* This parameter limits the number of insns in a loop that will be unrolled,
268
   and by how much the loop is unrolled.
269
 
270
   This limit should be at most half of the peeling limits:  loop unroller
271
   decides to not unroll loops that iterate fewer than 2*number of allowed
272
   unrollings and thus we would have loops that are neither peeled or unrolled
273
   otherwise.  */
274
DEFPARAM(PARAM_MAX_UNROLLED_INSNS,
275
         "max-unrolled-insns",
276
         "The maximum number of instructions to consider to unroll in a loop",
277
         200, 0, 0)
278
/* This parameter limits how many times the loop is unrolled depending
279
   on number of insns really executed in each iteration.  */
280
DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS,
281
         "max-average-unrolled-insns",
282
         "The maximum number of instructions to consider to unroll in a loop on average",
283
         80, 0, 0)
284
/* The maximum number of unrollings of a single loop.  */
285
DEFPARAM(PARAM_MAX_UNROLL_TIMES,
286
        "max-unroll-times",
287
        "The maximum number of unrollings of a single loop",
288
        8, 0, 0)
289
/* The maximum number of insns of a peeled loop.  */
290
DEFPARAM(PARAM_MAX_PEELED_INSNS,
291
        "max-peeled-insns",
292
        "The maximum number of insns of a peeled loop",
293
        100, 0, 0)
294
/* The maximum number of peelings of a single loop.  */
295
DEFPARAM(PARAM_MAX_PEEL_TIMES,
296
        "max-peel-times",
297
        "The maximum number of peelings of a single loop",
298
        16, 0, 0)
299
/* The maximum number of peelings of a single loop that is peeled completely.  */
300
DEFPARAM(PARAM_MAX_PEEL_BRANCHES,
301
        "max-peel-branches",
302
        "The maximum number of branches on the path through the peeled sequence",
303
        32, 0, 0)
304
/* The maximum number of insns of a peeled loop.  */
305
DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS,
306
        "max-completely-peeled-insns",
307
        "The maximum number of insns of a completely peeled loop",
308
        100, 0, 0)
309
/* The maximum number of peelings of a single loop that is peeled completely.  */
310
DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES,
311
        "max-completely-peel-times",
312
        "The maximum number of peelings of a single loop that is peeled completely",
313
        16, 0, 0)
314
/* The maximum number of insns of a peeled loop that rolls only once.  */
315
DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS,
316
        "max-once-peeled-insns",
317
        "The maximum number of insns of a peeled loop that rolls only once",
318
        400, 0, 0)
319
/* The maximum depth of a loop nest we completely peel.  */
320
DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS,
321
         "max-completely-peel-loop-nest-depth",
322
         "The maximum depth of a loop nest we completely peel",
323
         8, 0, 0)
324
 
325
/* The maximum number of insns of an unswitched loop.  */
326
DEFPARAM(PARAM_MAX_UNSWITCH_INSNS,
327
        "max-unswitch-insns",
328
        "The maximum number of insns of an unswitched loop",
329
        50, 0, 0)
330
/* The maximum level of recursion in unswitch_single_loop.  */
331
DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL,
332
        "max-unswitch-level",
333
        "The maximum number of unswitchings in a single loop",
334
        3, 0, 0)
335
 
336
/* The maximum number of iterations of a loop the brute force algorithm
337
   for analysis of # of iterations of the loop tries to evaluate.  */
338
DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK,
339
        "max-iterations-to-track",
340
        "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates",
341
        1000, 0, 0)
342
/* A cutoff to avoid costly computations of the number of iterations in
343
   the doloop transformation.  */
344
DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST,
345
        "max-iterations-computation-cost",
346
        "Bound on the cost of an expression to compute the number of iterations",
347
        10, 0, 0)
348
 
349
/* This parameter is used to tune SMS MAX II calculations.  */
350
DEFPARAM(PARAM_SMS_MAX_II_FACTOR,
351
         "sms-max-ii-factor",
352
         "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop",
353
         100, 0, 0)
354
/* The minimum value of stage count that swing modulo scheduler will generate.  */
355
DEFPARAM(PARAM_SMS_MIN_SC,
356
        "sms-min-sc",
357
        "The minimum value of stage count that swing modulo scheduler will generate.",
358
        2, 1, 1)
359
DEFPARAM(PARAM_SMS_DFA_HISTORY,
360
         "sms-dfa-history",
361
         "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA",
362
         0, 0, 0)
363
DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD,
364
         "sms-loop-average-count-threshold",
365
         "A threshold on the average loop count considered by the swing modulo scheduler",
366
         0, 0, 0)
367
 
368
DEFPARAM(HOT_BB_COUNT_WS_PERMILLE,
369
         "hot-bb-count-ws-permille",
370
         "A basic block profile count is considered hot if it contributes to "
371
         "the given permillage of the entire profiled execution",
372
         999, 0, 1000)
373
DEFPARAM(HOT_BB_FREQUENCY_FRACTION,
374
         "hot-bb-frequency-fraction",
375
         "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot",
376
         1000, 0, 0)
377
 
378
DEFPARAM (PARAM_ALIGN_THRESHOLD,
379
          "align-threshold",
380
          "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment",
381
          100, 0, 0)
382
 
383
DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS,
384
          "align-loop-iterations",
385
          "Loops iterating at least selected number of iterations will get loop alignement.",
386
          4, 0, 0)
387
 
388
/* For guessed profiles, the loops having unknown number of iterations
389
   are predicted to iterate relatively few (10) times at average.
390
   For functions containing one loop with large known number of iterations
391
   and other loops having unbounded loops we would end up predicting all
392
   the other loops cold that is not usually the case.  So we need to artificially
393
   flatten the profile.
394
 
395
   We need to cut the maximal predicted iterations to large enough iterations
396
   so the loop appears important, but safely within maximum hotness
397
   range.  */
398
 
399
DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS,
400
         "max-predicted-iterations",
401
         "The maximum number of loop iterations we predict statically",
402
         100, 0, 0)
403
DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK,
404
         "tracer-dynamic-coverage-feedback",
405
         "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available",
406
         95, 0, 100)
407
DEFPARAM(TRACER_DYNAMIC_COVERAGE,
408
         "tracer-dynamic-coverage",
409
         "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available",
410
         75, 0, 100)
411
DEFPARAM(TRACER_MAX_CODE_GROWTH,
412
         "tracer-max-code-growth",
413
         "Maximal code growth caused by tail duplication (in percent)",
414
         100, 0, 0)
415
DEFPARAM(TRACER_MIN_BRANCH_RATIO,
416
         "tracer-min-branch-ratio",
417
         "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)",
418
         10, 0, 100)
419
DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK,
420
         "tracer-min-branch-probability-feedback",
421
         "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available",
422
         80, 0, 100)
423
DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY,
424
         "tracer-min-branch-probability",
425
         "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available",
426
         50, 0, 100)
427
 
428
/* The maximum number of incoming edges to consider for crossjumping.  */
429
DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES,
430
         "max-crossjump-edges",
431
         "The maximum number of incoming edges to consider for crossjumping",
432
         100, 0, 0)
433
 
434
/* The minimum number of matching instructions to consider for crossjumping.  */
435
DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS,
436
     "min-crossjump-insns",
437
     "The minimum number of matching instructions to consider for crossjumping",
438
     5, 0, 0)
439
 
440
/* The maximum number expansion factor when copying basic blocks.  */
441
DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS,
442
     "max-grow-copy-bb-insns",
443
     "The maximum expansion factor when copying basic blocks",
444
     8, 0, 0)
445
 
446
/* The maximum number of insns to duplicate when unfactoring computed gotos.  */
447
DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS,
448
     "max-goto-duplication-insns",
449
     "The maximum number of insns to duplicate when unfactoring computed gotos",
450
     8, 0, 0)
451
 
452
/* The maximum length of path considered in cse.  */
453
DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH,
454
         "max-cse-path-length",
455
         "The maximum length of path considered in cse",
456
         10, 0, 0)
457
DEFPARAM(PARAM_MAX_CSE_INSNS,
458
         "max-cse-insns",
459
         "The maximum instructions CSE process before flushing",
460
         1000, 0, 0)
461
 
462
/* The cost of expression in loop invariant motion that is considered
463
   expensive.  */
464
DEFPARAM(PARAM_LIM_EXPENSIVE,
465
         "lim-expensive",
466
         "The minimum cost of an expensive expression in the loop invariant motion",
467
         20, 0, 0)
468
 
469
/* Bound on number of candidates for induction variables below that
470
   all candidates are considered for each use in induction variable
471
   optimizations.  */
472
 
473
DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND,
474
         "iv-consider-all-candidates-bound",
475
         "Bound on number of candidates below that all candidates are considered in iv optimizations",
476
         30, 0, 0)
477
 
478
/* The induction variable optimizations give up on loops that contain more
479
   induction variable uses.  */
480
 
481
DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES,
482
         "iv-max-considered-uses",
483
         "Bound on number of iv uses in loop optimized in iv optimizations",
484
         250, 0, 0)
485
 
486
/* If there are at most this number of ivs in the set, try removing unnecessary
487
   ivs from the set always.  */
488
 
489
DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND,
490
         "iv-always-prune-cand-set-bound",
491
         "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization",
492
         10, 0, 0)
493
 
494
DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE,
495
         "scev-max-expr-size",
496
         "Bound on size of expressions used in the scalar evolutions analyzer",
497
         100, 0, 0)
498
 
499
DEFPARAM(PARAM_SCEV_MAX_EXPR_COMPLEXITY,
500
         "scev-max-expr-complexity",
501
         "Bound on the complexity of the expressions in the scalar evolutions analyzer",
502
         10, 0, 0)
503
 
504
DEFPARAM(PARAM_OMEGA_MAX_VARS,
505
         "omega-max-vars",
506
         "Bound on the number of variables in Omega constraint systems",
507
         128, 0, 0)
508
 
509
DEFPARAM(PARAM_OMEGA_MAX_GEQS,
510
         "omega-max-geqs",
511
         "Bound on the number of inequalities in Omega constraint systems",
512
         256, 0, 0)
513
 
514
DEFPARAM(PARAM_OMEGA_MAX_EQS,
515
         "omega-max-eqs",
516
         "Bound on the number of equalities in Omega constraint systems",
517
         128, 0, 0)
518
 
519
DEFPARAM(PARAM_OMEGA_MAX_WILD_CARDS,
520
         "omega-max-wild-cards",
521
         "Bound on the number of wild cards in Omega constraint systems",
522
         18, 0, 0)
523
 
524
DEFPARAM(PARAM_OMEGA_HASH_TABLE_SIZE,
525
         "omega-hash-table-size",
526
         "Bound on the size of the hash table in Omega constraint systems",
527
         550, 0, 0)
528
 
529
DEFPARAM(PARAM_OMEGA_MAX_KEYS,
530
         "omega-max-keys",
531
         "Bound on the number of keys in Omega constraint systems",
532
         500, 0, 0)
533
 
534
DEFPARAM(PARAM_OMEGA_ELIMINATE_REDUNDANT_CONSTRAINTS,
535
         "omega-eliminate-redundant-constraints",
536
         "When set to 1, use expensive methods to eliminate all redundant constraints",
537
         0, 0, 1)
538
 
539
DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS,
540
         "vect-max-version-for-alignment-checks",
541
         "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check",
542
         6, 0, 0)
543
 
544
DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS,
545
         "vect-max-version-for-alias-checks",
546
         "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check",
547
         10, 0, 0)
548
 
549
DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS,
550
         "max-cselib-memory-locations",
551
         "The maximum memory locations recorded by cselib",
552
         500, 0, 0)
553
 
554
#ifdef ENABLE_GC_ALWAYS_COLLECT
555
# define GGC_MIN_EXPAND_DEFAULT 0
556
# define GGC_MIN_HEAPSIZE_DEFAULT 0
557
#else
558
# define GGC_MIN_EXPAND_DEFAULT 30
559
# define GGC_MIN_HEAPSIZE_DEFAULT 4096
560
#endif
561
 
562
DEFPARAM(GGC_MIN_EXPAND,
563
         "ggc-min-expand",
564
         "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap",
565
         GGC_MIN_EXPAND_DEFAULT, 0, 0)
566
 
567
DEFPARAM(GGC_MIN_HEAPSIZE,
568
         "ggc-min-heapsize",
569
         "Minimum heap size before we start collecting garbage, in kilobytes",
570
         GGC_MIN_HEAPSIZE_DEFAULT, 0, 0)
571
 
572
#undef GGC_MIN_EXPAND_DEFAULT
573
#undef GGC_MIN_HEAPSIZE_DEFAULT
574
 
575
DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS,
576
         "max-reload-search-insns",
577
         "The maximum number of instructions to search backward when looking for equivalent reload",
578
         100, 0, 0)
579
 
580
DEFPARAM(PARAM_SINK_FREQUENCY_THRESHOLD,
581
         "sink-frequency-threshold",
582
         "Target block's relative execution frequency (as a percentage) required to sink a statement",
583
         75, 0, 100)
584
 
585
DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS,
586
         "max-sched-region-blocks",
587
         "The maximum number of blocks in a region to be considered for interblock scheduling",
588
         10, 0, 0)
589
 
590
DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS,
591
         "max-sched-region-insns",
592
         "The maximum number of insns in a region to be considered for interblock scheduling",
593
         100, 0, 0)
594
 
595
DEFPARAM(PARAM_MAX_PIPELINE_REGION_BLOCKS,
596
         "max-pipeline-region-blocks",
597
         "The maximum number of blocks in a region to be considered for interblock scheduling",
598
         15, 0, 0)
599
 
600
DEFPARAM(PARAM_MAX_PIPELINE_REGION_INSNS,
601
         "max-pipeline-region-insns",
602
         "The maximum number of insns in a region to be considered for interblock scheduling",
603
         200, 0, 0)
604
 
605
DEFPARAM(PARAM_MIN_SPEC_PROB,
606
         "min-spec-prob",
607
         "The minimum probability of reaching a source block for interblock speculative scheduling",
608
         40, 0, 0)
609
 
610
DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS,
611
         "max-sched-extend-regions-iters",
612
         "The maximum number of iterations through CFG to extend regions",
613
         0, 0, 0)
614
 
615
DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY,
616
         "max-sched-insn-conflict-delay",
617
         "The maximum conflict delay for an insn to be considered for speculative motion",
618
         3, 1, 10)
619
 
620
DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF,
621
         "sched-spec-prob-cutoff",
622
         "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.",
623
         40, 0, 100)
624
 
625
DEFPARAM(PARAM_SCHED_STATE_EDGE_PROB_CUTOFF,
626
         "sched-state-edge-prob-cutoff",
627
         "The minimum probability an edge must have for the scheduler to save its state across it.",
628
         10, 0, 100)
629
 
630
DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD,
631
         "selsched-max-lookahead",
632
         "The maximum size of the lookahead window of selective scheduling",
633
         50, 0, 0)
634
 
635
DEFPARAM(PARAM_SELSCHED_MAX_SCHED_TIMES,
636
         "selsched-max-sched-times",
637
         "Maximum number of times that an insn could be scheduled",
638
         2, 0, 0)
639
 
640
DEFPARAM(PARAM_SELSCHED_INSNS_TO_RENAME,
641
         "selsched-insns-to-rename",
642
         "Maximum number of instructions in the ready list that are considered eligible for renaming",
643
         2, 0, 0)
644
 
645
DEFPARAM (PARAM_SCHED_MEM_TRUE_DEP_COST,
646
          "sched-mem-true-dep-cost",
647
          "Minimal distance between possibly conflicting store and load",
648
          1, 0, 0)
649
 
650
DEFPARAM(PARAM_MAX_LAST_VALUE_RTL,
651
         "max-last-value-rtl",
652
         "The maximum number of RTL nodes that can be recorded as combiner's last value",
653
         10000, 0, 0)
654
 
655
/* INTEGER_CST nodes are shared for values [{-1,0} .. N) for
656
   {signed,unsigned} integral types.  This determines N.
657
   Experimentation shows 251 to be a good value that generates the
658
   least amount of garbage for allocating the TREE_VEC storage.  */
659
DEFPARAM (PARAM_INTEGER_SHARE_LIMIT,
660
          "integer-share-limit",
661
          "The upper bound for sharing integer constants",
662
          251, 2, 2)
663
 
664
DEFPARAM (PARAM_SSP_BUFFER_SIZE,
665
          "ssp-buffer-size",
666
          "The lower bound for a buffer to be considered for stack smashing protection",
667
          8, 1, 0)
668
 
669
/* When we thread through a block we have to make copies of the
670
   statements within the block.  Clearly for large blocks the code
671
   duplication is bad.
672
 
673
   PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS specifies the maximum number
674
   of statements and PHI nodes allowed in a block which is going to
675
   be duplicated for thread jumping purposes.
676
 
677
   Some simple analysis showed that more than 99% of the jump
678
   threading opportunities are for blocks with less than 15
679
   statements.  So we can get the benefits of jump threading
680
   without excessive code bloat for pathological cases with the
681
   throttle set at 15 statements.  */
682
DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS,
683
          "max-jump-thread-duplication-stmts",
684
          "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps",
685
          15, 0, 0)
686
 
687
/* This is the maximum number of fields a variable may have before the pointer analysis machinery
688
   will stop trying to treat it in a field-sensitive manner.
689
   There are programs out there with thousands of fields per structure, and handling them
690
   field-sensitively is not worth the cost.  */
691
DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
692
          "max-fields-for-field-sensitive",
693
          "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable",
694
          0, 0, 0)
695
 
696
DEFPARAM(PARAM_MAX_SCHED_READY_INSNS,
697
         "max-sched-ready-insns",
698
         "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass",
699
         100, 0, 0)
700
 
701
/* This is the maximum number of active local stores RTL DSE will consider.  */
702
DEFPARAM (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES,
703
          "max-dse-active-local-stores",
704
          "Maximum number of active local stores in RTL dead store elimination",
705
          5000, 0, 0)
706
 
707
/* Prefetching and cache-optimizations related parameters.  Default values are
708
   usually set by machine description.  */
709
 
710
/* The number of insns executed before prefetch is completed.  */
711
 
712
DEFPARAM (PARAM_PREFETCH_LATENCY,
713
         "prefetch-latency",
714
         "The number of insns executed before prefetch is completed",
715
         200, 0, 0)
716
 
717
/* The number of prefetches that can run at the same time.  */
718
 
719
DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES,
720
          "simultaneous-prefetches",
721
          "The number of prefetches that can run at the same time",
722
          3, 0, 0)
723
 
724
/* The size of L1 cache in kB.  */
725
 
726
DEFPARAM (PARAM_L1_CACHE_SIZE,
727
          "l1-cache-size",
728
          "The size of L1 cache",
729
          64, 0, 0)
730
 
731
/* The size of L1 cache line in bytes.  */
732
 
733
DEFPARAM (PARAM_L1_CACHE_LINE_SIZE,
734
          "l1-cache-line-size",
735
          "The size of L1 cache line",
736
          32, 0, 0)
737
 
738
/* The size of L2 cache in kB.  */
739
 
740
DEFPARAM (PARAM_L2_CACHE_SIZE,
741
          "l2-cache-size",
742
          "The size of L2 cache",
743
          512, 0, 0)
744
 
745
/* Whether we should use canonical types rather than deep "structural"
746
   type checking.  Setting this value to 1 (the default) improves
747
   compilation performance in the C++ and Objective-C++ front end;
748
   this value should only be set to zero to work around bugs in the
749
   canonical type system by disabling it.  */
750
 
751
DEFPARAM (PARAM_USE_CANONICAL_TYPES,
752
          "use-canonical-types",
753
          "Whether to use canonical types",
754
          1, 0, 1)
755
 
756
DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH,
757
          "max-partial-antic-length",
758
          "Maximum length of partial antic set when performing tree pre optimization",
759
          100, 0, 0)
760
 
761
/* The following is used as a stop-gap limit for cases where really huge
762
   SCCs blow up memory and compile-time use too much.  If we hit this limit,
763
   SCCVN and such FRE and PRE will be not done at all for the current
764
   function.  */
765
 
766
DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE,
767
          "sccvn-max-scc-size",
768
          "Maximum size of a SCC before SCCVN stops processing a function",
769
          10000, 10, 0)
770
 
771
/* The following is used as a stop-gap limit for cases where really huge
772
   functions blow up compile-time use too much.  It limits the number of
773
   alias-queries we do for finding common subexpressions for memory loads and
774
   stores.  The number of alias-queries is otherwise limited by the number of
775
   stores on paths to function entry.  */
776
 
777
DEFPARAM (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS,
778
          "sccvn-max-alias-queries-per-access",
779
          "Maximum number of disambiguations to perform per memory access",
780
          1000, 0, 0)
781
 
782
DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM,
783
          "ira-max-loops-num",
784
          "Max loops number for regional RA",
785
          100, 0, 0)
786
 
787
DEFPARAM (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE,
788
          "ira-max-conflict-table-size",
789
          "Max size of conflict table in MB",
790
          1000, 0, 0)
791
 
792
DEFPARAM (PARAM_IRA_LOOP_RESERVED_REGS,
793
          "ira-loop-reserved-regs",
794
          "The number of registers in each class kept unused by loop invariant motion",
795
          2, 0, 0)
796
 
797
/* Switch initialization conversion will refuse to create arrays that are
798
   bigger than this parameter times the number of switch branches.  */
799
 
800
DEFPARAM (PARAM_SWITCH_CONVERSION_BRANCH_RATIO,
801
          "switch-conversion-max-branch-ratio",
802
          "The maximum ratio between array size and switch branches for "
803
          "a switch conversion to take place",
804
          8, 1, 0)
805
 
806
/* Size of tiles when doing loop blocking.  */
807
 
808
DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE,
809
          "loop-block-tile-size",
810
          "size of tiles for loop blocking",
811
          51, 0, 0)
812
 
813
/* Maximal number of parameters that we allow in a SCoP.  */
814
 
815
DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS,
816
          "graphite-max-nb-scop-params",
817
          "maximum number of parameters in a SCoP",
818
          10, 0, 0)
819
 
820
/* Maximal number of basic blocks in the functions analyzed by Graphite.  */
821
 
822
DEFPARAM (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION,
823
          "graphite-max-bbs-per-function",
824
          "maximum number of basic blocks per function to be analyzed by Graphite",
825
          100, 0, 0)
826
 
827
/* Avoid data dependence analysis on very large loops.  */
828
DEFPARAM (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS,
829
          "loop-max-datarefs-for-datadeps",
830
          "Maximum number of datarefs in loop for building loop data dependencies",
831
          1000, 0, 0)
832
 
833
/* Avoid doing loop invariant motion on very large loops.  */
834
 
835
DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
836
          "loop-invariant-max-bbs-in-loop",
837
          "Max basic blocks number in loop for loop invariant motion",
838
          10000, 0, 0)
839
 
840
/* Avoid SLP vectorization of large basic blocks.  */
841
DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB,
842
          "slp-max-insns-in-bb",
843
          "Maximum number of instructions in basic block to be considered for SLP vectorization",
844
          1000, 0, 0)
845
 
846
DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO,
847
          "min-insn-to-prefetch-ratio",
848
          "Min. ratio of insns to prefetches to enable prefetching for "
849
          "a loop with an unknown trip count",
850
          9, 0, 0)
851
 
852
DEFPARAM (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO,
853
          "prefetch-min-insn-to-mem-ratio",
854
          "Min. ratio of insns to mem ops to enable prefetching in a loop",
855
          3, 0, 0)
856
 
857
/* Set maximum hash table size for var tracking.  */
858
 
859
DEFPARAM (PARAM_MAX_VARTRACK_SIZE,
860
          "max-vartrack-size",
861
          "Max. size of var tracking hash tables",
862
          50000000, 0, 0)
863
 
864
/* Set maximum recursion depth for var tracking expression expansion
865
   and resolution.  */
866
 
867
DEFPARAM (PARAM_MAX_VARTRACK_EXPR_DEPTH,
868
          "max-vartrack-expr-depth",
869
          "Max. recursion depth for expanding var tracking expressions",
870
          12, 0, 0)
871
 
872
/* Set minimum insn uid for non-debug insns.  */
873
 
874
DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID,
875
          "min-nondebug-insn-uid",
876
          "The minimum UID to be used for a nondebug insn",
877
          0, 1, 0)
878
 
879
DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR,
880
          "ipa-sra-ptr-growth-factor",
881
          "Maximum allowed growth of size of new parameters ipa-sra replaces "
882
          "a pointer to an aggregate with",
883
          2, 0, 0)
884
 
885
DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE,
886
          "tm-max-aggregate-size",
887
          "Size in bytes after which thread-local aggregates should be "
888
          "instrumented with the logging functions instead of save/restore "
889
          "pairs",
890
          9, 0, 0)
891
 
892
DEFPARAM (PARAM_IPA_CP_VALUE_LIST_SIZE,
893
          "ipa-cp-value-list-size",
894
          "Maximum size of a list of values associated with each parameter for "
895
          "interprocedural constant propagation",
896
          8, 0, 0)
897
 
898
DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD,
899
          "ipa-cp-eval-threshold",
900
          "Threshold ipa-cp opportunity evaluation that is still considered "
901
          "beneficial to clone.",
902
          500, 0, 0)
903
 
904
DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS,
905
          "ipa-max-agg-items",
906
          "Maximum number of aggregate content items for a parameter in "
907
          "jump functions and lattices",
908
          16, 0, 0)
909
 
910
DEFPARAM (PARAM_IPA_CP_LOOP_HINT_BONUS,
911
          "ipa-cp-loop-hint-bonus",
912
          "Compile-time bonus IPA-CP assigns to candidates which make loop "
913
          "bounds or strides known.",
914
          64, 0, 0)
915
 
916
/* WHOPR partitioning configuration.  */
917
 
918
DEFPARAM (PARAM_LTO_PARTITIONS,
919
          "lto-partitions",
920
          "Number of partitions the program should be split to",
921
          32, 1, 0)
922
 
923
DEFPARAM (MIN_PARTITION_SIZE,
924
          "lto-min-partition",
925
          "Minimal size of a partition for LTO (in estimated instructions)",
926
          1000, 0, 0)
927
 
928
/* Diagnostic parameters.  */
929
 
930
DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP,
931
          "cxx-max-namespaces-for-diagnostic-help",
932
          "Maximum number of namespaces to search for alternatives when "
933
          "name lookup fails",
934
          1000, 0, 0)
935
 
936
/* Maximum number of conditional store pairs that can be sunk.  */
937
DEFPARAM (PARAM_MAX_STORES_TO_SINK,
938
          "max-stores-to-sink",
939
          "Maximum number of conditional store pairs that can be sunk",
940
          2, 0, 0)
941
 
942
/* Override CASE_VALUES_THRESHOLD of when to switch from doing switch
943
   statements via if statements to using a table jump operation.  If the value
944
   is 0, the default CASE_VALUES_THRESHOLD will be used.  */
945
DEFPARAM (PARAM_CASE_VALUES_THRESHOLD,
946
          "case-values-threshold",
947
          "The smallest number of different values for which it is best to "
948
          "use a jump-table instead of a tree of conditional branches, "
949
          "if 0, use the default for the machine",
950
          0, 0, 0)
951
 
952
/* Data race flags for C++0x memory model compliance.  */
953
DEFPARAM (PARAM_ALLOW_LOAD_DATA_RACES,
954
          "allow-load-data-races",
955
          "Allow new data races on loads to be introduced",
956
          1, 0, 1)
957
 
958
DEFPARAM (PARAM_ALLOW_STORE_DATA_RACES,
959
          "allow-store-data-races",
960
          "Allow new data races on stores to be introduced",
961
          1, 0, 1)
962
 
963
DEFPARAM (PARAM_ALLOW_PACKED_LOAD_DATA_RACES,
964
          "allow-packed-load-data-races",
965
          "Allow new data races on packed data loads to be introduced",
966
          1, 0, 1)
967
 
968
DEFPARAM (PARAM_ALLOW_PACKED_STORE_DATA_RACES,
969
          "allow-packed-store-data-races",
970
          "Allow new data races on packed data stores to be introduced",
971
          1, 0, 1)
972
 
973
/* Reassociation width to be used by tree reassoc optimization.  */
974
DEFPARAM (PARAM_TREE_REASSOC_WIDTH,
975
          "tree-reassoc-width",
976
          "Set the maximum number of instructions executed in parallel in "
977
          "reassociated tree. If 0, use the target dependent heuristic.",
978
          0, 0, 0)
979
 
980
DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS,
981
          "max-tail-merge-comparisons",
982
          "Maximum amount of similar bbs to compare a bb with",
983
          10, 0, 0)
984
 
985
DEFPARAM (PARAM_MAX_TAIL_MERGE_ITERATIONS,
986
          "max-tail-merge-iterations",
987
          "Maximum amount of iterations of the pass over a function",
988
          2, 0, 0)
989
 
990
/* Maximum number of strings for which strlen optimization pass will
991
   track string lenths.  */
992
DEFPARAM (PARAM_MAX_TRACKED_STRLENS,
993
          "max-tracked-strlens",
994
          "Maximum number of strings for which strlen optimization pass will "
995
          "track string lengths",
996
          1000, 0, 0)
997
 
998
/* Keep this in sync with the sched_pressure_algorithm enum.  */
999
DEFPARAM (PARAM_SCHED_PRESSURE_ALGORITHM,
1000
          "sched-pressure-algorithm",
1001
          "Which -fsched-pressure algorithm to apply",
1002
          1, 1, 2)
1003
 
1004
/* Maximum length of candidate scans in straight-line strength reduction.  */
1005
DEFPARAM (PARAM_MAX_SLSR_CANDIDATE_SCAN,
1006
          "max-slsr-cand-scan",
1007
          "Maximum length of candidate scans for straight-line "
1008
          "strength reduction",
1009
          50, 1, 999999)
1010
 
1011
/*
1012
Local variables:
1013
mode:c
1014
End:
1015
*/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.