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/] [tree-flow.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
/* Data and Control Flow Analysis for Trees.
2
   Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
3
   2012 Free Software Foundation, Inc.
4
   Contributed by Diego Novillo <dnovillo@redhat.com>
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 3, or (at your option)
11
any later version.
12
 
13
GCC is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
GNU General Public License 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
#ifndef _TREE_FLOW_H
23
#define _TREE_FLOW_H 1
24
 
25
#include "bitmap.h"
26
#include "sbitmap.h"
27
#include "basic-block.h"
28
#include "hashtab.h"
29
#include "gimple.h"
30
#include "tree-ssa-operands.h"
31
#include "cgraph.h"
32
#include "ipa-reference.h"
33
#include "tree-ssa-alias.h"
34
 
35
 
36
/* This structure is used to map a gimple statement to a label,
37
   or list of labels to represent transaction restart.  */
38
 
39
struct GTY(()) tm_restart_node {
40
  gimple stmt;
41
  tree label_or_list;
42
};
43
 
44
/* Gimple dataflow datastructure. All publicly available fields shall have
45
   gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable
46
   fields should have gimple_set accessor.  */
47
struct GTY(()) gimple_df {
48
  /* A vector of all the noreturn calls passed to modify_stmt.
49
     cleanup_control_flow uses it to detect cases where a mid-block
50
     indirect call has been turned into a noreturn call.  When this
51
     happens, all the instructions after the call are no longer
52
     reachable and must be deleted as dead.  */
53
  vec<gimple, va_gc> *modified_noreturn_calls;
54
 
55
  /* Array of all SSA_NAMEs used in the function.  */
56
  vec<tree, va_gc> *ssa_names;
57
 
58
  /* Artificial variable used for the virtual operand FUD chain.  */
59
  tree vop;
60
 
61
  /* The PTA solution for the ESCAPED artificial variable.  */
62
  struct pt_solution escaped;
63
 
64
  /* A map of decls to artificial ssa-names that point to the partition
65
     of the decl.  */
66
  struct pointer_map_t * GTY((skip(""))) decls_to_pointers;
67
 
68
  /* Free list of SSA_NAMEs.  */
69
  vec<tree, va_gc> *free_ssanames;
70
 
71
  /* Hashtable holding definition for symbol.  If this field is not NULL, it
72
     means that the first reference to this variable in the function is a
73
     USE or a VUSE.  In those cases, the SSA renamer creates an SSA name
74
     for this variable with an empty defining statement.  */
75
  htab_t GTY((param_is (union tree_node))) default_defs;
76
 
77
  /* True if there are any symbols that need to be renamed.  */
78
  unsigned int ssa_renaming_needed : 1;
79
 
80
  /* True if all virtual operands need to be renamed.  */
81
  unsigned int rename_vops : 1;
82
 
83
  /* True if the code is in ssa form.  */
84
  unsigned int in_ssa_p : 1;
85
 
86
  /* True if IPA points-to information was computed for this function.  */
87
  unsigned int ipa_pta : 1;
88
 
89
  struct ssa_operands ssa_operands;
90
 
91
  /* Map gimple stmt to tree label (or list of labels) for transaction
92
     restart and abort.  */
93
  htab_t GTY ((param_is (struct tm_restart_node))) tm_restart;
94
};
95
 
96
/* Accessors for internal use only.  Generic code should use abstraction
97
   provided by tree-flow-inline.h or specific modules.  */
98
#define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames
99
#define SSANAMES(fun) (fun)->gimple_df->ssa_names
100
#define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls
101
#define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs
102
 
103
typedef struct
104
{
105
  htab_t htab;
106
  PTR *slot;
107
  PTR *limit;
108
} htab_iterator;
109
 
110
/* Iterate through the elements of hashtable HTAB, using htab_iterator ITER,
111
   storing each element in RESULT, which is of type TYPE.  */
112
#define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \
113
  for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \
114
        !end_htab_p (&(ITER)); \
115
        RESULT = (TYPE) next_htab_element (&(ITER)))
116
 
117
/*---------------------------------------------------------------------------
118
                      Attributes for SSA_NAMEs.
119
 
120
  NOTE: These structures are stored in struct tree_ssa_name
121
  but are only used by the tree optimizers, so it makes better sense
122
  to declare them here to avoid recompiling unrelated files when
123
  making changes.
124
---------------------------------------------------------------------------*/
125
 
126
/* Aliasing information for SSA_NAMEs representing pointer variables.  */
127
 
128
struct GTY(()) ptr_info_def
129
{
130
  /* The points-to solution.  */
131
  struct pt_solution pt;
132
 
133
  /* Alignment and misalignment of the pointer in bytes.  Together
134
     align and misalign specify low known bits of the pointer.
135
     ptr & (align - 1) == misalign.  */
136
 
137
  /* When known, this is the power-of-two byte alignment of the object this
138
     pointer points into.  This is usually DECL_ALIGN_UNIT for decls and
139
     MALLOC_ABI_ALIGNMENT for allocated storage.  When the alignment is not
140
     known, it is zero.  Do not access directly but use functions
141
     get_ptr_info_alignment, set_ptr_info_alignment,
142
     mark_ptr_info_alignment_unknown and similar.  */
143
  unsigned int align;
144
 
145
  /* When alignment is known, the byte offset this pointer differs from the
146
     above alignment.  Access only through the same helper functions as align
147
     above.  */
148
  unsigned int misalign;
149
};
150
 
151
 
152
/* It is advantageous to avoid things like life analysis for variables which
153
   do not need PHI nodes.  This enum describes whether or not a particular
154
   variable may need a PHI node.  */
155
 
156
enum need_phi_state {
157
  /* This is the default.  If we are still in this state after finding
158
     all the definition and use sites, then we will assume the variable
159
     needs PHI nodes.  This is probably an overly conservative assumption.  */
160
  NEED_PHI_STATE_UNKNOWN,
161
 
162
  /* This state indicates that we have seen one or more sets of the
163
     variable in a single basic block and that the sets dominate all
164
     uses seen so far.  If after finding all definition and use sites
165
     we are still in this state, then the variable does not need any
166
     PHI nodes.  */
167
  NEED_PHI_STATE_NO,
168
 
169
  /* This state indicates that we have either seen multiple definitions of
170
     the variable in multiple blocks, or that we encountered a use in a
171
     block that was not dominated by the block containing the set(s) of
172
     this variable.  This variable is assumed to need PHI nodes.  */
173
  NEED_PHI_STATE_MAYBE
174
};
175
 
176
 
177
/* Immediate use lists are used to directly access all uses for an SSA
178
   name and get pointers to the statement for each use.
179
 
180
   The structure ssa_use_operand_d consists of PREV and NEXT pointers
181
   to maintain the list.  A USE pointer, which points to address where
182
   the use is located and a LOC pointer which can point to the
183
   statement where the use is located, or, in the case of the root
184
   node, it points to the SSA name itself.
185
 
186
   The list is anchored by an occurrence of ssa_operand_d *in* the
187
   ssa_name node itself (named 'imm_uses').  This node is uniquely
188
   identified by having a NULL USE pointer. and the LOC pointer
189
   pointing back to the ssa_name node itself.  This node forms the
190
   base for a circular list, and initially this is the only node in
191
   the list.
192
 
193
   Fast iteration allows each use to be examined, but does not allow
194
   any modifications to the uses or stmts.
195
 
196
   Normal iteration allows insertion, deletion, and modification. the
197
   iterator manages this by inserting a marker node into the list
198
   immediately before the node currently being examined in the list.
199
   this marker node is uniquely identified by having null stmt *and* a
200
   null use pointer.
201
 
202
   When iterating to the next use, the iteration routines check to see
203
   if the node after the marker has changed. if it has, then the node
204
   following the marker is now the next one to be visited. if not, the
205
   marker node is moved past that node in the list (visualize it as
206
   bumping the marker node through the list).  this continues until
207
   the marker node is moved to the original anchor position. the
208
   marker node is then removed from the list.
209
 
210
   If iteration is halted early, the marker node must be removed from
211
   the list before continuing.  */
212
typedef struct immediate_use_iterator_d
213
{
214
  /* This is the current use the iterator is processing.  */
215
  ssa_use_operand_t *imm_use;
216
  /* This marks the last use in the list (use node from SSA_NAME)  */
217
  ssa_use_operand_t *end_p;
218
  /* This node is inserted and used to mark the end of the uses for a stmt.  */
219
  ssa_use_operand_t iter_node;
220
  /* This is the next ssa_name to visit.  IMM_USE may get removed before
221
     the next one is traversed to, so it must be cached early.  */
222
  ssa_use_operand_t *next_imm_name;
223
} imm_use_iterator;
224
 
225
 
226
/* Use this iterator when simply looking at stmts.  Adding, deleting or
227
   modifying stmts will cause this iterator to malfunction.  */
228
 
229
#define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR)               \
230
  for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR));     \
231
       !end_readonly_imm_use_p (&(ITER));                       \
232
       (void) ((DEST) = next_readonly_imm_use (&(ITER))))
233
 
234
/* Use this iterator to visit each stmt which has a use of SSAVAR.  */
235
 
236
#define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR)               \
237
  for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR));         \
238
       !end_imm_use_stmt_p (&(ITER));                           \
239
       (void) ((STMT) = next_imm_use_stmt (&(ITER))))
240
 
241
/* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early.  Failure to
242
   do so will result in leaving a iterator marker node in the immediate
243
   use list, and nothing good will come from that.   */
244
#define BREAK_FROM_IMM_USE_STMT(ITER)                           \
245
   {                                                            \
246
     end_imm_use_stmt_traverse (&(ITER));                       \
247
     break;                                                     \
248
   }
249
 
250
 
251
/* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to
252
   get access to each occurrence of ssavar on the stmt returned by
253
   that iterator..  for instance:
254
 
255
     FOR_EACH_IMM_USE_STMT (stmt, iter, var)
256
       {
257
         FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
258
           {
259
             SET_USE (use_p, blah);
260
           }
261
         update_stmt (stmt);
262
       }                                                         */
263
 
264
#define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER)                    \
265
  for ((DEST) = first_imm_use_on_stmt (&(ITER));                \
266
       !end_imm_use_on_stmt_p (&(ITER));                        \
267
       (void) ((DEST) = next_imm_use_on_stmt (&(ITER))))
268
 
269
 
270
 
271
static inline void update_stmt (gimple);
272
static inline int get_lineno (const_gimple);
273
 
274
/* Accessors for basic block annotations.  */
275
static inline gimple_seq phi_nodes (const_basic_block);
276
static inline void set_phi_nodes (basic_block, gimple_seq);
277
 
278
/*---------------------------------------------------------------------------
279
                              Global declarations
280
---------------------------------------------------------------------------*/
281
struct int_tree_map {
282
  unsigned int uid;
283
  tree to;
284
};
285
 
286
extern unsigned int int_tree_map_hash (const void *);
287
extern int int_tree_map_eq (const void *, const void *);
288
 
289
extern unsigned int uid_decl_map_hash (const void *);
290
extern int uid_decl_map_eq (const void *, const void *);
291
 
292
#define num_ssa_names (vec_safe_length (cfun->gimple_df->ssa_names))
293
#define ssa_name(i) ((*cfun->gimple_df->ssa_names)[(i)])
294
 
295
/* Macros for showing usage statistics.  */
296
#define SCALE(x) ((unsigned long) ((x) < 1024*10        \
297
                  ? (x)                                 \
298
                  : ((x) < 1024*1024*10                 \
299
                     ? (x) / 1024                       \
300
                     : (x) / (1024*1024))))
301
 
302
#define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M'))
303
 
304
#define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y))
305
 
306
/*---------------------------------------------------------------------------
307
                              OpenMP Region Tree
308
---------------------------------------------------------------------------*/
309
 
310
/* Parallel region information.  Every parallel and workshare
311
   directive is enclosed between two markers, the OMP_* directive
312
   and a corresponding OMP_RETURN statement.  */
313
 
314
struct omp_region
315
{
316
  /* The enclosing region.  */
317
  struct omp_region *outer;
318
 
319
  /* First child region.  */
320
  struct omp_region *inner;
321
 
322
  /* Next peer region.  */
323
  struct omp_region *next;
324
 
325
  /* Block containing the omp directive as its last stmt.  */
326
  basic_block entry;
327
 
328
  /* Block containing the OMP_RETURN as its last stmt.  */
329
  basic_block exit;
330
 
331
  /* Block containing the OMP_CONTINUE as its last stmt.  */
332
  basic_block cont;
333
 
334
  /* If this is a combined parallel+workshare region, this is a list
335
     of additional arguments needed by the combined parallel+workshare
336
     library call.  */
337
  vec<tree, va_gc> *ws_args;
338
 
339
  /* The code for the omp directive of this region.  */
340
  enum gimple_code type;
341
 
342
  /* Schedule kind, only used for OMP_FOR type regions.  */
343
  enum omp_clause_schedule_kind sched_kind;
344
 
345
  /* True if this is a combined parallel+workshare region.  */
346
  bool is_combined_parallel;
347
};
348
 
349
extern struct omp_region *root_omp_region;
350
extern struct omp_region *new_omp_region (basic_block, enum gimple_code,
351
                                          struct omp_region *);
352
extern void free_omp_regions (void);
353
void omp_expand_local (basic_block);
354
extern tree find_omp_clause (tree, enum omp_clause_code);
355
tree copy_var_decl (tree, tree, tree);
356
 
357
/*---------------------------------------------------------------------------
358
                              Function prototypes
359
---------------------------------------------------------------------------*/
360
/* In tree-cfg.c  */
361
 
362
/* Location to track pending stmt for edge insertion.  */
363
#define PENDING_STMT(e) ((e)->insns.g)
364
 
365
extern void delete_tree_cfg_annotations (void);
366
extern bool stmt_ends_bb_p (gimple);
367
extern bool is_ctrl_stmt (gimple);
368
extern bool is_ctrl_altering_stmt (gimple);
369
extern bool simple_goto_p (gimple);
370
extern bool stmt_can_make_abnormal_goto (gimple);
371
extern basic_block single_noncomplex_succ (basic_block bb);
372
extern void gimple_dump_bb (FILE *, basic_block, int, int);
373
extern void gimple_debug_bb (basic_block);
374
extern basic_block gimple_debug_bb_n (int);
375
extern void gimple_dump_cfg (FILE *, int);
376
extern void gimple_debug_cfg (int);
377
extern void dump_cfg_stats (FILE *);
378
extern void dot_cfg (void);
379
extern void debug_cfg_stats (void);
380
extern void debug_loops (int);
381
extern void debug_loop (struct loop *, int);
382
extern void debug_loop_num (unsigned, int);
383
extern void print_loops (FILE *, int);
384
extern void print_loops_bb (FILE *, basic_block, int, int);
385
extern void cleanup_dead_labels (void);
386
extern void group_case_labels_stmt (gimple);
387
extern void group_case_labels (void);
388
extern gimple first_stmt (basic_block);
389
extern gimple last_stmt (basic_block);
390
extern gimple last_and_only_stmt (basic_block);
391
extern edge find_taken_edge (basic_block, tree);
392
extern basic_block label_to_block_fn (struct function *, tree);
393
#define label_to_block(t) (label_to_block_fn (cfun, t))
394
extern void notice_special_calls (gimple);
395
extern void clear_special_calls (void);
396
extern void verify_gimple_in_seq (gimple_seq);
397
extern void verify_gimple_in_cfg (struct function *);
398
extern tree gimple_block_label (basic_block);
399
extern void extract_true_false_edges_from_block (basic_block, edge *, edge *);
400
extern bool gimple_duplicate_sese_region (edge, edge, basic_block *, unsigned,
401
                                        basic_block *);
402
extern bool gimple_duplicate_sese_tail (edge, edge, basic_block *, unsigned,
403
                                      basic_block *);
404
extern void gather_blocks_in_sese_region (basic_block entry, basic_block exit,
405
                                          vec<basic_block> *bbs_p);
406
extern void add_phi_args_after_copy_bb (basic_block);
407
extern void add_phi_args_after_copy (basic_block *, unsigned, edge);
408
extern bool gimple_purge_dead_eh_edges (basic_block);
409
extern bool gimple_purge_all_dead_eh_edges (const_bitmap);
410
extern bool gimple_purge_dead_abnormal_call_edges (basic_block);
411
extern bool gimple_purge_all_dead_abnormal_call_edges (const_bitmap);
412
extern tree gimplify_build1 (gimple_stmt_iterator *, enum tree_code,
413
                             tree, tree);
414
extern tree gimplify_build2 (gimple_stmt_iterator *, enum tree_code,
415
                             tree, tree, tree);
416
extern tree gimplify_build3 (gimple_stmt_iterator *, enum tree_code,
417
                             tree, tree, tree, tree);
418
extern void init_empty_tree_cfg (void);
419
extern void init_empty_tree_cfg_for_function (struct function *);
420
extern void fold_cond_expr_cond (void);
421
extern void make_abnormal_goto_edges (basic_block, bool);
422
extern void replace_uses_by (tree, tree);
423
extern void start_recording_case_labels (void);
424
extern void end_recording_case_labels (void);
425
extern basic_block move_sese_region_to_fn (struct function *, basic_block,
426
                                           basic_block, tree);
427
void remove_edge_and_dominated_blocks (edge);
428
bool tree_node_can_be_shared (tree);
429
 
430
/* In tree-cfgcleanup.c  */
431
extern bitmap cfgcleanup_altered_bbs;
432
extern bool cleanup_tree_cfg (void);
433
 
434
/* In tree-pretty-print.c.  */
435
extern void dump_generic_bb (FILE *, basic_block, int, int);
436
extern int op_code_prio (enum tree_code);
437
extern int op_prio (const_tree);
438
extern const char *op_symbol_code (enum tree_code);
439
 
440
/* In tree-dfa.c  */
441
extern void renumber_gimple_stmt_uids (void);
442
extern void renumber_gimple_stmt_uids_in_blocks (basic_block *, int);
443
extern void dump_dfa_stats (FILE *);
444
extern void debug_dfa_stats (void);
445
extern void dump_variable (FILE *, tree);
446
extern void debug_variable (tree);
447
extern void set_ssa_default_def (struct function *, tree, tree);
448
extern tree ssa_default_def (struct function *, tree);
449
extern tree get_or_create_ssa_default_def (struct function *, tree);
450
extern bool stmt_references_abnormal_ssa_name (gimple);
451
extern tree get_addr_base_and_unit_offset (tree, HOST_WIDE_INT *);
452
extern void dump_enumerated_decls (FILE *, int);
453
 
454
/* In tree-phinodes.c  */
455
extern void reserve_phi_args_for_new_edge (basic_block);
456
extern void add_phi_node_to_bb (gimple phi, basic_block bb);
457
extern gimple create_phi_node (tree, basic_block);
458
extern void add_phi_arg (gimple, tree, edge, source_location);
459
extern void remove_phi_args (edge);
460
extern void remove_phi_node (gimple_stmt_iterator *, bool);
461
extern void remove_phi_nodes (basic_block);
462
extern void release_phi_node (gimple);
463
extern void phinodes_print_statistics (void);
464
 
465
/* In gimple-low.c  */
466
extern void record_vars_into (tree, tree);
467
extern void record_vars (tree);
468
extern bool gimple_seq_may_fallthru (gimple_seq);
469
extern bool gimple_stmt_may_fallthru (gimple);
470
extern bool gimple_check_call_matching_types (gimple, tree);
471
 
472
 
473
/* In tree-ssa.c  */
474
 
475
/* Mapping for redirected edges.  */
476
struct _edge_var_map {
477
  tree result;                  /* PHI result.  */
478
  tree def;                     /* PHI arg definition.  */
479
  source_location locus;        /* PHI arg location.  */
480
};
481
typedef struct _edge_var_map edge_var_map;
482
 
483
 
484
/* A vector of var maps.  */
485
typedef vec<edge_var_map> edge_var_map_vector;
486
 
487
extern void init_tree_ssa (struct function *);
488
extern void redirect_edge_var_map_add (edge, tree, tree, source_location);
489
extern void redirect_edge_var_map_clear (edge);
490
extern void redirect_edge_var_map_dup (edge, edge);
491
extern edge_var_map_vector *redirect_edge_var_map_vector (edge);
492
extern void redirect_edge_var_map_destroy (void);
493
 
494
extern edge ssa_redirect_edge (edge, basic_block);
495
extern void flush_pending_stmts (edge);
496
extern void verify_ssa (bool);
497
extern void delete_tree_ssa (void);
498
extern bool ssa_undefined_value_p (tree);
499
extern void warn_uninit (enum opt_code, tree, tree, tree, const char *, void *);
500
extern unsigned int warn_uninitialized_vars (bool);
501
extern void execute_update_addresses_taken (void);
502
 
503
/* Call-back function for walk_use_def_chains().  At each reaching
504
   definition, a function with this prototype is called.  */
505
typedef bool (*walk_use_def_chains_fn) (tree, gimple, void *);
506
 
507
extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool);
508
 
509
void insert_debug_temps_for_defs (gimple_stmt_iterator *);
510
void insert_debug_temp_for_var_def (gimple_stmt_iterator *, tree);
511
void reset_debug_uses (gimple);
512
void release_defs_bitset (bitmap toremove);
513
 
514
/* In tree-into-ssa.c  */
515
void update_ssa (unsigned);
516
void delete_update_ssa (void);
517
tree create_new_def_for (tree, gimple, def_operand_p);
518
bool need_ssa_update_p (struct function *);
519
bool name_registered_for_update_p (tree);
520
void release_ssa_name_after_update_ssa (tree);
521
void mark_virtual_operands_for_renaming (struct function *);
522
tree get_current_def (tree);
523
void set_current_def (tree, tree);
524
 
525
/* In tree-ssanames.c  */
526
extern void init_ssanames (struct function *, int);
527
extern void fini_ssanames (void);
528
extern tree make_ssa_name_fn (struct function *, tree, gimple);
529
extern tree copy_ssa_name_fn (struct function *, tree, gimple);
530
extern tree duplicate_ssa_name_fn (struct function *, tree, gimple);
531
extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *);
532
extern void release_ssa_name (tree);
533
extern void release_defs (gimple);
534
extern void replace_ssa_name_symbol (tree, tree);
535
extern bool get_ptr_info_alignment (struct ptr_info_def *, unsigned int *,
536
                                    unsigned int *);
537
extern void mark_ptr_info_alignment_unknown (struct ptr_info_def *);
538
extern void set_ptr_info_alignment (struct ptr_info_def *, unsigned int,
539
                                    unsigned int);
540
extern void adjust_ptr_info_misalignment (struct ptr_info_def *,
541
                                          unsigned int);
542
 
543
extern void ssanames_print_statistics (void);
544
 
545
/* In tree-ssa-ccp.c  */
546
tree fold_const_aggregate_ref (tree);
547
tree gimple_fold_stmt_to_constant (gimple, tree (*)(tree));
548
 
549
/* In tree-ssa-dom.c  */
550
extern void dump_dominator_optimization_stats (FILE *);
551
extern void debug_dominator_optimization_stats (void);
552
int loop_depth_of_name (tree);
553
tree degenerate_phi_result (gimple);
554
bool simple_iv_increment_p (gimple);
555
 
556
/* In tree-ssa-copy.c  */
557
extern void propagate_value (use_operand_p, tree);
558
extern void propagate_tree_value (tree *, tree);
559
extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree);
560
extern void replace_exp (use_operand_p, tree);
561
extern bool may_propagate_copy (tree, tree);
562
extern bool may_propagate_copy_into_stmt (gimple, tree);
563
extern bool may_propagate_copy_into_asm (tree);
564
 
565
/* In tree-ssa-loop-ch.c  */
566
bool do_while_loop_p (struct loop *);
567
 
568
/* Affine iv.  */
569
 
570
typedef struct
571
{
572
  /* Iv = BASE + STEP * i.  */
573
  tree base, step;
574
 
575
  /* True if this iv does not overflow.  */
576
  bool no_overflow;
577
} affine_iv;
578
 
579
/* Description of number of iterations of a loop.  All the expressions inside
580
   the structure can be evaluated at the end of the loop's preheader
581
   (and due to ssa form, also anywhere inside the body of the loop).  */
582
 
583
struct tree_niter_desc
584
{
585
  tree assumptions;     /* The boolean expression.  If this expression evaluates
586
                           to false, then the other fields in this structure
587
                           should not be used; there is no guarantee that they
588
                           will be correct.  */
589
  tree may_be_zero;     /* The boolean expression.  If it evaluates to true,
590
                           the loop will exit in the first iteration (i.e.
591
                           its latch will not be executed), even if the niter
592
                           field says otherwise.  */
593
  tree niter;           /* The expression giving the number of iterations of
594
                           a loop (provided that assumptions == true and
595
                           may_be_zero == false), more precisely the number
596
                           of executions of the latch of the loop.  */
597
  double_int max;       /* The upper bound on the number of iterations of
598
                           the loop.  */
599
 
600
  /* The simplified shape of the exit condition.  The loop exits if
601
     CONTROL CMP BOUND is false, where CMP is one of NE_EXPR,
602
     LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is
603
     LE_EXPR and negative if CMP is GE_EXPR.  This information is used
604
     by loop unrolling.  */
605
  affine_iv control;
606
  tree bound;
607
  enum tree_code cmp;
608
};
609
 
610
/* In tree-ssa-phiopt.c */
611
bool empty_block_p (basic_block);
612
basic_block *blocks_in_phiopt_order (void);
613
 
614
/* In tree-ssa-loop*.c  */
615
 
616
unsigned int tree_ssa_lim (void);
617
unsigned int tree_ssa_unswitch_loops (void);
618
unsigned int canonicalize_induction_variables (void);
619
unsigned int tree_unroll_loops_completely (bool, bool);
620
unsigned int tree_ssa_prefetch_arrays (void);
621
void tree_ssa_iv_optimize (void);
622
unsigned tree_predictive_commoning (void);
623
tree canonicalize_loop_ivs (struct loop *, tree *, bool);
624
bool parallelize_loops (void);
625
 
626
bool loop_only_exit_p (const struct loop *, const_edge);
627
bool number_of_iterations_exit (struct loop *, edge,
628
                                struct tree_niter_desc *niter, bool,
629
                                bool every_iteration = true);
630
tree find_loop_niter (struct loop *, edge *);
631
tree loop_niter_by_eval (struct loop *, edge);
632
tree find_loop_niter_by_eval (struct loop *, edge *);
633
void estimate_numbers_of_iterations (void);
634
bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool);
635
bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool);
636
 
637
bool nowrap_type_p (tree);
638
enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN};
639
enum ev_direction scev_direction (const_tree);
640
 
641
void free_numbers_of_iterations_estimates (void);
642
void free_numbers_of_iterations_estimates_loop (struct loop *);
643
void rewrite_into_loop_closed_ssa (bitmap, unsigned);
644
void verify_loop_closed_ssa (bool);
645
bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *);
646
void create_iv (tree, tree, tree, struct loop *, gimple_stmt_iterator *, bool,
647
                tree *, tree *);
648
basic_block split_loop_exit_edge (edge);
649
void standard_iv_increment_position (struct loop *, gimple_stmt_iterator *,
650
                                     bool *);
651
basic_block ip_end_pos (struct loop *);
652
basic_block ip_normal_pos (struct loop *);
653
bool gimple_duplicate_loop_to_header_edge (struct loop *, edge,
654
                                         unsigned int, sbitmap,
655
                                         edge, vec<edge> *,
656
                                         int);
657
struct loop *slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *, edge);
658
void rename_variables_in_loop (struct loop *);
659
void rename_variables_in_bb (basic_block bb);
660
tree expand_simple_operations (tree);
661
void substitute_in_loop_info (struct loop *, tree, tree);
662
edge single_dom_exit (struct loop *);
663
bool can_unroll_loop_p (struct loop *loop, unsigned factor,
664
                        struct tree_niter_desc *niter);
665
void tree_unroll_loop (struct loop *, unsigned,
666
                       edge, struct tree_niter_desc *);
667
typedef void (*transform_callback)(struct loop *, void *);
668
void tree_transform_and_unroll_loop (struct loop *, unsigned,
669
                                     edge, struct tree_niter_desc *,
670
                                     transform_callback, void *);
671
bool contains_abnormal_ssa_name_p (tree);
672
bool stmt_dominates_stmt_p (gimple, gimple);
673
 
674
/* In tree-ssa-dce.c */
675
void mark_virtual_operand_for_renaming (tree);
676
void mark_virtual_phi_result_for_renaming (gimple);
677
 
678
/* In tree-ssa-threadedge.c */
679
extern void threadedge_initialize_values (void);
680
extern void threadedge_finalize_values (void);
681
extern vec<tree> ssa_name_values;
682
#define SSA_NAME_VALUE(x) \
683
    (SSA_NAME_VERSION(x) < ssa_name_values.length () \
684
     ? ssa_name_values[SSA_NAME_VERSION(x)] \
685
     : NULL_TREE)
686
extern void set_ssa_name_value (tree, tree);
687
extern bool potentially_threadable_block (basic_block);
688
extern void thread_across_edge (gimple, edge, bool,
689
                                vec<tree> *, tree (*) (gimple, gimple));
690
extern void propagate_threaded_block_debug_into (basic_block, basic_block);
691
 
692
/* In tree-ssa-loop-im.c  */
693
/* The possibilities of statement movement.  */
694
 
695
enum move_pos
696
  {
697
    MOVE_IMPOSSIBLE,            /* No movement -- side effect expression.  */
698
    MOVE_PRESERVE_EXECUTION,    /* Must not cause the non-executed statement
699
                                   become executed -- memory accesses, ... */
700
    MOVE_POSSIBLE               /* Unlimited movement.  */
701
  };
702
extern enum move_pos movement_possibility (gimple);
703
char *get_lsm_tmp_name (tree, unsigned);
704
 
705
/* In tree-flow-inline.h  */
706
static inline bool unmodifiable_var_p (const_tree);
707
static inline bool ref_contains_array_ref (const_tree);
708
 
709
/* In tree-eh.c  */
710
extern void make_eh_edges (gimple);
711
extern bool make_eh_dispatch_edges (gimple);
712
extern edge redirect_eh_edge (edge, basic_block);
713
extern void redirect_eh_dispatch_edge (gimple, edge, basic_block);
714
extern bool stmt_could_throw_p (gimple);
715
extern bool stmt_can_throw_internal (gimple);
716
extern bool stmt_can_throw_external (gimple);
717
extern void add_stmt_to_eh_lp_fn (struct function *, gimple, int);
718
extern void add_stmt_to_eh_lp (gimple, int);
719
extern bool remove_stmt_from_eh_lp (gimple);
720
extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple);
721
extern int lookup_stmt_eh_lp_fn (struct function *, gimple);
722
extern int lookup_stmt_eh_lp (gimple);
723
extern bool maybe_clean_eh_stmt_fn (struct function *, gimple);
724
extern bool maybe_clean_eh_stmt (gimple);
725
extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple);
726
extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple,
727
                                        struct function *, gimple,
728
                                        struct pointer_map_t *, int);
729
extern bool maybe_duplicate_eh_stmt (gimple, gimple);
730
extern bool verify_eh_edges (gimple);
731
extern bool verify_eh_dispatch_edge (gimple);
732
extern void maybe_remove_unreachable_handlers (void);
733
 
734
/* In tree-ssa-pre.c  */
735
void debug_value_expressions (unsigned int);
736
 
737
/* In tree-loop-linear.c  */
738
extern void linear_transform_loops (void);
739
extern unsigned perfect_loop_nest_depth (struct loop *);
740
 
741
/* In graphite.c  */
742
extern void graphite_transform_loops (void);
743
 
744
/* In tree-data-ref.c  */
745
extern void tree_check_data_deps (void);
746
 
747
/* In tree-ssa-loop-ivopts.c  */
748
bool expr_invariant_in_loop_p (struct loop *, tree);
749
bool stmt_invariant_in_loop_p (struct loop *, gimple);
750
bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode,
751
                                      addr_space_t);
752
bool may_be_nonaddressable_p (tree expr);
753
 
754
/* In tree-ssa-threadupdate.c.  */
755
extern bool thread_through_all_blocks (bool);
756
extern void register_jump_thread (edge, edge, edge);
757
 
758
/* In gimplify.c  */
759
tree force_gimple_operand_1 (tree, gimple_seq *, gimple_predicate, tree);
760
tree force_gimple_operand (tree, gimple_seq *, bool, tree);
761
tree force_gimple_operand_gsi_1 (gimple_stmt_iterator *, tree,
762
                                 gimple_predicate, tree,
763
                                 bool, enum gsi_iterator_update);
764
tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree,
765
                               bool, enum gsi_iterator_update);
766
tree gimple_fold_indirect_ref (tree);
767
 
768
/* In tree-ssa-live.c */
769
extern void remove_unused_locals (void);
770
extern void dump_scope_blocks (FILE *, int);
771
extern void debug_scope_blocks (int);
772
extern void debug_scope_block (tree, int);
773
 
774
/* In tree-ssa-address.c  */
775
 
776
/* Description of a memory address.  */
777
 
778
struct mem_address
779
{
780
  tree symbol, base, index, step, offset;
781
};
782
 
783
struct affine_tree_combination;
784
tree create_mem_ref (gimple_stmt_iterator *, tree,
785
                     struct affine_tree_combination *, tree, tree, tree, bool);
786
rtx addr_for_mem_ref (struct mem_address *, addr_space_t, bool);
787
void get_address_description (tree, struct mem_address *);
788
tree maybe_fold_tmr (tree);
789
 
790
unsigned int execute_fixup_cfg (void);
791
bool fixup_noreturn_call (gimple stmt);
792
 
793
/* In ipa-pure-const.c  */
794
void warn_function_noreturn (tree);
795
 
796
/* In tree-ssa-ter.c  */
797
bool stmt_is_replaceable_p (gimple);
798
 
799
/* In tree-parloops.c  */
800
bool parallelized_function_p (tree);
801
 
802
#include "tree-flow-inline.h"
803
 
804
void swap_tree_operands (gimple, tree *, tree *);
805
 
806
#endif /* _TREE_FLOW_H  */

powered by: WebSVN 2.1.0

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