/* IRA conflict builder.
- Copyright (C) 2006-2014 Free Software Foundation, Inc.
+ Copyright (C) 2006-2019 Free Software Foundation, Inc.
Contributed by Vladimir Makarov <vmakarov@redhat.com>.
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
-#include "regs.h"
+#include "backend.h"
+#include "target.h"
#include "rtl.h"
+#include "predict.h"
+#include "memmodel.h"
#include "tm_p.h"
-#include "target.h"
-#include "flags.h"
-#include "hard-reg-set.h"
-#include "basic-block.h"
#include "insn-config.h"
-#include "recog.h"
-#include "diagnostic-core.h"
+#include "regs.h"
+#include "ira.h"
+#include "ira-int.h"
#include "params.h"
-#include "df.h"
#include "sparseset.h"
-#include "ira-int.h"
#include "addresses.h"
/* This file contains code responsible for allocno conflict creation,
\f
/* Record a conflict between objects OBJ1 and OBJ2. If necessary,
canonicalize the conflict by recording it for lower-order subobjects
- of the corresponding allocnos. */
+ of the corresponding allocnos. */
static void
record_object_conflict (ira_object_t obj1, ira_object_t obj2)
{
gcc_assert (id < ira_objects_num);
aclass = ALLOCNO_CLASS (allocno);
- sparseset_set_bit (objects_live, id);
EXECUTE_IF_SET_IN_SPARSESET (objects_live, j)
{
ira_object_t live_obj = ira_object_id_map[j];
record_object_conflict (obj, live_obj);
}
}
+ sparseset_set_bit (objects_live, id);
}
for (r = ira_finish_point_ranges[i]; r != NULL; r = r->finish_next)
if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
*offset = subreg_regno_offset (REGNO (reg), GET_MODE (reg),
SUBREG_BYTE (x), GET_MODE (x));
- else
- *offset = (SUBREG_BYTE (x) / REGMODE_NATURAL_SIZE (GET_MODE (x)));
+ else if (!can_div_trunc_p (SUBREG_BYTE (x),
+ REGMODE_NATURAL_SIZE (GET_MODE (x)), offset))
+ /* Checked by validate_subreg. We must know at compile time which
+ inner hard registers are being accessed. */
+ gcc_unreachable ();
return reg;
}
FALSE. */
static bool
process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p,
- rtx insn, int freq)
+ rtx_insn *insn, int freq)
{
int allocno_preferenced_hard_regno, cost, index, offset1, offset2;
bool only_regs_p;
ira_allocno_t a;
reg_class_t rclass, aclass;
- enum machine_mode mode;
+ machine_mode mode;
ira_copy_t cp;
gcc_assert (REG_SUBREG_P (reg1) && REG_SUBREG_P (reg2));
if (! IN_RANGE (allocno_preferenced_hard_regno,
0, FIRST_PSEUDO_REGISTER - 1))
- /* Can not be tied. */
+ /* Cannot be tied. */
return false;
rclass = REGNO_REG_CLASS (allocno_preferenced_hard_regno);
mode = ALLOCNO_MODE (a);
return false;
index = ira_class_hard_reg_index[aclass][allocno_preferenced_hard_regno];
if (index < 0)
- /* Can not be tied. It is not in the allocno class. */
+ /* Cannot be tied. It is not in the allocno class. */
return false;
ira_init_register_move_cost_if_necessary (mode);
if (HARD_REGISTER_P (reg1))
|| bound_p[i])
continue;
- process_regs_for_copy (reg, another_reg, false, NULL_RTX, freq);
+ process_regs_for_copy (reg, another_reg, false, NULL, freq);
}
}
it might be because INSN is a pseudo-register move or INSN is two
operand insn. */
static void
-add_insn_allocno_copies (rtx insn)
+add_insn_allocno_copies (rtx_insn *insn)
{
rtx set, operand, dup;
bool bound_p[MAX_RECOG_OPERANDS];
REG_P (operand)
? operand
: SUBREG_REG (operand)) != NULL_RTX)
- process_regs_for_copy (operand, dup, true, NULL_RTX,
+ process_regs_for_copy (operand, dup, true, NULL,
freq);
}
}
add_copies (ira_loop_tree_node_t loop_tree_node)
{
basic_block bb;
- rtx insn;
+ rtx_insn *insn;
bb = loop_tree_node->bb;
if (bb == NULL)
ira_object_conflict_iterator oci;
if (OBJECT_CONFLICT_ARRAY (obj) == NULL)
- continue;
+ {
+ fprintf (file, "\n;; total conflict hard regs:\n");
+ fprintf (file, ";; conflict hard regs:\n\n");
+ continue;
+ }
+
if (n > 1)
fprintf (file, "\n;; subobject %d:", i);
FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci)
FOR_EACH_ALLOCNO (a, ai)
print_allocno_conflicts (file, reg_p, a);
+ putc ('\n', file);
}
/* Print information about allocno or only regno (if REG_P) conflicts
for (i = 0; i < n; i++)
{
ira_object_t obj = ALLOCNO_OBJECT (a, i);
+ machine_mode obj_mode = obj->allocno->mode;
rtx allocno_reg = regno_reg_rtx [ALLOCNO_REGNO (a)];
if ((! flag_caller_saves && ALLOCNO_CALLS_CROSSED_NUM (a) != 0)
temp_hard_reg_set);
}
+ /* Now we deal with paradoxical subreg cases where certain registers
+ cannot be accessed in the widest mode. */
+ machine_mode outer_mode = ALLOCNO_WMODE (a);
+ machine_mode inner_mode = ALLOCNO_MODE (a);
+ if (paradoxical_subreg_p (outer_mode, inner_mode))
+ {
+ enum reg_class aclass = ALLOCNO_CLASS (a);
+ for (int j = ira_class_hard_regs_num[aclass] - 1; j >= 0; --j)
+ {
+ int inner_regno = ira_class_hard_regs[aclass][j];
+ int outer_regno = simplify_subreg_regno (inner_regno,
+ inner_mode, 0,
+ outer_mode);
+ if (outer_regno < 0
+ || !in_hard_reg_set_p (reg_class_contents[aclass],
+ outer_mode, outer_regno))
+ {
+ SET_HARD_REG_BIT (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj),
+ inner_regno);
+ SET_HARD_REG_BIT (OBJECT_CONFLICT_HARD_REGS (obj),
+ inner_regno);
+ }
+ }
+ }
+
if (ALLOCNO_CALLS_CROSSED_NUM (a) != 0)
{
int regno;
regs must conflict with them. */
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (!TEST_HARD_REG_BIT (call_used_reg_set, regno)
- && HARD_REGNO_CALL_PART_CLOBBERED (regno,
- obj->allocno->mode))
+ && targetm.hard_regno_call_part_clobbered (NULL, regno,
+ obj_mode))
{
SET_HARD_REG_BIT (OBJECT_CONFLICT_HARD_REGS (obj), regno);
SET_HARD_REG_BIT (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj),
projects / thirdparty / gcc.git / blobdiff