#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "obstack.h"
#include "rtl.h"
#include "output.h"
#include "df.h"
#include "insn-config.h"
#include "recog.h"
#include "expr.h"
#include "splay-tree.h"
#include "hashtab.h"
#include "regs.h"
#include "timevar.h"
#include "tree-pass.h"
enum entry_type {
NOT_RELEVANT,
SIGN_EXTENDED_DEF,
ZERO_EXTENDED_DEF,
EXTENDED_DEF,
RELEVANT_USE
};
enum extension_type {
DEF_EXTENSION,
EXPLICIT_DEF_EXTENSION,
IMPLICIT_DEF_EXTENSION,
USE_EXTENSION
};
struct see_entry_extra_info
{
enum entry_type relevancy;
enum entry_type local_relevancy;
enum machine_mode source_mode;
enum machine_mode local_source_mode;
enum machine_mode source_mode_signed;
enum machine_mode source_mode_unsigned;
};
struct see_ref_s
{
unsigned int luid;
rtx insn;
rtx merged_insn;
htab_t unmerged_def_se_hash;
htab_t merged_def_se_hash;
htab_t use_se_hash;
};
struct see_register_properties
{
unsigned int regno;
int last_def;
int first_se_before_any_def;
int first_se_after_last_def;
};
struct see_occr
{
struct see_occr *next;
rtx insn;
int block_num;
};
struct see_pre_extension_expr
{
rtx se_insn;
int bitmap_index;
struct see_occr *antic_occr;
struct see_occr *avail_occr;
};
struct see_replace_data
{
rtx from;
rtx to;
};
struct see_mentioned_reg_data
{
rtx reg;
bool mentioned;
};
static struct df *df = NULL;
static struct web_entry *def_entry = NULL;
static struct web_entry *use_entry = NULL;
static splay_tree *see_bb_splay_ar = NULL;
static htab_t *see_bb_hash_ar = NULL;
static htab_t see_pre_extension_hash = NULL;
static sbitmap *transp = NULL;
static sbitmap *comp = NULL;
static sbitmap *antloc = NULL;
static sbitmap *ae_kill = NULL;
static sbitmap *pre_insert_map = NULL;
static sbitmap *pre_delete_map = NULL;
static struct edge_list *edge_list = NULL;
static int last_bb;
static unsigned int uses_num;
static unsigned int defs_num;
#define ENTRY_EI(ENTRY) ((struct see_entry_extra_info *) (ENTRY)->extra_info)
static rtx
see_get_extension_reg (rtx extension, bool return_dest_reg)
{
rtx set, rhs, lhs;
rtx reg1 = NULL;
rtx reg2 = NULL;
if (GET_CODE (PATTERN (extension)) == PARALLEL)
return NULL;
set = single_set (extension);
if (!set)
return NULL;
lhs = SET_DEST (set);
rhs = SET_SRC (set);
if (REG_P (lhs))
reg1 = lhs;
else if (REG_P (SUBREG_REG (lhs)))
reg1 = SUBREG_REG (lhs);
else
return NULL;
if (GET_CODE (rhs) != SIGN_EXTEND && GET_CODE (rhs) != ZERO_EXTEND)
return NULL;
rhs = XEXP (rhs, 0);
if (REG_P (rhs))
reg2 = rhs;
else if (REG_P (SUBREG_REG (rhs)))
reg2 = SUBREG_REG (rhs);
else
return NULL;
if (return_dest_reg)
return reg1;
return reg2;
}
static enum rtx_code
see_get_extension_data (rtx extension, enum machine_mode *source_mode)
{
rtx rhs, lhs, set;
if (!extension || !INSN_P (extension))
return UNKNOWN;
if (GET_CODE (PATTERN (extension)) == PARALLEL)
return NOT_RELEVANT;
set = single_set (extension);
if (!set)
return NOT_RELEVANT;
rhs = SET_SRC (set);
lhs = SET_DEST (set);
if (!REG_P (lhs) && !SUBREG_REG (lhs))
return UNKNOWN;
if (GET_CODE (rhs) != SIGN_EXTEND && GET_CODE (rhs) != ZERO_EXTEND)
return UNKNOWN;
if (!REG_P (XEXP (rhs, 0))
&& !(GET_CODE (XEXP (rhs, 0)) == SUBREG
&& REG_P (SUBREG_REG (XEXP (rhs, 0)))))
return UNKNOWN;
*source_mode = GET_MODE (XEXP (rhs, 0));
if (GET_CODE (rhs) == SIGN_EXTEND)
return SIGN_EXTEND;
return ZERO_EXTEND;
}
static rtx
see_gen_normalized_extension (rtx reg, enum rtx_code extension_code,
enum machine_mode mode)
{
rtx subreg, insn;
rtx extension = NULL;
if (!reg
|| !REG_P (reg)
|| (extension_code != SIGN_EXTEND && extension_code != ZERO_EXTEND))
return NULL;
subreg = gen_lowpart_SUBREG (mode, reg);
if (extension_code == SIGN_EXTEND)
extension = gen_rtx_SIGN_EXTEND (GET_MODE (reg), subreg);
else
extension = gen_rtx_ZERO_EXTEND (GET_MODE (reg), subreg);
start_sequence ();
emit_insn (gen_rtx_SET (VOIDmode, reg, extension));
insn = get_insns ();
end_sequence ();
if (insn_invalid_p (insn))
return NULL;
return insn;
}
static int
eq_descriptor_pre_extension (const void *p1, const void *p2)
{
const struct see_pre_extension_expr *extension1 = p1;
const struct see_pre_extension_expr *extension2 = p2;
rtx set1 = single_set (extension1->se_insn);
rtx set2 = single_set (extension2->se_insn);
rtx rhs1, rhs2;
gcc_assert (set1 && set2);
rhs1 = SET_SRC (set1);
rhs2 = SET_SRC (set2);
return rtx_equal_p (rhs1, rhs2);
}
static hashval_t
hash_descriptor_pre_extension (const void *p)
{
const struct see_pre_extension_expr *extension = p;
rtx set = single_set (extension->se_insn);
rtx rhs;
gcc_assert (set);
rhs = SET_SRC (set);
return hash_rtx (rhs, GET_MODE (rhs), 0, NULL, 0);
}
static void
hash_del_pre_extension (void *p)
{
struct see_pre_extension_expr *extension = p;
struct see_occr *curr_occr = extension->antic_occr;
struct see_occr *next_occr = NULL;
while (curr_occr)
{
next_occr = curr_occr->next;
free (curr_occr);
curr_occr = next_occr;
}
curr_occr = extension->avail_occr;
while (curr_occr)
{
next_occr = curr_occr->next;
free (curr_occr);
curr_occr = next_occr;
}
free (extension);
}
static int
eq_descriptor_properties (const void *p1, const void *p2)
{
const struct see_register_properties *curr_prop1 = p1;
const struct see_register_properties *curr_prop2 = p2;
return curr_prop1->regno == curr_prop2->regno;
}
static hashval_t
hash_descriptor_properties (const void *p)
{
const struct see_register_properties *curr_prop = p;
return curr_prop->regno;
}
static void
hash_del_properties (void *p)
{
struct see_register_properties *curr_prop = p;
free (curr_prop);
}
static int
eq_descriptor_extension (const void *p1, const void *p2)
{
const rtx insn = (rtx) p1;
const rtx element = (rtx) p2;
rtx set1 = single_set (insn);
rtx dest_reg1;
rtx set2 = NULL;
rtx dest_reg2 = NULL;
gcc_assert (set1 && element && (REG_P (element) || INSN_P (element)));
dest_reg1 = SET_DEST (set1);
if (INSN_P (element))
{
set2 = single_set (element);
dest_reg2 = SET_DEST (set2);
}
else
dest_reg2 = element;
return REGNO (dest_reg1) == REGNO (dest_reg2);
}
static hashval_t
hash_descriptor_extension (const void *p)
{
const rtx r = (rtx) p;
rtx set, lhs;
if (r && REG_P (r))
return REGNO (r);
gcc_assert (r && INSN_P (r));
set = single_set (r);
gcc_assert (set);
lhs = SET_DEST (set);
return REGNO (lhs);
}
static void
see_free_ref_s (splay_tree_value value)
{
struct see_ref_s *ref_s = (struct see_ref_s *)value;
if (ref_s->unmerged_def_se_hash)
htab_delete (ref_s->unmerged_def_se_hash);
if (ref_s->merged_def_se_hash)
htab_delete (ref_s->merged_def_se_hash);
if (ref_s->use_se_hash)
htab_delete (ref_s->use_se_hash);
free (ref_s);
}
static struct see_pre_extension_expr *
see_seek_pre_extension_expr (rtx extension, enum extension_type type)
{
struct see_pre_extension_expr **slot_pre_exp, temp_pre_exp;
rtx dest_extension_reg = see_get_extension_reg (extension, 1);
enum rtx_code extension_code;
enum machine_mode source_extension_mode;
if (type == DEF_EXTENSION)
{
extension_code = see_get_extension_data (extension,
&source_extension_mode);
gcc_assert (extension_code != UNKNOWN);
extension =
see_gen_normalized_extension (dest_extension_reg, extension_code,
source_extension_mode);
}
temp_pre_exp.se_insn = extension;
slot_pre_exp =
(struct see_pre_extension_expr **) htab_find_slot (see_pre_extension_hash,
&temp_pre_exp, INSERT);
if (*slot_pre_exp == NULL)
{
(*slot_pre_exp) = xmalloc (sizeof (struct see_pre_extension_expr));
(*slot_pre_exp)->se_insn = extension;
(*slot_pre_exp)->bitmap_index =
(htab_elements (see_pre_extension_hash) - 1);
(*slot_pre_exp)->antic_occr = NULL;
(*slot_pre_exp)->avail_occr = NULL;
return NULL;
}
return *slot_pre_exp;
}
static bool
see_update_leader_extra_info (struct web_entry *first, struct web_entry *second)
{
struct see_entry_extra_info *first_ei, *second_ei;
first = unionfind_root (first);
second = unionfind_root (second);
if (unionfind_union (first, second))
return true;
first_ei = (struct see_entry_extra_info *) first->extra_info;
second_ei = (struct see_entry_extra_info *) second->extra_info;
gcc_assert (first_ei && second_ei);
if (second_ei->relevancy == NOT_RELEVANT)
{
first_ei->relevancy = NOT_RELEVANT;
return false;
}
switch (first_ei->relevancy)
{
case NOT_RELEVANT:
break;
case RELEVANT_USE:
switch (second_ei->relevancy)
{
case RELEVANT_USE:
break;
case EXTENDED_DEF:
first_ei->relevancy = second_ei->relevancy;
first_ei->source_mode_signed = second_ei->source_mode_signed;
first_ei->source_mode_unsigned = second_ei->source_mode_unsigned;
break;
case SIGN_EXTENDED_DEF:
case ZERO_EXTENDED_DEF:
first_ei->relevancy = second_ei->relevancy;
first_ei->source_mode = second_ei->source_mode;
break;
default:
gcc_unreachable ();
}
break;
case SIGN_EXTENDED_DEF:
switch (second_ei->relevancy)
{
case SIGN_EXTENDED_DEF:
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode) ?
first_ei->source_mode : second_ei->source_mode;
break;
case RELEVANT_USE:
break;
case ZERO_EXTENDED_DEF:
first_ei->relevancy = NOT_RELEVANT;
break;
case EXTENDED_DEF:
if (second_ei->source_mode_signed == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
else
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode_signed) ?
first_ei->source_mode : second_ei->source_mode_signed;
break;
default:
gcc_unreachable ();
}
break;
case ZERO_EXTENDED_DEF:
switch (second_ei->relevancy)
{
case SIGN_EXTENDED_DEF:
first_ei->relevancy = NOT_RELEVANT;
break;
case RELEVANT_USE:
break;
case ZERO_EXTENDED_DEF:
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode) ?
first_ei->source_mode : second_ei->source_mode;
break;
case EXTENDED_DEF:
if (second_ei->source_mode_unsigned == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
else
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode_unsigned) ?
first_ei->source_mode : second_ei->source_mode_unsigned;
break;
default:
gcc_unreachable ();
}
break;
case EXTENDED_DEF:
if (first_ei->source_mode_signed != MAX_MACHINE_MODE
&& first_ei->source_mode_unsigned != MAX_MACHINE_MODE)
{
switch (second_ei->relevancy)
{
case SIGN_EXTENDED_DEF:
first_ei->relevancy = SIGN_EXTENDED_DEF;
first_ei->source_mode =
(first_ei->source_mode_signed > second_ei->source_mode) ?
first_ei->source_mode_signed : second_ei->source_mode;
break;
case RELEVANT_USE:
break;
case ZERO_EXTENDED_DEF:
first_ei->relevancy = ZERO_EXTENDED_DEF;
first_ei->source_mode =
(first_ei->source_mode_unsigned > second_ei->source_mode) ?
first_ei->source_mode_unsigned : second_ei->source_mode;
break;
case EXTENDED_DEF:
if (second_ei->source_mode_unsigned != MAX_MACHINE_MODE)
first_ei->source_mode_unsigned =
(first_ei->source_mode_unsigned >
second_ei->source_mode_unsigned) ?
first_ei->source_mode_unsigned :
second_ei->source_mode_unsigned;
if (second_ei->source_mode_signed != MAX_MACHINE_MODE)
first_ei->source_mode_signed =
(first_ei->source_mode_signed >
second_ei->source_mode_signed) ?
first_ei->source_mode_signed : second_ei->source_mode_signed;
break;
default:
gcc_unreachable ();
}
}
else if (first_ei->source_mode_signed == MAX_MACHINE_MODE)
{
gcc_assert (first_ei->source_mode_unsigned != MAX_MACHINE_MODE);
switch (second_ei->relevancy)
{
case SIGN_EXTENDED_DEF:
first_ei->relevancy = NOT_RELEVANT;
break;
case RELEVANT_USE:
break;
case ZERO_EXTENDED_DEF:
first_ei->relevancy = ZERO_EXTENDED_DEF;
first_ei->source_mode =
(first_ei->source_mode_unsigned > second_ei->source_mode) ?
first_ei->source_mode_unsigned : second_ei->source_mode;
break;
case EXTENDED_DEF:
if (second_ei->source_mode_unsigned == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
else
first_ei->source_mode_unsigned =
(first_ei->source_mode_unsigned >
second_ei->source_mode_unsigned) ?
first_ei->source_mode_unsigned :
second_ei->source_mode_unsigned;
break;
default:
gcc_unreachable ();
}
}
else
{
gcc_assert (first_ei->source_mode_unsigned == MAX_MACHINE_MODE);
gcc_assert (first_ei->source_mode_signed != MAX_MACHINE_MODE);
switch (second_ei->relevancy)
{
case SIGN_EXTENDED_DEF:
first_ei->relevancy = SIGN_EXTENDED_DEF;
first_ei->source_mode =
(first_ei->source_mode_signed > second_ei->source_mode) ?
first_ei->source_mode_signed : second_ei->source_mode;
break;
case RELEVANT_USE:
break;
case ZERO_EXTENDED_DEF:
first_ei->relevancy = NOT_RELEVANT;
break;
case EXTENDED_DEF:
if (second_ei->source_mode_signed == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
else
first_ei->source_mode_signed =
(first_ei->source_mode_signed >
second_ei->source_mode_signed) ?
first_ei->source_mode_signed : second_ei->source_mode_signed;
break;
default:
gcc_unreachable ();
}
}
break;
default:
gcc_unreachable ();
}
return false;
}
static void
see_free_data_structures (void)
{
int i;
unsigned int j;
if (transp)
{
sbitmap_vector_free (transp);
transp = NULL;
sbitmap_vector_free (comp);
comp = NULL;
sbitmap_vector_free (antloc);
antloc = NULL;
sbitmap_vector_free (ae_kill);
ae_kill = NULL;
}
if (pre_insert_map)
{
sbitmap_vector_free (pre_insert_map);
pre_insert_map = NULL;
}
if (pre_delete_map)
{
sbitmap_vector_free (pre_delete_map);
pre_delete_map = NULL;
}
if (edge_list)
{
free_edge_list (edge_list);
edge_list = NULL;
}
htab_delete (see_pre_extension_hash);
for (i = 0; i < last_bb; i++)
if (see_bb_hash_ar[i])
htab_delete (see_bb_hash_ar[i]);
free (see_bb_hash_ar);
for (i = 0; i < last_bb; i++)
if (see_bb_splay_ar[i])
splay_tree_delete (see_bb_splay_ar[i]);
free (see_bb_splay_ar);
for (j = 0; j < defs_num; j++)
free (def_entry[j].extra_info);
free (def_entry);
for (j = 0; j < uses_num; j++)
free (use_entry[j].extra_info);
free (use_entry);
}
static void
see_initialize_data_structures (void)
{
df = df_init (DF_HARD_REGS | DF_EQUIV_NOTES | DF_SUBREGS);
df_rd_add_problem (df, 0);
df_chain_add_problem (df, DF_DU_CHAIN | DF_UD_CHAIN);
df_analyze (df);
if (dump_file)
df_dump (df, dump_file);
last_bb = last_basic_block;
uses_num = DF_USES_SIZE (df);
defs_num = DF_DEFS_SIZE (df);
def_entry = xcalloc (defs_num, sizeof (struct web_entry));
use_entry = xcalloc (uses_num, sizeof (struct web_entry));
see_bb_splay_ar = xcalloc (last_bb, sizeof (splay_tree));
see_bb_hash_ar = xcalloc (last_bb, sizeof (htab_t));
see_pre_extension_hash = htab_create (10,
hash_descriptor_pre_extension,
eq_descriptor_pre_extension,
hash_del_pre_extension);
}
static void
see_mentioned_reg (rtx *x, void *data)
{
struct see_mentioned_reg_data *d
= (struct see_mentioned_reg_data *) data;
if (reg_mentioned_p (d->reg, *x))
d->mentioned = true;
}
static bool
see_want_to_be_merged_with_extension (rtx ref, rtx extension,
enum extension_type type)
{
rtx pat;
rtx dest_extension_reg = see_get_extension_reg (extension, 1);
rtx source_extension_reg = see_get_extension_reg (extension, 0);
enum rtx_code code;
struct see_mentioned_reg_data d;
int i;
pat = PATTERN (ref);
code = GET_CODE (pat);
if (code == PARALLEL)
{
for (i = 0; i < XVECLEN (pat, 0); i++)
{
rtx sub = XVECEXP (pat, 0, i);
if (GET_CODE (sub) == SET
&& (REG_P (SET_DEST (sub))
|| (GET_CODE (SET_DEST (sub)) == SUBREG
&& REG_P (SUBREG_REG (SET_DEST (sub)))))
&& (REG_P (SET_SRC (sub))
|| (GET_CODE (SET_SRC (sub)) == SUBREG
&& REG_P (SUBREG_REG (SET_SRC (sub))))))
{
if (type == DEF_EXTENSION
&& reg_mentioned_p (source_extension_reg, SET_DEST (sub)))
return false;
}
else
{
if (type == USE_EXTENSION)
{
d.reg = dest_extension_reg;
d.mentioned = false;
note_uses (&sub, see_mentioned_reg, &d);
if (d.mentioned)
return true;
}
}
}
if (type == USE_EXTENSION)
return false;
}
else
{
if (code == SET
&& (REG_P (SET_DEST (pat))
|| (GET_CODE (SET_DEST (pat)) == SUBREG
&& REG_P (SUBREG_REG (SET_DEST (pat)))))
&& (REG_P (SET_SRC (pat))
|| (GET_CODE (SET_SRC (pat)) == SUBREG
&& REG_P (SUBREG_REG (SET_SRC (pat))))))
return false;
}
return true;
}
static int
see_print_register_properties (void **slot, void *b ATTRIBUTE_UNUSED)
{
struct see_register_properties *prop = *slot;
gcc_assert (prop);
fprintf (dump_file, "Property found for register %d\n", prop->regno);
return 1;
}
static int
see_print_pre_extension_expr (void **slot, void *b ATTRIBUTE_UNUSED)
{
struct see_pre_extension_expr *pre_extension = *slot;
gcc_assert (pre_extension
&& pre_extension->se_insn
&& INSN_P (pre_extension->se_insn));
fprintf (dump_file, "Index %d for:\n", pre_extension->bitmap_index);
print_rtl_single (dump_file, pre_extension->se_insn);
return 1;
}
static int
see_delete_merged_def_extension (void **slot, void *b ATTRIBUTE_UNUSED)
{
rtx def_se = *slot;
if (dump_file)
{
fprintf (dump_file, "Deleting merged def extension:\n");
print_rtl_single (dump_file, def_se);
}
if (INSN_DELETED_P (def_se))
return 1;
delete_insn (def_se);
return 1;
}
static int
see_delete_unmerged_def_extension (void **slot, void *b ATTRIBUTE_UNUSED)
{
rtx def_se = *slot;
if (dump_file)
{
fprintf (dump_file, "Deleting unmerged def extension:\n");
print_rtl_single (dump_file, def_se);
}
delete_insn (def_se);
return 1;
}
static int
see_emit_use_extension (void **slot, void *b)
{
rtx use_se = *slot;
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
if (INSN_DELETED_P (use_se))
return 1;
if (dump_file)
{
fprintf (dump_file, "Inserting use extension:\n");
print_rtl_single (dump_file, use_se);
}
add_insn_before (use_se, curr_ref_s->insn);
return 1;
}
static int
see_commit_ref_changes (splay_tree_node stn,
void *data ATTRIBUTE_UNUSED)
{
htab_t use_se_hash = ((struct see_ref_s *) (stn->value))->use_se_hash;
htab_t unmerged_def_se_hash =
((struct see_ref_s *) (stn->value))->unmerged_def_se_hash;
htab_t merged_def_se_hash =
((struct see_ref_s *) (stn->value))->merged_def_se_hash;
rtx ref = ((struct see_ref_s *) (stn->value))->insn;
rtx merged_ref = ((struct see_ref_s *) (stn->value))->merged_insn;
if (use_se_hash)
htab_traverse_noresize (use_se_hash, see_emit_use_extension,
(PTR) (stn->value));
if (unmerged_def_se_hash)
htab_traverse (unmerged_def_se_hash, see_delete_unmerged_def_extension,
(PTR) (stn->value));
if (merged_def_se_hash)
htab_traverse (merged_def_se_hash, see_delete_merged_def_extension,
(PTR) (stn->value));
if (merged_ref && !INSN_DELETED_P (ref))
{
if (dump_file)
{
fprintf (dump_file, "Replacing orig reference:\n");
print_rtl_single (dump_file, ref);
fprintf (dump_file, "With merged reference:\n");
print_rtl_single (dump_file, merged_ref);
}
emit_insn_after (merged_ref, ref);
delete_insn (ref);
}
return 0;
}
static bool
see_pre_insert_extensions (struct see_pre_extension_expr **index_map)
{
int num_edges = NUM_EDGES (edge_list);
int set_size = pre_insert_map[0]->size;
size_t pre_extension_num = htab_elements (see_pre_extension_hash);
int did_insert = 0;
int e;
int i;
int j;
for (e = 0; e < num_edges; e++)
{
int indx;
basic_block bb = INDEX_EDGE_PRED_BB (edge_list, e);
for (i = indx = 0; i < set_size; i++, indx += SBITMAP_ELT_BITS)
{
SBITMAP_ELT_TYPE insert = pre_insert_map[e]->elms[i];
for (j = indx; insert && j < (int) pre_extension_num;
j++, insert >>= 1)
if (insert & 1)
{
struct see_pre_extension_expr *expr = index_map[j];
int idx = expr->bitmap_index;
rtx se_insn = NULL;
edge eg = INDEX_EDGE (edge_list, e);
start_sequence ();
emit_insn (PATTERN (expr->se_insn));
se_insn = get_insns ();
end_sequence ();
if (eg->flags & EDGE_ABNORMAL)
{
rtx new_insn = NULL;
new_insn = insert_insn_end_bb_new (se_insn, bb);
gcc_assert (new_insn && INSN_P (new_insn));
if (dump_file)
{
fprintf (dump_file,
"PRE: end of bb %d, insn %d, ",
bb->index, INSN_UID (new_insn));
fprintf (dump_file,
"inserting expression %d\n", idx);
}
}
else
{
insert_insn_on_edge (se_insn, eg);
if (dump_file)
{
fprintf (dump_file, "PRE: edge (%d,%d), ",
bb->index,
INDEX_EDGE_SUCC_BB (edge_list, e)->index);
fprintf (dump_file, "inserting expression %d\n", idx);
}
}
did_insert = true;
}
}
}
return did_insert;
}
static int
see_pre_delete_extension (void **slot, void *b ATTRIBUTE_UNUSED)
{
struct see_pre_extension_expr *expr = *slot;
struct see_occr *occr;
int indx = expr->bitmap_index;
for (occr = expr->antic_occr; occr != NULL; occr = occr->next)
{
if (TEST_BIT (pre_delete_map[occr->block_num], indx))
{
INSN_DELETED_P (occr->insn) = 1;
if (dump_file)
{
fprintf (dump_file,"Redundant extension deleted:\n");
print_rtl_single (dump_file, occr->insn);
}
}
}
return 1;
}
static int
see_map_extension (void **slot, void *b)
{
struct see_pre_extension_expr *expr = *slot;
struct see_pre_extension_expr **index_map =
(struct see_pre_extension_expr **) b;
index_map[expr->bitmap_index] = expr;
return 1;
}
static void
see_commit_changes (void)
{
struct see_pre_extension_expr **index_map;
size_t pre_extension_num = htab_elements (see_pre_extension_hash);
bool did_insert = false;
int i;
index_map = xcalloc (pre_extension_num,
sizeof (struct see_pre_extension_expr *));
if (dump_file)
fprintf (dump_file,
"* Phase 4: Commit changes to the insn stream. *\n");
htab_traverse (see_pre_extension_hash, see_map_extension, (PTR) index_map);
htab_traverse (see_pre_extension_hash, see_pre_delete_extension, NULL);
df_finish (df);
df = NULL;
did_insert = see_pre_insert_extensions (index_map);
if (did_insert)
commit_edge_insertions ();
for (i = 0; i < last_bb; i++)
{
if (see_bb_splay_ar[i])
{
splay_tree_foreach (see_bb_splay_ar[i],
see_commit_ref_changes, NULL);
}
}
free (index_map);
}
static int
see_analyze_merged_def_local_prop (void **slot, void *b)
{
rtx def_se = *slot;
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx ref = curr_ref_s->insn;
struct see_pre_extension_expr *extension_expr;
int indx;
int bb_num = BLOCK_NUM (ref);
htab_t curr_bb_hash;
struct see_register_properties *curr_prop, **slot_prop;
struct see_register_properties temp_prop;
rtx dest_extension_reg = see_get_extension_reg (def_se, 1);
struct see_occr *curr_occr = NULL;
struct see_occr *tmp_occr = NULL;
extension_expr = see_seek_pre_extension_expr (def_se, DEF_EXTENSION);
gcc_assert (extension_expr);
curr_bb_hash = see_bb_hash_ar[bb_num];
gcc_assert (curr_bb_hash);
temp_prop.regno = REGNO (dest_extension_reg);
slot_prop =
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
curr_prop = *slot_prop;
gcc_assert (curr_prop);
indx = extension_expr->bitmap_index;
RESET_BIT (transp[bb_num], indx);
RESET_BIT (ae_kill[bb_num], indx);
if (curr_prop->first_se_after_last_def == DF_INSN_LUID (df, ref))
{
SET_BIT (comp[bb_num], indx);
curr_occr = xmalloc (sizeof (struct see_occr));
curr_occr->next = NULL;
curr_occr->insn = def_se;
curr_occr->block_num = bb_num;
tmp_occr = extension_expr->avail_occr;
if (!tmp_occr)
extension_expr->avail_occr = curr_occr;
else
{
while (tmp_occr->next)
tmp_occr = tmp_occr->next;
tmp_occr->next = curr_occr;
}
}
return 1;
}
static int
see_analyze_unmerged_def_local_prop (void **slot, void *b)
{
rtx def_se = *slot;
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx ref = curr_ref_s->insn;
struct see_pre_extension_expr *extension_expr;
int indx;
int bb_num = BLOCK_NUM (ref);
htab_t curr_bb_hash;
struct see_register_properties *curr_prop, **slot_prop;
struct see_register_properties temp_prop;
rtx dest_extension_reg = see_get_extension_reg (def_se, 1);
extension_expr = see_seek_pre_extension_expr (def_se, DEF_EXTENSION);
gcc_assert (extension_expr);
curr_bb_hash = see_bb_hash_ar[bb_num];
gcc_assert (curr_bb_hash);
temp_prop.regno = REGNO (dest_extension_reg);
slot_prop =
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
curr_prop = *slot_prop;
gcc_assert (curr_prop);
indx = extension_expr->bitmap_index;
RESET_BIT (transp[bb_num], indx);
SET_BIT (ae_kill[bb_num], indx);
return 1;
}
static int
see_analyze_use_local_prop (void **slot, void *b)
{
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx use_se = *slot;
rtx ref = curr_ref_s->insn;
rtx dest_extension_reg = see_get_extension_reg (use_se, 1);
struct see_pre_extension_expr *extension_expr;
struct see_register_properties *curr_prop, **slot_prop;
struct see_register_properties temp_prop;
struct see_occr *curr_occr = NULL;
struct see_occr *tmp_occr = NULL;
htab_t curr_bb_hash;
int indx;
int bb_num = BLOCK_NUM (ref);
extension_expr = see_seek_pre_extension_expr (use_se, USE_EXTENSION);
gcc_assert (extension_expr);
curr_bb_hash = see_bb_hash_ar[bb_num];
gcc_assert (curr_bb_hash);
temp_prop.regno = REGNO (dest_extension_reg);
slot_prop =
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
curr_prop = *slot_prop;
gcc_assert (curr_prop);
indx = extension_expr->bitmap_index;
if (curr_prop->first_se_before_any_def == DF_INSN_LUID (df, ref))
{
SET_BIT (antloc[bb_num], indx);
curr_occr = xmalloc (sizeof (struct see_occr));
curr_occr->next = NULL;
curr_occr->insn = use_se;
curr_occr->block_num = bb_num;
tmp_occr = extension_expr->antic_occr;
if (!tmp_occr)
extension_expr->antic_occr = curr_occr;
else
{
while (tmp_occr->next)
tmp_occr = tmp_occr->next;
tmp_occr->next = curr_occr;
}
if (curr_prop->last_def < 0)
{
SET_BIT (comp[bb_num], indx);
curr_occr = xmalloc (sizeof (struct see_occr));
curr_occr->next = NULL;
curr_occr->insn = use_se;
curr_occr->block_num = bb_num;
tmp_occr = extension_expr->avail_occr;
if (!tmp_occr)
extension_expr->avail_occr = curr_occr;
else
{
while (tmp_occr->next)
tmp_occr = tmp_occr->next;
tmp_occr->next = curr_occr;
}
}
}
else if (curr_prop->first_se_after_last_def == DF_INSN_LUID (df, ref))
{
SET_BIT (comp[bb_num], indx);
RESET_BIT (ae_kill[bb_num], indx);
curr_occr = xmalloc (sizeof (struct see_occr));
curr_occr->next = NULL;
curr_occr->insn = use_se;
curr_occr->block_num = bb_num;
tmp_occr = extension_expr->avail_occr;
if (!tmp_occr)
extension_expr->avail_occr = curr_occr;
else
{
while (tmp_occr->next)
tmp_occr = tmp_occr->next;
tmp_occr->next = curr_occr;
}
}
return 1;
}
static int
see_analyze_ref_local_prop (splay_tree_node stn,
void *data ATTRIBUTE_UNUSED)
{
htab_t use_se_hash = ((struct see_ref_s *) (stn->value))->use_se_hash;
htab_t unmerged_def_se_hash =
((struct see_ref_s *) (stn->value))->unmerged_def_se_hash;
htab_t merged_def_se_hash =
((struct see_ref_s *) (stn->value))->merged_def_se_hash;
if (use_se_hash)
htab_traverse_noresize (use_se_hash, see_analyze_use_local_prop,
(PTR) (stn->value));
if (unmerged_def_se_hash)
htab_traverse (unmerged_def_se_hash, see_analyze_unmerged_def_local_prop,
(PTR) (stn->value));
if (merged_def_se_hash)
htab_traverse (merged_def_se_hash, see_analyze_merged_def_local_prop,
(PTR) (stn->value));
return 0;
}
static void
see_execute_LCM (void)
{
size_t pre_extension_num = htab_elements (see_pre_extension_hash);
int i = 0;
if (dump_file)
fprintf (dump_file,
"* Phase 3: Eliminate globally redundant extensions. *\n");
transp = sbitmap_vector_alloc (last_bb, pre_extension_num);
comp = sbitmap_vector_alloc (last_bb, pre_extension_num);
antloc = sbitmap_vector_alloc (last_bb, pre_extension_num);
ae_kill = sbitmap_vector_alloc (last_bb, pre_extension_num);
sbitmap_vector_ones (transp, last_bb);
sbitmap_vector_zero (comp, last_bb);
sbitmap_vector_zero (antloc, last_bb);
sbitmap_vector_zero (ae_kill, last_bb);
for (i = 0; i < last_bb; i++)
{
if (see_bb_splay_ar[i])
{
splay_tree_foreach (see_bb_splay_ar[i],
see_analyze_ref_local_prop, NULL);
}
}
add_noreturn_fake_exit_edges ();
edge_list = pre_edge_lcm (pre_extension_num, transp, comp, antloc,
ae_kill, &pre_insert_map, &pre_delete_map);
remove_fake_exit_edges ();
}
static int
see_set_prop_merged_def (void **slot, void *b)
{
rtx def_se = *slot;
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx insn = curr_ref_s->insn;
rtx dest_extension_reg = see_get_extension_reg (def_se, 1);
htab_t curr_bb_hash;
struct see_register_properties *curr_prop = NULL;
struct see_register_properties **slot_prop;
struct see_register_properties temp_prop;
int ref_luid = DF_INSN_LUID (df, insn);
curr_bb_hash = see_bb_hash_ar[BLOCK_NUM (curr_ref_s->insn)];
if (!curr_bb_hash)
{
curr_bb_hash = htab_create (10,
hash_descriptor_properties,
eq_descriptor_properties,
hash_del_properties);
see_bb_hash_ar[BLOCK_NUM (curr_ref_s->insn)] = curr_bb_hash;
}
temp_prop.regno = REGNO (dest_extension_reg);
slot_prop =
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
if (slot_prop && *slot_prop != NULL)
{
curr_prop = *slot_prop;
gcc_assert (curr_prop->regno == REGNO (dest_extension_reg));
curr_prop->last_def = ref_luid;
curr_prop->first_se_after_last_def = ref_luid;
}
else
{
curr_prop = xmalloc (sizeof (struct see_register_properties));
curr_prop->regno = REGNO (dest_extension_reg);
curr_prop->last_def = ref_luid;
curr_prop->first_se_before_any_def = -1;
curr_prop->first_se_after_last_def = ref_luid;
*slot_prop = curr_prop;
}
see_seek_pre_extension_expr (def_se, DEF_EXTENSION);
return 1;
}
static int
see_set_prop_unmerged_def (void **slot, void *b)
{
rtx def_se = *slot;
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx insn = curr_ref_s->insn;
rtx dest_extension_reg = see_get_extension_reg (def_se, 1);
htab_t curr_bb_hash;
struct see_register_properties *curr_prop = NULL;
struct see_register_properties **slot_prop;
struct see_register_properties temp_prop;
int ref_luid = DF_INSN_LUID (df, insn);
curr_bb_hash = see_bb_hash_ar[BLOCK_NUM (curr_ref_s->insn)];
if (!curr_bb_hash)
{
curr_bb_hash = htab_create (10,
hash_descriptor_properties,
eq_descriptor_properties,
hash_del_properties);
see_bb_hash_ar[BLOCK_NUM (curr_ref_s->insn)] = curr_bb_hash;
}
temp_prop.regno = REGNO (dest_extension_reg);
slot_prop =
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
if (slot_prop && *slot_prop != NULL)
{
curr_prop = *slot_prop;
gcc_assert (curr_prop->regno == REGNO (dest_extension_reg));
curr_prop->last_def = ref_luid;
curr_prop->first_se_after_last_def = -1;
}
else
{
curr_prop = xmalloc (sizeof (struct see_register_properties));
curr_prop->regno = REGNO (dest_extension_reg);
curr_prop->last_def = ref_luid;
curr_prop->first_se_before_any_def = -1;
curr_prop->first_se_after_last_def = -1;
*slot_prop = curr_prop;
}
see_seek_pre_extension_expr (def_se, DEF_EXTENSION);
return 1;
}
static int
see_set_prop_unmerged_use (void **slot, void *b)
{
rtx use_se = *slot;
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx insn = curr_ref_s->insn;
rtx dest_extension_reg = see_get_extension_reg (use_se, 1);
htab_t curr_bb_hash;
struct see_register_properties *curr_prop = NULL;
struct see_register_properties **slot_prop;
struct see_register_properties temp_prop;
bool locally_redundant = false;
int ref_luid = DF_INSN_LUID (df, insn);
curr_bb_hash = see_bb_hash_ar[BLOCK_NUM (curr_ref_s->insn)];
if (!curr_bb_hash)
{
curr_bb_hash = htab_create (10,
hash_descriptor_properties,
eq_descriptor_properties,
hash_del_properties);
see_bb_hash_ar[BLOCK_NUM (curr_ref_s->insn)] = curr_bb_hash;
}
temp_prop.regno = REGNO (dest_extension_reg);
slot_prop =
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
if (slot_prop && *slot_prop != NULL)
{
curr_prop = *slot_prop;
gcc_assert (curr_prop->regno == REGNO (dest_extension_reg));
if (curr_prop->last_def < 0 && curr_prop->first_se_before_any_def < 0)
curr_prop->first_se_before_any_def = ref_luid;
else if (curr_prop->last_def < 0
&& curr_prop->first_se_before_any_def >= 0)
{
htab_clear_slot (curr_ref_s->use_se_hash, (PTR *)slot);
locally_redundant = true;
}
else if (curr_prop->last_def >= 0
&& curr_prop->first_se_after_last_def < 0)
curr_prop->first_se_after_last_def = ref_luid;
else if (curr_prop->last_def >= 0
&& curr_prop->first_se_after_last_def >= 0)
{
htab_clear_slot (curr_ref_s->use_se_hash, (PTR *)slot);
locally_redundant = true;
}
else
gcc_unreachable ();
}
else
{
curr_prop = xmalloc (sizeof (struct see_register_properties));
curr_prop->regno = REGNO (dest_extension_reg);
curr_prop->last_def = -1;
curr_prop->first_se_before_any_def = ref_luid;
curr_prop->first_se_after_last_def = -1;
*slot_prop = curr_prop;
}
if (!locally_redundant)
see_seek_pre_extension_expr (use_se, USE_EXTENSION);
if (locally_redundant && dump_file)
{
fprintf (dump_file, "Locally redundant extension:\n");
print_rtl_single (dump_file, use_se);
}
return 1;
}
static int
see_print_one_extension (void **slot, void *b ATTRIBUTE_UNUSED)
{
rtx def_se = *slot;
gcc_assert (def_se && INSN_P (def_se));
print_rtl_single (dump_file, def_se);
return 1;
}
static void
see_replace_src (rtx *x, void *data)
{
struct see_replace_data *d
= (struct see_replace_data *) data;
*x = replace_rtx (*x, d->from, d->to);
}
static void
see_def_extension_not_merged (struct see_ref_s *curr_ref_s, rtx def_se)
{
struct see_replace_data d;
rtx ref = (curr_ref_s->merged_insn) ? curr_ref_s->merged_insn :
curr_ref_s->insn;
rtx merged_ref_next = (curr_ref_s->merged_insn) ?
NEXT_INSN (curr_ref_s->merged_insn): NULL_RTX;
rtx ref_copy = copy_rtx (ref);
rtx source_extension_reg = see_get_extension_reg (def_se, 0);
rtx dest_extension_reg = see_get_extension_reg (def_se, 1);
rtx move_insn = NULL;
rtx set, rhs;
rtx dest_reg, dest_real_reg;
rtx new_pseudo_reg, subreg;
enum machine_mode source_extension_mode = GET_MODE (source_extension_reg);
enum machine_mode dest_mode;
set = single_set (def_se);
gcc_assert (set);
rhs = SET_SRC (set);
gcc_assert (GET_CODE (rhs) == SIGN_EXTEND
|| GET_CODE (rhs) == ZERO_EXTEND);
dest_reg = XEXP (rhs, 0);
gcc_assert (REG_P (dest_reg)
|| (GET_CODE (dest_reg) == SUBREG
&& REG_P (SUBREG_REG (dest_reg))));
dest_real_reg = REG_P (dest_reg) ? dest_reg : SUBREG_REG (dest_reg);
dest_mode = GET_MODE (dest_reg);
subreg = gen_lowpart_SUBREG (dest_mode, dest_extension_reg);
new_pseudo_reg = gen_reg_rtx (source_extension_mode);
d.from = dest_real_reg;
d.to = new_pseudo_reg;
note_uses (&PATTERN (ref_copy), see_replace_src, &d);
ref_copy = replace_rtx (ref_copy, dest_reg, subreg);
d.from = new_pseudo_reg;
d.to = dest_real_reg;
note_uses (&PATTERN (ref_copy), see_replace_src, &d);
if (rtx_equal_p (PATTERN (ref), PATTERN (ref_copy))
|| insn_invalid_p (ref_copy))
{
ref_copy = copy_rtx (ref);
start_sequence ();
emit_move_insn (subreg, dest_reg);
move_insn = get_insns ();
end_sequence ();
PREV_INSN (ref_copy) = NULL_RTX;
NEXT_INSN (ref_copy) = move_insn;
PREV_INSN (move_insn) = ref_copy;
NEXT_INSN (move_insn) = merged_ref_next;
if (merged_ref_next != NULL_RTX)
PREV_INSN (merged_ref_next) = move_insn;
curr_ref_s->merged_insn = ref_copy;
if (dump_file)
{
fprintf (dump_file, "Following def merge failure a move ");
fprintf (dump_file, "insn was added after the ref.\n");
fprintf (dump_file, "Original ref:\n");
print_rtl_single (dump_file, ref);
fprintf (dump_file, "Move insn that was added:\n");
print_rtl_single (dump_file, move_insn);
}
return;
}
validate_simplify_insn (ref_copy);
start_sequence ();
emit_move_insn (dest_reg, subreg);
move_insn = get_insns ();
end_sequence ();
PREV_INSN (ref_copy) = NULL_RTX;
NEXT_INSN (ref_copy) = move_insn;
PREV_INSN (move_insn) = ref_copy;
NEXT_INSN (move_insn) = merged_ref_next;
if (merged_ref_next != NULL_RTX)
PREV_INSN (merged_ref_next) = move_insn;
curr_ref_s->merged_insn = ref_copy;
if (dump_file)
{
fprintf (dump_file, "Following merge failure the ref was transformed!\n");
fprintf (dump_file, "Original ref:\n");
print_rtl_single (dump_file, ref);
fprintf (dump_file, "Transformed ref:\n");
print_rtl_single (dump_file, ref_copy);
fprintf (dump_file, "Move insn that was added:\n");
print_rtl_single (dump_file, move_insn);
}
}
static int
see_merge_one_use_extension (void **slot, void *b)
{
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx use_se = *slot;
rtx ref = (curr_ref_s->merged_insn) ? curr_ref_s->merged_insn :
curr_ref_s->insn;
rtx merged_ref_next = (curr_ref_s->merged_insn) ?
NEXT_INSN (curr_ref_s->merged_insn): NULL_RTX;
rtx ref_copy = copy_rtx (ref);
rtx extension_set = single_set (use_se);
rtx extension_rhs = NULL;
rtx dest_extension_reg = see_get_extension_reg (use_se, 1);
rtx note = NULL;
rtx simplified_note = NULL;
gcc_assert (use_se && curr_ref_s && extension_set);
extension_rhs = SET_SRC (extension_set);
note = find_reg_equal_equiv_note (ref_copy);
if (note)
{
simplified_note = simplify_replace_rtx (XEXP (note, 0),
dest_extension_reg,
extension_rhs);
if (rtx_equal_p (XEXP (note, 0), simplified_note))
remove_note (ref_copy, note);
else
XEXP (note, 0) = simplified_note;
}
if (!see_want_to_be_merged_with_extension (ref, use_se, USE_EXTENSION))
{
if (dump_file)
{
fprintf (dump_file, "Use merge skipped!\n");
fprintf (dump_file, "Original instructions:\n");
print_rtl_single (dump_file, use_se);
print_rtl_single (dump_file, ref);
}
return 1;
}
validate_replace_src_group (dest_extension_reg, extension_rhs, ref_copy);
if (!num_changes_pending ())
{
if (dump_file)
{
fprintf (dump_file, "Use extension not necessary before:\n");
print_rtl_single (dump_file, ref);
}
htab_clear_slot (curr_ref_s->use_se_hash, (PTR *)slot);
PREV_INSN (ref_copy) = NULL_RTX;
NEXT_INSN (ref_copy) = merged_ref_next;
if (merged_ref_next != NULL_RTX)
PREV_INSN (merged_ref_next) = ref_copy;
curr_ref_s->merged_insn = ref_copy;
return 1;
}
if (!apply_change_group ())
{
if (dump_file)
{
fprintf (dump_file, "Use merge failed!\n");
fprintf (dump_file, "Original instructions:\n");
print_rtl_single (dump_file, use_se);
print_rtl_single (dump_file, ref);
}
return 1;
}
validate_simplify_insn (ref_copy);
PREV_INSN (ref_copy) = NULL_RTX;
NEXT_INSN (ref_copy) = merged_ref_next;
if (merged_ref_next != NULL_RTX)
PREV_INSN (merged_ref_next) = ref_copy;
curr_ref_s->merged_insn = ref_copy;
if (dump_file)
{
fprintf (dump_file, "Use merge succeeded!\n");
fprintf (dump_file, "Original instructions:\n");
print_rtl_single (dump_file, use_se);
print_rtl_single (dump_file, ref);
fprintf (dump_file, "Merged instruction:\n");
print_rtl_single (dump_file, ref_copy);
}
htab_clear_slot (curr_ref_s->use_se_hash, (PTR *)slot);
return 1;
}
static int
see_merge_one_def_extension (void **slot, void *b)
{
struct see_ref_s *curr_ref_s = (struct see_ref_s *) b;
rtx def_se = *slot;
rtx ref = (curr_ref_s->merged_insn) ? curr_ref_s->merged_insn :
curr_ref_s->insn;
rtx merged_ref_next = (curr_ref_s->merged_insn) ?
NEXT_INSN (curr_ref_s->merged_insn): NULL_RTX;
rtx ref_copy = copy_rtx (ref);
rtx new_set = NULL;
rtx source_extension_reg = see_get_extension_reg (def_se, 0);
rtx dest_extension_reg = see_get_extension_reg (def_se, 1);
rtx move_insn, *rtx_slot, subreg;
rtx temp_extension = NULL;
rtx simplified_temp_extension = NULL;
rtx *pat;
enum rtx_code code;
enum rtx_code extension_code;
enum machine_mode source_extension_mode;
enum machine_mode source_mode;
enum machine_mode dest_extension_mode;
bool merge_success = false;
int i;
gcc_assert (def_se
&& INSN_P (def_se)
&& curr_ref_s
&& ref
&& INSN_P (ref));
if (!see_want_to_be_merged_with_extension (ref, def_se, DEF_EXTENSION))
{
if (dump_file)
{
fprintf (dump_file, "Def merge skipped!\n");
fprintf (dump_file, "Original instructions:\n");
print_rtl_single (dump_file, ref);
print_rtl_single (dump_file, def_se);
}
see_def_extension_not_merged (curr_ref_s, def_se);
return 1;
}
extension_code = see_get_extension_data (def_se, &source_mode);
source_extension_mode = GET_MODE (source_extension_reg);
dest_extension_mode = GET_MODE (dest_extension_reg);
pat = &PATTERN (ref_copy);
code = GET_CODE (*pat);
if (code == PARALLEL)
{
bool need_to_apply_change = false;
for (i = 0; i < XVECLEN (*pat, 0); i++)
{
rtx *sub = &XVECEXP (*pat, 0, i);
if (GET_CODE (*sub) == SET
&& GET_MODE (SET_SRC (*sub)) != VOIDmode
&& GET_MODE (SET_DEST (*sub)) == source_mode
&& ((REG_P (SET_DEST (*sub))
&& REGNO (SET_DEST (*sub)) == REGNO (source_extension_reg))
|| (GET_CODE (SET_DEST (*sub)) == SUBREG
&& REG_P (SUBREG_REG (SET_DEST (*sub)))
&& (REGNO (SUBREG_REG (SET_DEST (*sub))) ==
REGNO (source_extension_reg)))))
{
rtx orig_src = SET_SRC (*sub);
if (extension_code == SIGN_EXTEND)
temp_extension = gen_rtx_SIGN_EXTEND (dest_extension_mode,
orig_src);
else
temp_extension = gen_rtx_ZERO_EXTEND (dest_extension_mode,
orig_src);
simplified_temp_extension = simplify_rtx (temp_extension);
temp_extension =
(simplified_temp_extension) ? simplified_temp_extension :
temp_extension;
new_set = gen_rtx_SET (VOIDmode, dest_extension_reg,
temp_extension);
validate_change (ref_copy, sub, new_set, 1);
need_to_apply_change = true;
}
}
if (need_to_apply_change)
if (apply_change_group ())
merge_success = true;
}
else if (code == SET
&& GET_MODE (SET_SRC (*pat)) != VOIDmode
&& GET_MODE (SET_DEST (*pat)) == source_mode
&& ((REG_P (SET_DEST (*pat))
&& REGNO (SET_DEST (*pat)) == REGNO (source_extension_reg))
|| (GET_CODE (SET_DEST (*pat)) == SUBREG
&& REG_P (SUBREG_REG (SET_DEST (*pat)))
&& (REGNO (SUBREG_REG (SET_DEST (*pat))) ==
REGNO (source_extension_reg)))))
{
rtx orig_src = SET_SRC (*pat);
if (extension_code == SIGN_EXTEND)
temp_extension = gen_rtx_SIGN_EXTEND (dest_extension_mode, orig_src);
else
temp_extension = gen_rtx_ZERO_EXTEND (dest_extension_mode, orig_src);
simplified_temp_extension = simplify_rtx (temp_extension);
temp_extension = (simplified_temp_extension) ? simplified_temp_extension :
temp_extension;
new_set = gen_rtx_SET (VOIDmode, dest_extension_reg, temp_extension);
if (validate_change (ref_copy, pat, new_set, 0))
merge_success = true;
}
if (!merge_success)
{
if (dump_file)
{
fprintf (dump_file, "Def merge failed!\n");
fprintf (dump_file, "Original instructions:\n");
print_rtl_single (dump_file, ref);
print_rtl_single (dump_file, def_se);
}
see_def_extension_not_merged (curr_ref_s, def_se);
return 1;
}
subreg = gen_lowpart_SUBREG (source_extension_mode, dest_extension_reg);
start_sequence ();
emit_move_insn (source_extension_reg, subreg);
move_insn = get_insns ();
end_sequence ();
PREV_INSN (ref_copy) = NULL_RTX;
NEXT_INSN (ref_copy) = move_insn;
PREV_INSN (move_insn) = ref_copy;
NEXT_INSN (move_insn) = merged_ref_next;
if (merged_ref_next != NULL_RTX)
PREV_INSN (merged_ref_next) = move_insn;
curr_ref_s->merged_insn = ref_copy;
if (dump_file)
{
fprintf (dump_file, "Def merge succeeded!\n");
fprintf (dump_file, "Original instructions:\n");
print_rtl_single (dump_file, ref);
print_rtl_single (dump_file, def_se);
fprintf (dump_file, "Merged instruction:\n");
print_rtl_single (dump_file, ref_copy);
fprintf (dump_file, "Move instruction that was added:\n");
print_rtl_single (dump_file, move_insn);
}
htab_clear_slot (curr_ref_s->unmerged_def_se_hash, (PTR *)slot);
if (!curr_ref_s->merged_def_se_hash)
curr_ref_s->merged_def_se_hash = htab_create (10,
hash_descriptor_extension,
eq_descriptor_extension,
NULL);
rtx_slot = (rtx *) htab_find_slot (curr_ref_s->merged_def_se_hash,
dest_extension_reg, INSERT);
gcc_assert (*rtx_slot == NULL);
*rtx_slot = def_se;
return 1;
}
static int
see_handle_extensions_for_one_ref (splay_tree_node stn,
void *data ATTRIBUTE_UNUSED)
{
htab_t use_se_hash = ((struct see_ref_s *) (stn->value))->use_se_hash;
htab_t unmerged_def_se_hash =
((struct see_ref_s *) (stn->value))->unmerged_def_se_hash;
htab_t merged_def_se_hash;
rtx ref = ((struct see_ref_s *) (stn->value))->insn;
if (dump_file)
{
fprintf (dump_file, "Handling ref:\n");
print_rtl_single (dump_file, ref);
}
if (unmerged_def_se_hash)
htab_traverse_noresize (unmerged_def_se_hash, see_merge_one_def_extension,
(PTR) (stn->value));
if (use_se_hash)
htab_traverse_noresize (use_se_hash, see_merge_one_use_extension,
(PTR) (stn->value));
merged_def_se_hash = ((struct see_ref_s *) (stn->value))->merged_def_se_hash;
if (dump_file)
{
fprintf (dump_file, "The hashes of the current reference:\n");
if (unmerged_def_se_hash)
{
fprintf (dump_file, "unmerged_def_se_hash:\n");
htab_traverse (unmerged_def_se_hash, see_print_one_extension, NULL);
}
if (merged_def_se_hash)
{
fprintf (dump_file, "merged_def_se_hash:\n");
htab_traverse (merged_def_se_hash, see_print_one_extension, NULL);
}
if (use_se_hash)
{
fprintf (dump_file, "use_se_hash:\n");
htab_traverse (use_se_hash, see_print_one_extension, NULL);
}
}
if (use_se_hash)
htab_traverse_noresize (use_se_hash, see_set_prop_unmerged_use,
(PTR) (stn->value));
if (unmerged_def_se_hash)
htab_traverse (unmerged_def_se_hash, see_set_prop_unmerged_def,
(PTR) (stn->value));
if (merged_def_se_hash)
htab_traverse (merged_def_se_hash, see_set_prop_merged_def,
(PTR) (stn->value));
return 0;
}
static void
see_merge_and_eliminate_extensions (void)
{
int i = 0;
if (dump_file)
fprintf (dump_file,
"* Phase 2: Merge and eliminate locally redundant extensions. *\n");
for (i = 0; i < last_bb; i++)
{
if (see_bb_splay_ar[i])
{
if (dump_file)
fprintf (dump_file, "Handling references for bb %d\n", i);
splay_tree_foreach (see_bb_splay_ar[i],
see_handle_extensions_for_one_ref, NULL);
}
}
}
static bool
see_store_reference_and_extension (rtx ref_insn, rtx se_insn,
enum extension_type type)
{
rtx *rtx_slot;
int curr_bb_num;
splay_tree_node stn = NULL;
htab_t se_hash = NULL;
struct see_ref_s *ref_s = NULL;
gcc_assert (ref_insn && se_insn);
if (!see_bb_splay_ar)
return false;
curr_bb_num = BLOCK_NUM (ref_insn);
gcc_assert (curr_bb_num < last_bb && curr_bb_num >= 0);
if (!see_bb_splay_ar[curr_bb_num])
see_bb_splay_ar[curr_bb_num] = splay_tree_new (splay_tree_compare_ints,
NULL, see_free_ref_s);
else
{
stn = splay_tree_lookup (see_bb_splay_ar[curr_bb_num],
DF_INSN_LUID (df, ref_insn));
if (stn)
switch (type)
{
case EXPLICIT_DEF_EXTENSION:
se_hash =
((struct see_ref_s *) (stn->value))->unmerged_def_se_hash;
if (!se_hash)
{
se_hash = htab_create (10,
hash_descriptor_extension,
eq_descriptor_extension,
NULL);
((struct see_ref_s *) (stn->value))->unmerged_def_se_hash =
se_hash;
}
break;
case IMPLICIT_DEF_EXTENSION:
se_hash = ((struct see_ref_s *) (stn->value))->merged_def_se_hash;
if (!se_hash)
{
se_hash = htab_create (10,
hash_descriptor_extension,
eq_descriptor_extension,
NULL);
((struct see_ref_s *) (stn->value))->merged_def_se_hash =
se_hash;
}
break;
case USE_EXTENSION:
se_hash = ((struct see_ref_s *) (stn->value))->use_se_hash;
if (!se_hash)
{
se_hash = htab_create (10,
hash_descriptor_extension,
eq_descriptor_extension,
NULL);
((struct see_ref_s *) (stn->value))->use_se_hash = se_hash;
}
break;
default:
gcc_unreachable ();
}
}
if (!stn)
{
ref_s = xmalloc (sizeof (struct see_ref_s));
ref_s->luid = DF_INSN_LUID (df, ref_insn);
ref_s->insn = ref_insn;
ref_s->merged_insn = NULL;
switch (type)
{
case EXPLICIT_DEF_EXTENSION:
ref_s->unmerged_def_se_hash = htab_create (10,
hash_descriptor_extension,
eq_descriptor_extension,
NULL);
se_hash = ref_s->unmerged_def_se_hash;
ref_s->merged_def_se_hash = NULL;
ref_s->use_se_hash = NULL;
break;
case IMPLICIT_DEF_EXTENSION:
ref_s->merged_def_se_hash = htab_create (10,
hash_descriptor_extension,
eq_descriptor_extension,
NULL);
se_hash = ref_s->merged_def_se_hash;
ref_s->unmerged_def_se_hash = NULL;
ref_s->use_se_hash = NULL;
break;
case USE_EXTENSION:
ref_s->use_se_hash = htab_create (10,
hash_descriptor_extension,
eq_descriptor_extension,
NULL);
se_hash = ref_s->use_se_hash;
ref_s->unmerged_def_se_hash = NULL;
ref_s->merged_def_se_hash = NULL;
break;
default:
gcc_unreachable ();
}
}
rtx_slot = (rtx *) htab_find_slot (se_hash, se_insn, INSERT);
if (*rtx_slot != NULL)
{
gcc_assert (type == USE_EXTENSION);
gcc_assert (rtx_equal_p (PATTERN (*rtx_slot), PATTERN (se_insn)));
}
else
*rtx_slot = se_insn;
if (!stn)
splay_tree_insert (see_bb_splay_ar[curr_bb_num],
DF_INSN_LUID (df, ref_insn), (splay_tree_value) ref_s);
return true;
}
static int
see_handle_relevant_defs (void)
{
rtx insn = NULL;
rtx se_insn = NULL;
rtx reg = NULL;
rtx ref_insn = NULL;
struct web_entry *root_entry = NULL;
unsigned int i;
int num_relevant_defs = 0;
enum rtx_code extension_code;
for (i = 0; i < defs_num; i++)
{
insn = DF_REF_INSN (DF_DEFS_GET (df, i));
reg = DF_REF_REAL_REG (DF_DEFS_GET (df, i));
if (!insn)
continue;
if (!INSN_P (insn))
continue;
root_entry = unionfind_root (&def_entry[i]);
if (ENTRY_EI (root_entry)->relevancy != SIGN_EXTENDED_DEF
&& ENTRY_EI (root_entry)->relevancy != ZERO_EXTENDED_DEF)
continue;
if (root_entry->reg)
gcc_assert (rtx_equal_p (root_entry->reg, reg));
else
root_entry->reg = reg;
if (ENTRY_EI (&def_entry[i])->local_relevancy == EXTENDED_DEF
|| (ENTRY_EI (&def_entry[i])->local_source_mode <
ENTRY_EI (root_entry)->source_mode))
{
num_relevant_defs++;
if (ENTRY_EI (root_entry)->relevancy == SIGN_EXTENDED_DEF)
extension_code = SIGN_EXTEND;
else
extension_code = ZERO_EXTEND;
se_insn =
see_gen_normalized_extension (reg, extension_code,
ENTRY_EI (root_entry)->source_mode);
INSN_DELETED_P (se_insn) = 1;
if (!see_store_reference_and_extension (insn, se_insn,
IMPLICIT_DEF_EXTENSION))
return -1;
continue;
}
ref_insn = PREV_INSN (insn);
gcc_assert (BLOCK_NUM (ref_insn) == BLOCK_NUM (insn));
num_relevant_defs++;
if (!see_store_reference_and_extension (ref_insn, insn,
EXPLICIT_DEF_EXTENSION))
return -1;
}
return num_relevant_defs;
}
static int
see_handle_relevant_uses (void)
{
rtx insn = NULL;
rtx reg = NULL;
struct web_entry *root_entry = NULL;
rtx se_insn = NULL;
unsigned int i;
int num_relevant_uses = 0;
enum rtx_code extension_code;
for (i = 0; i < uses_num; i++)
{
insn = DF_REF_INSN (DF_USES_GET (df, i));
reg = DF_REF_REAL_REG (DF_USES_GET (df, i));
if (!insn)
continue;
if (!INSN_P (insn))
continue;
root_entry = unionfind_root (&use_entry[i]);
if (ENTRY_EI (root_entry)->relevancy != SIGN_EXTENDED_DEF
&& ENTRY_EI (root_entry)->relevancy != ZERO_EXTENDED_DEF)
continue;
if (root_entry->reg)
gcc_assert (rtx_equal_p (root_entry->reg, reg));
else
root_entry->reg = reg;
if (ENTRY_EI (root_entry)->relevancy == SIGN_EXTENDED_DEF)
extension_code = SIGN_EXTEND;
else
extension_code = ZERO_EXTEND;
se_insn =
see_gen_normalized_extension (reg, extension_code,
ENTRY_EI (root_entry)->source_mode);
if (!se_insn)
return -1;
num_relevant_uses++;
if (!see_store_reference_and_extension (insn, se_insn,
USE_EXTENSION))
return -1;
}
return num_relevant_uses;
}
static void
see_update_uses_relevancy (void)
{
rtx insn = NULL;
rtx reg = NULL;
struct see_entry_extra_info *curr_entry_extra_info;
enum entry_type et;
unsigned int i;
if (!df || !use_entry)
return;
for (i = 0; i < uses_num; i++)
{
insn = DF_REF_INSN (DF_USES_GET (df, i));
reg = DF_REF_REAL_REG (DF_USES_GET (df, i));
et = RELEVANT_USE;
if (insn)
{
if (!INSN_P (insn))
et = NOT_RELEVANT;
if (insn && find_reg_note (insn, REG_LIBCALL, NULL_RTX))
et = NOT_RELEVANT;
if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
et = NOT_RELEVANT;
}
else
et = NOT_RELEVANT;
if (dump_file)
{
fprintf (dump_file, "u%i insn %i reg %i ",
i, (insn ? INSN_UID (insn) : -1), REGNO (reg));
if (et == NOT_RELEVANT)
fprintf (dump_file, "NOT RELEVANT \n");
else
fprintf (dump_file, "RELEVANT USE \n");
}
curr_entry_extra_info = xmalloc (sizeof (struct see_entry_extra_info));
curr_entry_extra_info->relevancy = et;
curr_entry_extra_info->local_relevancy = et;
use_entry[i].extra_info = curr_entry_extra_info;
use_entry[i].reg = NULL;
use_entry[i].pred = NULL;
}
}
static enum entry_type
see_analyze_one_def (rtx insn, enum machine_mode *source_mode,
enum machine_mode *source_mode_unsigned)
{
enum rtx_code extension_code;
rtx rhs = NULL;
rtx lhs = NULL;
rtx set = NULL;
rtx source_register = NULL;
rtx prev_insn = NULL;
rtx next_insn = NULL;
enum machine_mode mode;
enum machine_mode next_source_mode;
HOST_WIDE_INT val = 0;
HOST_WIDE_INT val2 = 0;
int i = 0;
*source_mode = MAX_MACHINE_MODE;
*source_mode_unsigned = MAX_MACHINE_MODE;
if (!insn)
return NOT_RELEVANT;
if (!INSN_P (insn))
return NOT_RELEVANT;
extension_code = see_get_extension_data (insn, source_mode);
switch (extension_code)
{
case SIGN_EXTEND:
case ZERO_EXTEND:
source_register = see_get_extension_reg (insn, 0);
prev_insn = PREV_INSN (insn);
if (!prev_insn || !INSN_P (prev_insn))
return NOT_RELEVANT;
if (!reg_set_between_p (source_register, PREV_INSN (prev_insn), insn))
return NOT_RELEVANT;
if (find_reg_note (prev_insn, REG_LIBCALL, NULL_RTX))
return NOT_RELEVANT;
if (find_reg_note (prev_insn, REG_RETVAL, NULL_RTX))
return NOT_RELEVANT;
if (GET_CODE (PATTERN (prev_insn)) == PARALLEL
&& asm_noperands (PATTERN (prev_insn)) >= 0)
return NOT_RELEVANT;
next_insn = NEXT_INSN (insn);
if (next_insn
&& INSN_P (next_insn)
&& (see_get_extension_data (next_insn, &next_source_mode) !=
NOT_RELEVANT))
{
rtx curr_dest_register = see_get_extension_reg (insn, 1);
rtx next_source_register = see_get_extension_reg (next_insn, 0);
if (REGNO (curr_dest_register) == REGNO (next_source_register))
return NOT_RELEVANT;
}
if (extension_code == SIGN_EXTEND)
return SIGN_EXTENDED_DEF;
else
return ZERO_EXTENDED_DEF;
case UNKNOWN:
set = single_set (insn);
if (!set)
return NOT_RELEVANT;
rhs = SET_SRC (set);
lhs = SET_DEST (set);
if (!REG_P (lhs) && !SUBREG_REG (lhs))
return NOT_RELEVANT;
switch (GET_CODE (rhs))
{
case SIGN_EXTEND:
*source_mode = GET_MODE (XEXP (rhs, 0));
*source_mode_unsigned = MAX_MACHINE_MODE;
return EXTENDED_DEF;
case ZERO_EXTEND:
*source_mode = MAX_MACHINE_MODE;
*source_mode_unsigned = GET_MODE (XEXP (rhs, 0));
return EXTENDED_DEF;
case CONST_INT:
val = INTVAL (rhs);
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT), i = 0;
GET_MODE_BITSIZE (mode) < BITS_PER_WORD;
mode = GET_MODE_WIDER_MODE (mode), i++)
{
val2 = trunc_int_for_mode (val, mode);
if (val2 == val && *source_mode == MAX_MACHINE_MODE)
*source_mode = mode;
if (val == (val & (HOST_WIDE_INT)GET_MODE_MASK (mode))
&& *source_mode_unsigned == MAX_MACHINE_MODE)
*source_mode_unsigned = mode;
if (*source_mode != MAX_MACHINE_MODE
&& *source_mode_unsigned !=MAX_MACHINE_MODE)
return EXTENDED_DEF;
}
if (*source_mode != MAX_MACHINE_MODE
|| *source_mode_unsigned !=MAX_MACHINE_MODE)
return EXTENDED_DEF;
return NOT_RELEVANT;
default:
return NOT_RELEVANT;
}
default:
gcc_unreachable ();
}
}
static void
see_update_defs_relevancy (void)
{
struct see_entry_extra_info *curr_entry_extra_info;
unsigned int i;
rtx insn = NULL;
rtx reg = NULL;
enum entry_type et;
enum machine_mode source_mode;
enum machine_mode source_mode_unsigned;
if (!df || !def_entry)
return;
for (i = 0; i < defs_num; i++)
{
insn = DF_REF_INSN (DF_DEFS_GET (df, i));
reg = DF_REF_REAL_REG (DF_DEFS_GET (df, i));
et = see_analyze_one_def (insn, &source_mode, &source_mode_unsigned);
curr_entry_extra_info = xmalloc (sizeof (struct see_entry_extra_info));
curr_entry_extra_info->relevancy = et;
curr_entry_extra_info->local_relevancy = et;
if (et != EXTENDED_DEF)
{
curr_entry_extra_info->source_mode = source_mode;
curr_entry_extra_info->local_source_mode = source_mode;
}
else
{
curr_entry_extra_info->source_mode_signed = source_mode;
curr_entry_extra_info->source_mode_unsigned = source_mode_unsigned;
}
def_entry[i].extra_info = curr_entry_extra_info;
def_entry[i].reg = NULL;
def_entry[i].pred = NULL;
if (dump_file)
{
if (et == NOT_RELEVANT)
{
fprintf (dump_file, "d%i insn %i reg %i ",
i, (insn ? INSN_UID (insn) : -1), REGNO (reg));
fprintf (dump_file, "NOT RELEVANT \n");
}
else
{
fprintf (dump_file, "d%i insn %i reg %i ",
i ,INSN_UID (insn), REGNO (reg));
fprintf (dump_file, "RELEVANT - ");
switch (et)
{
case SIGN_EXTENDED_DEF :
fprintf (dump_file, "SIGN_EXTENDED_DEF, source_mode = %s\n",
GET_MODE_NAME (source_mode));
break;
case ZERO_EXTENDED_DEF :
fprintf (dump_file, "ZERO_EXTENDED_DEF, source_mode = %s\n",
GET_MODE_NAME (source_mode));
break;
case EXTENDED_DEF :
fprintf (dump_file, "EXTENDED_DEF, ");
if (source_mode != MAX_MACHINE_MODE
&& source_mode_unsigned != MAX_MACHINE_MODE)
{
fprintf (dump_file, "positive const, ");
fprintf (dump_file, "source_mode_signed = %s, ",
GET_MODE_NAME (source_mode));
fprintf (dump_file, "source_mode_unsigned = %s\n",
GET_MODE_NAME (source_mode_unsigned));
}
else if (source_mode != MAX_MACHINE_MODE)
fprintf (dump_file, "source_mode_signed = %s\n",
GET_MODE_NAME (source_mode));
else
fprintf (dump_file, "source_mode_unsigned = %s\n",
GET_MODE_NAME (source_mode_unsigned));
break;
default :
gcc_unreachable ();
}
}
}
}
}
static bool
see_propagate_extensions_to_uses (void)
{
unsigned int i = 0;
int num_relevant_uses;
int num_relevant_defs;
if (dump_file)
fprintf (dump_file,
"* Phase 1: Propagate extensions to uses. *\n");
see_update_defs_relevancy ();
see_update_uses_relevancy ();
for (i = 0; i < uses_num; i++)
union_defs (df, DF_USES_GET (df, i), def_entry, use_entry,
see_update_leader_extra_info);
num_relevant_uses = see_handle_relevant_uses ();
if (num_relevant_uses < 0)
return false;
num_relevant_defs = see_handle_relevant_defs ();
if (num_relevant_defs < 0)
return false;
return num_relevant_uses > 0 || num_relevant_defs > 0;
}
static void
see_main (void)
{
bool cont = false;
int i = 0;
see_initialize_data_structures ();
cont = see_propagate_extensions_to_uses ();
if (cont)
{
init_recog ();
see_merge_and_eliminate_extensions ();
see_execute_LCM ();
see_commit_changes ();
if (dump_file)
{
fprintf (dump_file, "see_pre_extension_hash:\n");
htab_traverse (see_pre_extension_hash, see_print_pre_extension_expr,
NULL);
for (i = 0; i < last_bb; i++)
{
if (see_bb_hash_ar[i])
{
fprintf (dump_file,
"Searching register properties in bb %d\n", i);
htab_traverse (see_bb_hash_ar[i],
see_print_register_properties, NULL);
}
}
}
}
see_free_data_structures ();
}
static bool
gate_handle_see (void)
{
return optimize > 1 && flag_see;
}
static unsigned int
rest_of_handle_see (void)
{
int no_new_pseudos_bcp = no_new_pseudos;
no_new_pseudos = 0;
see_main ();
no_new_pseudos = no_new_pseudos_bcp;
delete_trivially_dead_insns (get_insns (), max_reg_num ());
update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
(PROP_DEATH_NOTES));
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (get_insns (), max_reg_num ());
return 0;
}
struct tree_opt_pass pass_see =
{
"see",
gate_handle_see,
rest_of_handle_see,
NULL,
NULL,
0,
TV_SEE,
0,
0,
0,
0,
TODO_dump_func,
'u'
};