diff options
Diffstat (limited to 'gcc/tree-flow-inline.h')
| -rw-r--r-- | gcc/tree-flow-inline.h | 643 |
1 files changed, 386 insertions, 257 deletions
diff --git a/gcc/tree-flow-inline.h b/gcc/tree-flow-inline.h index 5da85e049e1..3fa6259aa8e 100644 --- a/gcc/tree-flow-inline.h +++ b/gcc/tree-flow-inline.h @@ -186,7 +186,7 @@ stmt_modified_p (tree t) /* Delink an immediate_uses node from its chain. */ static inline void -delink_imm_use (ssa_imm_use_t *linknode) +delink_imm_use (ssa_use_operand_t *linknode) { /* Return if this node is not in a list. */ if (linknode->prev == NULL) @@ -200,7 +200,7 @@ delink_imm_use (ssa_imm_use_t *linknode) /* Link ssa_imm_use node LINKNODE into the chain for LIST. */ static inline void -link_imm_use_to_list (ssa_imm_use_t *linknode, ssa_imm_use_t *list) +link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list) { /* Link the new node at the head of the list. If we are in the process of traversing the list, we won't visit any new nodes added to it. */ @@ -212,9 +212,9 @@ link_imm_use_to_list (ssa_imm_use_t *linknode, ssa_imm_use_t *list) /* Link ssa_imm_use node LINKNODE into the chain for DEF. */ static inline void -link_imm_use (ssa_imm_use_t *linknode, tree def) +link_imm_use (ssa_use_operand_t *linknode, tree def) { - ssa_imm_use_t *root; + ssa_use_operand_t *root; if (!def || TREE_CODE (def) != SSA_NAME) linknode->prev = NULL; @@ -241,7 +241,7 @@ set_ssa_use_from_ptr (use_operand_p use, tree val) /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occuring in STMT. */ static inline void -link_imm_use_stmt (ssa_imm_use_t *linknode, tree def, tree stmt) +link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, tree stmt) { if (stmt) link_imm_use (linknode, def); @@ -252,7 +252,7 @@ link_imm_use_stmt (ssa_imm_use_t *linknode, tree def, tree stmt) /* Relink a new node in place of an old node in the list. */ static inline void -relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old) +relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old) { /* The node one had better be in the same list. */ gcc_assert (*(old->use) == *(node->use)); @@ -270,7 +270,7 @@ relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old) /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occuring in STMT. */ static inline void -relink_imm_use_stmt (ssa_imm_use_t *linknode, ssa_imm_use_t *old, tree stmt) +relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, tree stmt) { if (stmt) relink_imm_use (linknode, old); @@ -318,7 +318,7 @@ first_safe_imm_use (imm_use_iterator *imm, tree var) static inline use_operand_p next_safe_imm_use (imm_use_iterator *imm) { - ssa_imm_use_t *ptr; + ssa_use_operand_t *ptr; use_operand_p old; old = imm->imm_use; @@ -405,7 +405,7 @@ next_readonly_imm_use (imm_use_iterator *imm) static inline bool has_zero_uses (tree var) { - ssa_imm_use_t *ptr; + ssa_use_operand_t *ptr; ptr = &(SSA_NAME_IMM_USE_NODE (var)); /* A single use means there is no items in the list. */ return (ptr == ptr->next); @@ -415,7 +415,7 @@ has_zero_uses (tree var) static inline bool has_single_use (tree var) { - ssa_imm_use_t *ptr; + ssa_use_operand_t *ptr; ptr = &(SSA_NAME_IMM_USE_NODE (var)); /* A single use means there is one item in the list. */ return (ptr != ptr->next && ptr == ptr->next->next); @@ -426,7 +426,7 @@ has_single_use (tree var) static inline bool single_imm_use (tree var, use_operand_p *use_p, tree *stmt) { - ssa_imm_use_t *ptr; + ssa_use_operand_t *ptr; ptr = &(SSA_NAME_IMM_USE_NODE (var)); if (ptr != ptr->next && ptr == ptr->next->next) @@ -444,7 +444,7 @@ single_imm_use (tree var, use_operand_p *use_p, tree *stmt) static inline unsigned int num_imm_uses (tree var) { - ssa_imm_use_t *ptr, *start; + ssa_use_operand_t *ptr, *start; unsigned int num; start = &(SSA_NAME_IMM_USE_NODE (var)); @@ -455,46 +455,6 @@ num_imm_uses (tree var) return num; } -/* Return the definitions present in ANN, a statement annotation. - Return NULL if this annotation contains no definitions. */ -static inline def_optype -get_def_ops (stmt_ann_t ann) -{ - return ann ? ann->operands.def_ops : NULL; -} - -/* Return the uses present in ANN, a statement annotation. - Return NULL if this annotation contains no uses. */ -static inline use_optype -get_use_ops (stmt_ann_t ann) -{ - return ann ? ann->operands.use_ops : NULL; -} - -/* Return the virtual may-defs present in ANN, a statement - annotation. - Return NULL if this annotation contains no virtual may-defs. */ -static inline v_may_def_optype -get_v_may_def_ops (stmt_ann_t ann) -{ - return ann ? ann->operands.v_may_def_ops : NULL; -} - -/* Return the virtual uses present in ANN, a statement annotation. - Return NULL if this annotation contains no virtual uses. */ -static inline vuse_optype -get_vuse_ops (stmt_ann_t ann) -{ - return ann ? ann->operands.vuse_ops : NULL; -} - -/* Return the virtual must-defs present in ANN, a statement - annotation. Return NULL if this annotation contains no must-defs.*/ -static inline v_must_def_optype -get_v_must_def_ops (stmt_ann_t ann) -{ - return ann ? ann->operands.v_must_def_ops : NULL; -} /* Return the tree pointer to by USE. */ static inline tree @@ -507,80 +467,14 @@ get_use_from_ptr (use_operand_p use) static inline tree get_def_from_ptr (def_operand_p def) { - return *(def.def); -} - -/* Return a pointer to the tree that is at INDEX in the USES array. */ -static inline use_operand_p -get_use_op_ptr (use_optype uses, unsigned int index) -{ - gcc_assert (index < uses->num_uses); - return &(uses->uses[index]); -} - -/* Return a def_operand_p pointer for element INDEX of DEFS. */ -static inline def_operand_p -get_def_op_ptr (def_optype defs, unsigned int index) -{ - gcc_assert (index < defs->num_defs); - return defs->defs[index]; -} - -/* Return the def_operand_p that is the V_MAY_DEF_RESULT for the V_MAY_DEF - at INDEX in the V_MAY_DEFS array. */ -static inline def_operand_p -get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index) -{ - def_operand_p op; - gcc_assert (index < v_may_defs->num_v_may_defs); - op.def = &(v_may_defs->v_may_defs[index].def); - return op; -} - -/* Return a use_operand_p that is the V_MAY_DEF_OP for the V_MAY_DEF at - INDEX in the V_MAY_DEFS array. */ -static inline use_operand_p -get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index) -{ - gcc_assert (index < v_may_defs->num_v_may_defs); - return &(v_may_defs->v_may_defs[index].imm_use); -} - -/* Return a use_operand_p that is at INDEX in the VUSES array. */ -static inline use_operand_p -get_vuse_op_ptr(vuse_optype vuses, unsigned int index) -{ - gcc_assert (index < vuses->num_vuses); - return &(vuses->vuses[index].imm_use); -} - -/* Return a def_operand_p that is the V_MUST_DEF_RESULT for the - V_MUST_DEF at INDEX in the V_MUST_DEFS array. */ -static inline def_operand_p -get_v_must_def_result_ptr (v_must_def_optype v_must_defs, unsigned int index) -{ - def_operand_p op; - gcc_assert (index < v_must_defs->num_v_must_defs); - op.def = &(v_must_defs->v_must_defs[index].def); - return op; -} - -/* Return a use_operand_p that is the V_MUST_DEF_KILL for the - V_MUST_DEF at INDEX in the V_MUST_DEFS array. */ -static inline use_operand_p -get_v_must_def_kill_ptr (v_must_def_optype v_must_defs, unsigned int index) -{ - gcc_assert (index < v_must_defs->num_v_must_defs); - return &(v_must_defs->v_must_defs[index].imm_use); + return *def; } /* Return a def_operand_p pointer for the result of PHI. */ static inline def_operand_p get_phi_result_ptr (tree phi) { - def_operand_p op; - op.def = &(PHI_RESULT_TREE (phi)); - return op; + return &(PHI_RESULT_TREE (phi)); } /* Return a use_operand_p pointer for argument I of phinode PHI. */ @@ -590,29 +484,6 @@ get_phi_arg_def_ptr (tree phi, int i) return &(PHI_ARG_IMM_USE_NODE (phi,i)); } -/* Delink all immediate_use information for STMT. */ -static inline void -delink_stmt_imm_use (tree stmt) -{ - unsigned int x; - use_optype uses = STMT_USE_OPS (stmt); - vuse_optype vuses = STMT_VUSE_OPS (stmt); - v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (stmt); - v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (stmt); - - for (x = 0; x < NUM_USES (uses); x++) - delink_imm_use (&(uses->uses[x])); - - for (x = 0; x < NUM_VUSES (vuses); x++) - delink_imm_use (&(vuses->vuses[x].imm_use)); - - for (x = 0; x < NUM_V_MAY_DEFS (v_may_defs); x++) - delink_imm_use (&(v_may_defs->v_may_defs[x].imm_use)); - - for (x = 0; x < NUM_V_MUST_DEFS (v_must_defs); x++) - delink_imm_use (&(v_must_defs->v_must_defs[x].imm_use)); -} - /* Return the bitmap of addresses taken by STMT, or NULL if it takes no addresses. */ @@ -963,23 +834,37 @@ op_iter_done (ssa_op_iter *ptr) static inline use_operand_p op_iter_next_use (ssa_op_iter *ptr) { - if (ptr->use_i < ptr->num_use) + use_operand_p use_p; +#ifdef ENABLE_CHECKING + gcc_assert (ptr->iter_type == ssa_op_iter_use); +#endif + if (ptr->uses) { - return USE_OP_PTR (ptr->ops->use_ops, (ptr->use_i)++); + use_p = USE_OP_PTR (ptr->uses); + ptr->uses = ptr->uses->next; + return use_p; } - if (ptr->vuse_i < ptr->num_vuse) + if (ptr->vuses) { - return VUSE_OP_PTR (ptr->ops->vuse_ops, (ptr->vuse_i)++); + use_p = VUSE_OP_PTR (ptr->vuses); + ptr->vuses = ptr->vuses->next; + return use_p; } - if (ptr->v_mayu_i < ptr->num_v_mayu) + if (ptr->mayuses) { - return V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, - (ptr->v_mayu_i)++); + use_p = MAYDEF_OP_PTR (ptr->mayuses); + ptr->mayuses = ptr->mayuses->next; + return use_p; } - if (ptr->v_mustu_i < ptr->num_v_mustu) + if (ptr->mustkills) { - return V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops, - (ptr->v_mustu_i)++); + use_p = MUSTDEF_KILL_PTR (ptr->mustkills); + ptr->mustkills = ptr->mustkills->next; + return use_p; + } + if (ptr->phi_i < ptr->num_phi) + { + return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++); } ptr->done = true; return NULL_USE_OPERAND_P; @@ -989,19 +874,27 @@ op_iter_next_use (ssa_op_iter *ptr) static inline def_operand_p op_iter_next_def (ssa_op_iter *ptr) { - if (ptr->def_i < ptr->num_def) + def_operand_p def_p; +#ifdef ENABLE_CHECKING + gcc_assert (ptr->iter_type == ssa_op_iter_def); +#endif + if (ptr->defs) { - return DEF_OP_PTR (ptr->ops->def_ops, (ptr->def_i)++); + def_p = DEF_OP_PTR (ptr->defs); + ptr->defs = ptr->defs->next; + return def_p; } - if (ptr->v_mustd_i < ptr->num_v_mustd) + if (ptr->mustdefs) { - return V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, - (ptr->v_mustd_i)++); + def_p = MUSTDEF_RESULT_PTR (ptr->mustdefs); + ptr->mustdefs = ptr->mustdefs->next; + return def_p; } - if (ptr->v_mayd_i < ptr->num_v_mayd) + if (ptr->maydefs) { - return V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, - (ptr->v_mayd_i)++); + def_p = MAYDEF_RESULT_PTR (ptr->maydefs); + ptr->maydefs = ptr->maydefs->next; + return def_p; } ptr->done = true; return NULL_DEF_OPERAND_P; @@ -1011,68 +904,100 @@ op_iter_next_def (ssa_op_iter *ptr) static inline tree op_iter_next_tree (ssa_op_iter *ptr) { - if (ptr->use_i < ptr->num_use) + tree val; +#ifdef ENABLE_CHECKING + gcc_assert (ptr->iter_type == ssa_op_iter_tree); +#endif + if (ptr->uses) { - return USE_OP (ptr->ops->use_ops, (ptr->use_i)++); + val = USE_OP (ptr->uses); + ptr->uses = ptr->uses->next; + return val; } - if (ptr->vuse_i < ptr->num_vuse) + if (ptr->vuses) { - return VUSE_OP (ptr->ops->vuse_ops, (ptr->vuse_i)++); + val = VUSE_OP (ptr->vuses); + ptr->vuses = ptr->vuses->next; + return val; } - if (ptr->v_mayu_i < ptr->num_v_mayu) + if (ptr->mayuses) { - return V_MAY_DEF_OP (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++); + val = MAYDEF_OP (ptr->mayuses); + ptr->mayuses = ptr->mayuses->next; + return val; } - if (ptr->v_mustu_i < ptr->num_v_mustu) + if (ptr->mustkills) { - return V_MUST_DEF_KILL (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++); + val = MUSTDEF_KILL (ptr->mustkills); + ptr->mustkills = ptr->mustkills->next; + return val; } - if (ptr->def_i < ptr->num_def) + if (ptr->defs) { - return DEF_OP (ptr->ops->def_ops, (ptr->def_i)++); + val = DEF_OP (ptr->defs); + ptr->defs = ptr->defs->next; + return val; } - if (ptr->v_mustd_i < ptr->num_v_mustd) + if (ptr->mustdefs) { - return V_MUST_DEF_RESULT (ptr->ops->v_must_def_ops, - (ptr->v_mustd_i)++); + val = MUSTDEF_RESULT (ptr->mustdefs); + ptr->mustdefs = ptr->mustdefs->next; + return val; } - if (ptr->v_mayd_i < ptr->num_v_mayd) + if (ptr->maydefs) { - return V_MAY_DEF_RESULT (ptr->ops->v_may_def_ops, - (ptr->v_mayd_i)++); + val = MAYDEF_RESULT (ptr->maydefs); + ptr->maydefs = ptr->maydefs->next; + return val; } + + ptr->done = true; + return NULL_TREE; + +} + + +/* This functiins clears the iterator PTR, and marks it done. This is normally + used to prevent warnings in the compile about might be uninitailzied + components. */ + +static inline void +clear_and_done_ssa_iter (ssa_op_iter *ptr) +{ + ptr->defs = NULL; + ptr->uses = NULL; + ptr->vuses = NULL; + ptr->maydefs = NULL; + ptr->mayuses = NULL; + ptr->mustdefs = NULL; + ptr->mustkills = NULL; + ptr->iter_type = ssa_op_iter_none; + ptr->phi_i = 0; + ptr->num_phi = 0; + ptr->phi_stmt = NULL_TREE; ptr->done = true; - return NULL; } /* Initialize the iterator PTR to the virtual defs in STMT. */ static inline void op_iter_init (ssa_op_iter *ptr, tree stmt, int flags) { - stmt_operands_p ops; - stmt_ann_t ann = get_stmt_ann (stmt); +#ifdef ENABLE_CHECKING + gcc_assert (stmt_ann (stmt)); +#endif - ops = &(ann->operands); + ptr->defs = (flags & SSA_OP_DEF) ? DEF_OPS (stmt) : NULL; + ptr->uses = (flags & SSA_OP_USE) ? USE_OPS (stmt) : NULL; + ptr->vuses = (flags & SSA_OP_VUSE) ? VUSE_OPS (stmt) : NULL; + ptr->maydefs = (flags & SSA_OP_VMAYDEF) ? MAYDEF_OPS (stmt) : NULL; + ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? MAYDEF_OPS (stmt) : NULL; + ptr->mustdefs = (flags & SSA_OP_VMUSTDEF) ? MUSTDEF_OPS (stmt) : NULL; + ptr->mustkills = (flags & SSA_OP_VMUSTKILL) ? MUSTDEF_OPS (stmt) : NULL; ptr->done = false; - ptr->ops = ops; - ptr->num_def = (flags & SSA_OP_DEF) ? NUM_DEFS (ops->def_ops) : 0; - ptr->num_use = (flags & SSA_OP_USE) ? NUM_USES (ops->use_ops) : 0; - ptr->num_vuse = (flags & SSA_OP_VUSE) ? NUM_VUSES (ops->vuse_ops) : 0; - ptr->num_v_mayu = (flags & SSA_OP_VMAYUSE) - ? NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0; - ptr->num_v_mayd = (flags & SSA_OP_VMAYDEF) - ? NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0; - ptr->num_v_mustu = (flags & SSA_OP_VMUSTDEFKILL) - ? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0; - ptr->num_v_mustd = (flags & SSA_OP_VMUSTDEF) - ? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0; - ptr->def_i = 0; - ptr->use_i = 0; - ptr->vuse_i = 0; - ptr->v_mayu_i = 0; - ptr->v_mayd_i = 0; - ptr->v_mustu_i = 0; - ptr->v_mustd_i = 0; + + ptr->phi_i = 0; + ptr->num_phi = 0; + ptr->phi_stmt = NULL_TREE; } /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return @@ -1081,6 +1006,7 @@ static inline use_operand_p op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags) { op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_use; return op_iter_next_use (ptr); } @@ -1090,6 +1016,7 @@ static inline def_operand_p op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags) { op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_def; return op_iter_next_def (ptr); } @@ -1099,85 +1026,53 @@ static inline tree op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags) { op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_tree; return op_iter_next_tree (ptr); } /* Get the next iterator mustdef value for PTR, returning the mustdef values in KILL and DEF. */ static inline void -op_iter_next_mustdef (use_operand_p *kill, def_operand_p *def, ssa_op_iter *ptr) +op_iter_next_maymustdef (use_operand_p *use, def_operand_p *def, + ssa_op_iter *ptr) { - if (ptr->v_mustu_i < ptr->num_v_mustu) +#ifdef ENABLE_CHECKING + gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef); +#endif + if (ptr->mayuses) { - *def = V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, ptr->v_mustu_i); - *kill = V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++); + *def = MAYDEF_RESULT_PTR (ptr->mayuses); + *use = MAYDEF_OP_PTR (ptr->mayuses); + ptr->mayuses = ptr->mayuses->next; return; } - else - { - *def = NULL_DEF_OPERAND_P; - *kill = NULL_USE_OPERAND_P; - } - ptr->done = true; - return; -} -/* Get the next iterator maydef value for PTR, returning the maydef values in - USE and DEF. */ -static inline void -op_iter_next_maydef (use_operand_p *use, def_operand_p *def, ssa_op_iter *ptr) -{ - if (ptr->v_mayu_i < ptr->num_v_mayu) + if (ptr->mustkills) { - *def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i); - *use = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++); + *def = MUSTDEF_RESULT_PTR (ptr->mustkills); + *use = MUSTDEF_KILL_PTR (ptr->mustkills); + ptr->mustkills = ptr->mustkills->next; return; } - else - { - *def = NULL_DEF_OPERAND_P; - *use = NULL_USE_OPERAND_P; - } - ptr->done = true; - return; -} -/* Get the next iterator mustdef or maydef value for PTR, returning the - mustdef or maydef values in KILL and DEF. */ -static inline void -op_iter_next_must_and_may_def (use_operand_p *kill, - def_operand_p *def, - ssa_op_iter *ptr) -{ - if (ptr->v_mustu_i < ptr->num_v_mustu) - { - *def = V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, ptr->v_mustu_i); - *kill = V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++); - return; - } - else if (ptr->v_mayu_i < ptr->num_v_mayu) - { - *def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i); - *kill = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++); - return; - } - else - { - *def = NULL_DEF_OPERAND_P; - *kill = NULL_USE_OPERAND_P; - } + *def = NULL_DEF_OPERAND_P; + *use = NULL_USE_OPERAND_P; ptr->done = true; return; } + /* Initialize iterator PTR to the operands in STMT. Return the first operands in USE and DEF. */ static inline void op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use, def_operand_p *def) { + gcc_assert (TREE_CODE (stmt) != PHI_NODE); + op_iter_init (ptr, stmt, SSA_OP_VMAYUSE); - op_iter_next_maydef (use, def, ptr); + ptr->iter_type = ssa_op_iter_maymustdef; + op_iter_next_maymustdef (use, def, ptr); } @@ -1187,8 +1082,11 @@ static inline void op_iter_init_mustdef (ssa_op_iter *ptr, tree stmt, use_operand_p *kill, def_operand_p *def) { - op_iter_init (ptr, stmt, SSA_OP_VMUSTDEFKILL); - op_iter_next_mustdef (kill, def, ptr); + gcc_assert (TREE_CODE (stmt) != PHI_NODE); + + op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL); + ptr->iter_type = ssa_op_iter_maymustdef; + op_iter_next_maymustdef (kill, def, ptr); } /* Initialize iterator PTR to the operands in STMT. Return the first operands @@ -1197,10 +1095,241 @@ static inline void op_iter_init_must_and_may_def (ssa_op_iter *ptr, tree stmt, use_operand_p *kill, def_operand_p *def) { - op_iter_init (ptr, stmt, SSA_OP_VMUSTDEFKILL | SSA_OP_VMAYUSE); - op_iter_next_must_and_may_def (kill, def, ptr); + gcc_assert (TREE_CODE (stmt) != PHI_NODE); + + op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL|SSA_OP_VMAYUSE); + ptr->iter_type = ssa_op_iter_maymustdef; + op_iter_next_maymustdef (kill, def, ptr); +} + + +/* If there is a single opernad in STMT matching FLAGS, return it. Otherwise + return NULL. PTR is the iterator to use. */ +static inline tree +single_ssa_tree_operand (tree stmt, int flags) +{ + tree var; + ssa_op_iter iter; + + var = op_iter_init_tree (&iter, stmt, flags); + if (op_iter_done (&iter)) + return NULL_TREE; + op_iter_next_tree (&iter); + if (op_iter_done (&iter)) + return var; + return NULL_TREE; +} + + +/* If there is a single opernad in STMT matching FLAGS, return it. Otherwise + return NULL. PTR is the iterator to use. */ +static inline use_operand_p +single_ssa_use_operand (tree stmt, int flags) +{ + use_operand_p var; + ssa_op_iter iter; + + var = op_iter_init_use (&iter, stmt, flags); + if (op_iter_done (&iter)) + return NULL_USE_OPERAND_P; + op_iter_next_use (&iter); + if (op_iter_done (&iter)) + return var; + return NULL_USE_OPERAND_P; +} + + + +/* If there is a single opernad in STMT matching FLAGS, return it. Otherwise + return NULL. PTR is the iterator to use. */ +static inline def_operand_p +single_ssa_def_operand (tree stmt, int flags) +{ + def_operand_p var; + ssa_op_iter iter; + + var = op_iter_init_def (&iter, stmt, flags); + if (op_iter_done (&iter)) + return NULL_DEF_OPERAND_P; + op_iter_next_def (&iter); + if (op_iter_done (&iter)) + return var; + return NULL_DEF_OPERAND_P; +} + + +/* If there is a single opernad in STMT matching FLAGS, return it. Otherwise + return NULL. PTR is the iterator to use. */ +static inline bool +zero_ssa_operands (tree stmt, int flags) +{ + ssa_op_iter iter; + + op_iter_init_tree (&iter, stmt, flags); + return op_iter_done (&iter); } + +/* Return the number of opernads mathcing FLAGS in STMT. */ +static inline int +num_ssa_operands (tree stmt, int flags) +{ + ssa_op_iter iter; + int num = 0; + + op_iter_init (&iter, stmt, flags); + for ( ; iter.defs; iter.defs = iter.defs->next) + num++; + for ( ; iter.uses; iter.uses = iter.uses->next) + num++; + for ( ; iter.vuses; iter.vuses = iter.vuses->next) + num++; + for ( ; iter.maydefs; iter.maydefs = iter.maydefs->next) + num++; + for ( ; iter.mayuses; iter.mayuses = iter.mayuses->next) + num++; + for ( ; iter.mustdefs; iter.mustdefs = iter.mustdefs->next) + num++; + for ( ; iter.mustkills; iter.mustkills = iter.mustkills->next) + num++; + + return num; +} + + +/* Delink all immediate_use information for STMT. */ +static inline void +delink_stmt_imm_use (tree stmt) +{ + ssa_op_iter iter; + use_operand_p use_p; + + if (ssa_operands_active ()) + FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, + (SSA_OP_ALL_USES | SSA_OP_ALL_KILLS)) + delink_imm_use (use_p); +} + + +/* This routine will compare all the operands matching FLAGS in STMT1 to those + in STMT2. TRUE is returned if they are the same. STMTs can be NULL. */ +static inline bool +compare_ssa_operands_equal (tree stmt1, tree stmt2, int flags) +{ + ssa_op_iter iter1, iter2; + tree op1 = NULL_TREE; + tree op2 = NULL_TREE; + bool look1, look2; + + if (stmt1 == stmt2) + return true; + + look1 = stmt1 && stmt_ann (stmt1); + look2 = stmt2 && stmt_ann (stmt2); + + if (look1) + { + op1 = op_iter_init_tree (&iter1, stmt1, flags); + if (!look2) + return op_iter_done (&iter1); + } + else + clear_and_done_ssa_iter (&iter1); + + if (look2) + { + op2 = op_iter_init_tree (&iter2, stmt2, flags); + if (!look1) + return op_iter_done (&iter2); + } + else + clear_and_done_ssa_iter (&iter2); + + while (!op_iter_done (&iter1) && !op_iter_done (&iter2)) + { + if (op1 != op2) + return false; + op1 = op_iter_next_tree (&iter1); + op2 = op_iter_next_tree (&iter2); + } + + return (op_iter_done (&iter1) && op_iter_done (&iter2)); +} + + +/* If there is a single DEF in the PHI node which matches FLAG, return it. + Otherwise return NULL_DEF_OPERAND_P. */ +static inline tree +single_phi_def (tree stmt, int flags) +{ + tree def = PHI_RESULT (stmt); + if ((flags & SSA_OP_DEF) && is_gimple_reg (def)) + return def; + if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def)) + return def; + return NULL_TREE; +} + +/* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should + be either SSA_OP_USES or SAS_OP_VIRTUAL_USES. */ +static inline use_operand_p +op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags) +{ + tree phi_def = PHI_RESULT (phi); + int comp; + + clear_and_done_ssa_iter (ptr); + ptr->done = false; + + gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0); + + comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES); + + /* if the PHI node deosn't the operand type we care about, we're done. */ + if ((flags & comp) == 0) + { + ptr->done = true; + return NULL_USE_OPERAND_P; + } + + ptr->phi_stmt = phi; + ptr->num_phi = PHI_NUM_ARGS (phi); + ptr->iter_type = ssa_op_iter_use; + return op_iter_next_use (ptr); +} + + +/* Start an iterator for a PHI defintion. */ + +static inline def_operand_p +op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags) +{ + tree phi_def = PHI_RESULT (phi); + int comp; + + clear_and_done_ssa_iter (ptr); + ptr->done = false; + + gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0); + + comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS); + + /* if the PHI node deosn't the operand type we care about, we're done. */ + if ((flags & comp) == 0) + { + ptr->done = true; + return NULL_USE_OPERAND_P; + } + + ptr->iter_type = ssa_op_iter_def; + /* The first call to op_iter_next_def will terminate the iterator since + all the fields are NULL. Simply return the result here as the first and + therefore only result. */ + return PHI_RESULT_PTR (phi); +} + + + /* Return true if VAR cannot be modified by the program. */ static inline bool |