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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [passes.c] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Top level of GCC compilers (cc1, cc1plus, etc.)
2
   Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4
   Free Software Foundation, Inc.
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
/* This is the top level of cc1/c++.
23
   It parses command args, opens files, invokes the various passes
24
   in the proper order, and counts the time used by each.
25
   Error messages and low-level interface to malloc also handled here.  */
26
 
27
#include "config.h"
28
#undef FLOAT /* This is for hpux. They should change hpux.  */
29
#undef FFS  /* Some systems define this in param.h.  */
30
#include "system.h"
31
#include "coretypes.h"
32
#include "tm.h"
33
#include <signal.h>
34
 
35
#ifdef HAVE_SYS_RESOURCE_H
36
# include <sys/resource.h>
37
#endif
38
 
39
#ifdef HAVE_SYS_TIMES_H
40
# include <sys/times.h>
41
#endif
42
 
43
#include "line-map.h"
44
#include "input.h"
45
#include "tree.h"
46
#include "rtl.h"
47
#include "tm_p.h"
48
#include "flags.h"
49
#include "insn-attr.h"
50
#include "insn-config.h"
51
#include "insn-flags.h"
52
#include "hard-reg-set.h"
53
#include "recog.h"
54
#include "output.h"
55
#include "except.h"
56
#include "function.h"
57
#include "toplev.h"
58
#include "expr.h"
59
#include "basic-block.h"
60
#include "intl.h"
61
#include "ggc.h"
62
#include "graph.h"
63
#include "regs.h"
64
#include "timevar.h"
65
#include "diagnostic.h"
66
#include "params.h"
67
#include "reload.h"
68
#include "dwarf2asm.h"
69
#include "integrate.h"
70
#include "real.h"
71
#include "debug.h"
72
#include "target.h"
73
#include "langhooks.h"
74
#include "cfglayout.h"
75
#include "cfgloop.h"
76
#include "hosthooks.h"
77
#include "cgraph.h"
78
#include "opts.h"
79
#include "coverage.h"
80
#include "value-prof.h"
81
#include "tree-inline.h"
82
#include "tree-flow.h"
83
#include "tree-pass.h"
84
#include "tree-dump.h"
85
 
86
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
87
#include "dwarf2out.h"
88
#endif
89
 
90
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
91
#include "dbxout.h"
92
#endif
93
 
94
#ifdef SDB_DEBUGGING_INFO
95
#include "sdbout.h"
96
#endif
97
 
98
#ifdef XCOFF_DEBUGGING_INFO
99
#include "xcoffout.h"           /* Needed for external data
100
                                   declarations for e.g. AIX 4.x.  */
101
#endif
102
 
103
/* Global variables used to communicate with passes.  */
104
int dump_flags;
105
bool in_gimple_form;
106
 
107
 
108
/* This is called from various places for FUNCTION_DECL, VAR_DECL,
109
   and TYPE_DECL nodes.
110
 
111
   This does nothing for local (non-static) variables, unless the
112
   variable is a register variable with DECL_ASSEMBLER_NAME set.  In
113
   that case, or if the variable is not an automatic, it sets up the
114
   RTL and outputs any assembler code (label definition, storage
115
   allocation and initialization).
116
 
117
   DECL is the declaration.  TOP_LEVEL is nonzero
118
   if this declaration is not within a function.  */
119
 
120
void
121
rest_of_decl_compilation (tree decl,
122
                          int top_level,
123
                          int at_end)
124
{
125
  /* We deferred calling assemble_alias so that we could collect
126
     other attributes such as visibility.  Emit the alias now.  */
127
  {
128
    tree alias;
129
    alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
130
    if (alias)
131
      {
132
        alias = TREE_VALUE (TREE_VALUE (alias));
133
        alias = get_identifier (TREE_STRING_POINTER (alias));
134
        assemble_alias (decl, alias);
135
      }
136
  }
137
 
138
  /* Can't defer this, because it needs to happen before any
139
     later function definitions are processed.  */
140
  if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
141
    make_decl_rtl (decl);
142
 
143
  /* Forward declarations for nested functions are not "external",
144
     but we need to treat them as if they were.  */
145
  if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
146
      || TREE_CODE (decl) == FUNCTION_DECL)
147
    {
148
      timevar_push (TV_VARCONST);
149
 
150
      /* Don't output anything when a tentative file-scope definition
151
         is seen.  But at end of compilation, do output code for them.
152
 
153
         We do output all variables when unit-at-a-time is active and rely on
154
         callgraph code to defer them except for forward declarations
155
         (see gcc.c-torture/compile/920624-1.c) */
156
      if ((at_end
157
           || !DECL_DEFER_OUTPUT (decl)
158
           || DECL_INITIAL (decl))
159
          && !DECL_EXTERNAL (decl))
160
        {
161
          if (TREE_CODE (decl) != FUNCTION_DECL)
162
            cgraph_varpool_finalize_decl (decl);
163
          else
164
            assemble_variable (decl, top_level, at_end, 0);
165
        }
166
 
167
#ifdef ASM_FINISH_DECLARE_OBJECT
168
      if (decl == last_assemble_variable_decl)
169
        {
170
          ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
171
                                     top_level, at_end);
172
        }
173
#endif
174
 
175
      timevar_pop (TV_VARCONST);
176
    }
177
  else if (TREE_CODE (decl) == TYPE_DECL
178
           /* Like in rest_of_type_compilation, avoid confusing the debug
179
              information machinery when there are errors.  */
180
           && !(sorrycount || errorcount))
181
    {
182
      timevar_push (TV_SYMOUT);
183
      debug_hooks->type_decl (decl, !top_level);
184
      timevar_pop (TV_SYMOUT);
185
    }
186
 
187
  /* Let cgraph know about the existence of variables.  */
188
  if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
189
    cgraph_varpool_node (decl);
190
}
191
 
192
/* Called after finishing a record, union or enumeral type.  */
193
 
194
void
195
rest_of_type_compilation (tree type, int toplev)
196
{
197
  /* Avoid confusing the debug information machinery when there are
198
     errors.  */
199
  if (errorcount != 0 || sorrycount != 0)
200
    return;
201
 
202
  timevar_push (TV_SYMOUT);
203
  debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
204
  timevar_pop (TV_SYMOUT);
205
}
206
 
207
 
208
 
209
void
210
finish_optimization_passes (void)
211
{
212
  enum tree_dump_index i;
213
  struct dump_file_info *dfi;
214
  char *name;
215
 
216
  timevar_push (TV_DUMP);
217
  if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
218
    {
219
      dump_file = dump_begin (pass_profile.static_pass_number, NULL);
220
      end_branch_prob ();
221
      if (dump_file)
222
        dump_end (pass_profile.static_pass_number, dump_file);
223
    }
224
 
225
  if (optimize > 0)
226
    {
227
      dump_file = dump_begin (pass_combine.static_pass_number, NULL);
228
      if (dump_file)
229
        {
230
          dump_combine_total_stats (dump_file);
231
          dump_end (pass_combine.static_pass_number, dump_file);
232
        }
233
    }
234
 
235
  /* Do whatever is necessary to finish printing the graphs.  */
236
  if (graph_dump_format != no_graph)
237
    for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
238
      if (dump_initialized_p (i)
239
          && (dfi->flags & TDF_GRAPH) != 0
240
          && (name = get_dump_file_name (i)) != NULL)
241
        {
242
          finish_graph_dump_file (name);
243
          free (name);
244
        }
245
 
246
  timevar_pop (TV_DUMP);
247
}
248
 
249
static bool
250
gate_rest_of_compilation (void)
251
{
252
  /* Early return if there were errors.  We can run afoul of our
253
     consistency checks, and there's not really much point in fixing them.  */
254
  return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
255
}
256
 
257
struct tree_opt_pass pass_rest_of_compilation =
258
{
259
  NULL,                                 /* name */
260
  gate_rest_of_compilation,             /* gate */
261
  NULL,                                 /* execute */
262
  NULL,                                 /* sub */
263
  NULL,                                 /* next */
264
  0,                                    /* static_pass_number */
265
  TV_REST_OF_COMPILATION,               /* tv_id */
266
  PROP_rtl,                             /* properties_required */
267
  0,                                    /* properties_provided */
268
  0,                                    /* properties_destroyed */
269
  0,                                    /* todo_flags_start */
270
  TODO_ggc_collect,                     /* todo_flags_finish */
271
 
272
};
273
 
274
static bool
275
gate_postreload (void)
276
{
277
  return reload_completed;
278
}
279
 
280
struct tree_opt_pass pass_postreload =
281
{
282
  NULL,                                 /* name */
283
  gate_postreload,                      /* gate */
284
  NULL,                                 /* execute */
285
  NULL,                                 /* sub */
286
  NULL,                                 /* next */
287
  0,                                    /* static_pass_number */
288
  0,                                    /* tv_id */
289
  PROP_rtl,                             /* properties_required */
290
  0,                                    /* properties_provided */
291
  0,                                    /* properties_destroyed */
292
  0,                                    /* todo_flags_start */
293
  TODO_ggc_collect,                     /* todo_flags_finish */
294
 
295
};
296
 
297
 
298
 
299
/* The root of the compilation pass tree, once constructed.  */
300
struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
301
 
302
/* Iterate over the pass tree allocating dump file numbers.  We want
303
   to do this depth first, and independent of whether the pass is
304
   enabled or not.  */
305
 
306
static void
307
register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int properties)
308
{
309
  char *dot_name, *flag_name, *glob_name;
310
  const char *prefix;
311
  char num[10];
312
  int flags;
313
 
314
  /* See below in next_pass_1.  */
315
  num[0] = '\0';
316
  if (pass->static_pass_number != -1)
317
    sprintf (num, "%d", ((int) pass->static_pass_number < 0
318
                         ? 1 : pass->static_pass_number));
319
 
320
  dot_name = concat (".", pass->name, num, NULL);
321
  if (ipa)
322
    prefix = "ipa-", flags = TDF_IPA;
323
  else if (properties & PROP_trees)
324
    prefix = "tree-", flags = TDF_TREE;
325
  else
326
    prefix = "rtl-", flags = TDF_RTL;
327
 
328
  flag_name = concat (prefix, pass->name, num, NULL);
329
  glob_name = concat (prefix, pass->name, NULL);
330
  pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
331
                                            flags, pass->letter);
332
}
333
 
334
/* Recursive worker function for register_dump_files.  */
335
 
336
static int
337
register_dump_files_1 (struct tree_opt_pass *pass, bool ipa, int properties)
338
{
339
  do
340
    {
341
      int new_properties = (properties | pass->properties_provided)
342
                           & ~pass->properties_destroyed;
343
 
344
      if (pass->name)
345
        register_one_dump_file (pass, ipa, new_properties);
346
 
347
      if (pass->sub)
348
        new_properties = register_dump_files_1 (pass->sub, false,
349
                                                new_properties);
350
 
351
      /* If we have a gate, combine the properties that we could have with
352
         and without the pass being examined.  */
353
      if (pass->gate)
354
        properties &= new_properties;
355
      else
356
        properties = new_properties;
357
 
358
      pass = pass->next;
359
    }
360
  while (pass);
361
 
362
  return properties;
363
}
364
 
365
/* Register the dump files for the pipeline starting at PASS.  IPA is
366
   true if the pass is inter-procedural, and PROPERTIES reflects the
367
   properties that are guaranteed to be available at the beginning of
368
   the pipeline.  */
369
 
370
static void
371
register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
372
{
373
  pass->properties_required |= properties;
374
  pass->todo_flags_start |= TODO_set_props;
375
  register_dump_files_1 (pass, ipa, properties);
376
}
377
 
378
/* Add a pass to the pass list. Duplicate the pass if it's already
379
   in the list.  */
380
 
381
static struct tree_opt_pass **
382
next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
383
{
384
  /* A nonzero static_pass_number indicates that the
385
     pass is already in the list.  */
386
  if (pass->static_pass_number)
387
    {
388
      struct tree_opt_pass *new;
389
 
390
      new = xmalloc (sizeof (*new));
391
      memcpy (new, pass, sizeof (*new));
392
 
393
      /* Indicate to register_dump_files that this pass has duplicates,
394
         and so it should rename the dump file.  The first instance will
395
         be -1, and be number of duplicates = -static_pass_number - 1.
396
         Subsequent instances will be > 0 and just the duplicate number.  */
397
      if (pass->name)
398
        {
399
          pass->static_pass_number -= 1;
400
          new->static_pass_number = -pass->static_pass_number;
401
        }
402
 
403
      *list = new;
404
    }
405
  else
406
    {
407
      pass->static_pass_number = -1;
408
      *list = pass;
409
    }
410
 
411
  return &(*list)->next;
412
 
413
}
414
 
415
/* Construct the pass tree.  The sequencing of passes is driven by
416
   the cgraph routines:
417
 
418
   cgraph_finalize_compilation_unit ()
419
       for each node N in the cgraph
420
           cgraph_analyze_function (N)
421
               cgraph_lower_function (N) -> all_lowering_passes
422
 
423
   If we are optimizing, cgraph_optimize is then invoked:
424
 
425
   cgraph_optimize ()
426
       ipa_passes ()                    -> all_ipa_passes
427
       cgraph_expand_all_functions ()
428
           for each node N in the cgraph
429
               cgraph_expand_function (N)
430
                   cgraph_lower_function (N)    -> Now a NOP.
431
                   lang_hooks.callgraph.expand_function (DECL (N))
432
                        tree_rest_of_compilation (DECL (N))  -> all_passes
433
*/
434
 
435
void
436
init_optimization_passes (void)
437
{
438
  struct tree_opt_pass **p;
439
 
440
#define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
441
  /* Interprocedural optimization passes.  */
442
  p = &all_ipa_passes;
443
  NEXT_PASS (pass_early_ipa_inline);
444
  NEXT_PASS (pass_early_local_passes);
445
  NEXT_PASS (pass_ipa_cp);
446
  NEXT_PASS (pass_ipa_inline);
447
  NEXT_PASS (pass_ipa_reference);
448
  NEXT_PASS (pass_ipa_pure_const);
449
  NEXT_PASS (pass_ipa_type_escape);
450
  NEXT_PASS (pass_ipa_pta);
451
  *p = NULL;
452
 
453
  /* All passes needed to lower the function into shape optimizers can
454
     operate on.  */
455
  p = &all_lowering_passes;
456
  NEXT_PASS (pass_remove_useless_stmts);
457
  NEXT_PASS (pass_mudflap_1);
458
  NEXT_PASS (pass_lower_omp);
459
  NEXT_PASS (pass_lower_cf);
460
  NEXT_PASS (pass_lower_eh);
461
  NEXT_PASS (pass_build_cfg);
462
  NEXT_PASS (pass_lower_complex_O0);
463
  NEXT_PASS (pass_lower_vector);
464
  NEXT_PASS (pass_warn_function_return);
465
  NEXT_PASS (pass_early_tree_profile);
466
  *p = NULL;
467
 
468
  p = &pass_early_local_passes.sub;
469
  NEXT_PASS (pass_tree_profile);
470
  NEXT_PASS (pass_cleanup_cfg);
471
  NEXT_PASS (pass_rebuild_cgraph_edges);
472
  *p = NULL;
473
 
474
  p = &all_passes;
475
  NEXT_PASS (pass_fixup_cfg);
476
  NEXT_PASS (pass_init_datastructures);
477
  NEXT_PASS (pass_expand_omp);
478
  NEXT_PASS (pass_all_optimizations);
479
  NEXT_PASS (pass_warn_function_noreturn);
480
  NEXT_PASS (pass_mudflap_2);
481
  NEXT_PASS (pass_free_datastructures);
482
  NEXT_PASS (pass_free_cfg_annotations);
483
  NEXT_PASS (pass_expand);
484
  NEXT_PASS (pass_rest_of_compilation);
485
  NEXT_PASS (pass_clean_state);
486
  *p = NULL;
487
 
488
  p = &pass_all_optimizations.sub;
489
  NEXT_PASS (pass_referenced_vars);
490
  NEXT_PASS (pass_reset_cc_flags);
491
  NEXT_PASS (pass_create_structure_vars);
492
  NEXT_PASS (pass_build_ssa);
493
  NEXT_PASS (pass_may_alias);
494
  NEXT_PASS (pass_return_slot);
495
  NEXT_PASS (pass_rename_ssa_copies);
496
  NEXT_PASS (pass_early_warn_uninitialized);
497
 
498
  /* Initial scalar cleanups.  */
499
  NEXT_PASS (pass_ccp);
500
  NEXT_PASS (pass_fre);
501
  NEXT_PASS (pass_dce);
502
  NEXT_PASS (pass_forwprop);
503
  NEXT_PASS (pass_copy_prop);
504
  NEXT_PASS (pass_merge_phi);
505
  NEXT_PASS (pass_vrp);
506
  NEXT_PASS (pass_dce);
507
  NEXT_PASS (pass_dominator);
508
 
509
  /* The only const/copy propagation opportunities left after
510
     DOM should be due to degenerate PHI nodes.  So rather than
511
     run the full propagators, run a specialized pass which
512
     only examines PHIs to discover const/copy propagation
513
     opportunities.  */
514
  NEXT_PASS (pass_phi_only_cprop);
515
 
516
  NEXT_PASS (pass_phiopt);
517
  NEXT_PASS (pass_may_alias);
518
  NEXT_PASS (pass_tail_recursion);
519
  NEXT_PASS (pass_profile);
520
  NEXT_PASS (pass_ch);
521
  NEXT_PASS (pass_stdarg);
522
  NEXT_PASS (pass_lower_complex);
523
  NEXT_PASS (pass_sra);
524
  /* FIXME: SRA may generate arbitrary gimple code, exposing new
525
     aliased and call-clobbered variables.  As mentioned below,
526
     pass_may_alias should be a TODO item.  */
527
  NEXT_PASS (pass_may_alias);
528
  NEXT_PASS (pass_rename_ssa_copies);
529
  NEXT_PASS (pass_dominator);
530
 
531
  /* The only const/copy propagation opportunities left after
532
     DOM should be due to degenerate PHI nodes.  So rather than
533
     run the full propagators, run a specialized pass which
534
     only examines PHIs to discover const/copy propagation
535
     opportunities.  */
536
  NEXT_PASS (pass_phi_only_cprop);
537
 
538
  NEXT_PASS (pass_reassoc);
539
  NEXT_PASS (pass_dce);
540
  NEXT_PASS (pass_dse);
541
  NEXT_PASS (pass_may_alias);
542
  NEXT_PASS (pass_forwprop);
543
  NEXT_PASS (pass_phiopt);
544
  NEXT_PASS (pass_object_sizes);
545
  NEXT_PASS (pass_store_ccp);
546
  NEXT_PASS (pass_store_copy_prop);
547
  NEXT_PASS (pass_fold_builtins);
548
  /* FIXME: May alias should a TODO but for 4.0.0,
549
     we add may_alias right after fold builtins
550
     which can create arbitrary GIMPLE.  */
551
  NEXT_PASS (pass_may_alias);
552
  NEXT_PASS (pass_split_crit_edges);
553
  NEXT_PASS (pass_pre);
554
  NEXT_PASS (pass_may_alias);
555
  NEXT_PASS (pass_sink_code);
556
  NEXT_PASS (pass_tree_loop);
557
  NEXT_PASS (pass_cse_reciprocals);
558
  NEXT_PASS (pass_reassoc);
559
  NEXT_PASS (pass_vrp);
560
  NEXT_PASS (pass_dominator);
561
 
562
  /* The only const/copy propagation opportunities left after
563
     DOM should be due to degenerate PHI nodes.  So rather than
564
     run the full propagators, run a specialized pass which
565
     only examines PHIs to discover const/copy propagation
566
     opportunities.  */
567
  NEXT_PASS (pass_phi_only_cprop);
568
 
569
  NEXT_PASS (pass_cd_dce);
570
 
571
  /* FIXME: If DCE is not run before checking for uninitialized uses,
572
     we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
573
     However, this also causes us to misdiagnose cases that should be
574
     real warnings (e.g., testsuite/gcc.dg/pr18501.c).
575
 
576
     To fix the false positives in uninit-5.c, we would have to
577
     account for the predicates protecting the set and the use of each
578
     variable.  Using a representation like Gated Single Assignment
579
     may help.  */
580
  NEXT_PASS (pass_late_warn_uninitialized);
581
  NEXT_PASS (pass_dse);
582
  NEXT_PASS (pass_forwprop);
583
  NEXT_PASS (pass_phiopt);
584
  NEXT_PASS (pass_tail_calls);
585
  NEXT_PASS (pass_rename_ssa_copies);
586
  NEXT_PASS (pass_uncprop);
587
  NEXT_PASS (pass_del_ssa);
588
  NEXT_PASS (pass_nrv);
589
  NEXT_PASS (pass_mark_used_blocks);
590
  NEXT_PASS (pass_cleanup_cfg_post_optimizing);
591
  *p = NULL;
592
 
593
  p = &pass_tree_loop.sub;
594
  NEXT_PASS (pass_tree_loop_init);
595
  NEXT_PASS (pass_copy_prop);
596
  NEXT_PASS (pass_lim);
597
  NEXT_PASS (pass_tree_unswitch);
598
  NEXT_PASS (pass_scev_cprop);
599
  NEXT_PASS (pass_empty_loop);
600
  NEXT_PASS (pass_record_bounds);
601
  NEXT_PASS (pass_linear_transform);
602
  NEXT_PASS (pass_iv_canon);
603
  NEXT_PASS (pass_if_conversion);
604
  NEXT_PASS (pass_vectorize);
605
  /* NEXT_PASS (pass_may_alias) cannot be done again because the
606
     vectorizer creates alias relations that are not supported by
607
     pass_may_alias.  */
608
  NEXT_PASS (pass_complete_unroll);
609
  NEXT_PASS (pass_loop_prefetch);
610
  NEXT_PASS (pass_iv_optimize);
611
  NEXT_PASS (pass_tree_loop_done);
612
  *p = NULL;
613
 
614
  p = &pass_vectorize.sub;
615
  NEXT_PASS (pass_lower_vector_ssa);
616
  NEXT_PASS (pass_dce_loop);
617
  *p = NULL;
618
 
619
  p = &pass_loop2.sub;
620
  NEXT_PASS (pass_rtl_loop_init);
621
  NEXT_PASS (pass_rtl_move_loop_invariants);
622
  NEXT_PASS (pass_rtl_unswitch);
623
  NEXT_PASS (pass_rtl_unroll_and_peel_loops);
624
  NEXT_PASS (pass_rtl_doloop);
625
  NEXT_PASS (pass_rtl_loop_done);
626
  *p = NULL;
627
 
628
  p = &pass_rest_of_compilation.sub;
629
  NEXT_PASS (pass_init_function);
630
  NEXT_PASS (pass_jump);
631
  NEXT_PASS (pass_insn_locators_initialize);
632
  NEXT_PASS (pass_rtl_eh);
633
  NEXT_PASS (pass_initial_value_sets);
634
  NEXT_PASS (pass_unshare_all_rtl);
635
  NEXT_PASS (pass_instantiate_virtual_regs);
636
  NEXT_PASS (pass_jump2);
637
  NEXT_PASS (pass_cse);
638
  NEXT_PASS (pass_gcse);
639
  NEXT_PASS (pass_jump_bypass);
640
  NEXT_PASS (pass_rtl_ifcvt);
641
  NEXT_PASS (pass_tracer);
642
  /* Perform loop optimizations.  It might be better to do them a bit
643
     sooner, but we want the profile feedback to work more
644
     efficiently.  */
645
  NEXT_PASS (pass_loop2);
646
  NEXT_PASS (pass_web);
647
  NEXT_PASS (pass_cse2);
648
  NEXT_PASS (pass_life);
649
  NEXT_PASS (pass_combine);
650
  NEXT_PASS (pass_if_after_combine);
651
  NEXT_PASS (pass_partition_blocks);
652
  NEXT_PASS (pass_regmove);
653
  NEXT_PASS (pass_split_all_insns);
654
  NEXT_PASS (pass_mode_switching);
655
  NEXT_PASS (pass_see);
656
  NEXT_PASS (pass_recompute_reg_usage);
657
  NEXT_PASS (pass_sms);
658
  NEXT_PASS (pass_sched);
659
  NEXT_PASS (pass_local_alloc);
660
  NEXT_PASS (pass_global_alloc);
661
  NEXT_PASS (pass_postreload);
662
  *p = NULL;
663
 
664
  p = &pass_postreload.sub;
665
  NEXT_PASS (pass_postreload_cse);
666
  NEXT_PASS (pass_gcse2);
667
  NEXT_PASS (pass_flow2);
668
  NEXT_PASS (pass_rtl_seqabstr);
669
  NEXT_PASS (pass_stack_adjustments);
670
  NEXT_PASS (pass_peephole2);
671
  NEXT_PASS (pass_if_after_reload);
672
  NEXT_PASS (pass_regrename);
673
  NEXT_PASS (pass_reorder_blocks);
674
  NEXT_PASS (pass_branch_target_load_optimize);
675
  NEXT_PASS (pass_leaf_regs);
676
  NEXT_PASS (pass_sched2);
677
  NEXT_PASS (pass_split_before_regstack);
678
  NEXT_PASS (pass_stack_regs);
679
  NEXT_PASS (pass_compute_alignments);
680
  NEXT_PASS (pass_duplicate_computed_gotos);
681
  NEXT_PASS (pass_variable_tracking);
682
  NEXT_PASS (pass_free_cfg);
683
  NEXT_PASS (pass_machine_reorg);
684
  NEXT_PASS (pass_purge_lineno_notes);
685
  NEXT_PASS (pass_cleanup_barriers);
686
  NEXT_PASS (pass_delay_slots);
687
  NEXT_PASS (pass_split_for_shorten_branches);
688
  NEXT_PASS (pass_convert_to_eh_region_ranges);
689
  NEXT_PASS (pass_shorten_branches);
690
  NEXT_PASS (pass_set_nothrow_function_flags);
691
  NEXT_PASS (pass_final);
692
  *p = NULL;
693
 
694
#undef NEXT_PASS
695
 
696
  /* Register the passes with the tree dump code.  */
697
  register_dump_files (all_ipa_passes, true,
698
                       PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
699
                       | PROP_cfg);
700
  register_dump_files (all_lowering_passes, false, PROP_gimple_any);
701
  register_dump_files (all_passes, false,
702
                       PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
703
                       | PROP_cfg);
704
}
705
 
706
static unsigned int last_verified;
707
static unsigned int curr_properties;
708
 
709
static void
710
execute_todo (unsigned int flags)
711
{
712
#if defined ENABLE_CHECKING
713
  if (need_ssa_update_p ())
714
    gcc_assert (flags & TODO_update_ssa_any);
715
#endif
716
 
717
  if (curr_properties & PROP_ssa)
718
    flags |= TODO_verify_ssa;
719
  flags &= ~last_verified;
720
  if (!flags)
721
    return;
722
 
723
  /* Always recalculate SMT usage before doing anything else.  */
724
  if (flags & TODO_update_smt_usage)
725
    recalculate_used_alone ();
726
 
727
  /* Always cleanup the CFG before trying to update SSA .  */
728
  if (flags & TODO_cleanup_cfg)
729
    {
730
      /* CFG Cleanup can cause a constant to prop into an ARRAY_REF.  */
731
      updating_used_alone = true;
732
 
733
      if (current_loops)
734
        cleanup_tree_cfg_loop ();
735
      else
736
        cleanup_tree_cfg ();
737
 
738
      /* Update the used alone after cleanup cfg.  */
739
      recalculate_used_alone ();
740
 
741
      /* When cleanup_tree_cfg merges consecutive blocks, it may
742
         perform some simplistic propagation when removing single
743
         valued PHI nodes.  This propagation may, in turn, cause the
744
         SSA form to become out-of-date (see PR 22037).  So, even
745
         if the parent pass had not scheduled an SSA update, we may
746
         still need to do one.  */
747
      if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
748
        flags |= TODO_update_ssa;
749
    }
750
 
751
  if (flags & TODO_update_ssa_any)
752
    {
753
      unsigned update_flags = flags & TODO_update_ssa_any;
754
      update_ssa (update_flags);
755
      last_verified &= ~TODO_verify_ssa;
756
    }
757
 
758
  if (flags & TODO_remove_unused_locals)
759
    remove_unused_locals ();
760
 
761
  if ((flags & TODO_dump_func)
762
      && dump_file && current_function_decl)
763
    {
764
      if (curr_properties & PROP_trees)
765
        dump_function_to_file (current_function_decl,
766
                               dump_file, dump_flags);
767
      else
768
        {
769
          if (dump_flags & TDF_SLIM)
770
            print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
771
          else if ((curr_properties & PROP_cfg) && (dump_flags & TDF_BLOCKS))
772
            print_rtl_with_bb (dump_file, get_insns ());
773
          else
774
            print_rtl (dump_file, get_insns ());
775
 
776
          if (curr_properties & PROP_cfg
777
              && graph_dump_format != no_graph
778
              && (dump_flags & TDF_GRAPH))
779
            print_rtl_graph_with_bb (dump_file_name, get_insns ());
780
        }
781
 
782
      /* Flush the file.  If verification fails, we won't be able to
783
         close the file before aborting.  */
784
      fflush (dump_file);
785
    }
786
  if ((flags & TODO_dump_cgraph)
787
      && dump_file && !current_function_decl)
788
    {
789
      dump_cgraph (dump_file);
790
      /* Flush the file.  If verification fails, we won't be able to
791
         close the file before aborting.  */
792
      fflush (dump_file);
793
    }
794
 
795
  if (flags & TODO_ggc_collect)
796
    {
797
      ggc_collect ();
798
    }
799
 
800
#if defined ENABLE_CHECKING
801
  if (flags & TODO_verify_ssa)
802
    verify_ssa (true);
803
  if (flags & TODO_verify_flow)
804
    verify_flow_info ();
805
  if (flags & TODO_verify_stmts)
806
    verify_stmts ();
807
  if (flags & TODO_verify_loops)
808
    verify_loop_closed_ssa ();
809
#endif
810
 
811
  last_verified = flags & TODO_verify_all;
812
}
813
 
814
/* Verify invariants that should hold between passes.  This is a place
815
   to put simple sanity checks.  */
816
 
817
static void
818
verify_interpass_invariants (void)
819
{
820
#ifdef ENABLE_CHECKING
821
  gcc_assert (!fold_deferring_overflow_warnings_p ());
822
#endif
823
}
824
 
825
static bool
826
execute_one_pass (struct tree_opt_pass *pass)
827
{
828
  bool initializing_dump;
829
  unsigned int todo_after = 0;
830
 
831
  /* See if we're supposed to run this pass.  */
832
  if (pass->gate && !pass->gate ())
833
    return false;
834
 
835
  if (pass->todo_flags_start & TODO_set_props)
836
    curr_properties = pass->properties_required;
837
 
838
  /* Note that the folders should only create gimple expressions.
839
     This is a hack until the new folder is ready.  */
840
  in_gimple_form = (curr_properties & PROP_trees) != 0;
841
 
842
  /* Run pre-pass verification.  */
843
  execute_todo (pass->todo_flags_start);
844
 
845
  gcc_assert ((curr_properties & pass->properties_required)
846
              == pass->properties_required);
847
 
848
  if (pass->properties_destroyed & PROP_smt_usage)
849
    updating_used_alone = true;
850
 
851
  /* If a dump file name is present, open it if enabled.  */
852
  if (pass->static_pass_number != -1)
853
    {
854
      initializing_dump = !dump_initialized_p (pass->static_pass_number);
855
      dump_file_name = get_dump_file_name (pass->static_pass_number);
856
      dump_file = dump_begin (pass->static_pass_number, &dump_flags);
857
      if (dump_file && current_function_decl)
858
        {
859
          const char *dname, *aname;
860
          dname = lang_hooks.decl_printable_name (current_function_decl, 2);
861
          aname = (IDENTIFIER_POINTER
862
                   (DECL_ASSEMBLER_NAME (current_function_decl)));
863
          fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
864
             cfun->function_frequency == FUNCTION_FREQUENCY_HOT
865
             ? " (hot)"
866
             : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
867
             ? " (unlikely executed)"
868
             : "");
869
        }
870
    }
871
  else
872
    initializing_dump = false;
873
 
874
  /* If a timevar is present, start it.  */
875
  if (pass->tv_id)
876
    timevar_push (pass->tv_id);
877
 
878
  /* Do it!  */
879
  if (pass->execute)
880
    {
881
      todo_after = pass->execute ();
882
      last_verified = 0;
883
    }
884
 
885
  /* Stop timevar.  */
886
  if (pass->tv_id)
887
    timevar_pop (pass->tv_id);
888
 
889
  curr_properties = (curr_properties | pass->properties_provided)
890
                    & ~pass->properties_destroyed;
891
 
892
  if (initializing_dump
893
      && dump_file
894
      && graph_dump_format != no_graph
895
      && (curr_properties & (PROP_cfg | PROP_rtl)) == (PROP_cfg | PROP_rtl))
896
    {
897
      get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
898
      dump_flags |= TDF_GRAPH;
899
      clean_graph_dump_file (dump_file_name);
900
    }
901
 
902
  /* Run post-pass cleanup and verification.  */
903
  execute_todo (todo_after | pass->todo_flags_finish);
904
  verify_interpass_invariants ();
905
 
906
  /* Flush and close dump file.  */
907
  if (dump_file_name)
908
    {
909
      free ((char *) dump_file_name);
910
      dump_file_name = NULL;
911
    }
912
  if (dump_file)
913
    {
914
      dump_end (pass->static_pass_number, dump_file);
915
      dump_file = NULL;
916
    }
917
 
918
  if (pass->properties_destroyed & PROP_smt_usage)
919
    updating_used_alone = false;
920
 
921
  /* Reset in_gimple_form to not break non-unit-at-a-time mode.  */
922
  in_gimple_form = false;
923
 
924
  return true;
925
}
926
 
927
void
928
execute_pass_list (struct tree_opt_pass *pass)
929
{
930
  do
931
    {
932
      if (execute_one_pass (pass) && pass->sub)
933
        execute_pass_list (pass->sub);
934
      pass = pass->next;
935
    }
936
  while (pass);
937
}
938
 
939
/* Same as execute_pass_list but assume that subpasses of IPA passes
940
   are local passes.  */
941
void
942
execute_ipa_pass_list (struct tree_opt_pass *pass)
943
{
944
  do
945
    {
946
      if (execute_one_pass (pass) && pass->sub)
947
        {
948
          struct cgraph_node *node;
949
          for (node = cgraph_nodes; node; node = node->next)
950
            if (node->analyzed)
951
              {
952
                push_cfun (DECL_STRUCT_FUNCTION (node->decl));
953
                current_function_decl = node->decl;
954
                execute_pass_list (pass->sub);
955
                free_dominance_info (CDI_DOMINATORS);
956
                free_dominance_info (CDI_POST_DOMINATORS);
957
                current_function_decl = NULL;
958
                pop_cfun ();
959
                ggc_collect ();
960
              }
961
        }
962
      pass = pass->next;
963
    }
964
  while (pass);
965
}

powered by: WebSVN 2.1.0

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