}
}
}
-
+
for (r = ira_finish_point_ranges[i]; r != NULL; r = r->finish_next)
sparseset_clear_bit (allocnos_live, ALLOCNO_NUM (r->allocno));
}
{
case 'X':
return -1;
-
+
case 'm':
case 'o':
/* Accept a register which might be placed in memory. */
case 'g':
return -1;
-
+
case 'r':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
case 'h': case 'j': case 'k': case 'l':
#endif
break;
}
-
+
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (original != -1 && original != c)
return dup;
}
-/* Return the operand which should be, in any case, the same as
- operand with number OP_NUM. If USE_COMMUT_OP_P is TRUE, the
- function makes temporarily commutative operand exchange before
- this. */
-static rtx
-get_dup (int op_num, bool use_commut_op_p)
-{
- int n = get_dup_num (op_num, use_commut_op_p);
-
- if (n < 0)
- return NULL_RTX;
- else
- return recog_data.operand[n];
-}
-
/* Check that X is REG or SUBREG of REG. */
#define REG_SUBREG_P(x) \
(REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x))))
ira_curr_regno_allocno_map[REGNO (reg2)],
freq, constraint_p, insn,
ira_curr_loop_tree_node);
- bitmap_set_bit (ira_curr_loop_tree_node->local_copies, cp->num);
+ bitmap_set_bit (ira_curr_loop_tree_node->local_copies, cp->num);
return true;
}
else
return true;
}
-/* Process all of the output registers of the current insn and
- the input register REG (its operand number OP_NUM) which dies in the
- insn as if there were a move insn between them with frequency
- FREQ. */
+/* Process all of the output registers of the current insn which are
+ not bound (BOUND_P) and the input register REG (its operand number
+ OP_NUM) which dies in the insn as if there were a move insn between
+ them with frequency FREQ. */
static void
-process_reg_shuffles (rtx reg, int op_num, int freq)
+process_reg_shuffles (rtx reg, int op_num, int freq, bool *bound_p)
{
int i;
rtx another_reg;
for (i = 0; i < recog_data.n_operands; i++)
{
another_reg = recog_data.operand[i];
-
+
if (!REG_SUBREG_P (another_reg) || op_num == i
- || recog_data.operand_type[i] != OP_OUT)
+ || recog_data.operand_type[i] != OP_OUT
+ || bound_p[i])
continue;
-
+
process_regs_for_copy (reg, another_reg, false, NULL_RTX, freq);
}
}
{
rtx set, operand, dup;
const char *str;
- bool commut_p, bound_p;
- int i, j, freq;
+ bool commut_p, bound_p[MAX_RECOG_OPERANDS];
+ int i, j, n, freq;
freq = REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn));
if (freq == 0)
REG_P (SET_SRC (set))
? SET_SRC (set)
: SUBREG_REG (SET_SRC (set))) != NULL_RTX)
- process_regs_for_copy (SET_DEST (set), SET_SRC (set), false, insn, freq);
- else
{
- extract_insn (insn);
- for (i = 0; i < recog_data.n_operands; i++)
- {
- operand = recog_data.operand[i];
- if (REG_SUBREG_P (operand)
- && find_reg_note (insn, REG_DEAD,
- REG_P (operand)
- ? operand : SUBREG_REG (operand)) != NULL_RTX)
- {
- str = recog_data.constraints[i];
- while (*str == ' ' || *str == '\t')
- str++;
- bound_p = false;
- for (j = 0, commut_p = false; j < 2; j++, commut_p = true)
- if ((dup = get_dup (i, commut_p)) != NULL_RTX
- && REG_SUBREG_P (dup)
- && process_regs_for_copy (operand, dup, true,
- NULL_RTX, freq))
- bound_p = true;
- if (bound_p)
- continue;
- /* If an operand dies, prefer its hard register for the
- output operands by decreasing the hard register cost
- or creating the corresponding allocno copies. The
- cost will not correspond to a real move insn cost, so
- make the frequency smaller. */
- process_reg_shuffles (operand, i, freq < 8 ? 1 : freq / 8);
- }
- }
+ process_regs_for_copy (SET_DEST (set), SET_SRC (set), false, insn, freq);
+ return;
+ }
+ /* Fast check of possibility of constraint or shuffle copies. If
+ there are no dead registers, there will be no such copies. */
+ if (! find_reg_note (insn, REG_DEAD, NULL_RTX))
+ return;
+ extract_insn (insn);
+ for (i = 0; i < recog_data.n_operands; i++)
+ bound_p[i] = false;
+ for (i = 0; i < recog_data.n_operands; i++)
+ {
+ operand = recog_data.operand[i];
+ if (! REG_SUBREG_P (operand))
+ continue;
+ str = recog_data.constraints[i];
+ while (*str == ' ' || *str == '\t')
+ str++;
+ for (j = 0, commut_p = false; j < 2; j++, commut_p = true)
+ if ((n = get_dup_num (i, commut_p)) >= 0)
+ {
+ bound_p[n] = true;
+ dup = recog_data.operand[n];
+ if (REG_SUBREG_P (dup)
+ && find_reg_note (insn, REG_DEAD,
+ REG_P (operand)
+ ? operand
+ : SUBREG_REG (operand)) != NULL_RTX)
+ process_regs_for_copy (operand, dup, true, NULL_RTX, freq);
+ }
+ }
+ for (i = 0; i < recog_data.n_operands; i++)
+ {
+ operand = recog_data.operand[i];
+ if (REG_SUBREG_P (operand)
+ && find_reg_note (insn, REG_DEAD,
+ REG_P (operand)
+ ? operand : SUBREG_REG (operand)) != NULL_RTX)
+ /* If an operand dies, prefer its hard register for the output
+ operands by decreasing the hard register cost or creating
+ the corresponding allocno copies. The cost will not
+ correspond to a real move insn cost, so make the frequency
+ smaller. */
+ process_reg_shuffles (operand, i, freq < 8 ? 1 : freq / 8, bound_p);
}
}
{
int i, start;
- fprintf (file, title);
+ fputs (title, file);
for (start = -1, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
if (TEST_HARD_REG_BIT (set, i))
start = -1;
}
}
- fprintf (file, "\n");
+ putc ('\n', file);
}
/* Print information about allocno or only regno (if REG_P) conflicts
fprintf (file, "b%d", bb->index);
else
fprintf (file, "l%d", ALLOCNO_LOOP_TREE_NODE (a)->loop->num);
- fprintf (file, ")");
+ putc (')', file);
}
- fprintf (file, " conflicts:");
+ fputs (" conflicts:", file);
if (ALLOCNO_CONFLICT_ALLOCNO_ARRAY (a) != NULL)
FOR_EACH_ALLOCNO_CONFLICT (a, conflict_a, aci)
{
print_hard_reg_set (file, ";; conflict hard regs:",
conflicting_hard_regs);
}
- fprintf (file, "\n");
+ putc ('\n', file);
}
/* Print information about allocno or only regno (if REG_P) conflicts
OSDN Git Service
