1 /* Inline functions for tree-flow.h
2 Copyright (C) 2001, 2003 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 #ifndef _TREE_FLOW_INLINE_H
23 #define _TREE_FLOW_INLINE_H 1
25 /* Inline functions for manipulating various data structures defined in
26 tree-flow.h. See tree-flow.h for documentation. */
28 /* Return the variable annotation for T, which must be a _DECL node.
29 Return NULL if the variable annotation doesn't already exist. */
30 static inline var_ann_t
33 #if defined ENABLE_CHECKING
37 && t->common.ann->common.type != VAR_ANN))
41 return (var_ann_t) t->common.ann;
44 /* Return the variable annotation for T, which must be a _DECL node.
45 Create the variable annotation if it doesn't exist. */
46 static inline var_ann_t
47 get_var_ann (tree var)
49 var_ann_t ann = var_ann (var);
50 return (ann) ? ann : create_var_ann (var);
53 /* Return the statement annotation for T, which must be a statement
54 node. Return NULL if the statement annotation doesn't exist. */
55 static inline stmt_ann_t
58 #if defined ENABLE_CHECKING
59 if (!is_gimple_stmt (t))
63 return (stmt_ann_t) t->common.ann;
66 /* Return the statement annotation for T, which must be a statement
67 node. Create the statement annotation if it doesn't exist. */
68 static inline stmt_ann_t
69 get_stmt_ann (tree stmt)
71 stmt_ann_t ann = stmt_ann (stmt);
72 return (ann) ? ann : create_stmt_ann (stmt);
76 /* Return the annotation type for annotation ANN. */
77 static inline enum tree_ann_type
78 ann_type (tree_ann_t ann)
80 return ann->common.type;
83 /* Return the basic block for statement T. */
84 static inline basic_block
87 stmt_ann_t ann = stmt_ann (t);
88 return ann ? ann->bb : NULL;
91 /* Return the may_aliases varray for variable VAR, or NULL if it has
93 static inline varray_type
94 may_aliases (tree var)
96 var_ann_t ann = var_ann (var);
97 return ann ? ann->may_aliases : NULL;
100 /* Return the line number for EXPR, or return -1 if we have no line
101 number information for it. */
103 get_lineno (tree expr)
105 if (expr == NULL_TREE)
108 if (TREE_CODE (expr) == COMPOUND_EXPR)
109 expr = TREE_OPERAND (expr, 0);
111 if (! EXPR_HAS_LOCATION (expr))
114 return EXPR_LINENO (expr);
117 /* Return the file name for EXPR, or return "???" if we have no
118 filename information. */
119 static inline const char *
120 get_filename (tree expr)
122 const char *filename;
123 if (expr == NULL_TREE)
126 if (TREE_CODE (expr) == COMPOUND_EXPR)
127 expr = TREE_OPERAND (expr, 0);
129 if (EXPR_HAS_LOCATION (expr) && (filename = EXPR_FILENAME (expr)))
135 /* Mark statement T as modified. */
139 stmt_ann_t ann = stmt_ann (t);
141 ann = create_stmt_ann (t);
145 /* Mark statement T as unmodified. */
147 unmodify_stmt (tree t)
149 stmt_ann_t ann = stmt_ann (t);
151 ann = create_stmt_ann (t);
155 /* Return true if T is marked as modified, false otherwise. */
157 stmt_modified_p (tree t)
159 stmt_ann_t ann = stmt_ann (t);
161 /* Note that if the statement doesn't yet have an annotation, we consider it
162 modified. This will force the next call to get_stmt_operands to scan the
164 return ann ? ann->modified : true;
167 /* Return the definitions present in ANN, a statement annotation.
168 Return NULL if this annotation contains no definitions. */
169 static inline def_optype
170 get_def_ops (stmt_ann_t ann)
172 return ann ? ann->def_ops : NULL;
175 /* Return the uses present in ANN, a statement annotation.
176 Return NULL if this annotation contains no uses. */
177 static inline use_optype
178 get_use_ops (stmt_ann_t ann)
180 return ann ? ann->use_ops : NULL;
183 /* Return the virtual may-defs present in ANN, a statement
185 Return NULL if this annotation contains no virtual may-defs. */
186 static inline v_may_def_optype
187 get_v_may_def_ops (stmt_ann_t ann)
189 return ann ? ann->v_may_def_ops : NULL;
192 /* Return the virtual uses present in ANN, a statement annotation.
193 Return NULL if this annotation contains no virtual uses. */
194 static inline vuse_optype
195 get_vuse_ops (stmt_ann_t ann)
197 return ann ? ann->vuse_ops : NULL;
200 /* Return the virtual must-defs present in ANN, a statement
201 annotation. Return NULL if this annotation contains no must-defs.*/
202 static inline v_must_def_optype
203 get_v_must_def_ops (stmt_ann_t ann)
205 return ann ? ann->v_must_def_ops : NULL;
208 /* Return the tree pointer to by USE. */
210 get_use_from_ptr (use_operand_p use)
215 /* Return the tree pointer to by DEF. */
217 get_def_from_ptr (def_operand_p def)
222 /* Return a pointer to the tree that is at INDEX in the USES array. */
223 static inline use_operand_p
224 get_use_op_ptr (use_optype uses, unsigned int index)
226 #ifdef ENABLE_CHECKING
227 if (index >= uses->num_uses)
230 return uses->uses[index];
233 /* Return a def_operand_p pointer for element INDEX of DEFS. */
234 static inline def_operand_p
235 get_def_op_ptr (def_optype defs, unsigned int index)
237 #ifdef ENABLE_CHECKING
238 if (index >= defs->num_defs)
241 return defs->defs[index];
245 /* Return the def_operand_p that is the V_MAY_DEF_RESULT for the V_MAY_DEF
246 at INDEX in the V_MAY_DEFS array. */
247 static inline def_operand_p
248 get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index)
251 #ifdef ENABLE_CHECKING
252 if (index >= v_may_defs->num_v_may_defs)
255 op.def = &(v_may_defs->v_may_defs[index * 2]);
259 /* Return a use_operand_p that is the V_MAY_DEF_OP for the V_MAY_DEF at
260 INDEX in the V_MAY_DEFS array. */
261 static inline use_operand_p
262 get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index)
265 #ifdef ENABLE_CHECKING
266 if (index >= v_may_defs->num_v_may_defs)
269 op.use = &(v_may_defs->v_may_defs[index * 2 + 1]);
273 /* Return a use_operand_p that is at INDEX in the VUSES array. */
274 static inline use_operand_p
275 get_vuse_op_ptr(vuse_optype vuses, unsigned int index)
278 #ifdef ENABLE_CHECKING
279 if (index >= vuses->num_vuses)
282 op.use = &(vuses->vuses[index]);
286 /* Return a def_operand_p that is the V_MUST_DEF_OP for the
287 V_MUST_DEF at INDEX in the V_MUST_DEFS array. */
288 static inline def_operand_p
289 get_v_must_def_op_ptr (v_must_def_optype v_must_defs, unsigned int index)
292 #ifdef ENABLE_CHECKING
293 if (index >= v_must_defs->num_v_must_defs)
296 op.def = &(v_must_defs->v_must_defs[index]);
300 /* Return a def_operand_p pointer for the result of PHI. */
301 static inline def_operand_p
302 get_phi_result_ptr (tree phi)
305 op.def = &(PHI_RESULT_TREE (phi));
309 /* Return a use_operand_p pointer for argument I of phinode PHI. */
310 static inline use_operand_p
311 get_phi_arg_def_ptr (tree phi, int i)
314 op.use = &(PHI_ARG_DEF_TREE (phi, i));
318 /* Mark the beginning of changes to the SSA operands for STMT. */
320 start_ssa_stmt_operands (tree stmt ATTRIBUTE_UNUSED)
322 #ifdef ENABLE_CHECKING
323 verify_start_operands (stmt);
327 /* Return the bitmap of addresses taken by STMT, or NULL if it takes
330 addresses_taken (tree stmt)
332 stmt_ann_t ann = stmt_ann (stmt);
333 return ann ? ann->addresses_taken : NULL;
336 /* Return the immediate uses of STMT, or NULL if this information is
339 get_immediate_uses (tree stmt)
341 stmt_ann_t ann = stmt_ann (stmt);
342 return ann ? ann->df : NULL;
345 /* Return the number of immediate uses present in the dataflow
346 information at DF. */
348 num_immediate_uses (dataflow_t df)
355 imm = df->immediate_uses;
357 return df->uses[1] ? 2 : 1;
359 return VARRAY_ACTIVE_SIZE (imm) + 2;
362 /* Return the tree that is at NUM in the immediate use DF array. */
364 immediate_use (dataflow_t df, int num)
369 #ifdef ENABLE_CHECKING
370 if (num >= num_immediate_uses (df))
374 return df->uses[num];
375 return VARRAY_TREE (df->immediate_uses, num - 2);
378 /* Return the basic_block annotation for BB. */
379 static inline bb_ann_t
380 bb_ann (basic_block bb)
382 return (bb_ann_t)bb->tree_annotations;
385 /* Return the PHI nodes for basic block BB, or NULL if there are no
388 phi_nodes (basic_block bb)
392 return bb_ann (bb)->phi_nodes;
395 /* Set list of phi nodes of a basic block BB to L. */
398 set_phi_nodes (basic_block bb, tree l)
402 bb_ann (bb)->phi_nodes = l;
403 for (phi = l; phi; phi = PHI_CHAIN (phi))
404 set_bb_for_stmt (phi, bb);
407 /* Return the phi index number for an edge. */
409 phi_arg_from_edge (tree phi, edge e)
412 #if defined ENABLE_CHECKING
413 if (!phi || TREE_CODE (phi) != PHI_NODE)
417 for (i = 0; i < PHI_NUM_ARGS (phi); i++)
418 if (PHI_ARG_EDGE (phi, i) == e)
424 /* ----------------------------------------------------------------------- */
426 /* Return true if T is an executable statement. */
428 is_exec_stmt (tree t)
430 return (t && !IS_EMPTY_STMT (t) && t != error_mark_node);
434 /* Return true if this stmt can be the target of a control transfer stmt such
437 is_label_stmt (tree t)
440 switch (TREE_CODE (t))
444 case CASE_LABEL_EXPR:
452 /* Set the default definition for VAR to DEF. */
454 set_default_def (tree var, tree def)
456 var_ann_t ann = var_ann (var);
458 ann = create_var_ann (var);
459 ann->default_def = def;
462 /* Return the default definition for variable VAR, or NULL if none
465 default_def (tree var)
467 var_ann_t ann = var_ann (var);
468 return ann ? ann->default_def : NULL_TREE;
471 /* PHI nodes should contain only ssa_names and invariants. A test
472 for ssa_name is definitely simpler; don't let invalid contents
473 slip in in the meantime. */
476 phi_ssa_name_p (tree t)
478 if (TREE_CODE (t) == SSA_NAME)
480 #ifdef ENABLE_CHECKING
481 if (!is_gimple_min_invariant (t))
487 /* ----------------------------------------------------------------------- */
489 /* Return a block_stmt_iterator that points to beginning of basic
491 static inline block_stmt_iterator
492 bsi_start (basic_block bb)
494 block_stmt_iterator bsi;
496 bsi.tsi = tsi_start (bb->stmt_list);
499 #ifdef ENABLE_CHECKING
504 bsi.tsi.container = NULL;
510 /* Return a block statement iterator that points to the last label in
513 static inline block_stmt_iterator
514 bsi_after_labels (basic_block bb)
516 block_stmt_iterator bsi;
517 tree_stmt_iterator next;
523 #ifdef ENABLE_CHECKING
528 bsi.tsi.container = NULL;
532 bsi.tsi = tsi_start (bb->stmt_list);
533 if (tsi_end_p (bsi.tsi))
536 /* Ensure that there are some labels. The rationale is that we want
537 to insert after the bsi that is returned, and these insertions should
538 be placed at the start of the basic block. This would not work if the
539 first statement was not label; rather fail here than enable the user
540 proceed in wrong way. */
541 if (TREE_CODE (tsi_stmt (bsi.tsi)) != LABEL_EXPR)
547 while (!tsi_end_p (next)
548 && TREE_CODE (tsi_stmt (next)) == LABEL_EXPR)
557 /* Return a block statement iterator that points to the end of basic
559 static inline block_stmt_iterator
560 bsi_last (basic_block bb)
562 block_stmt_iterator bsi;
564 bsi.tsi = tsi_last (bb->stmt_list);
567 #ifdef ENABLE_CHECKING
572 bsi.tsi.container = NULL;
578 /* Return true if block statement iterator I has reached the end of
581 bsi_end_p (block_stmt_iterator i)
583 return tsi_end_p (i.tsi);
586 /* Modify block statement iterator I so that it is at the next
587 statement in the basic block. */
589 bsi_next (block_stmt_iterator *i)
594 /* Modify block statement iterator I so that it is at the previous
595 statement in the basic block. */
597 bsi_prev (block_stmt_iterator *i)
602 /* Return the statement that block statement iterator I is currently
605 bsi_stmt (block_stmt_iterator i)
607 return tsi_stmt (i.tsi);
610 /* Return a pointer to the statement that block statement iterator I
613 bsi_stmt_ptr (block_stmt_iterator i)
615 return tsi_stmt_ptr (i.tsi);
618 /* Returns the loop of the statement STMT. */
620 static inline struct loop *
621 loop_containing_stmt (tree stmt)
623 basic_block bb = bb_for_stmt (stmt);
627 return bb->loop_father;
630 /* Return true if VAR may be aliased. */
632 may_be_aliased (tree var)
634 return (TREE_ADDRESSABLE (var)
635 || decl_function_context (var) != current_function_decl);
638 /* Return true if VAR is a clobbered by function calls. */
640 is_call_clobbered (tree var)
642 return needs_to_live_in_memory (var)
643 || bitmap_bit_p (call_clobbered_vars, var_ann (var)->uid);
646 /* Mark variable VAR as being clobbered by function calls. */
648 mark_call_clobbered (tree var)
650 var_ann_t ann = var_ann (var);
651 /* Call-clobbered variables need to live in memory. */
652 DECL_NEEDS_TO_LIVE_IN_MEMORY_INTERNAL (var) = 1;
653 bitmap_set_bit (call_clobbered_vars, ann->uid);
656 /* Mark variable VAR as being non-addressable. */
658 mark_non_addressable (tree var)
660 bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
661 DECL_NEEDS_TO_LIVE_IN_MEMORY_INTERNAL (var) = 0;
662 TREE_ADDRESSABLE (var) = 0;
665 /* Return the common annotation for T. Return NULL if the annotation
666 doesn't already exist. */
667 static inline tree_ann_t
670 return t->common.ann;
673 /* Return a common annotation for T. Create the constant annotation if it
675 static inline tree_ann_t
676 get_tree_ann (tree t)
678 tree_ann_t ann = tree_ann (t);
679 return (ann) ? ann : create_tree_ann (t);
682 #endif /* _TREE_FLOW_INLINE_H */