#include "timevar.h"
#include "tree-pass.h"
-void
-see_main (void);
-
/* Used to classify defs and uses according to relevancy. */
enum entry_type {
NOT_RELEVANT,
/* The insn of the ref. */
rtx insn;
/* The merged insn that was formed from the reference's insn and extensions.
- If all merges faile it remains NULL. */
+ If all merges failed, it remains NULL. */
rtx merged_insn;
/* The def extensions of the reference that were not merged with
it. */
};
/* Occurrence of an expression.
- There must be at most one available occurance and at most one anticipatable
+ There must be at most one available occurrence and at most one anticipatable
occurrence per basic block. */
struct see_occr
{
/* Records the number of definitions at the beginning of the optimization. */
static unsigned int defs_num;
-#define ENTRY_EI(ENTRY) ((struct see_entry_extra_info *)(ENTRY)->extra_info)
+#define ENTRY_EI(ENTRY) ((struct see_entry_extra_info *) (ENTRY)->extra_info)
\f
/* Functions implementation. */
static rtx
see_get_extension_reg (rtx extension, bool return_dest_reg)
{
- rtx set = NULL;
- rtx rhs = NULL;
- rtx lhs = NULL;
+ rtx set, rhs, lhs;
rtx reg1 = NULL;
rtx reg2 = NULL;
+ /* Parallel pattern for extension not supported for the moment. */
+ if (GET_CODE (PATTERN (extension)) == PARALLEL)
+ return NULL;
+
set = single_set (extension);
if (!set)
return NULL;
else
return NULL;
- if ((GET_CODE (rhs) != SIGN_EXTEND) && (GET_CODE (rhs) != ZERO_EXTEND))
+ if (GET_CODE (rhs) != SIGN_EXTEND && GET_CODE (rhs) != ZERO_EXTEND)
return NULL;
rhs = XEXP (rhs, 0);
static enum rtx_code
see_get_extension_data (rtx extension, enum machine_mode *source_mode)
{
- rtx rhs = NULL;
- rtx lhs = NULL;
- rtx set = NULL;
+ rtx rhs, lhs, set;
if (!extension || !INSN_P (extension))
return UNKNOWN;
+ /* Parallel pattern for extension not supported for the moment. */
+ if (GET_CODE (PATTERN (extension)) == PARALLEL)
+ return NOT_RELEVANT;
+
set = single_set (extension);
if (!set)
return NOT_RELEVANT;
if (!REG_P (lhs) && !SUBREG_REG (lhs))
return UNKNOWN;
- if ((GET_CODE (rhs) != SIGN_EXTEND) && (GET_CODE (rhs) != ZERO_EXTEND))
+ 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))))))
+ && !(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;
- else
- return ZERO_EXTEND;
+ return ZERO_EXTEND;
}
(the register r on both sides of the set is the same register).
And recognize it.
If the recognition failed, this is very bad, return NULL (This will abort
- the entier optimization).
+ the entire optimization).
Otherwise, return the generated instruction. */
static rtx
see_gen_normalized_extension (rtx reg, enum rtx_code extension_code,
enum machine_mode mode)
{
- rtx subreg = NULL;
+ rtx subreg, insn;
rtx extension = NULL;
- rtx insn = NULL;
if (!reg
|| !REG_P (reg)
- || ((extension_code != SIGN_EXTEND) && (extension_code != ZERO_EXTEND)))
+ || (extension_code != SIGN_EXTEND && extension_code != ZERO_EXTEND))
return NULL;
subreg = gen_lowpart_SUBREG (mode, reg);
const struct see_pre_extension_expr *extension2 = p2;
rtx set1 = single_set (extension1->se_insn);
rtx set2 = single_set (extension2->se_insn);
- rtx rhs1 = NULL;
- rtx rhs2 = NULL;
+ rtx rhs1, rhs2;
gcc_assert (set1 && set2);
rhs1 = SET_SRC (set1);
{
const struct see_pre_extension_expr *extension = p;
rtx set = single_set (extension->se_insn);
- rtx rhs = NULL;
+ rtx rhs;
gcc_assert (set);
rhs = SET_SRC (set);
const struct see_register_properties *curr_prop1 = p1;
const struct see_register_properties *curr_prop2 = p2;
- return (curr_prop1->regno == curr_prop2->regno);
+ return curr_prop1->regno == curr_prop2->regno;
}
set ((reg:WIDEmode r1) (sign_extend:WIDEmode (reg:NARROWmode r2)))
The value of the key is (REGNO (reg:WIDEmode r1))
- It is posibble to search this hash in two ways:
+ It is possible to search this hash in two ways:
1. By a register rtx. The Value that is been compared to the keys is the
REGNO of it.
2. By an insn with the above pattern. The Value that is been compared to
const rtx insn = (rtx) p1;
const rtx element = (rtx) p2;
rtx set1 = single_set (insn);
+ rtx dest_reg1;
rtx set2 = NULL;
- rtx dest_reg1 = NULL;
rtx dest_reg2 = NULL;
gcc_assert (set1 && element && (REG_P (element) || INSN_P (element)));
else
dest_reg2 = element;
- return (REGNO (dest_reg1) == REGNO (dest_reg2));
+ return REGNO (dest_reg1) == REGNO (dest_reg2);
}
hash_descriptor_extension (const void *p)
{
const rtx r = (rtx) p;
- rtx set = NULL;
- rtx lhs = NULL;
+ rtx set, lhs;
if (r && REG_P (r))
return REGNO (r);
- else
- {
- gcc_assert (r && INSN_P (r));
- set = single_set (r);
- gcc_assert (set);
- lhs = SET_DEST (set);
- return REGNO (lhs);
- }
+
+ gcc_assert (r && INSN_P (r));
+ set = single_set (r);
+ gcc_assert (set);
+ lhs = SET_DEST (set);
+ return REGNO (lhs);
}
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 = NULL;
- struct see_pre_extension_expr temp_pre_exp;
+ 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;
static bool
see_update_leader_extra_info (struct web_entry *first, struct web_entry *second)
{
- struct see_entry_extra_info *first_ei = NULL;
- struct see_entry_extra_info *second_ei = NULL;
+ 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;
+ 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);
switch (first_ei->relevancy)
{
case NOT_RELEVANT:
- return false;
+ break;
case RELEVANT_USE:
switch (second_ei->relevancy)
{
case RELEVANT_USE:
- return false;
+ 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;
- return false;
+ break;
case SIGN_EXTENDED_DEF:
case ZERO_EXTENDED_DEF:
first_ei->relevancy = second_ei->relevancy;
first_ei->source_mode = second_ei->source_mode;
- return false;
+ break;
default:
gcc_unreachable ();
}
+ break;
case SIGN_EXTENDED_DEF:
switch (second_ei->relevancy)
{
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode) ?
first_ei->source_mode : second_ei->source_mode;
- return false;
+ break;
case RELEVANT_USE:
- return false;
+ break;
case ZERO_EXTENDED_DEF:
/* Don't mix webs with zero extend and sign extend. */
first_ei->relevancy = NOT_RELEVANT;
- return false;
+ break;
case EXTENDED_DEF:
if (second_ei->source_mode_signed == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode_signed) ?
first_ei->source_mode : second_ei->source_mode_signed;
- return false;
+ break;
default:
gcc_unreachable ();
}
+ break;
/* This case is similar to the previous one, with little changes. */
case ZERO_EXTENDED_DEF:
switch (second_ei->relevancy)
case SIGN_EXTENDED_DEF:
/* Don't mix webs with zero extend and sign extend. */
first_ei->relevancy = NOT_RELEVANT;
- return false;
+ break;
case RELEVANT_USE:
- return false;
+ break;
case ZERO_EXTENDED_DEF:
/* The mode of the root should be the wider one in this case. */
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode) ?
first_ei->source_mode : second_ei->source_mode;
- return false;
+ break;
case EXTENDED_DEF:
if (second_ei->source_mode_unsigned == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
first_ei->source_mode =
(first_ei->source_mode > second_ei->source_mode_unsigned) ?
first_ei->source_mode : second_ei->source_mode_unsigned;
- return false;
+ 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))
+ if (first_ei->source_mode_signed != MAX_MACHINE_MODE
+ && first_ei->source_mode_unsigned != MAX_MACHINE_MODE)
{
switch (second_ei->relevancy)
{
first_ei->source_mode =
(first_ei->source_mode_signed > second_ei->source_mode) ?
first_ei->source_mode_signed : second_ei->source_mode;
- return false;
+ break;
case RELEVANT_USE:
- return false;
+ 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;
- return false;
+ break;
case EXTENDED_DEF:
if (second_ei->source_mode_unsigned != MAX_MACHINE_MODE)
first_ei->source_mode_unsigned =
(first_ei->source_mode_signed >
second_ei->source_mode_signed) ?
first_ei->source_mode_signed : second_ei->source_mode_signed;
- return false;
+ break;
default:
gcc_unreachable ();
}
{
case SIGN_EXTENDED_DEF:
first_ei->relevancy = NOT_RELEVANT;
- return false;
+ break;
case RELEVANT_USE:
- return false;
+ 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;
- return false;
+ break;
case EXTENDED_DEF:
if (second_ei->source_mode_unsigned == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
second_ei->source_mode_unsigned) ?
first_ei->source_mode_unsigned :
second_ei->source_mode_unsigned;
- return false;
+ break;
default:
gcc_unreachable ();
}
first_ei->source_mode =
(first_ei->source_mode_signed > second_ei->source_mode) ?
first_ei->source_mode_signed : second_ei->source_mode;
- return false;
+ break;
case RELEVANT_USE:
- return false;
+ break;
case ZERO_EXTENDED_DEF:
first_ei->relevancy = NOT_RELEVANT;
- return false;
+ break;
case EXTENDED_DEF:
if (second_ei->source_mode_signed == MAX_MACHINE_MODE)
first_ei->relevancy = NOT_RELEVANT;
(first_ei->source_mode_signed >
second_ei->source_mode_signed) ?
first_ei->source_mode_signed : second_ei->source_mode_signed;
- return false;
+ break;
default:
gcc_unreachable ();
}
}
+ break;
default:
/* Unknown patern type. */
gcc_unreachable ();
}
+
+ return false;
}
see_initialize_data_structures (void)
{
/* Build the df object. */
- df = df_init (DF_HARD_REGS | DF_EQUIV_NOTES | DF_SUBREGS);
- df_rd_add_problem (df);
- /* df_ru_add_problem (df); */
+ 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);
/* Allocate the extension hash. It will hold the extensions that we want
to PRE. */
- see_pre_extension_hash =
- htab_create (10, hash_descriptor_pre_extension, eq_descriptor_pre_extension,
- hash_del_pre_extension);
+ see_pre_extension_hash = htab_create (10,
+ hash_descriptor_pre_extension,
+ eq_descriptor_pre_extension,
+ hash_del_pre_extension);
}
see_want_to_be_merged_with_extension (rtx ref, rtx extension,
enum extension_type type)
{
- rtx pat = NULL;
+ 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;
{
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 (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))))))
{
/* This is a simple move SET. */
- if ((type == DEF_EXTENSION)
+ if (type == DEF_EXTENSION
&& reg_mentioned_p (source_extension_reg, SET_DEST (sub)))
return false;
}
}
else
{
- if ((code == SET)
+ if (code == SET
&& (REG_P (SET_DEST (pat))
- || ((GET_CODE (SET_DEST (pat)) == SUBREG)
- && (REG_P (SUBREG_REG (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)))))))
+ || (GET_CODE (SET_SRC (pat)) == SUBREG
+ && REG_P (SUBREG_REG (SET_SRC (pat))))))
/* This is a simple move SET. */
return false;
}
redundant.
INDEX_MAP is a mapping of an index to an expression.
- Return true if an instruction was insertedon an edge.
+ Return true if an instruction was inserted on an edge.
Otherwise, return false. */
static bool
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 = NULL;
+ struct see_pre_extension_expr *extension_expr;
int indx;
int bb_num = BLOCK_NUM (ref);
- htab_t curr_bb_hash = NULL;
- struct see_register_properties *curr_prop = NULL;
- struct see_register_properties **slot_prop = NULL;
+ 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;
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 = NULL;
+ struct see_pre_extension_expr *extension_expr;
int indx;
int bb_num = BLOCK_NUM (ref);
- htab_t curr_bb_hash = NULL;
- struct see_register_properties *curr_prop = NULL;
- struct see_register_properties **slot_prop = NULL;
+ 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);
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 = NULL;
- struct see_register_properties *curr_prop = NULL;
- struct see_register_properties **slot_prop = NULL;
+ 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 = NULL;
+ htab_t curr_bb_hash;
int indx;
int bb_num = BLOCK_NUM (ref);
/* In this function we set the register properties for the register that is
defined and extended in the reference.
The properties are defined in see_register_properties structure which is
- allocated per basic bloack and per register.
+ allocated per basic block and per register.
Later the extension is inserted into the see_pre_extension_hash for the next
phase of the optimization.
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 = NULL;
+ htab_t curr_bb_hash;
struct see_register_properties *curr_prop = NULL;
- struct see_register_properties **slot_prop = NULL;
+ struct see_register_properties **slot_prop;
struct see_register_properties temp_prop;
int ref_luid = DF_INSN_LUID (df, insn);
if (!curr_bb_hash)
{
/* The hash doesn't exist yet. Create it. */
- curr_bb_hash =
- htab_create (10, hash_descriptor_properties, eq_descriptor_properties,
- hash_del_properties);
+ 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;
}
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
- if (slot_prop && (*slot_prop != NULL))
+ if (slot_prop && *slot_prop != NULL)
{
/* Property already exists. */
curr_prop = *slot_prop;
/* In this function we set the register properties for the register that is
defined but not extended in the reference.
The properties are defined in see_register_properties structure which is
- allocated per basic bloack and per register.
+ allocated per basic block and per register.
Later the extension is inserted into the see_pre_extension_hash for the next
phase of the optimization.
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 = NULL;
+ htab_t curr_bb_hash;
struct see_register_properties *curr_prop = NULL;
- struct see_register_properties **slot_prop = NULL;
+ struct see_register_properties **slot_prop;
struct see_register_properties temp_prop;
int ref_luid = DF_INSN_LUID (df, insn);
if (!curr_bb_hash)
{
/* The hash doesn't exist yet. Create it. */
- curr_bb_hash =
- htab_create (10, hash_descriptor_properties, eq_descriptor_properties,
- hash_del_properties);
+ 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;
}
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
- if (slot_prop && (*slot_prop != NULL))
+ if (slot_prop && *slot_prop != NULL)
{
/* Property already exists. */
curr_prop = *slot_prop;
/* In this function we set the register properties for the register that is used
in the reference.
The properties are defined in see_register_properties structure which is
- allocated per basic bloack and per register.
+ allocated per basic block and per register.
When a redundant use extension is found it is removed from the hash of the
reference.
If the extension is non redundant it is inserted into the
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 = NULL;
+ htab_t curr_bb_hash;
struct see_register_properties *curr_prop = NULL;
- struct see_register_properties **slot_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);
if (!curr_bb_hash)
{
/* The hash doesn't exist yet. Create it. */
- curr_bb_hash =
- htab_create (10, hash_descriptor_properties, eq_descriptor_properties,
- hash_del_properties);
+ 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;
}
(struct see_register_properties **) htab_find_slot (curr_bb_hash,
&temp_prop, INSERT);
- if (slot_prop && (*slot_prop != NULL))
+ if (slot_prop && *slot_prop != NULL)
{
/* Property already exists. */
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))
+ 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))
+ else if (curr_prop->last_def < 0
+ && curr_prop->first_se_before_any_def >= 0)
{
- /* In this case the extension is localy redundant. */
+ /* In this case the extension is locally redundant. */
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))
+ 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))
+ else if (curr_prop->last_def >= 0
+ && curr_prop->first_se_after_last_def >= 0)
{
- /* In this case the extension is localy redundant. */
+ /* In this case the extension is locally redundant. */
htab_clear_slot (curr_ref_s->use_se_hash, (PTR *)slot);
locally_redundant = true;
}
set (subreg (dest_extension_reg)) (rhs)
We do this in 4 steps:
- a. Replace every use of dest_reg with a new preudo register.
+ a. Replace every use of dest_reg with a new pseudo register.
b. Replace every instance of dest_reg with the subreg.
c. Replace every use of the new pseudo register back to dest_reg.
d. Try to recognize and simplify.
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 dest_reg = NULL;
- rtx dest_real_reg = NULL;
rtx source_extension_reg = see_get_extension_reg (def_se, 0);
rtx dest_extension_reg = see_get_extension_reg (def_se, 1);
- rtx new_pseudo_reg = NULL;
- rtx subreg = NULL;
rtx move_insn = NULL;
- rtx set = NULL;
- rtx rhs = 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));
+ 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)
+ || (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);
- /* Step a: Replace every use of dest_real_reg with a new preudo register. */
+ /* Step a: Replace every use of dest_real_reg with a new pseudo register. */
d.from = dest_real_reg;
d.to = new_pseudo_reg;
note_uses (&PATTERN (ref_copy), see_replace_src, &d);
ref: set (dest_reg) (rhs)
def_se: set (dest_extension_reg) (sign/zero_extend (source_extension_reg))
- where dest_reg and source_extension_reg can both be subregs (togather)
+ where dest_reg and source_extension_reg can both be subregs (together)
and (REGNO (dest_reg) == REGNO (source_extension_reg))
The merge is done by generating, simplifying and recognizing the pattern:
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 = NULL;
- rtx *rtx_slot = NULL;
- rtx subreg = NULL;
+ rtx move_insn, *rtx_slot, subreg;
rtx temp_extension = NULL;
rtx simplified_temp_extension = NULL;
- rtx *pat = NULL;
+ rtx *pat;
enum rtx_code code;
enum rtx_code extension_code;
enum machine_mode source_extension_mode;
{
rtx *sub = &XVECEXP (*pat, 0, i);
- if ((GET_CODE (*sub) == SET)
- && (GET_MODE (SET_SRC (*sub)) != VOIDmode)
- && (GET_MODE (SET_DEST (*sub)) == source_mode)
+ 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)))))
+ && 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 (apply_change_group ())
merge_success = true;
}
- else if ((code == SET)
- && (GET_MODE (SET_SRC (*pat)) != VOIDmode)
- && (GET_MODE (SET_DEST (*pat)) == source_mode)
+ 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))))
+ || (GET_CODE (SET_DEST (*pat)) == SUBREG
+ && REG_P (SUBREG_REG (SET_DEST (*pat)))
&& (REGNO (SUBREG_REG (SET_DEST (*pat))) ==
REGNO (source_extension_reg)))))
{
the merged_def_se_hash. */
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);
+ 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);
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 = NULL;
+ htab_t merged_def_se_hash;
rtx ref = ((struct see_ref_s *) (stn->value))->insn;
if (dump_file)
see_store_reference_and_extension (rtx ref_insn, rtx se_insn,
enum extension_type type)
{
- rtx *rtx_slot = NULL;
+ rtx *rtx_slot;
int curr_bb_num;
splay_tree_node stn = NULL;
htab_t se_hash = NULL;
return false;
curr_bb_num = BLOCK_NUM (ref_insn);
- gcc_assert ((curr_bb_num < last_bb) && (curr_bb_num >= 0));
+ gcc_assert (curr_bb_num < last_bb && curr_bb_num >= 0);
/* Insert the reference to the splay tree of its basic block. */
if (!see_bb_splay_ar[curr_bb_num])
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 ();
- }
- }
+ 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 ();
+ }
}
/* Initialize a new see_ref_s structure and insert it to the splay
switch (type)
{
case EXPLICIT_DEF_EXTENSION:
- ref_s->unmerged_def_se_hash =
- htab_create (10, hash_descriptor_extension, eq_descriptor_extension,
- NULL);
+ 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);
+ 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);
+ 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;
root_entry = unionfind_root (&def_entry[i]);
- if ((ENTRY_EI (root_entry)->relevancy != SIGN_EXTENDED_DEF)
- && (ENTRY_EI (root_entry)->relevancy != ZERO_EXTENDED_DEF))
+ if (ENTRY_EI (root_entry)->relevancy != SIGN_EXTENDED_DEF
+ && ENTRY_EI (root_entry)->relevancy != ZERO_EXTENDED_DEF)
/* The current web is not relevant. Continue to the next def. */
continue;
source_mode is narrower then its web's source_mode.
This means that we need to generate the implicit extension explicitly
and store it in the current reference's merged_def_se_hash. */
- if ((ENTRY_EI (&def_entry[i])->local_relevancy == EXTENDED_DEF)
+ if (ENTRY_EI (&def_entry[i])->local_relevancy == EXTENDED_DEF
|| (ENTRY_EI (&def_entry[i])->local_source_mode <
ENTRY_EI (root_entry)->source_mode))
{
root_entry = unionfind_root (&use_entry[i]);
- if ((ENTRY_EI (root_entry)->relevancy != SIGN_EXTENDED_DEF)
- && (ENTRY_EI (root_entry)->relevancy != ZERO_EXTENDED_DEF))
+ if (ENTRY_EI (root_entry)->relevancy != SIGN_EXTENDED_DEF
+ && ENTRY_EI (root_entry)->relevancy != ZERO_EXTENDED_DEF)
/* The current web is not relevant. Continue to the next use. */
continue;
return NOT_RELEVANT;
/* If we can't use copy_rtx on the reference it can't be a reference. */
- if ((GET_CODE (PATTERN (prev_insn)) == PARALLEL)
- && (asm_noperands (PATTERN (prev_insn)) >= 0))
+ if (GET_CODE (PATTERN (prev_insn)) == PARALLEL
+ && asm_noperands (PATTERN (prev_insn)) >= 0)
return NOT_RELEVANT;
/* Now, check if this extension is a reference itself. If so, it is not
relevant. Handling this extension as relevant would make things much
more complicated. */
next_insn = NEXT_INSN (insn);
- if (prev_insn
- && INSN_P (prev_insn)
+ if (next_insn
+ && INSN_P (next_insn)
&& (see_get_extension_data (next_insn, &next_source_mode) !=
NOT_RELEVANT))
{
switch (GET_CODE (rhs))
{
- case (SIGN_EXTEND):
+ case SIGN_EXTEND:
*source_mode = GET_MODE (XEXP (rhs, 0));
*source_mode_unsigned = MAX_MACHINE_MODE;
return EXTENDED_DEF;
- case (ZERO_EXTEND):
+ case ZERO_EXTEND:
*source_mode = MAX_MACHINE_MODE;
*source_mode_unsigned = GET_MODE (XEXP (rhs, 0));
return EXTENDED_DEF;
- case (CONST_INT):
+ case CONST_INT:
val = INTVAL (rhs);
mode = GET_MODE_WIDER_MODE (mode), i++)
{
val2 = trunc_int_for_mode (val, mode);
- if ((val2 == val) && (*source_mode == MAX_MACHINE_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))
+ 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))
+ 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))
+ if (*source_mode != MAX_MACHINE_MODE
+ || *source_mode_unsigned !=MAX_MACHINE_MODE)
return EXTENDED_DEF;
return NOT_RELEVANT;
default:
break;
case EXTENDED_DEF :
fprintf (dump_file, "EXTENDED_DEF, ");
- if ((source_mode != MAX_MACHINE_MODE)
- && (source_mode_unsigned != MAX_MACHINE_MODE))
+ if (source_mode != MAX_MACHINE_MODE
+ && source_mode_unsigned != MAX_MACHINE_MODE)
{
fprintf (dump_file, "positive const, ");
fprintf (dump_file, "source_mode_signed = %s, ",
and there is at least one definition that was marked as SIGN_EXTENDED_DEF
or ZERO_EXTENDED_DEF. */
for (i = 0; i < uses_num; i++)
- {
- union_defs (df, DF_USES_GET (df, i), def_entry, use_entry,
- see_update_leader_extra_info);
- }
+ union_defs (df, DF_USES_GET (df, i), def_entry, use_entry,
+ see_update_leader_extra_info);
/* Generate use extensions for references and insert these
references to see_bb_splay_ar data structure. */
if (num_relevant_defs < 0)
return false;
- return ((num_relevant_uses > 0) || (num_relevant_defs > 0));
+ return num_relevant_uses > 0 || num_relevant_defs > 0;
}
/* Main entry point for the sign extension elimination optimization. */
-void
+static void
see_main (void)
{
bool cont = false;
static bool
gate_handle_see (void)
{
- return ((optimize > 1) && flag_see);
+ return optimize > 1 && flag_see;
}
static unsigned int
OSDN Git Service
