aboutsummaryrefslogtreecommitdiff
path: root/gcc
AgeCommit message (Collapse)AuthorFilesLines
2020-11-22widening_mul: pattern recognize further forms of __builtin_add_overflow ↵Jakub Jelinek2-14/+307
[PR95853] The following patch recognizes some further forms of additions with overflow checks as shown in the testcase, in particular where the unsigned addition is performed in a wider mode just to catch overflow with a > narrower_utype_max check. 2020-11-22 Jakub Jelinek <jakub@redhat.com> PR tree-optimization/95853 * tree-ssa-math-opts.c (uaddsub_overflow_check_p): Add maxval argument, if non-NULL, instead look for r > maxval or r <= maxval comparisons. (match_uaddsub_overflow): Pattern recognize even other forms of __builtin_add_overflow, in particular when addition is performed in a wider type and result compared to maximum of the narrower type. * gcc.dg/pr95853.c: New test.
2020-11-22Partially revert recent H8 patch for conditional branchesJeff Law1-25/+41
So I'd forgotten an important tidbit on the H8 port. Specifically for a branch instruction, the target label must be operand 0 for the length computations. This really only affects the main conditional branch pattern. The other conditional branch patterns are split and ultimately funnel into the main pattern. This patch fixes the issue by partially reverting an earlier change. This issue didn't show up until late in the optimization work on cc0 removal of the H8 port, but was caught by the testsuite. So there's no new test. Built and regression tested H8 with this change, with and without the cc0 removal patches. gcc/ * config/h8300/jumpcall.md (branch_true, branch_false): Revert recent change. Ensure operand[0] is always the target label.
2020-11-22Darwin : Avoid a C++ ODR violation seen with LTO.Iain Sandoe1-8/+7
We have a similar code pattern in darwin-c.c to one in c-pragmas (most likely a cut & paste) with a struct type used locally to the TU. With C++ we need to rename the type to avoid an ODR violation. gcc/ChangeLog: * config/darwin-c.c (struct f_align_stack): Rename to type from align_stack to f_align_stack. (push_field_alignment): Likewise. (pop_field_alignment): Likewise.
2020-11-22Daily bump.GCC Administrator6-1/+198
2020-11-21c++: Extend -Wrange-loop-construct for binding-to-temp [PR94695]Marek Polacek3-4/+254
This patch finishes the second half of -Wrange-loop-construct I promised to implement: it warns when a loop variable in a range-based for-loop is initialized with a value of a different type resulting in a copy. For instance: int arr[10]; for (const double &x : arr) { ... } where in every iteration we have to create and destroy a temporary value of type double, to which we bind the reference. This could negatively impact performance. As per Clang, this doesn't warn when the range returns a copy, hence the glvalue_p check. gcc/ChangeLog: PR c++/94695 * doc/invoke.texi: Update the -Wrange-loop-construct description. gcc/cp/ChangeLog: PR c++/94695 * parser.c (warn_for_range_copy): Warn when the loop variable is initialized with a value of a different type resulting in a copy. gcc/testsuite/ChangeLog: PR c++/94695 * g++.dg/warn/Wrange-loop-construct2.C: New test.
2020-11-21c++: Reject identifier label in constexpr [PR97846]Marek Polacek2-1/+17
[dcl.constexpr]/3 says that the function-body of a constexpr function shall not contain an identifier label, but we aren't enforcing that. This patch implements that. Of course, we can't reject artificial labels. gcc/cp/ChangeLog: PR c++/97846 * constexpr.c (potential_constant_expression_1): Reject LABEL_EXPRs that use non-artifical LABEL_DECLs. gcc/testsuite/ChangeLog: PR c++/97846 * g++.dg/cpp1y/constexpr-label.C: New test.
2020-11-21c++: Fix ICE-on-invalid with -Wvexing-parse [PR97881]Marek Polacek2-6/+13
This invalid (?) code broke my assumption that if decl_specifiers->type is null, there must be any type-specifiers. Turn the assert into an if to fix this crash. gcc/cp/ChangeLog: PR c++/97881 * parser.c (warn_about_ambiguous_parse): Only assume "int" if we actually saw any type-specifiers. gcc/testsuite/ChangeLog: PR c++/97881 * g++.dg/warn/Wvexing-parse9.C: New test.
2020-11-21testsuite: localclass2 require LTODavid Edelsohn1-1/+2
The testcase uses LTO but does not include the dg-require LTO. gcc/testsuite/ChangeLog: * g++.dg/debug/localclass2.C: Require LTO.
2020-11-21c++: Allow template lambdas without lambda-declarator [PR97839]Marek Polacek2-8/+15
Our implementation of template lambdas incorrectly requires the optional lambda-declarator. This was probably required by an early draft of generic lambdas, but now the production is [expr.prim.lambda.general]: lambda-expression: lambda-introducer lambda-declarator [opt] compound-statement lambda-introducer < template-parameter-list > requires-clause [opt] lambda-declarator [opt] compound-statement Therefore, we should accept the following test. gcc/cp/ChangeLog: PR c++/97839 * parser.c (cp_parser_lambda_declarator_opt): Don't require (). gcc/testsuite/ChangeLog: PR c++/97839 * g++.dg/cpp2a/lambda-generic8.C: New test.
2020-11-21Use OEP_MATCH_SIDE_EFFECTS in compare_ao_refsJan Hubicka1-4/+5
* tree-ssa-alias.c (ao_compare::compare_ao_refs, ao_compare::hash_ao_ref): Use OEP_MATCH_SIDE_EFFECTS.
2020-11-21c++: Fix wrong error with constexpr destructor [PR97427]Marek Polacek2-16/+49
When I implemented the code to detect modifying const objects in constexpr contexts, we couldn't have constexpr destructors, so I didn't consider them. But now we can and that caused a bogus error in this testcase: [class.dtor]p5 says that "const and volatile semantics are not applied on an object under destruction. They stop being in effect when the destructor for the most derived object starts." so we have to clear the TREE_READONLY flag we set on the object after the constructors have been called to mark it as no-longer-under-construction. In the ~Foo call it's now an object under destruction, so don't report those errors. gcc/cp/ChangeLog: PR c++/97427 * constexpr.c (cxx_set_object_constness): New function. (cxx_eval_call_expression): Set new_obj for destructors too. Call cxx_set_object_constness to set/unset TREE_READONLY of the object under construction/destruction. gcc/testsuite/ChangeLog: PR c++/97427 * g++.dg/cpp2a/constexpr-dtor10.C: New test.
2020-11-21Update vec-35.c and vect-35-big-array.cJan Hubicka2-12/+2
We now determine depnedencies across union fields correctly. * gcc.dg/vect/vect-35-big-array.c: Excpect 2 loops to be vectorized. * gcc.dg/vect/vect-35.c: Excpect 2 loops to be vectorized.
2020-11-21Improve hasing of anonymous namespace typesJan Hubicka1-1/+15
* ipa-icf.c (sem_function::equals_wpa): Do not compare ODR type with -fno-devirtualize. (sem_item_optimizer::update_hash_by_addr_refs): Hash anonymous ODR types by TYPE_UID of their main variant.
2020-11-21Re-enable vector pair memcpy/memmove expansionAaron Sawdey1-5/+4
After the MMA opaque mode patch goes in, we can re-enable use of vector pair in the inline expansion of memcpy/memmove. gcc/ * config/rs6000/rs6000.c (rs6000_option_override_internal): Enable vector pair memcpy/memmove expansion.
2020-11-21Make MMA builtins use opaque modesAaron Sawdey13-372/+517
This patch changes powerpc MMA builtins to use the new opaque mode class and use modes OO (32 bytes) and XO (64 bytes) instead of POI/PXI. Using the opaque modes prevents optimization from trying to do anything with vector pair/quad, which was the problem we were seeing with the partial integer modes. gcc/ * config/rs6000/mma.md (unspec): Add assemble/extract UNSPECs. (movoi): Change to movoo. (*movpoi): Change to *movoo. (movxi): Change to movxo. (*movpxi): Change to *movxo. (mma_assemble_pair): Change to OO mode. (*mma_assemble_pair): New define_insn_and_split. (mma_disassemble_pair): New define_expand. (*mma_disassemble_pair): New define_insn_and_split. (mma_assemble_acc): Change to XO mode. (*mma_assemble_acc): Change to XO mode. (mma_disassemble_acc): New define_expand. (*mma_disassemble_acc): New define_insn_and_split. (mma_<acc>): Change to XO mode. (mma_<vv>): Change to XO mode. (mma_<avv>): Change to XO mode. (mma_<pv>): Change to OO mode. (mma_<apv>): Change to XO/OO mode. (mma_<vvi4i4i8>): Change to XO mode. (mma_<avvi4i4i8>): Change to XO mode. (mma_<vvi4i4i2>): Change to XO mode. (mma_<avvi4i4i2>): Change to XO mode. (mma_<vvi4i4>): Change to XO mode. (mma_<avvi4i4>): Change to XO mode. (mma_<pvi4i2>): Change to XO/OO mode. (mma_<apvi4i2>): Change to XO/OO mode. (mma_<vvi4i4i4>): Change to XO mode. (mma_<avvi4i4i4>): Change to XO mode. * config/rs6000/predicates.md (input_operand): Allow opaque. (mma_disassemble_output_operand): New predicate. * config/rs6000/rs6000-builtin.def: Changes to disassemble builtins. * config/rs6000/rs6000-call.c (rs6000_return_in_memory): Disallow __vector_pair/__vector_quad as return types. (rs6000_promote_function_mode): Remove function return type check because we can't test it here any more. (rs6000_function_arg): Do not allow __vector_pair/__vector_quad as as function arguments. (rs6000_gimple_fold_mma_builtin): Handle mma_disassemble_* builtins. (rs6000_init_builtins): Create types for XO/OO modes. * config/rs6000/rs6000-modes.def: DElete OI, XI, POI, and PXI modes, and create XO and OO modes. * config/rs6000/rs6000-string.c (expand_block_move): Update to OO mode. * config/rs6000/rs6000.c (rs6000_hard_regno_mode_ok_uncached): Update for XO/OO modes. (rs6000_rtx_costs): Make UNSPEC_MMA_XXSETACCZ cost 0. (rs6000_modes_tieable_p): Update for XO/OO modes. (rs6000_debug_reg_global): Update for XO/OO modes. (rs6000_setup_reg_addr_masks): Update for XO/OO modes. (rs6000_init_hard_regno_mode_ok): Update for XO/OO modes. (reg_offset_addressing_ok_p): Update for XO/OO modes. (rs6000_emit_move): Update for XO/OO modes. (rs6000_preferred_reload_class): Update for XO/OO modes. (rs6000_split_multireg_move): Update for XO/OO modes. (rs6000_mangle_type): Update for opaque types. (rs6000_invalid_conversion): Update for XO/OO modes. * config/rs6000/rs6000.h (VECTOR_ALIGNMENT_P): Update for XO/OO modes. * config/rs6000/rs6000.md (RELOAD): Update for XO/OO modes. gcc/testsuite/ * gcc.target/powerpc/mma-double-test.c (main): Call abort for failure. * gcc.target/powerpc/mma-single-test.c (main): Call abort for failure. * gcc.target/powerpc/pr96506.c: Rename to pr96506-1.c. * gcc.target/powerpc/pr96506-2.c: New test.
2020-11-21Additional small changes to support opaque modesAaron Sawdey12-1/+19
After building some larger codes using opaque types and some c++ codes using opaque types it became clear I needed to go through and look for places where opaque types and modes needed to be handled. A whole pile of one-liners. gcc/ * typeclass.h: Add opaque_type_class. * builtins.c (type_to_class): Identify opaque type class. * dwarf2out.c (is_base_type): Handle opaque types. (gen_type_die_with_usage): Handle opaque types. * expr.c (count_type_elements): Opaque types should never have initializers. * ipa-devirt.c (odr_types_equivalent_p): No type-specific handling for opaque types is needed as it eventually checks the underlying mode which is what is important. * tree-streamer.c (record_common_node): Handle opaque types. * tree.c (type_contains_placeholder_1): Handle opaque types. (type_cache_hasher::equal): No additional comparison needed for opaque types. gcc/c-family * c-pretty-print.c (c_pretty_printer::simple_type_specifier): Treat opaque types like other types. (c_pretty_printer::direct_abstract_declarator): Opaque types are supported types. gcc/c * c-aux-info.c (gen_type): Support opaque types. gcc/cp * error.c (dump_type): Handle opaque types. (dump_type_prefix): Handle opaque types. (dump_type_suffix): Handle opaque types. (dump_expr): Handle opaque types. * pt.c (tsubst): Allow opaque types in templates. (unify): Allow opaque types in templates. * typeck.c (structural_comptypes): Handle comparison of opaque types.
2020-11-20libgo: update to Go 1.15.5 releaseIan Lance Taylor1-1/+1
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/272146
2020-11-21Daily bump.GCC Administrator15-1/+322
2020-11-20Include math.h in nextafter-2.c test.Michael Meissner1-0/+12
Since the test is compiled with -fno-builtin, include math.h to allow for implementations (like the PowerPC) that have multiple versions of long double that are selectable by switch. Math.h could possibly switch what function nextafterl points to. gcc/testsuite/ 2020-11-17 Michael Meissner <meissner@linux.ibm.com> * gcc.dg/nextafter-2.c: Include math.h.
2020-11-20Power10: Add missing IEEE 128-bit XSCMP* built-in mappings.Michael Meissner1-0/+16
This patch adds support for mapping the scalar_cmp_exp_qp_* built-in functions to handle arguments that are either TFmode or KFmode, depending on whether long double uses the IEEE 128-bit representation (TFmode) or the IBM 128-bit representation (KFmode). This shows up in the float128-cmp2-runnable.c test when long double uses the IEEE 128-bit representation. gcc/ 2020-11-20 Michael Meissner <meissner@linux.ibm.com> * config/rs6000/rs6000-call.c (rs6000_expand_builtin): Add missing XSCMP* cases for IEEE 128-bit long double.
2020-11-20dwarf2: ICE with local class in unused function [PR97918]Jason Merrill2-3/+26
Here, since we only mention bar<B>, we never emit debug information for it. But we do emit debug information for H<J>::h, so we need to refer to the debug info for bar<B>::J even though there is no bar<B>. We deal with this sort of thing in dwarf2out with the limbo_die_list; parentless dies like J get attached to the CU at EOF. But here, we were flushing the limbo list, then generating the template argument DIE for H<J> that refers to J, which adds J to the limbo list, too late to be flushed. So let's flush a little later. gcc/ChangeLog: PR c++/97918 * dwarf2out.c (dwarf2out_early_finish): flush_limbo_die_list after gen_scheduled_generic_parms_dies. gcc/testsuite/ChangeLog: PR c++/97918 * g++.dg/debug/localclass2.C: New test.
2020-11-20PR middle-end/97861 - ICE on an invalid redeclaration of a function with ↵Martin Sebor2-7/+17
attribute access gcc/c-family/ChangeLog: * c-warn.c (warn_parm_array_mismatch): Bail on invalid redeclarations with fewer arguments. gcc/testsuite/ChangeLog: * gcc.dg/attr-access-4.c: New test.
2020-11-20libada: Check for the presence of _SC_NPROCESSORS_ONLNMaciej W. Rozycki1-3/+1
Check for the presence of _SC_NPROCESSORS_ONLN rather than using a list of OS-specific macros to decide whether to use `sysconf' like elsewhere across GCC sources, fixing a compilation error: adaint.c: In function '__gnat_number_of_cpus': adaint.c:2398:26: error: '_SC_NPROCESSORS_ONLN' undeclared (first use in this function) 2398 | cores = (int) sysconf (_SC_NPROCESSORS_ONLN); | ^~~~~~~~~~~~~~~~~~~~ adaint.c:2398:26: note: each undeclared identifier is reported only once for each function it appears in at least with with VAX/NetBSD 1.6.2. gcc/ada/ * adaint.c (__gnat_number_of_cpus): Check for the presence of _SC_NPROCESSORS_ONLN rather than a list of OS-specific macros to decide whether to use `sysconf'.
2020-11-20PR middle-end/97879 - ICE on invalid mode in attribute accessMartin Sebor4-13/+51
gcc/c-family/ChangeLog: PR middle-end/97879 * c-attribs.c (handle_access_attribute): Handle ATTR_FLAG_INTERNAL. Error out on invalid modes. gcc/c/ChangeLog: PR middle-end/97879 * c-decl.c (start_function): Set ATTR_FLAG_INTERNAL in flags. gcc/ChangeLog: PR middle-end/97879 * tree-core.h (enum attribute_flags): Add ATTR_FLAG_INTERNAL. gcc/testsuite/ChangeLog: PR middle-end/97879 * gcc.dg/attr-access-3.c: New test.
2020-11-20compiler, libgo: change mangling schemeIan Lance Taylor12-713/+986
Overhaul the mangling scheme to avoid ambiguities if the package path contains a dot. Instead of using dot both to separate components and to mangle characters, use dot only to separate components and use underscore to mangle characters. For golang/go#41862 Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/271726
2020-11-20Improve hashing of decls in ipa-icf-gimpleJan Hubicka1-1/+19
Another remaining case is that we end up comparing calls with mismatching number of parameters or with different permutations of them. This is because we hash decls to nothing. This patch improves that by hashing decls by their code and parm decls by indexes that are stable. Also for defualt defs in SSA_NAMEs we can add the corresponding decl (that is usually parm decls). Still we could improve on this by hasing ssa names by their definit parameters and possibly making maps of other decls and assigning them stable function local IDs. * ipa-icf-gimple.c (func_checker::hash_operand): Improve hashing of decls.
2020-11-20Only compare sizes of automatic variablesJan Hubicka1-2/+15
one of common remaining reasons for ICF to fail after loading in fuction body is mismatched type of automatic vairable. This is becuase compatible_types_p resorts to checking TYPE_MAIN_VARIANTS for euqivalence that prevents merging many TBAA compaitle cases. (And thus is also not reflected by the hash extended by alias sets of accesses.) Since in gimple automatic variables are just blocks of memory I think we should only check its size only. All accesses are matched when copmparing the actual loads/stores. I am not sure if we need to match types of other DECLs but I decided I can try to be safe here: for PARM_DECl/RESUILT_DECL we match them anyway to be sure that functions are ABI compatible. For CONST_DECL and readonly global VAR_DECLs they are matched when comparing their constructors. * ipa-icf-gimple.c (func_checker::compare_decl): Do not compare types of local variables.
2020-11-20re: FAIL: gcc.dg/pr97515.cAndrew MacLeod1-3/+5
Adjust testcase to check in CCP not EVRP. gcc/testuite/ * gcc.dg/pr97515.c: Check in ccp2, not evrp.
2020-11-20PR target/97727 aarch64: [testcase] fix bf16_vstN_lane_2.c for big endian ↵Andrea Corallo1-7/+3
targets gcc/testsuite/ChangeLog 2020-11-09 Andrea Corallo <andrea.corallo@arm.com> PR target/97727 * gcc.target/aarch64/advsimd-intrinsics/bf16_vstN_lane_2.c: Relax regexps.
2020-11-20doc: Fixup a couple of formatting nitsNathan Sidwell1-2/+2
I noticed a couple of places we used @code{program} instead of @command{program}. gcc/ * doc/invoke.texi: Replace a couple of @code with @command
2020-11-20[PR target/97726] arm: [testsuite] fix some simd tests on armbeAndrea Corallo3-37/+43
2020-11-10 Andrea Corallo <andrea.corallo@arm.com> PR target/97726 * gcc.target/arm/simd/bf16_vldn_1.c: Relax regexps not to fail on big endian. * gcc.target/arm/simd/vldn_lane_bf16_1.c: Likewise * gcc.target/arm/simd/vmmla_1.c: Add -mfloat-abi=hard flag.
2020-11-20SLP: Have vectorizable_slp_permutation set type on invariantsTamar Christina1-1/+2
This modifies vectorizable_slp_permutation to update the type of the children of a perm node before trying to permute them. This allows us to be able to permute invariant nodes. This will be covered by test from the SLP pattern matcher. gcc/ChangeLog: * tree-vect-slp.c (vectorizable_slp_permutation): Update types on nodes when needed.
2020-11-20Deal with (pattern) SLP consumed stmts in hybrid discoveryRichard Biener1-7/+72
This makes hybrid SLP discovery deal with stmts indirectly consumed by SLP, for example via patterns. This means that all uses of a stmt end up in SLP vectorized stmts. This helps my prototype patches for PR97832 where I make SLP discovery re-associate chains to make operands match. This ends up building SLP computation nodes without 1:1 representatives in the scalar IL and thus no scalar lane defs in SLP_TREE_SCALAR_STMTS. Nevertheless all of the original scalar stmts are consumed so this represents another kind of SLP pattern for the computation chain result. 2020-11-20 Richard Biener <rguenther@suse.de> * tree-vect-slp.c (maybe_push_to_hybrid_worklist): New function. (vect_detect_hybrid_slp): Use it. Perform a backward walk over the IL.
2020-11-20dump SLP_TREE_REPRESENTATIVERichard Biener1-0/+8
It always annoyed me to see those empty SLP nodes in dumpfiles: t.c:16:3: note: node 0x3a2a280 (max_nunits=1, refcnt=1) t.c:16:3: note: { } t.c:16:3: note: children 0x3a29db0 0x3a29e90 resulting from two-operator handling. The following makes sure to also dump the operation template or VEC_PERM_EXPR. 2020-11-20 Richard Biener <rguenther@suse.de> * tree-vect-slp.c (vect_print_slp_tree): Also dump SLP_TREE_REPRESENTATIVE.
2020-11-20c++: Add __builtin_clear_padding builtin - C++20 P0528R3 compiler side [PR88101]Jakub Jelinek14-0/+1094
The following patch implements __builtin_clear_padding builtin that clears the padding bits in object representation (but preserves value representation). Inside of unions it clears only those padding bits that are padding for all the union members (so that it never alters value representation). It handles trailing padding, padding in the middle of structs including bitfields (PDP11 unhandled, I've never figured out how those bitfields work), VLAs (doesn't handle variable length structures, but I think almost nobody uses them and it isn't worth the extra complexity). For VLAs and sufficiently large arrays it uses runtime clearing loop instead of emitting straight-line code (unless arrays are inside of a union). The way I think this can be used for atomics is e.g. if the structures are power of two sized and small enough that we use the hw atomics for say compare_exchange __builtin_clear_padding could be called first on the address of expected and desired arguments (for desired only if we want to ensure that most of the time the atomic memory will have padding bits cleared), then perform the weak cmpxchg and if that fails, we got the value from the atomic memory; we can call __builtin_clear_padding on a copy of that and then compare it with expected, and if it is the same with the padding bits masked off, we can use the original with whatever random padding bits in it as the new expected for next cmpxchg. __builtin_clear_padding itself is not atomic and therefore it shouldn't be called on the atomic memory itself, but compare_exchange*'s expected argument is a reference and normally the implementation may store there the current value from memory, so padding bits can be cleared in that, and desired is passed by value rather than reference, so clearing is fine too. When using libatomic, we can use it either that way, or add new libatomic APIs that accept another argument, pointer to the padding bit bitmask, and construct that in the template as alignas (_T) unsigned char _mask[sizeof (_T)]; std::memset (_mask, ~0, sizeof (_mask)); __builtin_clear_padding ((_T *) _mask); which will have bits cleared for padding bits and set for bits taking part in the value representation. Then libatomic could internally instead of using memcmp compare for (i = 0; i < N; i++) if ((val1[i] & mask[i]) != (val2[i] & mask[i])) 2020-11-20 Jakub Jelinek <jakub@redhat.com> PR libstdc++/88101 gcc/ * builtins.def (BUILT_IN_CLEAR_PADDING): New built-in function. * gimplify.c (gimplify_call_expr): Rewrite single argument BUILT_IN_CLEAR_PADDING into two-argument variant. * gimple-fold.c (clear_padding_unit, clear_padding_buf_size): New const variables. (struct clear_padding_struct): New type. (clear_padding_flush, clear_padding_add_padding, clear_padding_emit_loop, clear_padding_type, clear_padding_union, clear_padding_real_needs_padding_p, clear_padding_type_may_have_padding_p, gimple_fold_builtin_clear_padding): New functions. (gimple_fold_builtin): Handle BUILT_IN_CLEAR_PADDING. * doc/extend.texi (__builtin_clear_padding): Document. gcc/c-family/ * c-common.c (check_builtin_function_arguments): Handle BUILT_IN_CLEAR_PADDING. gcc/testsuite/ * c-c++-common/builtin-clear-padding-1.c: New test. * c-c++-common/torture/builtin-clear-padding-1.c: New test. * c-c++-common/torture/builtin-clear-padding-2.c: New test. * c-c++-common/torture/builtin-clear-padding-3.c: New test. * c-c++-common/torture/builtin-clear-padding-4.c: New test. * c-c++-common/torture/builtin-clear-padding-5.c: New test. * g++.dg/torture/builtin-clear-padding-1.C: New test. * g++.dg/torture/builtin-clear-padding-2.C: New test. * gcc.dg/builtin-clear-padding-1.c: New test.
2020-11-20arm: Fix up neon_vector_mem_operand [PR97528]Jakub Jelinek2-1/+31
The documentation for POST_MODIFY says: Currently, the compiler can only handle second operands of the form (plus (reg) (reg)) and (plus (reg) (const_int)), where the first operand of the PLUS has to be the same register as the first operand of the *_MODIFY. The following testcase ICEs, because combine just attempts to simplify things and ends up with (post_modify (reg1) (plus (mult (reg2) (const_int 4)) (reg1)) but the target predicates accept it, because they only verify that POST_MODIFY's second operand is PLUS and the second operand of the PLUS is a REG. The following patch fixes this by performing further verification that the POST_MODIFY is in the form it should be. 2020-11-20 Jakub Jelinek <jakub@redhat.com> PR target/97528 * config/arm/arm.c (neon_vector_mem_operand): For POST_MODIFY, require first POST_MODIFY operand is a REG and is equal to the first operand of PLUS. * gcc.target/arm/pr97528.c: New test.
2020-11-20Plug loophole in string store mergingEric Botcazou11-4/+173
There is a loophole in new string store merging support added recently: it does not check that the stores are consecutive, which is obviously required if you want to concatenate them... Simple fix attached, the nice thing being that it can fall back to the regular processing if any hole is detected in the series of stores, thanks to the handling of STRING_CST by native_encode_expr. gcc/ChangeLog: * gimple-ssa-store-merging.c (struct merged_store_group): Add new 'consecutive' field. (merged_store_group): Set it to true. (do_merge): Set it to false if the store is not consecutive and set string_concatenation to false in this case. (merge_into): Call do_merge on entry. (merge_overlapping): Likewise. gcc/testsuite/ChangeLog: * gnat.dg/opt90a.adb: New test. * gnat.dg/opt90b.adb: Likewise. * gnat.dg/opt90c.adb: Likewise. * gnat.dg/opt90d.adb: Likewise. * gnat.dg/opt90e.adb: Likewise. * gnat.dg/opt90a_pkg.ads: New helper. * gnat.dg/opt90b_pkg.ads: Likewise. * gnat.dg/opt90c_pkg.ads: Likewise. * gnat.dg/opt90d_pkg.ads: Likewise. * gnat.dg/opt90e_pkg.ads: Likewise.
2020-11-20Fix comment in ipa-icf-gimple.cJan Hubicka1-1/+1
* ipa-icf-gimple.c (func_checker::operand_equal_p): Fix comment.
2020-11-20Fix comparsion of {CLOBBER} in icfJan Hubicka1-0/+12
after fixing few issues I gotto stage where 1.4M icf mismatches are due to comparing two gimple clobber. The problem is that operand_equal_p match clobber case CONSTRUCTOR: /* In GIMPLE empty constructors are allowed in initializers of aggregates. */ return !CONSTRUCTOR_NELTS (arg0) && !CONSTRUCTOR_NELTS (arg1); But this happens too late after comparing its types (that are not very relevant for memory store). In the context of ipa-icf we do not really need to match RHS of gimple clobbers: it is enough to know that the LHS stores can be considered equivalent. I this added logic to hash them all the same way and compare using TREE_CLOBBER_P flag. I see other option in extending operand_equal_p in fold-const to handle them more generously or making stmt hash and compare to skip comparing/hashing RHS of gimple_clobber_p. * ipa-icf-gimple.c (func_checker::hash_operand): Hash gimple clobber. (func_checker::operand_equal_p): Special case gimple clobber.
2020-11-20i386: Optimize abs expansion [PR97873]Uros Bizjak4-61/+171
The patch introduces absM named pattern to generate optimal insn sequence for CMOVE_TARGET targets. Currently, the expansion goes through neg+max optabs, and the following code is generated: movl %edi, %eax negl %eax cmpl %edi, %eax cmovl %edi, %eax This sequence is unoptimal in two ways. a) The compare instruction is not needed, since NEG insn sets the sign flag based on the result. The CMOV can use sign flag to select between negated and original value: movl %edi, %eax negl %eax cmovs %edi, %eax b) On some targets, CMOV is undesirable due to its performance issues. In addition to TARGET_EXPAND_ABS bypass, the patch introduces STV conversion of abs RTX to use PABS SSE insn: vmovd %edi, %xmm0 vpabsd %xmm0, %xmm0 vmovd %xmm0, %eax The patch changes compare mode of NEG instruction to CCGOCmode, which is the same mode as the mode of SUB instruction. IOW, sign bit becomes usable. Also, the mode iterator of <maxmin:code><mode>3 pattern is changed to SWI48x instead of SWI248. The purpose of maxmin expander is to prepare max/min RTX for STV to eventually convert them to SSE PMAX/PMIN instructions, in order to *avoid* CMOV insns with general registers. 2020-11-20 Uroš Bizjak <ubizjak@gmail.com> gcc/ PR target/97873 * config/i386/i386.md (*neg<mode>2_2): Rename from "*neg<mode>2_cmpz". Use CCGOCmode instead of CCZmode. (*negsi2_zext): Rename from *negsi2_cmpz_zext. Use CCGOCmode instead of CCZmode. (*neg<mode>_ccc_1): New insn pattern. (*neg<dwi>2_doubleword): Use *neg<mode>_ccc_1. (abs<mode>2): Add FLAGS_REG clobber. Use TARGET_CMOVE insn predicate. (*abs<mode>2_1): New insn_and_split pattern. (*absdi2_doubleword): Ditto. (<maxmin:code><mode>3): Use SWI48x mode iterator. (*<maxmin:code><mode>3): Use SWI48 mode iterator. * config/i386/i386-features.c (general_scalar_chain::compute_convert_gain): Handle ABS code. (general_scalar_chain::convert_insn): Ditto. (general_scalar_to_vector_candidate_p): Ditto. gcc/testsuite/ PR target/97873 * gcc.target/i386/pr97873.c: New test. * gcc.target/i386/pr97873-1.c: New test.
2020-11-20configury: Fix up --enable-link-serialization supportJakub Jelinek13-40/+40
Eric reported that the --enable-link-serialization changes seemed to cause the binaries to be always relinked, for example from the gcc/ directory of the build tree: make [relink of gnat1, brig1, cc1plus, d21, f951, go1, lto1, ...] make [relink of gnat1, brig1, cc1plus, d21, f951, go1, lto1, ...] Furthermore as reported in PR, it can cause problems during make install where make install rebuilds the binaries again. The problem is that for make .PHONY targets are just "rebuilt" always, so it is very much undesirable for the cc1plus$(exeext) etc. dependencies to include .PHONY targets, but I was using them - cc1plus.prev which would depend on some *.serial and e.g. cc1.serial depending on c and c depending on cc1$(exeext). The following patch rewrites this so that *.serial and *.prev aren't .PHONY targets, but instead just make variables. I was worried that the order in which the language makefile fragments are included (which is quite random, what order we get from the filesystem matching */config-lang.in) would be a problem but it seems to work fine - as it uses make = rather than := variables, later definitions are just fine for earlier uses as long as the uses aren't needed during the makefile parsing, but only in the dependencies of make targets and in their commands. 2020-11-20 Jakub Jelinek <jakub@redhat.com> PR other/97911 gcc/ * configure.ac: In SERIAL_LIST use lang words without .serial suffix. Change $lang.prev from a target to variable and instead of depending on *.serial expand to the *.serial variable if the word is in the SERIAL_LIST at all, otherwise to nothing. * configure: Regenerated. gcc/c/ * Make-lang.in (c.serial): Change from goal to a variable. (.PHONY): Drop c.serial. gcc/ada/ * gcc-interface/Make-lang.in (ada.serial): Change from goal to a variable. (.PHONY): Drop ada.serial and ada.prev. (gnat1$(exeext)): Depend on $(ada.serial) rather than ada.serial. gcc/brig/ * Make-lang.in (brig.serial): Change from goal to a variable. (.PHONY): Drop brig.serial and brig.prev. (brig1$(exeext)): Depend on $(brig.serial) rather than brig.serial. gcc/cp/ * Make-lang.in (c++.serial): Change from goal to a variable. (.PHONY): Drop c++.serial and c++.prev. (cc1plus$(exeext)): Depend on $(c++.serial) rather than c++.serial. gcc/d/ * Make-lang.in (d.serial): Change from goal to a variable. (.PHONY): Drop d.serial and d.prev. (d21$(exeext)): Depend on $(d.serial) rather than d.serial. gcc/fortran/ * Make-lang.in (fortran.serial): Change from goal to a variable. (.PHONY): Drop fortran.serial and fortran.prev. (f951$(exeext)): Depend on $(fortran.serial) rather than fortran.serial. gcc/go/ * Make-lang.in (go.serial): Change from goal to a variable. (.PHONY): Drop go.serial and go.prev. (go1$(exeext)): Depend on $(go.serial) rather than go.serial. gcc/jit/ * Make-lang.in (jit.serial): Change from goal to a variable. (.PHONY): Drop jit.serial and jit.prev. ($(LIBGCCJIT_FILENAME)): Depend on $(jit.serial) rather than jit.serial. gcc/lto/ * Make-lang.in (lto1.serial, lto2.serial): Change from goals to variables. (.PHONY): Drop lto1.serial, lto2.serial, lto1.prev and lto2.prev. ($(LTO_EXE)): Depend on $(lto1.serial) rather than lto1.serial. ($(LTO_DUMP_EXE)): Depend on $(lto2.serial) rather than lto2.serial. gcc/objc/ * Make-lang.in (objc.serial): Change from goal to a variable. (.PHONY): Drop objc.serial and objc.prev. (cc1obj$(exeext)): Depend on $(objc.serial) rather than objc.serial. gcc/objcp/ * Make-lang.in (obj-c++.serial): Change from goal to a variable. (.PHONY): Drop obj-c++.serial and obj-c++.prev. (cc1objplus$(exeext)): Depend on $(obj-c++.serial) rather than obj-c++.serial.
2020-11-20rs6000: Fix p8_mtvsrd_df's insn typeKewen Lin1-1/+1
This patch is to fix insn type of p8_mtvsrd_df from mfvsr to mtvsr, in order to align with the other places using mtvsrd. gcc/ChangeLog: * config/rs6000/rs6000.md (p8_mtvsrd_df): Fix insn type.
2020-11-20C: Drop qualifiers during lvalue conversion [PR97702]Martin Uecker5-2/+58
2020-11-20 Martin Uecker <muecker@gwdg.de> gcc/ * gimplify.c (gimplify_modify_expr_rhs): Optimizie NOP_EXPRs that contain compound literals. gcc/c/ * c-typeck.c (convert_lvalue_to_rvalue): Drop qualifiers. gcc/testsuite/ * gcc.dg/cond-constqual-1.c: Adapt test. * gcc.dg/lvalue-11.c: New test. * gcc.dg/pr60195.c: Add warning.
2020-11-20Daily bump.GCC Administrator6-1/+318
2020-11-20ranger: Improve a % b operand ranges [PR91029]Jakub Jelinek3-16/+219
As mentioned in the PR, the previous PR91029 patch was testing op2 >= 0 which is unnecessary, even negative op2 values will work the same, furthermore, from if a % b > 0 we can deduce a > 0 rather than just a >= 0 (0 % b would be 0), and it actually valid even for other constants than 0, a % b > 5 means a > 5 (a % b has the same sign as a and a in [0, 5] would result in a % b in [0, 5]. Also, we can deduce a range for the other operand, if we know a % b >= 20, then b must be (in absolute value for signed modulo) > 20, for a % [0, 20] the result would be [0, 19]. 2020-11-19 Jakub Jelinek <jakub@redhat.com> PR tree-optimization/91029 * range-op.cc (operator_trunc_mod::op1_range): Don't require signed types, nor require that op2 >= 0. Implement (a % b) >= x && x > 0 implies a >= x and (a % b) <= x && x < 0 implies a <= x. (operator_trunc_mod::op2_range): New method. * gcc.dg/tree-ssa/pr91029-1.c: New test. * gcc.dg/tree-ssa/pr91029-2.c: New test.
2020-11-19Process only valid shift ranges.Andrew MacLeod4-28/+92
When shifting outside the valid range of [0, precision-1], we can choose to process just the valid ones since the rest is undefined. this allows us to produce results for x << [0,2][+INF, +INF] by discarding the invalid ranges and processing just [0,2]. gcc/ PR tree-optimization/93781 * range-op.cc (get_shift_range): Rename from undefined_shift_range_check and now return valid shift ranges. (operator_lshift::fold_range): Use result from get_shift_range. (operator_rshift::fold_range): Ditto. gcc/testsuite/ * gcc.dg/tree-ssa/pr93781-1.c: New. * gcc.dg/tree-ssa/pr93781-2.c: New. * gcc.dg/tree-ssa/pr93781-3.c: New.
2020-11-19c++: Template hash accessNathan Sidwell2-7/+112
This exposes the template specialization table, so the modules machinery may access it. The hashed entity (tmpl, args & spec) is available, along with a hash table walker. We also need a way of finding or inserting entries, along with some bookkeeping fns to deal with the instantiation and (partial) specialization lists. gcc/cp/ * cp-tree.h (struct spec_entry): Moved from pt.c. (walk_specializations, match_mergeable_specialization) (get_mergeable_specialization_flags) (add_mergeable_specialization): Declare. * pt.c (struct spec_entry): Moved to cp-tree.h. (walk_specializations, match_mergeable_specialization) (get_mergeable_specialization_flags) (add_mergeable_specialization): New.
2020-11-19c++: Expose constexpr hash tableNathan Sidwell3-61/+59
This patch exposes the constexpr hash table so that the modules machinery can save and load constexpr bodies. While there I noticed that we could do a little constification of the hasher and comparator functions. Also combine the saving machinery to a single function returning void -- nothing ever looked at its return value. gcc/cp/ * cp-tree.h (struct constexpr_fundef): Moved from constexpr.c. (maybe_save_constexpr_fundef): Declare. (register_constexpr_fundef): Take constexpr_fundef object, return void. * decl.c (mabe_save_function_definition): Delete, functionality moved to maybe_save_constexpr_fundef. (emit_coro_helper, finish_function): Adjust. * constexpr.c (struct constexpr_fundef): Moved to cp-tree.h. (constexpr_fundef_hasher::equal): Constify. (constexpr_fundef_hasher::hash): Constify. (retrieve_constexpr_fundef): Make non-static. (maybe_save_constexpr_fundef): Break out checking and duplication from ... (register_constexpr_fundef): ... here. Just register the constexpr.
2020-11-19Fix two bugs in operand_equal_pJan Hubicka1-28/+38
* fold-const.c (operand_compare::operand_equal_p): Fix thinko in COMPONENT_REF handling and guard types_same_for_odr by virtual_method_call_p. (operand_compare::hash_operand): Likewise.
2020-11-19c, tree: Fix ICE from get_parm_array_spec [PR97860]Jakub Jelinek3-1/+24
The C and C++ FEs handle zero sized arrays differently, C uses NULL TYPE_MAX_VALUE on non-NULL TYPE_DOMAIN on complete ARRAY_TYPEs with bitsize_zero_node TYPE_SIZE, while C++ FE likes to set TYPE_MAX_VALUE to the largest value (and min to the lowest). Martin has used array_type_nelts in get_parm_array_spec where the function on the C form of [0] arrays returns error_mark_node and the code crashes soon afterwards. The following patch teaches array_type_nelts about this (e.g. dwarf2out already handles that as [0]). While it will change what is_empty_type returns for certain types (e.g. struct S { int a[0]; };), as those types occupy zero bits in C, it should make an ABI difference. So, the tree.c change makes the c-decl.c code handle the [0] arrays like any other constant extents, and the c-decl.c change just makes sure that if we'd run into error_mark_node e.g. from the VLA expressions, we don't crash on those. 2020-11-19 Jakub Jelinek <jakub@redhat.com> PR c/97860 * tree.c (array_type_nelts): For complete arrays with zero min and NULL max and zero size return -1. * c-decl.c (get_parm_array_spec): Bail out of nelts is error_operand_p. * gcc.dg/pr97860.c: New test.
generated by cgit v1.1 at 2025-09-20 02:12:36 +0000