[gcc] branch hsa updated (4f2ebec -> 4630ab4)
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a change to branch hsa
in repository gcc.
from 4f2ebec Merged trunk revision 226491 into the hsa branch.
new f1ab3df HSA: fix kernel initialization for dependent kernels
new 4630ab4 HSA: calculate properly maximum OMP data size which is necessary.
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "adds" were already present in the repository and have only
been added to this reference.
Summary of changes:
libgomp/ChangeLog.hsa | 16 +++++++++++++
libgomp/plugin/plugin-hsa.c | 57 +++++++++++++++++++++++++--------------------
2 files changed, 48 insertions(+), 25 deletions(-)
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] 01/01: [PR64164] Drop copyrename, use coalescible partition as base when optimizing.
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a commit to branch aoliva/pr64164
in repository gcc.
commit 5ce2a91a3afba67bad0070eee623f7f59d4f40f8
Author: Alexandre Oliva <aoliva(a)redhat.com>
Date: Sat Jul 18 02:06:32 2015 -0300
[PR64164] Drop copyrename, use coalescible partition as base when optimizing.
for gcc/ChangeLog
PR rtl-optimization/64164
PR bootstrap/66978
PR middle-end/66983
PR rtl-optimization/67000
PR middle-end/67034
PR middle-end/67035
* Makefile.in (OBJS): Drop tree-ssa-copyrename.o.
* tree-ssa-copyrename.c: Removed.
* opts.c (default_options_table): Drop -ftree-copyrename. Add
-ftree-coalesce-vars.
* passes.def: Drop all occurrences of pass_rename_ssa_copies.
* common.opt (ftree-copyrename): Ignore.
(ftree-coalesce-inlined-vars): Likewise.
* doc/invoke.texi: Remove the ignored options above.
* gimple-expr.h (gimple_can_coalesce_p): Move declaration
* tree-ssa-coalesce.h: ... here.
* tree-ssa-uncprop.c: Include tree-ssa-coalesce.h and other
headers required by it.
* gimple-expr.c (gimple_can_coalesce_p): Allow coalescing
across variables when flag_tree_coalesce_vars. Check register
use and promoted modes to allow coalescing. Do not coalesce
maybe-byref parms with SSA_NAMEs of other variables, or
anonymous SSA_NAMEs. Moved to tree-ssa-coalesce.c.
* tree-ssa-live.c (struct tree_int_map_hasher): Move along
with its member functions to tree-ssa-coalesce.c.
(var_map_base_init): Likewise. Renamed to
compute_samebase_partition_bases.
(partition_view_normal): Drop want_bases parameter.
(partition_view_bitmap): Likewise.
* tree-ssa-live.h: Adjust declarations.
* tree-ssa-coalesce.c: Include explow.h and cfgexpand.h.
(build_ssa_conflict_graph): Process PARM_ and RESULT_DECLs's
default defs at the entry point.
(dump_part_var_map): New.
(compute_optimized_partition_bases): New, called by...
(coalesce_ssa_name): ... when flag_tree_coalesce_vars, instead
of compute_samebase_partition_bases. Adjust.
* alias.c (nonoverlapping_memrefs_p): Disregard gimple-regs.
* cfgexpand.c (leader_merge, parm_maybe_byref_p): New.
(ssa_default_def_partition): New.
(get_rtl_for_parm_ssa_default_def): New.
(align_local_variable, add_stack_var): Support anonymous SSA
names.
(defer_stack_allocation): Likewise. Declare earlier.
(set_rtl): Merge exprs and attrs, even for MEMs and non-SSA
vars. Update DECL_RTL for PARM_DECLs and RESULT_DECLs too.
Do no record deferred-allocation marker in
SA.partition_to_pseudo.
(expand_stack_vars): Adjust check for the marker in it.
(expand_one_stack_var_at): Handle anonymous SSA_NAMEs. Drop
redundant MEM attr setting.
(expand_one_stack_var_1): Handle anonymous SSA_NAMEs. Renamed
from...
(expand_one_stack_var): ... this. New wrapper to check and
skip already expanded SSA partitions.
(record_alignment_for_reg_var): New, factored out of...
(expand_one_var): ... this.
(expand_one_ssa_partition): New.
(adjust_one_expanded_partition_var): New.
(expand_one_register_var): Check and skip already expanded SSA
partitions.
(expand_used_vars): Don't create DECLs for anonymous SSA
names. Expand all SSA partitions, then adjust all SSA names.
(pass::execute): Replace the loops that set
SA.partition_to_pseudo from partition leaders and cleared
DECL_RTL for multi-location variables, and that which used to
rename vars and set attrs, with one that clears DECL_RTL and
checks that PARMs and RESULTs default_defs match DECL_RTL.
* cfgexpand.h (get_rtl_for_parm_ssa_default_def): Declare.
* emit-rtl.c: Include stor-layout.h.
(set_reg_attrs_for_parm): Handle NULL decl.
(set_reg_attrs_for_decl_rtl): Take mode from expression if
it's not a DECL.
* stmt.c (emit_case_decision_tree): Pass it the SSA_NAME
rather than its possibly-NULL DECL.
* explow.c (promote_ssa_mode): New.
* explow.h (promote_ssa_mode): Declare.
* expr.c (expand_expr_real_1): Handle anonymous SSA_NAMEs.
(read_complex_part): Export.
* expr.h (read_complex_part): Declare.
* cfgexpand.h (parm_maybe_byref_p): Declare.
* function.c: Include cfgexpand.h.
(use_register_for_decl): Handle SSA_NAMEs, anonymous or not.
(use_register_for_parm_decl): Wrapper for the above to
special-case the result_ptr.
(rtl_for_parm): Ditto for get_rtl_for_parm_ssa_default_def.
(split_complex_args): Take assign_parm_data_all argument.
Pass it to rtl_for_parm. Set up rtl and context for split
args. Reset complex parm before fetching its default decl
rtl.
(assign_parms_unsplit_complex): Use the default-def complex
parm rtl if it matches the components.
(assign_parms_augmented_arg_list): Adjust.
(maybe_reset_rtl_for_parm): Reset DECL_RTL of parms with
multiple locations. Recognize split complex args.
(assign_parm_adjust_stack_rtl): Add all and parm arguments,
for rtl_for_parm. For SSA-assigned parms, zero stack_parm.
(assign_parm_setup_block): Prefer SSA-assigned location, and
fill in its address if the memory location of a maybe-byref
parm was not assigned by cfgexpand.
(assign_parm_setup_reg): Likewise. Adjust its mode as
needed. Use entry_parm for equiv if stack_parm is NULL. Make
sure passed_pointer parms don't need conversion. Copy address
or value as needed.
(assign_parm_setup_stack): Prefer SSA-assigned location.
(assign_parms): Maybe reset DECL_RTL of params. Adjust stack
rtl before testing for pointer bounds. Special-case result_ptr.
(expand_function_start): Maybe reset DECL_RTL of result.
Prefer SSA-assigned location for result and static chain.
Factor out DECL_RESULT and SET_DECL_RTL. Convert static chain
to Pmode if needed, from H.J. Lu <hongjiu.lu(a)intel.com>.
* tree-outof-ssa.c (insert_value_copy_on_edge): Handle
anonymous SSA names. Use promote_ssa_mode.
(get_temp_reg): Likewise.
(remove_ssa_form): Adjust.
* stor-layout.c (layout_decl): Don't set mem attributes of
non-MEMs.
* var-tracking.c (dataflow_set_clear_at_call): Take call_insn
and get its reg_usage for reg invalidation.
(compute_bb_dataflow): Pass it insn.
(emit_notes_in_bb): Likewise.
for gcc/testsuite/ChangeLog
* gcc.dg/guality/pr54200.c: Add -fno-tree-coalesce-vars.
* gcc.dg/ssp-1.c: Make counter a register.
* gcc.dg/ssp-2.c: Likewise.
* gcc.dg/torture/parm-coalesce.c: New.
---
gcc/Makefile.in | 1 -
gcc/alias.c | 13 +
gcc/cfgexpand.c | 471 +++++++++++++++++++-------
gcc/cfgexpand.h | 3 +
gcc/common.opt | 12 +-
gcc/doc/invoke.texi | 48 +--
gcc/emit-rtl.c | 8 +-
gcc/explow.c | 29 ++
gcc/explow.h | 3 +
gcc/expr.c | 41 ++-
gcc/expr.h | 1 +
gcc/function.c | 341 +++++++++++++++----
gcc/gimple-expr.c | 39 ---
gcc/gimple-expr.h | 1 -
gcc/opts.c | 2 +-
gcc/passes.def | 5 -
gcc/stmt.c | 2 +-
gcc/stor-layout.c | 3 +-
gcc/testsuite/gcc.dg/guality/pr54200.c | 2 +-
gcc/testsuite/gcc.dg/ssp-1.c | 2 +-
gcc/testsuite/gcc.dg/ssp-2.c | 2 +-
gcc/testsuite/gcc.dg/torture/parm-coalesce.c | 40 +++
gcc/tree-outof-ssa.c | 16 +-
gcc/tree-ssa-coalesce.c | 384 +++++++++++++++++++++-
gcc/tree-ssa-coalesce.h | 1 +
gcc/tree-ssa-copyrename.c | 475 ---------------------------
gcc/tree-ssa-live.c | 99 +-----
gcc/tree-ssa-live.h | 4 +-
gcc/tree-ssa-uncprop.c | 5 +
gcc/var-tracking.c | 12 +-
30 files changed, 1187 insertions(+), 878 deletions(-)
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index be259e8..6079acc 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1444,7 +1444,6 @@ OBJS = \
tree-ssa-ccp.o \
tree-ssa-coalesce.o \
tree-ssa-copy.o \
- tree-ssa-copyrename.o \
tree-ssa-dce.o \
tree-ssa-dom.o \
tree-ssa-dse.o \
diff --git a/gcc/alias.c b/gcc/alias.c
index fa7d5d8..4681e3f 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -2507,6 +2507,19 @@ nonoverlapping_memrefs_p (const_rtx x, const_rtx y, bool loo [...]
if (! DECL_P (exprx) || ! DECL_P (expry))
return 0;
+ /* If we refer to different gimple registers, or one gimple register
+ and one non-gimple-register, we know they can't overlap. First,
+ gimple registers don't have their addresses taken. Now, there
+ could be more than one stack slot for (different versions of) the
+ same gimple register, but we can presumably tell they don't
+ overlap based on offsets from stack base addresses elsewhere.
+ It's important that we don't proceed to DECL_RTL, because gimple
+ registers may not pass DECL_RTL_SET_P, and make_decl_rtl won't be
+ able to do anything about them since no SSA information will have
+ remained to guide it. */
+ if (is_gimple_reg (exprx) || is_gimple_reg (expry))
+ return exprx != expry;
+
/* With invalid code we can end up storing into the constant pool.
Bail out to avoid ICEing when creating RTL for this.
See gfortran.dg/lto/20091028-2_0.f90. */
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index a047632..8f6caf6 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -97,6 +97,8 @@ gimple currently_expanding_gimple_stmt;
static rtx expand_debug_expr (tree);
+static bool defer_stack_allocation (tree, bool);
+
/* Return an expression tree corresponding to the RHS of GIMPLE
statement STMT. */
@@ -150,21 +152,149 @@ gimple_assign_rhs_to_tree (gimple stmt)
#define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
+/* Choose either CUR or NEXT as the leader DECL for a partition.
+ Prefer ignored decls, to simplify debug dumps and reduce ambiguity
+ out of the same user variable being in multiple partitions (this is
+ less likely for compiler-introduced temps). */
+
+static tree
+leader_merge (tree cur, tree next)
+{
+ if (cur == NULL || cur == next)
+ return next;
+
+ if (DECL_P (cur) && DECL_IGNORED_P (cur))
+ return cur;
+
+ if (DECL_P (next) && DECL_IGNORED_P (next))
+ return next;
+
+ return cur;
+}
+
+/* Return true if VAR is a PARM_DECL or a RESULT_DECL of type BLKmode.
+ Such parameters are likely passed as a pointer to the value, rather
+ than as a value, and so we must not coalesce them, nor allocate
+ stack space for them before determining the calling conventions for
+ them. For their SSA_NAMEs, expand_one_ssa_partition emits RTL as
+ MEMs with pc_rtx as the address, and then it replaces the pc_rtx
+ with NULL so as to make sure the MEM is not used before it is
+ adjusted in assign_parm_setup_reg. */
+
+bool
+parm_maybe_byref_p (tree var)
+{
+ if (!var || VAR_P (var))
+ return false;
+
+ gcc_assert (TREE_CODE (var) == PARM_DECL
+ || TREE_CODE (var) == RESULT_DECL);
+
+ return TYPE_MODE (TREE_TYPE (var)) == BLKmode;
+}
+
+/* Return the partition of the default SSA_DEF for decl VAR. */
+
+static int
+ssa_default_def_partition (tree var)
+{
+ tree name = ssa_default_def (cfun, var);
+
+ if (!name)
+ return NO_PARTITION;
+
+ return var_to_partition (SA.map, name);
+}
+
+/* Return the RTL for the default SSA def of a PARM or RESULT, if
+ there is one. */
+
+rtx
+get_rtl_for_parm_ssa_default_def (tree var)
+{
+ gcc_assert (TREE_CODE (var) == PARM_DECL || TREE_CODE (var) == RESULT_DECL);
+
+ if (!is_gimple_reg (var))
+ return NULL_RTX;
+
+ /* If we've already determined RTL for the decl, use it. This is
+ not just an optimization: if VAR is a PARM whose incoming value
+ is unused, we won't find a default def to use its partition, but
+ we still want to use the location of the parm, if it was used at
+ all. During assign_parms, until a location is assigned for the
+ VAR, RTL can only for a parm or result if we're not coalescing
+ across variables, when we know we're coalescing all SSA_NAMEs of
+ each parm or result, and we're not coalescing them with names
+ pertaining to other variables, such as other parms' default
+ defs. */
+ if (DECL_RTL_SET_P (var))
+ {
+ gcc_assert (DECL_RTL (var) != pc_rtx);
+ return DECL_RTL (var);
+ }
+
+ int part = ssa_default_def_partition (var);
+ if (part == NO_PARTITION)
+ return NULL_RTX;
+
+ return SA.partition_to_pseudo[part];
+}
+
/* Associate declaration T with storage space X. If T is no
SSA name this is exactly SET_DECL_RTL, otherwise make the
partition of T associated with X. */
static inline void
set_rtl (tree t, rtx x)
{
+ if (x && SSAVAR (t))
+ {
+ bool skip = false;
+ tree cur = NULL_TREE;
+
+ if (MEM_P (x))
+ cur = MEM_EXPR (x);
+ else if (REG_P (x))
+ cur = REG_EXPR (x);
+ else if (GET_CODE (x) == CONCAT
+ && REG_P (XEXP (x, 0)))
+ cur = REG_EXPR (XEXP (x, 0));
+ else if (GET_CODE (x) == PARALLEL)
+ cur = REG_EXPR (XVECEXP (x, 0, 0));
+ else if (x == pc_rtx)
+ skip = true;
+ else
+ gcc_unreachable ();
+
+ tree next = skip ? cur : leader_merge (cur, SSAVAR (t));
+
+ if (cur != next)
+ {
+ if (MEM_P (x))
+ set_mem_attributes (x, next, true);
+ else
+ set_reg_attrs_for_decl_rtl (next, x);
+ }
+ }
+
if (TREE_CODE (t) == SSA_NAME)
{
- SA.partition_to_pseudo[var_to_partition (SA.map, t)] = x;
- if (x && !MEM_P (x))
- set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t), x);
- /* For the benefit of debug information at -O0 (where vartracking
- doesn't run) record the place also in the base DECL if it's
- a normal variable (not a parameter). */
- if (x && x != pc_rtx && TREE_CODE (SSA_NAME_VAR (t)) == VAR_DECL)
+ int part = var_to_partition (SA.map, t);
+ if (part != NO_PARTITION)
+ {
+ if (SA.partition_to_pseudo[part])
+ gcc_assert (SA.partition_to_pseudo[part] == x);
+ else if (x != pc_rtx)
+ SA.partition_to_pseudo[part] = x;
+ }
+ /* For the benefit of debug information at -O0 (where
+ vartracking doesn't run) record the place also in the base
+ DECL. For PARMs and RESULTs, we may end up resetting these
+ in function.c:maybe_reset_rtl_for_parm, but in some rare
+ cases we may need them (unused and overwritten incoming
+ value, that at -O0 must share the location with the other
+ uses in spite of the missing default def), and this may be
+ the only chance to preserve them. */
+ if (x && x != pc_rtx && SSA_NAME_VAR (t))
{
tree var = SSA_NAME_VAR (t);
/* If we don't yet have something recorded, just record it now. */
@@ -248,8 +378,15 @@ static bool has_short_buffer;
static unsigned int
align_local_variable (tree decl)
{
- unsigned int align = LOCAL_DECL_ALIGNMENT (decl);
- DECL_ALIGN (decl) = align;
+ unsigned int align;
+
+ if (TREE_CODE (decl) == SSA_NAME)
+ align = TYPE_ALIGN (TREE_TYPE (decl));
+ else
+ {
+ align = LOCAL_DECL_ALIGNMENT (decl);
+ DECL_ALIGN (decl) = align;
+ }
return align / BITS_PER_UNIT;
}
@@ -315,12 +452,15 @@ add_stack_var (tree decl)
decl_to_stack_part->put (decl, stack_vars_num);
v->decl = decl;
- v->size = tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (decl)));
+ tree size = TREE_CODE (decl) == SSA_NAME
+ ? TYPE_SIZE_UNIT (TREE_TYPE (decl))
+ : DECL_SIZE_UNIT (decl);
+ v->size = tree_to_uhwi (size);
/* Ensure that all variables have size, so that &a != &b for any two
variables that are simultaneously live. */
if (v->size == 0)
v->size = 1;
- v->alignb = align_local_variable (SSAVAR (decl));
+ v->alignb = align_local_variable (decl);
/* An alignment of zero can mightily confuse us later. */
gcc_assert (v->alignb != 0);
@@ -862,7 +1002,9 @@ expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
x = plus_constant (Pmode, base, offset);
- x = gen_rtx_MEM (DECL_MODE (SSAVAR (decl)), x);
+ x = gen_rtx_MEM (TREE_CODE (decl) == SSA_NAME
+ ? TYPE_MODE (TREE_TYPE (decl))
+ : DECL_MODE (SSAVAR (decl)), x);
if (TREE_CODE (decl) != SSA_NAME)
{
@@ -884,7 +1026,6 @@ expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
DECL_USER_ALIGN (decl) = 0;
}
- set_mem_attributes (x, SSAVAR (decl), true);
set_rtl (decl, x);
}
@@ -950,9 +1091,9 @@ expand_stack_vars (bool (*pred) (size_t), struct stack_vars_da [...]
/* Skip variables that have already had rtl assigned. See also
add_stack_var where we perpetrate this pc_rtx hack. */
decl = stack_vars[i].decl;
- if ((TREE_CODE (decl) == SSA_NAME
- ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
- : DECL_RTL (decl)) != pc_rtx)
+ if (TREE_CODE (decl) == SSA_NAME
+ ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
+ : DECL_RTL (decl) != pc_rtx)
continue;
large_size += alignb - 1;
@@ -981,9 +1122,9 @@ expand_stack_vars (bool (*pred) (size_t), struct stack_vars_da [...]
/* Skip variables that have already had rtl assigned. See also
add_stack_var where we perpetrate this pc_rtx hack. */
decl = stack_vars[i].decl;
- if ((TREE_CODE (decl) == SSA_NAME
- ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
- : DECL_RTL (decl)) != pc_rtx)
+ if (TREE_CODE (decl) == SSA_NAME
+ ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
+ : DECL_RTL (decl) != pc_rtx)
continue;
/* Check the predicate to see whether this variable should be
@@ -1099,13 +1240,22 @@ account_stack_vars (void)
to a variable to be allocated in the stack frame. */
static void
-expand_one_stack_var (tree var)
+expand_one_stack_var_1 (tree var)
{
HOST_WIDE_INT size, offset;
unsigned byte_align;
- size = tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (var)));
- byte_align = align_local_variable (SSAVAR (var));
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ tree type = TREE_TYPE (var);
+ size = tree_to_uhwi (TYPE_SIZE_UNIT (type));
+ byte_align = TYPE_ALIGN_UNIT (type);
+ }
+ else
+ {
+ size = tree_to_uhwi (DECL_SIZE_UNIT (var));
+ byte_align = align_local_variable (var);
+ }
/* We handle highly aligned variables in expand_stack_vars. */
gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
@@ -1116,6 +1266,27 @@ expand_one_stack_var (tree var)
crtl->max_used_stack_slot_alignment, offset);
}
+/* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
+ already assigned some MEM. */
+
+static void
+expand_one_stack_var (tree var)
+{
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ int part = var_to_partition (SA.map, var);
+ if (part != NO_PARTITION)
+ {
+ rtx x = SA.partition_to_pseudo[part];
+ gcc_assert (x);
+ gcc_assert (MEM_P (x));
+ return;
+ }
+ }
+
+ return expand_one_stack_var_1 (var);
+}
+
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
that will reside in a hard register. */
@@ -1125,13 +1296,136 @@ expand_one_hard_reg_var (tree var)
rest_of_decl_compilation (var, 0, 0);
}
+/* Record the alignment requirements of some variable assigned to a
+ pseudo. */
+
+static void
+record_alignment_for_reg_var (unsigned int align)
+{
+ if (SUPPORTS_STACK_ALIGNMENT
+ && crtl->stack_alignment_estimated < align)
+ {
+ /* stack_alignment_estimated shouldn't change after stack
+ realign decision made */
+ gcc_assert (!crtl->stack_realign_processed);
+ crtl->stack_alignment_estimated = align;
+ }
+
+ /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
+ So here we only make sure stack_alignment_needed >= align. */
+ if (crtl->stack_alignment_needed < align)
+ crtl->stack_alignment_needed = align;
+ if (crtl->max_used_stack_slot_alignment < align)
+ crtl->max_used_stack_slot_alignment = align;
+}
+
+/* Create RTL for an SSA partition. */
+
+static void
+expand_one_ssa_partition (tree var)
+{
+ int part = var_to_partition (SA.map, var);
+ gcc_assert (part != NO_PARTITION);
+
+ if (SA.partition_to_pseudo[part])
+ return;
+
+ unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
+ TYPE_MODE (TREE_TYPE (var)),
+ TYPE_ALIGN (TREE_TYPE (var)));
+
+ /* If the variable alignment is very large we'll dynamicaly allocate
+ it, which means that in-frame portion is just a pointer. */
+ if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
+ align = POINTER_SIZE;
+
+ record_alignment_for_reg_var (align);
+
+ if (!use_register_for_decl (var))
+ {
+ if (parm_maybe_byref_p (SSA_NAME_VAR (var))
+ && ssa_default_def_partition (SSA_NAME_VAR (var)) == part)
+ {
+ expand_one_stack_var_at (var, pc_rtx, 0, 0);
+ rtx x = SA.partition_to_pseudo[part];
+ gcc_assert (GET_CODE (x) == MEM);
+ gcc_assert (GET_MODE (x) == BLKmode);
+ gcc_assert (XEXP (x, 0) == pc_rtx);
+ /* Reset the address, so that any attempt to use it will
+ ICE. It will be adjusted in assign_parm_setup_reg. */
+ XEXP (x, 0) = NULL_RTX;
+ }
+ else if (defer_stack_allocation (var, true))
+ add_stack_var (var);
+ else
+ expand_one_stack_var_1 (var);
+ return;
+ }
+
+ machine_mode reg_mode = promote_ssa_mode (var, NULL);
+
+ rtx x = gen_reg_rtx (reg_mode);
+
+ set_rtl (var, x);
+}
+
+/* Record the association between the RTL generated for a partition
+ and the underlying variable of the SSA_NAME. */
+
+static void
+adjust_one_expanded_partition_var (tree var)
+{
+ if (!var)
+ return;
+
+ tree decl = SSA_NAME_VAR (var);
+
+ int part = var_to_partition (SA.map, var);
+ if (part == NO_PARTITION)
+ return;
+
+ rtx x = SA.partition_to_pseudo[part];
+
+ if (!x)
+ {
+ /* This var will get a stack slot later. */
+ gcc_assert (defer_stack_allocation (var, true));
+ return;
+ }
+
+ set_rtl (var, x);
+
+ if (!REG_P (x))
+ return;
+
+ /* Note if the object is a user variable. */
+ if (decl && !DECL_ARTIFICIAL (decl))
+ mark_user_reg (x);
+
+ if (POINTER_TYPE_P (decl ? TREE_TYPE (decl) : TREE_TYPE (var)))
+ mark_reg_pointer (x, get_pointer_alignment (var));
+}
+
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
that will reside in a pseudo register. */
static void
expand_one_register_var (tree var)
{
- tree decl = SSAVAR (var);
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ int part = var_to_partition (SA.map, var);
+ if (part != NO_PARTITION)
+ {
+ rtx x = SA.partition_to_pseudo[part];
+ gcc_assert (x);
+ gcc_assert (REG_P (x));
+ return;
+ }
+ gcc_unreachable ();
+ }
+
+ tree decl = var;
tree type = TREE_TYPE (decl);
machine_mode reg_mode = promote_decl_mode (decl, NULL);
rtx x = gen_reg_rtx (reg_mode);
@@ -1177,10 +1471,14 @@ expand_one_error_var (tree var)
static bool
defer_stack_allocation (tree var, bool toplevel)
{
+ tree size_unit = TREE_CODE (var) == SSA_NAME
+ ? TYPE_SIZE_UNIT (TREE_TYPE (var))
+ : DECL_SIZE_UNIT (var);
+
/* Whether the variable is small enough for immediate allocation not to be
a problem with regard to the frame size. */
bool smallish
- = ((HOST_WIDE_INT) tree_to_uhwi (DECL_SIZE_UNIT (var))
+ = ((HOST_WIDE_INT) tree_to_uhwi (size_unit)
< PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING));
/* If stack protection is enabled, *all* stack variables must be deferred,
@@ -1189,16 +1487,24 @@ defer_stack_allocation (tree var, bool toplevel)
if (flag_stack_protect || ((flag_sanitize & SANITIZE_ADDRESS) && ASAN_STACK))
return true;
+ unsigned int align = TREE_CODE (var) == SSA_NAME
+ ? TYPE_ALIGN (TREE_TYPE (var))
+ : DECL_ALIGN (var);
+
/* We handle "large" alignment via dynamic allocation. We want to handle
this extra complication in only one place, so defer them. */
- if (DECL_ALIGN (var) > MAX_SUPPORTED_STACK_ALIGNMENT)
+ if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
return true;
+ bool ignored = TREE_CODE (var) == SSA_NAME
+ ? !SSAVAR (var) || DECL_IGNORED_P (SSA_NAME_VAR (var))
+ : DECL_IGNORED_P (var);
+
/* When optimization is enabled, DECL_IGNORED_P variables originally scoped
might be detached from their block and appear at toplevel when we reach
here. We want to coalesce them with variables from other blocks when
the immediate contribution to the frame size would be noticeable. */
- if (toplevel && optimize > 0 && DECL_IGNORED_P (var) && !smallish)
+ if (toplevel && optimize > 0 && ignored && !smallish)
return true;
/* Variables declared in the outermost scope automatically conflict
@@ -1265,21 +1571,7 @@ expand_one_var (tree var, bool toplevel, bool really_expand)
align = POINTER_SIZE;
}
- if (SUPPORTS_STACK_ALIGNMENT
- && crtl->stack_alignment_estimated < align)
- {
- /* stack_alignment_estimated shouldn't change after stack
- realign decision made */
- gcc_assert (!crtl->stack_realign_processed);
- crtl->stack_alignment_estimated = align;
- }
-
- /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
- So here we only make sure stack_alignment_needed >= align. */
- if (crtl->stack_alignment_needed < align)
- crtl->stack_alignment_needed = align;
- if (crtl->max_used_stack_slot_alignment < align)
- crtl->max_used_stack_slot_alignment = align;
+ record_alignment_for_reg_var (align);
if (TREE_CODE (origvar) == SSA_NAME)
{
@@ -1713,48 +2005,18 @@ expand_used_vars (void)
if (targetm.use_pseudo_pic_reg ())
pic_offset_table_rtx = gen_reg_rtx (Pmode);
- hash_map<tree, tree> ssa_name_decls;
for (i = 0; i < SA.map->num_partitions; i++)
{
tree var = partition_to_var (SA.map, i);
gcc_assert (!virtual_operand_p (var));
- /* Assign decls to each SSA name partition, share decls for partitions
- we could have coalesced (those with the same type). */
- if (SSA_NAME_VAR (var) == NULL_TREE)
- {
- tree *slot = &ssa_name_decls.get_or_insert (TREE_TYPE (var));
- if (!*slot)
- *slot = create_tmp_reg (TREE_TYPE (var));
- replace_ssa_name_symbol (var, *slot);
- }
-
- /* Always allocate space for partitions based on VAR_DECLs. But for
- those based on PARM_DECLs or RESULT_DECLs and which matter for the
- debug info, there is no need to do so if optimization is disabled
- because all the SSA_NAMEs based on these DECLs have been coalesced
- into a single partition, which is thus assigned the canonical RTL
- location of the DECLs. If in_lto_p, we can't rely on optimize,
- a function could be compiled with -O1 -flto first and only the
- link performed at -O0. */
- if (TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
- expand_one_var (var, true, true);
- else if (DECL_IGNORED_P (SSA_NAME_VAR (var)) || optimize || in_lto_p)
- {
- /* This is a PARM_DECL or RESULT_DECL. For those partitions that
- contain the default def (representing the parm or result itself)
- we don't do anything here. But those which don't contain the
- default def (representing a temporary based on the parm/result)
- we need to allocate space just like for normal VAR_DECLs. */
- if (!bitmap_bit_p (SA.partition_has_default_def, i))
- {
- expand_one_var (var, true, true);
- gcc_assert (SA.partition_to_pseudo[i]);
- }
- }
+ expand_one_ssa_partition (var);
}
+ for (i = 1; i < num_ssa_names; i++)
+ adjust_one_expanded_partition_var (ssa_name (i));
+
if (flag_stack_protect == SPCT_FLAG_STRONG)
gen_stack_protect_signal
= stack_protect_decl_p () || stack_protect_return_slot_p ();
@@ -5928,35 +6190,6 @@ pass_expand::execute (function *fun)
parm_birth_insn = var_seq;
}
- /* Now that we also have the parameter RTXs, copy them over to our
- partitions. */
- for (i = 0; i < SA.map->num_partitions; i++)
- {
- tree var = SSA_NAME_VAR (partition_to_var (SA.map, i));
-
- if (TREE_CODE (var) != VAR_DECL
- && !SA.partition_to_pseudo[i])
- SA.partition_to_pseudo[i] = DECL_RTL_IF_SET (var);
- gcc_assert (SA.partition_to_pseudo[i]);
-
- /* If this decl was marked as living in multiple places, reset
- this now to NULL. */
- if (DECL_RTL_IF_SET (var) == pc_rtx)
- SET_DECL_RTL (var, NULL);
-
- /* Some RTL parts really want to look at DECL_RTL(x) when x
- was a decl marked in REG_ATTR or MEM_ATTR. We could use
- SET_DECL_RTL here making this available, but that would mean
- to select one of the potentially many RTLs for one DECL. Instead
- of doing that we simply reset the MEM_EXPR of the RTL in question,
- then nobody can get at it and hence nobody can call DECL_RTL on it. */
- if (!DECL_RTL_SET_P (var))
- {
- if (MEM_P (SA.partition_to_pseudo[i]))
- set_mem_expr (SA.partition_to_pseudo[i], NULL);
- }
- }
-
/* If we have a class containing differently aligned pointers
we need to merge those into the corresponding RTL pointer
alignment. */
@@ -5964,7 +6197,6 @@ pass_expand::execute (function *fun)
{
tree name = ssa_name (i);
int part;
- rtx r;
if (!name
/* We might have generated new SSA names in
@@ -5977,20 +6209,25 @@ pass_expand::execute (function *fun)
if (part == NO_PARTITION)
continue;
- /* Adjust all partition members to get the underlying decl of
- the representative which we might have created in expand_one_var. */
- if (SSA_NAME_VAR (name) == NULL_TREE)
+ gcc_assert (SA.partition_to_pseudo[part]
+ || defer_stack_allocation (name, true));
+
+ /* If this decl was marked as living in multiple places, reset
+ this now to NULL. */
+ tree var = SSA_NAME_VAR (name);
+ if (var && DECL_RTL_IF_SET (var) == pc_rtx)
+ SET_DECL_RTL (var, NULL);
+ /* Check that the pseudos chosen by assign_parms are those of
+ the corresponding default defs. */
+ else if (SSA_NAME_IS_DEFAULT_DEF (name)
+ && (TREE_CODE (var) == PARM_DECL
+ || TREE_CODE (var) == RESULT_DECL))
{
- tree leader = partition_to_var (SA.map, part);
- gcc_assert (SSA_NAME_VAR (leader) != NULL_TREE);
- replace_ssa_name_symbol (name, SSA_NAME_VAR (leader));
+ rtx in = DECL_RTL_IF_SET (var);
+ gcc_assert (in);
+ rtx out = SA.partition_to_pseudo[part];
+ gcc_assert (in == out || rtx_equal_p (in, out));
}
- if (!POINTER_TYPE_P (TREE_TYPE (name)))
- continue;
-
- r = SA.partition_to_pseudo[part];
- if (REG_P (r))
- mark_reg_pointer (r, get_pointer_alignment (name));
}
/* If this function is `main', emit a call to `__main'
diff --git a/gcc/cfgexpand.h b/gcc/cfgexpand.h
index a0b6e3e..987cf356 100644
--- a/gcc/cfgexpand.h
+++ b/gcc/cfgexpand.h
@@ -22,5 +22,8 @@ along with GCC; see the file COPYING3. If not see
extern tree gimple_assign_rhs_to_tree (gimple);
extern HOST_WIDE_INT estimated_stack_frame_size (struct cgraph_node *);
+extern bool parm_maybe_byref_p (tree);
+extern rtx get_rtl_for_parm_ssa_default_def (tree var);
+
#endif /* GCC_CFGEXPAND_H */
diff --git a/gcc/common.opt b/gcc/common.opt
index 8f25f8b..6d47e94 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -2230,16 +2230,16 @@ Common Report Var(flag_tree_ch) Optimization
Enable loop header copying on trees
ftree-coalesce-inlined-vars
-Common Report Var(flag_ssa_coalesce_vars,1) Init(2) RejectNegative Optimization
-Enable coalescing of copy-related user variables that are inlined
+Common Ignore RejectNegative
+Does nothing. Preserved for backward compatibility.
ftree-coalesce-vars
-Common Report Var(flag_ssa_coalesce_vars,2) Optimization
-Enable coalescing of all copy-related user variables
+Common Report Var(flag_tree_coalesce_vars) Optimization
+Enable SSA coalescing of user variables
ftree-copyrename
-Common Report Var(flag_tree_copyrename) Optimization
-Replace SSA temporaries with better names in copies
+Common Ignore
+Does nothing. Preserved for backward compatibility.
ftree-copy-prop
Common Report Var(flag_tree_copy_prop) Optimization
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 7b5d86b..fcb1d36 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -341,7 +341,6 @@ Objective-C and Objective-C++ Dialects}.
-fdump-tree-phiprop@r{[}-@var{n}@r{]} @gol
-fdump-tree-phiopt@r{[}-@var{n}@r{]} @gol
-fdump-tree-forwprop@r{[}-@var{n}@r{]} @gol
--fdump-tree-copyrename@r{[}-@var{n}@r{]} @gol
-fdump-tree-nrv -fdump-tree-vect @gol
-fdump-tree-sink @gol
-fdump-tree-sra@r{[}-@var{n}@r{]} @gol
@@ -447,9 +446,8 @@ Objective-C and Objective-C++ Dialects}.
-fstack-protector-explicit -fstdarg-opt -fstrict-aliasing @gol
-fstrict-overflow -fthread-jumps -ftracer -ftree-bit-ccp @gol
-ftree-builtin-call-dce -ftree-ccp -ftree-ch @gol
--ftree-coalesce-inline-vars -ftree-coalesce-vars -ftree-copy-prop @gol
--ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse @gol
--ftree-forwprop -ftree-fre -ftree-loop-if-convert @gol
+-ftree-coalesce-vars -ftree-copy-prop -ftree-dce -ftree-dominator-opts @gol
+-ftree-dse -ftree-forwprop -ftree-fre -ftree-loop-if-convert @gol
-ftree-loop-if-convert-stores -ftree-loop-im @gol
-ftree-phiprop -ftree-loop-distribution -ftree-loop-distribute-patterns @gol
-ftree-loop-ivcanon -ftree-loop-linear -ftree-loop-optimize @gol
@@ -7114,11 +7112,6 @@ name is made by appending @file{.phiopt} to the source file name.
Dump each function after forward propagating single use variables. The file
name is made by appending @file{.forwprop} to the source file name.
-@item copyrename
-@opindex fdump-tree-copyrename
-Dump each function after applying the copy rename optimization. The file
-name is made by appending @file{.copyrename} to the source file name.
-
@item nrv
@opindex fdump-tree-nrv
Dump each function after applying the named return value optimization on
@@ -7583,8 +7576,8 @@ compilation time.
-ftree-ccp @gol
-fssa-phiopt @gol
-ftree-ch @gol
+-ftree-coalesce-vars @gol
-ftree-copy-prop @gol
--ftree-copyrename @gol
-ftree-dce @gol
-ftree-dominator-opts @gol
-ftree-dse @gol
@@ -8848,6 +8841,15 @@ be parallelized. Parallelize all the loops that can be analyzed to
not contain loop carried dependences without checking that it is
profitable to parallelize the loops.
+@item -ftree-coalesce-vars
+@opindex ftree-coalesce-vars
+Tell the compiler to attempt to combine small user-defined variables
+too, instead of just compiler temporaries. This may severely limit the
+ability to debug an optimized program compiled with
+@option{-fno-var-tracking-assignments}. In the negated form, this flag
+prevents SSA coalescing of user variables. This option is enabled by
+default if optimization is enabled.
+
@item -ftree-loop-if-convert
@opindex ftree-loop-if-convert
Attempt to transform conditional jumps in the innermost loops to
@@ -8961,32 +8963,6 @@ Perform scalar replacement of aggregates. This pass replace [...]
references with scalars to prevent committing structures to memory too
early. This flag is enabled by default at @option{-O} and higher.
-@item -ftree-copyrename
-@opindex ftree-copyrename
-Perform copy renaming on trees. This pass attempts to rename compiler
-temporaries to other variables at copy locations, usually resulting in
-variable names which more closely resemble the original variables. This flag
-is enabled by default at @option{-O} and higher.
-
-@item -ftree-coalesce-inlined-vars
-@opindex ftree-coalesce-inlined-vars
-Tell the copyrename pass (see @option{-ftree-copyrename}) to attempt to
-combine small user-defined variables too, but only if they are inlined
-from other functions. It is a more limited form of
-@option{-ftree-coalesce-vars}. This may harm debug information of such
-inlined variables, but it keeps variables of the inlined-into
-function apart from each other, such that they are more likely to
-contain the expected values in a debugging session.
-
-@item -ftree-coalesce-vars
-@opindex ftree-coalesce-vars
-Tell the copyrename pass (see @option{-ftree-copyrename}) to attempt to
-combine small user-defined variables too, instead of just compiler
-temporaries. This may severely limit the ability to debug an optimized
-program compiled with @option{-fno-var-tracking-assignments}. In the
-negated form, this flag prevents SSA coalescing of user variables,
-including inlined ones. This option is enabled by default.
-
@item -ftree-ter
@opindex ftree-ter
Perform temporary expression replacement during the SSA->normal phase. Single
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index ed2b30b..3b95c5d 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "builtins.h"
#include "rtl-iter.h"
+#include "stor-layout.h"
struct target_rtl default_target_rtl;
#if SWITCHABLE_TARGET
@@ -1232,6 +1233,9 @@ set_reg_attrs_for_parm (rtx parm_rtx, rtx mem)
void
set_reg_attrs_for_decl_rtl (tree t, rtx x)
{
+ if (!t)
+ return;
+ tree tdecl = t;
if (GET_CODE (x) == SUBREG)
{
gcc_assert (subreg_lowpart_p (x));
@@ -1240,7 +1244,9 @@ set_reg_attrs_for_decl_rtl (tree t, rtx x)
if (REG_P (x))
REG_ATTRS (x)
= get_reg_attrs (t, byte_lowpart_offset (GET_MODE (x),
- DECL_MODE (t)));
+ DECL_P (tdecl)
+ ? DECL_MODE (tdecl)
+ : TYPE_MODE (TREE_TYPE (tdecl))));
if (GET_CODE (x) == CONCAT)
{
if (REG_P (XEXP (x, 0)))
diff --git a/gcc/explow.c b/gcc/explow.c
index bd342c1..6941f4e 100644
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -842,6 +842,35 @@ promote_decl_mode (const_tree decl, int *punsignedp)
return pmode;
}
+/* Return the promoted mode for name. If it is a named SSA_NAME, it
+ is the same as promote_decl_mode. Otherwise, it is the promoted
+ mode of a temp decl of same type as the SSA_NAME, if we had created
+ one. */
+
+machine_mode
+promote_ssa_mode (const_tree name, int *punsignedp)
+{
+ gcc_assert (TREE_CODE (name) == SSA_NAME);
+
+ /* Partitions holding parms and results must be promoted as expected
+ by function.c. */
+ if (SSA_NAME_VAR (name)
+ && (TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL
+ || TREE_CODE (SSA_NAME_VAR (name)) == RESULT_DECL))
+ return promote_decl_mode (SSA_NAME_VAR (name), punsignedp);
+
+ tree type = TREE_TYPE (name);
+ int unsignedp = TYPE_UNSIGNED (type);
+ machine_mode mode = TYPE_MODE (type);
+
+ machine_mode pmode = promote_mode (type, mode, &unsignedp);
+ if (punsignedp)
+ *punsignedp = unsignedp;
+
+ return pmode;
+}
+
+
/* Controls the behaviour of {anti_,}adjust_stack. */
static bool suppress_reg_args_size;
diff --git a/gcc/explow.h b/gcc/explow.h
index 94613de..52113db 100644
--- a/gcc/explow.h
+++ b/gcc/explow.h
@@ -57,6 +57,9 @@ extern machine_mode promote_mode (const_tree, machine_mode, int *);
/* Return mode and signedness to use when object is promoted. */
machine_mode promote_decl_mode (const_tree, int *);
+/* Return mode and signedness to use when object is promoted. */
+machine_mode promote_ssa_mode (const_tree, int *);
+
/* Remove some bytes from the stack. An rtx says how many. */
extern void adjust_stack (rtx);
diff --git a/gcc/expr.c b/gcc/expr.c
index 899a42c..fc49f92 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -3022,7 +3022,7 @@ write_complex_part (rtx cplx, rtx val, bool imag_p)
/* Extract one of the components of the complex value CPLX. Extract the
real part if IMAG_P is false, and the imaginary part if it's true. */
-static rtx
+rtx
read_complex_part (rtx cplx, bool imag_p)
{
machine_mode cmode, imode;
@@ -9246,7 +9246,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
rtx op0, op1, temp, decl_rtl;
tree type;
int unsignedp;
- machine_mode mode;
+ machine_mode mode, dmode;
enum tree_code code = TREE_CODE (exp);
rtx subtarget, original_target;
int ignore;
@@ -9377,7 +9377,8 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
if (g == NULL
&& modifier == EXPAND_INITIALIZER
&& !SSA_NAME_IS_DEFAULT_DEF (exp)
- && (optimize || DECL_IGNORED_P (SSA_NAME_VAR (exp)))
+ && (optimize || !SSA_NAME_VAR (exp)
+ || DECL_IGNORED_P (SSA_NAME_VAR (exp)))
&& stmt_is_replaceable_p (SSA_NAME_DEF_STMT (exp)))
g = SSA_NAME_DEF_STMT (exp);
if (g)
@@ -9456,15 +9457,18 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
/* Ensure variable marked as used even if it doesn't go through
a parser. If it hasn't be used yet, write out an external
definition. */
- TREE_USED (exp) = 1;
+ if (exp)
+ TREE_USED (exp) = 1;
/* Show we haven't gotten RTL for this yet. */
temp = 0;
/* Variables inherited from containing functions should have
been lowered by this point. */
- context = decl_function_context (exp);
- gcc_assert (SCOPE_FILE_SCOPE_P (context)
+ if (exp)
+ context = decl_function_context (exp);
+ gcc_assert (!exp
+ || SCOPE_FILE_SCOPE_P (context)
|| context == current_function_decl
|| TREE_STATIC (exp)
|| DECL_EXTERNAL (exp)
@@ -9488,7 +9492,8 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
decl_rtl = use_anchored_address (decl_rtl);
if (modifier != EXPAND_CONST_ADDRESS
&& modifier != EXPAND_SUM
- && !memory_address_addr_space_p (DECL_MODE (exp),
+ && !memory_address_addr_space_p (exp ? DECL_MODE (exp)
+ : GET_MODE (decl_rtl),
XEXP (decl_rtl, 0),
MEM_ADDR_SPACE (decl_rtl)))
temp = replace_equiv_address (decl_rtl,
@@ -9499,12 +9504,17 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
if the address is a register. */
if (temp != 0)
{
- if (MEM_P (temp) && REG_P (XEXP (temp, 0)))
+ if (exp && MEM_P (temp) && REG_P (XEXP (temp, 0)))
mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
return temp;
}
+ if (exp)
+ dmode = DECL_MODE (exp);
+ else
+ dmode = TYPE_MODE (TREE_TYPE (ssa_name));
+
/* If the mode of DECL_RTL does not match that of the decl,
there are two cases: we are dealing with a BLKmode value
that is returned in a register, or we are dealing with
@@ -9512,22 +9522,23 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
of the wanted mode, but mark it so that we know that it
was already extended. */
if (REG_P (decl_rtl)
- && DECL_MODE (exp) != BLKmode
- && GET_MODE (decl_rtl) != DECL_MODE (exp))
+ && dmode != BLKmode
+ && GET_MODE (decl_rtl) != dmode)
{
machine_mode pmode;
/* Get the signedness to be used for this variable. Ensure we get
the same mode we got when the variable was declared. */
- if (code == SSA_NAME
- && (g = SSA_NAME_DEF_STMT (ssa_name))
- && gimple_code (g) == GIMPLE_CALL
- && !gimple_call_internal_p (g))
+ if (code != SSA_NAME)
+ pmode = promote_decl_mode (exp, &unsignedp);
+ else if ((g = SSA_NAME_DEF_STMT (ssa_name))
+ && gimple_code (g) == GIMPLE_CALL
+ && !gimple_call_internal_p (g))
pmode = promote_function_mode (type, mode, &unsignedp,
gimple_call_fntype (g),
2);
else
- pmode = promote_decl_mode (exp, &unsignedp);
+ pmode = promote_ssa_mode (ssa_name, &unsignedp);
gcc_assert (GET_MODE (decl_rtl) == pmode);
temp = gen_lowpart_SUBREG (mode, decl_rtl);
diff --git a/gcc/expr.h b/gcc/expr.h
index 32d1707..a2c8e1d 100644
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -210,6 +210,7 @@ extern rtx_insn *emit_move_insn_1 (rtx, rtx);
extern rtx_insn *emit_move_complex_push (machine_mode, rtx, rtx);
extern rtx_insn *emit_move_complex_parts (rtx, rtx);
+extern rtx read_complex_part (rtx, bool);
extern void write_complex_part (rtx, rtx, bool);
extern rtx emit_move_resolve_push (machine_mode, rtx);
diff --git a/gcc/function.c b/gcc/function.c
index f9d11bf..1d98ede 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -72,6 +72,9 @@ along with GCC; see the file COPYING3. If not see
#include "cfganal.h"
#include "cfgbuild.h"
#include "cfgcleanup.h"
+#include "cfgexpand.h"
+#include "basic-block.h"
+#include "df.h"
#include "params.h"
#include "bb-reorder.h"
#include "shrink-wrap.h"
@@ -148,6 +151,9 @@ static bool contains (const_rtx, hash_table<insn_cache_hasher> *);
static void prepare_function_start (void);
static void do_clobber_return_reg (rtx, void *);
static void do_use_return_reg (rtx, void *);
+static rtx rtl_for_parm (struct assign_parm_data_all *, tree);
+static void maybe_reset_rtl_for_parm (tree);
+
/* Stack of nested functions. */
/* Keep track of the cfun stack. */
@@ -2105,6 +2111,30 @@ aggregate_value_p (const_tree exp, const_tree fntype)
bool
use_register_for_decl (const_tree decl)
{
+ if (TREE_CODE (decl) == SSA_NAME)
+ {
+ /* We often try to use the SSA_NAME, instead of its underlying
+ decl, to get type information and guide decisions, to avoid
+ differences of behavior between anonymous and named
+ variables, but in this one case we have to go for the actual
+ variable if there is one. The main reason is that, at least
+ at -O0, we want to place user variables on the stack, but we
+ don't mind using pseudos for anonymous or ignored temps.
+ Should we take the SSA_NAME, we'd conclude all SSA_NAMEs
+ should go in pseudos, whereas their corresponding variables
+ might have to go on the stack. So, disregarding the decl
+ here would negatively impact debug info at -O0, enable
+ coalescing between SSA_NAMEs that ought to get different
+ stack/pseudo assignments, and get the incoming argument
+ processing thoroughly confused by PARM_DECLs expected to live
+ in stack slots but assigned to pseudos. */
+ if (!SSA_NAME_VAR (decl))
+ return TYPE_MODE (TREE_TYPE (decl)) != BLKmode
+ && !(flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)));
+
+ decl = SSA_NAME_VAR (decl);
+ }
+
if (!targetm.calls.allocate_stack_slots_for_args ())
return true;
@@ -2240,7 +2270,7 @@ assign_parms_initialize_all (struct assign_parm_data_all *all)
needed, else the old list. */
static void
-split_complex_args (vec<tree> *args)
+split_complex_args (struct assign_parm_data_all *all, vec<tree> *args)
{
unsigned i;
tree p;
@@ -2251,6 +2281,7 @@ split_complex_args (vec<tree> *args)
if (TREE_CODE (type) == COMPLEX_TYPE
&& targetm.calls.split_complex_arg (type))
{
+ tree cparm = p;
tree decl;
tree subtype = TREE_TYPE (type);
bool addressable = TREE_ADDRESSABLE (p);
@@ -2269,6 +2300,9 @@ split_complex_args (vec<tree> *args)
DECL_ARTIFICIAL (p) = addressable;
DECL_IGNORED_P (p) = addressable;
TREE_ADDRESSABLE (p) = 0;
+ /* Reset the RTL before layout_decl, or it may change the
+ mode of the RTL of the original argument copied to P. */
+ SET_DECL_RTL (p, NULL_RTX);
layout_decl (p, 0);
(*args)[i] = p;
@@ -2280,6 +2314,25 @@ split_complex_args (vec<tree> *args)
DECL_IGNORED_P (decl) = addressable;
layout_decl (decl, 0);
args->safe_insert (++i, decl);
+
+ /* If we are expanding a function, rather than gimplifying
+ it, propagate the RTL of the complex parm to the split
+ declarations, and set their contexts so that
+ maybe_reset_rtl_for_parm can recognize them and refrain
+ from resetting their RTL. */
+ if (currently_expanding_to_rtl)
+ {
+ maybe_reset_rtl_for_parm (cparm);
+ rtx rtl = rtl_for_parm (all, cparm);
+ if (rtl)
+ {
+ SET_DECL_RTL (p, read_complex_part (rtl, false));
+ SET_DECL_RTL (decl, read_complex_part (rtl, true));
+
+ DECL_CONTEXT (p) = cparm;
+ DECL_CONTEXT (decl) = cparm;
+ }
+ }
}
}
}
@@ -2342,7 +2395,7 @@ assign_parms_augmented_arg_list (struct assign_parm_data_all *all)
/* If the target wants to split complex arguments into scalars, do so. */
if (targetm.calls.split_complex_arg)
- split_complex_args (&fnargs);
+ split_complex_args (all, &fnargs);
return fnargs;
}
@@ -2745,23 +2798,98 @@ assign_parm_remove_parallels (struct assign_parm_data_one *data)
data->entry_parm = entry_parm;
}
+/* Wrapper for use_register_for_decl, that special-cases the
+ .result_ptr as the function's RESULT_DECL when the RESULT_DECL is
+ passed by reference. */
+
+static bool
+use_register_for_parm_decl (struct assign_parm_data_all *all, tree parm)
+{
+ if (parm == all->function_result_decl)
+ {
+ tree result = DECL_RESULT (current_function_decl);
+
+ if (DECL_BY_REFERENCE (result))
+ parm = result;
+ }
+
+ return use_register_for_decl (parm);
+}
+
+/* Wrapper for get_rtl_for_parm_ssa_default_def, that special-cases
+ the .result_ptr as the function's RESULT_DECL when the RESULT_DECL
+ is passed by reference. */
+
+static rtx
+rtl_for_parm (struct assign_parm_data_all *all, tree parm)
+{
+ if (parm == all->function_result_decl)
+ {
+ tree result = DECL_RESULT (current_function_decl);
+
+ if (!DECL_BY_REFERENCE (result))
+ return NULL_RTX;
+
+ parm = result;
+ }
+
+ return get_rtl_for_parm_ssa_default_def (parm);
+}
+
+/* Reset the location of PARM_DECLs and RESULT_DECLs that had
+ SSA_NAMEs in multiple partitions, so that assign_parms will choose
+ the default def, if it exists, or create new RTL to hold the unused
+ entry value. If we are coalescing across variables, we want to
+ reset the location too, because a parm without a default def
+ (incoming value unused) might be coalesced with one with a default
+ def, and then assign_parms would copy both incoming values to the
+ same location, which might cause the wrong value to survive. */
+static void
+maybe_reset_rtl_for_parm (tree parm)
+{
+ gcc_assert (TREE_CODE (parm) == PARM_DECL
+ || TREE_CODE (parm) == RESULT_DECL);
+
+ /* This is a split complex parameter, and its context was set to its
+ original PARM_DECL in split_complex_args so that we could
+ recognize it here and not reset its RTL. */
+ if (DECL_CONTEXT (parm) && TREE_CODE (DECL_CONTEXT (parm)) == PARM_DECL)
+ {
+ DECL_CONTEXT (parm) = DECL_CONTEXT (DECL_CONTEXT (parm));
+ return;
+ }
+
+ if ((flag_tree_coalesce_vars
+ || (DECL_RTL_SET_P (parm) && DECL_RTL (parm) == pc_rtx))
+ && is_gimple_reg (parm))
+ SET_DECL_RTL (parm, NULL_RTX);
+}
+
/* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
always valid and properly aligned. */
static void
-assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data)
+assign_parm_adjust_stack_rtl (struct assign_parm_data_all *all, tree parm,
+ struct assign_parm_data_one *data)
{
rtx stack_parm = data->stack_parm;
+ /* If out-of-SSA assigned RTL to the parm default def, make sure we
+ don't use what we might have computed before. */
+ rtx ssa_assigned = rtl_for_parm (all, parm);
+ if (ssa_assigned)
+ stack_parm = NULL;
+
/* If we can't trust the parm stack slot to be aligned enough for its
ultimate type, don't use that slot after entry. We'll make another
stack slot, if we need one. */
- if (stack_parm
- && ((STRICT_ALIGNMENT
- && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm))
- || (data->nominal_type
- && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
- && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
+ else if (stack_parm
+ && ((STRICT_ALIGNMENT
+ && (GET_MODE_ALIGNMENT (data->nominal_mode)
+ > MEM_ALIGN (stack_parm)))
+ || (data->nominal_type
+ && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
+ && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
stack_parm = NULL;
/* If parm was passed in memory, and we need to convert it on entry,
@@ -2823,14 +2951,32 @@ assign_parm_setup_block (struct assign_parm_data_all *all,
size = int_size_in_bytes (data->passed_type);
size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
+
if (stack_parm == 0)
{
DECL_ALIGN (parm) = MAX (DECL_ALIGN (parm), BITS_PER_WORD);
- stack_parm = assign_stack_local (BLKmode, size_stored,
- DECL_ALIGN (parm));
- if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size)
- PUT_MODE (stack_parm, GET_MODE (entry_parm));
- set_mem_attributes (stack_parm, parm, 1);
+ rtx from_expand = rtl_for_parm (all, parm);
+ if (from_expand && (!parm_maybe_byref_p (parm)
+ || XEXP (from_expand, 0) != NULL_RTX))
+ stack_parm = copy_rtx (from_expand);
+ else
+ {
+ stack_parm = assign_stack_local (BLKmode, size_stored,
+ DECL_ALIGN (parm));
+ if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size)
+ PUT_MODE (stack_parm, GET_MODE (entry_parm));
+ if (from_expand)
+ {
+ gcc_assert (GET_CODE (stack_parm) == MEM);
+ gcc_assert (GET_CODE (from_expand) == MEM);
+ gcc_assert (XEXP (from_expand, 0) == NULL_RTX);
+ XEXP (from_expand, 0) = XEXP (stack_parm, 0);
+ PUT_MODE (from_expand, GET_MODE (stack_parm));
+ stack_parm = copy_rtx (from_expand);
+ }
+ else
+ set_mem_attributes (stack_parm, parm, 1);
+ }
}
/* If a BLKmode arrives in registers, copy it to a stack slot. Handle
@@ -2968,14 +3114,34 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
= promote_function_mode (data->nominal_type, data->nominal_mode, &unsignedp,
TREE_TYPE (current_function_decl), 2);
- parmreg = gen_reg_rtx (promoted_nominal_mode);
+ rtx from_expand = parmreg = rtl_for_parm (all, parm);
- if (!DECL_ARTIFICIAL (parm))
- mark_user_reg (parmreg);
+ if (from_expand && !data->passed_pointer)
+ {
+ if (GET_MODE (parmreg) != promoted_nominal_mode)
+ parmreg = gen_lowpart (promoted_nominal_mode, parmreg);
+ }
+ else if (!from_expand || parm_maybe_byref_p (parm))
+ {
+ parmreg = gen_reg_rtx (promoted_nominal_mode);
+ if (!DECL_ARTIFICIAL (parm))
+ mark_user_reg (parmreg);
+
+ if (from_expand)
+ {
+ gcc_assert (data->passed_pointer);
+ gcc_assert (GET_CODE (from_expand) == MEM
+ && GET_MODE (from_expand) == BLKmode
+ && XEXP (from_expand, 0) == NULL_RTX);
+ XEXP (from_expand, 0) = parmreg;
+ }
+ }
/* If this was an item that we received a pointer to,
set DECL_RTL appropriately. */
- if (data->passed_pointer)
+ if (from_expand)
+ SET_DECL_RTL (parm, from_expand);
+ else if (data->passed_pointer)
{
rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->passed_type)), parmreg);
set_mem_attributes (x, parm, 1);
@@ -2990,10 +3156,13 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
assign_parm_find_data_types and expand_expr_real_1. */
equiv_stack_parm = data->stack_parm;
+ if (!equiv_stack_parm)
+ equiv_stack_parm = data->entry_parm;
validated_mem = validize_mem (copy_rtx (data->entry_parm));
need_conversion = (data->nominal_mode != data->passed_mode
|| promoted_nominal_mode != data->promoted_mode);
+ gcc_assert (!(need_conversion && data->passed_pointer && from_expand));
moved = false;
if (need_conversion
@@ -3125,16 +3294,28 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
did_conversion = true;
}
- else
+ /* We don't want to copy the incoming pointer to a parmreg expected
+ to hold the value rather than the pointer. */
+ else if (!data->passed_pointer || parmreg != from_expand)
emit_move_insn (parmreg, validated_mem);
/* If we were passed a pointer but the actual value can safely live
in a register, retrieve it and use it directly. */
- if (data->passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode)
+ if (data->passed_pointer
+ && (from_expand || TYPE_MODE (TREE_TYPE (parm)) != BLKmode))
{
+ rtx src = DECL_RTL (parm);
+
/* We can't use nominal_mode, because it will have been set to
Pmode above. We must use the actual mode of the parm. */
- if (use_register_for_decl (parm))
+ if (from_expand)
+ {
+ parmreg = from_expand;
+ gcc_assert (GET_MODE (parmreg) == TYPE_MODE (TREE_TYPE (parm)));
+ src = gen_rtx_MEM (GET_MODE (parmreg), validated_mem);
+ set_mem_attributes (src, parm, 1);
+ }
+ else if (use_register_for_decl (parm))
{
parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
mark_user_reg (parmreg);
@@ -3151,14 +3332,14 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
set_mem_attributes (parmreg, parm, 1);
}
- if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
+ if (GET_MODE (parmreg) != GET_MODE (src))
{
- rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
+ rtx tempreg = gen_reg_rtx (GET_MODE (src));
int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm));
push_to_sequence2 (all->first_conversion_insn,
all->last_conversion_insn);
- emit_move_insn (tempreg, DECL_RTL (parm));
+ emit_move_insn (tempreg, src);
tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p);
emit_move_insn (parmreg, tempreg);
all->first_conversion_insn = get_insns ();
@@ -3167,14 +3348,16 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
did_conversion = true;
}
+ else if (GET_MODE (parmreg) == BLKmode)
+ gcc_assert (parm_maybe_byref_p (parm));
else
- emit_move_insn (parmreg, DECL_RTL (parm));
+ emit_move_insn (parmreg, src);
SET_DECL_RTL (parm, parmreg);
/* STACK_PARM is the pointer, not the parm, and PARMREG is
now the parm. */
- data->stack_parm = NULL;
+ data->stack_parm = equiv_stack_parm = NULL;
}
/* Mark the register as eliminable if we did no conversion and it was
@@ -3184,11 +3367,11 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
make here would screw up life analysis for it. */
if (data->nominal_mode == data->passed_mode
&& !did_conversion
- && data->stack_parm != 0
- && MEM_P (data->stack_parm)
+ && equiv_stack_parm != 0
+ && MEM_P (equiv_stack_parm)
&& data->locate.offset.var == 0
&& reg_mentioned_p (virtual_incoming_args_rtx,
- XEXP (data->stack_parm, 0)))
+ XEXP (equiv_stack_parm, 0)))
{
rtx_insn *linsn = get_last_insn ();
rtx_insn *sinsn;
@@ -3201,8 +3384,8 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
= GET_MODE_INNER (GET_MODE (parmreg));
int regnor = REGNO (XEXP (parmreg, 0));
int regnoi = REGNO (XEXP (parmreg, 1));
- rtx stackr = adjust_address_nv (data->stack_parm, submode, 0);
- rtx stacki = adjust_address_nv (data->stack_parm, submode,
+ rtx stackr = adjust_address_nv (equiv_stack_parm, submode, 0);
+ rtx stacki = adjust_address_nv (equiv_stack_parm, submode,
GET_MODE_SIZE (submode));
/* Scan backwards for the set of the real and
@@ -3275,6 +3458,13 @@ assign_parm_setup_stack (struct assign_parm_data_all *all, t [...]
if (data->stack_parm == 0)
{
+ rtx x = data->stack_parm = rtl_for_parm (all, parm);
+ if (x)
+ gcc_assert (GET_MODE (x) == GET_MODE (data->entry_parm));
+ }
+
+ if (data->stack_parm == 0)
+ {
int align = STACK_SLOT_ALIGNMENT (data->passed_type,
GET_MODE (data->entry_parm),
TYPE_ALIGN (data->passed_type));
@@ -3337,11 +3527,21 @@ assign_parms_unsplit_complex (struct assign_parm_data_all *all,
imag = DECL_RTL (fnargs[i + 1]);
if (inner != GET_MODE (real))
{
- real = gen_lowpart_SUBREG (inner, real);
- imag = gen_lowpart_SUBREG (inner, imag);
+ real = simplify_gen_subreg (inner, real, GET_MODE (real),
+ subreg_lowpart_offset
+ (inner, GET_MODE (real)));
+ imag = simplify_gen_subreg (inner, imag, GET_MODE (imag),
+ subreg_lowpart_offset
+ (inner, GET_MODE (imag)));
}
- if (TREE_ADDRESSABLE (parm))
+ if ((tmp = rtl_for_parm (all, parm)) != NULL_RTX
+ && rtx_equal_p (real,
+ read_complex_part (tmp, false))
+ && rtx_equal_p (imag,
+ read_complex_part (tmp, true)))
+ ; /* We now have the right rtl in tmp. */
+ else if (TREE_ADDRESSABLE (parm))
{
rtx rmem, imem;
HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm));
@@ -3487,7 +3687,7 @@ assign_bounds (vec<bounds_parm_data> &bndargs,
assign_parm_setup_block (&all, pbdata->bounds_parm,
&pbdata->parm_data);
else if (pbdata->parm_data.passed_pointer
- || use_register_for_decl (pbdata->bounds_parm))
+ || use_register_for_parm_decl (&all, pbdata->bounds_parm))
assign_parm_setup_reg (&all, pbdata->bounds_parm,
&pbdata->parm_data);
else
@@ -3531,6 +3731,8 @@ assign_parms (tree fndecl)
DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
continue;
}
+ else
+ maybe_reset_rtl_for_parm (parm);
/* Estimate stack alignment from parameter alignment. */
if (SUPPORTS_STACK_ALIGNMENT)
@@ -3580,7 +3782,9 @@ assign_parms (tree fndecl)
else
set_decl_incoming_rtl (parm, data.entry_parm, false);
- /* Boudns should be loaded in the particular order to
+ assign_parm_adjust_stack_rtl (&all, parm, &data);
+
+ /* Bounds should be loaded in the particular order to
have registers allocated correctly. Collect info about
input bounds and load them later. */
if (POINTER_BOUNDS_TYPE_P (data.passed_type))
@@ -3597,11 +3801,10 @@ assign_parms (tree fndecl)
}
else
{
- assign_parm_adjust_stack_rtl (&data);
-
if (assign_parm_setup_block_p (&data))
assign_parm_setup_block (&all, parm, &data);
- else if (data.passed_pointer || use_register_for_decl (parm))
+ else if (data.passed_pointer
+ || use_register_for_parm_decl (&all, parm))
assign_parm_setup_reg (&all, parm, &data);
else
assign_parm_setup_stack (&all, parm, &data);
@@ -4932,7 +5135,9 @@ expand_function_start (tree subr)
before any library calls that assign parms might generate. */
/* Decide whether to return the value in memory or in a register. */
- if (aggregate_value_p (DECL_RESULT (subr), subr))
+ tree res = DECL_RESULT (subr);
+ maybe_reset_rtl_for_parm (res);
+ if (aggregate_value_p (res, subr))
{
/* Returning something that won't go in a register. */
rtx value_address = 0;
@@ -4940,7 +5145,7 @@ expand_function_start (tree subr)
#ifdef PCC_STATIC_STRUCT_RETURN
if (cfun->returns_pcc_struct)
{
- int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
+ int size = int_size_in_bytes (TREE_TYPE (res));
value_address = assemble_static_space (size);
}
else
@@ -4952,36 +5157,45 @@ expand_function_start (tree subr)
it. */
if (sv)
{
- value_address = gen_reg_rtx (Pmode);
+ if (DECL_BY_REFERENCE (res))
+ value_address = get_rtl_for_parm_ssa_default_def (res);
+ if (!value_address)
+ value_address = gen_reg_rtx (Pmode);
emit_move_insn (value_address, sv);
}
}
if (value_address)
{
rtx x = value_address;
- if (!DECL_BY_REFERENCE (DECL_RESULT (subr)))
+ if (!DECL_BY_REFERENCE (res))
{
- x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), x);
- set_mem_attributes (x, DECL_RESULT (subr), 1);
+ x = get_rtl_for_parm_ssa_default_def (res);
+ if (!x)
+ {
+ x = gen_rtx_MEM (DECL_MODE (res), value_address);
+ set_mem_attributes (x, res, 1);
+ }
}
- SET_DECL_RTL (DECL_RESULT (subr), x);
+ SET_DECL_RTL (res, x);
}
}
- else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
+ else if (DECL_MODE (res) == VOIDmode)
/* If return mode is void, this decl rtl should not be used. */
- SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
+ SET_DECL_RTL (res, NULL_RTX);
else
{
/* Compute the return values into a pseudo reg, which we will copy
into the true return register after the cleanups are done. */
- tree return_type = TREE_TYPE (DECL_RESULT (subr));
- if (TYPE_MODE (return_type) != BLKmode
- && targetm.calls.return_in_msb (return_type))
+ tree return_type = TREE_TYPE (res);
+ rtx x = get_rtl_for_parm_ssa_default_def (res);
+ if (x)
+ /* Use it. */;
+ else if (TYPE_MODE (return_type) != BLKmode
+ && targetm.calls.return_in_msb (return_type))
/* expand_function_end will insert the appropriate padding in
this case. Use the return value's natural (unpadded) mode
within the function proper. */
- SET_DECL_RTL (DECL_RESULT (subr),
- gen_reg_rtx (TYPE_MODE (return_type)));
+ x = gen_reg_rtx (TYPE_MODE (return_type));
else
{
/* In order to figure out what mode to use for the pseudo, we
@@ -4992,25 +5206,26 @@ expand_function_start (tree subr)
/* Structures that are returned in registers are not
aggregate_value_p, so we may see a PARALLEL or a REG. */
if (REG_P (hard_reg))
- SET_DECL_RTL (DECL_RESULT (subr),
- gen_reg_rtx (GET_MODE (hard_reg)));
+ x = gen_reg_rtx (GET_MODE (hard_reg));
else
{
gcc_assert (GET_CODE (hard_reg) == PARALLEL);
- SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
+ x = gen_group_rtx (hard_reg);
}
}
+ SET_DECL_RTL (res, x);
+
/* Set DECL_REGISTER flag so that expand_function_end will copy the
result to the real return register(s). */
- DECL_REGISTER (DECL_RESULT (subr)) = 1;
+ DECL_REGISTER (res) = 1;
if (chkp_function_instrumented_p (current_function_decl))
{
- tree return_type = TREE_TYPE (DECL_RESULT (subr));
+ tree return_type = TREE_TYPE (res);
rtx bounds = targetm.calls.chkp_function_value_bounds (return_type,
subr, 1);
- SET_DECL_BOUNDS_RTL (DECL_RESULT (subr), bounds);
+ SET_DECL_BOUNDS_RTL (res, bounds);
}
}
@@ -5025,13 +5240,19 @@ expand_function_start (tree subr)
rtx local, chain;
rtx_insn *insn;
- local = gen_reg_rtx (Pmode);
+ local = get_rtl_for_parm_ssa_default_def (parm);
+ if (!local)
+ local = gen_reg_rtx (Pmode);
chain = targetm.calls.static_chain (current_function_decl, true);
set_decl_incoming_rtl (parm, chain, false);
SET_DECL_RTL (parm, local);
mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
+ if (GET_MODE (local) != Pmode)
+ local = convert_to_mode (Pmode, local,
+ TYPE_UNSIGNED (TREE_TYPE (parm)));
+
insn = emit_move_insn (local, chain);
/* Mark the register as eliminable, similar to parameters. */
diff --git a/gcc/gimple-expr.c b/gcc/gimple-expr.c
index b558d90..baed630 100644
--- a/gcc/gimple-expr.c
+++ b/gcc/gimple-expr.c
@@ -375,45 +375,6 @@ copy_var_decl (tree var, tree name, tree type)
return copy;
}
-/* Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for
- coalescing together, false otherwise.
-
- This must stay consistent with var_map_base_init in tree-ssa-live.c. */
-
-bool
-gimple_can_coalesce_p (tree name1, tree name2)
-{
- /* First check the SSA_NAME's associated DECL. We only want to
- coalesce if they have the same DECL or both have no associated DECL. */
- tree var1 = SSA_NAME_VAR (name1);
- tree var2 = SSA_NAME_VAR (name2);
- var1 = (var1 && (!VAR_P (var1) || !DECL_IGNORED_P (var1))) ? var1 : NULL_TREE;
- var2 = (var2 && (!VAR_P (var2) || !DECL_IGNORED_P (var2))) ? var2 : NULL_TREE;
- if (var1 != var2)
- return false;
-
- /* Now check the types. If the types are the same, then we should
- try to coalesce V1 and V2. */
- tree t1 = TREE_TYPE (name1);
- tree t2 = TREE_TYPE (name2);
- if (t1 == t2)
- return true;
-
- /* If the types are not the same, check for a canonical type match. This
- (for example) allows coalescing when the types are fundamentally the
- same, but just have different names.
-
- Note pointer types with different address spaces may have the same
- canonical type. Those are rejected for coalescing by the
- types_compatible_p check. */
- if (TYPE_CANONICAL (t1)
- && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2)
- && types_compatible_p (t1, t2))
- return true;
-
- return false;
-}
-
/* Strip off a legitimate source ending from the input string NAME of
length LEN. Rather than having to know the names used by all of
our front ends, we strip off an ending of a period followed by
diff --git a/gcc/gimple-expr.h b/gcc/gimple-expr.h
index ed23eb2..3d1c89f 100644
--- a/gcc/gimple-expr.h
+++ b/gcc/gimple-expr.h
@@ -28,7 +28,6 @@ extern gimple_seq gimple_body (tree);
extern bool gimple_has_body_p (tree);
extern const char *gimple_decl_printable_name (tree, int);
extern tree copy_var_decl (tree, tree, tree);
-extern bool gimple_can_coalesce_p (tree, tree);
extern tree create_tmp_var_name (const char *);
extern tree create_tmp_var_raw (tree, const char * = NULL);
extern tree create_tmp_var (tree, const char * = NULL);
diff --git a/gcc/opts.c b/gcc/opts.c
index 468a802..f22edd3 100644
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -445,12 +445,12 @@ static const struct default_options default_options_table[] =
{ OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_bit_ccp, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_coalesce_vars, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_sra, NULL, 1 },
- { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
diff --git a/gcc/passes.def b/gcc/passes.def
index 6b66f8f..64fc4d9 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -77,7 +77,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_all_early_optimizations);
PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
NEXT_PASS (pass_remove_cgraph_callee_edges);
- NEXT_PASS (pass_rename_ssa_copies);
NEXT_PASS (pass_object_sizes);
NEXT_PASS (pass_ccp);
/* After CCP we rewrite no longer addressed locals into SSA
@@ -155,7 +154,6 @@ along with GCC; see the file COPYING3. If not see
/* Initial scalar cleanups before alias computation.
They ensure memory accesses are not indirect wherever possible. */
NEXT_PASS (pass_strip_predict_hints);
- NEXT_PASS (pass_rename_ssa_copies);
NEXT_PASS (pass_ccp);
/* After CCP we rewrite no longer addressed locals into SSA
form if possible. */
@@ -183,7 +181,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_ch);
NEXT_PASS (pass_lower_complex);
NEXT_PASS (pass_sra);
- NEXT_PASS (pass_rename_ssa_copies);
/* The dom pass will also resolve all __builtin_constant_p calls
that are still there to 0. This has to be done after some
propagations have already run, but before some more dead code
@@ -293,7 +290,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_fold_builtins);
NEXT_PASS (pass_optimize_widening_mul);
NEXT_PASS (pass_tail_calls);
- NEXT_PASS (pass_rename_ssa_copies);
/* FIXME: If DCE is not run before checking for uninitialized uses,
we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
However, this also causes us to misdiagnose cases that should be
@@ -328,7 +324,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_dce);
NEXT_PASS (pass_asan);
NEXT_PASS (pass_tsan);
- NEXT_PASS (pass_rename_ssa_copies);
/* ??? We do want some kind of loop invariant motion, but we possibly
need to adjust LIM to be more friendly towards preserving accurate
debug information here. */
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 391686c..e7f7dd4 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -891,7 +891,7 @@ emit_case_decision_tree (tree index_expr, tree index_type,
{
index = copy_to_reg (index);
if (TREE_CODE (index_expr) == SSA_NAME)
- set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (index_expr), index);
+ set_reg_attrs_for_decl_rtl (index_expr, index);
}
balance_case_nodes (&case_list, NULL);
diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index 0d4f4a4..288227a 100644
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -794,7 +794,8 @@ layout_decl (tree decl, unsigned int known_align)
{
PUT_MODE (rtl, DECL_MODE (decl));
SET_DECL_RTL (decl, 0);
- set_mem_attributes (rtl, decl, 1);
+ if (MEM_P (rtl))
+ set_mem_attributes (rtl, decl, 1);
SET_DECL_RTL (decl, rtl);
}
}
diff --git a/gcc/testsuite/gcc.dg/guality/pr54200.c b/gcc/testsuite/gcc.dg/guality/ [...]
index 9b17187..e1e7293 100644
--- a/gcc/testsuite/gcc.dg/guality/pr54200.c
+++ b/gcc/testsuite/gcc.dg/guality/pr54200.c
@@ -1,6 +1,6 @@
/* PR tree-optimization/54200 */
/* { dg-do run } */
-/* { dg-options "-g -fno-var-tracking-assignments" } */
+/* { dg-options "-g -fno-var-tracking-assignments -fno-tree-coalesce-vars" } */
int o __attribute__((used));
diff --git a/gcc/testsuite/gcc.dg/ssp-1.c b/gcc/testsuite/gcc.dg/ssp-1.c
index 5467f4d..db69332 100644
--- a/gcc/testsuite/gcc.dg/ssp-1.c
+++ b/gcc/testsuite/gcc.dg/ssp-1.c
@@ -12,7 +12,7 @@ __stack_chk_fail (void)
int main ()
{
- int i;
+ register int i;
char foo[255];
// smash stack
diff --git a/gcc/testsuite/gcc.dg/ssp-2.c b/gcc/testsuite/gcc.dg/ssp-2.c
index 9a7ac32..752fe53 100644
--- a/gcc/testsuite/gcc.dg/ssp-2.c
+++ b/gcc/testsuite/gcc.dg/ssp-2.c
@@ -14,7 +14,7 @@ __stack_chk_fail (void)
void
overflow()
{
- int i = 0;
+ register int i = 0;
char foo[30];
/* Overflow buffer. */
diff --git a/gcc/testsuite/gcc.dg/torture/parm-coalesce.c b/gcc/testsuite/gcc.dg/to [...]
new file mode 100644
index 0000000..dbd81c1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/parm-coalesce.c
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+
+#include <stdlib.h>
+
+/* Make sure we don't coalesce both incoming parms, one whose incoming
+ value is unused, to the same location, so as to overwrite one of
+ them with the incoming value of the other. */
+
+int __attribute__((noinline, noclone))
+foo (int i, int j)
+{
+ j = i; /* The incoming value for J is unused. */
+ i = 2;
+ if (j)
+ j++;
+ j += i + 1;
+ return j;
+}
+
+/* Same as foo, but with swapped parameters. */
+int __attribute__((noinline, noclone))
+bar (int j, int i)
+{
+ j = i; /* The incoming value for J is unused. */
+ i = 2;
+ if (j)
+ j++;
+ j += i + 1;
+ return j;
+}
+
+int
+main (void)
+{
+ if (foo (0, 1) != 3)
+ abort ();
+ if (bar (1, 0) != 3)
+ abort ();
+ return 0;
+}
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index 7b747ab..978476c 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -279,7 +279,6 @@ insert_value_copy_on_edge (edge e, int dest, tree src, source_l [...]
rtx dest_rtx, seq, x;
machine_mode dest_mode, src_mode;
int unsignedp;
- tree var;
if (dump_file && (dump_flags & TDF_DETAILS))
{
@@ -301,12 +300,12 @@ insert_value_copy_on_edge (edge e, int dest, tree src, source [...]
start_sequence ();
- var = SSA_NAME_VAR (partition_to_var (SA.map, dest));
+ tree name = partition_to_var (SA.map, dest);
src_mode = TYPE_MODE (TREE_TYPE (src));
dest_mode = GET_MODE (dest_rtx);
- gcc_assert (src_mode == TYPE_MODE (TREE_TYPE (var)));
+ gcc_assert (src_mode == TYPE_MODE (TREE_TYPE (name)));
gcc_assert (!REG_P (dest_rtx)
- || dest_mode == promote_decl_mode (var, &unsignedp));
+ || dest_mode == promote_ssa_mode (name, &unsignedp));
if (src_mode != dest_mode)
{
@@ -682,13 +681,12 @@ elim_backward (elim_graph g, int T)
static rtx
get_temp_reg (tree name)
{
- tree var = TREE_CODE (name) == SSA_NAME ? SSA_NAME_VAR (name) : name;
- tree type = TREE_TYPE (var);
+ tree type = TREE_TYPE (name);
int unsignedp;
- machine_mode reg_mode = promote_decl_mode (var, &unsignedp);
+ machine_mode reg_mode = promote_ssa_mode (name, &unsignedp);
rtx x = gen_reg_rtx (reg_mode);
if (POINTER_TYPE_P (type))
- mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
+ mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (type)));
return x;
}
@@ -988,7 +986,7 @@ remove_ssa_form (bool perform_ter, struct ssaexpand *sa)
/* Return to viewing the variable list as just all reference variables after
coalescing has been performed. */
- partition_view_normal (map, false);
+ partition_view_normal (map);
if (dump_file && (dump_flags & TDF_DETAILS))
{
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index bf8983f..08ce72c 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -36,6 +36,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-iterator.h"
#include "tree-ssa-live.h"
#include "tree-ssa-coalesce.h"
+#include "cfgexpand.h"
+#include "explow.h"
#include "diagnostic-core.h"
@@ -806,6 +808,16 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
basic_block bb;
ssa_op_iter iter;
live_track_p live;
+ basic_block entry;
+
+ /* If inter-variable coalescing is enabled, we may attempt to
+ coalesce variables from different base variables, including
+ different parameters, so we have to make sure default defs live
+ at the entry block conflict with each other. */
+ if (flag_tree_coalesce_vars)
+ entry = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
+ else
+ entry = NULL;
map = live_var_map (liveinfo);
graph = ssa_conflicts_new (num_var_partitions (map));
@@ -864,6 +876,30 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
live_track_process_def (live, result, graph);
}
+ /* Pretend there are defs for params' default defs at the start
+ of the (post-)entry block. */
+ if (bb == entry)
+ {
+ unsigned base;
+ bitmap_iterator bi;
+ EXECUTE_IF_SET_IN_BITMAP (live->live_base_var, 0, base, bi)
+ {
+ bitmap_iterator bi2;
+ unsigned part;
+ EXECUTE_IF_SET_IN_BITMAP (live->live_base_partitions[base],
+ 0, part, bi2)
+ {
+ tree var = partition_to_var (map, part);
+ if (!SSA_NAME_VAR (var)
+ || (TREE_CODE (SSA_NAME_VAR (var)) != PARM_DECL
+ && TREE_CODE (SSA_NAME_VAR (var)) != RESULT_DECL)
+ || !SSA_NAME_IS_DEFAULT_DEF (var))
+ continue;
+ live_track_process_def (live, var, graph);
+ }
+ }
+ }
+
live_track_clear_base_vars (live);
}
@@ -1132,6 +1168,7 @@ attempt_coalesce (var_map map, ssa_conflicts_p graph, int x, int y,
{
var1 = partition_to_var (map, p1);
var2 = partition_to_var (map, p2);
+
z = var_union (map, var1, var2);
if (z == NO_PARTITION)
{
@@ -1149,6 +1186,7 @@ attempt_coalesce (var_map map, ssa_conflicts_p graph, int x, int y,
if (debug)
fprintf (debug, ": Success -> %d\n", z);
+
return true;
}
@@ -1244,6 +1282,333 @@ ssa_name_var_hash::equal (const tree_node *n1, const tree_n [...]
}
+/* Output partition map MAP with coalescing plan PART to file F. */
+
+void
+dump_part_var_map (FILE *f, partition part, var_map map)
+{
+ int t;
+ unsigned x, y;
+ int p;
+
+ fprintf (f, "\nCoalescible Partition map \n\n");
+
+ for (x = 0; x < map->num_partitions; x++)
+ {
+ if (map->view_to_partition != NULL)
+ p = map->view_to_partition[x];
+ else
+ p = x;
+
+ if (ssa_name (p) == NULL_TREE
+ || virtual_operand_p (ssa_name (p)))
+ continue;
+
+ t = 0;
+ for (y = 1; y < num_ssa_names; y++)
+ {
+ tree var = version_to_var (map, y);
+ if (!var)
+ continue;
+ int q = var_to_partition (map, var);
+ p = partition_find (part, q);
+ gcc_assert (map->partition_to_base_index[q]
+ == map->partition_to_base_index[p]);
+
+ if (p == (int)x)
+ {
+ if (t++ == 0)
+ {
+ fprintf (f, "Partition %d, base %d (", x,
+ map->partition_to_base_index[q]);
+ print_generic_expr (f, partition_to_var (map, q), TDF_SLIM);
+ fprintf (f, " - ");
+ }
+ fprintf (f, "%d ", y);
+ }
+ }
+ if (t != 0)
+ fprintf (f, ")\n");
+ }
+ fprintf (f, "\n");
+}
+
+/* Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for
+ coalescing together, false otherwise.
+
+ This must stay consistent with var_map_base_init in tree-ssa-live.c. */
+
+bool
+gimple_can_coalesce_p (tree name1, tree name2)
+{
+ /* First check the SSA_NAME's associated DECL. Without
+ optimization, we only want to coalesce if they have the same DECL
+ or both have no associated DECL. */
+ tree var1 = SSA_NAME_VAR (name1);
+ tree var2 = SSA_NAME_VAR (name2);
+ var1 = (var1 && (!VAR_P (var1) || !DECL_IGNORED_P (var1))) ? var1 : NULL_TREE;
+ var2 = (var2 && (!VAR_P (var2) || !DECL_IGNORED_P (var2))) ? var2 : NULL_TREE;
+ if (var1 != var2 && !flag_tree_coalesce_vars)
+ return false;
+
+ /* Now check the types. If the types are the same, then we should
+ try to coalesce V1 and V2. */
+ tree t1 = TREE_TYPE (name1);
+ tree t2 = TREE_TYPE (name2);
+ if (t1 == t2)
+ {
+ check_modes:
+ /* If the base variables are the same, we're good: none of the
+ other tests below could possibly fail. */
+ var1 = SSA_NAME_VAR (name1);
+ var2 = SSA_NAME_VAR (name2);
+ if (var1 == var2)
+ return true;
+
+ /* We don't want to coalesce two SSA names if one of the base
+ variables is supposed to be a register while the other is
+ supposed to be on the stack. Anonymous SSA names take
+ registers, but when not optimizing, user variables should go
+ on the stack, so coalescing them with the anonymous variable
+ as the partition leader would end up assigning the user
+ variable to a register. Don't do that! */
+ bool reg1 = !var1 || use_register_for_decl (var1);
+ bool reg2 = !var2 || use_register_for_decl (var2);
+ if (reg1 != reg2)
+ return false;
+
+ /* Check that the promoted modes are the same. We don't want to
+ coalesce if the promoted modes would be different. Only
+ PARM_DECLs and RESULT_DECLs have different promotion rules,
+ so skip the test if both are variables, or both are anonymous
+ SSA_NAMEs. Now, if a parm or result has BLKmode, do not
+ coalesce its SSA versions with those of any other variables,
+ because it may be passed by reference. */
+ return ((!var1 || VAR_P (var1)) && (!var2 || VAR_P (var2)))
+ || (/* The case var1 == var2 is already covered above. */
+ !parm_maybe_byref_p (var1)
+ && !parm_maybe_byref_p (var2)
+ && promote_ssa_mode (name1, NULL) == promote_ssa_mode (name2, NULL));
+ }
+
+ /* If the types are not the same, check for a canonical type match. This
+ (for example) allows coalescing when the types are fundamentally the
+ same, but just have different names.
+
+ Note pointer types with different address spaces may have the same
+ canonical type. Those are rejected for coalescing by the
+ types_compatible_p check. */
+ if (TYPE_CANONICAL (t1)
+ && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2)
+ && types_compatible_p (t1, t2))
+ goto check_modes;
+
+ return false;
+}
+
+/* Fill in MAP's partition_to_base_index, with one index for each
+ partition of SSA names USED_IN_COPIES and related by CL coalesce
+ possibilities. This must match gimple_can_coalesce_p in the
+ optimized case. */
+
+static void
+compute_optimized_partition_bases (var_map map, bitmap used_in_copies,
+ coalesce_list_p cl)
+{
+ int parts = num_var_partitions (map);
+ partition tentative = partition_new (parts);
+
+ /* Partition the SSA versions so that, for each coalescible
+ pair, both of its members are in the same partition in
+ TENTATIVE. */
+ gcc_assert (!cl->sorted);
+ coalesce_pair_p node;
+ coalesce_iterator_type ppi;
+ FOR_EACH_PARTITION_PAIR (node, ppi, cl)
+ {
+ tree v1 = ssa_name (node->first_element);
+ int p1 = partition_find (tentative, var_to_partition (map, v1));
+ tree v2 = ssa_name (node->second_element);
+ int p2 = partition_find (tentative, var_to_partition (map, v2));
+
+ if (p1 == p2)
+ continue;
+
+ partition_union (tentative, p1, p2);
+ }
+
+ /* We have to deal with cost one pairs too. */
+ for (cost_one_pair_d *co = cl->cost_one_list; co; co = co->next)
+ {
+ tree v1 = ssa_name (co->first_element);
+ int p1 = partition_find (tentative, var_to_partition (map, v1));
+ tree v2 = ssa_name (co->second_element);
+ int p2 = partition_find (tentative, var_to_partition (map, v2));
+
+ if (p1 == p2)
+ continue;
+
+ partition_union (tentative, p1, p2);
+ }
+
+ /* And also with abnormal edges. */
+ basic_block bb;
+ edge e;
+ edge_iterator ei;
+ FOR_EACH_BB_FN (bb, cfun)
+ {
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ if (e->flags & EDGE_ABNORMAL)
+ {
+ gphi_iterator gsi;
+ for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
+ {
+ gphi *phi = gsi.phi ();
+ tree arg = PHI_ARG_DEF (phi, e->dest_idx);
+ if (SSA_NAME_IS_DEFAULT_DEF (arg)
+ && (!SSA_NAME_VAR (arg)
+ || TREE_CODE (SSA_NAME_VAR (arg)) != PARM_DECL))
+ continue;
+
+ tree res = PHI_RESULT (phi);
+
+ int p1 = partition_find (tentative, var_to_partition (map, res));
+ int p2 = partition_find (tentative, var_to_partition (map, arg));
+
+ if (p1 == p2)
+ continue;
+
+ partition_union (tentative, p1, p2);
+ }
+ }
+ }
+
+ map->partition_to_base_index = XCNEWVEC (int, parts);
+ auto_vec<unsigned int> index_map (parts);
+ if (parts)
+ index_map.quick_grow (parts);
+
+ const unsigned no_part = -1;
+ unsigned count = parts;
+ while (count)
+ index_map[--count] = no_part;
+
+ /* Initialize MAP's mapping from partition to base index, using
+ as base indices an enumeration of the TENTATIVE partitions in
+ which each SSA version ended up, so that we compute conflicts
+ between all SSA versions that ended up in the same potential
+ coalesce partition. */
+ bitmap_iterator bi;
+ unsigned i;
+ EXECUTE_IF_SET_IN_BITMAP (used_in_copies, 0, i, bi)
+ {
+ int pidx = var_to_partition (map, ssa_name (i));
+ int base = partition_find (tentative, pidx);
+ if (index_map[base] != no_part)
+ continue;
+ index_map[base] = count++;
+ }
+
+ map->num_basevars = count;
+
+ EXECUTE_IF_SET_IN_BITMAP (used_in_copies, 0, i, bi)
+ {
+ int pidx = var_to_partition (map, ssa_name (i));
+ int base = partition_find (tentative, pidx);
+ gcc_assert (index_map[base] < count);
+ map->partition_to_base_index[pidx] = index_map[base];
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ dump_part_var_map (dump_file, tentative, map);
+
+ partition_delete (tentative);
+}
+
+/* Hashtable helpers. */
+
+struct tree_int_map_hasher : nofree_ptr_hash <tree_int_map>
+{
+ static inline hashval_t hash (const tree_int_map *);
+ static inline bool equal (const tree_int_map *, const tree_int_map *);
+};
+
+inline hashval_t
+tree_int_map_hasher::hash (const tree_int_map *v)
+{
+ return tree_map_base_hash (v);
+}
+
+inline bool
+tree_int_map_hasher::equal (const tree_int_map *v, const tree_int_map *c)
+{
+ return tree_int_map_eq (v, c);
+}
+
+/* This routine will initialize the basevar fields of MAP with base
+ names. Partitions will share the same base if they have the same
+ SSA_NAME_VAR, or, being anonymous variables, the same type. This
+ must match gimple_can_coalesce_p in the non-optimized case. */
+
+static void
+compute_samebase_partition_bases (var_map map)
+{
+ int x, num_part;
+ tree var;
+ struct tree_int_map *m, *mapstorage;
+
+ num_part = num_var_partitions (map);
+ hash_table<tree_int_map_hasher> tree_to_index (num_part);
+ /* We can have at most num_part entries in the hash tables, so it's
+ enough to allocate so many map elements once, saving some malloc
+ calls. */
+ mapstorage = m = XNEWVEC (struct tree_int_map, num_part);
+
+ /* If a base table already exists, clear it, otherwise create it. */
+ free (map->partition_to_base_index);
+ map->partition_to_base_index = (int *) xmalloc (sizeof (int) * num_part);
+
+ /* Build the base variable list, and point partitions at their bases. */
+ for (x = 0; x < num_part; x++)
+ {
+ struct tree_int_map **slot;
+ unsigned baseindex;
+ var = partition_to_var (map, x);
+ if (SSA_NAME_VAR (var)
+ && (!VAR_P (SSA_NAME_VAR (var))
+ || !DECL_IGNORED_P (SSA_NAME_VAR (var))))
+ m->base.from = SSA_NAME_VAR (var);
+ else
+ /* This restricts what anonymous SSA names we can coalesce
+ as it restricts the sets we compute conflicts for.
+ Using TREE_TYPE to generate sets is the easies as
+ type equivalency also holds for SSA names with the same
+ underlying decl.
+
+ Check gimple_can_coalesce_p when changing this code. */
+ m->base.from = (TYPE_CANONICAL (TREE_TYPE (var))
+ ? TYPE_CANONICAL (TREE_TYPE (var))
+ : TREE_TYPE (var));
+ /* If base variable hasn't been seen, set it up. */
+ slot = tree_to_index.find_slot (m, INSERT);
+ if (!*slot)
+ {
+ baseindex = m - mapstorage;
+ m->to = baseindex;
+ *slot = m;
+ m++;
+ }
+ else
+ baseindex = (*slot)->to;
+ map->partition_to_base_index[x] = baseindex;
+ }
+
+ map->num_basevars = m - mapstorage;
+
+ free (mapstorage);
+}
+
/* Reduce the number of copies by coalescing variables in the function. Return
a partition map with the resulting coalesces. */
@@ -1260,9 +1625,10 @@ coalesce_ssa_name (void)
cl = create_coalesce_list ();
map = create_outofssa_var_map (cl, used_in_copies);
- /* If optimization is disabled, we need to coalesce all the names originating
- from the same SSA_NAME_VAR so debug info remains undisturbed. */
- if (!optimize)
+ /* If this optimization is disabled, we need to coalesce all the
+ names originating from the same SSA_NAME_VAR so debug info
+ remains undisturbed. */
+ if (!flag_tree_coalesce_vars)
{
hash_table<ssa_name_var_hash> ssa_name_hash (10);
@@ -1303,8 +1669,13 @@ coalesce_ssa_name (void)
if (dump_file && (dump_flags & TDF_DETAILS))
dump_var_map (dump_file, map);
- /* Don't calculate live ranges for variables not in the coalesce list. */
- partition_view_bitmap (map, used_in_copies, true);
+ partition_view_bitmap (map, used_in_copies);
+
+ if (flag_tree_coalesce_vars)
+ compute_optimized_partition_bases (map, used_in_copies, cl);
+ else
+ compute_samebase_partition_bases (map);
+
BITMAP_FREE (used_in_copies);
if (num_var_partitions (map) < 1)
@@ -1343,8 +1714,7 @@ coalesce_ssa_name (void)
/* Now coalesce everything in the list. */
coalesce_partitions (map, graph, cl,
- ((dump_flags & TDF_DETAILS) ? dump_file
- : NULL));
+ ((dump_flags & TDF_DETAILS) ? dump_file : NULL));
delete_coalesce_list (cl);
ssa_conflicts_delete (graph);
diff --git a/gcc/tree-ssa-coalesce.h b/gcc/tree-ssa-coalesce.h
index 99b188a..ae289b4 100644
--- a/gcc/tree-ssa-coalesce.h
+++ b/gcc/tree-ssa-coalesce.h
@@ -21,5 +21,6 @@ along with GCC; see the file COPYING3. If not see
#define GCC_TREE_SSA_COALESCE_H
extern var_map coalesce_ssa_name (void);
+extern bool gimple_can_coalesce_p (tree, tree);
#endif /* GCC_TREE_SSA_COALESCE_H */
diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c
deleted file mode 100644
index aeb7f28..0000000
--- a/gcc/tree-ssa-copyrename.c
+++ /dev/null
@@ -1,475 +0,0 @@
-/* Rename SSA copies.
- Copyright (C) 2004-2015 Free Software Foundation, Inc.
- Contributed by Andrew MacLeod <amacleod(a)redhat.com>
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3. If not see
-<http://www.gnu.org/licenses/>. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "backend.h"
-#include "tree.h"
-#include "gimple.h"
-#include "rtl.h"
-#include "ssa.h"
-#include "alias.h"
-#include "fold-const.h"
-#include "internal-fn.h"
-#include "gimple-iterator.h"
-#include "flags.h"
-#include "tree-pretty-print.h"
-#include "insn-config.h"
-#include "expmed.h"
-#include "dojump.h"
-#include "explow.h"
-#include "calls.h"
-#include "emit-rtl.h"
-#include "varasm.h"
-#include "stmt.h"
-#include "expr.h"
-#include "tree-dfa.h"
-#include "tree-inline.h"
-#include "tree-ssa-live.h"
-#include "tree-pass.h"
-#include "langhooks.h"
-
-static struct
-{
- /* Number of copies coalesced. */
- int coalesced;
-} stats;
-
-/* The following routines implement the SSA copy renaming phase.
-
- This optimization looks for copies between 2 SSA_NAMES, either through a
- direct copy, or an implicit one via a PHI node result and its arguments.
-
- Each copy is examined to determine if it is possible to rename the base
- variable of one of the operands to the same variable as the other operand.
- i.e.
- T.3_5 = <blah>
- a_1 = T.3_5
-
- If this copy couldn't be copy propagated, it could possibly remain in the
- program throughout the optimization phases. After SSA->normal, it would
- become:
-
- T.3 = <blah>
- a = T.3
-
- Since T.3_5 is distinct from all other SSA versions of T.3, there is no
- fundamental reason why the base variable needs to be T.3, subject to
- certain restrictions. This optimization attempts to determine if we can
- change the base variable on copies like this, and result in code such as:
-
- a_5 = <blah>
- a_1 = a_5
-
- This gives the SSA->normal pass a shot at coalescing a_1 and a_5. If it is
- possible, the copy goes away completely. If it isn't possible, a new temp
- will be created for a_5, and you will end up with the exact same code:
-
- a.8 = <blah>
- a = a.8
-
- The other benefit of performing this optimization relates to what variables
- are chosen in copies. Gimplification of the program uses temporaries for
- a lot of things. expressions like
-
- a_1 = <blah>
- <blah2> = a_1
-
- get turned into
-
- T.3_5 = <blah>
- a_1 = T.3_5
- <blah2> = a_1
-
- Copy propagation is done in a forward direction, and if we can propagate
- through the copy, we end up with:
-
- T.3_5 = <blah>
- <blah2> = T.3_5
-
- The copy is gone, but so is all reference to the user variable 'a'. By
- performing this optimization, we would see the sequence:
-
- a_5 = <blah>
- a_1 = a_5
- <blah2> = a_1
-
- which copy propagation would then turn into:
-
- a_5 = <blah>
- <blah2> = a_5
-
- and so we still retain the user variable whenever possible. */
-
-
-/* Coalesce the partitions in MAP representing VAR1 and VAR2 if it is valid.
- Choose a representative for the partition, and send debug info to DEBUG. */
-
-static void
-copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug)
-{
- int p1, p2, p3;
- tree root1, root2;
- tree rep1, rep2;
- bool ign1, ign2, abnorm;
-
- gcc_assert (TREE_CODE (var1) == SSA_NAME);
- gcc_assert (TREE_CODE (var2) == SSA_NAME);
-
- register_ssa_partition (map, var1);
- register_ssa_partition (map, var2);
-
- p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1));
- p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2));
-
- if (debug)
- {
- fprintf (debug, "Try : ");
- print_generic_expr (debug, var1, TDF_SLIM);
- fprintf (debug, "(P%d) & ", p1);
- print_generic_expr (debug, var2, TDF_SLIM);
- fprintf (debug, "(P%d)", p2);
- }
-
- gcc_assert (p1 != NO_PARTITION);
- gcc_assert (p2 != NO_PARTITION);
-
- if (p1 == p2)
- {
- if (debug)
- fprintf (debug, " : Already coalesced.\n");
- return;
- }
-
- rep1 = partition_to_var (map, p1);
- rep2 = partition_to_var (map, p2);
- root1 = SSA_NAME_VAR (rep1);
- root2 = SSA_NAME_VAR (rep2);
- if (!root1 && !root2)
- return;
-
- /* Don't coalesce if one of the variables occurs in an abnormal PHI. */
- abnorm = (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep1)
- || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep2));
- if (abnorm)
- {
- if (debug)
- fprintf (debug, " : Abnormal PHI barrier. No coalesce.\n");
- return;
- }
-
- /* Partitions already have the same root, simply merge them. */
- if (root1 == root2)
- {
- p1 = partition_union (map->var_partition, p1, p2);
- if (debug)
- fprintf (debug, " : Same root, coalesced --> P%d.\n", p1);
- return;
- }
-
- /* Never attempt to coalesce 2 different parameters. */
- if ((root1 && TREE_CODE (root1) == PARM_DECL)
- && (root2 && TREE_CODE (root2) == PARM_DECL))
- {
- if (debug)
- fprintf (debug, " : 2 different PARM_DECLS. No coalesce.\n");
- return;
- }
-
- if ((root1 && TREE_CODE (root1) == RESULT_DECL)
- != (root2 && TREE_CODE (root2) == RESULT_DECL))
- {
- if (debug)
- fprintf (debug, " : One root a RESULT_DECL. No coalesce.\n");
- return;
- }
-
- ign1 = !root1 || (TREE_CODE (root1) == VAR_DECL && DECL_IGNORED_P (root1));
- ign2 = !root2 || (TREE_CODE (root2) == VAR_DECL && DECL_IGNORED_P (root2));
-
- /* Refrain from coalescing user variables, if requested. */
- if (!ign1 && !ign2)
- {
- if (flag_ssa_coalesce_vars && DECL_FROM_INLINE (root2))
- ign2 = true;
- else if (flag_ssa_coalesce_vars && DECL_FROM_INLINE (root1))
- ign1 = true;
- else if (flag_ssa_coalesce_vars != 2)
- {
- if (debug)
- fprintf (debug, " : 2 different USER vars. No coalesce.\n");
- return;
- }
- else
- ign2 = true;
- }
-
- /* If both values have default defs, we can't coalesce. If only one has a
- tag, make sure that variable is the new root partition. */
- if (root1 && ssa_default_def (cfun, root1))
- {
- if (root2 && ssa_default_def (cfun, root2))
- {
- if (debug)
- fprintf (debug, " : 2 default defs. No coalesce.\n");
- return;
- }
- else
- {
- ign2 = true;
- ign1 = false;
- }
- }
- else if (root2 && ssa_default_def (cfun, root2))
- {
- ign1 = true;
- ign2 = false;
- }
-
- /* Do not coalesce if we cannot assign a symbol to the partition. */
- if (!(!ign2 && root2)
- && !(!ign1 && root1))
- {
- if (debug)
- fprintf (debug, " : Choosen variable has no root. No coalesce.\n");
- return;
- }
-
- /* Don't coalesce if the new chosen root variable would be read-only.
- If both ign1 && ign2, then the root var of the larger partition
- wins, so reject in that case if any of the root vars is TREE_READONLY.
- Otherwise reject only if the root var, on which replace_ssa_name_symbol
- will be called below, is readonly. */
- if (((root1 && TREE_READONLY (root1)) && ign2)
- || ((root2 && TREE_READONLY (root2)) && ign1))
- {
- if (debug)
- fprintf (debug, " : Readonly variable. No coalesce.\n");
- return;
- }
-
- /* Don't coalesce if the two variables aren't type compatible . */
- if (!types_compatible_p (TREE_TYPE (var1), TREE_TYPE (var2))
- /* There is a disconnect between the middle-end type-system and
- VRP, avoid coalescing enum types with different bounds. */
- || ((TREE_CODE (TREE_TYPE (var1)) == ENUMERAL_TYPE
- || TREE_CODE (TREE_TYPE (var2)) == ENUMERAL_TYPE)
- && TREE_TYPE (var1) != TREE_TYPE (var2)))
- {
- if (debug)
- fprintf (debug, " : Incompatible types. No coalesce.\n");
- return;
- }
-
- /* Merge the two partitions. */
- p3 = partition_union (map->var_partition, p1, p2);
-
- /* Set the root variable of the partition to the better choice, if there is
- one. */
- if (!ign2 && root2)
- replace_ssa_name_symbol (partition_to_var (map, p3), root2);
- else if (!ign1 && root1)
- replace_ssa_name_symbol (partition_to_var (map, p3), root1);
- else
- gcc_unreachable ();
-
- if (debug)
- {
- fprintf (debug, " --> P%d ", p3);
- print_generic_expr (debug, SSA_NAME_VAR (partition_to_var (map, p3)),
- TDF_SLIM);
- fprintf (debug, "\n");
- }
-}
-
-
-namespace {
-
-const pass_data pass_data_rename_ssa_copies =
-{
- GIMPLE_PASS, /* type */
- "copyrename", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- TV_TREE_COPY_RENAME, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_rename_ssa_copies : public gimple_opt_pass
-{
-public:
- pass_rename_ssa_copies (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_rename_ssa_copies, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_rename_ssa_copies (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_copyrename != 0; }
- virtual unsigned int execute (function *);
-
-}; // class pass_rename_ssa_copies
-
-/* This function will make a pass through the IL, and attempt to coalesce any
- SSA versions which occur in PHI's or copies. Coalescing is accomplished by
- changing the underlying root variable of all coalesced version. This will
- then cause the SSA->normal pass to attempt to coalesce them all to the same
- variable. */
-
-unsigned int
-pass_rename_ssa_copies::execute (function *fun)
-{
- var_map map;
- basic_block bb;
- tree var, part_var;
- gimple stmt;
- unsigned x;
- FILE *debug;
-
- memset (&stats, 0, sizeof (stats));
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- debug = dump_file;
- else
- debug = NULL;
-
- map = init_var_map (num_ssa_names);
-
- FOR_EACH_BB_FN (bb, fun)
- {
- /* Scan for real copies. */
- for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
- gsi_next (&gsi))
- {
- stmt = gsi_stmt (gsi);
- if (gimple_assign_ssa_name_copy_p (stmt))
- {
- tree lhs = gimple_assign_lhs (stmt);
- tree rhs = gimple_assign_rhs1 (stmt);
-
- copy_rename_partition_coalesce (map, lhs, rhs, debug);
- }
- }
- }
-
- FOR_EACH_BB_FN (bb, fun)
- {
- /* Treat PHI nodes as copies between the result and each argument. */
- for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
- gsi_next (&gsi))
- {
- size_t i;
- tree res;
- gphi *phi = gsi.phi ();
- res = gimple_phi_result (phi);
-
- /* Do not process virtual SSA_NAMES. */
- if (virtual_operand_p (res))
- continue;
-
- /* Make sure to only use the same partition for an argument
- as the result but never the other way around. */
- if (SSA_NAME_VAR (res)
- && !DECL_IGNORED_P (SSA_NAME_VAR (res)))
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree arg = PHI_ARG_DEF (phi, i);
- if (TREE_CODE (arg) == SSA_NAME)
- copy_rename_partition_coalesce (map, res, arg,
- debug);
- }
- /* Else if all arguments are in the same partition try to merge
- it with the result. */
- else
- {
- int all_p_same = -1;
- int p = -1;
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree arg = PHI_ARG_DEF (phi, i);
- if (TREE_CODE (arg) != SSA_NAME)
- {
- all_p_same = 0;
- break;
- }
- else if (all_p_same == -1)
- {
- p = partition_find (map->var_partition,
- SSA_NAME_VERSION (arg));
- all_p_same = 1;
- }
- else if (all_p_same == 1
- && p != partition_find (map->var_partition,
- SSA_NAME_VERSION (arg)))
- {
- all_p_same = 0;
- break;
- }
- }
- if (all_p_same == 1)
- copy_rename_partition_coalesce (map, res,
- PHI_ARG_DEF (phi, 0),
- debug);
- }
- }
- }
-
- if (debug)
- dump_var_map (debug, map);
-
- /* Now one more pass to make all elements of a partition share the same
- root variable. */
-
- for (x = 1; x < num_ssa_names; x++)
- {
- part_var = partition_to_var (map, x);
- if (!part_var)
- continue;
- var = ssa_name (x);
- if (SSA_NAME_VAR (var) == SSA_NAME_VAR (part_var))
- continue;
- if (debug)
- {
- fprintf (debug, "Coalesced ");
- print_generic_expr (debug, var, TDF_SLIM);
- fprintf (debug, " to ");
- print_generic_expr (debug, part_var, TDF_SLIM);
- fprintf (debug, "\n");
- }
- stats.coalesced++;
- replace_ssa_name_symbol (var, SSA_NAME_VAR (part_var));
- }
-
- statistics_counter_event (fun, "copies coalesced",
- stats.coalesced);
- delete_var_map (map);
- return 0;
-}
-
-} // anon namespace
-
-gimple_opt_pass *
-make_pass_rename_ssa_copies (gcc::context *ctxt)
-{
- return new pass_rename_ssa_copies (ctxt);
-}
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index 5b00f58..4772558 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -70,88 +70,6 @@ static void verify_live_on_entry (tree_live_info_p);
ssa_name or variable, and vice versa. */
-/* Hashtable helpers. */
-
-struct tree_int_map_hasher : nofree_ptr_hash <tree_int_map>
-{
- static inline hashval_t hash (const tree_int_map *);
- static inline bool equal (const tree_int_map *, const tree_int_map *);
-};
-
-inline hashval_t
-tree_int_map_hasher::hash (const tree_int_map *v)
-{
- return tree_map_base_hash (v);
-}
-
-inline bool
-tree_int_map_hasher::equal (const tree_int_map *v, const tree_int_map *c)
-{
- return tree_int_map_eq (v, c);
-}
-
-
-/* This routine will initialize the basevar fields of MAP. */
-
-static void
-var_map_base_init (var_map map)
-{
- int x, num_part;
- tree var;
- struct tree_int_map *m, *mapstorage;
-
- num_part = num_var_partitions (map);
- hash_table<tree_int_map_hasher> tree_to_index (num_part);
- /* We can have at most num_part entries in the hash tables, so it's
- enough to allocate so many map elements once, saving some malloc
- calls. */
- mapstorage = m = XNEWVEC (struct tree_int_map, num_part);
-
- /* If a base table already exists, clear it, otherwise create it. */
- free (map->partition_to_base_index);
- map->partition_to_base_index = (int *) xmalloc (sizeof (int) * num_part);
-
- /* Build the base variable list, and point partitions at their bases. */
- for (x = 0; x < num_part; x++)
- {
- struct tree_int_map **slot;
- unsigned baseindex;
- var = partition_to_var (map, x);
- if (SSA_NAME_VAR (var)
- && (!VAR_P (SSA_NAME_VAR (var))
- || !DECL_IGNORED_P (SSA_NAME_VAR (var))))
- m->base.from = SSA_NAME_VAR (var);
- else
- /* This restricts what anonymous SSA names we can coalesce
- as it restricts the sets we compute conflicts for.
- Using TREE_TYPE to generate sets is the easies as
- type equivalency also holds for SSA names with the same
- underlying decl.
-
- Check gimple_can_coalesce_p when changing this code. */
- m->base.from = (TYPE_CANONICAL (TREE_TYPE (var))
- ? TYPE_CANONICAL (TREE_TYPE (var))
- : TREE_TYPE (var));
- /* If base variable hasn't been seen, set it up. */
- slot = tree_to_index.find_slot (m, INSERT);
- if (!*slot)
- {
- baseindex = m - mapstorage;
- m->to = baseindex;
- *slot = m;
- m++;
- }
- else
- baseindex = (*slot)->to;
- map->partition_to_base_index[x] = baseindex;
- }
-
- map->num_basevars = m - mapstorage;
-
- free (mapstorage);
-}
-
-
/* Remove the base table in MAP. */
static void
@@ -329,21 +247,17 @@ partition_view_fini (var_map map, bitmap selected)
}
-/* Create a partition view which includes all the used partitions in MAP. If
- WANT_BASES is true, create the base variable map as well. */
+/* Create a partition view which includes all the used partitions in MAP. */
void
-partition_view_normal (var_map map, bool want_bases)
+partition_view_normal (var_map map)
{
bitmap used;
used = partition_view_init (map);
partition_view_fini (map, used);
- if (want_bases)
- var_map_base_init (map);
- else
- var_map_base_fini (map);
+ var_map_base_fini (map);
}
@@ -352,7 +266,7 @@ partition_view_normal (var_map map, bool want_bases)
as well. */
void
-partition_view_bitmap (var_map map, bitmap only, bool want_bases)
+partition_view_bitmap (var_map map, bitmap only)
{
bitmap used;
bitmap new_partitions = BITMAP_ALLOC (NULL);
@@ -368,10 +282,7 @@ partition_view_bitmap (var_map map, bitmap only, bool want_bases)
}
partition_view_fini (map, new_partitions);
- if (want_bases)
- var_map_base_init (map);
- else
- var_map_base_fini (map);
+ var_map_base_fini (map);
}
diff --git a/gcc/tree-ssa-live.h b/gcc/tree-ssa-live.h
index d5d7820..1f88358 100644
--- a/gcc/tree-ssa-live.h
+++ b/gcc/tree-ssa-live.h
@@ -71,8 +71,8 @@ typedef struct _var_map
extern var_map init_var_map (int);
extern void delete_var_map (var_map);
extern int var_union (var_map, tree, tree);
-extern void partition_view_normal (var_map, bool);
-extern void partition_view_bitmap (var_map, bitmap, bool);
+extern void partition_view_normal (var_map);
+extern void partition_view_bitmap (var_map, bitmap);
extern void dump_scope_blocks (FILE *, int);
extern void debug_scope_block (tree, int);
extern void debug_scope_blocks (int);
diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
index 437f69d..1fbd71e 100644
--- a/gcc/tree-ssa-uncprop.c
+++ b/gcc/tree-ssa-uncprop.c
@@ -38,6 +38,11 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pass.h"
#include "tree-ssa-propagate.h"
#include "tree-hash-traits.h"
+#include "bitmap.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "tree-ssa-live.h"
+#include "tree-ssa-coalesce.h"
/* The basic structure describing an equivalency created by traversing
an edge. Traversing the edge effectively means that we can assume
diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c
index da9de28..a31a137 100644
--- a/gcc/var-tracking.c
+++ b/gcc/var-tracking.c
@@ -4856,12 +4856,16 @@ dataflow_set_remove_mem_locs (variable_def **slot, dataflow [...]
registers, as well as associations between MEMs and VALUEs. */
static void
-dataflow_set_clear_at_call (dataflow_set *set)
+dataflow_set_clear_at_call (dataflow_set *set, rtx_insn *call_insn)
{
unsigned int r;
hard_reg_set_iterator hrsi;
+ HARD_REG_SET invalidated_regs;
- EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, r, hrsi)
+ get_call_reg_set_usage (call_insn, &invalidated_regs,
+ regs_invalidated_by_call);
+
+ EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs, 0, r, hrsi)
var_regno_delete (set, r);
if (MAY_HAVE_DEBUG_INSNS)
@@ -6645,7 +6649,7 @@ compute_bb_dataflow (basic_block bb)
switch (mo->type)
{
case MO_CALL:
- dataflow_set_clear_at_call (out);
+ dataflow_set_clear_at_call (out, insn);
break;
case MO_USE:
@@ -9107,7 +9111,7 @@ emit_notes_in_bb (basic_block bb, dataflow_set *set)
switch (mo->type)
{
case MO_CALL:
- dataflow_set_clear_at_call (set);
+ dataflow_set_clear_at_call (set, insn);
emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
{
rtx arguments = mo->u.loc, *p = &arguments;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] branch aoliva/pr64164 updated (143090f -> 5ce2a91)
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a change to branch aoliva/pr64164
in repository gcc.
discards 143090f incremental fixes
discards 2348a01 [PR64164] Drop copyrename, use coalescible partition as base [...]
new 5ce2a91 [PR64164] Drop copyrename, use coalescible partition as base [...]
This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version. This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:
* -- * -- B -- O -- O -- O (143090f)
\
N -- N -- N refs/heads/aoliva/pr64164 (5ce2a91)
You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.
Any revisions marked "omits" are not gone; other references still
refer to them. Any revisions marked "discards" are gone forever.
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "adds" were already present in the repository and have only
been added to this reference.
Summary of changes:
gcc/function.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] branch trunk updated (c909938 -> 0686247)
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a change to branch trunk
in repository gcc.
from c909938 PR c/67088 * c-decl.c (check_bitfield_type_and_width): Add [...]
new 0686247 Avoid recomputing the defining predicate chains for the same PHI
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "adds" were already present in the repository and have only
been added to this reference.
Summary of changes:
gcc/ChangeLog | 10 ++++++++
gcc/tree-ssa-uninit.c | 71 +++++++++++++++++++++++++++++++++------------------
2 files changed, 56 insertions(+), 25 deletions(-)
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] branch hsa updated (e8a2733 -> 4f2ebec)
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a change to branch hsa
in repository gcc.
from e8a2733 HSA: introduce more pure kernel information emission.
adds b8783ab [PATCH][combine][1/2] Try to simplify before substituting
adds 5ced42f [simplify-rtx][2/2] Simplify - (y ? -x : x) -> (!y ? -x : x)
adds 8d669e7 PR c++/55095 * c-common.c (c_fully_fold_internal): Warn abo [...]
adds 049434b [AArch64][testcase] Restrict got_mem_hoist_1.c with small mem [...]
adds 49c77a4 * genemit.c (print_code, gen_exp, gen_insn, gen_expand, gen_ [...]
adds 196c8bc * plugin/plugin-nvptx.c (struct targ_fn_descriptor): Move la [...]
adds f337168 PR target/66217 * config/rs6000/constraints.md ("S", "T", " [...]
adds 834127d * config/rs6000/rs6000.md (*lt0_disi): New.
adds b4a3304 compiler: Remove unnecessary check for GCC-specific issue.
adds 7da522b compiler: Create dummy labels for blank labels.
adds 933b058 * oacc-parallel.c (GOACC_parallel): Move variadic handling i [...]
adds 0fc32b1 Missed a difference between gomp4 and trunk
adds bdb7800 Refactor graphite-isl-ast-to-gimple.c
adds 79af360 add missing changelog
adds 41a48fd * config/i386/i386.c (ix86_md_asm_adjust): Handle DImode des [...]
adds 89eaf71 * include/bits/c++config: Fix abi_tag in special modes.
adds d9b3844 * config/rl78/rl78-real.md (andqi3_real): Expand operands for [...]
adds ebd5ca6 Daily bump.
adds b1eac90 [match.pd] PR middle-end/66915 Restrict A - B -> A + (-B) to [...]
adds 487ff34 * gcc.dg/vmx/unpack-be-order.c: Use -Wno-shift-overflow. * [...]
adds 12f384c Fix ChangeLog of r225926 (PR fortran/61831)
adds 963e11e 2015-07-21 Alex Velenko <Alex.Velenko(a)arm.com> gcc/testsuit [...]
adds 9f8f6cb Fix r225926's broken testcase
adds 7de5731 libgomp/ * target.c (gomp_offload_image_to_device): Rename [...]
adds 9fe7e11 2015-07-21 Richard Biener <rguenther(a)suse.de>
adds 7c1913d 2015-07-21 Alex Velenko <Alex.Velenko(a)arm.com>
adds aa18db9 PR target/66956 * config/avr/avr-dimode.md (<extend_u>mulsi [...]
adds a26dad6 * configure.ac: Add check for new options in isl-0.15. * co [...]
adds 44a5770 2015-07-21 Andrew MacLeod <amacleod(a)redhat.com>
adds 189317c 2015-07-21 Vladimir Makarov <vmakarov(a)redhat.com>
adds d009152 /cp 2015-07-21 Paolo Carlini <paolo.carlini(a)oracle.com>
adds da3f7d6 Daily bump.
adds a93d7f2 * doc/invoke.texi (Language Independent Options): Rename nod [...]
adds 0146686 gcc/ChangeLog:
adds 3061044 2015-07-22 Richard Biener <rguenther(a)suse.de>
adds bf3bbdf 2015-07-22 Charles Baylis <charles.baylis(a)linaro.org>
adds ace499f 2015-07-22 Richard Biener <rguenther(a)suse.de>
adds a46441d 2015-07-22 Chung-Lin Tang <cltang(a)codesourcery.com>
adds 18be45a [AArch64] PR target/63521 Define REG_ALLOC_ORDER
adds 606d0d6 Add -march=interaptiv.
adds 68fb434 Add scheduling for M51xx core family.
adds 4d289e2 2015-07-22 Richard Biener <rguenther(a)suse.de>
adds cfa66ec 2015-07-22 Richard Biener <rguenther(a)suse.de>
adds 6059989 [Patch ARM/AArch64 obvious] Fix typo: Rename insn_reservation [...]
adds c70b874 Fix r225926's iso_varying_string ICE regression
adds 7794f2c * config/nvptx/nvptx.c: Expand some comments.
adds 78f81ee PR driver/66737 * config/i386/linux-common.h (MPX_SPEC): Us [...]
adds d7d63a0 * gcc.dg/vmx/unpack.c: Use dg-additional-options rather than [...]
adds 4bb2d10 2015-07-22 Maxim Blumenthal <maxim.blumenthal(a)intel.com>
adds ff285c7 libgcc/ChangeLog:
adds 09bddbe Daily bump.
adds 9f0a16a * config/msp430/t-msp430 (MULTILIB_DIRNAMES): Remove trailing [...]
adds 43f467b 2015-07-23 Richard Biener <rguenther(a)suse.de>
adds 9304906 2015-07-23 Richard Biener <rguenther(a)suse.de>
adds 4e503e6 2015-07-23 Richard Biener <rguenther(a)suse.de>
adds 607f558 I6400 scheduling.
adds 24882f0 [combine][obvious] Use std::swap in try_combine
adds ddb5dd6 /cp 2015-07-23 Paolo Carlini <paolo.carlini(a)oracle.com>
adds 480233e gcc/
adds 10adbe6 2015-07-23 Richard Biener <rguenther(a)suse.de>
adds b826233 Check TYPE_OVERFLOW_WRAPS for parloops reductions
adds 3f8c038 2015-07-23 Richard Biener <rguenther(a)suse.de>
adds f6f5e49 PR sanitizer/66908 * c-ubsan.c: Include gimplify.h. (ubsan [...]
adds f105443 2015-07-23 Richard Biener <rguenther(a)suse.de>
adds 9324fa0 PR target/66217 * config/rs6000/rs6000-protos.h (rs6000_emi [...]
adds f22255e [PR64164] Drop copyrename, use coalescible partition as base [...]
adds 0803497 * c-ubsan.c (ubsan_instrument_division): Use unshare_expr th [...]
adds f30ba9e * include/bits/functional_hash.h: Add specializations for __i [...]
adds 15c4143 * MAINTAINERS: Update my email address.
adds 636e50f PR c++/66572 * pt.c (tsubst_copy_and_build): Add warn_logic [...]
adds 0995ea8 2015-07-23 Bernd Edlinger <bernd.edlinger(a)hotmail.de>
adds 7661d70 compiler: Check for errors in the underlying types of una [...]
adds bf65976 compiler: Make empty interface types for vars during parse time.
adds ec361a0 PR lto/66752 * tree-ssa-threadedge.c (simplify_conrol_stmt_ [...]
adds 8ece6e0 jit: supply MULTILIB_DEFAULTS as arguments when invoking driver
adds da65bda * config/i386/i386.c (ix86_build_builtin_va_list_64): Rename [...]
adds 50e9206 Daily bump.
adds a76e121 gcc/ChangeLog:
adds 341224f gcc/testsuite/ChangeLog:
adds 7148646 PR middle-end/25529 2015-07-24 Naveen H.S <Naveen.Hurugalaw [...]
adds 20c41e0 PR middle-end/25530 2015-07-24 Naveen H.S <Naveen.Hurugalaw [...]
adds 58badc2 libstdc++-v3/fragment.am (AM_CPPFLAGS): Add CPPFLAGS
adds 1a19103 2015-07-24 Richard Biener <rguenther(a)suse.de>
adds 8218bff 2015-07-24 Richard Biener <rguenther(a)suse.de>
adds b47fee3 [AArch64] Revert REG_ALLOC_ORDER/HONOR_REG_ALLOC_ORDER
adds fa907c4 Remove xfail in autopar/uns-outer-4.c
adds 67d0722 2015-07-24 Richard Biener <rguenther(a)suse.de>
adds 058194a S390 -march=native related fixes
adds 9aae290 [PATCH 2/4] S390 -march=native related fixes
adds f369dcc [PATCH 3/4] S390 -march=native related fixes
adds 117d67d [PATCH 4/4] S390 -march=native related fixes
adds 02a8efd [PATCH] S/390: Improve risbg usage
adds c5dad79 S/390: Fix cfi for GPR 2 FPR saves
adds f269b75 Add a testcase for PR bootstrap/66978
adds aff92e4 2015-07-24 Richard Biener <rguenther(a)suse.de>
adds 0a45b02 2015-07-24 Richard Biener <rguenther(a)suse.de>
adds 1f9acbc 2015-07-24 Richard Biener <rguenther(a)suse.de>
adds b0343e0 gcc/
adds b0155c9 [AArch64] Fix LINUX_TARGET_LINK_SPEC to be consistent with ARM
adds 410acc7 [AArch64] elf toolchain does not pass -shared linker option
adds 44f8678 PR 66714
adds 69dcb06 Fix gfortran.dg/class_to_type_4.f90 deallocation code misorde [...]
adds 91d1485 Add transform_to_exit_first_loop_alt dump success message
adds 96db391 2015-07-24 Gary Funck <gary(a)intrepid.com>
adds 38f3f9a * gimplify.c (omp_default_clause): New function. Reorganize [...]
adds 5e5e10b PR target/64003 * config/i386/i386.h (ADJUST_INSN_LENGTH): [...]
adds 3491986 * include/bits/atomic_futex.h [_GLIBCXX_HAVE_LINUX_FUTEX] ( [...]
adds 3a49add * be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id [...]
adds 5be7cd7 * nl.po: Update.
adds c586a5e [obvious] Use std::swap instead of manually swapping in a few [...]
adds c79bba9 compiler: Don't make temporaries for constant expressions.
adds e757a6a PR other/66259 * config-ml.in: Reflects renaming of configu [...]
adds 5f7bd04 compiler: Disallow rune literals with '\X'.
adds f822e47 compiler: Don't parse malformed receiver/parameters.
adds f0ff386 * config/i386/i386.c (ix86_call_abi_override): Call ix86_fun [...]
adds 9e96f1e 2015-07-24 Manuel López-Ibáñez <manu(a)gcc.gnu.org>
adds 8372922 Don't allow unsafe reductions in graphite
adds 1d1e80e Enable reductions without fassociative-math in graphite
adds 1702f6e * config/i386/i386.c (ix86_va_start): Remove unneeded !TARG [...]
adds 57ca644 syscall: Add ioctl consts from if_tun.h
adds 298f23f Daily bump.
adds bcde57a Revert: 2015-07-23 Alexandre Oliva <aoliva(a)redhat.com>
adds b1e92b3 Revert: PR lto/66752 * tree-ssa-threadedge.c [...]
adds 5d7ff1c PR c++/64989 * pt.c (splice_late_return_type): Correct dedu [...]
adds f11b787 PR c++/64969 * pt.c (splice_late_return_type): Correct dedu [...]
adds 277c74d Fixup graphite/uns-*.c testcases
adds 24b12f6 update doc for supported isl versions
adds 9b81791 PR target/66648 * config/i386/i386.c (ix86_expand_set_or_mo [...]
adds 4773ab2 dump reasons why graphite failed to detect a scop
adds 894a34e remove tree-browser
adds 9fec678 PR target/67004 * config/i386/i386.h (ADJUST_INSN_LENGTH): [...]
adds e15c094 * config/i386/i386.c: Use SUBREG_P predicate. * config/i386 [...]
adds 05b349a * ChangeLog: Fix whitespace. * testsuite/ChangeLog: Ditto.
adds bd2a8585 gcc/ PR target/66930 * config/sh/sh.c (sh_split_movrt_negc_ [...]
adds cce0626 S390: Clean up cross-compile for S390.
adds 0a7452a Fix PR c++/66857
adds f2de820 Daily bump.
adds 6b21368 * config/alpha/alpha.c: Use SUBREG_P predicate. * config/al [...]
adds e9fe90a * gcc.target/alpha/pr66140.c (lpfc_bg_setup_bpl): Use unsign [...]
adds 0f4714e 2015-07-26 Paolo Carlini <paolo.carlini(a)oracle.com>
adds 2ce308e Fix PR c++/18969 (invalid return statement diagnosed too late)
adds e954729 Daily bump.
adds 9b6b471 2015-07-27 Richard Biener <rguenther(a)suse.de>
adds 6784a47 PR c++/66555 PR c/54979 * c-common.c (find_array_ref_with_ [...]
adds ab2874b 2015-07-27 Matthew Wahab <matthew.wahab(a)arm.com>
adds 1ed4ddb Fix logic error in Fortran OpenACC parsing
adds eab7bd2 [PATCH][AArch64] Improve spill code - swap order in shl pattern
adds 505e1f9 [ARM] PR/63870 Add qualifier to check lane bounds in expand
adds 732205b [ARM] PR/63870 Add a __builtin_lane_check
adds f4f2d7d [PATCH][AArch64] Improve spill code - swap order in shr patterns
adds e5e363a Add more tests for PR target/66232
adds bccc47e PR debug/66468 * dwarf2out.c (gen_inlined_subroutine_die): [...]
adds 37715b0 * constexpr.c (cxx_eval_call_expression): Don't add this cal [...]
adds d9e4fe2 PR bootstrap/67030 * c-common.c (warn_tautological_cmp): Do [...]
adds e5b7f5c * ipa-devirt.c (types_same_for_odr): Fix typo.
adds 3b73c99 Update outer-4.c and uns-outer-4.c
adds 81fbee0 Simplify gather_scalar_reductions
adds 2bb2f6b * c-c++-common/Wtautological-compare-2.c: Remove unused line.
adds dbbd4c6 gcc/c/ChangeLog
adds b419f44 Daily bump.
adds c14bac8 * config.sub, config.guess: Import from upstream.
adds 60a4580 Honour DriverOnly for enum values in error messages
adds ddc9c98 2015-07-28 Thomas Preud'homme <thomas.preudhomme(a)arm.com>
adds 16db639 2015-07-28 Richard Biener <rguenther(a)suse.de>
adds 95f4166 Handle double reduction in parloops
adds 95328f3 * config/rl78/rl78.c (rl78_addsi3_internal): New function. [...]
adds 66ed189 2015-07-28 Paolo Carlini <paolo.carlini(a)oracle.com>
adds 9d8e046 [AArch64] Properly handle simple arith+extend ops in rtx costs
adds 39e21ca 2015-07-28 Richard Biener <rguenther(a)suse.de>
adds aa0bf07 2015-07-28 Richard Biener <rguenther(a)suse.de>
adds 63593ac 2015-07-28 Eric Gallager <egall(a)gwmail.gwu.edu>
adds 68aee03 gcc/ * config/fr30/fr30.md (indirect_jump): Use pmode_regist [...]
adds de4e153 gcc/ * target-insns.def (indirect_jump): New targetm instruc [...]
adds f027535 gcc/ * target-insns.def (eh_return): New targetm instruction [...]
adds 4dd7c28 gcc/ * target-insns.def (can_extend, ptr_extend): New target [...]
adds f37fec3 gcc/ * target-insns.def (atomic_test_and_set): New targetm i [...]
adds 8a93a82 gcc/ * target-insns.def (reload_load_address): New targetm i [...]
adds d145b68 gcc/ 2015-07-28 David Sherwood <david.sherwood(a)arm.com>
adds 64ae101 Daily bump.
adds afd2b95 2015-07-28 Bill Schmidt <wschmidt(a)linux.vnet.ibm.com>
adds 940cb7d PR libstdc++/67015 * include/bits/regex_compiler.h (_Compil [...]
adds 64a6962 Use fast unwinder for PowerPC
adds 1ae7fdc 2015-07-29 Richard Biener <rguenther(a)suse.de>
adds 951c31b 2015-07-29 Richard Biener <rguenther(a)suse.de>
adds 5e0b3d2 2015-07-29 Richard Biener <rguenther(a)suse.de>
adds 6f52065 [AArch64] Add basic FP16 support
adds 87867af 2015-07-29 Ville Voutilainen <ville.voutilainen(a)gmail.com>
adds b7c1cfe 2015-07-29 Ville Voutilainen <ville.voutilainen(a)gmail.com>
adds ed5acf2 * testsuite/24_iterators/container_access.cc: New.
adds afa3578 [ARM/AArch64 Testsuite] Add basic fp16 tests
adds 236ea32 2015-07-29 Richard Biener <rguenther(a)suse.de>
adds 042f02d [AArch64 Testsuite] vld1-vst1_1.c: Add missing float32x4_t case
adds 1ee54bd [AArch64 Testsuite] vld1_lane.c: Remove unused test data
adds a13f5fb PR libstdc++/66829 * testsuite/lib/libstdc++.exp (v3-build_ [...]
adds df2106b PR libgfortran/66650 * libgfortran.h (GFC_DTYPE_SIZE_MASK): [...]
adds d46c0c7 * MAINTAINERS (Write After Approval): Add myself.
adds e4d0660 Fix whitespace in my MAINTAINERS change commit.
adds 1fe39f9 Define DBX_REGISTER_NUMBER for IA MCU
adds 0ba1028 [graphite] reduce the number of params in a scop to 3
adds 84a30a5 syscall: Fix to libgo/mksysinfo.sh
adds dcb1277 Daily bump.
adds b12954a PR target/66217 PR target/67045 * config/rs6000/rs6000.md [...]
adds 081da05 DR 1558 PR c++/67021 * pt.c (tsubst_decl) [TYPE_DECL]: Cle [...]
adds c4699ff 2015-07-30 Richard Biener <rguenther(a)suse.de>
adds 18b3866 2015-07-30 Richard Biener <rguenther(a)suse.de>
adds f58dd84 * c-common.c (warn_tautological_cmp): Bail for float types.
adds 330d065 * include/experimental/any (any::operator=(const any&)): Che [...]
adds 43d8404 2015-07-30 Paolo Carlini <paolo.carlini(a)oracle.com>
adds 17af35c * include/bits/regex_automaton.h (_State_base, _State<>): R [...]
adds 436dc21 2015-07-30 Richard Biener <rguenther(a)suse.de>
adds 0879fd1 * testsuite/experimental/filesystem/operations/current_path. [...]
adds 6e25659 gcc/ 2015-07-30 David Sherwood <david.sherwood(a)arm.com>
adds de299e5 2015-07-30 Richard Biener <rguenther(a)suse.de>
adds f4a09f4 gcc/ * builtins.c (HAVE_atomic_clear, gen_atomic_clear): Del [...]
adds 7b42a29 [AArch64] Removed unused VRL2/3/4 iterator values
adds 5638e47 * gcc.target/i386/pr66648.c: Move to correct place.
adds e880695 * c-pretty-print.c (unary_expression) [INDIRECT_REF]: Don't [...]
adds a8a727a Use lowpart_subreg instead of simplify_gen_subreg
adds be3783f [V850] Hookize LIBCALL_VALUE
adds fa7dcde Daily bump.
adds eb37590 * sv.po: Update.
adds 2aa16f1 * sv.po: Update.
adds 86a932e Don't cancel loop tree in parloops
adds 58c4f49 * go-lang.c (go_langhook_init_options_struct): Don't set x_fl [...]
adds b1cd5ae 2015-07-31 Richard Biener <rguenther(a)suse.de>
adds 5d262bd Refactoring masked built-in decls to use proper mask type.
adds 56b4132 2015-07-31 Richard Biener <rguenther(a)suse.de>
adds 4150a43 PR sanitizer/66977 * typeck.c (get_member_function_from_ptr [...]
adds 2d86a0e PR target/66870 * config/rs6000/rs6000.c (machine_function) [...]
adds 245894e * config/m32r/m32r.c (m32r_attribute_identifier): New functi [...]
adds 530bb69 [ARM][2/3] Make if_neg_move and if_move_neg into insn_and_split
adds 8b3c974 compiler: Don't allow builtin function values.
adds ad10d66 * MAINTAINERS (nvptx): Add self.
adds 8289950 compiler: Update unicode tables.
adds 6d69611 compiler: Check the type in function declarations.
adds 4d51316 PR target/67049 * config/sh/sh.md (GOTaddr2picreg): Fix typo [...]
adds 5f1045b compiler: Report errors for malformed builtin calls.
adds 4691a53 Daily bump.
adds 5955834 Allow non-overflow ops in reductions
adds 814b1ca 2015-08-01 Paul Thomas <pault(a)gcc.gnu.org>
adds 6ffea52 Daily bump.
adds 68a98a7 Fix PR 66521
adds 3d5db02 2015-08-01 Michael Collison <michael.collison(a)linaro.org [...]
adds 9255be0 Refactor entry point to -Wmisleading-indentation
adds f95bfdd Remove is_first_nonwhitespace_on_line(), instead improve get_ [...]
adds 17afcef Improve -Wmisleading-indentation heuristics
adds 5b252e9 gcc/ChangeLog 2015-07-28 Martin Sebor <msebor(a)redhat.com>
adds 408da55 Daily bump.
adds d1a8d2a * MAINTAINERS (loop ivopts): Add the entry and myself.
adds 9dd88d4 2015-08-03 Richard Biener <rguenther(a)suse.de>
adds 535bc42 2015-08-03 Richard Biener <rguenther(a)suse.de>
adds f11d6df 2015-08-03 Richard Biener <rguenther(a)suse.de>
adds 5a0909a 2015-08-03 Richard Biener <rguenther(a)suse.de>
adds a929e01 [RTL-ifcvt] Improve conditional select ops on immediates
new 4f2ebec Merged trunk revision 226491 into the hsa branch.
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "adds" were already present in the repository and have only
been added to this reference.
Summary of changes:
ChangeLog | 32 +
MAINTAINERS | 13 +-
boehm-gc/ChangeLog | 8 +
boehm-gc/Makefile.direct | 2 +-
boehm-gc/Makefile.dist | 2 +-
boehm-gc/doc/README | 2 +-
boehm-gc/version.h | 4 +-
config-ml.in | 6 +-
config.guess | 31 +-
config.sub | 18 +-
config/ChangeLog | 8 +
config/gettext.m4 | 4 +-
config/po.m4 | 4 +-
config/stdint.m4 | 2 +-
config/tcl.m4 | 4 +-
configure | 8 +-
configure.ac | 8 +-
fixincludes/ChangeLog | 4 +
fixincludes/check.tpl | 5 +-
gcc/ChangeLog | 1983 ++++
gcc/DATESTAMP | 2 +-
gcc/Makefile.in | 4 +-
gcc/acinclude.m4 | 2 +-
gcc/ada/ChangeLog | 6 +
gcc/ada/gcc-interface/Makefile.in | 2 +-
gcc/ada/prj-nmsc.adb | 2 +-
gcc/alias.c | 6 +-
gcc/builtins.c | 40 +-
gcc/c-family/ChangeLog | 72 +
gcc/c-family/c-common.c | 137 +-
gcc/c-family/c-common.h | 9 +-
gcc/c-family/c-indentation.c | 299 +-
gcc/c-family/c-indentation.h | 52 +
gcc/c-family/c-opts.c | 4 +
gcc/c-family/c-pretty-print.c | 8 +-
gcc/c-family/c-ubsan.c | 26 +-
gcc/c-family/c.opt | 16 +
gcc/c/ChangeLog | 30 +
gcc/c/c-decl.c | 20 +-
gcc/c/c-parser.c | 81 +-
gcc/c/c-typeck.c | 26 +-
gcc/cfgexpand.c | 19 +-
gcc/combine.c | 100 +-
gcc/config.host | 8 +-
gcc/config.in | 9 +-
gcc/config/aarch64/aarch64-builtins.c | 39 +-
gcc/config/aarch64/aarch64-elf-raw.h | 7 +-
gcc/config/aarch64/aarch64-linux.h | 5 +-
gcc/config/aarch64/aarch64-modes.def | 4 +
gcc/config/aarch64/aarch64-simd-builtins.def | 12 +-
gcc/config/aarch64/aarch64-simd.md | 76 +-
gcc/config/aarch64/aarch64.c | 60 +-
gcc/config/aarch64/aarch64.h | 4 +-
gcc/config/aarch64/aarch64.md | 97 +-
gcc/config/aarch64/arm_neon.h | 276 +-
gcc/config/aarch64/iterators.md | 18 +-
gcc/config/alpha/alpha.c | 8 +-
gcc/config/alpha/predicates.md | 8 +-
gcc/config/arm/arm-arches.def | 3 +-
gcc/config/arm/arm-builtins.c | 84 +-
gcc/config/arm/arm-c.c | 5 +
gcc/config/arm/arm-cores.def | 4 +-
gcc/config/arm/arm-protos.h | 8 +-
gcc/config/arm/arm-tables.opt | 31 +-
gcc/config/arm/arm.c | 59 +-
gcc/config/arm/arm.h | 2 +-
gcc/config/arm/arm.md | 98 +-
gcc/config/arm/arm_neon_builtins.def | 82 +-
gcc/config/arm/cortex-a53.md | 2 +-
gcc/config/arm/driver-arm.c | 3 +
gcc/config/arm/neon.md | 41 +-
gcc/config/avr/avr-dimode.md | 6 +-
gcc/config/fr30/fr30.md | 4 +-
gcc/config/i386/i386-builtin-types.def | 864 +-
gcc/config/i386/i386.c | 3446 ++++---
gcc/config/i386/i386.h | 9 +
gcc/config/i386/i386.md | 50 +-
gcc/config/i386/iamcu.h | 11 +
gcc/config/i386/linux-common.h | 6 +-
gcc/config/i386/predicates.md | 12 +-
gcc/config/i386/sse.md | 8 +-
gcc/config/m32r/m32r.c | 10 +
gcc/config/mips/i6400.md | 142 +
gcc/config/mips/m5100.md | 220 +
gcc/config/mips/mips-cpus.def | 11 +-
gcc/config/mips/mips-tables.opt | 47 +-
gcc/config/mips/mips.c | 29 +-
gcc/config/mips/mips.h | 16 +-
gcc/config/mips/mips.md | 4 +
gcc/config/msp430/constraints.md | 10 +
gcc/config/msp430/msp430.h | 2 +-
gcc/config/msp430/msp430.md | 41 +-
gcc/config/msp430/t-msp430 | 2 +-
gcc/config/nvptx/mkoffload.c | 21 +-
gcc/config/nvptx/nvptx.c | 29 +-
gcc/config/rl78/rl78-protos.h | 1 +
gcc/config/rl78/rl78-real.md | 4 +-
gcc/config/rl78/rl78.c | 30 +
gcc/config/rl78/rl78.md | 5 +-
gcc/config/rs6000/constraints.md | 20 +-
gcc/config/rs6000/predicates.md | 170 +-
gcc/config/rs6000/rs6000-protos.h | 17 +-
gcc/config/rs6000/rs6000.c | 837 +-
gcc/config/rs6000/rs6000.md | 1391 +--
gcc/config/s390/driver-native.c | 143 +-
gcc/config/s390/s390.c | 73 +-
gcc/config/s390/s390.h | 29 +-
gcc/config/s390/s390.md | 65 +
gcc/config/sh/sh.c | 1 +
gcc/config/sh/sh.md | 2 +-
gcc/config/spu/spu.c | 10 +-
gcc/config/v850/v850.c | 15 +-
gcc/config/v850/v850.h | 6 -
gcc/config/v850/v850.md | 1 +
gcc/configure | 52 +-
gcc/configure.ac | 31 +-
gcc/cp/ChangeLog | 146 +
gcc/cp/call.c | 22 +-
gcc/cp/class.c | 80 +-
gcc/cp/constexpr.c | 5 +-
gcc/cp/cvt.c | 3 +-
gcc/cp/decl.c | 98 +-
gcc/cp/decl2.c | 12 +-
gcc/cp/except.c | 5 +-
gcc/cp/friend.c | 6 +-
gcc/cp/init.c | 11 +-
gcc/cp/mangle.c | 26 +-
gcc/cp/method.c | 22 +-
gcc/cp/name-lookup.c | 36 +-
gcc/cp/parser.c | 109 +-
gcc/cp/pt.c | 50 +-
gcc/cp/search.c | 2 +-
gcc/cp/semantics.c | 4 +-
gcc/cp/typeck.c | 52 +-
gcc/cp/typeck2.c | 6 +-
gcc/cse.c | 15 +-
gcc/doc/extend.texi | 14 +-
gcc/doc/install.texi | 8 +-
gcc/doc/invoke.texi | 62 +-
gcc/doc/md.texi | 12 -
gcc/doc/tm.texi | 2 +-
gcc/doc/tm.texi.in | 2 +-
gcc/dwarf2out.c | 4 +
gcc/emit-rtl.c | 12 +-
gcc/except.c | 6 +-
gcc/expmed.c | 4 -
gcc/expr.c | 4 +-
gcc/fold-const.c | 346 +-
gcc/fortran/ChangeLog | 24 +
gcc/fortran/parse.c | 6 +-
gcc/fortran/trans-array.c | 6 +-
gcc/fortran/trans-expr.c | 2 +-
gcc/fortran/trans-intrinsic.c | 2 +
gcc/function.c | 2 -
gcc/genemit.c | 8 -
gcc/generic-match-head.c | 2 +
gcc/genmatch.c | 685 +-
gcc/genmodes.c | 4 +-
gcc/gimple-fold.c | 269 +-
gcc/gimple-match-head.c | 263 +-
gcc/gimple.h | 8 +-
gcc/gimplify.c | 170 +-
gcc/go/ChangeLog | 6 +
gcc/go/go-lang.c | 9 +-
gcc/go/gofrontend/MERGE | 2 +-
gcc/go/gofrontend/expressions.cc | 18 +-
gcc/go/gofrontend/gogo.cc | 79 +-
gcc/go/gofrontend/gogo.h | 8 +
gcc/go/gofrontend/lex.cc | 488 +-
gcc/go/gofrontend/parse.cc | 14 +-
gcc/go/gofrontend/statements.cc | 3 +-
gcc/graphite-blocking.c | 1 +
gcc/graphite-dependences.c | 15 +-
gcc/graphite-interchange.c | 1 +
gcc/graphite-isl-ast-to-gimple.c | 214 +-
gcc/graphite-optimize-isl.c | 10 +-
gcc/graphite-poly.c | 1 +
gcc/graphite-poly.h | 5 +
gcc/graphite-scop-detection.c | 73 +-
gcc/graphite-sese-to-poly.c | 21 +-
gcc/graphite.c | 1 +
gcc/ifcvt.c | 63 +-
gcc/ipa-devirt.c | 2 +-
gcc/ipa-inline-analysis.c | 6 +
gcc/jit/ChangeLog | 18 +
gcc/jit/docs/_build/texinfo/libgccjit.texi | 28 +-
.../docs/internals/test-hello-world.exe.log.txt | 26 +-
gcc/jit/jit-playback.c | 38 +-
gcc/jit/jit-playback.h | 3 +
gcc/loop-iv.c | 11 -
gcc/lra-eliminations.c | 3 +-
gcc/lra-remat.c | 10 +
gcc/lto-streamer-out.c | 4 +-
gcc/machmode.h | 20 +-
gcc/match.pd | 228 +-
gcc/omp-low.c | 38 +-
gcc/optabs.c | 32 +-
gcc/opts-common.c | 2 +
gcc/params.def | 2 +-
gcc/po/ChangeLog | 11 +
gcc/po/be.po | 8364 ++++++++---------
gcc/po/da.po | 8378 ++++++++---------
gcc/po/de.po | 8416 ++++++++---------
gcc/po/el.po | 8367 ++++++++---------
gcc/po/es.po | 8392 ++++++++---------
gcc/po/fi.po | 8384 ++++++++---------
gcc/po/fr.po | 8376 ++++++++---------
gcc/po/hr.po | 8361 ++++++++---------
gcc/po/id.po | 8391 ++++++++---------
gcc/po/ja.po | 8383 ++++++++---------
gcc/po/nl.po | 8370 ++++++++---------
gcc/po/ru.po | 8373 ++++++++---------
gcc/po/sr.po | 8390 ++++++++---------
gcc/po/sv.po | 8407 ++++++++---------
gcc/po/tr.po | 8390 ++++++++---------
gcc/po/{hr.po => uk.po} | 9550 ++++++++++----------
gcc/po/vi.po | 8390 ++++++++---------
gcc/po/zh_CN.po | 8396 ++++++++---------
gcc/po/zh_TW.po | 8385 ++++++++---------
gcc/reload1.c | 6 +-
gcc/rtl.h | 5 +-
gcc/rtlanal.c | 15 +-
gcc/simplify-rtx.c | 83 +-
gcc/ssa-iterators.h | 62 +-
gcc/stor-layout.c | 14 +-
gcc/target-insns.def | 6 +
gcc/testsuite/ChangeLog | 653 +-
.../c-c++-common/Wmisleading-indentation.c | 166 +
gcc/testsuite/c-c++-common/Wshift-overflow-1.c | 58 +
gcc/testsuite/c-c++-common/Wshift-overflow-2.c | 58 +
gcc/testsuite/c-c++-common/Wshift-overflow-3.c | 59 +
gcc/testsuite/c-c++-common/Wshift-overflow-4.c | 59 +
gcc/testsuite/c-c++-common/Wshift-overflow-5.c | 11 +
.../c-c++-common/Wtautological-compare-1.c | 70 +
.../c-c++-common/Wtautological-compare-2.c | 13 +
.../c-c++-common/Wtautological-compare-3.c | 20 +
gcc/testsuite/c-c++-common/Wunused-function-1.c | 10 +
gcc/testsuite/c-c++-common/ubsan/pr66908.c | 15 +
gcc/testsuite/g++.dg/Wframe-address-in-Wall.C | 14 +
gcc/testsuite/g++.dg/Wframe-address.C | 70 +
gcc/testsuite/g++.dg/Wno-frame-address.C | 6 +
gcc/testsuite/g++.dg/cpp0x/alias-decl-52.C | 24 +
gcc/testsuite/g++.dg/cpp0x/decltype-54581.C | 2 +-
gcc/testsuite/g++.dg/cpp1y/left-shift-1.C | 11 +
gcc/testsuite/g++.dg/cpp1z/abbrev1.C | 11 +
gcc/testsuite/g++.dg/expr/string-2.C | 2 +-
gcc/testsuite/g++.dg/ext/mv24.C | 35 +
gcc/testsuite/g++.dg/init/pr66857.C | 19 +
gcc/testsuite/g++.dg/other/vector-compare.C | 2 +-
gcc/testsuite/g++.dg/parse/error57.C | 4 +
gcc/testsuite/g++.dg/template/crash81.C | 3 +-
gcc/testsuite/g++.dg/template/pr18969-2.C | 11 +
gcc/testsuite/g++.dg/template/pr18969.C | 14 +
gcc/testsuite/g++.dg/ubsan/pr66977.C | 27 +
gcc/testsuite/g++.dg/warn/Wlogical-op-2.C | 30 +
gcc/testsuite/g++.old-deja/g++.jason/overload.C | 2 +-
gcc/testsuite/gcc.c-torture/execute/pr40386.c | 2 +-
gcc/testsuite/gcc.dg/Wframe-address-in-Wall.c | 14 +
gcc/testsuite/gcc.dg/Wframe-address.c | 54 +
gcc/testsuite/gcc.dg/Wno-frame-address.c | 6 +
gcc/testsuite/gcc.dg/autopar/outer-4.c | 21 +-
gcc/testsuite/gcc.dg/autopar/outer-5.c | 2 +-
gcc/testsuite/gcc.dg/autopar/outer-6.c | 4 +-
gcc/testsuite/gcc.dg/autopar/reduc-2.c | 4 +-
gcc/testsuite/gcc.dg/autopar/reduc-2char.c | 10 +-
gcc/testsuite/gcc.dg/autopar/reduc-2short.c | 10 +-
gcc/testsuite/gcc.dg/autopar/reduc-8.c | 5 +-
.../gcc.dg/autopar/{outer-1.c => uns-outer-4.c} | 26 +-
gcc/testsuite/gcc.dg/autopar/uns-outer-5.c | 49 +
.../gcc.dg/autopar/{outer-6.c => uns-outer-6.c} | 42 +-
gcc/testsuite/gcc.dg/c90-left-shift-2.c | 14 +
gcc/testsuite/gcc.dg/c90-left-shift-3.c | 14 +
gcc/testsuite/gcc.dg/c99-left-shift-2.c | 14 +
gcc/testsuite/gcc.dg/c99-left-shift-3.c | 14 +
gcc/testsuite/gcc.dg/graphite/block-1.c | 2 +-
gcc/testsuite/gcc.dg/graphite/graphite.exp | 6 +-
gcc/testsuite/gcc.dg/graphite/interchange-12.c | 2 +-
gcc/testsuite/gcc.dg/graphite/interchange-14.c | 2 +-
gcc/testsuite/gcc.dg/graphite/interchange-15.c | 2 +-
gcc/testsuite/gcc.dg/graphite/interchange-9.c | 2 +-
gcc/testsuite/gcc.dg/graphite/interchange-mvt.c | 2 +-
.../gcc.dg/graphite/{block-1.c => uns-block-1.c} | 10 +-
.../{interchange-12.c => uns-interchange-12.c} | 13 +-
.../{interchange-14.c => uns-interchange-14.c} | 5 +-
.../{interchange-15.c => uns-interchange-15.c} | 7 +-
.../{interchange-9.c => uns-interchange-9.c} | 11 +-
.../{interchange-mvt.c => uns-interchange-mvt.c} | 7 +-
.../gcc.dg/parloops-exit-first-loop-alt-2.c | 9 +-
.../gcc.dg/parloops-exit-first-loop-alt-3.c | 9 +-
.../gcc.dg/parloops-exit-first-loop-alt-4.c | 9 +-
.../gcc.dg/parloops-exit-first-loop-alt-5.c | 9 +-
.../gcc.dg/parloops-exit-first-loop-alt-6.c | 9 +-
.../gcc.dg/parloops-exit-first-loop-alt-7.c | 9 +-
.../gcc.dg/parloops-exit-first-loop-alt-pr66652.c | 11 +-
.../gcc.dg/parloops-exit-first-loop-alt.c | 10 +-
gcc/testsuite/gcc.dg/parm-incomplete-1.c | 1 -
gcc/testsuite/gcc.dg/pr18809-1.c | 1 -
gcc/testsuite/gcc.dg/pr25529.c | 11 +
gcc/testsuite/gcc.dg/pr25530.c | 11 +
gcc/testsuite/gcc.dg/pr27953.c | 1 -
gcc/testsuite/gcc.dg/pr40501.c | 2 +-
gcc/testsuite/gcc.dg/torture/pr66945.c | 12 +
gcc/testsuite/gcc.dg/torture/pr66952.c | 28 +
gcc/testsuite/gcc.dg/vect/pr33373.c | 1 +
gcc/testsuite/gcc.dg/vect/pr66951.c | 14 +
gcc/testsuite/gcc.dg/vect/trapv-vect-reduc-4.c | 2 +-
gcc/testsuite/gcc.dg/vect/vect-shift-2-big-array.c | 1 +
gcc/testsuite/gcc.dg/vect/vect-shift-2.c | 1 +
gcc/testsuite/gcc.dg/vla-11.c | 1 -
gcc/testsuite/gcc.dg/vmx/unpack-be-order.c | 2 +-
gcc/testsuite/gcc.dg/vmx/unpack.c | 2 +
.../advsimd-intrinsics/vld2_lane_f32_indices_1.c | 16 +
.../advsimd-intrinsics/vld2_lane_f64_indices_1.c | 17 +
.../advsimd-intrinsics/vld2_lane_p8_indices_1.c | 16 +
.../advsimd-intrinsics/vld2_lane_s16_indices_1.c | 16 +
.../advsimd-intrinsics/vld2_lane_s32_indices_1.c | 16 +
.../advsimd-intrinsics/vld2_lane_s64_indices_1.c | 17 +
.../advsimd-intrinsics/vld2_lane_s8_indices_1.c | 16 +
.../advsimd-intrinsics/vld2_lane_u16_indices_1.c | 16 +
.../advsimd-intrinsics/vld2_lane_u32_indices_1.c | 16 +
.../advsimd-intrinsics/vld2_lane_u64_indices_1.c | 17 +
.../advsimd-intrinsics/vld2_lane_u8_indices_1.c | 16 +
.../advsimd-intrinsics/vld2q_lane_f32_indices_1.c | 16 +
.../advsimd-intrinsics/vld2q_lane_f64_indices_1.c | 17 +
.../advsimd-intrinsics/vld2q_lane_p8_indices_1.c | 17 +
.../advsimd-intrinsics/vld2q_lane_s16_indices_1.c | 16 +
.../advsimd-intrinsics/vld2q_lane_s32_indices_1.c | 16 +
.../advsimd-intrinsics/vld2q_lane_s64_indices_1.c | 17 +
.../advsimd-intrinsics/vld2q_lane_s8_indices_1.c | 17 +
.../advsimd-intrinsics/vld2q_lane_u16_indices_1.c | 16 +
.../advsimd-intrinsics/vld2q_lane_u32_indices_1.c | 16 +
.../advsimd-intrinsics/vld2q_lane_u64_indices_1.c | 17 +
.../advsimd-intrinsics/vld2q_lane_u8_indices_1.c | 17 +
.../advsimd-intrinsics/vld3_lane_f32_indices_1.c | 16 +
.../advsimd-intrinsics/vld3_lane_f64_indices_1.c | 17 +
.../advsimd-intrinsics/vld3_lane_p8_indices_1.c | 16 +
.../advsimd-intrinsics/vld3_lane_s16_indices_1.c | 16 +
.../advsimd-intrinsics/vld3_lane_s32_indices_1.c | 16 +
.../advsimd-intrinsics/vld3_lane_s64_indices_1.c | 17 +
.../advsimd-intrinsics/vld3_lane_s8_indices_1.c | 16 +
.../advsimd-intrinsics/vld3_lane_u16_indices_1.c | 16 +
.../advsimd-intrinsics/vld3_lane_u32_indices_1.c | 16 +
.../advsimd-intrinsics/vld3_lane_u64_indices_1.c | 17 +
.../advsimd-intrinsics/vld3_lane_u8_indices_1.c | 16 +
.../advsimd-intrinsics/vld3q_lane_f32_indices_1.c | 16 +
.../advsimd-intrinsics/vld3q_lane_f64_indices_1.c | 17 +
.../advsimd-intrinsics/vld3q_lane_p8_indices_1.c | 17 +
.../advsimd-intrinsics/vld3q_lane_s16_indices_1.c | 16 +
.../advsimd-intrinsics/vld3q_lane_s32_indices_1.c | 16 +
.../advsimd-intrinsics/vld3q_lane_s64_indices_1.c | 17 +
.../advsimd-intrinsics/vld3q_lane_s8_indices_1.c | 17 +
.../advsimd-intrinsics/vld3q_lane_u16_indices_1.c | 16 +
.../advsimd-intrinsics/vld3q_lane_u32_indices_1.c | 16 +
.../advsimd-intrinsics/vld3q_lane_u64_indices_1.c | 17 +
.../advsimd-intrinsics/vld3q_lane_u8_indices_1.c | 17 +
.../advsimd-intrinsics/vld4_lane_f32_indices_1.c | 16 +
.../advsimd-intrinsics/vld4_lane_f64_indices_1.c | 17 +
.../advsimd-intrinsics/vld4_lane_p8_indices_1.c | 16 +
.../advsimd-intrinsics/vld4_lane_s16_indices_1.c | 16 +
.../advsimd-intrinsics/vld4_lane_s32_indices_1.c | 16 +
.../advsimd-intrinsics/vld4_lane_s64_indices_1.c | 17 +
.../advsimd-intrinsics/vld4_lane_s8_indices_1.c | 16 +
.../advsimd-intrinsics/vld4_lane_u16_indices_1.c | 16 +
.../advsimd-intrinsics/vld4_lane_u32_indices_1.c | 16 +
.../advsimd-intrinsics/vld4_lane_u64_indices_1.c | 17 +
.../advsimd-intrinsics/vld4_lane_u8_indices_1.c | 16 +
.../advsimd-intrinsics/vld4q_lane_f32_indices_1.c | 16 +
.../advsimd-intrinsics/vld4q_lane_f64_indices_1.c | 17 +
.../advsimd-intrinsics/vld4q_lane_p8_indices_1.c | 17 +
.../advsimd-intrinsics/vld4q_lane_s16_indices_1.c | 16 +
.../advsimd-intrinsics/vld4q_lane_s32_indices_1.c | 16 +
.../advsimd-intrinsics/vld4q_lane_s64_indices_1.c | 17 +
.../advsimd-intrinsics/vld4q_lane_s8_indices_1.c | 17 +
.../advsimd-intrinsics/vld4q_lane_u16_indices_1.c | 16 +
.../advsimd-intrinsics/vld4q_lane_u32_indices_1.c | 16 +
.../advsimd-intrinsics/vld4q_lane_u64_indices_1.c | 17 +
.../advsimd-intrinsics/vld4q_lane_u8_indices_1.c | 17 +
.../advsimd-intrinsics/vst2_lane_f32_indices_1.c | 15 +
.../advsimd-intrinsics/vst2_lane_f64_indices_1.c | 16 +
.../advsimd-intrinsics/vst2_lane_p8_indices_1.c | 15 +
.../advsimd-intrinsics/vst2_lane_s16_indices_1.c | 15 +
.../advsimd-intrinsics/vst2_lane_s32_indices_1.c | 15 +
.../advsimd-intrinsics/vst2_lane_s64_indices_1.c | 16 +
.../advsimd-intrinsics/vst2_lane_s8_indices_1.c | 15 +
.../advsimd-intrinsics/vst2_lane_u16_indices_1.c | 15 +
.../advsimd-intrinsics/vst2_lane_u32_indices_1.c | 15 +
.../advsimd-intrinsics/vst2_lane_u64_indices_1.c | 16 +
.../advsimd-intrinsics/vst2_lane_u8_indices_1.c | 15 +
.../advsimd-intrinsics/vst2q_lane_f32_indices_1.c | 15 +
.../advsimd-intrinsics/vst2q_lane_f64_indices_1.c | 16 +
.../advsimd-intrinsics/vst2q_lane_p8_indices_1.c | 16 +
.../advsimd-intrinsics/vst2q_lane_s16_indices_1.c | 15 +
.../advsimd-intrinsics/vst2q_lane_s32_indices_1.c | 15 +
.../advsimd-intrinsics/vst2q_lane_s64_indices_1.c | 16 +
.../advsimd-intrinsics/vst2q_lane_s8_indices_1.c | 16 +
.../advsimd-intrinsics/vst2q_lane_u16_indices_1.c | 15 +
.../advsimd-intrinsics/vst2q_lane_u32_indices_1.c | 15 +
.../advsimd-intrinsics/vst2q_lane_u64_indices_1.c | 16 +
.../advsimd-intrinsics/vst2q_lane_u8_indices_1.c | 16 +
.../advsimd-intrinsics/vst3_lane_f32_indices_1.c | 15 +
.../advsimd-intrinsics/vst3_lane_f64_indices_1.c | 16 +
.../advsimd-intrinsics/vst3_lane_p8_indices_1.c | 15 +
.../advsimd-intrinsics/vst3_lane_s16_indices_1.c | 15 +
.../advsimd-intrinsics/vst3_lane_s32_indices_1.c | 15 +
.../advsimd-intrinsics/vst3_lane_s64_indices_1.c | 16 +
.../advsimd-intrinsics/vst3_lane_s8_indices_1.c | 15 +
.../advsimd-intrinsics/vst3_lane_u16_indices_1.c | 15 +
.../advsimd-intrinsics/vst3_lane_u32_indices_1.c | 15 +
.../advsimd-intrinsics/vst3_lane_u64_indices_1.c | 16 +
.../advsimd-intrinsics/vst3_lane_u8_indices_1.c | 15 +
.../advsimd-intrinsics/vst3q_lane_f32_indices_1.c | 15 +
.../advsimd-intrinsics/vst3q_lane_f64_indices_1.c | 16 +
.../advsimd-intrinsics/vst3q_lane_p8_indices_1.c | 16 +
.../advsimd-intrinsics/vst3q_lane_s16_indices_1.c | 15 +
.../advsimd-intrinsics/vst3q_lane_s32_indices_1.c | 15 +
.../advsimd-intrinsics/vst3q_lane_s64_indices_1.c | 16 +
.../advsimd-intrinsics/vst3q_lane_s8_indices_1.c | 16 +
.../advsimd-intrinsics/vst3q_lane_u16_indices_1.c | 15 +
.../advsimd-intrinsics/vst3q_lane_u32_indices_1.c | 15 +
.../advsimd-intrinsics/vst3q_lane_u64_indices_1.c | 16 +
.../advsimd-intrinsics/vst3q_lane_u8_indices_1.c | 16 +
.../advsimd-intrinsics/vst4_lane_f32_indices_1.c | 15 +
.../advsimd-intrinsics/vst4_lane_f64_indices_1.c | 16 +
.../advsimd-intrinsics/vst4_lane_p8_indices_1.c | 15 +
.../advsimd-intrinsics/vst4_lane_s16_indices_1.c | 15 +
.../advsimd-intrinsics/vst4_lane_s32_indices_1.c | 15 +
.../advsimd-intrinsics/vst4_lane_s64_indices_1.c | 16 +
.../advsimd-intrinsics/vst4_lane_s8_indices_1.c | 15 +
.../advsimd-intrinsics/vst4_lane_u16_indices_1.c | 15 +
.../advsimd-intrinsics/vst4_lane_u32_indices_1.c | 15 +
.../advsimd-intrinsics/vst4_lane_u64_indices_1.c | 16 +
.../advsimd-intrinsics/vst4_lane_u8_indices_1.c | 15 +
.../advsimd-intrinsics/vst4q_lane_f32_indices_1.c | 15 +
.../advsimd-intrinsics/vst4q_lane_f64_indices_1.c | 16 +
.../advsimd-intrinsics/vst4q_lane_p8_indices_1.c | 16 +
.../advsimd-intrinsics/vst4q_lane_s16_indices_1.c | 15 +
.../advsimd-intrinsics/vst4q_lane_s32_indices_1.c | 15 +
.../advsimd-intrinsics/vst4q_lane_s64_indices_1.c | 16 +
.../advsimd-intrinsics/vst4q_lane_s8_indices_1.c | 16 +
.../advsimd-intrinsics/vst4q_lane_u16_indices_1.c | 15 +
.../advsimd-intrinsics/vst4q_lane_u32_indices_1.c | 15 +
.../advsimd-intrinsics/vst4q_lane_u64_indices_1.c | 16 +
.../advsimd-intrinsics/vst4q_lane_u8_indices_1.c | 16 +
gcc/testsuite/gcc.target/aarch64/csel_bfx_1.c | 11 +
gcc/testsuite/gcc.target/aarch64/csel_imms_inc_1.c | 42 +
gcc/testsuite/gcc.target/aarch64/f16_movs_1.c | 26 +
.../gcc.target/aarch64/fp16/f16_convs_1.c | 34 +
.../gcc.target/aarch64/fp16/f16_convs_2.c | 33 +
.../{nvptx/nvptx.exp => aarch64/fp16/fp16.exp} | 13 +-
gcc/testsuite/gcc.target/aarch64/got_mem_hoist_1.c | 1 +
gcc/testsuite/gcc.target/aarch64/neg_abs_1.c | 17 +
gcc/testsuite/gcc.target/aarch64/vld1-vst1_1.c | 1 +
gcc/testsuite/gcc.target/aarch64/vld1_lane.c | 29 +-
gcc/testsuite/gcc.target/alpha/pr66140.c | 2 +-
gcc/testsuite/gcc.target/arm/mincmp.c | 20 +
.../pr41917.c => gcc.target/arm/reg_equal_test.c} | 5 +-
.../arm/split-live-ranges-for-shrink-wrap.c | 2 +
gcc/testsuite/gcc.target/arm/thumb-bitfld1.c | 2 +
gcc/testsuite/gcc.target/i386/asm-flag-5.c | 1 +
gcc/testsuite/gcc.target/i386/mpx/pr66566.c | 12 +
gcc/testsuite/gcc.target/i386/pr66232-6.c | 13 +
gcc/testsuite/gcc.target/i386/pr66232-7.c | 14 +
gcc/testsuite/gcc.target/i386/pr66232-8.c | 13 +
gcc/testsuite/gcc.target/i386/pr66232-9.c | 13 +
gcc/testsuite/gcc.target/i386/pr66424.c | 51 +
gcc/testsuite/gcc.target/i386/pr66648.c | 33 +
gcc/testsuite/gcc.target/i386/pr66978.c | 15 +
gcc/testsuite/gcc.target/powerpc/quad-atomic.c | 2 +-
gcc/testsuite/gcc.target/s390/gpr2fprsavecfi.c | 23 +
gcc/testsuite/gcc.target/s390/insv-1.c | 111 +
gcc/testsuite/gcc.target/s390/insv-2.c | 111 +
gcc/testsuite/gcc.target/s390/insv-3.c | 18 +
gcc/testsuite/gfortran.dg/associated_target_6.f03 | 49 +
.../gfortran.dg/derived_constructor_comps_6.f90 | 2 +-
gcc/testsuite/gfortran.dg/generic_30.f90 | 41 +
.../gfortran.dg/parloops-exit-first-loop-alt-2.f95 | 9 +-
.../gfortran.dg/parloops-exit-first-loop-alt.f95 | 10 +-
gcc/toplev.c | 9 +-
gcc/tree-browser.c | 965 --
gcc/tree-browser.def | 97 -
gcc/tree-cfg.c | 84 +-
gcc/tree-cfg.h | 1 -
gcc/tree-inline.c | 1 -
gcc/tree-parloops.c | 147 +-
gcc/tree-pass.h | 1 -
gcc/tree-ssa-ifcombine.c | 17 +-
gcc/tree-ssa-math-opts.c | 2 +-
gcc/tree-ssa-operands.c | 19 +-
gcc/tree-ssa-propagate.c | 26 +-
gcc/tree-ssa-sccvn.c | 2 +
gcc/tree-ssanames.c | 17 +
gcc/tree-ssanames.h | 1 +
gcc/tree-vect-data-refs.c | 35 +-
gcc/tree-vect-loop-manip.c | 9 +-
gcc/tree-vect-loop.c | 46 +-
gcc/tree-vect-stmts.c | 26 +-
gcc/tree-vectorizer.h | 18 +-
gcc/tree.c | 69 +
gcc/tree.h | 2 +
gcc/vtable-verify.c | 92 +-
gcc/vtable-verify.h | 5 +
intl/ChangeLog | 5 +
intl/configure | 4 +-
libcpp/po/ChangeLog | 8 +
libcpp/po/nl.po | 95 +-
libcpp/po/sv.po | 6 +-
libgcc/ChangeLog | 11 +
libgcc/config/i386/cpuinfo.c | 5 +-
libgcc/config/nios2/linux-atomic.c | 5 -
libgfortran/ChangeLog | 6 +
libgfortran/libgfortran.h | 3 +-
libgo/mksysinfo.sh | 187 +
libgomp/ChangeLog | 55 +
libgomp/libgomp.h | 1 +
libgomp/oacc-init.c | 13 +-
libgomp/oacc-parallel.c | 79 +-
libgomp/plugin/plugin-nvptx.c | 145 +-
libgomp/target.c | 146 +-
libgomp/testsuite/libgomp.c/examples-4/simd-7.c | 25 +-
libgomp/testsuite/libgomp.c/pr66714.c | 17 +
libgomp/testsuite/libgomp.c/uns-outer-4.c | 36 +
.../libgomp.fortran/examples-4/simd-7.f90 | 30 +-
libjava/ChangeLog | 5 +
libjava/classpath/ChangeLog | 10 +
libjava/classpath/INSTALL | 7 +-
libjava/classpath/ltconfig | 2 +-
libjava/classpath/m4/ac_prog_javac.m4 | 4 +-
libjava/classpath/m4/ac_prog_javac_works.m4 | 2 +-
libjava/classpath/missing | 15 +-
.../classpath/resource/META-INF/mimetypes.default | 2 +-
libjava/configure | 2 +-
libjava/libltdl/ChangeLog | 5 +
libjava/libltdl/missing | 15 +-
libobjc/THREADS | 2 +-
liboffloadmic/ChangeLog | 5 +
liboffloadmic/configure | 2 +-
libsanitizer/ChangeLog | 14 +
.../sanitizer_common/sanitizer_stacktrace.cc | 11 +
.../sanitizer_common/sanitizer_stacktrace.h | 3 +-
libstdc++-v3/ChangeLog | 90 +
libstdc++-v3/Makefile.in | 2 +-
libstdc++-v3/doc/Makefile.in | 2 +-
libstdc++-v3/fragment.am | 2 +-
libstdc++-v3/include/Makefile.in | 2 +-
libstdc++-v3/include/bits/atomic_futex.h | 15 +-
libstdc++-v3/include/bits/c++config | 2 +-
libstdc++-v3/include/bits/functional_hash.h | 45 +
libstdc++-v3/include/bits/range_access.h | 121 +-
libstdc++-v3/include/bits/regex_automaton.h | 87 +-
libstdc++-v3/include/bits/regex_automaton.tcc | 18 +-
libstdc++-v3/include/bits/regex_compiler.h | 9 +-
libstdc++-v3/include/bits/regex_compiler.tcc | 35 +-
libstdc++-v3/include/bits/regex_executor.h | 2 +-
libstdc++-v3/include/bits/regex_executor.tcc | 8 +-
libstdc++-v3/include/experimental/any | 3 +
.../ext/pb_ds/detail/thin_heap_/thin_heap_.hpp | 15 +-
libstdc++-v3/include/std/regex | 1 +
libstdc++-v3/libsupc++/Makefile.in | 2 +-
libstdc++-v3/po/Makefile.in | 2 +-
libstdc++-v3/python/Makefile.in | 2 +-
libstdc++-v3/src/Makefile.in | 2 +-
libstdc++-v3/src/c++11/Makefile.in | 2 +-
libstdc++-v3/src/c++98/Makefile.in | 2 +-
libstdc++-v3/src/filesystem/Makefile.in | 2 +-
.../testsuite/20_util/hash/{52931.cc => 60970.cc} | 24 +-
.../testsuite/24_iterators/container_access.cc | 89 +
.../algorithms/regex_match/cstring_bracket_01.cc | 57 +
libstdc++-v3/testsuite/Makefile.in | 2 +-
.../64646.cc => experimental/any/assign/self.cc} | 14 +-
.../experimental/any/misc/any_cast_neg.cc | 2 +-
.../filesystem/operations/current_path.cc | 6 +-
libstdc++-v3/testsuite/lib/libstdc++.exp | 2 +-
libvtv/ChangeLog | 11 +
libvtv/testsuite/Makefile.am | 16 +-
libvtv/testsuite/Makefile.in | 14 +-
libvtv/testsuite/lib/libvtv.exp | 37 +-
libvtv/vtv_malloc.cc | 2 +-
libvtv/vtv_rts.cc | 7 +-
578 files changed, 97362 insertions(+), 87845 deletions(-)
create mode 100644 gcc/c-family/c-indentation.h
create mode 100644 gcc/config/mips/i6400.md
create mode 100644 gcc/config/mips/m5100.md
copy gcc/po/{hr.po => uk.po} (91%)
create mode 100644 gcc/testsuite/c-c++-common/Wshift-overflow-1.c
create mode 100644 gcc/testsuite/c-c++-common/Wshift-overflow-2.c
create mode 100644 gcc/testsuite/c-c++-common/Wshift-overflow-3.c
create mode 100644 gcc/testsuite/c-c++-common/Wshift-overflow-4.c
create mode 100644 gcc/testsuite/c-c++-common/Wshift-overflow-5.c
create mode 100644 gcc/testsuite/c-c++-common/Wtautological-compare-1.c
create mode 100644 gcc/testsuite/c-c++-common/Wtautological-compare-2.c
create mode 100644 gcc/testsuite/c-c++-common/Wtautological-compare-3.c
create mode 100644 gcc/testsuite/c-c++-common/Wunused-function-1.c
create mode 100644 gcc/testsuite/c-c++-common/ubsan/pr66908.c
create mode 100644 gcc/testsuite/g++.dg/Wframe-address-in-Wall.C
create mode 100644 gcc/testsuite/g++.dg/Wframe-address.C
create mode 100644 gcc/testsuite/g++.dg/Wno-frame-address.C
create mode 100644 gcc/testsuite/g++.dg/cpp0x/alias-decl-52.C
create mode 100644 gcc/testsuite/g++.dg/cpp1y/left-shift-1.C
create mode 100644 gcc/testsuite/g++.dg/cpp1z/abbrev1.C
create mode 100644 gcc/testsuite/g++.dg/ext/mv24.C
create mode 100644 gcc/testsuite/g++.dg/init/pr66857.C
create mode 100644 gcc/testsuite/g++.dg/parse/error57.C
create mode 100644 gcc/testsuite/g++.dg/template/pr18969-2.C
create mode 100644 gcc/testsuite/g++.dg/template/pr18969.C
create mode 100644 gcc/testsuite/g++.dg/ubsan/pr66977.C
create mode 100644 gcc/testsuite/g++.dg/warn/Wlogical-op-2.C
create mode 100644 gcc/testsuite/gcc.dg/Wframe-address-in-Wall.c
create mode 100644 gcc/testsuite/gcc.dg/Wframe-address.c
create mode 100644 gcc/testsuite/gcc.dg/Wno-frame-address.c
copy gcc/testsuite/gcc.dg/autopar/{outer-1.c => uns-outer-4.c} (58%)
create mode 100644 gcc/testsuite/gcc.dg/autopar/uns-outer-5.c
copy gcc/testsuite/gcc.dg/autopar/{outer-6.c => uns-outer-6.c} (57%)
create mode 100644 gcc/testsuite/gcc.dg/c90-left-shift-2.c
create mode 100644 gcc/testsuite/gcc.dg/c90-left-shift-3.c
create mode 100644 gcc/testsuite/gcc.dg/c99-left-shift-2.c
create mode 100644 gcc/testsuite/gcc.dg/c99-left-shift-3.c
copy gcc/testsuite/gcc.dg/graphite/{block-1.c => uns-block-1.c} (83%)
copy gcc/testsuite/gcc.dg/graphite/{interchange-12.c => uns-interchange-12.c} (78%)
copy gcc/testsuite/gcc.dg/graphite/{interchange-14.c => uns-interchange-14.c} (92%)
copy gcc/testsuite/gcc.dg/graphite/{interchange-15.c => uns-interchange-15.c} (85%)
copy gcc/testsuite/gcc.dg/graphite/{interchange-9.c => uns-interchange-9.c} (78%)
copy gcc/testsuite/gcc.dg/graphite/{interchange-mvt.c => uns-interchange-mvt.c} (86%)
create mode 100644 gcc/testsuite/gcc.dg/pr25529.c
create mode 100644 gcc/testsuite/gcc.dg/pr25530.c
create mode 100644 gcc/testsuite/gcc.dg/torture/pr66945.c
create mode 100644 gcc/testsuite/gcc.dg/torture/pr66952.c
create mode 100644 gcc/testsuite/gcc.dg/vect/pr66951.c
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_p [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_p [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_p [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_p [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_p [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_f [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_p [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_s [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4_lane_u [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_ [...]
create mode 100644 gcc/testsuite/gcc.target/aarch64/csel_bfx_1.c
create mode 100644 gcc/testsuite/gcc.target/aarch64/csel_imms_inc_1.c
create mode 100644 gcc/testsuite/gcc.target/aarch64/f16_movs_1.c
create mode 100644 gcc/testsuite/gcc.target/aarch64/fp16/f16_convs_1.c
create mode 100644 gcc/testsuite/gcc.target/aarch64/fp16/f16_convs_2.c
copy gcc/testsuite/gcc.target/{nvptx/nvptx.exp => aarch64/fp16/fp16.exp} (80%)
create mode 100644 gcc/testsuite/gcc.target/aarch64/neg_abs_1.c
create mode 100644 gcc/testsuite/gcc.target/arm/mincmp.c
copy gcc/testsuite/{gcc.c-torture/execute/pr41917.c => gcc.target/arm/reg_equal_te [...]
create mode 100644 gcc/testsuite/gcc.target/i386/mpx/pr66566.c
create mode 100644 gcc/testsuite/gcc.target/i386/pr66232-6.c
create mode 100644 gcc/testsuite/gcc.target/i386/pr66232-7.c
create mode 100644 gcc/testsuite/gcc.target/i386/pr66232-8.c
create mode 100644 gcc/testsuite/gcc.target/i386/pr66232-9.c
create mode 100644 gcc/testsuite/gcc.target/i386/pr66424.c
create mode 100644 gcc/testsuite/gcc.target/i386/pr66648.c
create mode 100644 gcc/testsuite/gcc.target/i386/pr66978.c
create mode 100644 gcc/testsuite/gcc.target/s390/gpr2fprsavecfi.c
create mode 100644 gcc/testsuite/gcc.target/s390/insv-1.c
create mode 100644 gcc/testsuite/gcc.target/s390/insv-2.c
create mode 100644 gcc/testsuite/gcc.target/s390/insv-3.c
create mode 100644 gcc/testsuite/gfortran.dg/associated_target_6.f03
create mode 100644 gcc/testsuite/gfortran.dg/generic_30.f90
delete mode 100644 gcc/tree-browser.c
delete mode 100644 gcc/tree-browser.def
create mode 100644 libgomp/testsuite/libgomp.c/pr66714.c
create mode 100644 libgomp/testsuite/libgomp.c/uns-outer-4.c
copy libstdc++-v3/testsuite/20_util/hash/{52931.cc => 60970.cc} (64%)
create mode 100644 libstdc++-v3/testsuite/24_iterators/container_access.cc
copy libstdc++-v3/testsuite/{25_algorithms/is_permutation/64646.cc => experimental [...]
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] 01/02: [PR64164] Drop copyrename, use coalescible partition as base when optimizing.
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a commit to branch aoliva/pr64164
in repository gcc.
commit 2348a01194e61ba0d625e02dbf131d55752e7e4a
Author: Alexandre Oliva <aoliva(a)redhat.com>
Date: Sat Jul 18 02:06:32 2015 -0300
[PR64164] Drop copyrename, use coalescible partition as base when optimizing.
for gcc/ChangeLog
PR rtl-optimization/64164
PR bootstrap/66978
PR middle-end/66983
PR rtl-optimization/67000
PR middle-end/67034
PR middle-end/67035
* Makefile.in (OBJS): Drop tree-ssa-copyrename.o.
* tree-ssa-copyrename.c: Removed.
* opts.c (default_options_table): Drop -ftree-copyrename. Add
-ftree-coalesce-vars.
* passes.def: Drop all occurrences of pass_rename_ssa_copies.
* common.opt (ftree-copyrename): Ignore.
(ftree-coalesce-inlined-vars): Likewise.
* doc/invoke.texi: Remove the ignored options above.
* gimple-expr.h (gimple_can_coalesce_p): Move declaration
* tree-ssa-coalesce.h: ... here.
* tree-ssa-uncprop.c: Include tree-ssa-coalesce.h and other
headers required by it.
* gimple-expr.c (gimple_can_coalesce_p): Allow coalescing
across variables when flag_tree_coalesce_vars. Check register
use and promoted modes to allow coalescing. Do not coalesce
maybe-byref parms with SSA_NAMEs of other variables, or
anonymous SSA_NAMEs. Moved to tree-ssa-coalesce.c.
* tree-ssa-live.c (struct tree_int_map_hasher): Move along
with its member functions to tree-ssa-coalesce.c.
(var_map_base_init): Likewise. Renamed to
compute_samebase_partition_bases.
(partition_view_normal): Drop want_bases parameter.
(partition_view_bitmap): Likewise.
* tree-ssa-live.h: Adjust declarations.
* tree-ssa-coalesce.c: Include explow.h and cfgexpand.h.
(build_ssa_conflict_graph): Process PARM_ and RESULT_DECLs's
default defs at the entry point.
(dump_part_var_map): New.
(compute_optimized_partition_bases): New, called by...
(coalesce_ssa_name): ... when flag_tree_coalesce_vars, instead
of compute_samebase_partition_bases. Adjust.
* alias.c (nonoverlapping_memrefs_p): Disregard gimple-regs.
* cfgexpand.c (leader_merge, parm_maybe_byref_p): New.
(ssa_default_def_partition): New.
(get_rtl_for_parm_ssa_default_def): New.
(align_local_variable, add_stack_var): Support anonymous SSA
names.
(defer_stack_allocation): Likewise. Declare earlier.
(set_rtl): Merge exprs and attrs, even for MEMs and non-SSA
vars. Update DECL_RTL for PARM_DECLs and RESULT_DECLs too.
Do no record deferred-allocation marker in
SA.partition_to_pseudo.
(expand_stack_vars): Adjust check for the marker in it.
(expand_one_stack_var_at): Handle anonymous SSA_NAMEs. Drop
redundant MEM attr setting.
(expand_one_stack_var_1): Handle anonymous SSA_NAMEs. Renamed
from...
(expand_one_stack_var): ... this. New wrapper to check and
skip already expanded SSA partitions.
(record_alignment_for_reg_var): New, factored out of...
(expand_one_var): ... this.
(expand_one_ssa_partition): New.
(adjust_one_expanded_partition_var): New.
(expand_one_register_var): Check and skip already expanded SSA
partitions.
(expand_used_vars): Don't create DECLs for anonymous SSA
names. Expand all SSA partitions, then adjust all SSA names.
(pass::execute): Replace the loops that set
SA.partition_to_pseudo from partition leaders and cleared
DECL_RTL for multi-location variables, and that which used to
rename vars and set attrs, with one that clears DECL_RTL and
checks that PARMs and RESULTs default_defs match DECL_RTL.
* cfgexpand.h (get_rtl_for_parm_ssa_default_def): Declare.
* emit-rtl.c: Include stor-layout.h.
(set_reg_attrs_for_parm): Handle NULL decl.
(set_reg_attrs_for_decl_rtl): Take mode from expression if
it's not a DECL.
* stmt.c (emit_case_decision_tree): Pass it the SSA_NAME
rather than its possibly-NULL DECL.
* explow.c (promote_ssa_mode): New.
* explow.h (promote_ssa_mode): Declare.
* expr.c (expand_expr_real_1): Handle anonymous SSA_NAMEs.
(read_complex_part): Export.
* expr.h (read_complex_part): Declare.
* cfgexpand.h (parm_maybe_byref_p): Declare.
* function.c: Include cfgexpand.h.
(use_register_for_decl): Handle SSA_NAMEs, anonymous or not.
(use_register_for_parm_decl): Wrapper for the above to
special-case the result_ptr.
(rtl_for_parm): Ditto for get_rtl_for_parm_ssa_default_def.
(split_complex_args): Take assign_parm_data_all argument.
Pass it to rtl_for_parm. Set up rtl and context for split
args. Reset complex parm before fetching its default decl
rtl.
(assign_parms_unsplit_complex): Use the default-def complex
parm rtl if it matches the components.
(assign_parms_augmented_arg_list): Adjust.
(maybe_reset_rtl_for_parm): Reset DECL_RTL of parms with
multiple locations. Recognize split complex args.
(assign_parm_adjust_stack_rtl): Add all and parm arguments,
for rtl_for_parm. For SSA-assigned parms, zero stack_parm.
(assign_parm_setup_block): Prefer SSA-assigned location, and
fill in its address if the memory location of a maybe-byref
parm was not assigned by cfgexpand.
(assign_parm_setup_reg): Likewise. Adjust its mode as
needed. Use entry_parm for equiv if stack_parm is NULL. Make
sure passed_pointer parms don't need conversion. Copy address
or value as needed.
(assign_parm_setup_stack): Prefer SSA-assigned location.
(assign_parms): Maybe reset DECL_RTL of params. Adjust stack
rtl before testing for pointer bounds. Special-case result_ptr.
(expand_function_start): Maybe reset DECL_RTL of result.
Prefer SSA-assigned location for result and static chain.
Factor out DECL_RESULT and SET_DECL_RTL. Convert static chain
to Pmode if needed, from H.J. Lu <hongjiu.lu(a)intel.com>.
* tree-outof-ssa.c (insert_value_copy_on_edge): Handle
anonymous SSA names. Use promote_ssa_mode.
(get_temp_reg): Likewise.
(remove_ssa_form): Adjust.
* stor-layout.c (layout_decl): Don't set mem attributes of
non-MEMs.
* var-tracking.c (dataflow_set_clear_at_call): Take call_insn
and get its reg_usage for reg invalidation.
(compute_bb_dataflow): Pass it insn.
(emit_notes_in_bb): Likewise.
for gcc/testsuite/ChangeLog
* gcc.dg/guality/pr54200.c: Add -fno-tree-coalesce-vars.
* gcc.dg/ssp-1.c: Make counter a register.
* gcc.dg/ssp-2.c: Likewise.
* gcc.dg/torture/parm-coalesce.c: New.
---
gcc/Makefile.in | 1 -
gcc/alias.c | 13 +
gcc/cfgexpand.c | 370 +++++++++++++++------
gcc/cfgexpand.h | 2 +
gcc/common.opt | 12 +-
gcc/doc/invoke.texi | 48 +--
gcc/emit-rtl.c | 5 +-
gcc/explow.c | 29 ++
gcc/explow.h | 3 +
gcc/expr.c | 39 ++-
gcc/function.c | 275 +++++++++++++---
gcc/gimple-expr.c | 39 ---
gcc/gimple-expr.h | 1 -
gcc/opts.c | 2 +-
gcc/passes.def | 5 -
gcc/stor-layout.c | 3 +-
gcc/testsuite/gcc.dg/guality/pr54200.c | 2 +-
gcc/testsuite/gcc.dg/ssp-1.c | 2 +-
gcc/testsuite/gcc.dg/ssp-2.c | 2 +-
gcc/testsuite/gcc.dg/torture/parm-coalesce.c | 40 +++
gcc/tree-outof-ssa.c | 16 +-
gcc/tree-ssa-coalesce.c | 378 ++++++++++++++++++++-
gcc/tree-ssa-coalesce.h | 1 +
gcc/tree-ssa-copyrename.c | 475 ---------------------------
gcc/tree-ssa-live.c | 99 +-----
gcc/tree-ssa-live.h | 4 +-
gcc/tree-ssa-uncprop.c | 5 +
gcc/var-tracking.c | 12 +-
28 files changed, 1030 insertions(+), 853 deletions(-)
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index be259e8..6079acc 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1444,7 +1444,6 @@ OBJS = \
tree-ssa-ccp.o \
tree-ssa-coalesce.o \
tree-ssa-copy.o \
- tree-ssa-copyrename.o \
tree-ssa-dce.o \
tree-ssa-dom.o \
tree-ssa-dse.o \
diff --git a/gcc/alias.c b/gcc/alias.c
index fa7d5d8..4681e3f 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -2507,6 +2507,19 @@ nonoverlapping_memrefs_p (const_rtx x, const_rtx y, bool loo [...]
if (! DECL_P (exprx) || ! DECL_P (expry))
return 0;
+ /* If we refer to different gimple registers, or one gimple register
+ and one non-gimple-register, we know they can't overlap. First,
+ gimple registers don't have their addresses taken. Now, there
+ could be more than one stack slot for (different versions of) the
+ same gimple register, but we can presumably tell they don't
+ overlap based on offsets from stack base addresses elsewhere.
+ It's important that we don't proceed to DECL_RTL, because gimple
+ registers may not pass DECL_RTL_SET_P, and make_decl_rtl won't be
+ able to do anything about them since no SSA information will have
+ remained to guide it. */
+ if (is_gimple_reg (exprx) || is_gimple_reg (expry))
+ return exprx != expry;
+
/* With invalid code we can end up storing into the constant pool.
Bail out to avoid ICEing when creating RTL for this.
See gfortran.dg/lto/20091028-2_0.f90. */
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index a047632..0b19953 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -150,21 +150,121 @@ gimple_assign_rhs_to_tree (gimple stmt)
#define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
+/* Choose either CUR or NEXT as the leader DECL for a partition.
+ Prefer ignored decls, to simplify debug dumps and reduce ambiguity
+ out of the same user variable being in multiple partitions (this is
+ less likely for compiler-introduced temps). */
+
+static tree
+leader_merge (tree cur, tree next)
+{
+ if (cur == NULL || cur == next)
+ return next;
+
+ if (DECL_P (cur) && DECL_IGNORED_P (cur))
+ return cur;
+
+ if (DECL_P (next) && DECL_IGNORED_P (next))
+ return next;
+
+ return cur;
+}
+
+
+/* Return the RTL for the default SSA def of a PARM or RESULT, if
+ there is one. */
+
+rtx
+get_rtl_for_parm_ssa_default_def (tree var)
+{
+ gcc_assert (TREE_CODE (var) == PARM_DECL || TREE_CODE (var) == RESULT_DECL);
+
+ if (!is_gimple_reg (var))
+ return NULL_RTX;
+
+ /* If we've already determined RTL for the decl, use it. This is
+ not just an optimization: if VAR is a PARM whose incoming value
+ is unused, we won't find a default def to use its partition, but
+ we still want to use the location of the parm, if it was used at
+ all. During assign_parms, until a location is assigned for the
+ VAR, RTL can only for a parm or result if we're not coalescing
+ across variables, when we know we're coalescing all SSA_NAMEs of
+ each parm or result, and we're not coalescing them with names
+ pertaining to other variables, such as other parms' default
+ defs. */
+ if (DECL_RTL_SET_P (var))
+ {
+ gcc_assert (DECL_RTL (var) != pc_rtx);
+ return DECL_RTL (var);
+ }
+
+ tree name = ssa_default_def (cfun, var);
+
+ if (!name)
+ return NULL_RTX;
+
+ int part = var_to_partition (SA.map, name);
+ if (part == NO_PARTITION)
+ return NULL_RTX;
+
+ return SA.partition_to_pseudo[part];
+}
+
/* Associate declaration T with storage space X. If T is no
SSA name this is exactly SET_DECL_RTL, otherwise make the
partition of T associated with X. */
static inline void
set_rtl (tree t, rtx x)
{
+ if (x && SSAVAR (t))
+ {
+ bool skip = false;
+ tree cur = NULL_TREE;
+
+ if (MEM_P (x))
+ cur = MEM_EXPR (x);
+ else if (REG_P (x))
+ cur = REG_EXPR (x);
+ else if (GET_CODE (x) == CONCAT
+ && REG_P (XEXP (x, 0)))
+ cur = REG_EXPR (XEXP (x, 0));
+ else if (GET_CODE (x) == PARALLEL)
+ cur = REG_EXPR (XVECEXP (x, 0, 0));
+ else if (x == pc_rtx)
+ skip = true;
+ else
+ gcc_unreachable ();
+
+ tree next = skip ? cur : leader_merge (cur, SSAVAR (t));
+
+ if (cur != next)
+ {
+ if (MEM_P (x))
+ set_mem_attributes (x, next, true);
+ else
+ set_reg_attrs_for_decl_rtl (next, x);
+ }
+ }
+
if (TREE_CODE (t) == SSA_NAME)
{
- SA.partition_to_pseudo[var_to_partition (SA.map, t)] = x;
- if (x && !MEM_P (x))
- set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t), x);
- /* For the benefit of debug information at -O0 (where vartracking
- doesn't run) record the place also in the base DECL if it's
- a normal variable (not a parameter). */
- if (x && x != pc_rtx && TREE_CODE (SSA_NAME_VAR (t)) == VAR_DECL)
+ int part = var_to_partition (SA.map, t);
+ if (part != NO_PARTITION)
+ {
+ if (SA.partition_to_pseudo[part])
+ gcc_assert (SA.partition_to_pseudo[part] == x);
+ else
+ SA.partition_to_pseudo[part] = x;
+ }
+ /* For the benefit of debug information at -O0 (where
+ vartracking doesn't run) record the place also in the base
+ DECL. For PARMs and RESULTs, we may end up resetting these
+ in function.c:maybe_reset_rtl_for_parm, but in some rare
+ cases we may need them (unused and overwritten incoming
+ value, that at -O0 must share the location with the other
+ uses in spite of the missing default def), and this may be
+ the only chance to preserve them. */
+ if (x && x != pc_rtx && SSA_NAME_VAR (t))
{
tree var = SSA_NAME_VAR (t);
/* If we don't yet have something recorded, just record it now. */
@@ -862,7 +962,9 @@ expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
x = plus_constant (Pmode, base, offset);
- x = gen_rtx_MEM (DECL_MODE (SSAVAR (decl)), x);
+ x = gen_rtx_MEM (TREE_CODE (decl) == SSA_NAME
+ ? TYPE_MODE (TREE_TYPE (decl))
+ : DECL_MODE (SSAVAR (decl)), x);
if (TREE_CODE (decl) != SSA_NAME)
{
@@ -884,7 +986,6 @@ expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
DECL_USER_ALIGN (decl) = 0;
}
- set_mem_attributes (x, SSAVAR (decl), true);
set_rtl (decl, x);
}
@@ -1099,13 +1200,22 @@ account_stack_vars (void)
to a variable to be allocated in the stack frame. */
static void
-expand_one_stack_var (tree var)
+expand_one_stack_var_1 (tree var)
{
HOST_WIDE_INT size, offset;
unsigned byte_align;
- size = tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (var)));
- byte_align = align_local_variable (SSAVAR (var));
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ tree type = TREE_TYPE (var);
+ size = tree_to_uhwi (TYPE_SIZE_UNIT (type));
+ byte_align = TYPE_ALIGN_UNIT (type);
+ }
+ else
+ {
+ size = tree_to_uhwi (DECL_SIZE_UNIT (var));
+ byte_align = align_local_variable (var);
+ }
/* We handle highly aligned variables in expand_stack_vars. */
gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
@@ -1116,6 +1226,27 @@ expand_one_stack_var (tree var)
crtl->max_used_stack_slot_alignment, offset);
}
+/* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
+ already assigned some MEM. */
+
+static void
+expand_one_stack_var (tree var)
+{
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ int part = var_to_partition (SA.map, var);
+ if (part != NO_PARTITION)
+ {
+ rtx x = SA.partition_to_pseudo[part];
+ gcc_assert (x);
+ gcc_assert (MEM_P (x));
+ return;
+ }
+ }
+
+ return expand_one_stack_var_1 (var);
+}
+
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
that will reside in a hard register. */
@@ -1125,13 +1256,114 @@ expand_one_hard_reg_var (tree var)
rest_of_decl_compilation (var, 0, 0);
}
+/* Record the alignment requirements of some variable assigned to a
+ pseudo. */
+
+static void
+record_alignment_for_reg_var (unsigned int align)
+{
+ if (SUPPORTS_STACK_ALIGNMENT
+ && crtl->stack_alignment_estimated < align)
+ {
+ /* stack_alignment_estimated shouldn't change after stack
+ realign decision made */
+ gcc_assert (!crtl->stack_realign_processed);
+ crtl->stack_alignment_estimated = align;
+ }
+
+ /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
+ So here we only make sure stack_alignment_needed >= align. */
+ if (crtl->stack_alignment_needed < align)
+ crtl->stack_alignment_needed = align;
+ if (crtl->max_used_stack_slot_alignment < align)
+ crtl->max_used_stack_slot_alignment = align;
+}
+
+/* Create RTL for an SSA partition. */
+
+static void
+expand_one_ssa_partition (tree var)
+{
+ int part = var_to_partition (SA.map, var);
+ gcc_assert (part != NO_PARTITION);
+
+ if (SA.partition_to_pseudo[part])
+ return;
+
+ if (!use_register_for_decl (var))
+ {
+ expand_one_stack_var_1 (var);
+ return;
+ }
+
+ unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
+ TYPE_MODE (TREE_TYPE (var)),
+ TYPE_ALIGN (TREE_TYPE (var)));
+
+ /* If the variable alignment is very large we'll dynamicaly allocate
+ it, which means that in-frame portion is just a pointer. */
+ if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
+ align = POINTER_SIZE;
+
+ record_alignment_for_reg_var (align);
+
+ machine_mode reg_mode = promote_ssa_mode (var, NULL);
+
+ rtx x = gen_reg_rtx (reg_mode);
+
+ set_rtl (var, x);
+}
+
+/* Record the association between the RTL generated for a partition
+ and the underlying variable of the SSA_NAME. */
+
+static void
+adjust_one_expanded_partition_var (tree var)
+{
+ if (!var)
+ return;
+
+ tree decl = SSA_NAME_VAR (var);
+
+ int part = var_to_partition (SA.map, var);
+ if (part == NO_PARTITION)
+ return;
+
+ rtx x = SA.partition_to_pseudo[part];
+
+ set_rtl (var, x);
+
+ if (!REG_P (x))
+ return;
+
+ /* Note if the object is a user variable. */
+ if (decl && !DECL_ARTIFICIAL (decl))
+ mark_user_reg (x);
+
+ if (POINTER_TYPE_P (decl ? TREE_TYPE (decl) : TREE_TYPE (var)))
+ mark_reg_pointer (x, get_pointer_alignment (var));
+}
+
/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
that will reside in a pseudo register. */
static void
expand_one_register_var (tree var)
{
- tree decl = SSAVAR (var);
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ int part = var_to_partition (SA.map, var);
+ if (part != NO_PARTITION)
+ {
+ rtx x = SA.partition_to_pseudo[part];
+ gcc_assert (x);
+ gcc_assert (REG_P (x));
+ return;
+ }
+ gcc_unreachable ();
+ }
+
+ tree decl = var;
tree type = TREE_TYPE (decl);
machine_mode reg_mode = promote_decl_mode (decl, NULL);
rtx x = gen_reg_rtx (reg_mode);
@@ -1265,21 +1497,7 @@ expand_one_var (tree var, bool toplevel, bool really_expand)
align = POINTER_SIZE;
}
- if (SUPPORTS_STACK_ALIGNMENT
- && crtl->stack_alignment_estimated < align)
- {
- /* stack_alignment_estimated shouldn't change after stack
- realign decision made */
- gcc_assert (!crtl->stack_realign_processed);
- crtl->stack_alignment_estimated = align;
- }
-
- /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
- So here we only make sure stack_alignment_needed >= align. */
- if (crtl->stack_alignment_needed < align)
- crtl->stack_alignment_needed = align;
- if (crtl->max_used_stack_slot_alignment < align)
- crtl->max_used_stack_slot_alignment = align;
+ record_alignment_for_reg_var (align);
if (TREE_CODE (origvar) == SSA_NAME)
{
@@ -1713,48 +1931,18 @@ expand_used_vars (void)
if (targetm.use_pseudo_pic_reg ())
pic_offset_table_rtx = gen_reg_rtx (Pmode);
- hash_map<tree, tree> ssa_name_decls;
for (i = 0; i < SA.map->num_partitions; i++)
{
tree var = partition_to_var (SA.map, i);
gcc_assert (!virtual_operand_p (var));
- /* Assign decls to each SSA name partition, share decls for partitions
- we could have coalesced (those with the same type). */
- if (SSA_NAME_VAR (var) == NULL_TREE)
- {
- tree *slot = &ssa_name_decls.get_or_insert (TREE_TYPE (var));
- if (!*slot)
- *slot = create_tmp_reg (TREE_TYPE (var));
- replace_ssa_name_symbol (var, *slot);
- }
-
- /* Always allocate space for partitions based on VAR_DECLs. But for
- those based on PARM_DECLs or RESULT_DECLs and which matter for the
- debug info, there is no need to do so if optimization is disabled
- because all the SSA_NAMEs based on these DECLs have been coalesced
- into a single partition, which is thus assigned the canonical RTL
- location of the DECLs. If in_lto_p, we can't rely on optimize,
- a function could be compiled with -O1 -flto first and only the
- link performed at -O0. */
- if (TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
- expand_one_var (var, true, true);
- else if (DECL_IGNORED_P (SSA_NAME_VAR (var)) || optimize || in_lto_p)
- {
- /* This is a PARM_DECL or RESULT_DECL. For those partitions that
- contain the default def (representing the parm or result itself)
- we don't do anything here. But those which don't contain the
- default def (representing a temporary based on the parm/result)
- we need to allocate space just like for normal VAR_DECLs. */
- if (!bitmap_bit_p (SA.partition_has_default_def, i))
- {
- expand_one_var (var, true, true);
- gcc_assert (SA.partition_to_pseudo[i]);
- }
- }
+ expand_one_ssa_partition (var);
}
+ for (i = 1; i < num_ssa_names; i++)
+ adjust_one_expanded_partition_var (ssa_name (i));
+
if (flag_stack_protect == SPCT_FLAG_STRONG)
gen_stack_protect_signal
= stack_protect_decl_p () || stack_protect_return_slot_p ();
@@ -5928,35 +6116,6 @@ pass_expand::execute (function *fun)
parm_birth_insn = var_seq;
}
- /* Now that we also have the parameter RTXs, copy them over to our
- partitions. */
- for (i = 0; i < SA.map->num_partitions; i++)
- {
- tree var = SSA_NAME_VAR (partition_to_var (SA.map, i));
-
- if (TREE_CODE (var) != VAR_DECL
- && !SA.partition_to_pseudo[i])
- SA.partition_to_pseudo[i] = DECL_RTL_IF_SET (var);
- gcc_assert (SA.partition_to_pseudo[i]);
-
- /* If this decl was marked as living in multiple places, reset
- this now to NULL. */
- if (DECL_RTL_IF_SET (var) == pc_rtx)
- SET_DECL_RTL (var, NULL);
-
- /* Some RTL parts really want to look at DECL_RTL(x) when x
- was a decl marked in REG_ATTR or MEM_ATTR. We could use
- SET_DECL_RTL here making this available, but that would mean
- to select one of the potentially many RTLs for one DECL. Instead
- of doing that we simply reset the MEM_EXPR of the RTL in question,
- then nobody can get at it and hence nobody can call DECL_RTL on it. */
- if (!DECL_RTL_SET_P (var))
- {
- if (MEM_P (SA.partition_to_pseudo[i]))
- set_mem_expr (SA.partition_to_pseudo[i], NULL);
- }
- }
-
/* If we have a class containing differently aligned pointers
we need to merge those into the corresponding RTL pointer
alignment. */
@@ -5964,7 +6123,6 @@ pass_expand::execute (function *fun)
{
tree name = ssa_name (i);
int part;
- rtx r;
if (!name
/* We might have generated new SSA names in
@@ -5977,20 +6135,24 @@ pass_expand::execute (function *fun)
if (part == NO_PARTITION)
continue;
- /* Adjust all partition members to get the underlying decl of
- the representative which we might have created in expand_one_var. */
- if (SSA_NAME_VAR (name) == NULL_TREE)
+ gcc_assert (SA.partition_to_pseudo[part]);
+
+ /* If this decl was marked as living in multiple places, reset
+ this now to NULL. */
+ tree var = SSA_NAME_VAR (name);
+ if (var && DECL_RTL_IF_SET (var) == pc_rtx)
+ SET_DECL_RTL (var, NULL);
+ /* Check that the pseudos chosen by assign_parms are those of
+ the corresponding default defs. */
+ else if (SSA_NAME_IS_DEFAULT_DEF (name)
+ && (TREE_CODE (var) == PARM_DECL
+ || TREE_CODE (var) == RESULT_DECL))
{
- tree leader = partition_to_var (SA.map, part);
- gcc_assert (SSA_NAME_VAR (leader) != NULL_TREE);
- replace_ssa_name_symbol (name, SSA_NAME_VAR (leader));
+ rtx in = DECL_RTL_IF_SET (var);
+ gcc_assert (in);
+ rtx out = SA.partition_to_pseudo[part];
+ gcc_assert (in == out || rtx_equal_p (in, out));
}
- if (!POINTER_TYPE_P (TREE_TYPE (name)))
- continue;
-
- r = SA.partition_to_pseudo[part];
- if (REG_P (r))
- mark_reg_pointer (r, get_pointer_alignment (name));
}
/* If this function is `main', emit a call to `__main'
diff --git a/gcc/cfgexpand.h b/gcc/cfgexpand.h
index a0b6e3e..602579d 100644
--- a/gcc/cfgexpand.h
+++ b/gcc/cfgexpand.h
@@ -22,5 +22,7 @@ along with GCC; see the file COPYING3. If not see
extern tree gimple_assign_rhs_to_tree (gimple);
extern HOST_WIDE_INT estimated_stack_frame_size (struct cgraph_node *);
+extern rtx get_rtl_for_parm_ssa_default_def (tree var);
+
#endif /* GCC_CFGEXPAND_H */
diff --git a/gcc/common.opt b/gcc/common.opt
index 8f25f8b..6d47e94 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -2230,16 +2230,16 @@ Common Report Var(flag_tree_ch) Optimization
Enable loop header copying on trees
ftree-coalesce-inlined-vars
-Common Report Var(flag_ssa_coalesce_vars,1) Init(2) RejectNegative Optimization
-Enable coalescing of copy-related user variables that are inlined
+Common Ignore RejectNegative
+Does nothing. Preserved for backward compatibility.
ftree-coalesce-vars
-Common Report Var(flag_ssa_coalesce_vars,2) Optimization
-Enable coalescing of all copy-related user variables
+Common Report Var(flag_tree_coalesce_vars) Optimization
+Enable SSA coalescing of user variables
ftree-copyrename
-Common Report Var(flag_tree_copyrename) Optimization
-Replace SSA temporaries with better names in copies
+Common Ignore
+Does nothing. Preserved for backward compatibility.
ftree-copy-prop
Common Report Var(flag_tree_copy_prop) Optimization
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 7b5d86b..fcb1d36 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -341,7 +341,6 @@ Objective-C and Objective-C++ Dialects}.
-fdump-tree-phiprop@r{[}-@var{n}@r{]} @gol
-fdump-tree-phiopt@r{[}-@var{n}@r{]} @gol
-fdump-tree-forwprop@r{[}-@var{n}@r{]} @gol
--fdump-tree-copyrename@r{[}-@var{n}@r{]} @gol
-fdump-tree-nrv -fdump-tree-vect @gol
-fdump-tree-sink @gol
-fdump-tree-sra@r{[}-@var{n}@r{]} @gol
@@ -447,9 +446,8 @@ Objective-C and Objective-C++ Dialects}.
-fstack-protector-explicit -fstdarg-opt -fstrict-aliasing @gol
-fstrict-overflow -fthread-jumps -ftracer -ftree-bit-ccp @gol
-ftree-builtin-call-dce -ftree-ccp -ftree-ch @gol
--ftree-coalesce-inline-vars -ftree-coalesce-vars -ftree-copy-prop @gol
--ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse @gol
--ftree-forwprop -ftree-fre -ftree-loop-if-convert @gol
+-ftree-coalesce-vars -ftree-copy-prop -ftree-dce -ftree-dominator-opts @gol
+-ftree-dse -ftree-forwprop -ftree-fre -ftree-loop-if-convert @gol
-ftree-loop-if-convert-stores -ftree-loop-im @gol
-ftree-phiprop -ftree-loop-distribution -ftree-loop-distribute-patterns @gol
-ftree-loop-ivcanon -ftree-loop-linear -ftree-loop-optimize @gol
@@ -7114,11 +7112,6 @@ name is made by appending @file{.phiopt} to the source file name.
Dump each function after forward propagating single use variables. The file
name is made by appending @file{.forwprop} to the source file name.
-@item copyrename
-@opindex fdump-tree-copyrename
-Dump each function after applying the copy rename optimization. The file
-name is made by appending @file{.copyrename} to the source file name.
-
@item nrv
@opindex fdump-tree-nrv
Dump each function after applying the named return value optimization on
@@ -7583,8 +7576,8 @@ compilation time.
-ftree-ccp @gol
-fssa-phiopt @gol
-ftree-ch @gol
+-ftree-coalesce-vars @gol
-ftree-copy-prop @gol
--ftree-copyrename @gol
-ftree-dce @gol
-ftree-dominator-opts @gol
-ftree-dse @gol
@@ -8848,6 +8841,15 @@ be parallelized. Parallelize all the loops that can be analyzed to
not contain loop carried dependences without checking that it is
profitable to parallelize the loops.
+@item -ftree-coalesce-vars
+@opindex ftree-coalesce-vars
+Tell the compiler to attempt to combine small user-defined variables
+too, instead of just compiler temporaries. This may severely limit the
+ability to debug an optimized program compiled with
+@option{-fno-var-tracking-assignments}. In the negated form, this flag
+prevents SSA coalescing of user variables. This option is enabled by
+default if optimization is enabled.
+
@item -ftree-loop-if-convert
@opindex ftree-loop-if-convert
Attempt to transform conditional jumps in the innermost loops to
@@ -8961,32 +8963,6 @@ Perform scalar replacement of aggregates. This pass replace [...]
references with scalars to prevent committing structures to memory too
early. This flag is enabled by default at @option{-O} and higher.
-@item -ftree-copyrename
-@opindex ftree-copyrename
-Perform copy renaming on trees. This pass attempts to rename compiler
-temporaries to other variables at copy locations, usually resulting in
-variable names which more closely resemble the original variables. This flag
-is enabled by default at @option{-O} and higher.
-
-@item -ftree-coalesce-inlined-vars
-@opindex ftree-coalesce-inlined-vars
-Tell the copyrename pass (see @option{-ftree-copyrename}) to attempt to
-combine small user-defined variables too, but only if they are inlined
-from other functions. It is a more limited form of
-@option{-ftree-coalesce-vars}. This may harm debug information of such
-inlined variables, but it keeps variables of the inlined-into
-function apart from each other, such that they are more likely to
-contain the expected values in a debugging session.
-
-@item -ftree-coalesce-vars
-@opindex ftree-coalesce-vars
-Tell the copyrename pass (see @option{-ftree-copyrename}) to attempt to
-combine small user-defined variables too, instead of just compiler
-temporaries. This may severely limit the ability to debug an optimized
-program compiled with @option{-fno-var-tracking-assignments}. In the
-negated form, this flag prevents SSA coalescing of user variables,
-including inlined ones. This option is enabled by default.
-
@item -ftree-ter
@opindex ftree-ter
Perform temporary expression replacement during the SSA->normal phase. Single
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index ed2b30b..0648af6 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1232,6 +1232,9 @@ set_reg_attrs_for_parm (rtx parm_rtx, rtx mem)
void
set_reg_attrs_for_decl_rtl (tree t, rtx x)
{
+ if (!t)
+ return;
+ tree tdecl = t;
if (GET_CODE (x) == SUBREG)
{
gcc_assert (subreg_lowpart_p (x));
@@ -1240,7 +1243,7 @@ set_reg_attrs_for_decl_rtl (tree t, rtx x)
if (REG_P (x))
REG_ATTRS (x)
= get_reg_attrs (t, byte_lowpart_offset (GET_MODE (x),
- DECL_MODE (t)));
+ DECL_MODE (tdecl)));
if (GET_CODE (x) == CONCAT)
{
if (REG_P (XEXP (x, 0)))
diff --git a/gcc/explow.c b/gcc/explow.c
index bd342c1..6941f4e 100644
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -842,6 +842,35 @@ promote_decl_mode (const_tree decl, int *punsignedp)
return pmode;
}
+/* Return the promoted mode for name. If it is a named SSA_NAME, it
+ is the same as promote_decl_mode. Otherwise, it is the promoted
+ mode of a temp decl of same type as the SSA_NAME, if we had created
+ one. */
+
+machine_mode
+promote_ssa_mode (const_tree name, int *punsignedp)
+{
+ gcc_assert (TREE_CODE (name) == SSA_NAME);
+
+ /* Partitions holding parms and results must be promoted as expected
+ by function.c. */
+ if (SSA_NAME_VAR (name)
+ && (TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL
+ || TREE_CODE (SSA_NAME_VAR (name)) == RESULT_DECL))
+ return promote_decl_mode (SSA_NAME_VAR (name), punsignedp);
+
+ tree type = TREE_TYPE (name);
+ int unsignedp = TYPE_UNSIGNED (type);
+ machine_mode mode = TYPE_MODE (type);
+
+ machine_mode pmode = promote_mode (type, mode, &unsignedp);
+ if (punsignedp)
+ *punsignedp = unsignedp;
+
+ return pmode;
+}
+
+
/* Controls the behaviour of {anti_,}adjust_stack. */
static bool suppress_reg_args_size;
diff --git a/gcc/explow.h b/gcc/explow.h
index 94613de..52113db 100644
--- a/gcc/explow.h
+++ b/gcc/explow.h
@@ -57,6 +57,9 @@ extern machine_mode promote_mode (const_tree, machine_mode, int *);
/* Return mode and signedness to use when object is promoted. */
machine_mode promote_decl_mode (const_tree, int *);
+/* Return mode and signedness to use when object is promoted. */
+machine_mode promote_ssa_mode (const_tree, int *);
+
/* Remove some bytes from the stack. An rtx says how many. */
extern void adjust_stack (rtx);
diff --git a/gcc/expr.c b/gcc/expr.c
index 899a42c..d601129 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -9246,7 +9246,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
rtx op0, op1, temp, decl_rtl;
tree type;
int unsignedp;
- machine_mode mode;
+ machine_mode mode, dmode;
enum tree_code code = TREE_CODE (exp);
rtx subtarget, original_target;
int ignore;
@@ -9377,7 +9377,8 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
if (g == NULL
&& modifier == EXPAND_INITIALIZER
&& !SSA_NAME_IS_DEFAULT_DEF (exp)
- && (optimize || DECL_IGNORED_P (SSA_NAME_VAR (exp)))
+ && (optimize || !SSA_NAME_VAR (exp)
+ || DECL_IGNORED_P (SSA_NAME_VAR (exp)))
&& stmt_is_replaceable_p (SSA_NAME_DEF_STMT (exp)))
g = SSA_NAME_DEF_STMT (exp);
if (g)
@@ -9456,15 +9457,18 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
/* Ensure variable marked as used even if it doesn't go through
a parser. If it hasn't be used yet, write out an external
definition. */
- TREE_USED (exp) = 1;
+ if (exp)
+ TREE_USED (exp) = 1;
/* Show we haven't gotten RTL for this yet. */
temp = 0;
/* Variables inherited from containing functions should have
been lowered by this point. */
- context = decl_function_context (exp);
- gcc_assert (SCOPE_FILE_SCOPE_P (context)
+ if (exp)
+ context = decl_function_context (exp);
+ gcc_assert (!exp
+ || SCOPE_FILE_SCOPE_P (context)
|| context == current_function_decl
|| TREE_STATIC (exp)
|| DECL_EXTERNAL (exp)
@@ -9488,7 +9492,8 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
decl_rtl = use_anchored_address (decl_rtl);
if (modifier != EXPAND_CONST_ADDRESS
&& modifier != EXPAND_SUM
- && !memory_address_addr_space_p (DECL_MODE (exp),
+ && !memory_address_addr_space_p (exp ? DECL_MODE (exp)
+ : GET_MODE (decl_rtl),
XEXP (decl_rtl, 0),
MEM_ADDR_SPACE (decl_rtl)))
temp = replace_equiv_address (decl_rtl,
@@ -9499,12 +9504,17 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
if the address is a register. */
if (temp != 0)
{
- if (MEM_P (temp) && REG_P (XEXP (temp, 0)))
+ if (exp && MEM_P (temp) && REG_P (XEXP (temp, 0)))
mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
return temp;
}
+ if (exp)
+ dmode = DECL_MODE (exp);
+ else
+ dmode = TYPE_MODE (TREE_TYPE (ssa_name));
+
/* If the mode of DECL_RTL does not match that of the decl,
there are two cases: we are dealing with a BLKmode value
that is returned in a register, or we are dealing with
@@ -9512,22 +9522,23 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
of the wanted mode, but mark it so that we know that it
was already extended. */
if (REG_P (decl_rtl)
- && DECL_MODE (exp) != BLKmode
- && GET_MODE (decl_rtl) != DECL_MODE (exp))
+ && dmode != BLKmode
+ && GET_MODE (decl_rtl) != dmode)
{
machine_mode pmode;
/* Get the signedness to be used for this variable. Ensure we get
the same mode we got when the variable was declared. */
- if (code == SSA_NAME
- && (g = SSA_NAME_DEF_STMT (ssa_name))
- && gimple_code (g) == GIMPLE_CALL
- && !gimple_call_internal_p (g))
+ if (code != SSA_NAME)
+ pmode = promote_decl_mode (exp, &unsignedp);
+ else if ((g = SSA_NAME_DEF_STMT (ssa_name))
+ && gimple_code (g) == GIMPLE_CALL
+ && !gimple_call_internal_p (g))
pmode = promote_function_mode (type, mode, &unsignedp,
gimple_call_fntype (g),
2);
else
- pmode = promote_decl_mode (exp, &unsignedp);
+ pmode = promote_ssa_mode (ssa_name, &unsignedp);
gcc_assert (GET_MODE (decl_rtl) == pmode);
temp = gen_lowpart_SUBREG (mode, decl_rtl);
diff --git a/gcc/function.c b/gcc/function.c
index f9d11bf..c3d00cd 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -72,6 +72,9 @@ along with GCC; see the file COPYING3. If not see
#include "cfganal.h"
#include "cfgbuild.h"
#include "cfgcleanup.h"
+#include "cfgexpand.h"
+#include "basic-block.h"
+#include "df.h"
#include "params.h"
#include "bb-reorder.h"
#include "shrink-wrap.h"
@@ -148,6 +151,8 @@ static bool contains (const_rtx, hash_table<insn_cache_hasher> *);
static void prepare_function_start (void);
static void do_clobber_return_reg (rtx, void *);
static void do_use_return_reg (rtx, void *);
+static rtx rtl_for_parm (struct assign_parm_data_all *, tree);
+
/* Stack of nested functions. */
/* Keep track of the cfun stack. */
@@ -2105,6 +2110,30 @@ aggregate_value_p (const_tree exp, const_tree fntype)
bool
use_register_for_decl (const_tree decl)
{
+ if (TREE_CODE (decl) == SSA_NAME)
+ {
+ /* We often try to use the SSA_NAME, instead of its underlying
+ decl, to get type information and guide decisions, to avoid
+ differences of behavior between anonymous and named
+ variables, but in this one case we have to go for the actual
+ variable if there is one. The main reason is that, at least
+ at -O0, we want to place user variables on the stack, but we
+ don't mind using pseudos for anonymous or ignored temps.
+ Should we take the SSA_NAME, we'd conclude all SSA_NAMEs
+ should go in pseudos, whereas their corresponding variables
+ might have to go on the stack. So, disregarding the decl
+ here would negatively impact debug info at -O0, enable
+ coalescing between SSA_NAMEs that ought to get different
+ stack/pseudo assignments, and get the incoming argument
+ processing thoroughly confused by PARM_DECLs expected to live
+ in stack slots but assigned to pseudos. */
+ if (!SSA_NAME_VAR (decl))
+ return TYPE_MODE (TREE_TYPE (decl)) != BLKmode
+ && !(flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)));
+
+ decl = SSA_NAME_VAR (decl);
+ }
+
if (!targetm.calls.allocate_stack_slots_for_args ())
return true;
@@ -2240,7 +2269,7 @@ assign_parms_initialize_all (struct assign_parm_data_all *all)
needed, else the old list. */
static void
-split_complex_args (vec<tree> *args)
+split_complex_args (struct assign_parm_data_all *all, vec<tree> *args)
{
unsigned i;
tree p;
@@ -2251,6 +2280,7 @@ split_complex_args (vec<tree> *args)
if (TREE_CODE (type) == COMPLEX_TYPE
&& targetm.calls.split_complex_arg (type))
{
+ tree cparm = p;
tree decl;
tree subtype = TREE_TYPE (type);
bool addressable = TREE_ADDRESSABLE (p);
@@ -2269,6 +2299,9 @@ split_complex_args (vec<tree> *args)
DECL_ARTIFICIAL (p) = addressable;
DECL_IGNORED_P (p) = addressable;
TREE_ADDRESSABLE (p) = 0;
+ /* Reset the RTL before layout_decl, or it may change the
+ mode of the RTL of the original argument copied to P. */
+ SET_DECL_RTL (p, NULL_RTX);
layout_decl (p, 0);
(*args)[i] = p;
@@ -2280,6 +2313,25 @@ split_complex_args (vec<tree> *args)
DECL_IGNORED_P (decl) = addressable;
layout_decl (decl, 0);
args->safe_insert (++i, decl);
+
+ /* If we are expanding a function, rather than gimplifying
+ it, propagate the RTL of the complex parm to the split
+ declarations, and set their contexts so that
+ maybe_reset_rtl_for_parm can recognize them and refrain
+ from resetting their RTL. */
+ if (currently_expanding_to_rtl)
+ {
+ rtx rtl = rtl_for_parm (all, cparm);
+ gcc_assert (!rtl || GET_CODE (rtl) == CONCAT);
+ if (rtl)
+ {
+ SET_DECL_RTL (p, XEXP (rtl, 0));
+ SET_DECL_RTL (decl, XEXP (rtl, 1));
+
+ DECL_CONTEXT (p) = cparm;
+ DECL_CONTEXT (decl) = cparm;
+ }
+ }
}
}
}
@@ -2342,7 +2394,7 @@ assign_parms_augmented_arg_list (struct assign_parm_data_all *all)
/* If the target wants to split complex arguments into scalars, do so. */
if (targetm.calls.split_complex_arg)
- split_complex_args (&fnargs);
+ split_complex_args (all, &fnargs);
return fnargs;
}
@@ -2745,23 +2797,98 @@ assign_parm_remove_parallels (struct assign_parm_data_one *data)
data->entry_parm = entry_parm;
}
+/* Wrapper for use_register_for_decl, that special-cases the
+ .result_ptr as the function's RESULT_DECL when the RESULT_DECL is
+ passed by reference. */
+
+static bool
+use_register_for_parm_decl (struct assign_parm_data_all *all, tree parm)
+{
+ if (parm == all->function_result_decl)
+ {
+ tree result = DECL_RESULT (current_function_decl);
+
+ if (DECL_BY_REFERENCE (result))
+ parm = result;
+ }
+
+ return use_register_for_decl (parm);
+}
+
+/* Wrapper for get_rtl_for_parm_ssa_default_def, that special-cases
+ the .result_ptr as the function's RESULT_DECL when the RESULT_DECL
+ is passed by reference. */
+
+static rtx
+rtl_for_parm (struct assign_parm_data_all *all, tree parm)
+{
+ if (parm == all->function_result_decl)
+ {
+ tree result = DECL_RESULT (current_function_decl);
+
+ if (!DECL_BY_REFERENCE (result))
+ return NULL_RTX;
+
+ parm = result;
+ }
+
+ return get_rtl_for_parm_ssa_default_def (parm);
+}
+
+/* Reset the location of PARM_DECLs and RESULT_DECLs that had
+ SSA_NAMEs in multiple partitions, so that assign_parms will choose
+ the default def, if it exists, or create new RTL to hold the unused
+ entry value. If we are coalescing across variables, we want to
+ reset the location too, because a parm without a default def
+ (incoming value unused) might be coalesced with one with a default
+ def, and then assign_parms would copy both incoming values to the
+ same location, which might cause the wrong value to survive. */
+static void
+maybe_reset_rtl_for_parm (tree parm)
+{
+ gcc_assert (TREE_CODE (parm) == PARM_DECL
+ || TREE_CODE (parm) == RESULT_DECL);
+
+ /* This is a split complex parameter, and its context was set to its
+ original PARM_DECL in split_complex_args so that we could
+ recognize it here and not reset its RTL. */
+ if (DECL_CONTEXT (parm) && TREE_CODE (DECL_CONTEXT (parm)) == PARM_DECL)
+ {
+ DECL_CONTEXT (parm) = DECL_CONTEXT (DECL_CONTEXT (parm));
+ return;
+ }
+
+ if ((flag_tree_coalesce_vars
+ || (DECL_RTL_SET_P (parm) && DECL_RTL (parm) == pc_rtx))
+ && is_gimple_reg (parm))
+ SET_DECL_RTL (parm, NULL_RTX);
+}
+
/* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
always valid and properly aligned. */
static void
-assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data)
+assign_parm_adjust_stack_rtl (struct assign_parm_data_all *all, tree parm,
+ struct assign_parm_data_one *data)
{
rtx stack_parm = data->stack_parm;
+ /* If out-of-SSA assigned RTL to the parm default def, make sure we
+ don't use what we might have computed before. */
+ rtx ssa_assigned = rtl_for_parm (all, parm);
+ if (ssa_assigned)
+ stack_parm = NULL;
+
/* If we can't trust the parm stack slot to be aligned enough for its
ultimate type, don't use that slot after entry. We'll make another
stack slot, if we need one. */
- if (stack_parm
- && ((STRICT_ALIGNMENT
- && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm))
- || (data->nominal_type
- && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
- && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
+ else if (stack_parm
+ && ((STRICT_ALIGNMENT
+ && (GET_MODE_ALIGNMENT (data->nominal_mode)
+ > MEM_ALIGN (stack_parm)))
+ || (data->nominal_type
+ && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
+ && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
stack_parm = NULL;
/* If parm was passed in memory, and we need to convert it on entry,
@@ -2823,14 +2950,21 @@ assign_parm_setup_block (struct assign_parm_data_all *all,
size = int_size_in_bytes (data->passed_type);
size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
+
if (stack_parm == 0)
{
DECL_ALIGN (parm) = MAX (DECL_ALIGN (parm), BITS_PER_WORD);
- stack_parm = assign_stack_local (BLKmode, size_stored,
- DECL_ALIGN (parm));
- if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size)
- PUT_MODE (stack_parm, GET_MODE (entry_parm));
- set_mem_attributes (stack_parm, parm, 1);
+ stack_parm = rtl_for_parm (all, parm);
+ if (stack_parm)
+ stack_parm = copy_rtx (stack_parm);
+ else
+ {
+ stack_parm = assign_stack_local (BLKmode, size_stored,
+ DECL_ALIGN (parm));
+ if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size)
+ PUT_MODE (stack_parm, GET_MODE (entry_parm));
+ set_mem_attributes (stack_parm, parm, 1);
+ }
}
/* If a BLKmode arrives in registers, copy it to a stack slot. Handle
@@ -2968,10 +3102,19 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
= promote_function_mode (data->nominal_type, data->nominal_mode, &unsignedp,
TREE_TYPE (current_function_decl), 2);
- parmreg = gen_reg_rtx (promoted_nominal_mode);
+ rtx from_expand = rtl_for_parm (all, parm);
- if (!DECL_ARTIFICIAL (parm))
- mark_user_reg (parmreg);
+ if (from_expand && !data->passed_pointer)
+ {
+ parmreg = from_expand;
+ gcc_assert (GET_MODE (parmreg) == promoted_nominal_mode);
+ }
+ else
+ {
+ parmreg = gen_reg_rtx (promoted_nominal_mode);
+ if (!DECL_ARTIFICIAL (parm))
+ mark_user_reg (parmreg);
+ }
/* If this was an item that we received a pointer to,
set DECL_RTL appropriately. */
@@ -2990,6 +3133,8 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
assign_parm_find_data_types and expand_expr_real_1. */
equiv_stack_parm = data->stack_parm;
+ if (!equiv_stack_parm)
+ equiv_stack_parm = data->entry_parm;
validated_mem = validize_mem (copy_rtx (data->entry_parm));
need_conversion = (data->nominal_mode != data->passed_mode
@@ -3130,11 +3275,17 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
/* If we were passed a pointer but the actual value can safely live
in a register, retrieve it and use it directly. */
- if (data->passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode)
+ if (data->passed_pointer
+ && (from_expand || TYPE_MODE (TREE_TYPE (parm)) != BLKmode))
{
/* We can't use nominal_mode, because it will have been set to
Pmode above. We must use the actual mode of the parm. */
- if (use_register_for_decl (parm))
+ if (from_expand)
+ {
+ parmreg = from_expand;
+ gcc_assert (GET_MODE (parmreg) == TYPE_MODE (TREE_TYPE (parm)));
+ }
+ else if (use_register_for_decl (parm))
{
parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
mark_user_reg (parmreg);
@@ -3174,7 +3325,7 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
/* STACK_PARM is the pointer, not the parm, and PARMREG is
now the parm. */
- data->stack_parm = NULL;
+ data->stack_parm = equiv_stack_parm = NULL;
}
/* Mark the register as eliminable if we did no conversion and it was
@@ -3184,11 +3335,11 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
make here would screw up life analysis for it. */
if (data->nominal_mode == data->passed_mode
&& !did_conversion
- && data->stack_parm != 0
- && MEM_P (data->stack_parm)
+ && equiv_stack_parm != 0
+ && MEM_P (equiv_stack_parm)
&& data->locate.offset.var == 0
&& reg_mentioned_p (virtual_incoming_args_rtx,
- XEXP (data->stack_parm, 0)))
+ XEXP (equiv_stack_parm, 0)))
{
rtx_insn *linsn = get_last_insn ();
rtx_insn *sinsn;
@@ -3201,8 +3352,8 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
= GET_MODE_INNER (GET_MODE (parmreg));
int regnor = REGNO (XEXP (parmreg, 0));
int regnoi = REGNO (XEXP (parmreg, 1));
- rtx stackr = adjust_address_nv (data->stack_parm, submode, 0);
- rtx stacki = adjust_address_nv (data->stack_parm, submode,
+ rtx stackr = adjust_address_nv (equiv_stack_parm, submode, 0);
+ rtx stacki = adjust_address_nv (equiv_stack_parm, submode,
GET_MODE_SIZE (submode));
/* Scan backwards for the set of the real and
@@ -3275,6 +3426,13 @@ assign_parm_setup_stack (struct assign_parm_data_all *all, t [...]
if (data->stack_parm == 0)
{
+ rtx x = data->stack_parm = rtl_for_parm (all, parm);
+ if (x)
+ gcc_assert (GET_MODE (x) == GET_MODE (data->entry_parm));
+ }
+
+ if (data->stack_parm == 0)
+ {
int align = STACK_SLOT_ALIGNMENT (data->passed_type,
GET_MODE (data->entry_parm),
TYPE_ALIGN (data->passed_type));
@@ -3531,6 +3689,8 @@ assign_parms (tree fndecl)
DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
continue;
}
+ else
+ maybe_reset_rtl_for_parm (parm);
/* Estimate stack alignment from parameter alignment. */
if (SUPPORTS_STACK_ALIGNMENT)
@@ -3580,7 +3740,9 @@ assign_parms (tree fndecl)
else
set_decl_incoming_rtl (parm, data.entry_parm, false);
- /* Boudns should be loaded in the particular order to
+ assign_parm_adjust_stack_rtl (&all, parm, &data);
+
+ /* Bounds should be loaded in the particular order to
have registers allocated correctly. Collect info about
input bounds and load them later. */
if (POINTER_BOUNDS_TYPE_P (data.passed_type))
@@ -3597,11 +3759,10 @@ assign_parms (tree fndecl)
}
else
{
- assign_parm_adjust_stack_rtl (&data);
-
if (assign_parm_setup_block_p (&data))
assign_parm_setup_block (&all, parm, &data);
- else if (data.passed_pointer || use_register_for_decl (parm))
+ else if (data.passed_pointer
+ || use_register_for_parm_decl (&all, parm))
assign_parm_setup_reg (&all, parm, &data);
else
assign_parm_setup_stack (&all, parm, &data);
@@ -4932,7 +5093,9 @@ expand_function_start (tree subr)
before any library calls that assign parms might generate. */
/* Decide whether to return the value in memory or in a register. */
- if (aggregate_value_p (DECL_RESULT (subr), subr))
+ tree res = DECL_RESULT (subr);
+ maybe_reset_rtl_for_parm (res);
+ if (aggregate_value_p (res, subr))
{
/* Returning something that won't go in a register. */
rtx value_address = 0;
@@ -4940,7 +5103,7 @@ expand_function_start (tree subr)
#ifdef PCC_STATIC_STRUCT_RETURN
if (cfun->returns_pcc_struct)
{
- int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
+ int size = int_size_in_bytes (TREE_TYPE (res));
value_address = assemble_static_space (size);
}
else
@@ -4952,36 +5115,45 @@ expand_function_start (tree subr)
it. */
if (sv)
{
- value_address = gen_reg_rtx (Pmode);
+ if (DECL_BY_REFERENCE (res))
+ value_address = get_rtl_for_parm_ssa_default_def (res);
+ if (!value_address)
+ value_address = gen_reg_rtx (Pmode);
emit_move_insn (value_address, sv);
}
}
if (value_address)
{
rtx x = value_address;
- if (!DECL_BY_REFERENCE (DECL_RESULT (subr)))
+ if (!DECL_BY_REFERENCE (res))
{
- x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), x);
- set_mem_attributes (x, DECL_RESULT (subr), 1);
+ x = get_rtl_for_parm_ssa_default_def (res);
+ if (!x)
+ {
+ x = gen_rtx_MEM (DECL_MODE (res), value_address);
+ set_mem_attributes (x, res, 1);
+ }
}
- SET_DECL_RTL (DECL_RESULT (subr), x);
+ SET_DECL_RTL (res, x);
}
}
- else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
+ else if (DECL_MODE (res) == VOIDmode)
/* If return mode is void, this decl rtl should not be used. */
- SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
+ SET_DECL_RTL (res, NULL_RTX);
else
{
/* Compute the return values into a pseudo reg, which we will copy
into the true return register after the cleanups are done. */
- tree return_type = TREE_TYPE (DECL_RESULT (subr));
- if (TYPE_MODE (return_type) != BLKmode
- && targetm.calls.return_in_msb (return_type))
+ tree return_type = TREE_TYPE (res);
+ rtx x = get_rtl_for_parm_ssa_default_def (res);
+ if (x)
+ /* Use it. */;
+ else if (TYPE_MODE (return_type) != BLKmode
+ && targetm.calls.return_in_msb (return_type))
/* expand_function_end will insert the appropriate padding in
this case. Use the return value's natural (unpadded) mode
within the function proper. */
- SET_DECL_RTL (DECL_RESULT (subr),
- gen_reg_rtx (TYPE_MODE (return_type)));
+ x = gen_reg_rtx (TYPE_MODE (return_type));
else
{
/* In order to figure out what mode to use for the pseudo, we
@@ -4992,25 +5164,26 @@ expand_function_start (tree subr)
/* Structures that are returned in registers are not
aggregate_value_p, so we may see a PARALLEL or a REG. */
if (REG_P (hard_reg))
- SET_DECL_RTL (DECL_RESULT (subr),
- gen_reg_rtx (GET_MODE (hard_reg)));
+ x = gen_reg_rtx (GET_MODE (hard_reg));
else
{
gcc_assert (GET_CODE (hard_reg) == PARALLEL);
- SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
+ x = gen_group_rtx (hard_reg);
}
}
+ SET_DECL_RTL (res, x);
+
/* Set DECL_REGISTER flag so that expand_function_end will copy the
result to the real return register(s). */
- DECL_REGISTER (DECL_RESULT (subr)) = 1;
+ DECL_REGISTER (res) = 1;
if (chkp_function_instrumented_p (current_function_decl))
{
- tree return_type = TREE_TYPE (DECL_RESULT (subr));
+ tree return_type = TREE_TYPE (res);
rtx bounds = targetm.calls.chkp_function_value_bounds (return_type,
subr, 1);
- SET_DECL_BOUNDS_RTL (DECL_RESULT (subr), bounds);
+ SET_DECL_BOUNDS_RTL (res, bounds);
}
}
@@ -5025,7 +5198,9 @@ expand_function_start (tree subr)
rtx local, chain;
rtx_insn *insn;
- local = gen_reg_rtx (Pmode);
+ local = get_rtl_for_parm_ssa_default_def (parm);
+ if (!local)
+ local = gen_reg_rtx (Pmode);
chain = targetm.calls.static_chain (current_function_decl, true);
set_decl_incoming_rtl (parm, chain, false);
diff --git a/gcc/gimple-expr.c b/gcc/gimple-expr.c
index b558d90..baed630 100644
--- a/gcc/gimple-expr.c
+++ b/gcc/gimple-expr.c
@@ -375,45 +375,6 @@ copy_var_decl (tree var, tree name, tree type)
return copy;
}
-/* Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for
- coalescing together, false otherwise.
-
- This must stay consistent with var_map_base_init in tree-ssa-live.c. */
-
-bool
-gimple_can_coalesce_p (tree name1, tree name2)
-{
- /* First check the SSA_NAME's associated DECL. We only want to
- coalesce if they have the same DECL or both have no associated DECL. */
- tree var1 = SSA_NAME_VAR (name1);
- tree var2 = SSA_NAME_VAR (name2);
- var1 = (var1 && (!VAR_P (var1) || !DECL_IGNORED_P (var1))) ? var1 : NULL_TREE;
- var2 = (var2 && (!VAR_P (var2) || !DECL_IGNORED_P (var2))) ? var2 : NULL_TREE;
- if (var1 != var2)
- return false;
-
- /* Now check the types. If the types are the same, then we should
- try to coalesce V1 and V2. */
- tree t1 = TREE_TYPE (name1);
- tree t2 = TREE_TYPE (name2);
- if (t1 == t2)
- return true;
-
- /* If the types are not the same, check for a canonical type match. This
- (for example) allows coalescing when the types are fundamentally the
- same, but just have different names.
-
- Note pointer types with different address spaces may have the same
- canonical type. Those are rejected for coalescing by the
- types_compatible_p check. */
- if (TYPE_CANONICAL (t1)
- && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2)
- && types_compatible_p (t1, t2))
- return true;
-
- return false;
-}
-
/* Strip off a legitimate source ending from the input string NAME of
length LEN. Rather than having to know the names used by all of
our front ends, we strip off an ending of a period followed by
diff --git a/gcc/gimple-expr.h b/gcc/gimple-expr.h
index ed23eb2..3d1c89f 100644
--- a/gcc/gimple-expr.h
+++ b/gcc/gimple-expr.h
@@ -28,7 +28,6 @@ extern gimple_seq gimple_body (tree);
extern bool gimple_has_body_p (tree);
extern const char *gimple_decl_printable_name (tree, int);
extern tree copy_var_decl (tree, tree, tree);
-extern bool gimple_can_coalesce_p (tree, tree);
extern tree create_tmp_var_name (const char *);
extern tree create_tmp_var_raw (tree, const char * = NULL);
extern tree create_tmp_var (tree, const char * = NULL);
diff --git a/gcc/opts.c b/gcc/opts.c
index 468a802..f22edd3 100644
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -445,12 +445,12 @@ static const struct default_options default_options_table[] =
{ OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_bit_ccp, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_coalesce_vars, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
{ OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_sra, NULL, 1 },
- { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
diff --git a/gcc/passes.def b/gcc/passes.def
index 6b66f8f..64fc4d9 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -77,7 +77,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_all_early_optimizations);
PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
NEXT_PASS (pass_remove_cgraph_callee_edges);
- NEXT_PASS (pass_rename_ssa_copies);
NEXT_PASS (pass_object_sizes);
NEXT_PASS (pass_ccp);
/* After CCP we rewrite no longer addressed locals into SSA
@@ -155,7 +154,6 @@ along with GCC; see the file COPYING3. If not see
/* Initial scalar cleanups before alias computation.
They ensure memory accesses are not indirect wherever possible. */
NEXT_PASS (pass_strip_predict_hints);
- NEXT_PASS (pass_rename_ssa_copies);
NEXT_PASS (pass_ccp);
/* After CCP we rewrite no longer addressed locals into SSA
form if possible. */
@@ -183,7 +181,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_ch);
NEXT_PASS (pass_lower_complex);
NEXT_PASS (pass_sra);
- NEXT_PASS (pass_rename_ssa_copies);
/* The dom pass will also resolve all __builtin_constant_p calls
that are still there to 0. This has to be done after some
propagations have already run, but before some more dead code
@@ -293,7 +290,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_fold_builtins);
NEXT_PASS (pass_optimize_widening_mul);
NEXT_PASS (pass_tail_calls);
- NEXT_PASS (pass_rename_ssa_copies);
/* FIXME: If DCE is not run before checking for uninitialized uses,
we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
However, this also causes us to misdiagnose cases that should be
@@ -328,7 +324,6 @@ along with GCC; see the file COPYING3. If not see
NEXT_PASS (pass_dce);
NEXT_PASS (pass_asan);
NEXT_PASS (pass_tsan);
- NEXT_PASS (pass_rename_ssa_copies);
/* ??? We do want some kind of loop invariant motion, but we possibly
need to adjust LIM to be more friendly towards preserving accurate
debug information here. */
diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index 0d4f4a4..288227a 100644
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -794,7 +794,8 @@ layout_decl (tree decl, unsigned int known_align)
{
PUT_MODE (rtl, DECL_MODE (decl));
SET_DECL_RTL (decl, 0);
- set_mem_attributes (rtl, decl, 1);
+ if (MEM_P (rtl))
+ set_mem_attributes (rtl, decl, 1);
SET_DECL_RTL (decl, rtl);
}
}
diff --git a/gcc/testsuite/gcc.dg/guality/pr54200.c b/gcc/testsuite/gcc.dg/guality/ [...]
index 9b17187..e1e7293 100644
--- a/gcc/testsuite/gcc.dg/guality/pr54200.c
+++ b/gcc/testsuite/gcc.dg/guality/pr54200.c
@@ -1,6 +1,6 @@
/* PR tree-optimization/54200 */
/* { dg-do run } */
-/* { dg-options "-g -fno-var-tracking-assignments" } */
+/* { dg-options "-g -fno-var-tracking-assignments -fno-tree-coalesce-vars" } */
int o __attribute__((used));
diff --git a/gcc/testsuite/gcc.dg/ssp-1.c b/gcc/testsuite/gcc.dg/ssp-1.c
index 5467f4d..db69332 100644
--- a/gcc/testsuite/gcc.dg/ssp-1.c
+++ b/gcc/testsuite/gcc.dg/ssp-1.c
@@ -12,7 +12,7 @@ __stack_chk_fail (void)
int main ()
{
- int i;
+ register int i;
char foo[255];
// smash stack
diff --git a/gcc/testsuite/gcc.dg/ssp-2.c b/gcc/testsuite/gcc.dg/ssp-2.c
index 9a7ac32..752fe53 100644
--- a/gcc/testsuite/gcc.dg/ssp-2.c
+++ b/gcc/testsuite/gcc.dg/ssp-2.c
@@ -14,7 +14,7 @@ __stack_chk_fail (void)
void
overflow()
{
- int i = 0;
+ register int i = 0;
char foo[30];
/* Overflow buffer. */
diff --git a/gcc/testsuite/gcc.dg/torture/parm-coalesce.c b/gcc/testsuite/gcc.dg/to [...]
new file mode 100644
index 0000000..dbd81c1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/parm-coalesce.c
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+
+#include <stdlib.h>
+
+/* Make sure we don't coalesce both incoming parms, one whose incoming
+ value is unused, to the same location, so as to overwrite one of
+ them with the incoming value of the other. */
+
+int __attribute__((noinline, noclone))
+foo (int i, int j)
+{
+ j = i; /* The incoming value for J is unused. */
+ i = 2;
+ if (j)
+ j++;
+ j += i + 1;
+ return j;
+}
+
+/* Same as foo, but with swapped parameters. */
+int __attribute__((noinline, noclone))
+bar (int j, int i)
+{
+ j = i; /* The incoming value for J is unused. */
+ i = 2;
+ if (j)
+ j++;
+ j += i + 1;
+ return j;
+}
+
+int
+main (void)
+{
+ if (foo (0, 1) != 3)
+ abort ();
+ if (bar (1, 0) != 3)
+ abort ();
+ return 0;
+}
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index 7b747ab..978476c 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -279,7 +279,6 @@ insert_value_copy_on_edge (edge e, int dest, tree src, source_l [...]
rtx dest_rtx, seq, x;
machine_mode dest_mode, src_mode;
int unsignedp;
- tree var;
if (dump_file && (dump_flags & TDF_DETAILS))
{
@@ -301,12 +300,12 @@ insert_value_copy_on_edge (edge e, int dest, tree src, source [...]
start_sequence ();
- var = SSA_NAME_VAR (partition_to_var (SA.map, dest));
+ tree name = partition_to_var (SA.map, dest);
src_mode = TYPE_MODE (TREE_TYPE (src));
dest_mode = GET_MODE (dest_rtx);
- gcc_assert (src_mode == TYPE_MODE (TREE_TYPE (var)));
+ gcc_assert (src_mode == TYPE_MODE (TREE_TYPE (name)));
gcc_assert (!REG_P (dest_rtx)
- || dest_mode == promote_decl_mode (var, &unsignedp));
+ || dest_mode == promote_ssa_mode (name, &unsignedp));
if (src_mode != dest_mode)
{
@@ -682,13 +681,12 @@ elim_backward (elim_graph g, int T)
static rtx
get_temp_reg (tree name)
{
- tree var = TREE_CODE (name) == SSA_NAME ? SSA_NAME_VAR (name) : name;
- tree type = TREE_TYPE (var);
+ tree type = TREE_TYPE (name);
int unsignedp;
- machine_mode reg_mode = promote_decl_mode (var, &unsignedp);
+ machine_mode reg_mode = promote_ssa_mode (name, &unsignedp);
rtx x = gen_reg_rtx (reg_mode);
if (POINTER_TYPE_P (type))
- mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
+ mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (type)));
return x;
}
@@ -988,7 +986,7 @@ remove_ssa_form (bool perform_ter, struct ssaexpand *sa)
/* Return to viewing the variable list as just all reference variables after
coalescing has been performed. */
- partition_view_normal (map, false);
+ partition_view_normal (map);
if (dump_file && (dump_flags & TDF_DETAILS))
{
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index bf8983f..a622728 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-iterator.h"
#include "tree-ssa-live.h"
#include "tree-ssa-coalesce.h"
+#include "explow.h"
#include "diagnostic-core.h"
@@ -806,6 +807,16 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
basic_block bb;
ssa_op_iter iter;
live_track_p live;
+ basic_block entry;
+
+ /* If inter-variable coalescing is enabled, we may attempt to
+ coalesce variables from different base variables, including
+ different parameters, so we have to make sure default defs live
+ at the entry block conflict with each other. */
+ if (flag_tree_coalesce_vars)
+ entry = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
+ else
+ entry = NULL;
map = live_var_map (liveinfo);
graph = ssa_conflicts_new (num_var_partitions (map));
@@ -864,6 +875,30 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
live_track_process_def (live, result, graph);
}
+ /* Pretend there are defs for params' default defs at the start
+ of the (post-)entry block. */
+ if (bb == entry)
+ {
+ unsigned base;
+ bitmap_iterator bi;
+ EXECUTE_IF_SET_IN_BITMAP (live->live_base_var, 0, base, bi)
+ {
+ bitmap_iterator bi2;
+ unsigned part;
+ EXECUTE_IF_SET_IN_BITMAP (live->live_base_partitions[base],
+ 0, part, bi2)
+ {
+ tree var = partition_to_var (map, part);
+ if (!SSA_NAME_VAR (var)
+ || (TREE_CODE (SSA_NAME_VAR (var)) != PARM_DECL
+ && TREE_CODE (SSA_NAME_VAR (var)) != RESULT_DECL)
+ || !SSA_NAME_IS_DEFAULT_DEF (var))
+ continue;
+ live_track_process_def (live, var, graph);
+ }
+ }
+ }
+
live_track_clear_base_vars (live);
}
@@ -1132,6 +1167,7 @@ attempt_coalesce (var_map map, ssa_conflicts_p graph, int x, int y,
{
var1 = partition_to_var (map, p1);
var2 = partition_to_var (map, p2);
+
z = var_union (map, var1, var2);
if (z == NO_PARTITION)
{
@@ -1149,6 +1185,7 @@ attempt_coalesce (var_map map, ssa_conflicts_p graph, int x, int y,
if (debug)
fprintf (debug, ": Success -> %d\n", z);
+
return true;
}
@@ -1244,6 +1281,328 @@ ssa_name_var_hash::equal (const tree_node *n1, const tree_n [...]
}
+/* Output partition map MAP with coalescing plan PART to file F. */
+
+void
+dump_part_var_map (FILE *f, partition part, var_map map)
+{
+ int t;
+ unsigned x, y;
+ int p;
+
+ fprintf (f, "\nCoalescible Partition map \n\n");
+
+ for (x = 0; x < map->num_partitions; x++)
+ {
+ if (map->view_to_partition != NULL)
+ p = map->view_to_partition[x];
+ else
+ p = x;
+
+ if (ssa_name (p) == NULL_TREE
+ || virtual_operand_p (ssa_name (p)))
+ continue;
+
+ t = 0;
+ for (y = 1; y < num_ssa_names; y++)
+ {
+ tree var = version_to_var (map, y);
+ if (!var)
+ continue;
+ int q = var_to_partition (map, var);
+ p = partition_find (part, q);
+ gcc_assert (map->partition_to_base_index[q]
+ == map->partition_to_base_index[p]);
+
+ if (p == (int)x)
+ {
+ if (t++ == 0)
+ {
+ fprintf (f, "Partition %d, base %d (", x,
+ map->partition_to_base_index[q]);
+ print_generic_expr (f, partition_to_var (map, q), TDF_SLIM);
+ fprintf (f, " - ");
+ }
+ fprintf (f, "%d ", y);
+ }
+ }
+ if (t != 0)
+ fprintf (f, ")\n");
+ }
+ fprintf (f, "\n");
+}
+
+/* Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for
+ coalescing together, false otherwise.
+
+ This must stay consistent with var_map_base_init in tree-ssa-live.c. */
+
+bool
+gimple_can_coalesce_p (tree name1, tree name2)
+{
+ /* First check the SSA_NAME's associated DECL. Without
+ optimization, we only want to coalesce if they have the same DECL
+ or both have no associated DECL. */
+ tree var1 = SSA_NAME_VAR (name1);
+ tree var2 = SSA_NAME_VAR (name2);
+ var1 = (var1 && (!VAR_P (var1) || !DECL_IGNORED_P (var1))) ? var1 : NULL_TREE;
+ var2 = (var2 && (!VAR_P (var2) || !DECL_IGNORED_P (var2))) ? var2 : NULL_TREE;
+ if (var1 != var2 && !flag_tree_coalesce_vars)
+ return false;
+
+ /* Now check the types. If the types are the same, then we should
+ try to coalesce V1 and V2. */
+ tree t1 = TREE_TYPE (name1);
+ tree t2 = TREE_TYPE (name2);
+ if (t1 == t2)
+ {
+ check_modes:
+ /* If the base variables are the same, we're good: none of the
+ other tests below could possibly fail. */
+ var1 = SSA_NAME_VAR (name1);
+ var2 = SSA_NAME_VAR (name2);
+ if (var1 == var2)
+ return true;
+
+ /* We don't want to coalesce two SSA names if one of the base
+ variables is supposed to be a register while the other is
+ supposed to be on the stack. Anonymous SSA names take
+ registers, but when not optimizing, user variables should go
+ on the stack, so coalescing them with the anonymous variable
+ as the partition leader would end up assigning the user
+ variable to a register. Don't do that! */
+ bool reg1 = !var1 || use_register_for_decl (var1);
+ bool reg2 = !var2 || use_register_for_decl (var2);
+ if (reg1 != reg2)
+ return false;
+
+ /* Check that the promoted modes are the same. We don't want to
+ coalesce if the promoted modes would be different. Only
+ PARM_DECLs and RESULT_DECLs have different promotion rules,
+ so skip the test if we both are variables or anonymous
+ SSA_NAMEs. */
+ return ((!var1 || VAR_P (var1)) && (!var2 || VAR_P (var2)))
+ || promote_ssa_mode (name1, NULL) == promote_ssa_mode (name2, NULL);
+ }
+
+ /* If the types are not the same, check for a canonical type match. This
+ (for example) allows coalescing when the types are fundamentally the
+ same, but just have different names.
+
+ Note pointer types with different address spaces may have the same
+ canonical type. Those are rejected for coalescing by the
+ types_compatible_p check. */
+ if (TYPE_CANONICAL (t1)
+ && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2)
+ && types_compatible_p (t1, t2))
+ goto check_modes;
+
+ return false;
+}
+
+/* Fill in MAP's partition_to_base_index, with one index for each
+ partition of SSA names USED_IN_COPIES and related by CL coalesce
+ possibilities. This must match gimple_can_coalesce_p in the
+ optimized case. */
+
+static void
+compute_optimized_partition_bases (var_map map, bitmap used_in_copies,
+ coalesce_list_p cl)
+{
+ int parts = num_var_partitions (map);
+ partition tentative = partition_new (parts);
+
+ /* Partition the SSA versions so that, for each coalescible
+ pair, both of its members are in the same partition in
+ TENTATIVE. */
+ gcc_assert (!cl->sorted);
+ coalesce_pair_p node;
+ coalesce_iterator_type ppi;
+ FOR_EACH_PARTITION_PAIR (node, ppi, cl)
+ {
+ tree v1 = ssa_name (node->first_element);
+ int p1 = partition_find (tentative, var_to_partition (map, v1));
+ tree v2 = ssa_name (node->second_element);
+ int p2 = partition_find (tentative, var_to_partition (map, v2));
+
+ if (p1 == p2)
+ continue;
+
+ partition_union (tentative, p1, p2);
+ }
+
+ /* We have to deal with cost one pairs too. */
+ for (cost_one_pair_d *co = cl->cost_one_list; co; co = co->next)
+ {
+ tree v1 = ssa_name (co->first_element);
+ int p1 = partition_find (tentative, var_to_partition (map, v1));
+ tree v2 = ssa_name (co->second_element);
+ int p2 = partition_find (tentative, var_to_partition (map, v2));
+
+ if (p1 == p2)
+ continue;
+
+ partition_union (tentative, p1, p2);
+ }
+
+ /* And also with abnormal edges. */
+ basic_block bb;
+ edge e;
+ edge_iterator ei;
+ FOR_EACH_BB_FN (bb, cfun)
+ {
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ if (e->flags & EDGE_ABNORMAL)
+ {
+ gphi_iterator gsi;
+ for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
+ {
+ gphi *phi = gsi.phi ();
+ tree arg = PHI_ARG_DEF (phi, e->dest_idx);
+ if (SSA_NAME_IS_DEFAULT_DEF (arg)
+ && (!SSA_NAME_VAR (arg)
+ || TREE_CODE (SSA_NAME_VAR (arg)) != PARM_DECL))
+ continue;
+
+ tree res = PHI_RESULT (phi);
+
+ int p1 = partition_find (tentative, var_to_partition (map, res));
+ int p2 = partition_find (tentative, var_to_partition (map, arg));
+
+ if (p1 == p2)
+ continue;
+
+ partition_union (tentative, p1, p2);
+ }
+ }
+ }
+
+ map->partition_to_base_index = XCNEWVEC (int, parts);
+ auto_vec<unsigned int> index_map (parts);
+ if (parts)
+ index_map.quick_grow (parts);
+
+ const unsigned no_part = -1;
+ unsigned count = parts;
+ while (count)
+ index_map[--count] = no_part;
+
+ /* Initialize MAP's mapping from partition to base index, using
+ as base indices an enumeration of the TENTATIVE partitions in
+ which each SSA version ended up, so that we compute conflicts
+ between all SSA versions that ended up in the same potential
+ coalesce partition. */
+ bitmap_iterator bi;
+ unsigned i;
+ EXECUTE_IF_SET_IN_BITMAP (used_in_copies, 0, i, bi)
+ {
+ int pidx = var_to_partition (map, ssa_name (i));
+ int base = partition_find (tentative, pidx);
+ if (index_map[base] != no_part)
+ continue;
+ index_map[base] = count++;
+ }
+
+ map->num_basevars = count;
+
+ EXECUTE_IF_SET_IN_BITMAP (used_in_copies, 0, i, bi)
+ {
+ int pidx = var_to_partition (map, ssa_name (i));
+ int base = partition_find (tentative, pidx);
+ gcc_assert (index_map[base] < count);
+ map->partition_to_base_index[pidx] = index_map[base];
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ dump_part_var_map (dump_file, tentative, map);
+
+ partition_delete (tentative);
+}
+
+/* Hashtable helpers. */
+
+struct tree_int_map_hasher : nofree_ptr_hash <tree_int_map>
+{
+ static inline hashval_t hash (const tree_int_map *);
+ static inline bool equal (const tree_int_map *, const tree_int_map *);
+};
+
+inline hashval_t
+tree_int_map_hasher::hash (const tree_int_map *v)
+{
+ return tree_map_base_hash (v);
+}
+
+inline bool
+tree_int_map_hasher::equal (const tree_int_map *v, const tree_int_map *c)
+{
+ return tree_int_map_eq (v, c);
+}
+
+/* This routine will initialize the basevar fields of MAP with base
+ names. Partitions will share the same base if they have the same
+ SSA_NAME_VAR, or, being anonymous variables, the same type. This
+ must match gimple_can_coalesce_p in the non-optimized case. */
+
+static void
+compute_samebase_partition_bases (var_map map)
+{
+ int x, num_part;
+ tree var;
+ struct tree_int_map *m, *mapstorage;
+
+ num_part = num_var_partitions (map);
+ hash_table<tree_int_map_hasher> tree_to_index (num_part);
+ /* We can have at most num_part entries in the hash tables, so it's
+ enough to allocate so many map elements once, saving some malloc
+ calls. */
+ mapstorage = m = XNEWVEC (struct tree_int_map, num_part);
+
+ /* If a base table already exists, clear it, otherwise create it. */
+ free (map->partition_to_base_index);
+ map->partition_to_base_index = (int *) xmalloc (sizeof (int) * num_part);
+
+ /* Build the base variable list, and point partitions at their bases. */
+ for (x = 0; x < num_part; x++)
+ {
+ struct tree_int_map **slot;
+ unsigned baseindex;
+ var = partition_to_var (map, x);
+ if (SSA_NAME_VAR (var)
+ && (!VAR_P (SSA_NAME_VAR (var))
+ || !DECL_IGNORED_P (SSA_NAME_VAR (var))))
+ m->base.from = SSA_NAME_VAR (var);
+ else
+ /* This restricts what anonymous SSA names we can coalesce
+ as it restricts the sets we compute conflicts for.
+ Using TREE_TYPE to generate sets is the easies as
+ type equivalency also holds for SSA names with the same
+ underlying decl.
+
+ Check gimple_can_coalesce_p when changing this code. */
+ m->base.from = (TYPE_CANONICAL (TREE_TYPE (var))
+ ? TYPE_CANONICAL (TREE_TYPE (var))
+ : TREE_TYPE (var));
+ /* If base variable hasn't been seen, set it up. */
+ slot = tree_to_index.find_slot (m, INSERT);
+ if (!*slot)
+ {
+ baseindex = m - mapstorage;
+ m->to = baseindex;
+ *slot = m;
+ m++;
+ }
+ else
+ baseindex = (*slot)->to;
+ map->partition_to_base_index[x] = baseindex;
+ }
+
+ map->num_basevars = m - mapstorage;
+
+ free (mapstorage);
+}
+
/* Reduce the number of copies by coalescing variables in the function. Return
a partition map with the resulting coalesces. */
@@ -1260,9 +1619,10 @@ coalesce_ssa_name (void)
cl = create_coalesce_list ();
map = create_outofssa_var_map (cl, used_in_copies);
- /* If optimization is disabled, we need to coalesce all the names originating
- from the same SSA_NAME_VAR so debug info remains undisturbed. */
- if (!optimize)
+ /* If this optimization is disabled, we need to coalesce all the
+ names originating from the same SSA_NAME_VAR so debug info
+ remains undisturbed. */
+ if (!flag_tree_coalesce_vars)
{
hash_table<ssa_name_var_hash> ssa_name_hash (10);
@@ -1303,8 +1663,13 @@ coalesce_ssa_name (void)
if (dump_file && (dump_flags & TDF_DETAILS))
dump_var_map (dump_file, map);
- /* Don't calculate live ranges for variables not in the coalesce list. */
- partition_view_bitmap (map, used_in_copies, true);
+ partition_view_bitmap (map, used_in_copies);
+
+ if (flag_tree_coalesce_vars)
+ compute_optimized_partition_bases (map, used_in_copies, cl);
+ else
+ compute_samebase_partition_bases (map);
+
BITMAP_FREE (used_in_copies);
if (num_var_partitions (map) < 1)
@@ -1343,8 +1708,7 @@ coalesce_ssa_name (void)
/* Now coalesce everything in the list. */
coalesce_partitions (map, graph, cl,
- ((dump_flags & TDF_DETAILS) ? dump_file
- : NULL));
+ ((dump_flags & TDF_DETAILS) ? dump_file : NULL));
delete_coalesce_list (cl);
ssa_conflicts_delete (graph);
diff --git a/gcc/tree-ssa-coalesce.h b/gcc/tree-ssa-coalesce.h
index 99b188a..ae289b4 100644
--- a/gcc/tree-ssa-coalesce.h
+++ b/gcc/tree-ssa-coalesce.h
@@ -21,5 +21,6 @@ along with GCC; see the file COPYING3. If not see
#define GCC_TREE_SSA_COALESCE_H
extern var_map coalesce_ssa_name (void);
+extern bool gimple_can_coalesce_p (tree, tree);
#endif /* GCC_TREE_SSA_COALESCE_H */
diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c
deleted file mode 100644
index aeb7f28..0000000
--- a/gcc/tree-ssa-copyrename.c
+++ /dev/null
@@ -1,475 +0,0 @@
-/* Rename SSA copies.
- Copyright (C) 2004-2015 Free Software Foundation, Inc.
- Contributed by Andrew MacLeod <amacleod(a)redhat.com>
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3. If not see
-<http://www.gnu.org/licenses/>. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "backend.h"
-#include "tree.h"
-#include "gimple.h"
-#include "rtl.h"
-#include "ssa.h"
-#include "alias.h"
-#include "fold-const.h"
-#include "internal-fn.h"
-#include "gimple-iterator.h"
-#include "flags.h"
-#include "tree-pretty-print.h"
-#include "insn-config.h"
-#include "expmed.h"
-#include "dojump.h"
-#include "explow.h"
-#include "calls.h"
-#include "emit-rtl.h"
-#include "varasm.h"
-#include "stmt.h"
-#include "expr.h"
-#include "tree-dfa.h"
-#include "tree-inline.h"
-#include "tree-ssa-live.h"
-#include "tree-pass.h"
-#include "langhooks.h"
-
-static struct
-{
- /* Number of copies coalesced. */
- int coalesced;
-} stats;
-
-/* The following routines implement the SSA copy renaming phase.
-
- This optimization looks for copies between 2 SSA_NAMES, either through a
- direct copy, or an implicit one via a PHI node result and its arguments.
-
- Each copy is examined to determine if it is possible to rename the base
- variable of one of the operands to the same variable as the other operand.
- i.e.
- T.3_5 = <blah>
- a_1 = T.3_5
-
- If this copy couldn't be copy propagated, it could possibly remain in the
- program throughout the optimization phases. After SSA->normal, it would
- become:
-
- T.3 = <blah>
- a = T.3
-
- Since T.3_5 is distinct from all other SSA versions of T.3, there is no
- fundamental reason why the base variable needs to be T.3, subject to
- certain restrictions. This optimization attempts to determine if we can
- change the base variable on copies like this, and result in code such as:
-
- a_5 = <blah>
- a_1 = a_5
-
- This gives the SSA->normal pass a shot at coalescing a_1 and a_5. If it is
- possible, the copy goes away completely. If it isn't possible, a new temp
- will be created for a_5, and you will end up with the exact same code:
-
- a.8 = <blah>
- a = a.8
-
- The other benefit of performing this optimization relates to what variables
- are chosen in copies. Gimplification of the program uses temporaries for
- a lot of things. expressions like
-
- a_1 = <blah>
- <blah2> = a_1
-
- get turned into
-
- T.3_5 = <blah>
- a_1 = T.3_5
- <blah2> = a_1
-
- Copy propagation is done in a forward direction, and if we can propagate
- through the copy, we end up with:
-
- T.3_5 = <blah>
- <blah2> = T.3_5
-
- The copy is gone, but so is all reference to the user variable 'a'. By
- performing this optimization, we would see the sequence:
-
- a_5 = <blah>
- a_1 = a_5
- <blah2> = a_1
-
- which copy propagation would then turn into:
-
- a_5 = <blah>
- <blah2> = a_5
-
- and so we still retain the user variable whenever possible. */
-
-
-/* Coalesce the partitions in MAP representing VAR1 and VAR2 if it is valid.
- Choose a representative for the partition, and send debug info to DEBUG. */
-
-static void
-copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug)
-{
- int p1, p2, p3;
- tree root1, root2;
- tree rep1, rep2;
- bool ign1, ign2, abnorm;
-
- gcc_assert (TREE_CODE (var1) == SSA_NAME);
- gcc_assert (TREE_CODE (var2) == SSA_NAME);
-
- register_ssa_partition (map, var1);
- register_ssa_partition (map, var2);
-
- p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1));
- p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2));
-
- if (debug)
- {
- fprintf (debug, "Try : ");
- print_generic_expr (debug, var1, TDF_SLIM);
- fprintf (debug, "(P%d) & ", p1);
- print_generic_expr (debug, var2, TDF_SLIM);
- fprintf (debug, "(P%d)", p2);
- }
-
- gcc_assert (p1 != NO_PARTITION);
- gcc_assert (p2 != NO_PARTITION);
-
- if (p1 == p2)
- {
- if (debug)
- fprintf (debug, " : Already coalesced.\n");
- return;
- }
-
- rep1 = partition_to_var (map, p1);
- rep2 = partition_to_var (map, p2);
- root1 = SSA_NAME_VAR (rep1);
- root2 = SSA_NAME_VAR (rep2);
- if (!root1 && !root2)
- return;
-
- /* Don't coalesce if one of the variables occurs in an abnormal PHI. */
- abnorm = (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep1)
- || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rep2));
- if (abnorm)
- {
- if (debug)
- fprintf (debug, " : Abnormal PHI barrier. No coalesce.\n");
- return;
- }
-
- /* Partitions already have the same root, simply merge them. */
- if (root1 == root2)
- {
- p1 = partition_union (map->var_partition, p1, p2);
- if (debug)
- fprintf (debug, " : Same root, coalesced --> P%d.\n", p1);
- return;
- }
-
- /* Never attempt to coalesce 2 different parameters. */
- if ((root1 && TREE_CODE (root1) == PARM_DECL)
- && (root2 && TREE_CODE (root2) == PARM_DECL))
- {
- if (debug)
- fprintf (debug, " : 2 different PARM_DECLS. No coalesce.\n");
- return;
- }
-
- if ((root1 && TREE_CODE (root1) == RESULT_DECL)
- != (root2 && TREE_CODE (root2) == RESULT_DECL))
- {
- if (debug)
- fprintf (debug, " : One root a RESULT_DECL. No coalesce.\n");
- return;
- }
-
- ign1 = !root1 || (TREE_CODE (root1) == VAR_DECL && DECL_IGNORED_P (root1));
- ign2 = !root2 || (TREE_CODE (root2) == VAR_DECL && DECL_IGNORED_P (root2));
-
- /* Refrain from coalescing user variables, if requested. */
- if (!ign1 && !ign2)
- {
- if (flag_ssa_coalesce_vars && DECL_FROM_INLINE (root2))
- ign2 = true;
- else if (flag_ssa_coalesce_vars && DECL_FROM_INLINE (root1))
- ign1 = true;
- else if (flag_ssa_coalesce_vars != 2)
- {
- if (debug)
- fprintf (debug, " : 2 different USER vars. No coalesce.\n");
- return;
- }
- else
- ign2 = true;
- }
-
- /* If both values have default defs, we can't coalesce. If only one has a
- tag, make sure that variable is the new root partition. */
- if (root1 && ssa_default_def (cfun, root1))
- {
- if (root2 && ssa_default_def (cfun, root2))
- {
- if (debug)
- fprintf (debug, " : 2 default defs. No coalesce.\n");
- return;
- }
- else
- {
- ign2 = true;
- ign1 = false;
- }
- }
- else if (root2 && ssa_default_def (cfun, root2))
- {
- ign1 = true;
- ign2 = false;
- }
-
- /* Do not coalesce if we cannot assign a symbol to the partition. */
- if (!(!ign2 && root2)
- && !(!ign1 && root1))
- {
- if (debug)
- fprintf (debug, " : Choosen variable has no root. No coalesce.\n");
- return;
- }
-
- /* Don't coalesce if the new chosen root variable would be read-only.
- If both ign1 && ign2, then the root var of the larger partition
- wins, so reject in that case if any of the root vars is TREE_READONLY.
- Otherwise reject only if the root var, on which replace_ssa_name_symbol
- will be called below, is readonly. */
- if (((root1 && TREE_READONLY (root1)) && ign2)
- || ((root2 && TREE_READONLY (root2)) && ign1))
- {
- if (debug)
- fprintf (debug, " : Readonly variable. No coalesce.\n");
- return;
- }
-
- /* Don't coalesce if the two variables aren't type compatible . */
- if (!types_compatible_p (TREE_TYPE (var1), TREE_TYPE (var2))
- /* There is a disconnect between the middle-end type-system and
- VRP, avoid coalescing enum types with different bounds. */
- || ((TREE_CODE (TREE_TYPE (var1)) == ENUMERAL_TYPE
- || TREE_CODE (TREE_TYPE (var2)) == ENUMERAL_TYPE)
- && TREE_TYPE (var1) != TREE_TYPE (var2)))
- {
- if (debug)
- fprintf (debug, " : Incompatible types. No coalesce.\n");
- return;
- }
-
- /* Merge the two partitions. */
- p3 = partition_union (map->var_partition, p1, p2);
-
- /* Set the root variable of the partition to the better choice, if there is
- one. */
- if (!ign2 && root2)
- replace_ssa_name_symbol (partition_to_var (map, p3), root2);
- else if (!ign1 && root1)
- replace_ssa_name_symbol (partition_to_var (map, p3), root1);
- else
- gcc_unreachable ();
-
- if (debug)
- {
- fprintf (debug, " --> P%d ", p3);
- print_generic_expr (debug, SSA_NAME_VAR (partition_to_var (map, p3)),
- TDF_SLIM);
- fprintf (debug, "\n");
- }
-}
-
-
-namespace {
-
-const pass_data pass_data_rename_ssa_copies =
-{
- GIMPLE_PASS, /* type */
- "copyrename", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- TV_TREE_COPY_RENAME, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_rename_ssa_copies : public gimple_opt_pass
-{
-public:
- pass_rename_ssa_copies (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_rename_ssa_copies, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_rename_ssa_copies (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_copyrename != 0; }
- virtual unsigned int execute (function *);
-
-}; // class pass_rename_ssa_copies
-
-/* This function will make a pass through the IL, and attempt to coalesce any
- SSA versions which occur in PHI's or copies. Coalescing is accomplished by
- changing the underlying root variable of all coalesced version. This will
- then cause the SSA->normal pass to attempt to coalesce them all to the same
- variable. */
-
-unsigned int
-pass_rename_ssa_copies::execute (function *fun)
-{
- var_map map;
- basic_block bb;
- tree var, part_var;
- gimple stmt;
- unsigned x;
- FILE *debug;
-
- memset (&stats, 0, sizeof (stats));
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- debug = dump_file;
- else
- debug = NULL;
-
- map = init_var_map (num_ssa_names);
-
- FOR_EACH_BB_FN (bb, fun)
- {
- /* Scan for real copies. */
- for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
- gsi_next (&gsi))
- {
- stmt = gsi_stmt (gsi);
- if (gimple_assign_ssa_name_copy_p (stmt))
- {
- tree lhs = gimple_assign_lhs (stmt);
- tree rhs = gimple_assign_rhs1 (stmt);
-
- copy_rename_partition_coalesce (map, lhs, rhs, debug);
- }
- }
- }
-
- FOR_EACH_BB_FN (bb, fun)
- {
- /* Treat PHI nodes as copies between the result and each argument. */
- for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
- gsi_next (&gsi))
- {
- size_t i;
- tree res;
- gphi *phi = gsi.phi ();
- res = gimple_phi_result (phi);
-
- /* Do not process virtual SSA_NAMES. */
- if (virtual_operand_p (res))
- continue;
-
- /* Make sure to only use the same partition for an argument
- as the result but never the other way around. */
- if (SSA_NAME_VAR (res)
- && !DECL_IGNORED_P (SSA_NAME_VAR (res)))
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree arg = PHI_ARG_DEF (phi, i);
- if (TREE_CODE (arg) == SSA_NAME)
- copy_rename_partition_coalesce (map, res, arg,
- debug);
- }
- /* Else if all arguments are in the same partition try to merge
- it with the result. */
- else
- {
- int all_p_same = -1;
- int p = -1;
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree arg = PHI_ARG_DEF (phi, i);
- if (TREE_CODE (arg) != SSA_NAME)
- {
- all_p_same = 0;
- break;
- }
- else if (all_p_same == -1)
- {
- p = partition_find (map->var_partition,
- SSA_NAME_VERSION (arg));
- all_p_same = 1;
- }
- else if (all_p_same == 1
- && p != partition_find (map->var_partition,
- SSA_NAME_VERSION (arg)))
- {
- all_p_same = 0;
- break;
- }
- }
- if (all_p_same == 1)
- copy_rename_partition_coalesce (map, res,
- PHI_ARG_DEF (phi, 0),
- debug);
- }
- }
- }
-
- if (debug)
- dump_var_map (debug, map);
-
- /* Now one more pass to make all elements of a partition share the same
- root variable. */
-
- for (x = 1; x < num_ssa_names; x++)
- {
- part_var = partition_to_var (map, x);
- if (!part_var)
- continue;
- var = ssa_name (x);
- if (SSA_NAME_VAR (var) == SSA_NAME_VAR (part_var))
- continue;
- if (debug)
- {
- fprintf (debug, "Coalesced ");
- print_generic_expr (debug, var, TDF_SLIM);
- fprintf (debug, " to ");
- print_generic_expr (debug, part_var, TDF_SLIM);
- fprintf (debug, "\n");
- }
- stats.coalesced++;
- replace_ssa_name_symbol (var, SSA_NAME_VAR (part_var));
- }
-
- statistics_counter_event (fun, "copies coalesced",
- stats.coalesced);
- delete_var_map (map);
- return 0;
-}
-
-} // anon namespace
-
-gimple_opt_pass *
-make_pass_rename_ssa_copies (gcc::context *ctxt)
-{
- return new pass_rename_ssa_copies (ctxt);
-}
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index 5b00f58..4772558 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -70,88 +70,6 @@ static void verify_live_on_entry (tree_live_info_p);
ssa_name or variable, and vice versa. */
-/* Hashtable helpers. */
-
-struct tree_int_map_hasher : nofree_ptr_hash <tree_int_map>
-{
- static inline hashval_t hash (const tree_int_map *);
- static inline bool equal (const tree_int_map *, const tree_int_map *);
-};
-
-inline hashval_t
-tree_int_map_hasher::hash (const tree_int_map *v)
-{
- return tree_map_base_hash (v);
-}
-
-inline bool
-tree_int_map_hasher::equal (const tree_int_map *v, const tree_int_map *c)
-{
- return tree_int_map_eq (v, c);
-}
-
-
-/* This routine will initialize the basevar fields of MAP. */
-
-static void
-var_map_base_init (var_map map)
-{
- int x, num_part;
- tree var;
- struct tree_int_map *m, *mapstorage;
-
- num_part = num_var_partitions (map);
- hash_table<tree_int_map_hasher> tree_to_index (num_part);
- /* We can have at most num_part entries in the hash tables, so it's
- enough to allocate so many map elements once, saving some malloc
- calls. */
- mapstorage = m = XNEWVEC (struct tree_int_map, num_part);
-
- /* If a base table already exists, clear it, otherwise create it. */
- free (map->partition_to_base_index);
- map->partition_to_base_index = (int *) xmalloc (sizeof (int) * num_part);
-
- /* Build the base variable list, and point partitions at their bases. */
- for (x = 0; x < num_part; x++)
- {
- struct tree_int_map **slot;
- unsigned baseindex;
- var = partition_to_var (map, x);
- if (SSA_NAME_VAR (var)
- && (!VAR_P (SSA_NAME_VAR (var))
- || !DECL_IGNORED_P (SSA_NAME_VAR (var))))
- m->base.from = SSA_NAME_VAR (var);
- else
- /* This restricts what anonymous SSA names we can coalesce
- as it restricts the sets we compute conflicts for.
- Using TREE_TYPE to generate sets is the easies as
- type equivalency also holds for SSA names with the same
- underlying decl.
-
- Check gimple_can_coalesce_p when changing this code. */
- m->base.from = (TYPE_CANONICAL (TREE_TYPE (var))
- ? TYPE_CANONICAL (TREE_TYPE (var))
- : TREE_TYPE (var));
- /* If base variable hasn't been seen, set it up. */
- slot = tree_to_index.find_slot (m, INSERT);
- if (!*slot)
- {
- baseindex = m - mapstorage;
- m->to = baseindex;
- *slot = m;
- m++;
- }
- else
- baseindex = (*slot)->to;
- map->partition_to_base_index[x] = baseindex;
- }
-
- map->num_basevars = m - mapstorage;
-
- free (mapstorage);
-}
-
-
/* Remove the base table in MAP. */
static void
@@ -329,21 +247,17 @@ partition_view_fini (var_map map, bitmap selected)
}
-/* Create a partition view which includes all the used partitions in MAP. If
- WANT_BASES is true, create the base variable map as well. */
+/* Create a partition view which includes all the used partitions in MAP. */
void
-partition_view_normal (var_map map, bool want_bases)
+partition_view_normal (var_map map)
{
bitmap used;
used = partition_view_init (map);
partition_view_fini (map, used);
- if (want_bases)
- var_map_base_init (map);
- else
- var_map_base_fini (map);
+ var_map_base_fini (map);
}
@@ -352,7 +266,7 @@ partition_view_normal (var_map map, bool want_bases)
as well. */
void
-partition_view_bitmap (var_map map, bitmap only, bool want_bases)
+partition_view_bitmap (var_map map, bitmap only)
{
bitmap used;
bitmap new_partitions = BITMAP_ALLOC (NULL);
@@ -368,10 +282,7 @@ partition_view_bitmap (var_map map, bitmap only, bool want_bases)
}
partition_view_fini (map, new_partitions);
- if (want_bases)
- var_map_base_init (map);
- else
- var_map_base_fini (map);
+ var_map_base_fini (map);
}
diff --git a/gcc/tree-ssa-live.h b/gcc/tree-ssa-live.h
index d5d7820..1f88358 100644
--- a/gcc/tree-ssa-live.h
+++ b/gcc/tree-ssa-live.h
@@ -71,8 +71,8 @@ typedef struct _var_map
extern var_map init_var_map (int);
extern void delete_var_map (var_map);
extern int var_union (var_map, tree, tree);
-extern void partition_view_normal (var_map, bool);
-extern void partition_view_bitmap (var_map, bitmap, bool);
+extern void partition_view_normal (var_map);
+extern void partition_view_bitmap (var_map, bitmap);
extern void dump_scope_blocks (FILE *, int);
extern void debug_scope_block (tree, int);
extern void debug_scope_blocks (int);
diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
index 437f69d..1fbd71e 100644
--- a/gcc/tree-ssa-uncprop.c
+++ b/gcc/tree-ssa-uncprop.c
@@ -38,6 +38,11 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pass.h"
#include "tree-ssa-propagate.h"
#include "tree-hash-traits.h"
+#include "bitmap.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "tree-ssa-live.h"
+#include "tree-ssa-coalesce.h"
/* The basic structure describing an equivalency created by traversing
an edge. Traversing the edge effectively means that we can assume
diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c
index da9de28..a31a137 100644
--- a/gcc/var-tracking.c
+++ b/gcc/var-tracking.c
@@ -4856,12 +4856,16 @@ dataflow_set_remove_mem_locs (variable_def **slot, dataflow [...]
registers, as well as associations between MEMs and VALUEs. */
static void
-dataflow_set_clear_at_call (dataflow_set *set)
+dataflow_set_clear_at_call (dataflow_set *set, rtx_insn *call_insn)
{
unsigned int r;
hard_reg_set_iterator hrsi;
+ HARD_REG_SET invalidated_regs;
- EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, r, hrsi)
+ get_call_reg_set_usage (call_insn, &invalidated_regs,
+ regs_invalidated_by_call);
+
+ EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs, 0, r, hrsi)
var_regno_delete (set, r);
if (MAY_HAVE_DEBUG_INSNS)
@@ -6645,7 +6649,7 @@ compute_bb_dataflow (basic_block bb)
switch (mo->type)
{
case MO_CALL:
- dataflow_set_clear_at_call (out);
+ dataflow_set_clear_at_call (out, insn);
break;
case MO_USE:
@@ -9107,7 +9111,7 @@ emit_notes_in_bb (basic_block bb, dataflow_set *set)
switch (mo->type)
{
case MO_CALL:
- dataflow_set_clear_at_call (set);
+ dataflow_set_clear_at_call (set, insn);
emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
{
rtx arguments = mo->u.loc, *p = &arguments;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] 02/02: incremental fixes
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a commit to branch aoliva/pr64164
in repository gcc.
commit 143090f5c0071e0de9118748c4d7611bd6e01e31
Author: Alexandre Oliva <aoliva(a)redhat.com>
Date: Wed Jul 29 14:34:34 2015 -0300
incremental fixes
* emit-rtl.c: Include stor-layout.h.
(set_reg_attrs_for_decl_rtl): Take mode from expression if
it's not a DECL.
* stmt.c (emit_case_decision_tree): Pass it the SSA_NAME
rather than its possibly-NULL DECL.
PR bootstrap/66978
* function.c (expand_function_start): Convert static chain to
Pmode if needed. From H.J. Lu <hongjiu.lu(a)intel.com>.
PR middle-end/66983
PR middle-end/67035
* cfgexpand.c (align_local_variable, add_stack_var): Support
anonymous SSA names.
(defer_stack_allocation): Likewise. Declare earlier.
(expand_one_ssa_partition): Record alignment before expanding
stack vars. Support deferred allocation.
(set_rtl): Do no record deferred-allocation marker in
SA.partition_to_pseudo.
(expand_stack_vars): Adjust check for the marker in it.
(adjust_one_expanded_partition_var): Skip deferred-alloc vars.
PR middle-end/67034
* cfgexpand.c (parm_maybe_byref_p): New.
(expand_one_ssa_partition): Call it. Expand maybe-byref
parms' default defs with a placeholder for the mem addr.
(ssa_default_def_partition): New.
(get_rtl_for_parm_ssa_default_def): Use it.
* function.c (assign_parm_setup_block): Replace the
placeholder with the address of the newly-allocated block.
(assign_parm_setup_reg): Replace the placeholder with a
newly-created pseudo. Arrange for the pseudo to be
initialized from the incoming passed pointer. Make sure
passed_pointer parms don't need conversion. Don't copy from
validated_mem if parmreg is the value expression from expand
and validated_mem is the passed pointer. For passed pointers,
copy from the mem referenced by validated_mem when using the
expand-chosen rtl.
* cfgexpand.h (parm_maybe_byref_p): Declare.
* tree-ssa-coalesce.c: Include cfgexpand.h.
(gimple_can_coalesce_p): Do not coalesce maybe-byref parms
with SSA_NAMEs of other variables, or anonymous SSA_NAMEs.
PR rtl-optimization/67000
* expr.c (read_complex_part): Export.
* expr.h (read_complex_part): Declare.
* function.c (split_complex_args): Use it. Reset complex parm
before fetching its default decl rtl.
(assign_parms_unsplit_complex): Use the preexisting complex
parm rtl if it matches the components.
(assign_parm_setup_reg): Drop assert on from_expand mode.
Adjust it to the promoted_mode, if not byref.
---
gcc/cfgexpand.c | 129 ++++++++++++++++++++++++++++++++++++++----------
gcc/cfgexpand.h | 1 +
gcc/emit-rtl.c | 5 +-
gcc/expr.c | 2 +-
gcc/expr.h | 1 +
gcc/function.c | 88 +++++++++++++++++++++++++--------
gcc/stmt.c | 2 +-
gcc/tree-ssa-coalesce.c | 12 +++--
8 files changed, 186 insertions(+), 54 deletions(-)
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 0b19953..8f6caf6 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -97,6 +97,8 @@ gimple currently_expanding_gimple_stmt;
static rtx expand_debug_expr (tree);
+static bool defer_stack_allocation (tree, bool);
+
/* Return an expression tree corresponding to the RHS of GIMPLE
statement STMT. */
@@ -170,6 +172,39 @@ leader_merge (tree cur, tree next)
return cur;
}
+/* Return true if VAR is a PARM_DECL or a RESULT_DECL of type BLKmode.
+ Such parameters are likely passed as a pointer to the value, rather
+ than as a value, and so we must not coalesce them, nor allocate
+ stack space for them before determining the calling conventions for
+ them. For their SSA_NAMEs, expand_one_ssa_partition emits RTL as
+ MEMs with pc_rtx as the address, and then it replaces the pc_rtx
+ with NULL so as to make sure the MEM is not used before it is
+ adjusted in assign_parm_setup_reg. */
+
+bool
+parm_maybe_byref_p (tree var)
+{
+ if (!var || VAR_P (var))
+ return false;
+
+ gcc_assert (TREE_CODE (var) == PARM_DECL
+ || TREE_CODE (var) == RESULT_DECL);
+
+ return TYPE_MODE (TREE_TYPE (var)) == BLKmode;
+}
+
+/* Return the partition of the default SSA_DEF for decl VAR. */
+
+static int
+ssa_default_def_partition (tree var)
+{
+ tree name = ssa_default_def (cfun, var);
+
+ if (!name)
+ return NO_PARTITION;
+
+ return var_to_partition (SA.map, name);
+}
/* Return the RTL for the default SSA def of a PARM or RESULT, if
there is one. */
@@ -198,12 +233,7 @@ get_rtl_for_parm_ssa_default_def (tree var)
return DECL_RTL (var);
}
- tree name = ssa_default_def (cfun, var);
-
- if (!name)
- return NULL_RTX;
-
- int part = var_to_partition (SA.map, name);
+ int part = ssa_default_def_partition (var);
if (part == NO_PARTITION)
return NULL_RTX;
@@ -253,7 +283,7 @@ set_rtl (tree t, rtx x)
{
if (SA.partition_to_pseudo[part])
gcc_assert (SA.partition_to_pseudo[part] == x);
- else
+ else if (x != pc_rtx)
SA.partition_to_pseudo[part] = x;
}
/* For the benefit of debug information at -O0 (where
@@ -348,8 +378,15 @@ static bool has_short_buffer;
static unsigned int
align_local_variable (tree decl)
{
- unsigned int align = LOCAL_DECL_ALIGNMENT (decl);
- DECL_ALIGN (decl) = align;
+ unsigned int align;
+
+ if (TREE_CODE (decl) == SSA_NAME)
+ align = TYPE_ALIGN (TREE_TYPE (decl));
+ else
+ {
+ align = LOCAL_DECL_ALIGNMENT (decl);
+ DECL_ALIGN (decl) = align;
+ }
return align / BITS_PER_UNIT;
}
@@ -415,12 +452,15 @@ add_stack_var (tree decl)
decl_to_stack_part->put (decl, stack_vars_num);
v->decl = decl;
- v->size = tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (decl)));
+ tree size = TREE_CODE (decl) == SSA_NAME
+ ? TYPE_SIZE_UNIT (TREE_TYPE (decl))
+ : DECL_SIZE_UNIT (decl);
+ v->size = tree_to_uhwi (size);
/* Ensure that all variables have size, so that &a != &b for any two
variables that are simultaneously live. */
if (v->size == 0)
v->size = 1;
- v->alignb = align_local_variable (SSAVAR (decl));
+ v->alignb = align_local_variable (decl);
/* An alignment of zero can mightily confuse us later. */
gcc_assert (v->alignb != 0);
@@ -1051,9 +1091,9 @@ expand_stack_vars (bool (*pred) (size_t), struct stack_vars_d [...]
/* Skip variables that have already had rtl assigned. See also
add_stack_var where we perpetrate this pc_rtx hack. */
decl = stack_vars[i].decl;
- if ((TREE_CODE (decl) == SSA_NAME
- ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
- : DECL_RTL (decl)) != pc_rtx)
+ if (TREE_CODE (decl) == SSA_NAME
+ ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
+ : DECL_RTL (decl) != pc_rtx)
continue;
large_size += alignb - 1;
@@ -1082,9 +1122,9 @@ expand_stack_vars (bool (*pred) (size_t), struct stack_vars_d [...]
/* Skip variables that have already had rtl assigned. See also
add_stack_var where we perpetrate this pc_rtx hack. */
decl = stack_vars[i].decl;
- if ((TREE_CODE (decl) == SSA_NAME
- ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
- : DECL_RTL (decl)) != pc_rtx)
+ if (TREE_CODE (decl) == SSA_NAME
+ ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
+ : DECL_RTL (decl) != pc_rtx)
continue;
/* Check the predicate to see whether this variable should be
@@ -1290,12 +1330,6 @@ expand_one_ssa_partition (tree var)
if (SA.partition_to_pseudo[part])
return;
- if (!use_register_for_decl (var))
- {
- expand_one_stack_var_1 (var);
- return;
- }
-
unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
TYPE_MODE (TREE_TYPE (var)),
TYPE_ALIGN (TREE_TYPE (var)));
@@ -1307,6 +1341,27 @@ expand_one_ssa_partition (tree var)
record_alignment_for_reg_var (align);
+ if (!use_register_for_decl (var))
+ {
+ if (parm_maybe_byref_p (SSA_NAME_VAR (var))
+ && ssa_default_def_partition (SSA_NAME_VAR (var)) == part)
+ {
+ expand_one_stack_var_at (var, pc_rtx, 0, 0);
+ rtx x = SA.partition_to_pseudo[part];
+ gcc_assert (GET_CODE (x) == MEM);
+ gcc_assert (GET_MODE (x) == BLKmode);
+ gcc_assert (XEXP (x, 0) == pc_rtx);
+ /* Reset the address, so that any attempt to use it will
+ ICE. It will be adjusted in assign_parm_setup_reg. */
+ XEXP (x, 0) = NULL_RTX;
+ }
+ else if (defer_stack_allocation (var, true))
+ add_stack_var (var);
+ else
+ expand_one_stack_var_1 (var);
+ return;
+ }
+
machine_mode reg_mode = promote_ssa_mode (var, NULL);
rtx x = gen_reg_rtx (reg_mode);
@@ -1331,6 +1386,13 @@ adjust_one_expanded_partition_var (tree var)
rtx x = SA.partition_to_pseudo[part];
+ if (!x)
+ {
+ /* This var will get a stack slot later. */
+ gcc_assert (defer_stack_allocation (var, true));
+ return;
+ }
+
set_rtl (var, x);
if (!REG_P (x))
@@ -1409,10 +1471,14 @@ expand_one_error_var (tree var)
static bool
defer_stack_allocation (tree var, bool toplevel)
{
+ tree size_unit = TREE_CODE (var) == SSA_NAME
+ ? TYPE_SIZE_UNIT (TREE_TYPE (var))
+ : DECL_SIZE_UNIT (var);
+
/* Whether the variable is small enough for immediate allocation not to be
a problem with regard to the frame size. */
bool smallish
- = ((HOST_WIDE_INT) tree_to_uhwi (DECL_SIZE_UNIT (var))
+ = ((HOST_WIDE_INT) tree_to_uhwi (size_unit)
< PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING));
/* If stack protection is enabled, *all* stack variables must be deferred,
@@ -1421,16 +1487,24 @@ defer_stack_allocation (tree var, bool toplevel)
if (flag_stack_protect || ((flag_sanitize & SANITIZE_ADDRESS) && ASAN_STACK))
return true;
+ unsigned int align = TREE_CODE (var) == SSA_NAME
+ ? TYPE_ALIGN (TREE_TYPE (var))
+ : DECL_ALIGN (var);
+
/* We handle "large" alignment via dynamic allocation. We want to handle
this extra complication in only one place, so defer them. */
- if (DECL_ALIGN (var) > MAX_SUPPORTED_STACK_ALIGNMENT)
+ if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
return true;
+ bool ignored = TREE_CODE (var) == SSA_NAME
+ ? !SSAVAR (var) || DECL_IGNORED_P (SSA_NAME_VAR (var))
+ : DECL_IGNORED_P (var);
+
/* When optimization is enabled, DECL_IGNORED_P variables originally scoped
might be detached from their block and appear at toplevel when we reach
here. We want to coalesce them with variables from other blocks when
the immediate contribution to the frame size would be noticeable. */
- if (toplevel && optimize > 0 && DECL_IGNORED_P (var) && !smallish)
+ if (toplevel && optimize > 0 && ignored && !smallish)
return true;
/* Variables declared in the outermost scope automatically conflict
@@ -6135,7 +6209,8 @@ pass_expand::execute (function *fun)
if (part == NO_PARTITION)
continue;
- gcc_assert (SA.partition_to_pseudo[part]);
+ gcc_assert (SA.partition_to_pseudo[part]
+ || defer_stack_allocation (name, true));
/* If this decl was marked as living in multiple places, reset
this now to NULL. */
diff --git a/gcc/cfgexpand.h b/gcc/cfgexpand.h
index 602579d..987cf356 100644
--- a/gcc/cfgexpand.h
+++ b/gcc/cfgexpand.h
@@ -22,6 +22,7 @@ along with GCC; see the file COPYING3. If not see
extern tree gimple_assign_rhs_to_tree (gimple);
extern HOST_WIDE_INT estimated_stack_frame_size (struct cgraph_node *);
+extern bool parm_maybe_byref_p (tree);
extern rtx get_rtl_for_parm_ssa_default_def (tree var);
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 0648af6..3b95c5d 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "builtins.h"
#include "rtl-iter.h"
+#include "stor-layout.h"
struct target_rtl default_target_rtl;
#if SWITCHABLE_TARGET
@@ -1243,7 +1244,9 @@ set_reg_attrs_for_decl_rtl (tree t, rtx x)
if (REG_P (x))
REG_ATTRS (x)
= get_reg_attrs (t, byte_lowpart_offset (GET_MODE (x),
- DECL_MODE (tdecl)));
+ DECL_P (tdecl)
+ ? DECL_MODE (tdecl)
+ : TYPE_MODE (TREE_TYPE (tdecl))));
if (GET_CODE (x) == CONCAT)
{
if (REG_P (XEXP (x, 0)))
diff --git a/gcc/expr.c b/gcc/expr.c
index d601129..fc49f92 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -3022,7 +3022,7 @@ write_complex_part (rtx cplx, rtx val, bool imag_p)
/* Extract one of the components of the complex value CPLX. Extract the
real part if IMAG_P is false, and the imaginary part if it's true. */
-static rtx
+rtx
read_complex_part (rtx cplx, bool imag_p)
{
machine_mode cmode, imode;
diff --git a/gcc/expr.h b/gcc/expr.h
index 32d1707..a2c8e1d 100644
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -210,6 +210,7 @@ extern rtx_insn *emit_move_insn_1 (rtx, rtx);
extern rtx_insn *emit_move_complex_push (machine_mode, rtx, rtx);
extern rtx_insn *emit_move_complex_parts (rtx, rtx);
+extern rtx read_complex_part (rtx, bool);
extern void write_complex_part (rtx, rtx, bool);
extern rtx emit_move_resolve_push (machine_mode, rtx);
diff --git a/gcc/function.c b/gcc/function.c
index c3d00cd..16708e9 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -152,6 +152,7 @@ static void prepare_function_start (void);
static void do_clobber_return_reg (rtx, void *);
static void do_use_return_reg (rtx, void *);
static rtx rtl_for_parm (struct assign_parm_data_all *, tree);
+static void maybe_reset_rtl_for_parm (tree);
/* Stack of nested functions. */
@@ -2321,12 +2322,12 @@ split_complex_args (struct assign_parm_data_all *all, vec<t [...]
from resetting their RTL. */
if (currently_expanding_to_rtl)
{
+ maybe_reset_rtl_for_parm (cparm);
rtx rtl = rtl_for_parm (all, cparm);
- gcc_assert (!rtl || GET_CODE (rtl) == CONCAT);
if (rtl)
{
- SET_DECL_RTL (p, XEXP (rtl, 0));
- SET_DECL_RTL (decl, XEXP (rtl, 1));
+ SET_DECL_RTL (p, read_complex_part (rtl, false));
+ SET_DECL_RTL (decl, read_complex_part (rtl, true));
DECL_CONTEXT (p) = cparm;
DECL_CONTEXT (decl) = cparm;
@@ -2954,16 +2955,27 @@ assign_parm_setup_block (struct assign_parm_data_all *all,
if (stack_parm == 0)
{
DECL_ALIGN (parm) = MAX (DECL_ALIGN (parm), BITS_PER_WORD);
- stack_parm = rtl_for_parm (all, parm);
- if (stack_parm)
- stack_parm = copy_rtx (stack_parm);
+ rtx from_expand = rtl_for_parm (all, parm);
+ if (from_expand && (!parm_maybe_byref_p (parm)
+ || XEXP (from_expand, 0) != NULL_RTX))
+ stack_parm = copy_rtx (from_expand);
else
{
stack_parm = assign_stack_local (BLKmode, size_stored,
DECL_ALIGN (parm));
if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size)
PUT_MODE (stack_parm, GET_MODE (entry_parm));
- set_mem_attributes (stack_parm, parm, 1);
+ if (from_expand)
+ {
+ gcc_assert (GET_CODE (stack_parm) == MEM);
+ gcc_assert (GET_CODE (from_expand) == MEM);
+ gcc_assert (XEXP (from_expand, 0) == NULL_RTX);
+ XEXP (from_expand, 0) = XEXP (stack_parm, 0);
+ PUT_MODE (from_expand, GET_MODE (stack_parm));
+ stack_parm = copy_rtx (from_expand);
+ }
+ else
+ set_mem_attributes (stack_parm, parm, 1);
}
}
@@ -3102,23 +3114,34 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
= promote_function_mode (data->nominal_type, data->nominal_mode, &unsignedp,
TREE_TYPE (current_function_decl), 2);
- rtx from_expand = rtl_for_parm (all, parm);
+ rtx from_expand = parmreg = rtl_for_parm (all, parm);
if (from_expand && !data->passed_pointer)
{
- parmreg = from_expand;
- gcc_assert (GET_MODE (parmreg) == promoted_nominal_mode);
+ if (GET_MODE (parmreg) != promoted_nominal_mode)
+ parmreg = gen_lowpart (promoted_nominal_mode, parmreg);
}
- else
+ else if (!from_expand || parm_maybe_byref_p (parm))
{
parmreg = gen_reg_rtx (promoted_nominal_mode);
if (!DECL_ARTIFICIAL (parm))
mark_user_reg (parmreg);
+
+ if (from_expand)
+ {
+ gcc_assert (data->passed_pointer);
+ gcc_assert (GET_CODE (from_expand) == MEM
+ && GET_MODE (from_expand) == BLKmode
+ && XEXP (from_expand, 0) == NULL_RTX);
+ XEXP (from_expand, 0) = parmreg;
+ }
}
/* If this was an item that we received a pointer to,
set DECL_RTL appropriately. */
- if (data->passed_pointer)
+ if (from_expand)
+ SET_DECL_RTL (parm, from_expand);
+ else if (data->passed_pointer)
{
rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->passed_type)), parmreg);
set_mem_attributes (x, parm, 1);
@@ -3139,6 +3162,7 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
need_conversion = (data->nominal_mode != data->passed_mode
|| promoted_nominal_mode != data->promoted_mode);
+ gcc_assert (!(need_conversion && data->passed_pointer));
moved = false;
if (need_conversion
@@ -3270,7 +3294,9 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
did_conversion = true;
}
- else
+ /* We don't want to copy the incoming pointer to a parmreg expected
+ to hold the value rather than the pointer. */
+ else if (!data->passed_pointer || parmreg != from_expand)
emit_move_insn (parmreg, validated_mem);
/* If we were passed a pointer but the actual value can safely live
@@ -3278,12 +3304,16 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
if (data->passed_pointer
&& (from_expand || TYPE_MODE (TREE_TYPE (parm)) != BLKmode))
{
+ rtx src = DECL_RTL (parm);
+
/* We can't use nominal_mode, because it will have been set to
Pmode above. We must use the actual mode of the parm. */
if (from_expand)
{
parmreg = from_expand;
gcc_assert (GET_MODE (parmreg) == TYPE_MODE (TREE_TYPE (parm)));
+ src = gen_rtx_MEM (GET_MODE (parmreg), validated_mem);
+ set_mem_attributes (src, parm, 1);
}
else if (use_register_for_decl (parm))
{
@@ -3302,14 +3332,14 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tr [...]
set_mem_attributes (parmreg, parm, 1);
}
- if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
+ if (GET_MODE (parmreg) != GET_MODE (src))
{
- rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
+ rtx tempreg = gen_reg_rtx (GET_MODE (src));
int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm));
push_to_sequence2 (all->first_conversion_insn,
all->last_conversion_insn);
- emit_move_insn (tempreg, DECL_RTL (parm));
+ emit_move_insn (tempreg, src);
tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p);
emit_move_insn (parmreg, tempreg);
all->first_conversion_insn = get_insns ();
@@ -3318,8 +3348,10 @@ assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
did_conversion = true;
}
+ else if (GET_MODE (parmreg) == BLKmode)
+ gcc_assert (parm_maybe_byref_p (parm));
else
- emit_move_insn (parmreg, DECL_RTL (parm));
+ emit_move_insn (parmreg, src);
SET_DECL_RTL (parm, parmreg);
@@ -3495,11 +3527,21 @@ assign_parms_unsplit_complex (struct assign_parm_data_all *all,
imag = DECL_RTL (fnargs[i + 1]);
if (inner != GET_MODE (real))
{
- real = gen_lowpart_SUBREG (inner, real);
- imag = gen_lowpart_SUBREG (inner, imag);
+ real = simplify_gen_subreg (inner, real, GET_MODE (real),
+ subreg_lowpart_offset
+ (inner, GET_MODE (real)));
+ imag = simplify_gen_subreg (inner, imag, GET_MODE (imag),
+ subreg_lowpart_offset
+ (inner, GET_MODE (imag)));
}
- if (TREE_ADDRESSABLE (parm))
+ if ((tmp = rtl_for_parm (all, parm)) != NULL_RTX
+ && rtx_equal_p (real,
+ read_complex_part (tmp, false))
+ && rtx_equal_p (imag,
+ read_complex_part (tmp, true)))
+ ; /* We now have the right rtl in tmp. */
+ else if (TREE_ADDRESSABLE (parm))
{
rtx rmem, imem;
HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm));
@@ -3645,7 +3687,7 @@ assign_bounds (vec<bounds_parm_data> &bndargs,
assign_parm_setup_block (&all, pbdata->bounds_parm,
&pbdata->parm_data);
else if (pbdata->parm_data.passed_pointer
- || use_register_for_decl (pbdata->bounds_parm))
+ || use_register_for_parm_decl (&all, pbdata->bounds_parm))
assign_parm_setup_reg (&all, pbdata->bounds_parm,
&pbdata->parm_data);
else
@@ -5207,6 +5249,10 @@ expand_function_start (tree subr)
SET_DECL_RTL (parm, local);
mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
+ if (GET_MODE (local) != Pmode)
+ local = convert_to_mode (Pmode, local,
+ TYPE_UNSIGNED (TREE_TYPE (parm)));
+
insn = emit_move_insn (local, chain);
/* Mark the register as eliminable, similar to parameters. */
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 391686c..e7f7dd4 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -891,7 +891,7 @@ emit_case_decision_tree (tree index_expr, tree index_type,
{
index = copy_to_reg (index);
if (TREE_CODE (index_expr) == SSA_NAME)
- set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (index_expr), index);
+ set_reg_attrs_for_decl_rtl (index_expr, index);
}
balance_case_nodes (&case_list, NULL);
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index a622728..08ce72c 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-iterator.h"
#include "tree-ssa-live.h"
#include "tree-ssa-coalesce.h"
+#include "cfgexpand.h"
#include "explow.h"
#include "diagnostic-core.h"
@@ -1379,10 +1380,15 @@ gimple_can_coalesce_p (tree name1, tree name2)
/* Check that the promoted modes are the same. We don't want to
coalesce if the promoted modes would be different. Only
PARM_DECLs and RESULT_DECLs have different promotion rules,
- so skip the test if we both are variables or anonymous
- SSA_NAMEs. */
+ so skip the test if both are variables, or both are anonymous
+ SSA_NAMEs. Now, if a parm or result has BLKmode, do not
+ coalesce its SSA versions with those of any other variables,
+ because it may be passed by reference. */
return ((!var1 || VAR_P (var1)) && (!var2 || VAR_P (var2)))
- || promote_ssa_mode (name1, NULL) == promote_ssa_mode (name2, NULL);
+ || (/* The case var1 == var2 is already covered above. */
+ !parm_maybe_byref_p (var1)
+ && !parm_maybe_byref_p (var2)
+ && promote_ssa_mode (name1, NULL) == promote_ssa_mode (name2, NULL));
}
/* If the types are not the same, check for a canonical type match. This
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] branch aoliva/pr64164 updated (ec7d074 -> 143090f)
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a change to branch aoliva/pr64164
in repository gcc.
discards ec7d074 use rtl_for_parm to test unsplit complex
discards a284ae4 accept ssa names as reg exprs
discards 9357ff1 further adjustments to handling of byref parms
discards 1013892 try special handling of byref parms
discards 2c8077e incremental fixes
omits f6c340c [PR64164] Drop copyrename, use coalescible partition as base [...]
new 2348a01 [PR64164] Drop copyrename, use coalescible partition as base [...]
new 143090f incremental fixes
This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version. This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:
* -- * -- B -- O -- O -- O (ec7d074)
\
N -- N -- N refs/heads/aoliva/pr64164 (143090f)
You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.
Any revisions marked "omits" are not gone; other references still
refer to them. Any revisions marked "discards" are gone forever.
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "adds" were already present in the repository and have only
been added to this reference.
Summary of changes:
gcc/ChangeLog | 3 ---
gcc/testsuite/ChangeLog | 3 ---
2 files changed, 6 deletions(-)
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] branch trunk updated (05999bf -> c909938)
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a change to branch trunk
in repository gcc.
from 05999bf 2015-08-03 Richard Biener <rguenther(a)suse.de>
new c909938 PR c/67088 * c-decl.c (check_bitfield_type_and_width): Add [...]
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "adds" were already present in the repository and have only
been added to this reference.
Summary of changes:
gcc/c/ChangeLog | 7 +++++++
gcc/c/c-decl.c | 24 +++++++++++++-----------
gcc/testsuite/ChangeLog | 5 +++++
gcc/testsuite/gcc.dg/pr67088.c | 18 ++++++++++++++++++
4 files changed, 43 insertions(+), 11 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/pr67088.c
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0
[gcc] branch trunk updated (ec66e09 -> 05999bf)
by git
This is an automated email from the git hooks/post-receive script.
unknown user pushed a change to branch trunk
in repository gcc.
from ec66e09 2015-08-03 Richard Biener <rguenther(a)suse.de>
new 05999bf 2015-08-03 Richard Biener <rguenther(a)suse.de>
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "adds" were already present in the repository and have only
been added to this reference.
Summary of changes:
gcc/match.pd | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
9 years, 4 months
- 1
- 0