diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/integrate.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/integrate.c | 369 |
1 files changed, 369 insertions, 0 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/integrate.c b/gcc-4.2.1-5666.3/gcc/integrate.c new file mode 100644 index 000000000..a6eeede39 --- /dev/null +++ b/gcc-4.2.1-5666.3/gcc/integrate.c @@ -0,0 +1,369 @@ +/* Procedure integration for GCC. + Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + Contributed by Michael Tiemann (tiemann@cygnus.com) + +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 2, 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 COPYING. If not, write to the Free +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" + +#include "rtl.h" +#include "tree.h" +#include "tm_p.h" +#include "regs.h" +#include "flags.h" +#include "debug.h" +#include "insn-config.h" +#include "expr.h" +#include "output.h" +#include "recog.h" +#include "integrate.h" +#include "real.h" +#include "except.h" +#include "function.h" +#include "toplev.h" +#include "intl.h" +#include "params.h" +#include "ggc.h" +#include "target.h" +#include "langhooks.h" +#include "tree-pass.h" + +/* Round to the next highest integer that meets the alignment. */ +#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1)) + + +/* Private type used by {get/has}_hard_reg_initial_val. */ +typedef struct initial_value_pair GTY(()) { + rtx hard_reg; + rtx pseudo; +} initial_value_pair; +typedef struct initial_value_struct GTY(()) { + int num_entries; + int max_entries; + initial_value_pair * GTY ((length ("%h.num_entries"))) entries; +} initial_value_struct; + +static void set_block_origin_self (tree); +static void set_block_abstract_flags (tree, int); + + +/* Return false if the function FNDECL cannot be inlined on account of its + attributes, true otherwise. */ +bool +function_attribute_inlinable_p (tree fndecl) +{ + if (targetm.attribute_table) + { + tree a; + + for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a)) + { + tree name = TREE_PURPOSE (a); + int i; + + for (i = 0; targetm.attribute_table[i].name != NULL; i++) + if (is_attribute_p (targetm.attribute_table[i].name, name)) + return targetm.function_attribute_inlinable_p (fndecl); + } + } + + return true; +} + +/* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the + given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so + that it points to the node itself, thus indicating that the node is its + own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for + the given node is NULL, recursively descend the decl/block tree which + it is the root of, and for each other ..._DECL or BLOCK node contained + therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also + still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN + values to point to themselves. */ + +static void +set_block_origin_self (tree stmt) +{ + if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE) + { + BLOCK_ABSTRACT_ORIGIN (stmt) = stmt; + + { + tree local_decl; + + for (local_decl = BLOCK_VARS (stmt); + local_decl != NULL_TREE; + local_decl = TREE_CHAIN (local_decl)) + set_decl_origin_self (local_decl); /* Potential recursion. */ + } + + { + tree subblock; + + for (subblock = BLOCK_SUBBLOCKS (stmt); + subblock != NULL_TREE; + subblock = BLOCK_CHAIN (subblock)) + set_block_origin_self (subblock); /* Recurse. */ + } + } +} + +/* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for + the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the + node to so that it points to the node itself, thus indicating that the + node represents its own (abstract) origin. Additionally, if the + DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend + the decl/block tree of which the given node is the root of, and for + each other ..._DECL or BLOCK node contained therein whose + DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL, + set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to + point to themselves. */ + +void +set_decl_origin_self (tree decl) +{ + if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE) + { + DECL_ABSTRACT_ORIGIN (decl) = decl; + if (TREE_CODE (decl) == FUNCTION_DECL) + { + tree arg; + + for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg)) + DECL_ABSTRACT_ORIGIN (arg) = arg; + if (DECL_INITIAL (decl) != NULL_TREE + && DECL_INITIAL (decl) != error_mark_node) + set_block_origin_self (DECL_INITIAL (decl)); + } + } +} + +/* Given a pointer to some BLOCK node, and a boolean value to set the + "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for + the given block, and for all local decls and all local sub-blocks + (recursively) which are contained therein. */ + +static void +set_block_abstract_flags (tree stmt, int setting) +{ + tree local_decl; + tree subblock; + + BLOCK_ABSTRACT (stmt) = setting; + + for (local_decl = BLOCK_VARS (stmt); + local_decl != NULL_TREE; + local_decl = TREE_CHAIN (local_decl)) + set_decl_abstract_flags (local_decl, setting); + + for (subblock = BLOCK_SUBBLOCKS (stmt); + subblock != NULL_TREE; + subblock = BLOCK_CHAIN (subblock)) + set_block_abstract_flags (subblock, setting); +} + +/* Given a pointer to some ..._DECL node, and a boolean value to set the + "abstract" flags to, set that value into the DECL_ABSTRACT flag for the + given decl, and (in the case where the decl is a FUNCTION_DECL) also + set the abstract flags for all of the parameters, local vars, local + blocks and sub-blocks (recursively) to the same setting. */ + +void +set_decl_abstract_flags (tree decl, int setting) +{ + DECL_ABSTRACT (decl) = setting; + if (TREE_CODE (decl) == FUNCTION_DECL) + { + tree arg; + + for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg)) + DECL_ABSTRACT (arg) = setting; + if (DECL_INITIAL (decl) != NULL_TREE + && DECL_INITIAL (decl) != error_mark_node) + set_block_abstract_flags (DECL_INITIAL (decl), setting); + } +} + +/* Functions to keep track of the values hard regs had at the start of + the function. */ + +rtx +get_hard_reg_initial_reg (struct function *fun, rtx reg) +{ + struct initial_value_struct *ivs = fun->hard_reg_initial_vals; + int i; + + if (ivs == 0) + return NULL_RTX; + + for (i = 0; i < ivs->num_entries; i++) + if (rtx_equal_p (ivs->entries[i].pseudo, reg)) + return ivs->entries[i].hard_reg; + + return NULL_RTX; +} + +/* Make sure that there's a pseudo register of mode MODE that stores the + initial value of hard register REGNO. Return an rtx for such a pseudo. */ + +rtx +get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno) +{ + struct initial_value_struct *ivs; + rtx rv; + + rv = has_hard_reg_initial_val (mode, regno); + if (rv) + return rv; + + ivs = cfun->hard_reg_initial_vals; + if (ivs == 0) + { + ivs = ggc_alloc (sizeof (initial_value_struct)); + ivs->num_entries = 0; + ivs->max_entries = 5; + ivs->entries = ggc_alloc (5 * sizeof (initial_value_pair)); + cfun->hard_reg_initial_vals = ivs; + } + + if (ivs->num_entries >= ivs->max_entries) + { + ivs->max_entries += 5; + ivs->entries = ggc_realloc (ivs->entries, + ivs->max_entries + * sizeof (initial_value_pair)); + } + + ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno); + ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode); + + return ivs->entries[ivs->num_entries++].pseudo; +} + +/* See if get_hard_reg_initial_val has been used to create a pseudo + for the initial value of hard register REGNO in mode MODE. Return + the associated pseudo if so, otherwise return NULL. */ + +rtx +has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno) +{ + struct initial_value_struct *ivs; + int i; + + ivs = cfun->hard_reg_initial_vals; + if (ivs != 0) + for (i = 0; i < ivs->num_entries; i++) + if (GET_MODE (ivs->entries[i].hard_reg) == mode + && REGNO (ivs->entries[i].hard_reg) == regno) + return ivs->entries[i].pseudo; + + return NULL_RTX; +} + +unsigned int +emit_initial_value_sets (void) +{ + struct initial_value_struct *ivs = cfun->hard_reg_initial_vals; + int i; + rtx seq; + + if (ivs == 0) + return 0; + + start_sequence (); + for (i = 0; i < ivs->num_entries; i++) + emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg); + seq = get_insns (); + end_sequence (); + + emit_insn_at_entry (seq); + return 0; +} + +struct tree_opt_pass pass_initial_value_sets = +{ + "initvals", /* name */ + NULL, /* gate */ + emit_initial_value_sets, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + 0, /* tv_id */ + 0, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func, /* todo_flags_finish */ + 0 /* letter */ +}; + +/* If the backend knows where to allocate pseudos for hard + register initial values, register these allocations now. */ +void +allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED) +{ + if (targetm.allocate_initial_value) + { + struct initial_value_struct *ivs = cfun->hard_reg_initial_vals; + int i; + + if (ivs == 0) + return; + + for (i = 0; i < ivs->num_entries; i++) + { + int regno = REGNO (ivs->entries[i].pseudo); + rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg); + + if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1) + { + if (MEM_P (x)) + reg_equiv_memory_loc[regno] = x; + else + { + basic_block bb; + int new_regno; + + gcc_assert (REG_P (x)); + new_regno = REGNO (x); + reg_renumber[regno] = new_regno; + /* Poke the regno right into regno_reg_rtx so that even + fixed regs are accepted. */ + REGNO (ivs->entries[i].pseudo) = new_regno; + /* Update global register liveness information. */ + FOR_EACH_BB (bb) + { + struct rtl_bb_info *info = bb->il.rtl; + + if (REGNO_REG_SET_P(info->global_live_at_start, regno)) + SET_REGNO_REG_SET (info->global_live_at_start, + new_regno); + if (REGNO_REG_SET_P(info->global_live_at_end, regno)) + SET_REGNO_REG_SET (info->global_live_at_end, + new_regno); + } + } + } + } + } +} + +#include "gt-integrate.h" |