From patchwork Tue Sep 24 14:39:58 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew MacLeod X-Patchwork-Id: 277517 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 646872C00C2 for ; Wed, 25 Sep 2013 00:40:30 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:subject:content-type; q= dns; s=default; b=OUp9ODVWq9ZrmXu91+WuOAlaPYuYM2r7Aolu/3xHbphHmo kl8rJ8aIDTyAw3RR0+uMQAR25uUbm8d7S6HglC/t5nkgxjvQA7BcEm8g5mbq2lwg ExMe3T3sUATCLF1KigKeIlEAARNsKOHPYgsUq3NKxZIzKr7EwQ3bMbF4opWzc= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:subject:content-type; s= default; bh=AV3NbIRpmcP1koBOv4cDF/a4XnM=; b=nUMa/3y34+4x+RwrAAOD 8KdDhSD91Ey44LOtvI3ASJkysWbIDYQJ+AVk5c7mFcBE5Oj8RLGHFcyy4YczfY59 f3K0IBNCaMciM6Q+hEFRx588q360ML2N8e99iZiGFYzc5gzjKKeDWvtusaayDBEY yWoATjcGOU5CqQFevIndOA8= Received: (qmail 18959 invoked by alias); 24 Sep 2013 14:40:15 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 18889 invoked by uid 89); 24 Sep 2013 14:40:15 -0000 Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 24 Sep 2013 14:40:15 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.9 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id r8OEe3Pf017779 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Tue, 24 Sep 2013 10:40:05 -0400 Received: from [10.10.52.34] (vpn-52-34.rdu2.redhat.com [10.10.52.34]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id r8OEdwoY005124; Tue, 24 Sep 2013 10:39:58 -0400 Message-ID: <5241A43E.7040207@redhat.com> Date: Tue, 24 Sep 2013 10:39:58 -0400 From: Andrew MacLeod User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130805 Thunderbird/17.0.8 MIME-Version: 1.0 To: gcc-patches , Richard Biener Subject: [patch] Separate immediate uses and phi routines from tree-flow*.h X-IsSubscribed: yes This larger patch moves all the immediate use and operand routines from tree-flow.h into tree-ssa-operands.h. It also moves the basic phi routines and prototypes into a newly created tree-phinodes.h, or tree-ssa-operands.h if they belong there. And finally shuffles a couple of other routines which allows tree-ssa-operands.h to be removed from the gimple.h header file. of note or interest: 1 - dump_decl_set() was defined in tree-into-ssa.c, but isn't really ssa specific. Its tree-specific, so normally I'd throw it into tree.c. Looking forward a little, its only used in a gimple context, so when we map to gimple_types it will need to be converted to/created for those. If it is in tree.c, I'll have to create a new version for gimple types, and then the routine in tree.c will become unused. Based on that, I figured gimple.c is the place place for it. 2 - has_zero_uses_1() and single_imm_use_1() were both in tree-cfg.c for some reason.. they've been moved to tree-ssa-operands.c 3 - a few routines seem like basic gimple routines, but really turn out to require the operand infrastructure to implement... so they are moved to tree-ssa-operands.[ch] as well. This sort of thing showed up when removing tree-ssa-operands.h from the gimple.h include file. These were things like gimple_vuse_op, gimple_vdef_op, update_stmt, and update_stmt_if_modified 4 - gimple_phi_arg_def() was oddly defined: static inline tree gimple_phi_arg_def (gimple gs, size_t index) { struct phi_arg_d *pd = gimple_phi_arg (gs, index); return get_use_from_ptr (&pd->imm_use); } /* Return a pointer to the tree operand for argument I of PHI node GS. */ static inline tree * gimple_phi_arg_def_ptr (gimple gs, size_t index) { return &gimple_phi_arg (gs, index)->def; } Im not sure why it goes through the immediate use routines... it should be the same as '* gimple_phi_arg_def_ptr(x,y)' ... And by using immediate use routine, it couldn't be put in tree-phinodes like it belong. I changed it to be simply return gimple_phi_arg (gs, index)->def; and bootstrapped that change, along with an assert that it was the same value as the immediate_use method. everything worked as expected. old wart I guess. I didn't bother with a Makefile.in change since its only dependencies change, and Tromey's pending auto-dependency patch would just delete those anyway. This bootstraps on x86_64-unknown-linux-gnu and has no new regressions. OK? Andrew * tree-into-ssa.c (enum need_phi_state): Relocate from tree-flow.h. (dump_decl_set): Move to gimple.c. * gimple.c (dump_decl_set): Here. * tree-cfg.c (has_zero_uses_1, single_imm_use_1): Move to... * tree-ssa-operands.c (has_zero_uses_1, single_imm_use_1): Here. * gimple.h: Don't include tree-ssa-operands.h. (dump_decl_set): Add prototype. (gimple_vuse_op, gimple_vdef_op, update_stmt, update_stmt_if_modified): Move to tree-ssa-operands.h. * tree-flow.h: Move various prototypes to tree-phinodes.h. (enum need_phi_state): Move to tree-into-ssa.c. (struct immediate_use_iterator_d, FOR_EACH_IMM_*, BREAK_FROM_IMM_USE_STMT): Move to tree-ssa-operands.h. (swap_tree_operands): Move prototype to tree-ssa-operands.h. * tree-flow-inline.h (delink_imm_use, link_imm_use_to_list, link_imm_use, set_ssa_use_from_ptr, link_imm_use_stmt, relink_imm_use, relink_imm_use_stmt, end_readonly_imm_use_p, first_readonly_imm_use, next_readonly_imm_use, has_zero_uses, has_single_use, single_imm_use, num_imm_uses, get_use_from_ptr, get_def_from_ptr, gimple_phi_arg_imm_use_ptr, phi_arg_index_from_use, op_iter_done, op_iter_next_def, op_iter_next_tree, clear_and_done_ssa_iter, op_iter_init, op_iter_init_use, op_iter_init_def, op_iter_init_tree, single_ssa_tree_operand, single_ssa_use_operand, single_ssa_def_operand, zero_ssa_operands, num_ssa_operands, delink_stmt_imm_use, single_phi_def, op_iter_init_phiuse, op_iter_init_phidef, end_imm_use_stmt_p, end_imm_use_stmt_traverse, move_use_after_head, link_use_stmts_after, first_imm_use_stmt, next_imm_use_stmt, first_imm_use_on_stmt, end_imm_use_on_stmt_p, next_imm_use_on_stmt): Move to tree-ssa-operands.h. (gimple_phi_arg_def, gimple_phi_arg_def_ptr, gimple_phi_arg_edge, gimple_phi_arg_location, gimple_phi_arg_location_from_edge, gimple_phi_arg_set_location, gimple_phi_arg_has_location, phi_nodes, phi_nodes_ptr, set_phi_nodes, phi_ssa_name_p): Move to tree-phinodes.h. * tree-ssa-operands.h (gimple_vuse_op, gimple_vdef_op, update_stmt, update_stmt_if_modified): Relocate from gimple.h. (dump_decl_set): Remove prototype. (struct immediate_use_iterator_d, FOR_EACH_IMM_*, BREAK_FROM_IMM_USE_STMT): Relocate from tree-flow.h. (delink_imm_use, link_imm_use_to_list, link_imm_use, set_ssa_use_from_ptr, link_imm_use_stmt, relink_imm_use, relink_imm_use_stmt, end_readonly_imm_use_p, first_readonly_imm_use, next_readonly_imm_use, has_zero_uses, has_single_use, single_imm_use, num_imm_uses, get_use_from_ptr, get_def_from_ptr, gimple_phi_arg_imm_use_ptr, phi_arg_index_from_use, op_iter_done, op_iter_next_def, op_iter_next_tree, clear_and_done_ssa_iter, op_iter_init, op_iter_init_use, op_iter_init_def, op_iter_init_tree, single_ssa_tree_operand, single_ssa_use_operand, single_ssa_def_operand, zero_ssa_operands, num_ssa_operands, delink_stmt_imm_use, single_phi_def, op_iter_init_phiuse, op_iter_init_phidef, end_imm_use_stmt_p, end_imm_use_stmt_traverse, move_use_after_head, link_use_stmts_after, first_imm_use_stmt, next_imm_use_stmt, first_imm_use_on_stmt, end_imm_use_on_stmt_p, next_imm_use_on_stmt): Relocate from tree-flow-inline.h. * tree-phinodes.h: New file. (enum need_phi_state): Move from tree-flow.h along with some prototypes. (phi_ssa_name_p, phi_nodes, phi_node_ptr, set_phi_nodes, gimple_phi_arg_def, gimple_phi_arg_def_ptr, gimple_phi_arg_edge, gimple_phi_arg_location, gimple_phi_arg_location_from_edge, gimple_phi_arg_set_location, gimple_phi_arg_has_location): Relocate from tree-flow-inline.h * tree-ssa.h: Add tree-phinodes.h to include list. Index: tree-into-ssa.c =================================================================== *** tree-into-ssa.c (revision 202838) --- tree-into-ssa.c (working copy) *************** struct mark_def_sites_global_data *** 128,133 **** --- 128,157 ---- bitmap kills; }; + /* It is advantageous to avoid things like life analysis for variables which + do not need PHI nodes. This enum describes whether or not a particular + variable may need a PHI node. */ + + enum need_phi_state { + /* This is the default. If we are still in this state after finding + all the definition and use sites, then we will assume the variable + needs PHI nodes. This is probably an overly conservative assumption. */ + NEED_PHI_STATE_UNKNOWN, + + /* This state indicates that we have seen one or more sets of the + variable in a single basic block and that the sets dominate all + uses seen so far. If after finding all definition and use sites + we are still in this state, then the variable does not need any + PHI nodes. */ + NEED_PHI_STATE_NO, + + /* This state indicates that we have either seen multiple definitions of + the variable in multiple blocks, or that we encountered a use in a + block that was not dominated by the block containing the set(s) of + this variable. This variable is assumed to need PHI nodes. */ + NEED_PHI_STATE_MAYBE + }; + /* Information stored for both SSA names and decls. */ struct common_info_d { *************** rewrite_dom_walker::after_dom_children ( *** 1494,1524 **** /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */ - void - dump_decl_set (FILE *file, bitmap set) - { - if (set) - { - bitmap_iterator bi; - unsigned i; - - fprintf (file, "{ "); - - EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi) - { - fprintf (file, "D.%u", i); - fprintf (file, " "); - } - - fprintf (file, "}"); - } - else - fprintf (file, "NIL"); - } - - - /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */ - DEBUG_FUNCTION void debug_decl_set (bitmap set) { --- 1518,1523 ---- Index: gimple.c =================================================================== *** gimple.c (revision 202838) --- gimple.c (working copy) *************** types_compatible_p (tree type1, tree typ *** 4579,4583 **** --- 4579,4606 ---- && useless_type_conversion_p (type2, type1))); } + /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */ + + void + dump_decl_set (FILE *file, bitmap set) + { + if (set) + { + bitmap_iterator bi; + unsigned i; + + fprintf (file, "{ "); + + EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi) + { + fprintf (file, "D.%u", i); + fprintf (file, " "); + } + + fprintf (file, "}"); + } + else + fprintf (file, "NIL"); + } #include "gt-gimple.h" Index: tree-cfg.c =================================================================== *** tree-cfg.c (revision 202838) --- tree-cfg.c (working copy) *************** gimple_can_merge_blocks_p (basic_block a *** 1513,1561 **** return true; } - /* Return true if the var whose chain of uses starts at PTR has no - nondebug uses. */ - bool - has_zero_uses_1 (const ssa_use_operand_t *head) - { - const ssa_use_operand_t *ptr; - - for (ptr = head->next; ptr != head; ptr = ptr->next) - if (!is_gimple_debug (USE_STMT (ptr))) - return false; - - return true; - } - - /* Return true if the var whose chain of uses starts at PTR has a - single nondebug use. Set USE_P and STMT to that single nondebug - use, if so, or to NULL otherwise. */ - bool - single_imm_use_1 (const ssa_use_operand_t *head, - use_operand_p *use_p, gimple *stmt) - { - ssa_use_operand_t *ptr, *single_use = 0; - - for (ptr = head->next; ptr != head; ptr = ptr->next) - if (!is_gimple_debug (USE_STMT (ptr))) - { - if (single_use) - { - single_use = NULL; - break; - } - single_use = ptr; - } - - if (use_p) - *use_p = single_use; - - if (stmt) - *stmt = single_use ? single_use->loc.stmt : NULL; - - return !!single_use; - } - /* Replaces all uses of NAME by VAL. */ void --- 1513,1518 ---- Index: tree-ssa-operands.c =================================================================== *** tree-ssa-operands.c (revision 202838) --- tree-ssa-operands.c (working copy) *************** unlink_stmt_vdef (gimple stmt) *** 1322,1324 **** --- 1322,1368 ---- SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse) = 1; } + + /* Return true if the var whose chain of uses starts at PTR has no + nondebug uses. */ + bool + has_zero_uses_1 (const ssa_use_operand_t *head) + { + const ssa_use_operand_t *ptr; + + for (ptr = head->next; ptr != head; ptr = ptr->next) + if (!is_gimple_debug (USE_STMT (ptr))) + return false; + + return true; + } + + + /* Return true if the var whose chain of uses starts at PTR has a + single nondebug use. Set USE_P and STMT to that single nondebug + use, if so, or to NULL otherwise. */ + bool + single_imm_use_1 (const ssa_use_operand_t *head, + use_operand_p *use_p, gimple *stmt) + { + ssa_use_operand_t *ptr, *single_use = 0; + + for (ptr = head->next; ptr != head; ptr = ptr->next) + if (!is_gimple_debug (USE_STMT (ptr))) + { + if (single_use) + { + single_use = NULL; + break; + } + single_use = ptr; + } + + if (use_p) + *use_p = single_use; + + if (stmt) + *stmt = single_use ? single_use->loc.stmt : NULL; + + return single_use; + } Index: gimple.h =================================================================== *** gimple.h (revision 202838) --- gimple.h (working copy) *************** along with GCC; see the file COPYING3. *** 28,34 **** #include "ggc.h" #include "basic-block.h" #include "tree.h" - #include "tree-ssa-operands.h" #include "tree-ssa-alias.h" #include "internal-fn.h" --- 28,33 ---- *************** extern void omp_firstprivatize_variable *** 1079,1084 **** --- 1078,1084 ---- extern tree gimple_boolify (tree); extern gimple_predicate rhs_predicate_for (tree); extern tree canonicalize_cond_expr_cond (tree); + extern void dump_decl_set (FILE *, bitmap); /* In omp-low.c. */ extern tree omp_reduction_init (tree, tree); *************** gimple_set_use_ops (gimple g, struct use *** 1486,1519 **** } - /* Return the set of VUSE operand for statement G. */ - - static inline use_operand_p - gimple_vuse_op (const_gimple g) - { - struct use_optype_d *ops; - if (!gimple_has_mem_ops (g)) - return NULL_USE_OPERAND_P; - ops = g->gsops.opbase.use_ops; - if (ops - && USE_OP_PTR (ops)->use == &g->gsmembase.vuse) - return USE_OP_PTR (ops); - return NULL_USE_OPERAND_P; - } - - /* Return the set of VDEF operand for statement G. */ - - static inline def_operand_p - gimple_vdef_op (gimple g) - { - if (!gimple_has_mem_ops (g)) - return NULL_DEF_OPERAND_P; - if (g->gsmembase.vdef) - return &g->gsmembase.vdef; - return NULL_DEF_OPERAND_P; - } - - /* Return the single VUSE operand of the statement G. */ static inline tree --- 1486,1491 ---- *************** gimple_expr_code (const_gimple stmt) *** 1614,1640 **** } - /* Mark statement S as modified, and update it. */ - - static inline void - update_stmt (gimple s) - { - if (gimple_has_ops (s)) - { - gimple_set_modified (s, true); - update_stmt_operands (s); - } - } - - /* Update statement S if it has been optimized. */ - - static inline void - update_stmt_if_modified (gimple s) - { - if (gimple_modified_p (s)) - update_stmt_operands (s); - } - /* Return true if statement STMT contains volatile operands. */ static inline bool --- 1586,1591 ---- Index: tree-flow.h =================================================================== *** tree-flow.h (revision 202838) --- tree-flow.h (working copy) *************** typedef struct *** 107,238 **** !end_htab_p (&(ITER)); \ RESULT = (TYPE) next_htab_element (&(ITER))) - /* It is advantageous to avoid things like life analysis for variables which - do not need PHI nodes. This enum describes whether or not a particular - variable may need a PHI node. */ - - enum need_phi_state { - /* This is the default. If we are still in this state after finding - all the definition and use sites, then we will assume the variable - needs PHI nodes. This is probably an overly conservative assumption. */ - NEED_PHI_STATE_UNKNOWN, - - /* This state indicates that we have seen one or more sets of the - variable in a single basic block and that the sets dominate all - uses seen so far. If after finding all definition and use sites - we are still in this state, then the variable does not need any - PHI nodes. */ - NEED_PHI_STATE_NO, - - /* This state indicates that we have either seen multiple definitions of - the variable in multiple blocks, or that we encountered a use in a - block that was not dominated by the block containing the set(s) of - this variable. This variable is assumed to need PHI nodes. */ - NEED_PHI_STATE_MAYBE - }; - - - /* Immediate use lists are used to directly access all uses for an SSA - name and get pointers to the statement for each use. - - The structure ssa_use_operand_d consists of PREV and NEXT pointers - to maintain the list. A USE pointer, which points to address where - the use is located and a LOC pointer which can point to the - statement where the use is located, or, in the case of the root - node, it points to the SSA name itself. - - The list is anchored by an occurrence of ssa_operand_d *in* the - ssa_name node itself (named 'imm_uses'). This node is uniquely - identified by having a NULL USE pointer. and the LOC pointer - pointing back to the ssa_name node itself. This node forms the - base for a circular list, and initially this is the only node in - the list. - - Fast iteration allows each use to be examined, but does not allow - any modifications to the uses or stmts. - - Normal iteration allows insertion, deletion, and modification. the - iterator manages this by inserting a marker node into the list - immediately before the node currently being examined in the list. - this marker node is uniquely identified by having null stmt *and* a - null use pointer. - - When iterating to the next use, the iteration routines check to see - if the node after the marker has changed. if it has, then the node - following the marker is now the next one to be visited. if not, the - marker node is moved past that node in the list (visualize it as - bumping the marker node through the list). this continues until - the marker node is moved to the original anchor position. the - marker node is then removed from the list. - - If iteration is halted early, the marker node must be removed from - the list before continuing. */ - typedef struct immediate_use_iterator_d - { - /* This is the current use the iterator is processing. */ - ssa_use_operand_t *imm_use; - /* This marks the last use in the list (use node from SSA_NAME) */ - ssa_use_operand_t *end_p; - /* This node is inserted and used to mark the end of the uses for a stmt. */ - ssa_use_operand_t iter_node; - /* This is the next ssa_name to visit. IMM_USE may get removed before - the next one is traversed to, so it must be cached early. */ - ssa_use_operand_t *next_imm_name; - } imm_use_iterator; - - - /* Use this iterator when simply looking at stmts. Adding, deleting or - modifying stmts will cause this iterator to malfunction. */ - - #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ - for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ - !end_readonly_imm_use_p (&(ITER)); \ - (void) ((DEST) = next_readonly_imm_use (&(ITER)))) - - /* Use this iterator to visit each stmt which has a use of SSAVAR. */ - - #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ - for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ - !end_imm_use_stmt_p (&(ITER)); \ - (void) ((STMT) = next_imm_use_stmt (&(ITER)))) - - /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to - do so will result in leaving a iterator marker node in the immediate - use list, and nothing good will come from that. */ - #define BREAK_FROM_IMM_USE_STMT(ITER) \ - { \ - end_imm_use_stmt_traverse (&(ITER)); \ - break; \ - } - - - /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to - get access to each occurrence of ssavar on the stmt returned by - that iterator.. for instance: - - FOR_EACH_IMM_USE_STMT (stmt, iter, var) - { - FOR_EACH_IMM_USE_ON_STMT (use_p, iter) - { - SET_USE (use_p, blah); - } - update_stmt (stmt); - } */ - - #define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ - for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ - !end_imm_use_on_stmt_p (&(ITER)); \ - (void) ((DEST) = next_imm_use_on_stmt (&(ITER)))) - - - - static inline void update_stmt (gimple); static inline int get_lineno (const_gimple); - /* Accessors for basic block annotations. */ - static inline gimple_seq phi_nodes (const_basic_block); - static inline void set_phi_nodes (basic_block, gimple_seq); - /*--------------------------------------------------------------------------- Global declarations ---------------------------------------------------------------------------*/ --- 107,114 ---- *************** extern bool stmt_references_abnormal_ssa *** 403,419 **** extern tree get_addr_base_and_unit_offset (tree, HOST_WIDE_INT *); extern void dump_enumerated_decls (FILE *, int); - /* In tree-phinodes.c */ - extern void reserve_phi_args_for_new_edge (basic_block); - extern void add_phi_node_to_bb (gimple phi, basic_block bb); - extern gimple create_phi_node (tree, basic_block); - extern void add_phi_arg (gimple, tree, edge, source_location); - extern void remove_phi_args (edge); - extern void remove_phi_node (gimple_stmt_iterator *, bool); - extern void remove_phi_nodes (basic_block); - extern void release_phi_node (gimple); - extern void phinodes_print_statistics (void); - /* In gimple-low.c */ extern void record_vars_into (tree, tree); extern void record_vars (tree); --- 279,284 ---- *************** bool parallelized_function_p (tree); *** 691,696 **** #include "tree-flow-inline.h" - void swap_tree_operands (gimple, tree *, tree *); - #endif /* _TREE_FLOW_H */ --- 556,559 ---- Index: tree-flow-inline.h =================================================================== *** tree-flow-inline.h (revision 202838) --- tree-flow-inline.h (working copy) *************** get_lineno (const_gimple stmt) *** 126,505 **** return LOCATION_LINE (loc); } - /* Delink an immediate_uses node from its chain. */ - static inline void - delink_imm_use (ssa_use_operand_t *linknode) - { - /* Return if this node is not in a list. */ - if (linknode->prev == NULL) - return; - - linknode->prev->next = linknode->next; - linknode->next->prev = linknode->prev; - linknode->prev = NULL; - linknode->next = NULL; - } - - /* Link ssa_imm_use node LINKNODE into the chain for LIST. */ - static inline void - 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. */ - linknode->prev = list; - linknode->next = list->next; - list->next->prev = linknode; - list->next = linknode; - } - - /* Link ssa_imm_use node LINKNODE into the chain for DEF. */ - static inline void - link_imm_use (ssa_use_operand_t *linknode, tree def) - { - ssa_use_operand_t *root; - - if (!def || TREE_CODE (def) != SSA_NAME) - linknode->prev = NULL; - else - { - root = &(SSA_NAME_IMM_USE_NODE (def)); - if (linknode->use) - gcc_checking_assert (*(linknode->use) == def); - link_imm_use_to_list (linknode, root); - } - } - - /* Set the value of a use pointed to by USE to VAL. */ - static inline void - set_ssa_use_from_ptr (use_operand_p use, tree val) - { - delink_imm_use (use); - *(use->use) = val; - link_imm_use (use, val); - } - - /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring - in STMT. */ - static inline void - link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt) - { - if (stmt) - link_imm_use (linknode, def); - else - link_imm_use (linknode, NULL); - linknode->loc.stmt = stmt; - } - - /* Relink a new node in place of an old node in the list. */ - static inline void - relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old) - { - /* The node one had better be in the same list. */ - gcc_checking_assert (*(old->use) == *(node->use)); - node->prev = old->prev; - node->next = old->next; - if (old->prev) - { - old->prev->next = node; - old->next->prev = node; - /* Remove the old node from the list. */ - old->prev = NULL; - } - } - - /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring - in STMT. */ - static inline void - relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, - gimple stmt) - { - if (stmt) - relink_imm_use (linknode, old); - else - link_imm_use (linknode, NULL); - linknode->loc.stmt = stmt; - } - - - /* Return true is IMM has reached the end of the immediate use list. */ - static inline bool - end_readonly_imm_use_p (const imm_use_iterator *imm) - { - return (imm->imm_use == imm->end_p); - } - - /* Initialize iterator IMM to process the list for VAR. */ - static inline use_operand_p - first_readonly_imm_use (imm_use_iterator *imm, tree var) - { - imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); - imm->imm_use = imm->end_p->next; - #ifdef ENABLE_CHECKING - imm->iter_node.next = imm->imm_use->next; - #endif - if (end_readonly_imm_use_p (imm)) - return NULL_USE_OPERAND_P; - return imm->imm_use; - } - - /* Bump IMM to the next use in the list. */ - static inline use_operand_p - next_readonly_imm_use (imm_use_iterator *imm) - { - use_operand_p old = imm->imm_use; - - #ifdef ENABLE_CHECKING - /* If this assertion fails, it indicates the 'next' pointer has changed - since the last bump. This indicates that the list is being modified - via stmt changes, or SET_USE, or somesuch thing, and you need to be - using the SAFE version of the iterator. */ - gcc_assert (imm->iter_node.next == old->next); - imm->iter_node.next = old->next->next; - #endif - - imm->imm_use = old->next; - if (end_readonly_imm_use_p (imm)) - return NULL_USE_OPERAND_P; - return imm->imm_use; - } - - /* tree-cfg.c */ - extern bool has_zero_uses_1 (const ssa_use_operand_t *head); - extern bool single_imm_use_1 (const ssa_use_operand_t *head, - use_operand_p *use_p, gimple *stmt); - - /* Return true if VAR has no nondebug uses. */ - static inline bool - has_zero_uses (const_tree var) - { - const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); - - /* A single use_operand means there is no items in the list. */ - if (ptr == ptr->next) - return true; - - /* If there are debug stmts, we have to look at each use and see - whether there are any nondebug uses. */ - if (!MAY_HAVE_DEBUG_STMTS) - return false; - - return has_zero_uses_1 (ptr); - } - - /* Return true if VAR has a single nondebug use. */ - static inline bool - has_single_use (const_tree var) - { - const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); - - /* If there aren't any uses whatsoever, we're done. */ - if (ptr == ptr->next) - return false; - - /* If there's a single use, check that it's not a debug stmt. */ - if (ptr == ptr->next->next) - return !is_gimple_debug (USE_STMT (ptr->next)); - - /* If there are debug stmts, we have to look at each of them. */ - if (!MAY_HAVE_DEBUG_STMTS) - return false; - - return single_imm_use_1 (ptr, NULL, NULL); - } - - - /* If VAR has only a single immediate nondebug use, return true, and - set USE_P and STMT to the use pointer and stmt of occurrence. */ - static inline bool - single_imm_use (const_tree var, use_operand_p *use_p, gimple *stmt) - { - const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); - - /* If there aren't any uses whatsoever, we're done. */ - if (ptr == ptr->next) - { - return_false: - *use_p = NULL_USE_OPERAND_P; - *stmt = NULL; - return false; - } - - /* If there's a single use, check that it's not a debug stmt. */ - if (ptr == ptr->next->next) - { - if (!is_gimple_debug (USE_STMT (ptr->next))) - { - *use_p = ptr->next; - *stmt = ptr->next->loc.stmt; - return true; - } - else - goto return_false; - } - - /* If there are debug stmts, we have to look at each of them. */ - if (!MAY_HAVE_DEBUG_STMTS) - goto return_false; - - return single_imm_use_1 (ptr, use_p, stmt); - } - - /* Return the number of nondebug immediate uses of VAR. */ - static inline unsigned int - num_imm_uses (const_tree var) - { - const ssa_use_operand_t *const start = &(SSA_NAME_IMM_USE_NODE (var)); - const ssa_use_operand_t *ptr; - unsigned int num = 0; - - if (!MAY_HAVE_DEBUG_STMTS) - for (ptr = start->next; ptr != start; ptr = ptr->next) - num++; - else - for (ptr = start->next; ptr != start; ptr = ptr->next) - if (!is_gimple_debug (USE_STMT (ptr))) - num++; - - return num; - } - - /* Return the tree pointed-to by USE. */ - static inline tree - get_use_from_ptr (use_operand_p use) - { - return *(use->use); - } - - /* Return the tree pointed-to by DEF. */ - static inline tree - get_def_from_ptr (def_operand_p def) - { - return *def; - } - - /* Return a use_operand_p pointer for argument I of PHI node GS. */ - - static inline use_operand_p - gimple_phi_arg_imm_use_ptr (gimple gs, int i) - { - return &gimple_phi_arg (gs, i)->imm_use; - } - - /* Return the tree operand for argument I of PHI node GS. */ - - static inline tree - gimple_phi_arg_def (gimple gs, size_t index) - { - struct phi_arg_d *pd = gimple_phi_arg (gs, index); - return get_use_from_ptr (&pd->imm_use); - } - - /* Return a pointer to the tree operand for argument I of PHI node GS. */ - - static inline tree * - gimple_phi_arg_def_ptr (gimple gs, size_t index) - { - return &gimple_phi_arg (gs, index)->def; - } - - /* Return the edge associated with argument I of phi node GS. */ - - static inline edge - gimple_phi_arg_edge (gimple gs, size_t i) - { - return EDGE_PRED (gimple_bb (gs), i); - } - - /* Return the source location of gimple argument I of phi node GS. */ - - static inline source_location - gimple_phi_arg_location (gimple gs, size_t i) - { - return gimple_phi_arg (gs, i)->locus; - } - - /* Return the source location of the argument on edge E of phi node GS. */ - - static inline source_location - gimple_phi_arg_location_from_edge (gimple gs, edge e) - { - return gimple_phi_arg (gs, e->dest_idx)->locus; - } - - /* Set the source location of gimple argument I of phi node GS to LOC. */ - - static inline void - gimple_phi_arg_set_location (gimple gs, size_t i, source_location loc) - { - gimple_phi_arg (gs, i)->locus = loc; - } - - /* Return TRUE if argument I of phi node GS has a location record. */ - - static inline bool - gimple_phi_arg_has_location (gimple gs, size_t i) - { - return gimple_phi_arg_location (gs, i) != UNKNOWN_LOCATION; - } - - - /* Return the PHI nodes for basic block BB, or NULL if there are no - PHI nodes. */ - static inline gimple_seq - phi_nodes (const_basic_block bb) - { - gcc_checking_assert (!(bb->flags & BB_RTL)); - return bb->il.gimple.phi_nodes; - } - - static inline gimple_seq * - phi_nodes_ptr (basic_block bb) - { - gcc_checking_assert (!(bb->flags & BB_RTL)); - return &bb->il.gimple.phi_nodes; - } - - /* Set PHI nodes of a basic block BB to SEQ. */ - - static inline void - set_phi_nodes (basic_block bb, gimple_seq seq) - { - gimple_stmt_iterator i; - - gcc_checking_assert (!(bb->flags & BB_RTL)); - bb->il.gimple.phi_nodes = seq; - if (seq) - for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) - gimple_set_bb (gsi_stmt (i), bb); - } - - /* Return the phi argument which contains the specified use. */ - - static inline int - phi_arg_index_from_use (use_operand_p use) - { - struct phi_arg_d *element, *root; - size_t index; - gimple phi; - - /* Since the use is the first thing in a PHI argument element, we can - calculate its index based on casting it to an argument, and performing - pointer arithmetic. */ - - phi = USE_STMT (use); - - element = (struct phi_arg_d *)use; - root = gimple_phi_arg (phi, 0); - index = element - root; - - /* Make sure the calculation doesn't have any leftover bytes. If it does, - then imm_use is likely not the first element in phi_arg_d. */ - gcc_checking_assert ((((char *)element - (char *)root) - % sizeof (struct phi_arg_d)) == 0 - && index < gimple_phi_capacity (phi)); - - return index; - } /* Return true if T (assumed to be a DECL) is a global variable. A variable is considered global if its storage is not automatic. */ --- 126,131 ---- *************** may_be_aliased (const_tree var) *** 528,547 **** } - /* PHI nodes should contain only ssa_names and invariants. A test - for ssa_name is definitely simpler; don't let invalid contents - slip in in the meantime. */ - - static inline bool - phi_ssa_name_p (const_tree t) - { - if (TREE_CODE (t) == SSA_NAME) - return true; - gcc_checking_assert (is_gimple_min_invariant (t)); - return false; - } - - /* Returns the loop of the statement STMT. */ static inline struct loop * --- 154,159 ---- *************** loop_containing_stmt (gimple stmt) *** 555,1090 **** } - /* ----------------------------------------------------------------------- */ - - /* The following set of routines are used to iterator over various type of - SSA operands. */ - - /* Return true if PTR is finished iterating. */ - static inline bool - op_iter_done (const ssa_op_iter *ptr) - { - return ptr->done; - } - - /* Get the next iterator use value for PTR. */ - static inline use_operand_p - op_iter_next_use (ssa_op_iter *ptr) - { - use_operand_p use_p; - gcc_checking_assert (ptr->iter_type == ssa_op_iter_use); - if (ptr->uses) - { - use_p = USE_OP_PTR (ptr->uses); - ptr->uses = ptr->uses->next; - return use_p; - } - if (ptr->i < ptr->numops) - { - return PHI_ARG_DEF_PTR (ptr->stmt, (ptr->i)++); - } - ptr->done = true; - return NULL_USE_OPERAND_P; - } - - /* Get the next iterator def value for PTR. */ - static inline def_operand_p - op_iter_next_def (ssa_op_iter *ptr) - { - gcc_checking_assert (ptr->iter_type == ssa_op_iter_def); - if (ptr->flags & SSA_OP_VDEF) - { - tree *p; - ptr->flags &= ~SSA_OP_VDEF; - p = gimple_vdef_ptr (ptr->stmt); - if (p && *p) - return p; - } - if (ptr->flags & SSA_OP_DEF) - { - while (ptr->i < ptr->numops) - { - tree *val = gimple_op_ptr (ptr->stmt, ptr->i); - ptr->i++; - if (*val) - { - if (TREE_CODE (*val) == TREE_LIST) - val = &TREE_VALUE (*val); - if (TREE_CODE (*val) == SSA_NAME - || is_gimple_reg (*val)) - return val; - } - } - ptr->flags &= ~SSA_OP_DEF; - } - - ptr->done = true; - return NULL_DEF_OPERAND_P; - } - - /* Get the next iterator tree value for PTR. */ - static inline tree - op_iter_next_tree (ssa_op_iter *ptr) - { - tree val; - gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree); - if (ptr->uses) - { - val = USE_OP (ptr->uses); - ptr->uses = ptr->uses->next; - return val; - } - if (ptr->flags & SSA_OP_VDEF) - { - ptr->flags &= ~SSA_OP_VDEF; - if ((val = gimple_vdef (ptr->stmt))) - return val; - } - if (ptr->flags & SSA_OP_DEF) - { - while (ptr->i < ptr->numops) - { - val = gimple_op (ptr->stmt, ptr->i); - ptr->i++; - if (val) - { - if (TREE_CODE (val) == TREE_LIST) - val = TREE_VALUE (val); - if (TREE_CODE (val) == SSA_NAME - || is_gimple_reg (val)) - return val; - } - } - ptr->flags &= ~SSA_OP_DEF; - } - - ptr->done = true; - return NULL_TREE; - } - - - /* This functions clears the iterator PTR, and marks it done. This is normally - used to prevent warnings in the compile about might be uninitialized - components. */ - - static inline void - clear_and_done_ssa_iter (ssa_op_iter *ptr) - { - ptr->i = 0; - ptr->numops = 0; - ptr->uses = NULL; - ptr->iter_type = ssa_op_iter_none; - ptr->stmt = NULL; - ptr->done = true; - ptr->flags = 0; - } - - /* Initialize the iterator PTR to the virtual defs in STMT. */ - static inline void - op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags) - { - /* PHI nodes require a different iterator initialization path. We - do not support iterating over virtual defs or uses without - iterating over defs or uses at the same time. */ - gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI - && (!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF)) - && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE))); - ptr->numops = 0; - if (flags & (SSA_OP_DEF | SSA_OP_VDEF)) - { - switch (gimple_code (stmt)) - { - case GIMPLE_ASSIGN: - case GIMPLE_CALL: - ptr->numops = 1; - break; - case GIMPLE_ASM: - ptr->numops = gimple_asm_noutputs (stmt); - break; - default: - ptr->numops = 0; - flags &= ~(SSA_OP_DEF | SSA_OP_VDEF); - break; - } - } - ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL; - if (!(flags & SSA_OP_VUSE) - && ptr->uses - && gimple_vuse (stmt) != NULL_TREE) - ptr->uses = ptr->uses->next; - ptr->done = false; - ptr->i = 0; - - ptr->stmt = stmt; - ptr->flags = flags; - } - - /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return - the first use. */ - static inline use_operand_p - op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags) - { - gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0 - && (flags & SSA_OP_USE)); - op_iter_init (ptr, stmt, flags); - ptr->iter_type = ssa_op_iter_use; - return op_iter_next_use (ptr); - } - - /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return - the first def. */ - static inline def_operand_p - op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags) - { - gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0 - && (flags & SSA_OP_DEF)); - op_iter_init (ptr, stmt, flags); - ptr->iter_type = ssa_op_iter_def; - return op_iter_next_def (ptr); - } - - /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return - the first operand as a tree. */ - static inline tree - op_iter_init_tree (ssa_op_iter *ptr, gimple stmt, int flags) - { - op_iter_init (ptr, stmt, flags); - ptr->iter_type = ssa_op_iter_tree; - return op_iter_next_tree (ptr); - } - - - /* If there is a single operand in STMT matching FLAGS, return it. Otherwise - return NULL. */ - static inline tree - single_ssa_tree_operand (gimple 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 operand in STMT matching FLAGS, return it. Otherwise - return NULL. */ - static inline use_operand_p - single_ssa_use_operand (gimple 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 operand in STMT matching FLAGS, return it. Otherwise - return NULL. */ - static inline def_operand_p - single_ssa_def_operand (gimple 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; - } - - - /* Return true if there are zero operands in STMT matching the type - given in FLAGS. */ - static inline bool - zero_ssa_operands (gimple stmt, int flags) - { - ssa_op_iter iter; - - op_iter_init_tree (&iter, stmt, flags); - return op_iter_done (&iter); - } - - - /* Return the number of operands matching FLAGS in STMT. */ - static inline int - num_ssa_operands (gimple stmt, int flags) - { - ssa_op_iter iter; - tree t; - int num = 0; - - gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI); - FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags) - num++; - return num; - } - - static inline use_operand_p - op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags); - - /* Delink all immediate_use information for STMT. */ - static inline void - delink_stmt_imm_use (gimple stmt) - { - ssa_op_iter iter; - use_operand_p use_p; - - if (ssa_operands_active (cfun)) - FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_ALL_USES) - delink_imm_use (use_p); - } - - - /* 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 (gimple 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 SSA_OP_VIRTUAL_USES. */ - static inline use_operand_p - op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags) - { - tree phi_def = gimple_phi_result (phi); - int comp; - - clear_and_done_ssa_iter (ptr); - ptr->done = false; - - gcc_checking_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 doesn't the operand type we care about, we're done. */ - if ((flags & comp) == 0) - { - ptr->done = true; - return NULL_USE_OPERAND_P; - } - - ptr->stmt = phi; - ptr->numops = gimple_phi_num_args (phi); - ptr->iter_type = ssa_op_iter_use; - ptr->flags = flags; - return op_iter_next_use (ptr); - } - - - /* Start an iterator for a PHI definition. */ - - static inline def_operand_p - op_iter_init_phidef (ssa_op_iter *ptr, gimple phi, int flags) - { - tree phi_def = PHI_RESULT (phi); - int comp; - - clear_and_done_ssa_iter (ptr); - ptr->done = false; - - gcc_checking_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 doesn't have the operand type we care about, - we're done. */ - if ((flags & comp) == 0) - { - ptr->done = true; - return NULL_DEF_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 is IMM has reached the end of the immediate use stmt list. */ - - static inline bool - end_imm_use_stmt_p (const imm_use_iterator *imm) - { - return (imm->imm_use == imm->end_p); - } - - /* Finished the traverse of an immediate use stmt list IMM by removing the - placeholder node from the list. */ - - static inline void - end_imm_use_stmt_traverse (imm_use_iterator *imm) - { - delink_imm_use (&(imm->iter_node)); - } - - /* Immediate use traversal of uses within a stmt require that all the - uses on a stmt be sequentially listed. This routine is used to build up - this sequential list by adding USE_P to the end of the current list - currently delimited by HEAD and LAST_P. The new LAST_P value is - returned. */ - - static inline use_operand_p - move_use_after_head (use_operand_p use_p, use_operand_p head, - use_operand_p last_p) - { - gcc_checking_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head)); - /* Skip head when we find it. */ - if (use_p != head) - { - /* If use_p is already linked in after last_p, continue. */ - if (last_p->next == use_p) - last_p = use_p; - else - { - /* Delink from current location, and link in at last_p. */ - delink_imm_use (use_p); - link_imm_use_to_list (use_p, last_p); - last_p = use_p; - } - } - return last_p; - } - - - /* This routine will relink all uses with the same stmt as HEAD into the list - immediately following HEAD for iterator IMM. */ - - static inline void - link_use_stmts_after (use_operand_p head, imm_use_iterator *imm) - { - use_operand_p use_p; - use_operand_p last_p = head; - gimple head_stmt = USE_STMT (head); - tree use = USE_FROM_PTR (head); - ssa_op_iter op_iter; - int flag; - - /* Only look at virtual or real uses, depending on the type of HEAD. */ - flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES); - - if (gimple_code (head_stmt) == GIMPLE_PHI) - { - FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag) - if (USE_FROM_PTR (use_p) == use) - last_p = move_use_after_head (use_p, head, last_p); - } - else - { - if (flag == SSA_OP_USE) - { - FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag) - if (USE_FROM_PTR (use_p) == use) - last_p = move_use_after_head (use_p, head, last_p); - } - else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P) - { - if (USE_FROM_PTR (use_p) == use) - last_p = move_use_after_head (use_p, head, last_p); - } - } - /* Link iter node in after last_p. */ - if (imm->iter_node.prev != NULL) - delink_imm_use (&imm->iter_node); - link_imm_use_to_list (&(imm->iter_node), last_p); - } - - /* Initialize IMM to traverse over uses of VAR. Return the first statement. */ - static inline gimple - first_imm_use_stmt (imm_use_iterator *imm, tree var) - { - imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); - imm->imm_use = imm->end_p->next; - imm->next_imm_name = NULL_USE_OPERAND_P; - - /* iter_node is used as a marker within the immediate use list to indicate - where the end of the current stmt's uses are. Initialize it to NULL - stmt and use, which indicates a marker node. */ - imm->iter_node.prev = NULL_USE_OPERAND_P; - imm->iter_node.next = NULL_USE_OPERAND_P; - imm->iter_node.loc.stmt = NULL; - imm->iter_node.use = NULL; - - if (end_imm_use_stmt_p (imm)) - return NULL; - - link_use_stmts_after (imm->imm_use, imm); - - return USE_STMT (imm->imm_use); - } - - /* Bump IMM to the next stmt which has a use of var. */ - - static inline gimple - next_imm_use_stmt (imm_use_iterator *imm) - { - imm->imm_use = imm->iter_node.next; - if (end_imm_use_stmt_p (imm)) - { - if (imm->iter_node.prev != NULL) - delink_imm_use (&imm->iter_node); - return NULL; - } - - link_use_stmts_after (imm->imm_use, imm); - return USE_STMT (imm->imm_use); - } - - /* This routine will return the first use on the stmt IMM currently refers - to. */ - - static inline use_operand_p - first_imm_use_on_stmt (imm_use_iterator *imm) - { - imm->next_imm_name = imm->imm_use->next; - return imm->imm_use; - } - - /* Return TRUE if the last use on the stmt IMM refers to has been visited. */ - - static inline bool - end_imm_use_on_stmt_p (const imm_use_iterator *imm) - { - return (imm->imm_use == &(imm->iter_node)); - } - - /* Bump to the next use on the stmt IMM refers to, return NULL if done. */ - - static inline use_operand_p - next_imm_use_on_stmt (imm_use_iterator *imm) - { - imm->imm_use = imm->next_imm_name; - if (end_imm_use_on_stmt_p (imm)) - return NULL_USE_OPERAND_P; - else - { - imm->next_imm_name = imm->imm_use->next; - return imm->imm_use; - } - } /* Return true if VAR cannot be modified by the program. */ --- 167,172 ---- Index: tree-ssa-operands.h =================================================================== *** tree-ssa-operands.h (revision 202838) --- tree-ssa-operands.h (working copy) *************** struct GTY(()) ssa_operands { *** 87,111 **** #define PHI_ARG_INDEX_FROM_USE(USE) phi_arg_index_from_use (USE) extern void init_ssa_operands (struct function *fn); extern void fini_ssa_operands (void); ! extern void update_stmt_operands (gimple); extern void free_stmt_operands (gimple); extern bool verify_imm_links (FILE *f, tree var); - extern bool verify_ssa_operands (gimple stmt); - extern void dump_immediate_uses (FILE *file); extern void dump_immediate_uses_for (FILE *file, tree var); extern void debug_immediate_uses (void); extern void debug_immediate_uses_for (tree var); - extern void dump_decl_set (FILE *, bitmap); - extern void debug_decl_set (bitmap); - - extern bool ssa_operands_active (struct function *); extern bool virtual_operand_p (tree); extern void unlink_stmt_vdef (gimple); enum ssa_op_iter_type { ssa_op_iter_none = 0, ssa_op_iter_tree, --- 87,270 ---- #define PHI_ARG_INDEX_FROM_USE(USE) phi_arg_index_from_use (USE) + extern bool ssa_operands_active (struct function *); extern void init_ssa_operands (struct function *fn); extern void fini_ssa_operands (void); ! extern bool verify_ssa_operands (gimple stmt); extern void free_stmt_operands (gimple); + extern void update_stmt_operands (gimple); + extern void swap_tree_operands (gimple, tree *, tree *); extern bool verify_imm_links (FILE *f, tree var); extern void dump_immediate_uses_for (FILE *file, tree var); + extern void dump_immediate_uses (FILE *file); extern void debug_immediate_uses (void); extern void debug_immediate_uses_for (tree var); extern bool virtual_operand_p (tree); extern void unlink_stmt_vdef (gimple); + + /* Return a use_operand_p pointer for argument I of PHI node GS. */ + + static inline use_operand_p + gimple_phi_arg_imm_use_ptr (gimple gs, int i) + { + return &gimple_phi_arg (gs, i)->imm_use; + } + + + /* Return the set of VUSE operand for statement G. */ + + static inline use_operand_p + gimple_vuse_op (const_gimple g) + { + struct use_optype_d *ops; + if (!gimple_has_mem_ops (g)) + return NULL_USE_OPERAND_P; + ops = g->gsops.opbase.use_ops; + if (ops + && USE_OP_PTR (ops)->use == &g->gsmembase.vuse) + return USE_OP_PTR (ops); + return NULL_USE_OPERAND_P; + } + + /* Return the set of VDEF operand for statement G. */ + + static inline def_operand_p + gimple_vdef_op (gimple g) + { + if (!gimple_has_mem_ops (g)) + return NULL_DEF_OPERAND_P; + if (g->gsmembase.vdef) + return &g->gsmembase.vdef; + return NULL_DEF_OPERAND_P; + } + + /* Mark statement S as modified, and update it. */ + + static inline void + update_stmt (gimple s) + { + if (gimple_has_ops (s)) + { + gimple_set_modified (s, true); + update_stmt_operands (s); + } + } + + /* Update statement S if it has been optimized. */ + + static inline void + update_stmt_if_modified (gimple s) + { + if (gimple_modified_p (s)) + update_stmt_operands (s); + } + + + + + + /* Immediate use lists are used to directly access all uses for an SSA + name and get pointers to the statement for each use. + + The structure ssa_use_operand_d consists of PREV and NEXT pointers + to maintain the list. A USE pointer, which points to address where + the use is located and a LOC pointer which can point to the + statement where the use is located, or, in the case of the root + node, it points to the SSA name itself. + + The list is anchored by an occurrence of ssa_operand_d *in* the + ssa_name node itself (named 'imm_uses'). This node is uniquely + identified by having a NULL USE pointer. and the LOC pointer + pointing back to the ssa_name node itself. This node forms the + base for a circular list, and initially this is the only node in + the list. + + Fast iteration allows each use to be examined, but does not allow + any modifications to the uses or stmts. + + Normal iteration allows insertion, deletion, and modification. the + iterator manages this by inserting a marker node into the list + immediately before the node currently being examined in the list. + this marker node is uniquely identified by having null stmt *and* a + null use pointer. + + When iterating to the next use, the iteration routines check to see + if the node after the marker has changed. if it has, then the node + following the marker is now the next one to be visited. if not, the + marker node is moved past that node in the list (visualize it as + bumping the marker node through the list). this continues until + the marker node is moved to the original anchor position. the + marker node is then removed from the list. + + If iteration is halted early, the marker node must be removed from + the list before continuing. */ + typedef struct immediate_use_iterator_d + { + /* This is the current use the iterator is processing. */ + ssa_use_operand_t *imm_use; + /* This marks the last use in the list (use node from SSA_NAME) */ + ssa_use_operand_t *end_p; + /* This node is inserted and used to mark the end of the uses for a stmt. */ + ssa_use_operand_t iter_node; + /* This is the next ssa_name to visit. IMM_USE may get removed before + the next one is traversed to, so it must be cached early. */ + ssa_use_operand_t *next_imm_name; + } imm_use_iterator; + + + /* Use this iterator when simply looking at stmts. Adding, deleting or + modifying stmts will cause this iterator to malfunction. */ + + #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ + for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ + !end_readonly_imm_use_p (&(ITER)); \ + (void) ((DEST) = next_readonly_imm_use (&(ITER)))) + + /* Use this iterator to visit each stmt which has a use of SSAVAR. */ + + #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ + for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ + !end_imm_use_stmt_p (&(ITER)); \ + (void) ((STMT) = next_imm_use_stmt (&(ITER)))) + + /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to + do so will result in leaving a iterator marker node in the immediate + use list, and nothing good will come from that. */ + #define BREAK_FROM_IMM_USE_STMT(ITER) \ + { \ + end_imm_use_stmt_traverse (&(ITER)); \ + break; \ + } + + + /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to + get access to each occurrence of ssavar on the stmt returned by + that iterator.. for instance: + + FOR_EACH_IMM_USE_STMT (stmt, iter, var) + { + FOR_EACH_IMM_USE_ON_STMT (use_p, iter) + { + SET_USE (use_p, blah); + } + update_stmt (stmt); + } */ + + #define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ + for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ + !end_imm_use_on_stmt_p (&(ITER)); \ + (void) ((DEST) = next_imm_use_on_stmt (&(ITER)))) + + + + extern bool has_zero_uses_1 (const ssa_use_operand_t *head); + extern bool single_imm_use_1 (const ssa_use_operand_t *head, + use_operand_p *use_p, gimple *stmt); + + enum ssa_op_iter_type { ssa_op_iter_none = 0, ssa_op_iter_tree, *************** typedef struct ssa_operand_iterator_d *** 219,222 **** --- 378,1183 ---- /* This macro counts the number of operands in STMT matching FLAGS. */ #define NUM_SSA_OPERANDS(STMT, FLAGS) num_ssa_operands (STMT, FLAGS) + + /* Delink an immediate_uses node from its chain. */ + static inline void + delink_imm_use (ssa_use_operand_t *linknode) + { + /* Return if this node is not in a list. */ + if (linknode->prev == NULL) + return; + + linknode->prev->next = linknode->next; + linknode->next->prev = linknode->prev; + linknode->prev = NULL; + linknode->next = NULL; + } + + /* Link ssa_imm_use node LINKNODE into the chain for LIST. */ + static inline void + 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. */ + linknode->prev = list; + linknode->next = list->next; + list->next->prev = linknode; + list->next = linknode; + } + + /* Link ssa_imm_use node LINKNODE into the chain for DEF. */ + static inline void + link_imm_use (ssa_use_operand_t *linknode, tree def) + { + ssa_use_operand_t *root; + + if (!def || TREE_CODE (def) != SSA_NAME) + linknode->prev = NULL; + else + { + root = &(SSA_NAME_IMM_USE_NODE (def)); + if (linknode->use) + gcc_checking_assert (*(linknode->use) == def); + link_imm_use_to_list (linknode, root); + } + } + + /* Set the value of a use pointed to by USE to VAL. */ + static inline void + set_ssa_use_from_ptr (use_operand_p use, tree val) + { + delink_imm_use (use); + *(use->use) = val; + link_imm_use (use, val); + } + + /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring + in STMT. */ + static inline void + link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt) + { + if (stmt) + link_imm_use (linknode, def); + else + link_imm_use (linknode, NULL); + linknode->loc.stmt = stmt; + } + + /* Relink a new node in place of an old node in the list. */ + static inline void + relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old) + { + /* The node one had better be in the same list. */ + gcc_checking_assert (*(old->use) == *(node->use)); + node->prev = old->prev; + node->next = old->next; + if (old->prev) + { + old->prev->next = node; + old->next->prev = node; + /* Remove the old node from the list. */ + old->prev = NULL; + } + } + + /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring + in STMT. */ + static inline void + relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, + gimple stmt) + { + if (stmt) + relink_imm_use (linknode, old); + else + link_imm_use (linknode, NULL); + linknode->loc.stmt = stmt; + } + + + /* Return true is IMM has reached the end of the immediate use list. */ + static inline bool + end_readonly_imm_use_p (const imm_use_iterator *imm) + { + return (imm->imm_use == imm->end_p); + } + + /* Initialize iterator IMM to process the list for VAR. */ + static inline use_operand_p + first_readonly_imm_use (imm_use_iterator *imm, tree var) + { + imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); + imm->imm_use = imm->end_p->next; + #ifdef ENABLE_CHECKING + imm->iter_node.next = imm->imm_use->next; + #endif + if (end_readonly_imm_use_p (imm)) + return NULL_USE_OPERAND_P; + return imm->imm_use; + } + + /* Bump IMM to the next use in the list. */ + static inline use_operand_p + next_readonly_imm_use (imm_use_iterator *imm) + { + use_operand_p old = imm->imm_use; + + #ifdef ENABLE_CHECKING + /* If this assertion fails, it indicates the 'next' pointer has changed + since the last bump. This indicates that the list is being modified + via stmt changes, or SET_USE, or somesuch thing, and you need to be + using the SAFE version of the iterator. */ + gcc_assert (imm->iter_node.next == old->next); + imm->iter_node.next = old->next->next; + #endif + + imm->imm_use = old->next; + if (end_readonly_imm_use_p (imm)) + return NULL_USE_OPERAND_P; + return imm->imm_use; + } + + + /* Return true if VAR has no nondebug uses. */ + static inline bool + has_zero_uses (const_tree var) + { + const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); + + /* A single use_operand means there is no items in the list. */ + if (ptr == ptr->next) + return true; + + /* If there are debug stmts, we have to look at each use and see + whether there are any nondebug uses. */ + if (!MAY_HAVE_DEBUG_STMTS) + return false; + + return has_zero_uses_1 (ptr); + } + + /* Return true if VAR has a single nondebug use. */ + static inline bool + has_single_use (const_tree var) + { + const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); + + /* If there aren't any uses whatsoever, we're done. */ + if (ptr == ptr->next) + return false; + + /* If there's a single use, check that it's not a debug stmt. */ + if (ptr == ptr->next->next) + return !is_gimple_debug (USE_STMT (ptr->next)); + + /* If there are debug stmts, we have to look at each of them. */ + if (!MAY_HAVE_DEBUG_STMTS) + return false; + + return single_imm_use_1 (ptr, NULL, NULL); + } + + + /* If VAR has only a single immediate nondebug use, return true, and + set USE_P and STMT to the use pointer and stmt of occurrence. */ + static inline bool + single_imm_use (const_tree var, use_operand_p *use_p, gimple *stmt) + { + const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); + + /* If there aren't any uses whatsoever, we're done. */ + if (ptr == ptr->next) + { + return_false: + *use_p = NULL_USE_OPERAND_P; + *stmt = NULL; + return false; + } + + /* If there's a single use, check that it's not a debug stmt. */ + if (ptr == ptr->next->next) + { + if (!is_gimple_debug (USE_STMT (ptr->next))) + { + *use_p = ptr->next; + *stmt = ptr->next->loc.stmt; + return true; + } + else + goto return_false; + } + + /* If there are debug stmts, we have to look at each of them. */ + if (!MAY_HAVE_DEBUG_STMTS) + goto return_false; + + return single_imm_use_1 (ptr, use_p, stmt); + } + + /* Return the number of nondebug immediate uses of VAR. */ + static inline unsigned int + num_imm_uses (const_tree var) + { + const ssa_use_operand_t *const start = &(SSA_NAME_IMM_USE_NODE (var)); + const ssa_use_operand_t *ptr; + unsigned int num = 0; + + if (!MAY_HAVE_DEBUG_STMTS) + for (ptr = start->next; ptr != start; ptr = ptr->next) + num++; + else + for (ptr = start->next; ptr != start; ptr = ptr->next) + if (!is_gimple_debug (USE_STMT (ptr))) + num++; + + return num; + } + + /* Return the tree pointed-to by USE. */ + static inline tree + get_use_from_ptr (use_operand_p use) + { + return *(use->use); + } + + /* Return the tree pointed-to by DEF. */ + static inline tree + get_def_from_ptr (def_operand_p def) + { + return *def; + } + + /* ----------------------------------------------------------------------- */ + + /* The following set of routines are used to iterator over various type of + SSA operands. */ + + /* Return true if PTR is finished iterating. */ + static inline bool + op_iter_done (const ssa_op_iter *ptr) + { + return ptr->done; + } + + /* Get the next iterator use value for PTR. */ + static inline use_operand_p + op_iter_next_use (ssa_op_iter *ptr) + { + use_operand_p use_p; + gcc_checking_assert (ptr->iter_type == ssa_op_iter_use); + if (ptr->uses) + { + use_p = USE_OP_PTR (ptr->uses); + ptr->uses = ptr->uses->next; + return use_p; + } + if (ptr->i < ptr->numops) + { + return PHI_ARG_DEF_PTR (ptr->stmt, (ptr->i)++); + } + ptr->done = true; + return NULL_USE_OPERAND_P; + } + + /* Get the next iterator def value for PTR. */ + static inline def_operand_p + op_iter_next_def (ssa_op_iter *ptr) + { + gcc_checking_assert (ptr->iter_type == ssa_op_iter_def); + if (ptr->flags & SSA_OP_VDEF) + { + tree *p; + ptr->flags &= ~SSA_OP_VDEF; + p = gimple_vdef_ptr (ptr->stmt); + if (p && *p) + return p; + } + if (ptr->flags & SSA_OP_DEF) + { + while (ptr->i < ptr->numops) + { + tree *val = gimple_op_ptr (ptr->stmt, ptr->i); + ptr->i++; + if (*val) + { + if (TREE_CODE (*val) == TREE_LIST) + val = &TREE_VALUE (*val); + if (TREE_CODE (*val) == SSA_NAME + || is_gimple_reg (*val)) + return val; + } + } + ptr->flags &= ~SSA_OP_DEF; + } + + ptr->done = true; + return NULL_DEF_OPERAND_P; + } + + /* Get the next iterator tree value for PTR. */ + static inline tree + op_iter_next_tree (ssa_op_iter *ptr) + { + tree val; + gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree); + if (ptr->uses) + { + val = USE_OP (ptr->uses); + ptr->uses = ptr->uses->next; + return val; + } + if (ptr->flags & SSA_OP_VDEF) + { + ptr->flags &= ~SSA_OP_VDEF; + if ((val = gimple_vdef (ptr->stmt))) + return val; + } + if (ptr->flags & SSA_OP_DEF) + { + while (ptr->i < ptr->numops) + { + val = gimple_op (ptr->stmt, ptr->i); + ptr->i++; + if (val) + { + if (TREE_CODE (val) == TREE_LIST) + val = TREE_VALUE (val); + if (TREE_CODE (val) == SSA_NAME + || is_gimple_reg (val)) + return val; + } + } + ptr->flags &= ~SSA_OP_DEF; + } + + ptr->done = true; + return NULL_TREE; + } + + + /* This functions clears the iterator PTR, and marks it done. This is normally + used to prevent warnings in the compile about might be uninitialized + components. */ + + static inline void + clear_and_done_ssa_iter (ssa_op_iter *ptr) + { + ptr->i = 0; + ptr->numops = 0; + ptr->uses = NULL; + ptr->iter_type = ssa_op_iter_none; + ptr->stmt = NULL; + ptr->done = true; + ptr->flags = 0; + } + + /* Initialize the iterator PTR to the virtual defs in STMT. */ + static inline void + op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags) + { + /* PHI nodes require a different iterator initialization path. We + do not support iterating over virtual defs or uses without + iterating over defs or uses at the same time. */ + gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI + && (!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF)) + && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE))); + ptr->numops = 0; + if (flags & (SSA_OP_DEF | SSA_OP_VDEF)) + { + switch (gimple_code (stmt)) + { + case GIMPLE_ASSIGN: + case GIMPLE_CALL: + ptr->numops = 1; + break; + case GIMPLE_ASM: + ptr->numops = gimple_asm_noutputs (stmt); + break; + default: + ptr->numops = 0; + flags &= ~(SSA_OP_DEF | SSA_OP_VDEF); + break; + } + } + ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL; + if (!(flags & SSA_OP_VUSE) + && ptr->uses + && gimple_vuse (stmt) != NULL_TREE) + ptr->uses = ptr->uses->next; + ptr->done = false; + ptr->i = 0; + + ptr->stmt = stmt; + ptr->flags = flags; + } + + /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return + the first use. */ + static inline use_operand_p + op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags) + { + gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0 + && (flags & SSA_OP_USE)); + op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_use; + return op_iter_next_use (ptr); + } + + /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return + the first def. */ + static inline def_operand_p + op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags) + { + gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0 + && (flags & SSA_OP_DEF)); + op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_def; + return op_iter_next_def (ptr); + } + + /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return + the first operand as a tree. */ + static inline tree + op_iter_init_tree (ssa_op_iter *ptr, gimple stmt, int flags) + { + op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_tree; + return op_iter_next_tree (ptr); + } + + + /* If there is a single operand in STMT matching FLAGS, return it. Otherwise + return NULL. */ + static inline tree + single_ssa_tree_operand (gimple 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 operand in STMT matching FLAGS, return it. Otherwise + return NULL. */ + static inline use_operand_p + single_ssa_use_operand (gimple 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 operand in STMT matching FLAGS, return it. Otherwise + return NULL. */ + static inline def_operand_p + single_ssa_def_operand (gimple 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; + } + + + /* Return true if there are zero operands in STMT matching the type + given in FLAGS. */ + static inline bool + zero_ssa_operands (gimple stmt, int flags) + { + ssa_op_iter iter; + + op_iter_init_tree (&iter, stmt, flags); + return op_iter_done (&iter); + } + + + /* Return the number of operands matching FLAGS in STMT. */ + static inline int + num_ssa_operands (gimple stmt, int flags) + { + ssa_op_iter iter; + tree t; + int num = 0; + + gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI); + FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags) + num++; + return num; + } + + /* 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 (gimple 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 SSA_OP_VIRTUAL_USES. */ + static inline use_operand_p + op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags) + { + tree phi_def = gimple_phi_result (phi); + int comp; + + clear_and_done_ssa_iter (ptr); + ptr->done = false; + + gcc_checking_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 doesn't the operand type we care about, we're done. */ + if ((flags & comp) == 0) + { + ptr->done = true; + return NULL_USE_OPERAND_P; + } + + ptr->stmt = phi; + ptr->numops = gimple_phi_num_args (phi); + ptr->iter_type = ssa_op_iter_use; + ptr->flags = flags; + return op_iter_next_use (ptr); + } + + + /* Start an iterator for a PHI definition. */ + + static inline def_operand_p + op_iter_init_phidef (ssa_op_iter *ptr, gimple phi, int flags) + { + tree phi_def = PHI_RESULT (phi); + int comp; + + clear_and_done_ssa_iter (ptr); + ptr->done = false; + + gcc_checking_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 doesn't have the operand type we care about, + we're done. */ + if ((flags & comp) == 0) + { + ptr->done = true; + return NULL_DEF_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 is IMM has reached the end of the immediate use stmt list. */ + + static inline bool + end_imm_use_stmt_p (const imm_use_iterator *imm) + { + return (imm->imm_use == imm->end_p); + } + + /* Finished the traverse of an immediate use stmt list IMM by removing the + placeholder node from the list. */ + + static inline void + end_imm_use_stmt_traverse (imm_use_iterator *imm) + { + delink_imm_use (&(imm->iter_node)); + } + + /* Immediate use traversal of uses within a stmt require that all the + uses on a stmt be sequentially listed. This routine is used to build up + this sequential list by adding USE_P to the end of the current list + currently delimited by HEAD and LAST_P. The new LAST_P value is + returned. */ + + static inline use_operand_p + move_use_after_head (use_operand_p use_p, use_operand_p head, + use_operand_p last_p) + { + gcc_checking_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head)); + /* Skip head when we find it. */ + if (use_p != head) + { + /* If use_p is already linked in after last_p, continue. */ + if (last_p->next == use_p) + last_p = use_p; + else + { + /* Delink from current location, and link in at last_p. */ + delink_imm_use (use_p); + link_imm_use_to_list (use_p, last_p); + last_p = use_p; + } + } + return last_p; + } + + + /* This routine will relink all uses with the same stmt as HEAD into the list + immediately following HEAD for iterator IMM. */ + + static inline void + link_use_stmts_after (use_operand_p head, imm_use_iterator *imm) + { + use_operand_p use_p; + use_operand_p last_p = head; + gimple head_stmt = USE_STMT (head); + tree use = USE_FROM_PTR (head); + ssa_op_iter op_iter; + int flag; + + /* Only look at virtual or real uses, depending on the type of HEAD. */ + flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES); + + if (gimple_code (head_stmt) == GIMPLE_PHI) + { + FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag) + if (USE_FROM_PTR (use_p) == use) + last_p = move_use_after_head (use_p, head, last_p); + } + else + { + if (flag == SSA_OP_USE) + { + FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag) + if (USE_FROM_PTR (use_p) == use) + last_p = move_use_after_head (use_p, head, last_p); + } + else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P) + { + if (USE_FROM_PTR (use_p) == use) + last_p = move_use_after_head (use_p, head, last_p); + } + } + /* Link iter node in after last_p. */ + if (imm->iter_node.prev != NULL) + delink_imm_use (&imm->iter_node); + link_imm_use_to_list (&(imm->iter_node), last_p); + } + + /* Initialize IMM to traverse over uses of VAR. Return the first statement. */ + static inline gimple + first_imm_use_stmt (imm_use_iterator *imm, tree var) + { + imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); + imm->imm_use = imm->end_p->next; + imm->next_imm_name = NULL_USE_OPERAND_P; + + /* iter_node is used as a marker within the immediate use list to indicate + where the end of the current stmt's uses are. Initialize it to NULL + stmt and use, which indicates a marker node. */ + imm->iter_node.prev = NULL_USE_OPERAND_P; + imm->iter_node.next = NULL_USE_OPERAND_P; + imm->iter_node.loc.stmt = NULL; + imm->iter_node.use = NULL; + + if (end_imm_use_stmt_p (imm)) + return NULL; + + link_use_stmts_after (imm->imm_use, imm); + + return USE_STMT (imm->imm_use); + } + + /* Bump IMM to the next stmt which has a use of var. */ + + static inline gimple + next_imm_use_stmt (imm_use_iterator *imm) + { + imm->imm_use = imm->iter_node.next; + if (end_imm_use_stmt_p (imm)) + { + if (imm->iter_node.prev != NULL) + delink_imm_use (&imm->iter_node); + return NULL; + } + + link_use_stmts_after (imm->imm_use, imm); + return USE_STMT (imm->imm_use); + } + + /* This routine will return the first use on the stmt IMM currently refers + to. */ + + static inline use_operand_p + first_imm_use_on_stmt (imm_use_iterator *imm) + { + imm->next_imm_name = imm->imm_use->next; + return imm->imm_use; + } + + /* Return TRUE if the last use on the stmt IMM refers to has been visited. */ + + static inline bool + end_imm_use_on_stmt_p (const imm_use_iterator *imm) + { + return (imm->imm_use == &(imm->iter_node)); + } + + /* Bump to the next use on the stmt IMM refers to, return NULL if done. */ + + static inline use_operand_p + next_imm_use_on_stmt (imm_use_iterator *imm) + { + imm->imm_use = imm->next_imm_name; + if (end_imm_use_on_stmt_p (imm)) + return NULL_USE_OPERAND_P; + else + { + imm->next_imm_name = imm->imm_use->next; + return imm->imm_use; + } + } + /* Return the phi argument which contains the specified use. */ + + static inline int + phi_arg_index_from_use (use_operand_p use) + { + struct phi_arg_d *element, *root; + size_t index; + gimple phi; + + /* Since the use is the first thing in a PHI argument element, we can + calculate its index based on casting it to an argument, and performing + pointer arithmetic. */ + + phi = USE_STMT (use); + + element = (struct phi_arg_d *)use; + root = gimple_phi_arg (phi, 0); + index = element - root; + + /* Make sure the calculation doesn't have any leftover bytes. If it does, + then imm_use is likely not the first element in phi_arg_d. */ + gcc_checking_assert ((((char *)element - (char *)root) + % sizeof (struct phi_arg_d)) == 0 + && index < gimple_phi_capacity (phi)); + + return index; + } + + /* Delink all immediate_use information for STMT. */ + static inline void + delink_stmt_imm_use (gimple stmt) + { + ssa_op_iter iter; + use_operand_p use_p; + + if (ssa_operands_active (cfun)) + FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_ALL_USES) + delink_imm_use (use_p); + } + #endif /* GCC_TREE_SSA_OPERANDS_H */ Index: tree-phinodes.h =================================================================== *** tree-phinodes.h (revision 0) --- tree-phinodes.h (revision 0) *************** *** 0 **** --- 1,138 ---- + /* Header file for PHI node routines + Copyright (C) 2013 Free Software Foundation, Inc. + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3, or (at your option) any later + version. + + GCC is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with GCC; see the file COPYING3. If not see + . */ + + #ifndef GCC_TREE_PHINODES_H + #define GCC_TREE_PHINODES_H + + extern void phinodes_print_statistics (void); + extern void release_phi_node (gimple); + extern void reserve_phi_args_for_new_edge (basic_block); + extern void add_phi_node_to_bb (gimple phi, basic_block bb); + extern gimple create_phi_node (tree, basic_block); + extern void add_phi_arg (gimple, tree, edge, source_location); + extern void remove_phi_args (edge); + extern void remove_phi_node (gimple_stmt_iterator *, bool); + extern void remove_phi_nodes (basic_block); + + + /* PHI nodes should contain only ssa_names and invariants. A test + for ssa_name is definitely simpler; don't let invalid contents + slip in in the meantime. */ + + static inline bool + phi_ssa_name_p (const_tree t) + { + if (TREE_CODE (t) == SSA_NAME) + return true; + gcc_checking_assert (is_gimple_min_invariant (t)); + return false; + } + + /* Return the PHI nodes for basic block BB, or NULL if there are no + PHI nodes. */ + + static inline gimple_seq + phi_nodes (const_basic_block bb) + { + gcc_checking_assert (!(bb->flags & BB_RTL)); + return bb->il.gimple.phi_nodes; + } + + /* Return a pointer to the PHI nodes for basic block BB. */ + + static inline gimple_seq * + phi_nodes_ptr (basic_block bb) + { + gcc_checking_assert (!(bb->flags & BB_RTL)); + return &bb->il.gimple.phi_nodes; + } + + /* Set PHI nodes of a basic block BB to SEQ. */ + + static inline void + set_phi_nodes (basic_block bb, gimple_seq seq) + { + gimple_stmt_iterator i; + + gcc_checking_assert (!(bb->flags & BB_RTL)); + bb->il.gimple.phi_nodes = seq; + if (seq) + for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) + gimple_set_bb (gsi_stmt (i), bb); + } + + + /* Return the tree operand for argument I of PHI node GS. */ + + static inline tree + gimple_phi_arg_def (gimple gs, size_t index) + { + return gimple_phi_arg (gs, index)->def; + } + + + /* Return a pointer to the tree operand for argument I of PHI node GS. */ + + static inline tree * + gimple_phi_arg_def_ptr (gimple gs, size_t index) + { + return &gimple_phi_arg (gs, index)->def; + } + + /* Return the edge associated with argument I of phi node GS. */ + + static inline edge + gimple_phi_arg_edge (gimple gs, size_t i) + { + return EDGE_PRED (gimple_bb (gs), i); + } + + /* Return the source location of gimple argument I of phi node GS. */ + + static inline source_location + gimple_phi_arg_location (gimple gs, size_t i) + { + return gimple_phi_arg (gs, i)->locus; + } + + /* Return the source location of the argument on edge E of phi node GS. */ + + static inline source_location + gimple_phi_arg_location_from_edge (gimple gs, edge e) + { + return gimple_phi_arg (gs, e->dest_idx)->locus; + } + + /* Set the source location of gimple argument I of phi node GS to LOC. */ + + static inline void + gimple_phi_arg_set_location (gimple gs, size_t i, source_location loc) + { + gimple_phi_arg (gs, i)->locus = loc; + } + + /* Return TRUE if argument I of phi node GS has a location record. */ + + static inline bool + gimple_phi_arg_has_location (gimple gs, size_t i) + { + return gimple_phi_arg_location (gs, i) != UNKNOWN_LOCATION; + } + + #endif /* GCC_TREE_PHINODES_H */ Index: tree-ssa.h =================================================================== *** tree-ssa.h (revision 202838) --- tree-ssa.h (working copy) *************** along with GCC; see the file COPYING3. *** 22,27 **** --- 22,28 ---- #include "tree-flow.h" #include "tree-ssanames.h" + #include "tree-phinodes.h" /* Mapping for redirected edges. */ struct _edge_var_map {