#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "toplev.h"
#include "rtl.h"
#include "hard-reg-set.h"
#include "flags.h"
#include "obstack.h"
#include "basic-block.h"
#include "output.h"
#include "df.h"
#include "function.h"
#include "timevar.h"
#include "tree-pass.h"
static rtx entry_register (struct web_entry *, struct df_ref *, char *);
static void replace_ref (struct df_ref *, rtx);
struct web_entry *
unionfind_root (struct web_entry *element)
{
struct web_entry *element1 = element, *element2;
while (element->pred)
element = element->pred;
while (element1->pred)
{
element2 = element1->pred;
element1->pred = element;
element1 = element2;
}
return element;
}
bool
unionfind_union (struct web_entry *first, struct web_entry *second)
{
first = unionfind_root (first);
second = unionfind_root (second);
if (first == second)
return true;
second->pred = first;
return false;
}
void
union_defs (struct df *df, struct df_ref *use, struct web_entry *def_entry,
struct web_entry *use_entry,
bool (*fun) (struct web_entry *, struct web_entry *))
{
rtx insn = DF_REF_INSN (use);
struct df_link *link = DF_REF_CHAIN (use);
struct df_ref *use_link;
struct df_ref *def_link;
rtx set;
if (insn)
{
use_link = DF_INSN_USES (df, insn);
def_link = DF_INSN_DEFS (df, insn);
set = single_set (insn);
}
else
{
use_link = NULL;
def_link = NULL;
set = NULL;
}
while (use_link)
{
if (use != use_link
&& DF_REF_REAL_REG (use) == DF_REF_REAL_REG (use_link))
(*fun) (use_entry + DF_REF_ID (use),
use_entry + DF_REF_ID (use_link));
use_link = use_link->next_ref;
}
if (set
&& SET_SRC (set) == DF_REF_REG (use)
&& SET_SRC (set) == SET_DEST (set))
{
while (def_link)
{
if (DF_REF_REAL_REG (use) == DF_REF_REAL_REG (def_link))
(*fun) (use_entry + DF_REF_ID (use),
def_entry + DF_REF_ID (def_link));
def_link = def_link->next_ref;
}
}
while (link)
{
(*fun) (use_entry + DF_REF_ID (use),
def_entry + DF_REF_ID (link->ref));
link = link->next;
}
if (use->flags & DF_REF_READ_WRITE)
{
struct df_ref *link;
if (DF_REF_INSN (use))
link = DF_INSN_DEFS (df, DF_REF_INSN (use));
else
link = NULL;
while (link)
{
if (DF_REF_REAL_REG (link) == DF_REF_REAL_REG (use))
(*fun) (use_entry + DF_REF_ID (use),
def_entry + DF_REF_ID (link));
link = link->next_ref;
}
}
}
static rtx
entry_register (struct web_entry *entry, struct df_ref *ref, char *used)
{
struct web_entry *root;
rtx reg, newreg;
root = unionfind_root (entry);
if (root->reg)
return root->reg;
reg = DF_REF_REAL_REG (ref);
if (!used[REGNO (reg)])
newreg = reg, used[REGNO (reg)] = 1;
else if (REG_USERVAR_P (reg) && 0)
{
newreg = reg;
if (dump_file)
fprintf (dump_file,
"New web forced to keep reg=%i (user variable)\n",
REGNO (reg));
}
else
{
newreg = gen_reg_rtx (GET_MODE (reg));
REG_USERVAR_P (newreg) = REG_USERVAR_P (reg);
REG_POINTER (newreg) = REG_POINTER (reg);
REG_ATTRS (newreg) = REG_ATTRS (reg);
if (dump_file)
fprintf (dump_file, "Web oldreg=%i newreg=%i\n", REGNO (reg),
REGNO (newreg));
}
root->reg = newreg;
return newreg;
}
static void
replace_ref (struct df_ref *ref, rtx reg)
{
rtx oldreg = DF_REF_REAL_REG (ref);
rtx *loc = DF_REF_REAL_LOC (ref);
if (oldreg == reg)
return;
if (dump_file)
fprintf (dump_file, "Updating insn %i (%i->%i)\n",
INSN_UID (DF_REF_INSN (ref)), REGNO (oldreg), REGNO (reg));
*loc = reg;
}
static void
web_main (void)
{
struct df *df;
struct web_entry *def_entry;
struct web_entry *use_entry;
unsigned int i;
int max = max_reg_num ();
char *used;
df = df_init (DF_EQUIV_NOTES);
df_chain_add_problem (df, DF_UD_CHAIN);
df_analyze (df);
df_reorganize_refs (&df->def_info);
df_reorganize_refs (&df->use_info);
def_entry = XCNEWVEC (struct web_entry, DF_DEFS_SIZE (df));
use_entry = XCNEWVEC (struct web_entry, DF_USES_SIZE (df));
used = XCNEWVEC (char, max);
if (dump_file)
df_dump (df, dump_file);
for (i = 0; i < DF_USES_SIZE (df); i++)
union_defs (df, DF_USES_GET (df, i), def_entry, use_entry, unionfind_union);
for (i = 0; i < DF_USES_SIZE (df); i++)
replace_ref (DF_USES_GET (df, i),
entry_register (use_entry + i, DF_USES_GET (df, i), used));
for (i = 0; i < DF_DEFS_SIZE (df); i++)
replace_ref (DF_DEFS_GET (df, i),
entry_register (def_entry + i, DF_DEFS_GET (df, i), used));
free (def_entry);
free (use_entry);
free (used);
df_finish (df);
df = NULL;
}
static bool
gate_handle_web (void)
{
return (optimize > 0 && flag_web);
}
static unsigned int
rest_of_handle_web (void)
{
web_main ();
delete_trivially_dead_insns (get_insns (), max_reg_num ());
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (get_insns (), max_reg_num ());
return 0;
}
struct tree_opt_pass pass_web =
{
"web",
gate_handle_web,
rest_of_handle_web,
NULL,
NULL,
0,
TV_WEB,
0,
0,
0,
0,
TODO_dump_func,
'Z'
};