aboutsummaryrefslogtreecommitdiff
AgeCommit message (Collapse)AuthorFilesLines
2022-05-10[Ada] Remove tiny and incomplete optimization for unset referencesPiotr Trojanek1-9/+0
Code cleanup; behaviour is unaffected. gcc/ada/ * sem_warn.adb (Check_Unset_Reference): The early test was only saving time of calls to Original_Node, Comes_From_Source and Nkind, which are all quick and cheap.
2022-05-10[Ada] Cleanup unnecessary declare block in Check_Unreachable_CodePiotr Trojanek1-102/+98
Cleanup related to static detection of references to uninitialized variables. Semantics is unaffected. gcc/ada/ * sem_ch5.adb (Check_Unreachable_Code): Remove inner declare block; refill code and comments.
2022-05-10[Ada] Refine iteration from entities to formalsPiotr Trojanek1-12/+12
When matching formal parameters from spec and body it is cleaner and more efficient to iterate with First_Formal/Next_Formal and not with First_Entity/Next_Entity. The previous iteration could unintentionally pick entities from within the subprogram body, e.g. objects declared within the subprogram. gcc/ada/ * sem_ch6.adb (Analyze_Subprogram_Body_Helper): Replace First_Entity/Next_Entity with First_Formal/Next_Formal; rename E1/E2 to F1/F2.
2022-05-10[Ada] Check declare and qualified expressions for unset referencesPiotr Trojanek2-6/+6
Detection of references to unset (uninitialized) objects requires calls to Check_Unset_Reference on every subexpression of a composite statement and expression. For declare and qualified expressions this was done only when they occurred within another composite statement/expression. gcc/ada/ * sem_res.adb (Resolve_Declare_Expression): Check expression for references to unset objects. (Resolve_Qualified_Expression): Likewise. * sem_warn.adb (Check_Unset_Reference): Remove handling of declare and qualified expressions; clarify comment for type conversions.
2022-05-10[Ada] Check if- and case-expressions for unset referencesPiotr Trojanek1-0/+6
Detection of references to unset (uninitialized) objects requires calls to Check_Unset_Reference on every subexpression of a composite statement and expression. This was missing for if-expressions and incomplete for case-expressions. gcc/ada/ * sem_res.adb (Resolve_Case_Expression): Check alternative expressions for references to unset objects. (Resolve_If_Expression): Check condition, then and else expressions for references to unset objects.
2022-05-10[Ada] Fix a couple of typosKévin Le Gouguec4-8/+7
gcc/ada/ * doc/gnat_rm/implementation_defined_attributes.rst, doc/gnat_ugn/the_gnat_compilation_model.rst: Fix typos. * gnat_rm.texi, gnat_ugn.texi: Regenerate.
2022-05-10[Ada] Fix typo in comment for Is_Predicate_StaticEtienne Servais1-1/+1
gcc/ada/ * sem_ch13.adb (Is_Predicate_Static): Fix typo in comment.
2022-05-10[Ada] Fix indentation to follow uniform style across runtime unitsYannick Moy2-47/+53
gcc/ada/ * libgnat/s-valuei.adb: Fix indentation. * libgnat/s-valuei.ads: Same.
2022-05-10[Ada] Accept Structural in aspect Subprogram_Variant and pragma Loop_VariantClaire Dross4-25/+64
Add a new form of variants to ensure termination of loops or recursive subprograms. Structural variants correspond to objects which designate a part of the data-structure they used to designate in the previous loop iteration or recursive call. They only imply termination if the data-structure is acyclic, which is the case in SPARK but not in Ada in general. The fact that these variants are correct is only verified formally by the proof tool and not by the compiler or dynamically at execution like other forms of variants. gcc/ada/ * snames.ads-tmpl: Add "Structural" as a name. * sem_prag.adb: (Analyze_Pragma): Accept modifier "Structural" in pragmas Loop_Variant and Subprogram_Variant. Check that items associated to Structural occur alone in the pragma associations. (Analyze_Subprogram_Variant_In_Decl_Part): Idem. * exp_prag.adb (Expand_Pragma_Loop_Variant): Discard structural variants. (Expand_Pragma_Subprogram_Variant): Idem. gcc/testsuite/ * gnat.dg/loopvar.adb: Update expected error message.
2022-05-10[Ada] Proof of System.Val_Int at gold levelClaire Dross5-22/+289
gcc/ada/ * libgnat/s-valint.ads: Add SPARK_Mode and pragma to ignore assertions in instance and add additional ghost parameters to the instance of Value_I. * libgnat/s-vallli.ads: Idem. * libgnat/s-valllli.ads: Idem. * libgnat/s-valuei.ads, libgnat/s-valuei.adb: New generic parameters for ghost functions from System.Valueu. Add functional contracts.
2022-05-10[Ada] Fix hiding of user-defined operator that is not a homographEric Botcazou4-91/+19
This adds a missing test for the presence of a homograph when applying the RM 8.4(10) clause about the visibility of operators, and removes resolution code made obsolete by the change. There is also a fixlet for a previously undetected ambiguity in the runtime. gcc/ada/ * sem_res.adb (Resolve_Eqyality_Op): Remove obsolete code. (Resolve_Op_Not): Likewise. * sem_type.adb (Disambiguate): Add missing test for RM 8.4(10). * libgnat/s-dwalin.adb (Enable_Cache): Fix ambiguity. (Symbolic_Address): Likewise. gcc/testsuite/ * gnat.dg/equal7.adb: Add expected error messages (code is now illegal).
2022-05-10[Ada] Fix oversight for case expression in Eval_Integer_LiteralEric Botcazou1-1/+1
The intent of the entry test is to treat conditional expressions, that is to say if-expression and case-expression, alike and to require that a second condition be true for them. But an N_Case_Expression_Alternative is not an N_Subexpr so this second condition was short-circuited for this node. gcc/ada/ * sem_eval.adb (Eval_Integer_Literal): Fix oversight in entry test.
2022-05-10[Ada] Avoid repeated conversions from Int to Char_CodePiotr Trojanek1-8/+10
When expanding aggregates like "(others => 'x')" into strings we repeated conversion from Int to Char_Code for every character. Now we convert once and use the Char_Code directly. Cleanup related to handling characters in GNATprove counterexamples; semantics is unaffected. gcc/ada/ * exp_aggr.adb (Expand_N_Aggregate): Replace UI_To_Int with UI_To_CC; replace magic literals with high-level routines that recognise wide and wide wide characters; reorder if-then-elsif condition, because we don't have a routine to detect wide wide characters.
2022-05-10[Ada] Reject numeric literals with too big exponentsEtienne Servais1-0/+9
While the compiler can compute numeric literal with arbitrary large exponents, this may take ages and is most likely a typo. Better emit an error when we certainly expect it to take long. The chosen threshold takes about 100s to compute. gcc/ada/ * scng.adb (Nlit): Error on big UI_Scale.
2022-05-10[Ada] Replace variables with constants in expanded code for task namesPiotr Trojanek1-6/+12
Using constants instead of variables is cleaner both in human-written and auto-generated code. Cleanup related to handling of character values in SPARK counterexamples, which just like the code for names of tasks create N_Character_Literal nodes. gcc/ada/ * exp_util.adb (Build_Task_Array_Image): Declare expanded objects as constants. (Build_Task_Image_Prefix): Likewise. (Build_Task_Record_Image): Likewise.
2022-05-10[Ada] Fix incorrect range computationMarc Poulhiès1-13/+40
When the type range [Lo, Hi] and the computed expression range [Lor, Hir] are disjoint, the range-constraining logic breaks and returns an incorrect range. For example, when Lo<Hi<Lor<Hir, it currently returns [Lor, Hi]. Instead, return the computed range. The current constraining logic would require returning the base type's bounds. However, this would miss an opportunity to warn about out of range values for some cases (e.g. when type's upper bound is equal to base type upper bound). The alternative of always returning the computed values, even when ranges are intersecting, has unwanted effects (mainly useless constraint checks are inserted) in the Enable_Overflow_Check and Apply_Scalar_Range_Check as these bounds have a special interpretation. gcc/ada/ * checks.adb (Determine_Range): Fix range refining.
2022-05-10[Ada] Failure compiling "for ... of" loop over a sliceSteve Baird1-8/+18
In some cases involving a "for ... of" loop (not to be confused with the more common "for ... in" loop) iterating over a slice, compilation would fail with an internal compiler error. gcc/ada/ * sem_util.adb (Get_Actual_Subtype): If a new subtype is built, do not freeze it if Expander_Active is False. The idea here is to avoid generating an unwanted Freeze_Node for a subtype that has been conjured up solely for purposes of preanalysis.
2022-05-10[Ada] Fix comment about building names in task arraysPiotr Trojanek1-5/+5
Cleanup related to handling of character values in SPARK counterexamples, which just like the code for names in task arrays create N_Character_Literal nodes. gcc/ada/ * exp_util.adb (Build_Task_Array_Image): Fix style in the structure of generated code; add Pref'Length as the component of the Sum initialization expression.
2022-05-10[Ada] Simplify conversion from Character to Char_CodePiotr Trojanek6-17/+17
Replace "Char_Code (Character'Pos (...))" with "Get_Char_Code (...)". The Get_Char_Code routine is inlined, so there is no performance penalty when it is called with static actual parameters. The N_Character_Literal has field Char_Literal_Value of type Unat, but we should really only store there values from Char_Code type (e.g. there are no characters with negative ASCII codes). It seems cleaner to use UI_From_CC and not a more general UI_From_Int when setting the character literal values. Cleanup related to handling of character values in SPARK counterexamples, which just like the code for names in task arrays create N_Character_Literal nodes. gcc/ada/ * exp_prag.adb (Expand_Pragma_Import_Or_Interface): Use Get_Char_Code. * exp_util.adb (Build_Task_Array_Image): Simplify conversion to Char_Code. (Build_Task_Image_Prefix): Likewise. (Build_Task_Record_Image): Likewise. * cstand.adb (Create_Standard): Use UI_From_Int instead of UI_From_CC. * exp_ch11.adb (Expand_N_Exception_Declaration): Likewise. * sem_res.adb (Patch_Up_Value): Likewise. * stringt.adb (Write_String_Table_Entry): Use Get_Char_Code.
2022-05-10Fix internal error with vectorization on SPARCEric Botcazou2-2/+33
This is a regression present since the 10.x series, but the underlying issue has been there since the TARGET_VEC_PERM_CONST hook was implemented, in the form of an ICE when expanding a constant VEC_PERM_EXPR in V4QI, while the back-end only supports V8QI constant VEC_PERM_EXPRs. gcc/ PR target/105292 * config/sparc/sparc.cc (sparc_vectorize_vec_perm_const): Return true only for 8-byte vector modes. gcc/testsuite/ * gcc.target/sparc/20220510-1.c: New test.
2022-05-10middle-end/70090: Dynamic sizes for -fsanitize=object-sizeSiddhesh Poyarekar2-6/+52
Use __builtin_dynamic_object_size to get object sizes for ubsan. gcc/ChangeLog: PR middle-end/70090 * ubsan.cc (ubsan_expand_objsize_ifn): Allow non-constant SIZE. (instrument_object_size): Get dynamic object size expression. gcc/testsuite/ChangeLog: PR middle-end/70090 * gcc.dg/ubsan/object-size-dyn.c: New test. Signed-off-by: Siddhesh Poyarekar <siddhesh@gotplt.org>
2022-05-10c++: fix arm-eabi crash building libstdc++ [PR105529]Jason Merrill5-45/+36
My recent change to cxx_eval_store_expression asserts that the target and value can only end up having different types in the case of an empty base; this was crashing arm-eabi compilers because in that ABI [cd]tors return *this, and weren't converting it to void* first. This also shares the 'return this' code between the three places it occurs. Thanks to Marek for the tests. PR c++/105529 gcc/cp/ChangeLog: * decl.cc (maybe_return_this): Replace... (finish_constructor_body, finish_destructor_body): ...these. (finish_function_body): Call it. * optimize.cc (build_delete_destructor_body): Call it. * cp-tree.h (maybe_return_this): Declare. gcc/testsuite/ChangeLog: * g++.dg/cpp2a/constexpr-dtor13.C: New test. * g++.dg/cpp2a/constexpr-dtor14.C: New test.
2022-05-10rs6000: avoid peeking eof after __vectorJiufu Guo2-4/+11
There is a rare corner case: where vector is followed only by one valid identifer and the ";" which is near the end of the file. Like the case in PR101168: using vdbl = __vector double; #define BREAK 1 For this case, "vector double" is followed by CPP_SEMICOLON and then EOF. There is no more tokens need to check for this case. PR preprocessor/101168 gcc/ChangeLog: * config/rs6000/rs6000-c.cc (rs6000_macro_to_expand): Avoid empty identifier. gcc/testsuite/ChangeLog: * g++.target/powerpc/pr101168.C: New test.
2022-05-10Daily bump.GCC Administrator11-1/+556
2022-05-09Update gcc.po filesJoseph Myers19-78532/+79044
* be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id.po, ja.po, nl.po, ru.po, sr.po, sv.po, tr.po, uk.po, vi.po, zh_CN.po, zh_TW.po: Update.
2022-05-09c++: Implement P2324R2, labels at the end of compound-stmts [PR103539]Marek Polacek3-9/+175
This patch implements C++23 <https://wg21.link/p2324r2>, which allows labels at the end of a compound statement. Its C FE counterpart was already implemented in r11-4813. In cp_parser_statement I rely on in_compound to determine whether we're in a compound-statement, so that the patch doesn't accidentally allow void fn(int c) { if (c) label: } Strangely, in_compound was reset after seeing a label (this is tested in c-c++-common/gomp/pr63326.c), so I've made a modifiable copy specific for OpenMP #pragma purposes. PR c++/103539 gcc/cp/ChangeLog: * parser.cc (cp_parser_statement): Constify the in_compound parameter. Create a modifiable copy. Allow labels at the end of compound statements. gcc/testsuite/ChangeLog: * g++.dg/cpp23/label1.C: New test. * g++.dg/cpp23/label2.C: New test.
2022-05-09Fortran: check for non-optional spaces between adjacent keywordsHarald Anlauf3-22/+37
In free format, spaces between adjacent keywords are not optional except when a combination is explicitly listed (e.g. F2018: table 6.2). The following combinations thus require separating blanks: CHANGE TEAM, ERROR STOP, EVENT POST, EVENT WAIT, FAIL IMAGE, FORM TEAM, SELECT RANK, SYNC ALL, SYNC IMAGES, SYNC MEMORY, SYNC TEAM, TYPE IS. gcc/fortran/ChangeLog: PR fortran/105501 * match.cc (gfc_match_if): Adjust patterns used for matching. (gfc_match_select_rank): Likewise. * parse.cc (decode_statement): Likewise. gcc/testsuite/ChangeLog: PR fortran/105501 * gfortran.dg/pr105501.f90: New test.
2022-05-09testsuite: Silence analyzer/pr51628-30.c for default_packedDimitar Dimitrov1-0/+1
On default_packed targets like PRU, a warning in the file included from analyzer/pr51628-30.c is reported as spurious one, even though it has been annotated there: Excess errors: gcc/gcc/testsuite/gcc.dg/analyzer/torture/../../../c-c++-common/pr51628-30.c:7:19: warning: 'packed' attribute ignored for field of type 'struct B' [-Wattributes] Mark that gcc.dg/analyzer/torture/pr51628-30.c generates excess warnings for default_packed targets. This is safe because the original test case covered an ICE, not a diagnostic error. gcc/testsuite/ChangeLog: * gcc.dg/analyzer/torture/pr51628-30.c: Test can spill excess errors for default_packed targets. Signed-off-by: Dimitar Dimitrov <dimitar@dinux.eu>
2022-05-09testsuite: Remove superfluous semicolon [PR105256]Jakub Jelinek1-1/+1
2022-05-09 Jakub Jelinek <jakub@redhat.com> PR c++/105256 * g++.dg/cpp0x/pr105256.C: Remove superfluous semicolon.
2022-05-09Merge branch 'master' into devel/modula-2.Gaius Mulley202-3127/+3502
2022-05-09i386: Adjust -fzero-call-used-regs to always use XOR [PR101891]Qing Zhao26-192/+180
Currently on i386, -fzero-call-used-regs uses a pattern of: XOR regA,regA MOV regA,regB MOV regA,regC ... RET However, this introduces both a register ordering dependency (e.g. the CPU cannot clear regB without clearing regA first), and while greatly reduces available ROP gadgets, it does technically leave a set of "MOV" ROP gadgets at the end of functions (e.g. "MOV regA,regC; RET"). This patch will switch to always use XOR on i386: XOR regA,regA XOR regB,regB XOR regC,regC ... RET gcc/ChangeLog: PR target/101891 * config/i386/i386.cc (zero_call_used_regno_mode): use V2SImode as a generic MMX mode instead of V4HImode. (zero_all_mm_registers): Use SET to zero instead of MOV for zeroing scratch registers. (ix86_zero_call_used_regs): Likewise. gcc/testsuite/ChangeLog: * gcc.target/i386/zero-scratch-regs-1.c: Add -fno-stack-protector -fno-PIC. * gcc.target/i386/zero-scratch-regs-10.c: Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-13.c: Add -msse. * gcc.target/i386/zero-scratch-regs-14.c: Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-15.c: Add -fno-stack-protector -fno-PIC. * gcc.target/i386/zero-scratch-regs-16.c: Likewise. * gcc.target/i386/zero-scratch-regs-17.c: Likewise. * gcc.target/i386/zero-scratch-regs-18.c: Add -fno-stack-protector -fno-PIC, adjust mov to xor. * gcc.target/i386/zero-scratch-regs-19.c: Add -fno-stack-protector -fno-PIC. * gcc.target/i386/zero-scratch-regs-2.c: Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-20.c: Add -msse. * gcc.target/i386/zero-scratch-regs-21.c: Add -fno-stack-protector -fno-PIC, Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-22.c: Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-23.c: Likewise. * gcc.target/i386/zero-scratch-regs-26.c: Likewise. * gcc.target/i386/zero-scratch-regs-27.c: Likewise. * gcc.target/i386/zero-scratch-regs-28.c: Likewise. * gcc.target/i386/zero-scratch-regs-3.c: Add -fno-stack-protector. * gcc.target/i386/zero-scratch-regs-31.c: Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-4.c: Add -fno-stack-protector -fno-PIC. * gcc.target/i386/zero-scratch-regs-5.c: Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-6.c: Add -fno-stack-protector. * gcc.target/i386/zero-scratch-regs-7.c: Likewise. * gcc.target/i386/zero-scratch-regs-8.c: Adjust mov to xor. * gcc.target/i386/zero-scratch-regs-9.c: Add -fno-stack-protector.
2022-05-09MAINTAINERS: Update my email addressXi Ruoyao1-1/+1
I have to change the domain name for "some unpleasant personal issue". ChangeLog: * MAINTAINERS: Update my email address.
2022-05-09c++: constexpr init of union sub-aggr w/ base [PR105491]Patrick Palka15-43/+116
Here ever since r10-7313-gb599bf9d6d1e18, reduced_constant_expression_p in C++11/14 is rejecting the marked sub-aggregate initializer (of type S) W w = {.D.2445={.s={.D.2387={.m=0}, .b=0}}}; ^ ultimately because said initializer has CONSTRUCTOR_NO_CLEARING set, hence the function must verify that all fields of S are initialized. And before C++17 it doesn't expect to see base class fields (since next_initializable_field skips over them), so the presence thereof causes r_c_e_p to return false. The reason r10-7313-gb599bf9d6d1e18 causes this is because in that commit we began using CONSTRUCTOR_NO_CLEARING to precisely track whether we're in middle of activating a union member. This ends up affecting clear_no_implicit_zero, which recurses into sub-aggregate initializers only if the outer initializer has CONSTRUCTOR_NO_CLEARING set. After that commit, the outer union initializer above no longer has the flag set at this point and so clear_no_implicit_zero no longer recurses into the marked inner initializer. But arguably r_c_e_p should be able to accept the marked initializer regardless of whether CONSTRUCTOR_NO_CLEARING is set. The primary bug therefore seems to be that r_c_e_p relies on next_initializable_field which skips over base class fields in C++11/14. To fix this, this patch introduces a new helper function next_subobject_field which is like next_initializable_field except that it never skips base class fields, and makes r_c_e_p use it. This patch then renames next_initializable_field to next_aggregate_field (and makes it skip over vptr fields again). PR c++/105491 gcc/cp/ChangeLog: * call.cc (field_in_pset): Adjust after next_initializable_field renaming. (build_aggr_conv): Likewise. (convert_like_internal): Likewise. (type_has_extended_temps): Likewise. * class.cc (default_init_uninitialized_part): Likewise. (finish_struct): Likewise. * constexpr.cc (cx_check_missing_mem_inits): Likewise. (reduced_constant_expression_p): Use next_subobject_field instead. * cp-gimplify.cc (get_source_location_impl_type): Adjust after next_initializable_field renaming. (fold_builtin_source_location): Likewise. * cp-tree.h (next_initializable_field): Rename to ... (next_aggregate_field): ... this. (next_subobject_field): Declare. * decl.cc (next_aggregate_field): Renamed from ... (next_initializable_field): ... this. Skip over vptr fields again. (next_subobject_field): Define. (reshape_init_class): Adjust after next_initializable_field renaming. * init.cc (build_value_init_noctor): Likewise. (emit_mem_initializers): Likewise. * lambda.cc (build_capture_proxy): Likewise. * method.cc (build_comparison_op): Likewise. * pt.cc (maybe_aggr_guide): Likewise. * tree.cc (structural_type_p): Likewise. * typeck2.cc (split_nonconstant_init_1): Likewise. (digest_init_r): Likewise. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/constexpr-union7.C: New test. * g++.dg/cpp0x/constexpr-union7a.C: New test. * g++.dg/cpp2a/constinit17.C: New test.
2022-05-09Implement permutation with pslldq + psrldq + por when pshufb is not available.liuhongt3-0/+347
pand/pandn may be used to clear upper/lower bits of the operands, in that case there will be 4-5 instructions for permutation, and it's still better than scalar codes. gcc/ChangeLog: PR target/105354 * config/i386/i386-expand.cc (expand_vec_perm_pslldq_psrldq_por): New function. (ix86_expand_vec_perm_const_1): Try expand_vec_perm_pslldq_psrldq_por for both 3-instruction and 4/5-instruction sequence. gcc/testsuite/ChangeLog: * gcc.target/i386/pr105354-1.c: New test. * gcc.target/i386/pr105354-2.c: New test.
2022-05-09[c++][NFC] Rename Attached to KeyedNathan Sidwell4-40/+40
With modules, certain decls are 'scoped' with another decl. I chose the name 'attached', but that has become something specific in the modules context, so is no longer a good name. The alternative name I considered was 'keyed', but we already had the concept of a key virtual function (from the ABI), which is why I went with 'attached'. However, I think 'keyed' is the less worse name. I think there's less chance of confusion. gcc/cp/ * cp-tree.h (DECL_MODULE_KEYED_DECLS_P): Renamed from DECL_MODULE_ATTACHMENTS_P. (struct lane_decl_base): Rename module_attached_p to module_keyed_decls_p. (maybe_key_decl): Renamed from maybe_attach_decl. * lambda.cc (record_lambda_scope): Adjust. * lex.cc (cxx_dup_lang_specific_decl): Adjust. * module.cc (keyed_map_t, keyed_table): Renamed from attached_map_t, attached_table. (enum merge_kind): Rename MK_attached to MK_keyed. (trees_out::lang_decl_bools): Adjust. (trees_in::lang_decl_bools): Adjust. (trees_in::decl_value): Adjust. (trees_out::get_merge_kind): Adjust. (trees_out::key_mergeable): Adjust. (trees_in::key_mergeable): Adjust. (maybe_key_decl): Rename from maybe_attach_decl. (direct_import): Adjust. (fini_modules): Adjust.
2022-05-09MAINTAINERS: Update my email address.Clément Chigot1-1/+1
Update my email address in the MAINTAINERS file. ChangeLog: 2022-05-06 Clément Chigot <chigot@adacore.com> * MAINTAINERS: Update my email address.
2022-05-09Simplify STATIC_ASSERT macro.Martin Liška2-6/+2
For C++, use always __static_assert and for C, use the negative array index. gcc/ChangeLog: * basic-block.h (STATIC_ASSERT): Use normal STATIC_ASSERT. * system.h (STATIC_ASSERT): Define as static_assert for C++ and fallback to array index in C.
2022-05-09Remove non-ANSI C path in ansidecl.h.Martin Liska1-17/+0
include/ChangeLog: * ansidecl.h (PTR): Remove Not ANCI C part.
2022-05-09tree-optimization/105517 - avoid offset truncation during VNRichard Biener2-2/+25
When value-numbering an address expression like &p_74(D)->a1x[4294967295].a1; we are accumulating the byte offset in an 64bit integer. When later exploiting the duality between that and a POINTER_PLUS_EXPR we should avoid truncating that offset to fit in the target specific sizetype. While such overflows are generally undefined behavior, exploiting this may leads to spurious missing diagnostics. 2022-05-09 Richard Biener <rguenther@suse.de> PR tree-optimization/105517 * tree-ssa-sccvn.cc (vn_reference_lookup): Make sure the accumulated offset can be represented in the POINTER_PLUS_EXPR IL. (vn_reference_insert): Likewise. * poly-int.h (sext_hwi): Add poly version of sext_hwi.
2022-05-09Remove GIMPLE restriction of ! using match.pd patternsRichard Biener1-11/+1
This removes #if GIMPLE guards around patterns using ! which is now also provided in the GENERIC implementation. 2022-05-09 Richard Biener <rguenther@suse.de> * match.pd: Remove #if GIMPLE guards around ! using patterns.
2022-05-09Optimize vec_setv8{hi,hf}_0 + pmovzxbq to pmovzxbq.liuhongt2-4/+65
gcc/ChangeLog: PR target/105072 * config/i386/sse.md (*sse4_1_<code>v2qiv2di2<mask_name>_1): New define_insn. (*sse4_1_zero_extendv2qiv2di2_2): New pre_reload define_insn_and_split. gcc/testsuite/ChangeLog: * gcc.target/i386/pr105072.c: New test.
2022-05-09[Ada] Suggest use of First_Valid/Last_Valid on type with static predicateYannick Moy1-0/+25
Attributes First_Valid/Last_Valid can be used on types with static predicate, instead of First/Last/Range. Include that suggestion in the corresponding error message. gcc/ada/ * sem_util.adb (Bad_Predicated_Subtype_Use): Add continuation message.
2022-05-09[Ada] Raise Constraint_Error when converting negative values to Char_CodePiotr Trojanek1-21/+8
GNATprove relies on the comment for Get_Enum_Lit_From_Pos, which promises to raise Constraint_Error when its Pos parameter is not among the representation values for enumeration literal. However, this promise was only respected in builds with range checks enabled. The root problem was that a similar comment for conversion from Uint to Char_Code was likewise only respected in builds with range checks enabled. Now both routines respect promises in their comments. The behaviour of GNAT itself is not affected. The fix is needed to filter garbage counterexamples generated by provers for characters objects in SPARK. gcc/ada/ * uintp.adb (UI_To_CC): Guard against illegal inputs; reuse UI_To_Int.
2022-05-09[Ada] Simplify conversions from Uint to Char_CodePiotr Trojanek2-4/+3
Replace "Char_Code (UI_To_Int (...))" with "UI_To_CC (...). Cleanup related to handling characters in GNATprove counterexamples; semantics is unaffected. gcc/ada/ * par-prag.adb (Prag): Simplify conversion of character codes. * sem_case.adb (Choice_Image): Likewise. (Lit_Of): Likewise.
2022-05-09[Ada] Fix invalid memory access on finalization of class-wide typeJustin Squirek3-17/+106
This patch corrects issues in the compiler whereby finalization of a heap- allocated class-wide type may cause an invalid memory read at runtime when the type in question contains a component whose type has a large alignment. gcc/ada/ * exp_attr.adb (Expand_N_Attribute_Reference) <Attribute_Tag>: Deal specifically wth class-wide equivalent types without a parent. * exp_util.adb (Build_Allocate_Deallocate_Proc): Extract allocator node for calculation of alignment actual and modify alignment for allocators of class-wide types with associated expressions. (Make_CW_Equivalent_Type): Handle interface types differently when generating the equivalent record. * sem_aux.adb (First_Tag_Component): Accept class-wide equivalent types too.
2022-05-09[Ada] Fully qualify name in JSON representation infoEtienne Servais1-3/+5
The current termination condition of the recursion is wrong. When in JSON mode, names should be fully qualified. This requires to stop not at the first encountered compilation unit but to recurse up to Standard. gcc/ada/ * repinfo.adb (List_Name): Rework termination condition.
2022-05-09[Ada] Remove extra space around binary operatorsPiotr Trojanek13-24/+24
Style cleanups. Violation initially spotted while reading the code for UI_Expon; other occurrences found with grep (and examined manually, because sometimes the extra space is needed for a code layout). gcc/ada/ * bindgen.adb, errout.adb, exp_unst.adb, gnatchop.adb, libgnat/a-ngcefu.adb, libgnat/a-strunb.adb, libgnat/a-stwiun.adb, libgnat/a-stzunb.adb, libgnat/a-wtedit.adb, libgnat/g-debpoo.adb, osint.adb, sigtramp-vxworks.c, uintp.adb: Remove extra whitespace around +, -, *, / and **.
2022-05-09[Ada] Remove CodePeer annotations for pragma Loop_VariantPiotr Trojanek1-3/+0
Pragma Loop_Variant is now expanded into a null statement in CodePeer mode. Remove annotation related to false positives in runtime units. gcc/ada/ * libgnat/s-expmod.adb: Remove CodePeer annotation for pragma Loop_Variant.
2022-05-09[Ada] Prevent inlining-for-proof for calls inside ELSIF conditionPiotr Trojanek3-28/+49
In GNATprove we don't want inlining-for-proof to expand subprogram bodies into actions attached to nodes. These actions are attached either to expressions or to statements. For expressions, we prevented inlining by Is_Potentially_Unevaluated. For statements, we prevented inlining by In_While_Loop_Condition, but forgot about actions attached to ELSIF condition. There are no other expression or statements nodes where actions could be attached, so this fix is exhaustive. gcc/ada/ * sem_util.ads (In_Statement_Condition_With_Actions): Renamed from In_While_Loop_Condition; move to fit the alphabetic order. * sem_util.adb (In_Statement_Condition_With_Actions): Detect Elsif condition; stop search on other statements; prevent search from going too far; move to fit the alphabetic order. * sem_res.adb (Resolve_Call): Adapt caller.
2022-05-09[Ada] Remove redundant guards for empty listPiotr Trojanek2-12/+4
Routine Has_Excluded_Declaration iterates over declarations with First/Present/Next, which is safe when declarations are No_List. Cleanup related to excessive inlining-for-proof by GNATprove. gcc/ada/ * inline.adb (Build_Body_To_Inline): Remove redundant guards. * sem_ch6.adb (Analyze_Subprogram_Body_Helper): Likewise.
generated by cgit v1.1 at 2025-09-25 12:52:26 +0000