| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
These tests violated strict aliasing, fixed by using a union and
type punning through that.
2020-12-08 Jakub Jelinek <jakub@redhat.com>
* gcc.target/i386/avx512dq-vandnpd-2.c (CALC): Use union
to avoid aliasing violations.
* gcc.target/i386/avx512dq-vandnps-2.c (CALC): Likewise.
* gcc.target/i386/avx512dq-vandpd-2.c (CALC): Likewise.
* gcc.target/i386/avx512dq-vandps-2.c (CALC): Likewise.
* gcc.target/i386/avx512dq-vorpd-2.c (CALC): Likewise.
* gcc.target/i386/avx512dq-vorps-2.c (CALC): Likewise.
* gcc.target/i386/avx512dq-vxorpd-2.c (CALC): Likewise.
* gcc.target/i386/avx512dq-vxorps-2.c (CALC): Likewise.
|
|
This patch fixes two bugs in the -fopenmp-simd support. One is that
in C++ #pragma omp parallel master would actually create OMP_PARALLEL
in the IL, which is a big no-no for -fopenmp-simd, we should be creating
only the constructs -fopenmp-simd handles (mainly OMP_SIMD, OMP_LOOP which
is gimplified as simd in that case, declare simd/reduction and ordered simd).
The other bug was that #pragma omp master taskloop simd combined construct
contains simd and thus should be recognized as #pragma omp simd (with only
the simd applicable clauses), but as master wasn't included in
omp_pragmas_simd, we'd ignore it completely instead.
2020-12-08 Jakub Jelinek <jakub@redhat.com>
PR c++/98187
* c-pragma.c (omp_pragmas): Remove "master".
(omp_pragmas_simd): Add "master".
* parser.c (cp_parser_omp_parallel): For parallel master with
-fopenmp-simd only, just call cp_parser_omp_master instead of
wrapping it in OMP_PARALLEL.
* c-c++-common/gomp/pr98187.c: New test.
|
|
This adds a missing check.
2020-12-08 Richard Biener <rguenther@suse.de>
PR tree-optimization/98191
* tree-vect-slp.c (vect_slp_check_for_constructors): Do not
follow a non-SSA def chain.
* gcc.dg/torture/pr98191.c: New testcase.
|
|
This fixes sinking of loads when irreducible regions are involved
and the heuristics to find stores on the path along the sink
breaks down since that uses dominator queries.
2020-12-08 Richard Biener <rguenther@suse.de>
PR tree-optimization/97559
* tree-ssa-sink.c (statement_sink_location): Never ignore
PHIs on sink paths in irreducible regions.
* gcc.dg/torture/pr97559-1.c: New testcase.
* gcc.dg/torture/pr97559-2.c: Likewise.
|
|
gcc/
2020-12-08 Prathamesh Kulkarni <prathamesh.kulkarni@linaro.org>
PR target/97872
* gimple-isel.cc (gimple_expand_vec_cond_expr): Try to fold
x CMP y ? -1 : 0 to x CMP y.
gcc/testsuite/
2020-12-08 Prathamesh Kulkarni <prathamesh.kulkarni@linaro.org>
PR target/97872
* gcc.target/arm/pr97872.c: New test.
|
|
This adds a missing check for the first inserted value.
2020-12-08 Richard Biener <rguenther@suse.de>
PR tree-optimization/98180
* tree-vect-slp.c (vect_slp_check_for_constructors): Check the
first inserted value has a def.
|
|
This forces the scalarization of the testcase on PowerPC.
gcc/testsuite/ChangeLog:
PR target/96470
* gnat.dg/opt39.adb: Add dg-additional-options for PowerPC.
|
|
The very recent addition of the if_to_switch pass has partially disabled
the optimization added back in June to optimize_range_tests_to_bit_test,
as witnessed by the 3 new failures in the gnat.dg testsuite. It turns out
that both tree-ssa-reassoc.c and tree-switch-conversion.c can turn things
into bit tests so the optimization is added to bit_test_cluster::emit too.
The patch also contains a secondary optimization, whereby the full bit-test
sequence is sent to the folder before being gimplified in case there is only
one test, so that the optimal sequence (bt + jc on x86) can be emitted like
with optimize_range_tests_to_bit_test.
gcc/ChangeLog:
PR tree-optimization/96344
* tree-switch-conversion.c (bit_test_cluster::emit): Compute the
range only if an entry test is necessary. Merge the entry test in
the bit test when possible. Use PREC local variable consistently.
When there is only one test, do a single gimplification at the end.
|
|
We'll try to canonicalize the arch string for --with-arch,
and the script is written in python, however it will turns out
GCC require python to build for RISC-V port, it's not expect as
the GCC requirement.
So this patch is made this as optional, detect python and only use it
when it available, it won't break any functionality with out doing
canonicalization, just might build one more redundant multi-lib.
gcc/ChangeLog:
PR target/98152
* config.gcc (riscv*-*-*): Checking python, python3 or python2
is available, and skip doing with_arch canonicalize if no python
available.
|
|
Patch from Svante Signell.
Fixes PR go/98153
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/275939
|
|
|
|
To handle atomic loads correctly, we need to move the code that
drops qualifiers in lvalue conversion after the code that
handles atomics.
2020-12-07 Martin Uecker <muecker@gwdg.de>
gcc/c/
PR c/97981
* c-typeck.c (convert_lvalue_to_rvalue): Move the code
that drops qualifiers to the end of the function.
gcc/testsuite/
PR c/97981
* gcc.dg/pr97981.c: New test.
* gcc.dg/pr60195.c: Adapt test.
|
|
targets [PR98147]
The function that calls targetm.emit_call_builtin___clear_cache
asserts that each of the begin and end operands has either ptr_mode or
Pmode.
On most targets that is the same mode, but e.g. on aarch64 -mabi=ilp32
or a few others it is different. When a target has a clear cache
non-library handler, it will use create_address_operand which will do the
conversion to the right mode automatically, but when emitting a library
call, we just say the operands are ptr_mode even when they can be Pmode
too; in that case we need to convert explicitly.
2020-12-07 Jakub Jelinek <jakub@redhat.com>
PR target/98147
* builtins.c (default_emit_call_builtin___clear_cache): Call
convert_memory_address to ptr_mode on both begin and end.
* gcc.dg/pr98147.c: New test.
|
|
To make this work from the do_type method, add "byte" and "rune" to
the list of known integer types, and look them up that way rather than
via gogo->lookup_global.
For golang/go#8745
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/275653
|
|
In this testcase we are crashing trying to gimplify a switch, because
the types of the switch condition and case constants have different
TYPE_PRECISIONs.
This started with my r5-3726 fix: SWITCH_STMT_TYPE is supposed to be the
original type of the switch condition before any conversions, so in the
C++ FE we need to use unlowered_expr_type to get the unlowered type of
enum bit-fields.
Normally, the switch type is subject to integral promotions, but here
we have a scoped enum type and those don't promote:
enum class B { A };
struct C { B c : 8; };
switch (x.c) // type B
case B::A: // type int, will be converted to B
Here TREE_TYPE is "signed char" but SWITCH_STMT_TYPE is "B". When
gimplifying this in gimplify_switch_expr, the index type is "B" and
we convert all the case values to "B" in preprocess_case_label_vec,
but SWITCH_COND is of type "signed char": gimple_switch_index should
be the (possibly promoted) type, not the original type, so we gimplify
the "x.c" SWITCH_COND to a SSA_NAME of type "signed char". And then
we crash because the precision of the index type doesn't match the
precision of the case value type.
I think it makes sense to do the following; at the end of pop_switch
we've already issued the switch warnings, and since scoped enums don't
promote, it should be okay to use the type of SWITCH_STMT_COND. The
r5-3726 change was about giving warnings for enum bit-fields anyway.
gcc/cp/ChangeLog:
PR c++/98043
* decl.c (pop_switch): If SWITCH_STMT_TYPE is a scoped enum type,
set it to the type of SWITCH_STMT_COND.
gcc/testsuite/ChangeLog:
PR c++/98043
* g++.dg/cpp0x/enum41.C: New test.
|
|
* go.test/go-test.exp (errchk): Don't backslash quote parentheses
that are already backslash quoted.
|
|
The test case is https://golang.org/cl/275632.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/275652
|
|
verify_sequence_points uses verify_tree to recursively walk the
subexpressions of an expression, and while recursing, it also
keeps lists of expressions found after/before a sequence point.
For a large expression, the list can grow significantly. And
merge_tlist is at least N(n^2): for a list of length n it will
iterate n(n -1) times, and call candidate_equal_p each time, and
that can recurse further. warn_for_collision also has to go
through the whole list. With a large-enough expression, the
compilation can easily get stuck here for 24 hours.
This patch is a simple kludge: if we see that the expression is
overly complex, don't even try.
gcc/c-family/ChangeLog:
PR c++/98126
* c-common.c (verify_tree_lim_r): New function.
(verify_sequence_points): Use it. Use nullptr instead of 0.
gcc/testsuite/ChangeLog:
PR c++/98126
* g++.dg/warn/Wsequence-point-4.C: New test.
|
|
This restores the dependent array changes I reverted, now that pr98116
appears fixed. As mentioned before, when deserializing a module we
need to construct arrays without using the dependent-type predicates
themselves.
gcc/cp/
* cp-tree.h (build_cplus_array_type): Add defaulted DEP parm.
* tree.c (set_array_type_common): Add DEP parm.
(build_cplus_array_type): Add DEP parm, determine dependency if
needed. Mark dependency of new types.
(cp_build_qualified_type_real): Adjust array-building call, assert
no surprising dependency.
(strip_typedefs): Likewise.
|
|
This fixes the underlying problem my recent (backedout) changes to
array type creation uncovered. We had paths through
structural_comptypes that ignored alias templates, even when
significant. This adds the necessary checks.
PR c++/98116
gcc/cp/
* typeck.c (structural_comptypes): Move early outs to comptype.
Always check template-alias match when comparing_specializations.
(comptypes): Do early out checking here.
gcc/testsuite/
* g++.dg/template/pr98116.C: Remove dg-ice.
* g++.dg/template/pr98116-2.C: New.
|
|
Copy the location info from the passed in call stmt
to the newly built gimple call stmt.
2020-12-07 Bernd Edlinger <bernd.edlinger@hotmail.de>
* ipa-param-manipulation.c
(ipa_param_body_adjustments::modify_call_stmt): Set location info.
|
|
gcc/ChangeLog:
* doc/extend.texi (used function attribute): Document saving
the declaration from linker garbage collection.
(used variable attribute): Likewise.
|
|
This adds the capability to handle a sequence of vector BIT_INSERT_EXPRs
to be vectorized similar as to how we vectorize vector constructors.
2020-12-03 Richard Biener <rguenther@suse.de>
PR tree-optimization/98113
* tree-vectorizer.h (struct slp_root): New.
(_bb_vec_info::roots): New member.
* tree-vect-slp.c (vect_analyze_slp): Also walk BB info
roots.
(_bb_vec_info::_bb_vec_info): Adjust.
(_bb_vec_info::~_bb_vec_info): Likewise.
(vld_cmp): New.
(vect_slp_is_lane_insert): Likewise.
(vect_slp_check_for_constructors): Match a series of
BIT_INSERT_EXPRs as vector constructor.
(vect_slp_analyze_bb_1): Continue if BB info roots is
not empty.
(vect_slp_analyze_bb_1): Mark the whole BIT_INSERT_EXPR root
sequence as pure_slp.
* gcc.dg/vect/bb-slp-70.c: New testcase.
|
|
This avoids the degenerate case of a TYPE_MAX_VALUE latch iteration
count value causing wrong range info for the vector IV. There's
still the case of VF == 1 where if we don't know whether we hit the
above case we cannot emit a range.
2020-12-07 Richard Biener <rguenther@suse.de>
PR tree-optimization/98117
* tree-vect-loop-manip.c (vect_gen_vector_loop_niters):
Properly handle degenerate niter when setting the vector
loop IV range.
* gcc.dg/torture/pr98117.c: New testcase.
|
|
gcc/ada/ChangeLog:
* gcc-interface/Make-lang.in: Remove ^L characters.
* gcc-interface/decl.c (create_concat_name): Add cast.
|
|
The compiler aborts on the local extension of a tagged type declared
at library level, with a progenitor given by an interface type having
a primitive that is a homograph of a primitive of the tagged type.
gcc/ada/ChangeLog:
* gcc-interface/trans.c (maybe_make_gnu_thunk): Return false if the
target is local and thunk and target do not have the same context.
|
|
Gigi uses a dummy global variable to register global types for debug
info purposes and its name can now collide with user variables.
gcc/ada/ChangeLog:
* gcc-interface/trans.c (lvalue_for_aggregate_p): Also return true
for return statements.
* gcc-interface/utils.c (gnat_write_global_declarations): Use the
maximum index for the dummy object to avoid a name collision.
|
|
gcc/ada/ChangeLog:
* gcc-interface/decl.c (gnat_to_gnu_entity) <Fixed_Point_Type>: Put
back the "else" unduly removed.
|
|
The compiler generates code that writes too much data into a component
of a record subject to a representation clause, when the source of the
assignment is a call to a function that returns a discriminated record
type with default discriminants, variable size and a statically known
upper bound for this size, and the size of the component given by the
representation clause is lower than the value of this bound rounded up
to the alignment.
gcc/ada/ChangeLog:
* gcc-interface/trans.c (Call_to_gnu): Also create a temporary for
the return value if the LHS is a bit-field and the return type is
a type padding a self-referential type.
(gnat_to_gnu): Do not remove the padding on the result if it is too
small with regard to the natural padding size.
|
|
The new ranger exposed a problematic conversion to boolean type.
gcc/ada/ChangeLog:
* gcc-interface/utils.c (convert) <INTEGER_TYPE>: Call fold_convert
in the cases where convert_to_integer is not called.
<BOOLEAN_TYPE>: Call fold_convert instead of convert_to_integer.
|
|
In s390.c we are still using Pmode for the stack probes. This breaks
with -m31 -mzarch where Pmode != word_mode.
The patch also adds a new target check to s390.exp which allows us to
implement zarch specific checks in the testcases.
gcc/ChangeLog:
* config/s390/s390.c (s390_emit_stack_probe): Change Pmode to
word_mode.
gcc/testsuite/ChangeLog:
* gcc.target/s390/s390.exp: New target check s390_zarch.
* gcc.target/s390/stack-clash-1.c: Use s390_zarch instead of lp64.
* gcc.target/s390/stack-clash-2.c: Likewise.
* gcc.target/s390/stack-clash-3.c: Likewise.
* gcc.target/s390/stack-clash-5.c: New test.
|
|
2020-12-07 Matthias Klose <doko@ubuntu.com>
PR ada/97504
* Makefile.rtl (LIBGNAT_TARGET_PAIRS) <mips*-*-linux*>: Use wraplf
version of Aux_Long_Long_Float.
|
|
When looking at the testcase of PR 97816 I realized that the reason
why we were hitting overflows in size growth estimates in IPA-CP is
not because the chains of how lattices feed values to each other are
so long but mainly because we add estimates in callee lattices to
caller lattices for each value source, which roughly corresponds to a
call graph edge, and therefore if there are multiple calls between two
functions passing the same value in a parameter we end up doing it
more than once, sometimes actually quite many times.
This patch avoids it by using a has_set to remember the source values
we have already updated and not increasing their size again.
Furhtermore, to improve estimation of times we scale the propagated
time benefits with edge frequencies as we accumulate them.
This should make any overflows very unlikely but not impossible, so I
still included checks for overflows but decided to restructure the
code to only need it in the propagate_effects function and modified it
so that it does not need to perform the check before each sum.
This is because I decided to add local estimates to propagated
estimates already in propagate_effects and not at the evaluation time.
The function can then do the sums in a wide type and discard them in
the unlikely case of an overflow. I also decided to use the
opportunity to make propagated effect stats now include stats from
other values in the same SCCs. In the dumps I have seen this tended
to increase size cost a tiny bit more than the estimated time benefit
but both increases were small.
Martin
gcc/ChangeLog:
2020-11-20 Martin Jambor <mjambor@suse.cz>
PR ipa/97816
* ipa-cp.c (safe_add): Removed.
(good_cloning_opportunity_p): Remove special handling of INT_MAX.
(value_topo_info<valtype>::propagate_effects): Take care not to
propagate from size one value to another through more sources. Scale
propagated times with edge frequencies. Include local time and size
in propagates ones here. Take care not to overflow size.
(decide_about_value): Do not add local and propagated effects when
passing them to good_cloning_opportunity_p.
|
|
As seen in PR98144, building insn-extract.o with rtl checking takes some memory,
and it doesn't work on 32bit architectures at all (PR97314). Richard suggested
on irc to disable rtl checking for this auto-generated file, like it's already
done for genconditions.c. Patching it like done for genconditons.c.
2020-12-07 Matthias Klose <doko@ubuntu.com>
* genextract.c (print_header): Undefine ENABLE_RTL_CHECKING
and ENABLE_RTL_FLAG_CHECKING.
|
|
split_constant_offset currently gives up looking at ranges when
dealing with possibly wrapping operations for looking through
conversions when the downstream analysis does not yield a SSA name.
That's overly conservative and we have a nice helper that can
deal with arbitrary expresssions. Use that. This helps data
reference group analysis so the testcase is fully SLP vectorized,
making use of the whole-function "BB" vectorization capabilities
we now have.
2020-12-04 Richard Biener <rguenther@suse.de>
PR tree-optimization/98137
* tree-data-ref.c (split_constant_offset_1): Use
determine_value_range instead of get_range_info to handle
arbitrary expressions.
* gcc.dg/vect/bb-slp-pr98137.c: New testcase.
|
|
|
|
-mcet was removed by
commit 231baae28ef7ff784683fa5a80df119da2b9a99b
Author: H.J. Lu <hongjiu.lu@intel.com>
Date: Tue Apr 24 16:56:04 2018 +0000
x86/CET: Remove the -mcet command-lint option
PR target/98162
* doc/extend.texi: Remove -mcet.
|
|
commit 266f44a91c0c9705d3d18e82d7c5bab32927a18f
Author: H.J. Lu <hjl.tools@gmail.com>
Date: Sun May 17 10:10:34 2020 -0700
x86: Allow V1TI vector register pushes
Add V1TI vector register push and split it after reload to a sequence
of:
(set (reg:P SP_REG) (plus:P SP_REG) (const_int -8)))
(set (match_dup 0) (match_dup 1))
added a pseudo register push check. But
(insn 13 12 14 3 (set (mem:SI (pre_dec:SI (reg/f:SI 7 sp)) [0 S4 A32])
(reg/v:SI 87 [ srclen ])) "x.c":37:16 54 {*pushsi2}
(expr_list:REG_DEAD (reg/v:SI 87 [ srclen ])
(expr_list:REG_ARGS_SIZE (const_int 4 [0x4])
(nil))))
is not a pseudo register push. In 64-bit mode, mode of pseudo register
push is TImode. In 32-bit mode, it is DImode. Add pseudo register push
mode check to pseudo_reg_set.
gcc/
PR target/98161
* config/i386/i386-features.c (pseudo_reg_set): Check mode of
pseudo register push.
gcc/testsuite/
* gcc.target/i386/pr98161.c: New test.
|
|
The following patch improves code generation on the included testcase by
enabling two_value_replacement on booleans. It does that only for arg0/arg1
values that conditional_replacement doesn't handle. Additionally
it limits two_value_replacement optimization to the late phiopt like
conditional_replacement.
2020-12-06 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/96232
* tree-ssa-phiopt.c (two_value_replacement): Optimize even boolean lhs
cases as long as arg0 has wider precision and conditional_replacement
doesn't handle that case.
(tree_ssa_phiopt_worker): Don't call two_value_replacement during
early phiopt.
* gcc.dg/tree-ssa/pr96232-2.c: New test.
* gcc.dg/tree-ssa/pr88676-2.c: Check phiopt2 dump rather than phiopt1.
|
|
As mentioned in the PR, for boolean x we currently optimize
in phiopt x ? 0 : -1 into -(int)!x but it can be optimized as
(int) x - 1 which is one less operation both in GIMPLE and in x86 assembly.
This patch optimizes it in match.pd, by optimizing -(type)!x when
x has boolean range into (type)x - 1.
2020-12-06 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/96232
* match.pd (-(type)!A -> (type)A - 1): New optimization.
* gcc.dg/tree-ssa/pr96232-1.c: New test.
|
|
gcc/testsuite/ChangeLog:
PR testsuite/98156
* gfortran.dg/coarray/alloc_comp_1.f90: Upper cobound is
determined by num_images(), not this_image().
|
|
Fixes
FAIL: gcc.target/powerpc/signbit-1.c scan-assembler-not stxvd2x
FAIL: gcc.target/powerpc/signbit-1.c scan-assembler-times mfvsrd 3
FAIL: gcc.target/powerpc/signbit-1.c scan-assembler-times srdi 3
FAIL: gcc.target/powerpc/signbit-2.c scan-assembler-times ld 1
FAIL: gcc.target/powerpc/signbit-2.c scan-assembler-times srdi 1
on powerpc-linux (or powerpc64-linux biarch -m32).
signbit-1.c is quite obviously a 64-bit only testcase given the
scan-assembler directives, and the purpose of the testcase to verify
the 64-bit only UNSPEC_SIGNBIT patterns. It could be made to pass for
-m32 by adding -mpowerpc64, but that option that isn't very effective
when bi-arch testing and results in errors on rs6000-aix. And it is
pointless to match -m32 stores to the stack followed by loads, which
is what we do at the moment.
signbit-2.c on the other hand has more reasonable 32-bit output.
* gcc.target/powerpc/signbit-1.c: Reinstate lp64 condition.
* gcc.target/powerpc/signbit-2.c: Match 32-bit output too.
|
|
|
|
ASM_OUTPUT_DEF is used by GCC as a proxy to enable alias support. But
the macro does not provide the necessary implementation for symbol aliasing
on AIX, which uses a different implementation. On AIX, the macro was empty.
Because the macro is empty, none of the macro argument are used, which
means that some of the variables in the function that calls the macro are
never used. This causes a warning when building varasm.c, and -Werror
converts that into a fatal error.
This patch references the macro arguments as (void) to prevent the
warning.
2020-12-05 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
David Edelsohn <dje.gcc@gmail.com>
gcc/ChangeLog:
* config/rs6000/xcoff.h (ASM_OUTPUT_DEF): Reference macro arguments.
|
|
The re-normalization performed from diagnose_nested_requirement doesn't
always work because we may have already lost the necessary template
context that determines the set of in-scope template parameters used by
the nested-requirement. This leads to normalization producing atoms
that have incomplete/bogus parameter mappings, which breaks satisfaction.
To fix this, we could just use the normal form that we previously
computed at parse time, but this normal form lacks the diagnostic
information that leads to good error messages.
Instead, this patch makes diagnose_nested_requirement normalize twice at
parse time -- once without diagnostic information and once with -- so
that routines can use the "regular" normal form when performing
satisfaction quietly and the "diagnostic" normal form when performing
satisfaction noisily. Moreover, this patch makes tsubst_nested_requirement
always first perform satisfaction quietly so that the satisfaction cache
can get consistently utilized.
This patch also adds some sanity checks to build_parameter_mapping that
would have caught the underlying bug sooner (and deterministically).
gcc/cp/ChangeLog:
PR c++/97093
* constraint.cc (parameter_mapping_equivalent_p): Add some
sanity checks. Clarify comment.
(tsubst_nested_requirement): Always perform satisfaction
quietly first. If that yields an erroneous result, emit a
context message and replay satisfaction noisily with the
diagnostic normal form.
(finish_nested_requirement): Normalize the constraint-expression
twice, once with diagnostic information and once without. Store
them in a TREE_LIST within the TREE_TYPE.
(diagnose_nested_requirement): When replaying satisfaction, use
the diagnostic normal form instead of renormalizing on the spot.
gcc/testsuite/ChangeLog:
PR c++/97093
* g++.dg/cpp2a/concepts-requires22.C: New test.
|
|
During satisfaction, the flag info.noisy() controls three things:
whether to diagnose ill-formed satisfaction (such as the satisfaction
value of an atom being non-bool or non-constant); whether to diagnose
unsatisfaction; and whether to bypass the satisfaction cache.
The flag turns out to be too coarse however, because in some cases we
want to diagnose ill-formed satisfaction (and bypass the satisfaction
cache) but not diagnose unsatisfaction, for instance when replaying an
erroneous satisfaction result from constraint_satisfaction_value,
evaluate_concept_check and tsubst_nested_requirement.
And when noisily evaluating a disjunction, we want to first evaluate its
branches noisily (bypassing the satisfaction cache) but suppress
unsatisfaction diagnostics. We currently work around this by instead
first evaluating each branch quietly, but that means the recursive calls
to satisfy_atom will use the satisfaction cache.
To fix this, this patch adds the info.diagnose_unsatisfaction_p() flag,
which refines the info.noisy() flag as part of a new sat_info class that
derives from subst_info. During satisfaction, info.noisy() now controls
whether to diagnose ill-formed satisfaction, and
info.diagnose_unsatisfaction_p() controls whether to additionally
diagnose unsatisfaction. This enables us to address the above two
issues straightforwardly.
Incidentally, the change to satisfy_disjunction suppresses the ICE in
the PR97093 testcase because we no longer insert atoms into the
satisfaction cache that have been incorrectly re-normalized in
diagnose_nested_requirement (after losing the necessary template
context). But the underlying re-normalization issue remains, and will
be fixed in a subsequent patch.
gcc/cp/ChangeLog:
PR c++/97093
* constraint.cc (struct sat_info): Define.
(tsubst_nested_requirement): Pass a sat_info object to
satisfy_constraint.
(satisfy_constraint_r): Take a sat_info argument instead of
subst_info.
(satisfy_conjunction): Likewise.
(satisfy_disjunction): Likewise. Instead of first evaluating
each branch quietly, evaluate each branch only with
unsatisfaction diagnostics disabled. Exit early if evaluation
of a branch returns error_mark_node.
(satisfy_atom): Take a sat_info argument instead of subst_info.
Fix a comment. Check diagnose_unsatisfaction_p() instead of
noisy() before replaying a substitution failure.
(satisfy_constraint): Take a sat_info argument instead of
subst_info.
(satisfy_associated_constraints): Likewise.
(satisfy_constraint_expression): Likewise.
(satisfy_declaration_constraints): Likewise.
(constraint_satisfaction_value): Likewise and adjust
accordingly. Fix formatting.
(constraints_satisfied_p): Pass a sat_info object to
constraint_satisfaction_value.
(evaluate_concept_check): Pass a sat_info object to
satisfy_constraint_expression.
(diagnose_nested_requirement): Likewise.
(diagnose_constraints): Pass an appropriate sat_info object to
constraint_satisfaction_value.
gcc/testsuite/ChangeLog:
PR c++/97093
* g++.dg/concepts/pr94252.C: Verify we no longer issue a
spurious unsatisfaction note when diagnosing ill-formed
satisfaction.
* g++.dg/cpp2a/concepts-requires18.C: No longer expect a
spurious unsatisfaction diagnostic when evaluating the
nested-requirement subst<void&> of a requires-expression that
appears outside of a template.
* g++.dg/cpp2a/concepts-requires21.C: Verify we no longer issue
a spurious unsatisfaction note when evaluating a
nested-requirement of a requires-expression that appears outside
of a template.
* g++.dg/cpp2a/concepts-nonbool3.C: New test.
* g++.dg/cpp2a/concepts-pr97093.C: New test.
|
|
gcc/testsuite/
PR target/95294
* gcc.target/vax/cmpelim-eq-adddf.c: New test.
* gcc.target/vax/cmpelim-eq-addhi.c: New test.
* gcc.target/vax/cmpelim-eq-addqi.c: New test.
* gcc.target/vax/cmpelim-eq-addsf.c: New test.
* gcc.target/vax/cmpelim-eq-addsi.c: New test.
* gcc.target/vax/cmpelim-eq-andhi.c: New test.
* gcc.target/vax/cmpelim-eq-andqi.c: New test.
* gcc.target/vax/cmpelim-eq-andsi.c: New test.
* gcc.target/vax/cmpelim-eq-ashlsi.c: New test.
* gcc.target/vax/cmpelim-eq-ashrsi.c: New test.
* gcc.target/vax/cmpelim-eq-divdf.c: New test.
* gcc.target/vax/cmpelim-eq-divhi.c: New test.
* gcc.target/vax/cmpelim-eq-divqi.c: New test.
* gcc.target/vax/cmpelim-eq-divsf.c: New test.
* gcc.target/vax/cmpelim-eq-divsi.c: New test.
* gcc.target/vax/cmpelim-eq-extendhisi.c: New test.
* gcc.target/vax/cmpelim-eq-extendqisi.c: New test.
* gcc.target/vax/cmpelim-eq-extvsi.c: New test.
* gcc.target/vax/cmpelim-eq-extzvsi.c: New test.
* gcc.target/vax/cmpelim-eq-fixdfhi.c: New test.
* gcc.target/vax/cmpelim-eq-fixdfqi.c: New test.
* gcc.target/vax/cmpelim-eq-fixdfsi.c: New test.
* gcc.target/vax/cmpelim-eq-fixsfhi.c: New test.
* gcc.target/vax/cmpelim-eq-fixsfqi.c: New test.
* gcc.target/vax/cmpelim-eq-fixsfsi.c: New test.
* gcc.target/vax/cmpelim-eq-floatsisf.c: New test.
* gcc.target/vax/cmpelim-eq-insvsi.c: New test.
* gcc.target/vax/cmpelim-eq-iorhi.c: New test.
* gcc.target/vax/cmpelim-eq-iorqi.c: New test.
* gcc.target/vax/cmpelim-eq-iorsi.c: New test.
* gcc.target/vax/cmpelim-eq-mova.c: New test.
* gcc.target/vax/cmpelim-eq-movdf.c: New test.
* gcc.target/vax/cmpelim-eq-movhi.c: New test.
* gcc.target/vax/cmpelim-eq-movqi.c: New test.
* gcc.target/vax/cmpelim-eq-movsf.c: New test.
* gcc.target/vax/cmpelim-eq-movsi.c: New test.
* gcc.target/vax/cmpelim-eq-muldf.c: New test.
* gcc.target/vax/cmpelim-eq-mulhi.c: New test.
* gcc.target/vax/cmpelim-eq-mulqi.c: New test.
* gcc.target/vax/cmpelim-eq-mulsf.c: New test.
* gcc.target/vax/cmpelim-eq-mulsi.c: New test.
* gcc.target/vax/cmpelim-eq-nothi.c: New test.
* gcc.target/vax/cmpelim-eq-notqi.c: New test.
* gcc.target/vax/cmpelim-eq-notsi.c: New test.
* gcc.target/vax/cmpelim-eq-rotlsi.c: New test.
* gcc.target/vax/cmpelim-eq-rotrsi.c: New test.
* gcc.target/vax/cmpelim-eq-subdf.c: New test.
* gcc.target/vax/cmpelim-eq-subhi.c: New test.
* gcc.target/vax/cmpelim-eq-subqi.c: New test.
* gcc.target/vax/cmpelim-eq-subsf.c: New test.
* gcc.target/vax/cmpelim-eq-subsi.c: New test.
* gcc.target/vax/cmpelim-eq-truncdfsf.c: New test.
* gcc.target/vax/cmpelim-eq-trunchiqi.c: New test.
* gcc.target/vax/cmpelim-eq-truncsihi.c: New test.
* gcc.target/vax/cmpelim-eq-truncsiqi.c: New test.
* gcc.target/vax/cmpelim-eq-zextendhisi.c: New test.
* gcc.target/vax/cmpelim-eq-zextendqihi.c: New test.
* gcc.target/vax/cmpelim-eq-zextendqisi.c: New test.
* gcc.target/vax/cmpelim-le-adddf.c: New test.
* gcc.target/vax/cmpelim-le-addhi.c: New test.
* gcc.target/vax/cmpelim-le-addqi.c: New test.
* gcc.target/vax/cmpelim-le-addsf.c: New test.
* gcc.target/vax/cmpelim-le-addsi.c: New test.
* gcc.target/vax/cmpelim-le-andhi.c: New test.
* gcc.target/vax/cmpelim-le-andqi.c: New test.
* gcc.target/vax/cmpelim-le-andsi.c: New test.
* gcc.target/vax/cmpelim-le-ashlsi.c: New test.
* gcc.target/vax/cmpelim-le-ashrsi.c: New test.
* gcc.target/vax/cmpelim-le-divdf.c: New test.
* gcc.target/vax/cmpelim-le-divhi.c: New test.
* gcc.target/vax/cmpelim-le-divqi.c: New test.
* gcc.target/vax/cmpelim-le-divsf.c: New test.
* gcc.target/vax/cmpelim-le-divsi.c: New test.
* gcc.target/vax/cmpelim-le-extendhisi.c: New test.
* gcc.target/vax/cmpelim-le-extendqisi.c: New test.
* gcc.target/vax/cmpelim-le-extvsi.c: New test.
* gcc.target/vax/cmpelim-le-extzvsi.c: New test.
* gcc.target/vax/cmpelim-le-fixdfhi.c: New test.
* gcc.target/vax/cmpelim-le-fixdfqi.c: New test.
* gcc.target/vax/cmpelim-le-fixdfsi.c: New test.
* gcc.target/vax/cmpelim-le-fixsfhi.c: New test.
* gcc.target/vax/cmpelim-le-fixsfqi.c: New test.
* gcc.target/vax/cmpelim-le-fixsfsi.c: New test.
* gcc.target/vax/cmpelim-le-floatsisf.c: New test.
* gcc.target/vax/cmpelim-le-insvsi.c: New test.
* gcc.target/vax/cmpelim-le-iorhi.c: New test.
* gcc.target/vax/cmpelim-le-iorqi.c: New test.
* gcc.target/vax/cmpelim-le-iorsi.c: New test.
* gcc.target/vax/cmpelim-le-movdf.c: New test.
* gcc.target/vax/cmpelim-le-movhi.c: New test.
* gcc.target/vax/cmpelim-le-movqi.c: New test.
* gcc.target/vax/cmpelim-le-movsf.c: New test.
* gcc.target/vax/cmpelim-le-movsi.c: New test.
* gcc.target/vax/cmpelim-le-muldf.c: New test.
* gcc.target/vax/cmpelim-le-mulhi.c: New test.
* gcc.target/vax/cmpelim-le-mulqi.c: New test.
* gcc.target/vax/cmpelim-le-mulsf.c: New test.
* gcc.target/vax/cmpelim-le-mulsi.c: New test.
* gcc.target/vax/cmpelim-le-nothi.c: New test.
* gcc.target/vax/cmpelim-le-notqi.c: New test.
* gcc.target/vax/cmpelim-le-notsi.c: New test.
* gcc.target/vax/cmpelim-le-rotlsi.c: New test.
* gcc.target/vax/cmpelim-le-rotrsi.c: New test.
* gcc.target/vax/cmpelim-le-subdf.c: New test.
* gcc.target/vax/cmpelim-le-subhi.c: New test.
* gcc.target/vax/cmpelim-le-subqi.c: New test.
* gcc.target/vax/cmpelim-le-subsf.c: New test.
* gcc.target/vax/cmpelim-le-subsi.c: New test.
* gcc.target/vax/cmpelim-le-truncdfsf.c: New test.
* gcc.target/vax/cmpelim-le-xorhi.c: New test.
* gcc.target/vax/cmpelim-le-xorqi.c: New test.
* gcc.target/vax/cmpelim-le-xorsi.c: New test.
* gcc.target/vax/cmpelim-leu-subhi.c: New test.
* gcc.target/vax/cmpelim-leu-subqi.c: New test.
* gcc.target/vax/cmpelim-leu-subsi.c: New test.
* gcc.target/vax/cmpelim-lt-adddf.c: New test.
* gcc.target/vax/cmpelim-lt-addhi.c: New test.
* gcc.target/vax/cmpelim-lt-addqi.c: New test.
* gcc.target/vax/cmpelim-lt-addsf.c: New test.
* gcc.target/vax/cmpelim-lt-addsi.c: New test.
* gcc.target/vax/cmpelim-lt-andhi.c: New test.
* gcc.target/vax/cmpelim-lt-andqi.c: New test.
* gcc.target/vax/cmpelim-lt-andsi.c: New test.
* gcc.target/vax/cmpelim-lt-ashlsi.c: New test.
* gcc.target/vax/cmpelim-lt-ashrsi.c: New test.
* gcc.target/vax/cmpelim-lt-divdf.c: New test.
* gcc.target/vax/cmpelim-lt-divhi.c: New test.
* gcc.target/vax/cmpelim-lt-divqi.c: New test.
* gcc.target/vax/cmpelim-lt-divsf.c: New test.
* gcc.target/vax/cmpelim-lt-divsi.c: New test.
* gcc.target/vax/cmpelim-lt-extendhisi.c: New test.
* gcc.target/vax/cmpelim-lt-extendqisi.c: New test.
* gcc.target/vax/cmpelim-lt-extvsi.c: New test.
* gcc.target/vax/cmpelim-lt-extzvsi.c: New test.
* gcc.target/vax/cmpelim-lt-fixdfhi.c: New test.
* gcc.target/vax/cmpelim-lt-fixdfqi.c: New test.
* gcc.target/vax/cmpelim-lt-fixdfsi.c: New test.
* gcc.target/vax/cmpelim-lt-fixsfhi.c: New test.
* gcc.target/vax/cmpelim-lt-fixsfqi.c: New test.
* gcc.target/vax/cmpelim-lt-fixsfsi.c: New test.
* gcc.target/vax/cmpelim-lt-floatsisf.c: New test.
* gcc.target/vax/cmpelim-lt-insvsi.c: New test.
* gcc.target/vax/cmpelim-lt-iorhi.c: New test.
* gcc.target/vax/cmpelim-lt-iorqi.c: New test.
* gcc.target/vax/cmpelim-lt-iorsi.c: New test.
* gcc.target/vax/cmpelim-lt-movdf.c: New test.
* gcc.target/vax/cmpelim-lt-movhi.c: New test.
* gcc.target/vax/cmpelim-lt-movqi.c: New test.
* gcc.target/vax/cmpelim-lt-movsf.c: New test.
* gcc.target/vax/cmpelim-lt-movsi.c: New test.
* gcc.target/vax/cmpelim-lt-muldf.c: New test.
* gcc.target/vax/cmpelim-lt-mulhi.c: New test.
* gcc.target/vax/cmpelim-lt-mulqi.c: New test.
* gcc.target/vax/cmpelim-lt-mulsf.c: New test.
* gcc.target/vax/cmpelim-lt-mulsi.c: New test.
* gcc.target/vax/cmpelim-lt-nothi.c: New test.
* gcc.target/vax/cmpelim-lt-notqi.c: New test.
* gcc.target/vax/cmpelim-lt-notsi.c: New test.
* gcc.target/vax/cmpelim-lt-rotlsi.c: New test.
* gcc.target/vax/cmpelim-lt-rotrsi.c: New test.
* gcc.target/vax/cmpelim-lt-subdf.c: New test.
* gcc.target/vax/cmpelim-lt-subhi.c: New test.
* gcc.target/vax/cmpelim-lt-subqi.c: New test.
* gcc.target/vax/cmpelim-lt-subsf.c: New test.
* gcc.target/vax/cmpelim-lt-subsi.c: New test.
* gcc.target/vax/cmpelim-lt-truncdfsf.c: New test.
* gcc.target/vax/cmpelim-lt-xorhi.c: New test.
* gcc.target/vax/cmpelim-lt-xorqi.c: New test.
* gcc.target/vax/cmpelim-lt-xorsi.c: New test.
* gcc.target/vax/cmpelim-ltu-subhi.c: New test.
* gcc.target/vax/cmpelim-ltu-subqi.c: New test.
* gcc.target/vax/cmpelim-ltu-subsi.c: New test.
* gcc.target/vax/cmpelim-xx-addsi.c: New test.
* gcc.target/vax/cmpelim-xx-insvsi.c: New test.
* gcc.target/vax/cmpelim-xxu-subsi.c: New test.
* gcc.target/vax/peephole2-eq-andhi.c: New test.
* gcc.target/vax/peephole2-eq-andqi.c: New test.
* gcc.target/vax/peephole2-eq-andsi.c: New test.
* gcc.target/vax/peephole2-eq-cmpvsi.c: New test.
* gcc.target/vax/peephole2-eq-cmpzvsi.c: New test.
* gcc.target/vax/peephole2-eq-ctzhi-0.c: New test.
* gcc.target/vax/peephole2-eq-ctzhi-1.c: New test.
* gcc.target/vax/peephole2-eq-ctzqi-0.c: New test.
* gcc.target/vax/peephole2-eq-ctzqi-1.c: New test.
* gcc.target/vax/peephole2-eq-ctzsi-0.c: New test.
* gcc.target/vax/peephole2-eq-ctzsi-1.c: New test.
* gcc.target/vax/peephole2-eq-ffshi.c: New test.
* gcc.target/vax/peephole2-eq-ffsqi.c: New test.
* gcc.target/vax/peephole2-eq-ffssi.c: New test.
* gcc.target/vax/peephole2-le-andhi.c: New test.
* gcc.target/vax/peephole2-le-andqi.c: New test.
* gcc.target/vax/peephole2-le-andsi.c: New test.
* gcc.target/vax/peephole2-le-cmpvsi.c: New test.
* gcc.target/vax/peephole2-le-cmpzvsi.c: New test.
* gcc.target/vax/peephole2-leu-cmpvsi.c: New test.
* gcc.target/vax/peephole2-leu-cmpzvsi.c: New test.
* gcc.target/vax/peephole2-lt-andhi.c: New test.
* gcc.target/vax/peephole2-lt-andqi.c: New test.
* gcc.target/vax/peephole2-lt-andsi.c: New test.
* gcc.target/vax/peephole2-lt-cmpvsi.c: New test.
* gcc.target/vax/peephole2-lt-cmpzvsi.c: New test.
* gcc.target/vax/peephole2-ltu-cmpvsi.c: New test.
* gcc.target/vax/peephole2-ltu-cmpzvsi.c: New test.
|
|
In the VAX ISA INSV bit-field insert instruction is the only computational
operation that keeps the condition codes, held in the PSL or Processor
Status Longword register, intact. The instruction is flexible enough it
could potentially be used for data moves post-reload, but then reportedly
it is not the best choice performance-wise, and then we have no addition
operation available that would keep the condition codes unchanged.
Futhermore, as usually with a complex CISC ISA, for many operations we
have several machine instructions or instruction sequences to choose
from that set condition codes in a different manner.
Use the approach then where the condition codes only get introduced by
reload, by definining instruction splitters for RTL insns that change
condition codes in some way, by default considering them clobbered.
Then to prevent code generated from regressing too much provide insns
that include a `compare' operation setting the condition codes in
parallel to the main operation. The manner condition codes are set by
each insn is supposed to be provided by the whatever the SELECT_CC_MODE
macro expands to.
Given that individual patterns provided for the same RTL basic operation
may set the condion codes differently keeping the information away from
the insn patterns themselves would cause a maintenance nightmare and
would be bound to fail in a horrible way sooner or later. Therefore
instead let the patterns themselves choose which condition modes they
support, by having one or more subst iterators applied and then have
individual comparison operators require the specific condition mode each
according to the codes used by the operation.
While subst iterators only support one alternative each, there is
actually no problem with applying multiple ones to a single insn with
the result as intended, and if the corresponding subst attribute
supplies an empty NO-SUBST-VALUE, then no mess results even. Make use
of this observation.
Add appropriate subst iterators to all the computational patterns then,
according to the condition codes they usably set, including DImode ones
and a substitute DImode comparison instruction in the absence of a CMPQ
machine instruction, however do not provide a `cbranchdi4' named pattern
as without a further development it regresses code quality by resorting
to the `__cmpdi2' libcall where a simpler operation would do, e.g. to
check for negativity the TSTL machine instruction may be executed over
the upper longword only. This is good material for further work.
Do not apply subst iterators to the increment- or decrement-and-branch
patterns at this time; these may yet have to be reviewed, in particular
whether `*jsobneq_minus_one' is still relevant in the context of the
recent integer constant cost review.
Also add a couple of peepholes to help eliminating comparisons in some
problematic cases, such as with the BIT instruction which is bitwise-AND
for condition codes only that has no direct counterpart for the actual
calculation, because the BIC instruction which does do bitwise-AND and
produces a result implements the operation with a bitwise negation of
its input `mask' operand. Or the FFS instruction which sets the Z
condition code according to its `field' input operand rather than the
result produced. Or the bit-field comparisons we don't have generic
middle-end support for.
Code size stats are as follows, obtained from 17640 and 9086 executables
built in `check-c' and `check-c++' GCC testing respectively:
check-c check-c++
samples average median samples average median
---------------------------------------------------------------
regressions 1813 0.578% 0.198% 289 0.349% 0.175%
unchanged 15160 0.000% 0.000% 8662 0.000% 0.000%
progressions 667 -0.589% -0.194% 135 -0.944% -0.191%
----------------------------------------------------------------
total 17640 0.037% 0.000% 9086 -0.003% 0.000%
Outliers:
old new change %change filename
----------------------------------------------------
2406 2950 +544 +22.610 20111208-1.exe
4314 5329 +1015 +23.528 pr39417.exe
2235 3055 +820 +36.689 990404-1.exe
2631 4213 +1582 +60.129 pr57521.exe
3063 5579 +2516 +82.142 20000422-1.exe
and:
old new change %change filename
----------------------------------------------------
6317 4845 -1472 -23.302 vector-compare-1.exe
6313 4845 -1468 -23.254 vector-compare-1.exe
6474 5002 -1472 -22.737 vector-compare-1.exe
6470 5002 -1468 -22.689 vector-compare-1.exe
We have some code quality regressions like:
10861: 9e ef d9 12 movab 11b40 <p>,r0
10865: 00 00 50
10868: 90 a0 03 a0 movb 0x3(r0),0x2(r0)
1086c: 02
1086d: d1 60 8f 61 cmpl (r0),$0x64646261
10871: 62 64 64
10874: 13 07 beql 1087d <main_test+0x21>
to:
10861: 9e ef e1 12 movab 11b48 <p>,r0
10865: 00 00 50
10868: 90 a0 03 a0 movb 0x3(r0),0x2(r0)
1086c: 02
1086d: d1 ef d5 12 cmpl 11b48 <p>,$0x64646261
10871: 00 00 8f 61
10875: 62 64 64
10878: 13 07 beql 10881 <main_test+0x25>
(from `memmove-2.x2') due to the constant propagation passes eagerly
replacing pseudo registers with direct symbol references where possible,
which does not happen with CC0 even though the passes do run regardless.
There are further code quality regressions due to earlier compilation
stages trying to push expression evaluation earlier where possible so
as to make data dependencies further apart from each other. This works
well for computations and architectures that do not involve condition
codes set as a side effect of calculations. However for integer
negation that makes assembly code produced like:
movb *8(%ap),%r0
mnegb %r0,%r1
tstb %r0
jeql .L2
the RTL equibvalent of which the comparison elimination pass cannot
really do anything about, because the comparison is made on the source
rather than the target operand of the negation (we could add a peephole
for this, but this seems futile an effort, as one'd have to iterate over
all the possible such cases), even though this is really equivalent to:
movb *8(%ap),%r0
mnegb %r0,%r1
jeql .L2
or, if R0 is dead at the conclusion of the branch, even:
mnegb *8(%ap),%r1
jeql .L2
Since the compiler insists on doing the comparison on the source of the
negation it obviously has to load it into a temporary so as to avoid
accessing the original memory location twice, hence the sequence of
three instructions rather than just a single one. A similar phenomenon
can be observed with the XOR operation and in other cases.
In some cases a comparison does get eliminated, however useless moves
into registers done in preparation to it remain, such as with:
movb *8(%ap),%r2
movb *12(%ap),%r1
subb3 %r1,%r2,%r0
jlssu .L2
where R1 and R2 are both dead at conclusion and therefore:
subb3 *12(%ap),*8(%ap),%r0
jlssu .L2
would obviously do, but there was to be a comparison before the branch:
cmpb %r2,%r1
All this looks like material for future improvement.
Test cases for comparison elimination and the peepholes will be supplied
separately.
gcc/
PR target/95294
* config/vax/elf.h (REGISTER_NAMES): Append `%psl'.
* config/vax/vax-modes.def (CCN, CCNZ, CCZ): New modes.
* config/vax/vax-protos.h (vax_select_cc_mode): New prototype.
(vax_maybe_split_dimode_move): Likewise.
(vax_notice_update_cc): Remove prototype.
* config/vax/vax.c (TARGET_FLAGS_REGNUM): New macro.
(TARGET_CC_MODES_COMPATIBLE): Likewise.
(TARGET_MD_ASM_ADJUST): Likewise.
(vax_select_cc_mode): New function
(vax_cc_modes_compatible): Likewise.
(vax_md_asm_adjust): Likewise.
(vax_notice_update_cc): Remove function.
(vax_output_int_move): Factor out code checking if a DImode move
may have to be split...
(vax_maybe_split_dimode_move): ... into this new function.
* config/vax/vax.h (FIRST_PSEUDO_REGISTER): Bump up.
(FIXED_REGISTERS): Append an entry for PSL.
(CALL_USED_REGISTERS): Likewise.
(NOTICE_UPDATE_CC, OUTPUT_JUMP): Remove macros.
(SELECT_CC_MODE): New macro.
(REGISTER_NAMES): Append `psl'.
* config/vax/predicates.md (const_zero_operand)
(vax_cc_comparison_operator, vax_ccn_comparison_operator)
(vax_ccnz_comparison_operator, vax_ccz_comparison_operator):
New predicates.
* config/vax/builtins.md: Rewrite for MODE_CC representation.
* config/vax/vax.md: Likewise.
|
|
Fix a testsuite failure:
/tmp/ccL65Mmt.s: Assembler messages:
/tmp/ccL65Mmt.s:36: Warning: Symbol n used as immediate operand in PIC mode.
FAIL: gcc.dg/lto/pr55660 c_lto_pr55660_0.o-c_lto_pr55660_1.o link, -O0 -flto -flto-partition=none -fuse-linker-plugin
where non-PIC code is substituted by the LTO compiler at the link stage
for what used to be PIC code in the original compilation. This happens
because in the de-facto VAX ELF psABI we rely on code being PIC for GOT
support in dynamic executables and arrange that by having `-fPIC' passed
to the compiler by default by means of a specs recipe.
That is however canceled where the LTO wrapper is used, by an internal
arrangement in the LTO compiler that clears the PIC flag whenever the
`-flinker-output=exec' option has been used. This has been deliberately
introduced with commit 1ff9ed6fb282 ("re PR lto/67548 (LTO drops weak
binding with "ld -r")")[1]:
"In the log of PR67548 HJ actually pointed out that we do have API at
linker plugin side which says what type of output is done. This is cool
because we can also use it to drop -fpic when building static binary.
This is common in Firefox, where some objects are built with -fpic and
linked to both binaries and libraries."
with this code:
case LTO_LINKER_OUTPUT_EXEC: /* Normal executable */
flag_pic = 0;
flag_pie = 0;
flag_shlib = 0;
break;
Consequently code like:
.L6:
addl3 -8(%fp),$n,%r0
pushl %r0
calls $1,foo
addl2 %r0,-12(%fp)
incl -8(%fp)
.L5:
is produced by the LTO compiler, where a reference to `n' is used that
is invalid in PIC code, because it uses the immediate addressing mode,
denoted by the `$' prefix.
For that not to happen we must never pass `-flinker-output=exec' to the
LTO compiler unless non-PIC code has been explicitly requested. Using
`-flinker-output=dyn' except for relocatable output would seem the
simplest approach, as it does not fiddle with any of the internal code
model settings beyond what the command-line options have arranged and
therefore lets them remain the same as with the original compilation,
but it breaks as well causing PR lto/69866 to retrigger, as that code
seems sensitive to `flag_shlib':
lto1: internal compiler error: in add_symbol_to_partition_1, at lto/lto-partition.c:152
0x105be1cb add_symbol_to_partition_1
.../gcc/lto/lto-partition.c:152
0x105be443 add_symbol_to_partition_1
.../gcc/lto/lto-partition.c:194
0x105be80f add_symbol_to_partition
.../gcc/lto/lto-partition.c:270
0x105bee6f add_sorted_nodes
.../gcc/lto/lto-partition.c:395
0x105c0903 lto_balanced_map(int, int)
.../gcc/lto/lto-partition.c:815
0x105aa91f do_whole_program_analysis
.../gcc/lto/lto.c:499
0x105aac97 lto_main()
.../gcc/lto/lto.c:637
Please submit a full bug report,
with preprocessed source if appropriate.
Please include the complete backtrace with any bug report.
See <https://gcc.gnu.org/bugs/> for instructions.
lto-wrapper: fatal error: .../gcc/xgcc returned 1 exit status
compilation terminated.
.../usr/bin/vax-netbsdelf-ld: error: lto-wrapper failed
collect2: error: ld returned 1 exit status
compiler exited with status 1
FAIL: gcc.dg/lto/pr69866 c_lto_pr69866_0.o-c_lto_pr69866_1.o link, -O0 -flto -fuse-linker-plugin -fno-fat-lto-objects (internal compiler error)
Substitute `-flinker-output=pie' for `-flinker-output=exec' in the specs
then unless `-no-pie' has also been used, preserving the original intent
of emitting PIC code by default for executables while keeping the linker
arrangement unchanged. The LTO compiler uses the `cc1' spec, so keep
`cc1plus' unmodified.
This makes code like:
.L6:
movab n,%r0
addl2 -8(%fp),%r0
pushl %r0
calls $1,foo
addl2 %r0,-12(%fp)
incl -8(%fp)
.L5:
be produced instead corresponding to the fragment quoted above, which is
valid PIC code as it uses the PC-relative addressing mode denoted by the
absence of a prefix to `n' (which can be redirected to GOT as required,
by changing the addressing mode to PC-relative indirect in the operand
specifier).
Ideally we would instead default to the PIE model for executables, but
that triggers a BFD bug where for a change the LTO wrapper is not used:
.../usr/bin/vax-netbsdelf-ld: /tmp/ccV2sWQt.ltrans0.ltrans.o: warning: GOT addend of 3 to `n' does not match previous GOT addend of 0
FAIL: gcc.dg/lto/pr55660 c_lto_pr55660_0.o-c_lto_pr55660_1.o link, -O2 -flto -flto-partition=1to1 -fno-use-linker-plugin
which is due to assembly code like:
main:
.word 0
subl2 $4,%sp
movab n,%r0
movab n+3,%r2
clrl %r3
movb $98,%r1
.L4:
and consequently object code like:
00000000 <main>:
0: 00 00 .word 0x0000 # Entry mask: < >
2: c2 04 5e subl2 $0x4,sp
5: 9e ef 00 00 movab b <main+0xb>,r0
9: 00 00 50
7: R_VAX_GOT32 n
c: 9e ef 00 00 movab 12 <main+0x12>,r2
10: 00 00 52
e: R_VAX_GOT32 n+0x3
13: d4 53 clrf r3
15: 90 8f 62 51 movb $0x62,r1
being produced. This would be problematic for external `n', because we
do not support multiple GOT entries for the same symbol referred to with
different offsets in a single link unit. In this case however the LTO
compiler correctly observes that `n' is defined by the executable and
not preemptible and therefore no GOT entry will be made for it.
Indeed a valid executable is produced:
00010548 <main>:
10548: 00 00 .word 0x0000 # Entry mask: < >
1054a: c2 04 5e subl2 $0x4,sp
1054d: 9e ef dd 14 movab 11a30 <n>,r0
10551: 00 00 50
10554: 9e ef d9 14 movab 11a33 <__bss_start>,r2
10558: 00 00 52
1055b: d4 53 clrf r3
1055d: 90 8f 62 51 movb $0x62,r1
despite the warning, but it would be rather bad to have users annoyed
with this message from BFD, however harmless, especially as it triggers
outside LTO compilations as well.
Therefore this change is the best we can do until binutils have been
fixed.
References:
[1] Jan Hubicka, "Getting LTO incremental linking work",
<https://gcc.gnu.org/ml/gcc-patches/2015-11/msg02986.html>
gcc/
* config/vax/elf.h (VAX_CC1_SPEC, VAX_CC1PLUS_SPEC): New macros.
* config/vax/netbsd-elf.h (CC1_SPEC): Use VAX_CC1_SPEC rather
than VAX_CC1_AND_CC1PLUS_SPEC.
(CC1PLUS_SPEC): Use VAX_CC1PLUS_SPEC rather than
VAX_CC1_AND_CC1PLUS_SPEC.
|
|
We do not define a comparison operation between floating-point and
integer data, including integer zero constant. Consequently the RTL
instruction stream presented to the post-reload comparison elimination
pass will include, where applicable, floating-point comparison insns
against `const_double:DF 0.0 [0x0.0p+0]' rather than `const_int 0 [0]',
meaning that the latter expression will not match when used in machine
description.
Use `const_double_zero' then for the relevant patterns to match the
intended RTL instructions.
gcc/
* config/pdp11/pdp11.md (fcc_cc, fcc_ccnz): Use
`const_double_zero' to express double zero constant.
|
