/* Procedure integration for GCC.
|
/* Procedure integration for GCC.
|
Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
2000, 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
2000, 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
Contributed by Michael Tiemann (tiemann@cygnus.com)
|
Contributed by Michael Tiemann (tiemann@cygnus.com)
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
|
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "debug.h"
|
#include "debug.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "output.h"
|
#include "output.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "integrate.h"
|
#include "integrate.h"
|
#include "real.h"
|
#include "real.h"
|
#include "except.h"
|
#include "except.h"
|
#include "function.h"
|
#include "function.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "params.h"
|
#include "params.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "target.h"
|
#include "target.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
|
|
/* Round to the next highest integer that meets the alignment. */
|
/* Round to the next highest integer that meets the alignment. */
|
#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
|
#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
|
|
|
|
|
/* Private type used by {get/has}_hard_reg_initial_val. */
|
/* Private type used by {get/has}_hard_reg_initial_val. */
|
typedef struct initial_value_pair GTY(()) {
|
typedef struct initial_value_pair GTY(()) {
|
rtx hard_reg;
|
rtx hard_reg;
|
rtx pseudo;
|
rtx pseudo;
|
} initial_value_pair;
|
} initial_value_pair;
|
typedef struct initial_value_struct GTY(()) {
|
typedef struct initial_value_struct GTY(()) {
|
int num_entries;
|
int num_entries;
|
int max_entries;
|
int max_entries;
|
initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
|
initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
|
} initial_value_struct;
|
} initial_value_struct;
|
|
|
static void set_block_origin_self (tree);
|
static void set_block_origin_self (tree);
|
static void set_block_abstract_flags (tree, int);
|
static void set_block_abstract_flags (tree, int);
|
|
|
|
|
/* Return false if the function FNDECL cannot be inlined on account of its
|
/* Return false if the function FNDECL cannot be inlined on account of its
|
attributes, true otherwise. */
|
attributes, true otherwise. */
|
bool
|
bool
|
function_attribute_inlinable_p (tree fndecl)
|
function_attribute_inlinable_p (tree fndecl)
|
{
|
{
|
if (targetm.attribute_table)
|
if (targetm.attribute_table)
|
{
|
{
|
tree a;
|
tree a;
|
|
|
for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
|
for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
|
{
|
{
|
tree name = TREE_PURPOSE (a);
|
tree name = TREE_PURPOSE (a);
|
int i;
|
int i;
|
|
|
for (i = 0; targetm.attribute_table[i].name != NULL; i++)
|
for (i = 0; targetm.attribute_table[i].name != NULL; i++)
|
if (is_attribute_p (targetm.attribute_table[i].name, name))
|
if (is_attribute_p (targetm.attribute_table[i].name, name))
|
return targetm.function_attribute_inlinable_p (fndecl);
|
return targetm.function_attribute_inlinable_p (fndecl);
|
}
|
}
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
|
/* 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
|
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
|
that it points to the node itself, thus indicating that the node is its
|
own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
|
own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
|
the given node is NULL, recursively descend the decl/block tree which
|
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
|
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
|
therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
|
still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
|
still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
|
values to point to themselves. */
|
values to point to themselves. */
|
|
|
static void
|
static void
|
set_block_origin_self (tree stmt)
|
set_block_origin_self (tree stmt)
|
{
|
{
|
if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
|
if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
|
{
|
{
|
BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
|
BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
|
|
|
{
|
{
|
tree local_decl;
|
tree local_decl;
|
|
|
for (local_decl = BLOCK_VARS (stmt);
|
for (local_decl = BLOCK_VARS (stmt);
|
local_decl != NULL_TREE;
|
local_decl != NULL_TREE;
|
local_decl = TREE_CHAIN (local_decl))
|
local_decl = TREE_CHAIN (local_decl))
|
set_decl_origin_self (local_decl); /* Potential recursion. */
|
set_decl_origin_self (local_decl); /* Potential recursion. */
|
}
|
}
|
|
|
{
|
{
|
tree subblock;
|
tree subblock;
|
|
|
for (subblock = BLOCK_SUBBLOCKS (stmt);
|
for (subblock = BLOCK_SUBBLOCKS (stmt);
|
subblock != NULL_TREE;
|
subblock != NULL_TREE;
|
subblock = BLOCK_CHAIN (subblock))
|
subblock = BLOCK_CHAIN (subblock))
|
set_block_origin_self (subblock); /* Recurse. */
|
set_block_origin_self (subblock); /* Recurse. */
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
|
/* 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
|
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 to so that it points to the node itself, thus indicating that the
|
node represents its own (abstract) origin. Additionally, if the
|
node represents its own (abstract) origin. Additionally, if the
|
DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
|
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
|
the decl/block tree of which the given node is the root of, and for
|
each other ..._DECL or BLOCK node contained therein whose
|
each other ..._DECL or BLOCK node contained therein whose
|
DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
|
DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
|
set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
|
set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
|
point to themselves. */
|
point to themselves. */
|
|
|
void
|
void
|
set_decl_origin_self (tree decl)
|
set_decl_origin_self (tree decl)
|
{
|
{
|
if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
|
if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
|
{
|
{
|
DECL_ABSTRACT_ORIGIN (decl) = decl;
|
DECL_ABSTRACT_ORIGIN (decl) = decl;
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
{
|
{
|
tree arg;
|
tree arg;
|
|
|
for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
|
for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
|
DECL_ABSTRACT_ORIGIN (arg) = arg;
|
DECL_ABSTRACT_ORIGIN (arg) = arg;
|
if (DECL_INITIAL (decl) != NULL_TREE
|
if (DECL_INITIAL (decl) != NULL_TREE
|
&& DECL_INITIAL (decl) != error_mark_node)
|
&& DECL_INITIAL (decl) != error_mark_node)
|
set_block_origin_self (DECL_INITIAL (decl));
|
set_block_origin_self (DECL_INITIAL (decl));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Given a pointer to some BLOCK node, and a boolean value to set the
|
/* 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
|
"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
|
the given block, and for all local decls and all local sub-blocks
|
(recursively) which are contained therein. */
|
(recursively) which are contained therein. */
|
|
|
static void
|
static void
|
set_block_abstract_flags (tree stmt, int setting)
|
set_block_abstract_flags (tree stmt, int setting)
|
{
|
{
|
tree local_decl;
|
tree local_decl;
|
tree subblock;
|
tree subblock;
|
|
|
BLOCK_ABSTRACT (stmt) = setting;
|
BLOCK_ABSTRACT (stmt) = setting;
|
|
|
for (local_decl = BLOCK_VARS (stmt);
|
for (local_decl = BLOCK_VARS (stmt);
|
local_decl != NULL_TREE;
|
local_decl != NULL_TREE;
|
local_decl = TREE_CHAIN (local_decl))
|
local_decl = TREE_CHAIN (local_decl))
|
set_decl_abstract_flags (local_decl, setting);
|
set_decl_abstract_flags (local_decl, setting);
|
|
|
for (subblock = BLOCK_SUBBLOCKS (stmt);
|
for (subblock = BLOCK_SUBBLOCKS (stmt);
|
subblock != NULL_TREE;
|
subblock != NULL_TREE;
|
subblock = BLOCK_CHAIN (subblock))
|
subblock = BLOCK_CHAIN (subblock))
|
set_block_abstract_flags (subblock, setting);
|
set_block_abstract_flags (subblock, setting);
|
}
|
}
|
|
|
/* Given a pointer to some ..._DECL node, and a boolean value to set the
|
/* 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
|
"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
|
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
|
set the abstract flags for all of the parameters, local vars, local
|
blocks and sub-blocks (recursively) to the same setting. */
|
blocks and sub-blocks (recursively) to the same setting. */
|
|
|
void
|
void
|
set_decl_abstract_flags (tree decl, int setting)
|
set_decl_abstract_flags (tree decl, int setting)
|
{
|
{
|
DECL_ABSTRACT (decl) = setting;
|
DECL_ABSTRACT (decl) = setting;
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
{
|
{
|
tree arg;
|
tree arg;
|
|
|
for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
|
for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
|
DECL_ABSTRACT (arg) = setting;
|
DECL_ABSTRACT (arg) = setting;
|
if (DECL_INITIAL (decl) != NULL_TREE
|
if (DECL_INITIAL (decl) != NULL_TREE
|
&& DECL_INITIAL (decl) != error_mark_node)
|
&& DECL_INITIAL (decl) != error_mark_node)
|
set_block_abstract_flags (DECL_INITIAL (decl), setting);
|
set_block_abstract_flags (DECL_INITIAL (decl), setting);
|
}
|
}
|
}
|
}
|
|
|
/* Functions to keep track of the values hard regs had at the start of
|
/* Functions to keep track of the values hard regs had at the start of
|
the function. */
|
the function. */
|
|
|
rtx
|
rtx
|
get_hard_reg_initial_reg (struct function *fun, rtx reg)
|
get_hard_reg_initial_reg (struct function *fun, rtx reg)
|
{
|
{
|
struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
|
struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
|
int i;
|
int i;
|
|
|
if (ivs == 0)
|
if (ivs == 0)
|
return NULL_RTX;
|
return NULL_RTX;
|
|
|
for (i = 0; i < ivs->num_entries; i++)
|
for (i = 0; i < ivs->num_entries; i++)
|
if (rtx_equal_p (ivs->entries[i].pseudo, reg))
|
if (rtx_equal_p (ivs->entries[i].pseudo, reg))
|
return ivs->entries[i].hard_reg;
|
return ivs->entries[i].hard_reg;
|
|
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Make sure that there's a pseudo register of mode MODE that stores the
|
/* 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. */
|
initial value of hard register REGNO. Return an rtx for such a pseudo. */
|
|
|
rtx
|
rtx
|
get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
|
get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
|
{
|
{
|
struct initial_value_struct *ivs;
|
struct initial_value_struct *ivs;
|
rtx rv;
|
rtx rv;
|
|
|
rv = has_hard_reg_initial_val (mode, regno);
|
rv = has_hard_reg_initial_val (mode, regno);
|
if (rv)
|
if (rv)
|
return rv;
|
return rv;
|
|
|
ivs = cfun->hard_reg_initial_vals;
|
ivs = cfun->hard_reg_initial_vals;
|
if (ivs == 0)
|
if (ivs == 0)
|
{
|
{
|
ivs = ggc_alloc (sizeof (initial_value_struct));
|
ivs = ggc_alloc (sizeof (initial_value_struct));
|
ivs->num_entries = 0;
|
ivs->num_entries = 0;
|
ivs->max_entries = 5;
|
ivs->max_entries = 5;
|
ivs->entries = ggc_alloc (5 * sizeof (initial_value_pair));
|
ivs->entries = ggc_alloc (5 * sizeof (initial_value_pair));
|
cfun->hard_reg_initial_vals = ivs;
|
cfun->hard_reg_initial_vals = ivs;
|
}
|
}
|
|
|
if (ivs->num_entries >= ivs->max_entries)
|
if (ivs->num_entries >= ivs->max_entries)
|
{
|
{
|
ivs->max_entries += 5;
|
ivs->max_entries += 5;
|
ivs->entries = ggc_realloc (ivs->entries,
|
ivs->entries = ggc_realloc (ivs->entries,
|
ivs->max_entries
|
ivs->max_entries
|
* sizeof (initial_value_pair));
|
* sizeof (initial_value_pair));
|
}
|
}
|
|
|
ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
|
ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
|
ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
|
ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
|
|
|
return ivs->entries[ivs->num_entries++].pseudo;
|
return ivs->entries[ivs->num_entries++].pseudo;
|
}
|
}
|
|
|
/* See if get_hard_reg_initial_val has been used to create a 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
|
for the initial value of hard register REGNO in mode MODE. Return
|
the associated pseudo if so, otherwise return NULL. */
|
the associated pseudo if so, otherwise return NULL. */
|
|
|
rtx
|
rtx
|
has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
|
has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
|
{
|
{
|
struct initial_value_struct *ivs;
|
struct initial_value_struct *ivs;
|
int i;
|
int i;
|
|
|
ivs = cfun->hard_reg_initial_vals;
|
ivs = cfun->hard_reg_initial_vals;
|
if (ivs != 0)
|
if (ivs != 0)
|
for (i = 0; i < ivs->num_entries; i++)
|
for (i = 0; i < ivs->num_entries; i++)
|
if (GET_MODE (ivs->entries[i].hard_reg) == mode
|
if (GET_MODE (ivs->entries[i].hard_reg) == mode
|
&& REGNO (ivs->entries[i].hard_reg) == regno)
|
&& REGNO (ivs->entries[i].hard_reg) == regno)
|
return ivs->entries[i].pseudo;
|
return ivs->entries[i].pseudo;
|
|
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
unsigned int
|
unsigned int
|
emit_initial_value_sets (void)
|
emit_initial_value_sets (void)
|
{
|
{
|
struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
|
struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
|
int i;
|
int i;
|
rtx seq;
|
rtx seq;
|
|
|
if (ivs == 0)
|
if (ivs == 0)
|
return 0;
|
return 0;
|
|
|
start_sequence ();
|
start_sequence ();
|
for (i = 0; i < ivs->num_entries; i++)
|
for (i = 0; i < ivs->num_entries; i++)
|
emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
|
emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
emit_insn_at_entry (seq);
|
emit_insn_at_entry (seq);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_initial_value_sets =
|
struct tree_opt_pass pass_initial_value_sets =
|
{
|
{
|
"initvals", /* name */
|
"initvals", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
emit_initial_value_sets, /* execute */
|
emit_initial_value_sets, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
0, /* tv_id */
|
0, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
/* If the backend knows where to allocate pseudos for hard
|
/* If the backend knows where to allocate pseudos for hard
|
register initial values, register these allocations now. */
|
register initial values, register these allocations now. */
|
void
|
void
|
allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
|
allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
|
{
|
{
|
if (targetm.allocate_initial_value)
|
if (targetm.allocate_initial_value)
|
{
|
{
|
struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
|
struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
|
int i;
|
int i;
|
|
|
if (ivs == 0)
|
if (ivs == 0)
|
return;
|
return;
|
|
|
for (i = 0; i < ivs->num_entries; i++)
|
for (i = 0; i < ivs->num_entries; i++)
|
{
|
{
|
int regno = REGNO (ivs->entries[i].pseudo);
|
int regno = REGNO (ivs->entries[i].pseudo);
|
rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);
|
rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);
|
|
|
if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
|
if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
|
{
|
{
|
if (MEM_P (x))
|
if (MEM_P (x))
|
reg_equiv_memory_loc[regno] = x;
|
reg_equiv_memory_loc[regno] = x;
|
else
|
else
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
int new_regno;
|
int new_regno;
|
|
|
gcc_assert (REG_P (x));
|
gcc_assert (REG_P (x));
|
new_regno = REGNO (x);
|
new_regno = REGNO (x);
|
reg_renumber[regno] = new_regno;
|
reg_renumber[regno] = new_regno;
|
/* Poke the regno right into regno_reg_rtx so that even
|
/* Poke the regno right into regno_reg_rtx so that even
|
fixed regs are accepted. */
|
fixed regs are accepted. */
|
REGNO (ivs->entries[i].pseudo) = new_regno;
|
REGNO (ivs->entries[i].pseudo) = new_regno;
|
/* Update global register liveness information. */
|
/* Update global register liveness information. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
struct rtl_bb_info *info = bb->il.rtl;
|
struct rtl_bb_info *info = bb->il.rtl;
|
|
|
if (REGNO_REG_SET_P(info->global_live_at_start, regno))
|
if (REGNO_REG_SET_P(info->global_live_at_start, regno))
|
SET_REGNO_REG_SET (info->global_live_at_start,
|
SET_REGNO_REG_SET (info->global_live_at_start,
|
new_regno);
|
new_regno);
|
if (REGNO_REG_SET_P(info->global_live_at_end, regno))
|
if (REGNO_REG_SET_P(info->global_live_at_end, regno))
|
SET_REGNO_REG_SET (info->global_live_at_end,
|
SET_REGNO_REG_SET (info->global_live_at_end,
|
new_regno);
|
new_regno);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
#include "gt-integrate.h"
|
#include "gt-integrate.h"
|
|
|
