URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [ipa-prop.c] - Rev 816
Compare with Previous | Blame | View Log
/* Interprocedural analyses. Copyright (C) 2005, 2007 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 <http://www.gnu.org/licenses/>. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "tree.h" #include "langhooks.h" #include "ggc.h" #include "target.h" #include "cgraph.h" #include "ipa-prop.h" #include "tree-flow.h" #include "tree-pass.h" #include "flags.h" #include "timevar.h" /* This file contains interfaces that can be used for various IPA optimizations: - ipa_methodlist interface - It is used to create and handle a temporary worklist used in the propagation stage of IPCP. (can be used for more IPA optimizations). - ipa_callsite interface - for each callsite this interface creates and handles ipa_edge structure associated with it. - ipa_method interface - for each method this interface creates and handles ipa_node structure associated with it. */ /* ipa_methodlist interface. */ /* Create a new worklist node. */ static inline ipa_methodlist_p ipa_create_methodlist_node (void) { return (ipa_methodlist_p) xcalloc (1, sizeof (struct ipa_methodlist)); } /* Return true if worklist WL is empty. */ bool ipa_methodlist_not_empty (ipa_methodlist_p wl) { return (wl != NULL); } /* Return the method in worklist element WL. */ static inline struct cgraph_node * ipa_methodlist_method (ipa_methodlist_p wl) { return wl->method_p; } /* Make worklist element WL point to method MT in the callgraph. */ static inline void ipa_methodlist_method_set (ipa_methodlist_p wl, struct cgraph_node *mt) { wl->method_p = mt; } /* Return the next element in the worklist following worklist element WL. */ static inline ipa_methodlist_p ipa_methodlist_next_method (ipa_methodlist_p wl) { return wl->next_method; } /* Set worklist element WL1 to point to worklist element WL2. */ static inline void ipa_methodlist_next_method_set (ipa_methodlist_p wl1, ipa_methodlist_p wl2) { wl1->next_method = wl2; } /* Initialize worklist to contain all methods. */ ipa_methodlist_p ipa_methodlist_init (void) { struct cgraph_node *node; ipa_methodlist_p wl; wl = NULL; for (node = cgraph_nodes; node; node = node->next) ipa_add_method (&wl, node); return wl; } /* Add method MT to the worklist. Set worklist element WL to point to MT. */ void ipa_add_method (ipa_methodlist_p * wl, struct cgraph_node *mt) { ipa_methodlist_p temp; temp = ipa_create_methodlist_node (); ipa_methodlist_method_set (temp, mt); ipa_methodlist_next_method_set (temp, *wl); *wl = temp; } /* Remove a method from the worklist. WL points to the first element in the list, which is removed. */ struct cgraph_node * ipa_remove_method (ipa_methodlist_p * wl) { ipa_methodlist_p first; struct cgraph_node *return_method; first = *wl; *wl = ipa_methodlist_next_method (*wl); return_method = ipa_methodlist_method (first); free (first); return return_method; } /* ipa_method interface. */ /* Return number of formals of method MT. */ int ipa_method_formal_count (struct cgraph_node *mt) { return IPA_NODE_REF (mt)->ipa_arg_num; } /* Set number of formals of method MT to I. */ void ipa_method_formal_count_set (struct cgraph_node *mt, int i) { IPA_NODE_REF (mt)->ipa_arg_num = i; } /* Return whether I-th formal of MT is modified in MT. */ static inline bool ipa_method_is_modified (struct cgraph_node *mt, int i) { return IPA_NODE_REF (mt)->ipa_mod[i]; } /* Return the tree of I-th formal of MT. */ tree ipa_method_get_tree (struct cgraph_node *mt, int i) { return IPA_NODE_REF (mt)->ipa_param_tree[i]; } /* Create tree map structure for MT. */ static inline void ipa_method_tree_map_create (struct cgraph_node *mt) { IPA_NODE_REF (mt)->ipa_param_tree = XCNEWVEC (tree, ipa_method_formal_count (mt)); } /* Create modify structure for MT. */ static inline void ipa_method_modify_create (struct cgraph_node *mt) { ((struct ipa_node *) mt->aux)->ipa_mod = XCNEWVEC (bool, ipa_method_formal_count (mt)); } /* Set modify of I-th formal of MT to VAL. */ static inline void ipa_method_modify_set (struct cgraph_node *mt, int i, bool val) { IPA_NODE_REF (mt)->ipa_mod[i] = val; } /* Return index of the formal whose tree is PTREE in method MT. */ static int ipa_method_tree_map (struct cgraph_node *mt, tree ptree) { int i, count; count = ipa_method_formal_count (mt); for (i = 0; i < count; i++) if (IPA_NODE_REF (mt)->ipa_param_tree[i] == ptree) return i; return -1; } /* Insert the formal trees to the ipa_param_tree array in method MT. */ void ipa_method_compute_tree_map (struct cgraph_node *mt) { tree fndecl; tree fnargs; tree parm; int param_num; ipa_method_tree_map_create (mt); fndecl = mt->decl; fnargs = DECL_ARGUMENTS (fndecl); param_num = 0; for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) { IPA_NODE_REF (mt)->ipa_param_tree[param_num] = parm; param_num++; } } /* Count number of formals in MT. Insert the result to the ipa_node. */ void ipa_method_formal_compute_count (struct cgraph_node *mt) { tree fndecl; tree fnargs; tree parm; int param_num; fndecl = mt->decl; fnargs = DECL_ARGUMENTS (fndecl); param_num = 0; for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) param_num++; ipa_method_formal_count_set (mt, param_num); } /* Check STMT to detect whether a formal is modified within MT, the appropriate entry is updated in the ipa_mod array of ipa_node (associated with MT). */ static void ipa_method_modify_stmt (struct cgraph_node *mt, tree stmt) { int i, j; switch (TREE_CODE (stmt)) { case MODIFY_EXPR: if (TREE_CODE (TREE_OPERAND (stmt, 0)) == PARM_DECL) { i = ipa_method_tree_map (mt, TREE_OPERAND (stmt, 0)); if (i >= 0) ipa_method_modify_set (mt, i, true); } break; case ASM_EXPR: /* Asm code could modify any of the parameters. */ for (j = 0; j < ipa_method_formal_count (mt); j++) ipa_method_modify_set (mt, j, true); break; default: break; } } /* Initialize ipa_mod array of MT. */ static void ipa_method_modify_init (struct cgraph_node *mt) { int i, count; ipa_method_modify_create (mt); count = ipa_method_formal_count (mt); for (i = 0; i < count; i++) ipa_method_modify_set (mt, i, false); } /* The modify computation driver for MT. Compute which formal arguments of method MT are locally modified. Formals may be modified in MT if their address is taken, or if they appear on the left hand side of an assignment. */ void ipa_method_compute_modify (struct cgraph_node *mt) { tree decl; tree body; int j, count; basic_block bb; struct function *func; block_stmt_iterator bsi; tree stmt, parm_tree; ipa_method_modify_init (mt); decl = mt->decl; count = ipa_method_formal_count (mt); /* ??? Handle pending sizes case. Set all parameters of the method to be modified. */ if (DECL_UNINLINABLE (decl)) { for (j = 0; j < count; j++) ipa_method_modify_set (mt, j, true); return; } /* Formals whose address is taken are considered modified. */ for (j = 0; j < count; j++) { parm_tree = ipa_method_get_tree (mt, j); if (TREE_ADDRESSABLE (parm_tree)) ipa_method_modify_set (mt, j, true); } body = DECL_SAVED_TREE (decl); if (body != NULL) { func = DECL_STRUCT_FUNCTION (decl); FOR_EACH_BB_FN (bb, func) { for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) { stmt = bsi_stmt (bsi); ipa_method_modify_stmt (mt, stmt); } } } } /* ipa_callsite interface. */ /* Return number of arguments in callsite CS. */ int ipa_callsite_param_count (struct cgraph_edge *cs) { return IPA_EDGE_REF (cs)->ipa_param_num; } /* Set number of arguments in callsite CS to I. */ void ipa_callsite_param_count_set (struct cgraph_edge *cs, int i) { IPA_EDGE_REF (cs)->ipa_param_num = i; } /* Return the jump function (ipa_jump_func struct) for argument I of callsite CS. */ struct ipa_jump_func * ipa_callsite_param (struct cgraph_edge *cs, int i) { return &(IPA_EDGE_REF (cs)->ipa_param_map[i]); } /* return the callee (cgraph_node) of callsite CS. */ struct cgraph_node * ipa_callsite_callee (struct cgraph_edge *cs) { return cs->callee; } /* Set field 'type' of jump function (ipa_jump_func struct) of argument I in callsite CS. */ static inline void ipa_callsite_param_set_type (struct cgraph_edge *cs, int i, enum jump_func_type type1) { IPA_EDGE_REF (cs)->ipa_param_map[i].type = type1; } /* Set FORMAL as 'info_type' field of jump function (ipa_jump_func struct) of argument I of callsite CS. */ static inline void ipa_callsite_param_set_info_type_formal (struct cgraph_edge *cs, int i, unsigned int formal) { ipa_callsite_param (cs, i)->info_type.formal_id = formal; } /* Set int-valued INFO_TYPE1 as 'info_type' field of jump function (ipa_jump_func struct) of argument I of callsite CS. */ static inline void ipa_callsite_param_set_info_type (struct cgraph_edge *cs, int i, tree info_type1) { ipa_callsite_param (cs, i)->info_type.value = info_type1; } /* Allocate space for callsite CS. */ static inline void ipa_callsite_param_map_create (struct cgraph_edge *cs) { IPA_EDGE_REF (cs)->ipa_param_map = XCNEWVEC (struct ipa_jump_func, ipa_callsite_param_count (cs)); } /* Return the call expr tree related to callsite CS. */ static inline tree ipa_callsite_tree (struct cgraph_edge *cs) { return cs->call_stmt; } /* Return the caller (cgraph_node) of CS. */ static inline struct cgraph_node * ipa_callsite_caller (struct cgraph_edge *cs) { return cs->caller; } /* Count number of arguments callsite CS has and store it in ipa_edge structure corresponding to this callsite. */ void ipa_callsite_compute_count (struct cgraph_edge *cs) { tree call_tree; tree arg; int arg_num; call_tree = get_call_expr_in (ipa_callsite_tree (cs)); gcc_assert (TREE_CODE (call_tree) == CALL_EXPR); arg = TREE_OPERAND (call_tree, 1); arg_num = 0; for (; arg != NULL_TREE; arg = TREE_CHAIN (arg)) arg_num++; ipa_callsite_param_count_set (cs, arg_num); } /* Compute jump function for all arguments of callsite CS and insert the information in the ipa_param_map array in the ipa_edge corresponding to this callsite. (Explanation on jump functions is in ipa-prop.h). */ void ipa_callsite_compute_param (struct cgraph_edge *cs) { tree call_tree; tree arg, cst_decl; int arg_num; int i; struct cgraph_node *mt; if (ipa_callsite_param_count (cs) == 0) return; ipa_callsite_param_map_create (cs); call_tree = get_call_expr_in (ipa_callsite_tree (cs)); gcc_assert (TREE_CODE (call_tree) == CALL_EXPR); arg = TREE_OPERAND (call_tree, 1); arg_num = 0; for (; arg != NULL_TREE; arg = TREE_CHAIN (arg)) { /* If the formal parameter was passed as argument, we store FORMAL_IPATYPE and its index in the caller as the jump function of this argument. */ if (TREE_CODE (TREE_VALUE (arg)) == PARM_DECL) { mt = ipa_callsite_caller (cs); i = ipa_method_tree_map (mt, TREE_VALUE (arg)); if (i < 0 || ipa_method_is_modified (mt, i)) ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE); else { ipa_callsite_param_set_type (cs, arg_num, FORMAL_IPATYPE); ipa_callsite_param_set_info_type_formal (cs, arg_num, i); } } /* If a constant value was passed as argument, we store CONST_IPATYPE and its value as the jump function of this argument. */ else if (TREE_CODE (TREE_VALUE (arg)) == INTEGER_CST || TREE_CODE (TREE_VALUE (arg)) == REAL_CST) { ipa_callsite_param_set_type (cs, arg_num, CONST_IPATYPE); ipa_callsite_param_set_info_type (cs, arg_num, TREE_VALUE (arg)); } /* This is for the case of Fortran. If the address of a const_decl was passed as argument then we store CONST_IPATYPE_REF/CONST_IPATYPE_REF and the constant value as the jump function corresponding to this argument. */ else if (TREE_CODE (TREE_VALUE (arg)) == ADDR_EXPR && TREE_CODE (TREE_OPERAND (TREE_VALUE (arg), 0)) == CONST_DECL) { cst_decl = TREE_OPERAND (TREE_VALUE (arg), 0); if (TREE_CODE (DECL_INITIAL (cst_decl)) == INTEGER_CST || TREE_CODE (DECL_INITIAL (cst_decl)) == REAL_CST) { ipa_callsite_param_set_type (cs, arg_num, CONST_IPATYPE_REF); ipa_callsite_param_set_info_type (cs, arg_num, DECL_INITIAL (cst_decl)); } } else ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE); arg_num++; } } /* Return type of jump function JF. */ enum jump_func_type get_type (struct ipa_jump_func *jf) { return jf->type; } /* Return info type of jump function JF. */ union parameter_info * ipa_jf_get_info_type (struct ipa_jump_func *jf) { return &(jf->info_type); } /* Allocate and initialize ipa_node structure. cgraph_node NODE points to the new allocated ipa_node. */ void ipa_node_create (struct cgraph_node *node) { node->aux = xcalloc (1, sizeof (struct ipa_node)); } /* Allocate and initialize ipa_node structure for all nodes in callgraph. */ void ipa_nodes_create (void) { struct cgraph_node *node; for (node = cgraph_nodes; node; node = node->next) ipa_node_create (node); } /* Allocate and initialize ipa_edge structure. */ void ipa_edges_create (void) { struct cgraph_node *node; struct cgraph_edge *cs; for (node = cgraph_nodes; node; node = node->next) for (cs = node->callees; cs; cs = cs->next_callee) cs->aux = xcalloc (1, sizeof (struct ipa_edge)); } /* Free ipa_node structure. */ void ipa_nodes_free (void) { struct cgraph_node *node; for (node = cgraph_nodes; node; node = node->next) { free (node->aux); node->aux = NULL; } } /* Free ipa_edge structure. */ void ipa_edges_free (void) { struct cgraph_node *node; struct cgraph_edge *cs; for (node = cgraph_nodes; node; node = node->next) for (cs = node->callees; cs; cs = cs->next_callee) { free (cs->aux); cs->aux = NULL; } } /* Free ipa data structures of ipa_node and ipa_edge. */ void ipa_free (void) { struct cgraph_node *node; struct cgraph_edge *cs; for (node = cgraph_nodes; node; node = node->next) { if (node->aux == NULL) continue; if (IPA_NODE_REF (node)->ipcp_cval) free (IPA_NODE_REF (node)->ipcp_cval); if (IPA_NODE_REF (node)->ipa_param_tree) free (IPA_NODE_REF (node)->ipa_param_tree); if (IPA_NODE_REF (node)->ipa_mod) free (IPA_NODE_REF (node)->ipa_mod); for (cs = node->callees; cs; cs = cs->next_callee) { if (cs->aux) if (IPA_EDGE_REF (cs)->ipa_param_map) free (IPA_EDGE_REF (cs)->ipa_param_map); } } } /* Print ipa_tree_map data structures of all methods in the callgraph to F. */ void ipa_method_tree_print (FILE * f) { int i, count; tree temp; struct cgraph_node *node; fprintf (f, "\nPARAM TREE MAP PRINT\n"); for (node = cgraph_nodes; node; node = node->next) { fprintf (f, "method %s Trees :: \n", cgraph_node_name (node)); count = ipa_method_formal_count (node); for (i = 0; i < count; i++) { temp = ipa_method_get_tree (node, i); if (TREE_CODE (temp) == PARM_DECL) fprintf (f, " param [%d] : %s\n", i, (*lang_hooks.decl_printable_name) (temp, 2)); } } } /* Print ipa_modify data structures of all methods in the callgraph to F. */ void ipa_method_modify_print (FILE * f) { int i, count; bool temp; struct cgraph_node *node; fprintf (f, "\nMODIFY PRINT\n"); for (node = cgraph_nodes; node; node = node->next) { fprintf (f, "method %s :: \n", cgraph_node_name (node)); count = ipa_method_formal_count (node); for (i = 0; i < count; i++) { temp = ipa_method_is_modified (node, i); if (temp) fprintf (f, " param [%d] true \n", i); else fprintf (f, " param [%d] false \n", i); } } }