public inbox for gcc-regression@sourceware.org
help / color / mirror / Atom feed
* [TCWG CI] 450.soplex grew in size by 2% after gcc: Commonize ipa-pta constraint generation for calls
@ 2021-10-14 14:59 ci_notify
0 siblings, 0 replies; only message in thread
From: ci_notify @ 2021-10-14 14:59 UTC (permalink / raw)
To: Jan Hubicka; +Cc: gcc-regression
After gcc commit 008e7397dad971c03c08fc1b0a4a98fddccaaed8
Author: Jan Hubicka <hubicka@ucw.cz>
Commonize ipa-pta constraint generation for calls
the following benchmarks grew in size by more than 1%:
- 450.soplex grew in size by 2% from 207414 to 211478 bytes
Below reproducer instructions can be used to re-build both "first_bad" and "last_good" cross-toolchains used in this bisection. Naturally, the scripts will fail when triggerring benchmarking jobs if you don't have access to Linaro TCWG CI.
For your convenience, we have uploaded tarballs with pre-processed source and assembly files at:
- First_bad save-temps: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/build-008e7397dad971c03c08fc1b0a4a98fddccaaed8/save-temps/
- Last_good save-temps: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/build-0de8c2f8104b74f46e63d0d5d7b9e8fd3f04bb98/save-temps/
- Baseline save-temps: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/build-baseline/save-temps/
Configuration:
- Benchmark: SPEC CPU2006
- Toolchain: GCC + Glibc + GNU Linker
- Version: all components were built from their tip of trunk
- Target: aarch64-linux-gnu
- Compiler flags: -Os -flto
- Hardware: APM Mustang 8x X-Gene1
This benchmarking CI is work-in-progress, and we welcome feedback and suggestions at linaro-toolchain@lists.linaro.org . In our improvement plans is to add support for SPEC CPU2017 benchmarks and provide "perf report/annotate" data behind these reports.
THIS IS THE END OF INTERESTING STUFF. BELOW ARE LINKS TO BUILDS, REPRODUCTION INSTRUCTIONS, AND THE RAW COMMIT.
This commit has regressed these CI configurations:
- tcwg_bmk_gnu_apm/gnu-master-aarch64-spec2k6-Os_LTO
First_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/build-008e7397dad971c03c08fc1b0a4a98fddccaaed8/
Last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/build-0de8c2f8104b74f46e63d0d5d7b9e8fd3f04bb98/
Baseline build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/build-baseline/
Even more details: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/
Reproduce builds:
<cut>
mkdir investigate-gcc-008e7397dad971c03c08fc1b0a4a98fddccaaed8
cd investigate-gcc-008e7397dad971c03c08fc1b0a4a98fddccaaed8
# Fetch scripts
git clone https://git.linaro.org/toolchain/jenkins-scripts
# Fetch manifests and test.sh script
mkdir -p artifacts/manifests
curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/manifests/build-baseline.sh --fail
curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/manifests/build-parameters.sh --fail
curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_apm-gnu-master-aarch64-spec2k6-Os_LTO/4/artifact/artifacts/test.sh --fail
chmod +x artifacts/test.sh
# Reproduce the baseline build (build all pre-requisites)
./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh
# Save baseline build state (which is then restored in artifacts/test.sh)
mkdir -p ./bisect
rsync -a --del --delete-excluded --exclude /bisect/ --exclude /artifacts/ --exclude /gcc/ ./ ./bisect/baseline/
cd gcc
# Reproduce first_bad build
git checkout --detach 008e7397dad971c03c08fc1b0a4a98fddccaaed8
../artifacts/test.sh
# Reproduce last_good build
git checkout --detach 0de8c2f8104b74f46e63d0d5d7b9e8fd3f04bb98
../artifacts/test.sh
cd ..
</cut>
Full commit (up to 1000 lines):
<cut>
commit 008e7397dad971c03c08fc1b0a4a98fddccaaed8
Author: Jan Hubicka <hubicka@ucw.cz>
Date: Mon Oct 11 18:43:26 2021 +0200
Commonize ipa-pta constraint generation for calls
Commonize the three paths to produce constraints for function call
and makes it more flexible, so we can implement new features more easily. Main
idea is to not special case pure and const since we can now describe all of
pure/const via their EAF flags (implicit_const_eaf_flags and
implicit_pure_eaf_flags) and info on existence of global memory loads/stores in
function which is readily available in the modref tree.
While rewriting the function, I dropped some of optimizations in the way we
generate constraints. Some of them we may want to add back, but I think the
constraint solver should be fast to get rid of them quickly, so it looks like
bit of premature optimization.
We now always produce one additional PTA variable (callescape) for things that
escape into function call and thus can be stored to parameters or global memory
(if modified). This is no longer the same as global escape in case function is
not reading global memory. It is also not same as call use, since we now
understand the fact that interposable functions may use parameter in a way that
is not releavnt for PTA (so we can not optimize out stores initializing the
memory, but we can be safe about fact that pointers stored does not escape).
Compared to previous code we now handle correctly EAF_NOT_RETURNED in all cases
(previously we did so only when all parameters had the flag) and also handle
NOCLOBBER in more cases (since we make difference between global escape and
call escape). Because I commonized code handling args and static chains, we
could now easily extend modref to also track flags for static chain and return
slot which I plan to do next.
Otherwise I put some effort into producing constraints that produce similar
solutions as before (so it is harder to debug differences). For example if
global memory is written one can simply move callescape to escape rather then
making everything escape by its own constraints, but it affects ipa-pta
testcases.
gcc/ChangeLog:
* ipa-modref-tree.h (modref_tree::global_access_p): New member
function.
* ipa-modref.c:
(implicint_const_eaf_flags,implicit_pure_eaf_flags,
ignore_stores_eaf_flags): Move to ipa-modref.h
(remove_useless_eaf_flags): Remove early exit on NOCLOBBER.
(modref_summary::global_memory_read_p): New member function.
(modref_summary::global_memory_written_p): New member function.
* ipa-modref.h (modref_summary::global_memory_read_p,
modref_summary::global_memory_written_p): Declare.
(implicint_const_eaf_flags,implicit_pure_eaf_flags,
ignore_stores_eaf_flags): move here.
* tree-ssa-structalias.c: Include ipa-modref-tree.h, ipa-modref.h
and attr-fnspec.h.
(handle_rhs_call): Rewrite.
(handle_call_arg): New function.
(determine_global_memory_access): New function.
(handle_const_call): Remove
(handle_pure_call): Remove
(find_func_aliases_for_call): Update use of handle_rhs_call.
(compute_points_to_sets): Handle global memory acccesses
selectively
gcc/testsuite/ChangeLog:
* gcc.dg/torture/ssa-pta-fn-1.c: Fix template; add noipa.
* gcc.dg/tree-ssa/pta-callused.c: Fix template.
---
gcc/ipa-modref-tree.h | 32 +-
gcc/ipa-modref.c | 39 +-
gcc/ipa-modref.h | 13 +
gcc/testsuite/gcc.dg/torture/ssa-pta-fn-1.c | 8 +-
gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c | 2 +-
gcc/tree-ssa-structalias.c | 518 +++++++++++++--------------
6 files changed, 317 insertions(+), 295 deletions(-)
diff --git a/gcc/ipa-modref-tree.h b/gcc/ipa-modref-tree.h
index 8e9b89b3e2c..52f225b1aae 100644
--- a/gcc/ipa-modref-tree.h
+++ b/gcc/ipa-modref-tree.h
@@ -148,7 +148,8 @@ struct GTY(()) modref_access_node
poly_int64 offset1, poly_int64 size1, poly_int64 max_size1,
bool record_adjustments)
{
- if (known_eq (offset, offset1)
+ if (known_eq (parm_offset, parm_offset1)
+ && known_eq (offset, offset1)
&& known_eq (size, size1)
&& known_eq (max_size, max_size1))
return;
@@ -577,6 +578,10 @@ struct GTY((user)) modref_ref_node
}
(*accesses)[best1].forced_merge (best2 < 0 ? a : (*accesses)[best2],
record_adjustments);
+ /* CHeck that merging indeed merged ranges. */
+ gcc_checking_assert ((*accesses)[best1].contains (best2 < 0 ? a : (*accesses)[best2]));
+ /*if (best2 >= 0)
+ accesses->unordered_remove (best2);*/
if (!(*accesses)[best1].useful_p ())
{
collapse ();
@@ -1012,6 +1017,31 @@ struct GTY((user)) modref_tree
return NULL;
}
+ /* Return true if tree contains access to global memory. */
+ bool global_access_p ()
+ {
+ size_t i, j, k;
+ modref_base_node <T> *base_node;
+ modref_ref_node <T> *ref_node;
+ modref_access_node *access_node;
+ if (every_base)
+ return true;
+ FOR_EACH_VEC_SAFE_ELT (bases, i, base_node)
+ {
+ if (base_node->every_ref)
+ return true;
+ FOR_EACH_VEC_SAFE_ELT (base_node->refs, j, ref_node)
+ {
+ if (ref_node->every_access)
+ return true;
+ FOR_EACH_VEC_SAFE_ELT (ref_node->accesses, k, access_node)
+ if (access_node->parm_index < 0)
+ return true;
+ }
+ }
+ return false;
+ }
+
/* Return ggc allocated instance. We explicitly call destructors via
ggc_delete and do not want finalizers to be registered and
called at the garbage collection time. */
diff --git a/gcc/ipa-modref.c b/gcc/ipa-modref.c
index 6d49cc1410e..0bbec8df0a2 100644
--- a/gcc/ipa-modref.c
+++ b/gcc/ipa-modref.c
@@ -85,6 +85,7 @@ along with GCC; see the file COPYING3. If not see
#include "ssa-iterators.h"
#include "stringpool.h"
#include "tree-ssanames.h"
+#include "attribs.h"
namespace {
@@ -280,17 +281,6 @@ modref_summary::~modref_summary ()
ggc_delete (stores);
}
-/* All flags that are implied by the ECF_CONST functions. */
-const int implicit_const_eaf_flags = EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE
- | EAF_NODIRECTESCAPE | EAF_NOREAD;
-/* All flags that are implied by the ECF_PURE function. */
-const int implicit_pure_eaf_flags = EAF_NOCLOBBER | EAF_NOESCAPE
- | EAF_NODIRECTESCAPE;
-/* All flags implied when we know we can ignore stores (i.e. when handling
- call to noreturn). */
-const int ignore_stores_eaf_flags = EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE
- | EAF_NODIRECTESCAPE;
-
/* Remove all flags from EAF_FLAGS that are implied by ECF_FLAGS and not
useful to track. If returns_void is true moreover clear
EAF_NOT_RETURNED. */
@@ -305,10 +295,6 @@ remove_useless_eaf_flags (int eaf_flags, int ecf_flags, bool returns_void)
eaf_flags &= ~implicit_pure_eaf_flags;
else if ((ecf_flags & ECF_NORETURN) || returns_void)
eaf_flags &= ~EAF_NOT_RETURNED;
- /* Only NOCLOBBER or DIRECT flags alone are not useful (see comments
- in tree-ssa-alias.c). Give up earlier. */
- if ((eaf_flags & ~(EAF_DIRECT | EAF_NOCLOBBER)) == 0)
- return 0;
return eaf_flags;
}
@@ -345,6 +331,26 @@ modref_summary::useful_p (int ecf_flags, bool check_flags)
return stores && !stores->every_base;
}
+/* Return true if global memory is read
+ (that is loads summary contains global memory access). */
+bool
+modref_summary::global_memory_read_p ()
+{
+ if (!loads)
+ return true;
+ return loads->global_access_p ();
+}
+
+/* Return true if global memory is written. */
+bool
+modref_summary::global_memory_written_p ()
+{
+ if (!stores)
+ return true;
+ return stores->global_access_p ();
+}
+
+
/* Single function summary used for LTO. */
typedef modref_tree <tree> modref_records_lto;
@@ -2016,7 +2022,8 @@ analyze_function (function *f, bool ipa)
DECL_PURE_P (current_function_decl) ? " (pure)" : "");
/* Don't analyze this function if it's compiled with -fno-strict-aliasing. */
- if (!flag_ipa_modref)
+ if (!flag_ipa_modref
+ || lookup_attribute ("noipa", DECL_ATTRIBUTES (current_function_decl)))
return;
/* Compute no-LTO summaries when local optimization is going to happen. */
diff --git a/gcc/ipa-modref.h b/gcc/ipa-modref.h
index 540fdea8efa..5afa3aa439f 100644
--- a/gcc/ipa-modref.h
+++ b/gcc/ipa-modref.h
@@ -37,10 +37,23 @@ struct GTY(()) modref_summary
~modref_summary ();
void dump (FILE *);
bool useful_p (int ecf_flags, bool check_flags = true);
+ bool global_memory_read_p ();
+ bool global_memory_written_p ();
};
modref_summary *get_modref_function_summary (cgraph_node *func);
void ipa_modref_c_finalize ();
void ipa_merge_modref_summary_after_inlining (cgraph_edge *e);
+/* All flags that are implied by the ECF_CONST functions. */
+static const int implicit_const_eaf_flags = EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE
+ | EAF_NODIRECTESCAPE | EAF_NOREAD;
+/* All flags that are implied by the ECF_PURE function. */
+static const int implicit_pure_eaf_flags = EAF_NOCLOBBER | EAF_NOESCAPE
+ | EAF_NODIRECTESCAPE;
+/* All flags implied when we know we can ignore stores (i.e. when handling
+ call to noreturn). */
+static const int ignore_stores_eaf_flags = EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE
+ | EAF_NODIRECTESCAPE;
+
#endif
diff --git a/gcc/testsuite/gcc.dg/torture/ssa-pta-fn-1.c b/gcc/testsuite/gcc.dg/torture/ssa-pta-fn-1.c
index 1f30467b98e..de019a7ecaf 100644
--- a/gcc/testsuite/gcc.dg/torture/ssa-pta-fn-1.c
+++ b/gcc/testsuite/gcc.dg/torture/ssa-pta-fn-1.c
@@ -6,13 +6,13 @@ extern void abort (void);
int *g;
int dummy;
-int * __attribute__((noinline,const))
+int * __attribute__((noinline,const,noipa))
foo_const(int *p) { return p; }
-int * __attribute__((noinline,pure))
+int * __attribute__((noinline,pure,noipa))
foo_pure(int *p) { return p + dummy; }
-int * __attribute__((noinline))
+int * __attribute__((noinline,noipa))
foo_normal(int *p) { g = p; return p; }
void test_const(void)
@@ -58,4 +58,4 @@ int main()
/* { dg-final { scan-tree-dump "q_const_. = { NONLOCAL i }" "alias" } } */
/* { dg-final { scan-tree-dump "q_pure_. = { ESCAPED NONLOCAL i }" "alias" } } */
-/* { dg-final { scan-tree-dump "q_normal_. = { ESCAPED NONLOCAL }" "alias" } } */
+/* { dg-final { scan-tree-dump "q_normal_. = { ESCAPED NONLOCAL i }" "alias" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c b/gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c
index cb85ec18bbc..aa639b45dc2 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pta-callused.c
@@ -22,5 +22,5 @@ int bar (int b)
return *foo (&q);
}
-/* { dg-final { scan-tree-dump "CALLUSED\\(\[0-9\]+\\) = { f.* i q }" "alias" } } */
+/* { dg-final { scan-tree-dump "CALLUSED\\(\[0-9\]+\\) = { NONLOCAL f.* i q }" "alias" } } */
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index 0b8a81ff113..6f12a66ee0d 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -44,6 +44,9 @@
#include "tree-ssa.h"
#include "tree-cfg.h"
#include "gimple-range.h"
+#include "ipa-modref-tree.h"
+#include "ipa-modref.h"
+#include "attr-fnspec.h"
/* The idea behind this analyzer is to generate set constraints from the
program, then solve the resulting constraints in order to generate the
@@ -4048,98 +4051,203 @@ get_function_part_constraint (varinfo_t fi, unsigned part)
return c;
}
-/* For non-IPA mode, generate constraints necessary for a call on the
- RHS. */
+/* Produce constraints for argument ARG of call STMT with eaf flags
+ FLAGS. RESULTS is array holding constraints for return value.
+ CALLESCAPE_ID is variable where call loocal escapes are added.
+ WRITES_GLOVEL_MEMORY is true if callee may write global memory. */
static void
-handle_rhs_call (gcall *stmt, vec<ce_s> *results)
-{
- struct constraint_expr rhsc;
- unsigned i;
- bool returns_uses = false;
+handle_call_arg (gcall *stmt, tree arg, vec<ce_s> *results, int flags,
+ int callescape_id, bool writes_global_memory)
+{
+ /* If the argument is not used we can ignore it.
+ Similarly argument is invisile for us if it not clobbered, does not
+ escape, is not read and can not be returned. */
+ if ((flags & EAF_UNUSED)
+ || ((flags & (EAF_NOCLOBBER | EAF_NOESCAPE | EAF_NOREAD
+ | EAF_NOT_RETURNED))
+ == (EAF_NOCLOBBER | EAF_NOESCAPE | EAF_NOREAD
+ | EAF_NOT_RETURNED)))
+ return;
+
+ varinfo_t tem = new_var_info (NULL_TREE, "callarg", true);
+ tem->is_reg_var = true;
+ make_constraint_to (tem->id, arg);
+ make_any_offset_constraints (tem);
+
+ if (!(flags & EAF_DIRECT))
+ make_transitive_closure_constraints (tem);
- for (i = 0; i < gimple_call_num_args (stmt); ++i)
+ if (!(flags & EAF_NOT_RETURNED))
{
- tree arg = gimple_call_arg (stmt, i);
- int flags = gimple_call_arg_flags (stmt, i);
+ struct constraint_expr cexpr;
+ cexpr.var = tem->id;
+ cexpr.type = SCALAR;
+ cexpr.offset = 0;
+ results->safe_push (cexpr);
+ }
- /* If the argument is not used we can ignore it.
- Similarly argument is invisile for us if it not clobbered, does not
- escape, is not read and can not be returned. */
- if ((flags & EAF_UNUSED)
- || ((flags & (EAF_NOCLOBBER | EAF_NOESCAPE | EAF_NOREAD
- | EAF_NOT_RETURNED))
- == (EAF_NOCLOBBER | EAF_NOESCAPE | EAF_NOREAD
- | EAF_NOT_RETURNED)))
- continue;
+ if (!(flags & EAF_NOREAD))
+ {
+ varinfo_t uses = get_call_use_vi (stmt);
+ make_copy_constraint (uses, tem->id);
+ }
- /* As we compute ESCAPED context-insensitive we do not gain
- any precision with just EAF_NOCLOBBER but not EAF_NOESCAPE
- set. The argument would still get clobbered through the
- escape solution. */
- if ((flags & EAF_NOCLOBBER)
- && (flags & (EAF_NOESCAPE | EAF_NODIRECTESCAPE)))
- {
- varinfo_t uses = get_call_use_vi (stmt);
- varinfo_t tem = new_var_info (NULL_TREE, "callarg", true);
- tem->is_reg_var = true;
- make_constraint_to (tem->id, arg);
- make_any_offset_constraints (tem);
- if (!(flags & EAF_DIRECT))
- make_transitive_closure_constraints (tem);
- make_copy_constraint (uses, tem->id);
- /* TODO: This is overly conservative when some parameters are
- returned while others are not. */
- if (!(flags & EAF_NOT_RETURNED))
- returns_uses = true;
- if (!(flags & (EAF_NOESCAPE | EAF_DIRECT)))
- make_indirect_escape_constraint (tem);
- }
- else if (flags & (EAF_NOESCAPE | EAF_NODIRECTESCAPE))
+ if (!(flags & EAF_NOCLOBBER))
+ {
+ struct constraint_expr lhs, rhs;
+
+ /* *arg = callescape. */
+ lhs.type = DEREF;
+ lhs.var = tem->id;
+ lhs.offset = 0;
+
+ rhs.type = SCALAR;
+ rhs.var = callescape_id;
+ rhs.offset = 0;
+ process_constraint (new_constraint (lhs, rhs));
+
+ /* callclobbered = arg. */
+ make_copy_constraint (get_call_clobber_vi (stmt), tem->id);
+ }
+
+ if (!(flags & (EAF_NOESCAPE | EAF_NODIRECTESCAPE)))
+ {
+ struct constraint_expr lhs, rhs;
+
+ /* callescape = arg; */
+ lhs.var = callescape_id;
+ lhs.offset = 0;
+ lhs.type = SCALAR;
+
+ rhs.var = tem->id;
+ rhs.offset = 0;
+ rhs.type = SCALAR;
+ process_constraint (new_constraint (lhs, rhs));
+
+ if (writes_global_memory)
+ make_escape_constraint (arg);
+ }
+ else if (!(flags & EAF_NOESCAPE))
+ {
+ struct constraint_expr lhs, rhs;
+
+ /* callescape = *(arg + UNKNOWN); */
+ lhs.var = callescape_id;
+ lhs.offset = 0;
+ lhs.type = SCALAR;
+
+ rhs.var = tem->id;
+ rhs.offset = UNKNOWN_OFFSET;
+ rhs.type = DEREF;
+ process_constraint (new_constraint (lhs, rhs));
+
+ if (writes_global_memory)
+ make_indirect_escape_constraint (tem);
+ }
+}
+
+/* Determine global memory access of call STMT and update
+ WRITES_GLOBAL_MEMORY, READS_GLOBAL_MEMORY and USES_GLOBAL_MEMORY. */
+
+static void
+determine_global_memory_access (gcall *stmt,
+ bool *writes_global_memory,
+ bool *reads_global_memory,
+ bool *uses_global_memory)
+{
+ tree callee;
+ cgraph_node *node;
+ modref_summary *summary;
+
+ /* We need to detrmine reads to set uses. */
+ gcc_assert (!uses_global_memory || reads_global_memory);
+
+ if ((callee = gimple_call_fndecl (stmt)) != NULL_TREE
+ && (node = cgraph_node::get (callee)) != NULL
+ && (summary = get_modref_function_summary (node)))
+ {
+ if (writes_global_memory && *writes_global_memory)
+ *writes_global_memory = summary->global_memory_written_p ();
+ if (reads_global_memory && *reads_global_memory)
+ *reads_global_memory = summary->global_memory_read_p ();
+ if (reads_global_memory && uses_global_memory
+ && !*reads_global_memory && node->binds_to_current_def_p ())
+ *uses_global_memory = false;
+ }
+ if ((writes_global_memory && *writes_global_memory)
+ || (uses_global_memory && *uses_global_memory)
+ || (reads_global_memory && *reads_global_memory))
+ {
+ attr_fnspec fnspec = gimple_call_fnspec (stmt);
+ if (fnspec.known_p ())
{
- struct constraint_expr lhs, rhs;
- varinfo_t uses = get_call_use_vi (stmt);
- varinfo_t clobbers = get_call_clobber_vi (stmt);
- varinfo_t tem = new_var_info (NULL_TREE, "callarg", true);
- tem->is_reg_var = true;
- make_constraint_to (tem->id, arg);
- make_any_offset_constraints (tem);
- if (!(flags & EAF_DIRECT))
- make_transitive_closure_constraints (tem);
- make_copy_constraint (uses, tem->id);
- if (!(flags & EAF_NOT_RETURNED))
- returns_uses = true;
- make_copy_constraint (clobbers, tem->id);
- /* Add *tem = nonlocal, do not add *tem = callused as
- EAF_NOESCAPE parameters do not escape to other parameters
- and all other uses appear in NONLOCAL as well. */
- lhs.type = DEREF;
- lhs.var = tem->id;
- lhs.offset = 0;
- rhs.type = SCALAR;
- rhs.var = nonlocal_id;
- rhs.offset = 0;
- process_constraint (new_constraint (lhs, rhs));
- if (!(flags & (EAF_NOESCAPE | EAF_DIRECT)))
- make_indirect_escape_constraint (tem);
+ if (writes_global_memory
+ && !fnspec.global_memory_written_p ())
+ *writes_global_memory = false;
+ if (reads_global_memory && !fnspec.global_memory_read_p ())
+ {
+ *reads_global_memory = false;
+ if (uses_global_memory)
+ *uses_global_memory = false;
+ }
}
- else
- make_escape_constraint (arg);
}
+}
+
+/* For non-IPA mode, generate constraints necessary for a call on the
+ RHS and collect return value constraint to RESULTS to be used later in
+ handle_lhs_call.
+
+ IMPLICIT_EAF_FLAGS are added to each function argument. If
+ WRITES_GLOBAL_MEMORY is true function is assumed to possibly write to global
+ memory. Similar for READS_GLOBAL_MEMORY. */
+
+static void
+handle_rhs_call (gcall *stmt, vec<ce_s> *results,
+ int implicit_eaf_flags,
+ bool writes_global_memory,
+ bool reads_global_memory)
+{
+ determine_global_memory_access (stmt, &writes_global_memory,
+ &reads_global_memory,
+ NULL);
+
+ varinfo_t callescape = new_var_info (NULL_TREE, "callescape", true);
+
+ /* If function can use global memory, add it to callescape
+ and to possible return values. If not we can still use/return addresses
+ of global symbols. */
+ struct constraint_expr lhs, rhs;
+
+ lhs.type = SCALAR;
+ lhs.var = callescape->id;
+ lhs.offset = 0;
+
+ rhs.type = reads_global_memory ? SCALAR : ADDRESSOF;
+ rhs.var = nonlocal_id;
+ rhs.offset = 0;
- /* If we added to the calls uses solution make sure we account for
- pointers to it to be returned. */
- if (returns_uses)
+ process_constraint (new_constraint (lhs, rhs));
+ results->safe_push (rhs);
+
+ varinfo_t uses = get_call_use_vi (stmt);
+ make_copy_constraint (uses, callescape->id);
+
+ for (unsigned i = 0; i < gimple_call_num_args (stmt); ++i)
{
- rhsc.var = get_call_use_vi (stmt)->id;
- rhsc.offset = UNKNOWN_OFFSET;
- rhsc.type = SCALAR;
- results->safe_push (rhsc);
+ tree arg = gimple_call_arg (stmt, i);
+ int flags = gimple_call_arg_flags (stmt, i);
+ handle_call_arg (stmt, arg, results,
+ flags | implicit_eaf_flags,
+ callescape->id, writes_global_memory);
}
/* The static chain escapes as well. */
if (gimple_call_chain (stmt))
- make_escape_constraint (gimple_call_chain (stmt));
+ handle_call_arg (stmt, gimple_call_chain (stmt), results,
+ implicit_eaf_flags,
+ callescape->id, writes_global_memory);
/* And if we applied NRV the address of the return slot escapes as well. */
if (gimple_call_return_slot_opt_p (stmt)
@@ -4147,20 +4255,17 @@ handle_rhs_call (gcall *stmt, vec<ce_s> *results)
&& TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
{
auto_vec<ce_s> tmpc;
- struct constraint_expr lhsc, *c;
+ struct constraint_expr *c;
+ unsigned i;
+
get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc);
- lhsc.var = escaped_id;
- lhsc.offset = 0;
- lhsc.type = SCALAR;
+
+ make_constraints_to (callescape->id, tmpc);
+ if (writes_global_memory)
+ make_constraints_to (escaped_id, tmpc);
FOR_EACH_VEC_ELT (tmpc, i, c)
- process_constraint (new_constraint (lhsc, *c));
+ results->safe_push (*c);
}
-
- /* Regular functions return nonlocal memory. */
- rhsc.var = nonlocal_id;
- rhsc.offset = 0;
- rhsc.type = SCALAR;
- results->safe_push (rhsc);
}
/* For non-IPA mode, generate constraints necessary for a call
@@ -4227,160 +4332,6 @@ handle_lhs_call (gcall *stmt, tree lhs, int flags, vec<ce_s> &rhsc,
process_all_all_constraints (lhsc, rhsc);
}
-/* For non-IPA mode, generate constraints necessary for a call of a
- const function that returns a pointer in the statement STMT. */
-
-static void
-handle_const_call (gcall *stmt, vec<ce_s> *results)
-{
- struct constraint_expr rhsc;
- unsigned int k;
- bool need_uses = false;
-
- /* Treat nested const functions the same as pure functions as far
- as the static chain is concerned. */
- if (gimple_call_chain (stmt))
- {
- varinfo_t uses = get_call_use_vi (stmt);
- make_constraint_to (uses->id, gimple_call_chain (stmt));
- need_uses = true;
- }
-
- /* And if we applied NRV the address of the return slot escapes as well. */
- if (gimple_call_return_slot_opt_p (stmt)
- && gimple_call_lhs (stmt) != NULL_TREE
- && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
- {
- varinfo_t uses = get_call_use_vi (stmt);
- auto_vec<ce_s> tmpc;
- get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc);
- make_constraints_to (uses->id, tmpc);
- need_uses = true;
- }
-
- if (need_uses)
- {
- varinfo_t uses = get_call_use_vi (stmt);
- make_any_offset_constraints (uses);
- make_transitive_closure_constraints (uses);
- rhsc.var = uses->id;
- rhsc.offset = 0;
- rhsc.type = SCALAR;
- results->safe_push (rhsc);
- }
-
- /* May return offsetted arguments. */
- varinfo_t tem = NULL;
- for (k = 0; k < gimple_call_num_args (stmt); ++k)
- {
- int flags = gimple_call_arg_flags (stmt, k);
-
- /* If the argument is not used or not returned we can ignore it. */
- if (flags & (EAF_UNUSED | EAF_NOT_RETURNED))
- continue;
- if (!tem)
- {
- tem = new_var_info (NULL_TREE, "callarg", true);
- tem->is_reg_var = true;
- }
- tree arg = gimple_call_arg (stmt, k);
- auto_vec<ce_s> argc;
- get_constraint_for_rhs (arg, &argc);
- make_constraints_to (tem->id, argc);
- }
- if (tem)
- {
- ce_s ce;
- ce.type = SCALAR;
- ce.var = tem->id;
- ce.offset = UNKNOWN_OFFSET;
- results->safe_push (ce);
- }
-
- /* May return addresses of globals. */
- rhsc.var = nonlocal_id;
- rhsc.offset = 0;
- rhsc.type = ADDRESSOF;
- results->safe_push (rhsc);
-}
-
-/* For non-IPA mode, generate constraints necessary for a call to a
- pure function in statement STMT. */
-
-static void
-handle_pure_call (gcall *stmt, vec<ce_s> *results)
-{
- struct constraint_expr rhsc;
- unsigned i;
- varinfo_t uses = NULL;
- bool record_uses = false;
-
- /* Memory reached from pointer arguments is call-used. */
- for (i = 0; i < gimple_call_num_args (stmt); ++i)
- {
- tree arg = gimple_call_arg (stmt, i);
- int flags = gimple_call_arg_flags (stmt, i);
-
- /* If the argument is not used we can ignore it. */
- if ((flags & EAF_UNUSED)
- || (flags & (EAF_NOT_RETURNED | EAF_NOREAD))
- == (EAF_NOT_RETURNED | EAF_NOREAD))
- continue;
- if (!uses)
- {
- uses = get_call_use_vi (stmt);
- make_any_offset_constraints (uses);
- make_transitive_closure_constraints (uses);
- }
- make_constraint_to (uses->id, arg);
- if (!(flags & EAF_NOT_RETURNED))
- record_uses = true;
- }
-
- /* The static chain is used as well. */
- if (gimple_call_chain (stmt))
- {
- if (!uses)
- {
- uses = get_call_use_vi (stmt);
- make_any_offset_constraints (uses);
- make_transitive_closure_constraints (uses);
- }
- make_constraint_to (uses->id, gimple_call_chain (stmt));
- record_uses = true;
- }
-
- /* And if we applied NRV the address of the return slot. */
- if (gimple_call_return_slot_opt_p (stmt)
- && gimple_call_lhs (stmt) != NULL_TREE
- && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
- {
- if (!uses)
- {
- uses = get_call_use_vi (stmt);
- make_any_offset_constraints (uses);
- make_transitive_closure_constraints (uses);
- }
- auto_vec<ce_s> tmpc;
- get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc);
- make_constraints_to (uses->id, tmpc);
- record_uses = true;
- }
-
- /* Pure functions may return call-used and nonlocal memory. */
- if (record_uses)
- {
- rhsc.var = uses->id;
- rhsc.offset = 0;
- rhsc.type = SCALAR;
- results->safe_push (rhsc);
- }
- rhsc.var = nonlocal_id;
- rhsc.offset = 0;
- rhsc.type = SCALAR;
- results->safe_push (rhsc);
-}
-
/* Return the varinfo for the callee of CALL. */
@@ -4931,13 +4882,13 @@ find_func_aliases_for_call (struct function *fn, gcall *t)
if (flags & (ECF_CONST|ECF_NOVOPS))
{
if (gimple_call_lhs (t))
- handle_const_call (t, &rhsc);
+ handle_rhs_call (t, &rhsc, implicit_const_eaf_flags, false, false);
}
/* Pure functions can return addresses in and of memory
reachable from their arguments, but they are not an escape
point for reachable memory of their arguments. */
else if (flags & (ECF_PURE|ECF_LOOPING_CONST_OR_PURE))
- handle_pure_call (t, &rhsc);
+ handle_rhs_call (t, &rhsc, implicit_pure_eaf_flags, true, false);
/* If the call is to a replaceable operator delete and results
from a delete expression as opposed to a direct call to
such operator, then the effects for PTA (in particular
@@ -4947,7 +4898,7 @@ find_func_aliases_for_call (struct function *fn, gcall *t)
&& gimple_call_from_new_or_delete (t))
;
else
- handle_rhs_call (t, &rhsc);
+ handle_rhs_call (t, &rhsc, 0, true, true);
if (gimple_call_lhs (t))
handle_lhs_call (t, gimple_call_lhs (t),
gimple_call_return_flags (t), rhsc, fndecl);
@@ -7582,43 +7533,64 @@ compute_points_to_sets (void)
pt = gimple_call_use_set (stmt);
if (gimple_call_flags (stmt) & ECF_CONST)
memset (pt, 0, sizeof (struct pt_solution));
- else if ((vi = lookup_call_use_vi (stmt)) != NULL)
- {
- *pt = find_what_var_points_to (cfun->decl, vi);
- /* Escaped (and thus nonlocal) variables are always
- implicitly used by calls. */
- /* ??? ESCAPED can be empty even though NONLOCAL
- always escaped. */
- pt->nonlocal = 1;
- pt->escaped = 1;
- }
else
{
- /* If there is nothing special about this call then
- we have made everything that is used also escape. */
- *pt = cfun->gimple_df->escaped;
- pt->nonlocal = 1;
+ bool uses_global_memory = true;
+ bool reads_global_memory = true;
+
+ determine_global_memory_access (stmt, NULL,
+ &reads_global_memory,
+ &uses_global_memory);
+ if (!uses_global_memory)
+ ;
+ else if ((vi = lookup_call_use_vi (stmt)) != NULL)
+ {
+ *pt = find_what_var_points_to (cfun->decl, vi);
+ /* Escaped (and thus nonlocal) variables are always
+ implicitly used by calls. */
+ /* ??? ESCAPED can be empty even though NONLOCAL
+ always escaped. */
+ pt->nonlocal = uses_global_memory;
+ pt->escaped = uses_global_memory;
+ }
+ else if (uses_global_memory)
+ {
+ /* If there is nothing special about this call then
+ we have made everything that is used also escape. */
+ *pt = cfun->gimple_df->escaped;
+ pt->nonlocal = 1;
+ }
}
pt = gimple_call_clobber_set (stmt);
if (gimple_call_flags (stmt) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
memset (pt, 0, sizeof (struct pt_solution));
- else if ((vi = lookup_call_clobber_vi (stmt)) != NULL)
- {
- *pt = find_what_var_points_to (cfun->decl, vi);
- /* Escaped (and thus nonlocal) variables are always
- implicitly clobbered by calls. */
- /* ??? ESCAPED can be empty even though NONLOCAL
- always escaped. */
- pt->nonlocal = 1;
- pt->escaped = 1;
- }
else
{
- /* If there is nothing special about this call then
- we have made everything that is used also escape. */
- *pt = cfun->gimple_df->escaped;
- pt->nonlocal = 1;
+ bool writes_global_memory = true;
+
+ determine_global_memory_access (stmt, &writes_global_memory,
+ NULL, NULL);
+
+ if (!writes_global_memory)
+ ;
+ else if ((vi = lookup_call_clobber_vi (stmt)) != NULL)
+ {
+ *pt = find_what_var_points_to (cfun->decl, vi);
+ /* Escaped (and thus nonlocal) variables are always
+ implicitly clobbered by calls. */
+ /* ??? ESCAPED can be empty even though NONLOCAL
+ always escaped. */
+ pt->nonlocal = writes_global_memory;
+ pt->escaped = writes_global_memory;
+ }
+ else if (writes_global_memory)
+ {
+ /* If there is nothing special about this call then
+ we have made everything that is used also escape. */
+ *pt = cfun->gimple_df->escaped;
+ pt->nonlocal = 1;
+ }
}
}
}
</cut>
>From hjl@sc.intel.com Thu Oct 14 15:39:54 2021
Return-Path: <hjl@sc.intel.com>
X-Original-To: gcc-regression@gcc.gnu.org
Delivered-To: gcc-regression@gcc.gnu.org
Received: from mga14.intel.com (mga14.intel.com [192.55.52.115])
by sourceware.org (Postfix) with ESMTPS id D6609385840F
for <gcc-regression@gcc.gnu.org>; Thu, 14 Oct 2021 15:39:52 +0000 (GMT)
DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org D6609385840F
X-IronPort-AV: E=McAfee;i="6200,9189,10137"; a="227986766"
X-IronPort-AV: E=Sophos;i="5.85,372,1624345200"; d="scan'208";a="227986766"
Received: from orsmga003.jf.intel.com ([10.7.209.27])
by fmsmga103.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384;
14 Oct 2021 08:39:51 -0700
X-ExtLoop1: 1
X-IronPort-AV: E=Sophos;i="5.85,372,1624345200"; d="scan'208";a="442864915"
Received: from scymds02.sc.intel.com ([10.82.73.244])
by orsmga003.jf.intel.com with ESMTP; 14 Oct 2021 08:39:51 -0700
Received: from gnu-clx-1.sc.intel.com (gnu-clx-1.sc.intel.com [172.25.70.216])
by scymds02.sc.intel.com with ESMTP id 19EFdpcb013516;
Thu, 14 Oct 2021 08:39:51 -0700
Received: by gnu-clx-1.sc.intel.com (Postfix, from userid 1000)
id 489F43E001F; Thu, 14 Oct 2021 08:39:51 -0700 (PDT)
Date: Thu, 14 Oct 2021 08:39:51 -0700
To: skpgkp2@gmail.com, hjl.tools@gmail.com, gcc-regression@gcc.gnu.org
Subject: Regressions on native/master at commit r12-4398 vs commit
r12-4383 on Linux/x86_64
User-Agent: Heirloom mailx 12.5 7/5/10
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Message-Id: <20211014153951.489F43E001F@gnu-clx-1.sc.intel.com>
From: "H. J. Lu" <hjl@sc.intel.com>
X-Spam-Status: No, score=-3469.9 required=5.0 tests=BAYES_00, KAM_DMARC_STATUS,
KAM_LAZY_DOMAIN_SECURITY, KAM_NUMSUBJECT, KAM_SHORT, SPF_HELO_NONE, SPF_NONE,
TXREP autolearn=no autolearn_force=no version=3.4.4
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on
server2.sourceware.org
X-BeenThere: gcc-regression@gcc.gnu.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: Gcc-regression mailing list <gcc-regression.gcc.gnu.org>
List-Unsubscribe: <https://gcc.gnu.org/mailman/options/gcc-regression>,
<mailto:gcc-regression-request@gcc.gnu.org?subject=unsubscribe>
List-Archive: <https://gcc.gnu.org/pipermail/gcc-regression/>
List-Post: <mailto:gcc-regression@gcc.gnu.org>
List-Help: <mailto:gcc-regression-request@gcc.gnu.org?subject=help>
List-Subscribe: <https://gcc.gnu.org/mailman/listinfo/gcc-regression>,
<mailto:gcc-regression-request@gcc.gnu.org?subject=subscribe>
X-List-Received-Date: Thu, 14 Oct 2021 15:39:54 -0000
New failures:
FAIL: gcc.dg/guality/pr54200.c -Og -DPREVENT_OPTIMIZATION line 20 z == 3
FAIL: gcc.dg/guality/pr54200.c -Og -DPREVENT_OPTIMIZATION line 20 z == 3
FAIL: gcc.target/i386/avx512fp16-vfcmaddcsh-1a.c scan-assembler-times vblendvps[ \\t]+[^{\n]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+(?:\n|[ \\t]+#) 2
FAIL: gcc.target/i386/avx512fp16-vfcmaddcsh-1a.c scan-assembler-times vblendvps[ \\t]+[^{\n]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+(?:\n|[ \\t]+#) 2
FAIL: gcc.target/i386/avx512fp16-vfcmaddcsh-1a.c scan-assembler-times vblendvps[ \\t]+[^{\n]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+(?:\n|[ \\t]+#) 2
FAIL: gcc.target/i386/avx512fp16-vfmaddcsh-1a.c scan-assembler-times vblendvps[ \\t]+[^{\n]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+(?:\n|[ \\t]+#) 2
FAIL: gcc.target/i386/avx512fp16-vfmaddcsh-1a.c scan-assembler-times vblendvps[ \\t]+[^{\n]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+(?:\n|[ \\t]+#) 2
FAIL: gcc.target/i386/avx512fp16-vfmaddcsh-1a.c scan-assembler-times vblendvps[ \\t]+[^{\n]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+[^\n\r]*%xmm[0-9]+(?:\n|[ \\t]+#) 2
New passes:
FAIL: gcc.dg/torture/pr69760.c -O2 -flto -fno-use-linker-plugin -flto-partition=none (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O2 -flto -fno-use-linker-plugin -flto-partition=none (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O2 -flto -fuse-linker-plugin -fno-fat-lto-objects (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O2 -flto -fuse-linker-plugin -fno-fat-lto-objects (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O2 (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O2 (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O3 -fomit-frame-pointer -funroll-loops -fpeel-loops -ftracer -finline-functions (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O3 -fomit-frame-pointer -funroll-loops -fpeel-loops -ftracer -finline-functions (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O3 -g (test for excess errors)
FAIL: gcc.dg/torture/pr69760.c -O3 -g (test for excess errors)
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2021-10-14 14:59 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-10-14 14:59 [TCWG CI] 450.soplex grew in size by 2% after gcc: Commonize ipa-pta constraint generation for calls ci_notify
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).