diff options
78 files changed, 1461 insertions, 295 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 0cee1ea..2314910 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,53 @@ +2025-04-03 Thomas Schwinge <tschwinge@baylibre.com> + + PR target/119573 + * config/nvptx/nvptx.cc (nvptx_encode_section_info): Don't set + 'DATA_AREA_CONST' for 'TREE_CONSTANT', or 'TREE_READONLY'. + (nvptx_asm_declare_constant_name): Use '.global' instead of + '.const'. + +2025-04-03 Peter Bergner <bergner@linux.ibm.com> + + PR target/119308 + * config/rs6000/rs6000-logue.cc (rs6000_output_function_epilogue): + Handle GCC COBOL for the tbtab lang field. + +2025-04-03 Sandra Loosemore <sloosemore@baylibre.com> + + * doc/extend.texi (Statement Attributes): Copy-edit the musttail + attribute documentation and correct the comment in the last + example. + +2025-04-03 Jan Hubicka <hubicka@ucw.cz> + + * config/i386/x86-tune-costs.h (ix86_size_cost): Fix sizes of move + instructions + +2025-04-03 Jakub Jelinek <jakub@redhat.com> + + PR cobol/119242 + * fold-const.h (native_encode_wide_int): Declare. + * fold-const.cc (native_encode_wide_int): New function. + (native_encode_int): Use it. + +2025-04-03 Xi Ruoyao <xry111@xry111.site> + + * config/loongarch/genopts/gen-evolution.awk: Avoid using gensub + that FreeBSD awk lacks. + +2025-04-03 Hongyu Wang <hongyu.wang@intel.com> + + PR target/119539 + * config/i386/i386.md (*<insn><mode>3_mask): Emit NF variant of + rotate when APX_NF enabled, and use force_lowpart_subreg. + (*<insn><mode>3_mask_1): Likewise. + +2025-04-03 Sandra Loosemore <sloosemore@baylibre.com> + + PR c/101440 + * doc/extend.texi (Common Function Attributes): Clean up some + confusing language in the description of the "access" attribute. + 2025-04-02 Sandra Loosemore <sloosemore@baylibre.com> GUO Yixuan <culu.gyx@gmail.com> diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 75f4546..c36e5b2 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20250403 +20250404 diff --git a/gcc/ada/libgnat/a-ngcoar.adb b/gcc/ada/libgnat/a-ngcoar.adb index 41c255f..9ce6caf 100644 --- a/gcc/ada/libgnat/a-ngcoar.adb +++ b/gcc/ada/libgnat/a-ngcoar.adb @@ -1058,19 +1058,21 @@ package body Ada.Numerics.Generic_Complex_Arrays is is N : constant Natural := Length (A); - -- For a Hermitian matrix C, we convert the eigenvalue problem to a - -- real symmetric one: if C = A + i * B, then the (N, N) complex + -- For a Hermitian matrix A, we convert the eigenvalue problem to a + -- real symmetric one: if A = X + i * Y, then the (N, N) complex -- eigenvalue problem: - -- (A + i * B) * (u + i * v) = Lambda * (u + i * v) + -- + -- (X + i * Y) * (u + i * v) = Lambda * (u + i * v) -- -- is equivalent to the (2 * N, 2 * N) real eigenvalue problem: - -- [ A, B ] [ u ] = Lambda * [ u ] - -- [ -B, A ] [ v ] [ v ] -- - -- Note that the (2 * N, 2 * N) matrix above is symmetric, as - -- Transpose (A) = A and Transpose (B) = -B if C is Hermitian. + -- [ X, -Y ] [ u ] = Lambda * [ u ] + -- [ Y, X ] [ v ] [ v ] + -- + -- Note that the (2 * N, 2 * N) matrix M above is symmetric, because + -- Transpose (X) = X and Transpose (Y) = -Y as A is Hermitian. - -- We solve this eigensystem using the real-valued algorithms. The final + -- We solve this eigensystem using the real-valued algorithm. The final -- result will have every eigenvalue twice, so in the sorted output we -- just pick every second value, with associated eigenvector u + i * v. @@ -1085,10 +1087,8 @@ package body Ada.Numerics.Generic_Complex_Arrays is C : constant Complex := (A (A'First (1) + (J - 1), A'First (2) + (K - 1))); begin - M (J, K) := Re (C); - M (J + N, K + N) := Re (C); - M (J + N, K) := Im (C); - M (J, K + N) := -Im (C); + M (J, K) := Re (C); M (J, K + N) := -Im (C); + M (J + N, K) := Im (C); M (J + N, K + N) := Re (C); end; end loop; end loop; @@ -1103,10 +1103,9 @@ package body Ada.Numerics.Generic_Complex_Arrays is for K in 1 .. N loop declare - Row : constant Integer := Vectors'First (2) + (K - 1); + Row : constant Integer := Vectors'First (1) + (K - 1); begin - Vectors (Row, Col) := - (Vecs (J * 2, Col), Vecs (J * 2, Col + N)); + Vectors (Row, Col) := (Vecs (K, 2 * J), Vecs (K + N, 2 * J)); end; end loop; end; @@ -1118,13 +1117,14 @@ package body Ada.Numerics.Generic_Complex_Arrays is ----------------- function Eigenvalues (A : Complex_Matrix) return Real_Vector is - -- See Eigensystem for a description of the algorithm - N : constant Natural := Length (A); - R : Real_Vector (A'Range (1)); + + -- See Eigensystem for a description of the algorithm M : Real_Matrix (1 .. 2 * N, 1 .. 2 * N); + R : Real_Vector (A'Range (1)); Vals : Real_Vector (1 .. 2 * N); + begin for J in 1 .. N loop for K in 1 .. N loop @@ -1132,10 +1132,8 @@ package body Ada.Numerics.Generic_Complex_Arrays is C : constant Complex := (A (A'First (1) + (J - 1), A'First (2) + (K - 1))); begin - M (J, K) := Re (C); - M (J + N, K + N) := Re (C); - M (J + N, K) := Im (C); - M (J, K + N) := -Im (C); + M (J, K) := Re (C); M (J, K + N) := -Im (C); + M (J + N, K) := Im (C); M (J + N, K + N) := Re (C); end; end loop; end loop; diff --git a/gcc/ada/libgnat/a-ngrear.adb b/gcc/ada/libgnat/a-ngrear.adb index e7b1bcd..524b4a0 100644 --- a/gcc/ada/libgnat/a-ngrear.adb +++ b/gcc/ada/libgnat/a-ngrear.adb @@ -85,7 +85,7 @@ package body Ada.Numerics.Generic_Real_Arrays is function Is_Symmetric (A : Real_Matrix) return Boolean is (Transpose (A) = A); - -- Return True iff A is symmetric, see RM G.3.1 (90). + -- Return True iff A is symmetric, see RM G.3.1 (90) function Is_Tiny (Value, Compared_To : Real) return Boolean is (abs Compared_To + 100.0 * abs Value = abs Compared_To); @@ -104,7 +104,7 @@ package body Ada.Numerics.Generic_Real_Arrays is -- not a square matrix, and otherwise returns its length. procedure Rotate (X, Y : in out Real; Sin, Tau : Real); - -- Perform a Givens rotation + -- Perform a Givens rotation of angle Theta given by sin and sin/(1 + cos) procedure Sort_Eigensystem (Values : in out Real_Vector; @@ -525,13 +525,13 @@ package body Ada.Numerics.Generic_Real_Arrays is Vectors : out Real_Matrix; Compute_Vectors : Boolean) is - -- This subprogram uses Carl Gustav Jacob Jacobi's iterative method - -- for computing eigenvalues and eigenvectors and is based on + -- This subprogram uses Carl Gustav Jacob Jacobi's cyclic iterative + -- method for computing eigenvalues and eigenvectors and is based on -- Rutishauser's implementation. -- The given real symmetric matrix is transformed iteratively to -- diagonal form through a sequence of appropriately chosen elementary - -- orthogonal transformations, called Jacobi rotations here. + -- orthogonal transformations, called Jacobi rotations. -- The Jacobi method produces a systematic decrease of the sum of the -- squares of off-diagonal elements. Convergence to zero is quadratic, @@ -542,41 +542,44 @@ package body Ada.Numerics.Generic_Real_Arrays is -- best choice here, even though for large matrices other methods will -- be significantly more efficient in both time and space. - -- While the eigensystem computations are absolutely foolproof for all + -- While the eigensystem computation is absolutely foolproof for all -- real symmetric matrices, in presence of invalid values, or similar - -- exceptional situations it might not. In such cases the results cannot - -- be trusted and Constraint_Error is raised. + -- exceptional situations, it may not be. In such cases, the results + -- cannot be trusted and Constraint_Error is raised. -- Note: this implementation needs temporary storage for 2 * N + N**2 -- values of type Real. - Max_Iterations : constant := 50; - N : constant Natural := Length (A); + Max_Iterations : constant := 50; + N : constant Natural := Length (A); subtype Square_Matrix is Real_Matrix (1 .. N, 1 .. N); - -- In order to annihilate the M (Row, Col) element, the - -- rotation parameters Cos and Sin are computed as - -- follows: + -- In order to annihilate the M (Row, Col) element, the rotation angle + -- Theta is chosen as follows: - -- Theta = Cot (2.0 * Phi) - -- = (Diag (Col) - Diag (Row)) / (2.0 * M (Row, Col)) + -- Cot (2.0 * Theta) = (Diag (Col) - Diag (Row)) / (2.0 * M (Row, Col)) - -- Then Tan (Phi) as the smaller root (in modulus) of + -- If C = Cot (2.0 * Theta), then Tan (Theta) is computed as the smaller + -- root (in modulus) of: - -- T**2 + 2 * T * Theta = 1 (or 0.5 / Theta, if Theta is large) + -- X**2 + 2 * C * X - 1 = 0 - function Compute_Tan (Theta : Real) return Real is - (Real'Copy_Sign (1.0 / (abs Theta + Sqrt (1.0 + Theta**2)), Theta)); + -- or else as 0.5 / C, if C is large. + + function Compute_Tan (C : Real) return Real is + (Real'Copy_Sign (1.0 / (abs C + Sqrt (1.0 + C**2)), C)); function Compute_Tan (P, H : Real) return Real is - (if Is_Tiny (P, Compared_To => H) then P / H - else Compute_Tan (Theta => H / (2.0 * P))); + (if Is_Tiny (P, Compared_To => H) + then P / H + else Compute_Tan (C => H / (2.0 * P))); pragma Annotate (CodePeer, False_Positive, "divide by zero", "H, P /= 0"); function Sum_Strict_Upper (M : Square_Matrix) return Real; - -- Return the sum of all elements in the strict upper triangle of M + -- Return the sum of the absolute value of all the elements in the + -- strict upper triangle of M. ---------------------- -- Sum_Strict_Upper -- @@ -595,11 +598,13 @@ package body Ada.Numerics.Generic_Real_Arrays is return Sum; end Sum_Strict_Upper; + -- Local variables + M : Square_Matrix := A; -- Work space for solving eigensystem - Threshold : Real; - Sum : Real; Diag : Real_Vector (1 .. N); Diag_Adj : Real_Vector (1 .. N); + Sum : Real; + Threshold : Real; -- The vector Diag_Adj indicates the amount of change in each value, -- while Diag tracks the value itself and Values holds the values as @@ -621,22 +626,24 @@ package body Ada.Numerics.Generic_Real_Arrays is raise Constraint_Error with "matrix not symmetric"; end if; + Values := Diagonal (M); + -- Note: Only the locally declared matrix M and vectors (Diag, Diag_Adj) -- have lower bound equal to 1. The Vectors matrix may have -- different bounds, so take care indexing elements. Assignment -- as a whole is fine as sliding is automatic in that case. - Vectors := (if not Compute_Vectors then [1 .. 0 => [1 .. 0 => 0.0]] - else Unit_Matrix (Vectors'Length (1), Vectors'Length (2))); - Values := Diagonal (M); + Vectors := (if Compute_Vectors + then Unit_Matrix (N) + else [1 .. 0 => [1 .. 0 => 0.0]]); Sweep : for Iteration in 1 .. Max_Iterations loop - -- The first three iterations, perform rotation for any non-zero - -- element. After this, rotate only for those that are not much - -- smaller than the average off-diagnal element. After the fifth - -- iteration, additionally zero out off-diagonal elements that are - -- very small compared to elements on the diagonal with the same + -- During the first three iterations, perform the rotation only for + -- elements that are not much smaller than the average off-diagonal + -- element. After this, rotate for any non-zero elements. After the + -- fifth iteration, additionally zero out off-diagonal elements that + -- are very small compared to elements on the diagonal with the same -- column or row index. Sum := Sum_Strict_Upper (M); @@ -645,8 +652,8 @@ package body Ada.Numerics.Generic_Real_Arrays is Threshold := (if Iteration < 4 then 0.2 * Sum / Real (N**2) else 0.0); - -- Iterate over all off-diagonal elements, rotating any that have - -- an absolute value that exceeds the threshold. + -- Iterate over all off-diagonal elements, rotating any that have an + -- absolute value that exceeds the threshold. Diag := Values; Diag_Adj := [others => 0.0]; -- Accumulates adjustments to Diag @@ -654,11 +661,11 @@ package body Ada.Numerics.Generic_Real_Arrays is for Row in 1 .. N - 1 loop for Col in Row + 1 .. N loop - -- If, before the rotation M (Row, Col) is tiny compared to + -- If, before the rotation, M (Row, Col) is tiny compared to -- Diag (Row) and Diag (Col), rotation is skipped. This is -- meaningful, as it produces no larger error than would be -- produced anyhow if the rotation had been performed. - -- Suppress this optimization in the first four sweeps, so + -- Suppress this optimization in the first four iterations, so -- that this procedure can be used for computing eigenvectors -- of perturbed diagonal matrices. @@ -670,8 +677,8 @@ package body Ada.Numerics.Generic_Real_Arrays is elsif abs M (Row, Col) > Threshold then Perform_Rotation : declare - Tan : constant Real := Compute_Tan (M (Row, Col), - Diag (Col) - Diag (Row)); + Tan : constant Real := + Compute_Tan (M (Row, Col), Diag (Col) - Diag (Row)); Cos : constant Real := 1.0 / Sqrt (1.0 + Tan**2); Sin : constant Real := Tan * Cos; Tau : constant Real := Sin / (1.0 + Cos); @@ -710,7 +717,7 @@ package body Ada.Numerics.Generic_Real_Arrays is Values := Values + Diag_Adj; end loop Sweep; - -- All normal matrices with valid values should converge perfectly. + -- All normal matrices with valid values should converge perfectly if Sum /= 0.0 then raise Constraint_Error with "eigensystem solution does not converge"; diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 829de00..5e7bff8 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,7 @@ +2025-04-03 Jakub Jelinek <jakub@redhat.com> + + * c.opt.urls: Regenerate. + 2025-03-30 Sandra Loosemore <sloosemore@baylibre.com> * c.opt.urls: Regenerate. diff --git a/gcc/cfgrtl.cc b/gcc/cfgrtl.cc index d206c0d..310028f 100644 --- a/gcc/cfgrtl.cc +++ b/gcc/cfgrtl.cc @@ -3213,6 +3213,16 @@ purge_dead_edges (basic_block bb) && ! may_trap_p (XEXP (eqnote, 0)))) remove_note (insn, note); } + /* A tail call cannot trap either. The tailc/musttail pass could have + allowed a tail call if it could throw internally, but perform no + actual statements and then caused the exception to be thrown externally + in the hope that it is cleaned up later. If it is not, just + remove REG_EH_REGION note. While the call maybe can throw, the + current function's frame will not be there anymore when it does. */ + if (CALL_P (insn) + && SIBLING_CALL_P (insn) + && (note = find_reg_note (insn, REG_EH_REGION, NULL))) + remove_note (insn, note); /* Cleanup abnormal edges caused by exceptions or non-local gotos. */ for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); ) diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index e06e789..0b85ff2 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,9 @@ +2025-04-03 Jakub Jelinek <jakub@redhat.com> + + PR cobol/119242 + * genapi.cc (binary_initial_from_float128): Use + native_encode_wide_int. + 2025-04-02 Bob Dubner <rdubner@symas.com> PR cobol/119521 diff --git a/gcc/cobol/cobol1.cc b/gcc/cobol/cobol1.cc index 0d07c46..d175ab1 100644 --- a/gcc/cobol/cobol1.cc +++ b/gcc/cobol/cobol1.cc @@ -646,6 +646,22 @@ cobol_get_sarif_source_language(const char *) return "cobol"; } +bool +cobol_langhook_post_options(const char**) + { + // This flag, when set to 0, results in calls to gg_exit working properly. + // I don't know why it is necessary. There is something going on with the + // definition of __gg__data_return_code in constants.cc, and with how it + // is used through var_decl_return_code in genapi.cc. Without it, the value + // delivered to exit@PLT is zero, and not __gg__data_return_code + // Dubner, 2025-04-04. + flag_strict_aliasing = 0; + + /* Returning false means that the backend should be used. */ + return false; + } + + #undef LANG_HOOKS_BUILTIN_FUNCTION #undef LANG_HOOKS_GETDECLS #undef LANG_HOOKS_GLOBAL_BINDINGS_P @@ -660,6 +676,7 @@ cobol_get_sarif_source_language(const char *) ////#undef LANG_HOOKS_TYPE_FOR_SIZE #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME #undef LANG_HOOKS_GET_SARIF_SOURCE_LANGUAGE +#undef LANG_HOOKS_POST_OPTIONS // We use GCC in the name, not GNU, as others do, // because "GnuCOBOL" refers to a different GNU project. @@ -685,6 +702,8 @@ cobol_get_sarif_source_language(const char *) #define LANG_HOOKS_GET_SARIF_SOURCE_LANGUAGE cobol_get_sarif_source_language +#define LANG_HOOKS_POST_OPTIONS cobol_langhook_post_options + struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; #include "gt-cobol-cobol1.h" diff --git a/gcc/cobol/genapi.cc b/gcc/cobol/genapi.cc index a0da647..fbe0bbc 100644 --- a/gcc/cobol/genapi.cc +++ b/gcc/cobol/genapi.cc @@ -8806,6 +8806,10 @@ static void set_user_status(struct cbl_file_t *file) { // This routine sets the user_status, if any, to the cblc_file_t::status + + // We have to do it this way, because in the case where the file->user_status + // is in linkage, the memory addresses can end up pointing to the wrong + // places if(file->user_status) { cbl_field_t *user_status = cbl_field_of(symbol_at(file->user_status)); @@ -10111,6 +10115,13 @@ parser_intrinsic_subst( cbl_field_t *f, SHOW_PARSE { SHOW_PARSE_HEADER + SHOW_PARSE_FIELD(" TO ", f) + for(size_t i=0; i<argc; i++) + { + SHOW_PARSE_INDENT + SHOW_PARSE_FIELD(" ", argv[i].orig.field) + SHOW_PARSE_FIELD(" ", argv[i].replacement.field) + } SHOW_PARSE_END } TRACE1 @@ -15908,12 +15919,12 @@ psa_global(cbl_field_t *new_var) if( strcmp(new_var->name, "RETURN-CODE") == 0 ) { - strcpy(ach, "__gg___11_return_code6"); + strcpy(ach, "__gg__return_code"); } if( strcmp(new_var->name, "UPSI-0") == 0 ) { - strcpy(ach, "__gg___6_upsi_04"); + strcpy(ach, "__gg__upsi"); } new_var->var_decl_node = gg_declare_variable(cblc_field_type_node, ach, NULL, vs_external_reference); @@ -16156,6 +16167,10 @@ psa_FldLiteralA(struct cbl_field_t *field ) field->data.initial, NULL_TREE, field->var_decl_node); + TREE_READONLY(field->var_decl_node) = 1; + TREE_USED(field->var_decl_node) = 1; + TREE_STATIC(field->var_decl_node) = 1; + DECL_PRESERVE_P (field->var_decl_node) = 1; nvar += 1; } TRACE1 diff --git a/gcc/cobol/gengen.cc b/gcc/cobol/gengen.cc index ffb64c8..e7a4e3c 100644 --- a/gcc/cobol/gengen.cc +++ b/gcc/cobol/gengen.cc @@ -375,6 +375,10 @@ show_type(tree type) static char ach[1024]; switch( TREE_CODE(type) ) { + case POINTER_TYPE: + sprintf(ach, "POINTER"); + break; + case VOID_TYPE: sprintf(ach, "VOID"); break; @@ -2548,6 +2552,10 @@ gg_define_function_with_no_parameters(tree return_type, DECL_CONTEXT (function_decl) = gg_trans_unit.trans_unit_decl; TREE_PUBLIC(function_decl) = 0; + // This function is file static, but nobody calls it, so without + // intervention -O1+ optimizations will discard it. + DECL_PRESERVE_P (function_decl) = 1; + // Append this function to the list of functions and variables // associated with the computation module. gg_append_var_decl(function_decl); @@ -3358,8 +3366,8 @@ gg_array_of_size_t( size_t N, size_t *values) tree gg_array_of_bytes( size_t N, unsigned char *values) { - tree retval = gg_define_variable(build_pointer_type(UCHAR)); - gg_assign(retval, gg_cast(build_pointer_type(UCHAR), gg_malloc( build_int_cst_type(UCHAR, N * sizeof(unsigned char))))); + tree retval = gg_define_variable(UCHAR_P); + gg_assign(retval, gg_cast(UCHAR_P, gg_malloc( build_int_cst_type(SIZE_T, N * sizeof(unsigned char))))); for(size_t i=0; i<N; i++) { gg_assign(gg_array_value(retval, i), build_int_cst_type(UCHAR, values[i])); diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index f38e3db..4f8380c4 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -21883,7 +21883,11 @@ ix86_rtx_costs (rtx x, machine_mode mode, int outer_code_i, int opno, case SYMBOL_REF: if (x86_64_immediate_operand (x, VOIDmode)) *total = 0; - else + else if (TARGET_64BIT && x86_64_zext_immediate_operand (x, VOIDmode)) + /* Consider the zext constants slightly more expensive, as they + can't appear in most instructions. */ + *total = 1; + else /* movabsq is slightly more expensive than a simple instruction. */ *total = COSTS_N_INSNS (1) + 1; return true; diff --git a/gcc/config/nvptx/nvptx.cc b/gcc/config/nvptx/nvptx.cc index 022037f..de0ce5d 100644 --- a/gcc/config/nvptx/nvptx.cc +++ b/gcc/config/nvptx/nvptx.cc @@ -470,9 +470,7 @@ nvptx_encode_section_info (tree decl, rtx rtl, int first) { nvptx_data_area area = DATA_AREA_GENERIC; - if (TREE_CONSTANT (decl)) - area = DATA_AREA_CONST; - else if (VAR_P (decl)) + if (VAR_P (decl)) { if (lookup_attribute ("shared", DECL_ATTRIBUTES (decl))) { @@ -482,7 +480,7 @@ nvptx_encode_section_info (tree decl, rtx rtl, int first) " memory is not supported", decl); } else - area = TREE_READONLY (decl) ? DATA_AREA_CONST : DATA_AREA_GLOBAL; + area = DATA_AREA_GLOBAL; } SET_SYMBOL_DATA_AREA (XEXP (rtl, 0), area); @@ -2597,7 +2595,7 @@ nvptx_asm_declare_constant_name (FILE *file, const char *name, fprintf (file, "\t"); tree type = TREE_TYPE (exp); - nvptx_assemble_decl_begin (file, name, ".const", type, obj_size, + nvptx_assemble_decl_begin (file, name, ".global", type, obj_size, TYPE_ALIGN (type)); } diff --git a/gcc/config/rs6000/rs6000-logue.cc b/gcc/config/rs6000/rs6000-logue.cc index 52f44b1..5377ad6c 100644 --- a/gcc/config/rs6000/rs6000-logue.cc +++ b/gcc/config/rs6000/rs6000-logue.cc @@ -5351,6 +5351,8 @@ rs6000_output_function_epilogue (FILE *file) i = 1; else if (! strcmp (language_string, "GNU Ada")) i = 3; + else if (! strcmp (language_string, "GCC COBOL")) + i = 7; else if (! strcmp (language_string, "GNU Modula-2")) i = 8; else if (lang_GNU_CXX () diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index b605560..9342f9f 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,28 @@ +2025-04-03 Patrick Palka <ppalka@redhat.com> + + PR c++/119387 + * constexpr.cc (p2280_active_p): New. + (cxx_eval_constant_expression) <case VAR_DECL>: Use it to + restrict P2280 relaxations. + <case PARM_DECL>: Likewise. + +2025-04-03 Jason Merrill <jason@redhat.com> + + * module.cc (module_state::read_cluster) + (post_load_processing): Clear DECL_EXTERNAL if DECL_COMDAT. + +2025-04-03 Jason Merrill <jason@redhat.com> + + * call.cc (add_candidates): Re-lookup ne_fns if we move into + another namespace. + +2025-04-03 Andrew Pinski <quic_apinski@quicinc.com> + Jakub Jelinek <jakub@redhat.com> + + PR c++/119563 + * call.cc (build_list_conv): Fix a typo in loop gathering + summary information from subsubconvs. + 2025-04-02 Sandra Loosemore <sloosemore@baylibre.com> PR middle-end/118965 diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc index d853362..6caac89 100644 --- a/gcc/cp/call.cc +++ b/gcc/cp/call.cc @@ -6673,6 +6673,7 @@ add_candidates (tree fns, tree first_arg, const vec<tree, va_gc> *args, bool check_list_ctor = false; bool check_converting = false; unification_kind_t strict; + tree ne_context = NULL_TREE; tree ne_fns = NULL_TREE; if (!fns) @@ -6719,6 +6720,7 @@ add_candidates (tree fns, tree first_arg, const vec<tree, va_gc> *args, tree ne_name = ovl_op_identifier (false, NE_EXPR); if (DECL_CLASS_SCOPE_P (fn)) { + ne_context = DECL_CONTEXT (fn); ne_fns = lookup_fnfields (TREE_TYPE ((*args)[0]), ne_name, 1, tf_none); if (ne_fns == error_mark_node || ne_fns == NULL_TREE) @@ -6728,8 +6730,9 @@ add_candidates (tree fns, tree first_arg, const vec<tree, va_gc> *args, } else { - tree context = decl_namespace_context (fn); - ne_fns = lookup_qualified_name (context, ne_name, LOOK_want::NORMAL, + ne_context = decl_namespace_context (fn); + ne_fns = lookup_qualified_name (ne_context, ne_name, + LOOK_want::NORMAL, /*complain*/false); if (ne_fns == error_mark_node || !is_overloaded_fn (ne_fns)) @@ -6828,8 +6831,26 @@ add_candidates (tree fns, tree first_arg, const vec<tree, va_gc> *args, /* When considering reversed operator==, if there's a corresponding operator!= in the same scope, it's not a rewrite target. */ - if (ne_fns) + if (ne_context) { + if (TREE_CODE (ne_context) == NAMESPACE_DECL) + { + /* With argument-dependent lookup, fns can span multiple + namespaces; make sure we look in the fn's namespace for a + corresponding operator!=. */ + tree fn_ns = decl_namespace_context (fn); + if (fn_ns != ne_context) + { + ne_context = fn_ns; + tree ne_name = ovl_op_identifier (false, NE_EXPR); + ne_fns = lookup_qualified_name (ne_context, ne_name, + LOOK_want::NORMAL, + /*complain*/false); + if (ne_fns == error_mark_node + || !is_overloaded_fn (ne_fns)) + ne_fns = NULL_TREE; + } + } bool found = false; for (lkp_iterator ne (ne_fns); !found && ne; ++ne) if (0 && !ne.using_p () diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index 4820bcc..9a57f48 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -1294,6 +1294,22 @@ struct constexpr_ctx { mce_value manifestly_const_eval; }; +/* True if the constexpr relaxations afforded by P2280R4 for unknown + references and objects are in effect. */ + +static bool +p2280_active_p (const constexpr_ctx *ctx) +{ + if (ctx->manifestly_const_eval != mce_true) + /* Disable these relaxations during speculative constexpr folding, + as it can significantly increase compile time/memory use + (PR119387). */ + return false; + + /* P2280R4 was accepted as a DR against C++11. */ + return cxx_dialect >= cxx11; +} + /* Remove T from the global values map, checking for attempts to destroy a value that has already finished its lifetime. */ @@ -7792,7 +7808,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, r = TARGET_EXPR_INITIAL (r); if (DECL_P (r) /* P2280 allows references to unknown. */ - && !(VAR_P (t) && TYPE_REF_P (TREE_TYPE (t)))) + && !(p2280_active_p (ctx) && VAR_P (t) && TYPE_REF_P (TREE_TYPE (t)))) { if (!ctx->quiet) non_const_var_error (loc, r, /*fundef_p*/false); @@ -7844,9 +7860,9 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, r = build_constructor (TREE_TYPE (t), NULL); TREE_CONSTANT (r) = true; } - else if (TYPE_REF_P (TREE_TYPE (t))) + else if (p2280_active_p (ctx) && TYPE_REF_P (TREE_TYPE (t))) /* P2280 allows references to unknown... */; - else if (is_this_parameter (t)) + else if (p2280_active_p (ctx) && is_this_parameter (t)) /* ...as well as the this pointer. */; else { diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc index ed70bb0..f0a54b6 100644 --- a/gcc/cp/lambda.cc +++ b/gcc/cp/lambda.cc @@ -59,7 +59,13 @@ build_lambda_object (tree lambda_expr) vec<constructor_elt, va_gc> *elts = NULL; tree node, expr, type; - if (processing_template_decl || lambda_expr == error_mark_node) + if (processing_template_decl && !in_template_context + && current_binding_level->requires_expression) + /* As in cp_parser_lambda_expression, don't get confused by + cp_parser_requires_expression setting processing_template_decl. In that + case we want to return the result of finish_compound_literal, to avoid + tsubst_lambda_expr. */; + else if (processing_template_decl || lambda_expr == error_mark_node) return lambda_expr; /* Make sure any error messages refer to the lambda-introducer. */ diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index ce22b2e..89deabb 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -16679,6 +16679,15 @@ module_state::read_cluster (unsigned snum) #endif cfun->returns_struct = aggr; expand_or_defer_fn (decl); + + /* If we first see this function after at_eof, it doesn't get + note_vague_linkage_fn from tentative_decl_linkage, so the loop in + c_parse_final_cleanups won't consider it. But with DECL_COMDAT we + can just clear DECL_EXTERNAL and let cgraph decide. + FIXME handle this outside module.cc after GCC 15. */ + if (at_eof && DECL_COMDAT (decl) && DECL_EXTERNAL (decl) + && DECL_NOT_REALLY_EXTERN (decl)) + DECL_EXTERNAL (decl) = false; } } @@ -19159,6 +19168,10 @@ post_load_processing () gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl)); expand_or_defer_fn (decl); + /* As in module_state::read_cluster. */ + if (at_eof && DECL_COMDAT (decl) && DECL_EXTERNAL (decl) + && DECL_NOT_REALLY_EXTERN (decl)) + DECL_EXTERNAL (decl) = false; } cfun = old_cfun; diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 53e6237..812a7c5 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -11736,21 +11736,34 @@ cp_parser_lambda_expression (cp_parser* parser) if (cp_parser_error_occurred (parser)) return error_mark_node; - type = begin_lambda_type (lambda_expr); - if (type == error_mark_node) - return error_mark_node; + { + /* OK, this is a bit tricksy. cp_parser_requires_expression sets + processing_template_decl to make checking more normal, but that confuses + lambda parsing terribly. In non-template context, we want to parse the + lambda once and not tsubst_lambda_expr. So in that case, clear + processing_template_decl now, and restore it before the call to + build_lambda_object; that way we end up with what looks like a templatey + functional cast to the closure type, which is suitable for the + requires-expression tsubst_expr. This is PR99546 and friends. */ + processing_template_decl_sentinel ptds (/*reset*/false); + if (processing_template_decl && !in_template_context + && current_binding_level->requires_expression) + processing_template_decl = 0; + + type = begin_lambda_type (lambda_expr); + if (type == error_mark_node) + return error_mark_node; - record_lambda_scope (lambda_expr); - record_lambda_scope_discriminator (lambda_expr); + record_lambda_scope (lambda_expr); + record_lambda_scope_discriminator (lambda_expr); - /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */ - determine_visibility (TYPE_NAME (type)); + /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */ + determine_visibility (TYPE_NAME (type)); - /* Now that we've started the type, add the capture fields for any - explicit captures. */ - register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr)); + /* Now that we've started the type, add the capture fields for any + explicit captures. */ + register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr)); - { /* Inside the class, surrounding template-parameter-lists do not apply. */ unsigned int saved_num_template_parameter_lists = parser->num_template_parameter_lists; diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 7d8beb8..a10ef34 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -4755,6 +4755,7 @@ finish_id_expression_1 (tree id_expression, body, except inside an unevaluated context (i.e. decltype). */ if (TREE_CODE (decl) == PARM_DECL && DECL_CONTEXT (decl) == NULL_TREE + && !CONSTRAINT_VAR_P (decl) && !cp_unevaluated_operand && !processing_contract_condition && !processing_omp_trait_property_expr) diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 4302df7..16ad83f 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -9314,7 +9314,7 @@ The @code{gnu::musttail} or @code{clang::musttail} standard attribute or @code{musttail} GNU attribute can be applied to a @code{return} statement with a return-value expression that is a function call. It asserts that the call must be a tail call that does not allocate extra stack space, so it is -safe to use tail recursion to implement long running loops. +safe to use tail recursion to implement long-running loops. @smallexample [[gnu::musttail]] return foo(); @@ -9324,11 +9324,11 @@ safe to use tail recursion to implement long running loops. __attribute__((musttail)) return bar(); @end smallexample -If the compiler cannot generate a @code{musttail} tail call it will report -an error. On some targets tail calls may never be supported. -The user asserts for @code{musttail} tail calls that lifetime of automatic +If the compiler cannot generate a @code{musttail} tail call it reports +an error. On some targets, tail calls may not be supported at all. +The @code{musttail} attribute asserts that the lifetime of automatic variables, function parameters and temporaries (unless they have non-trivial -destruction) can end before the actual call instruction and that any access +destruction) can end before the actual call instruction, and that any access to those from inside of the called function results is considered undefined behavior. Enabling @option{-O1} or @option{-O2} can improve the success of tail calls. @@ -9344,9 +9344,9 @@ baz (int *x) if (*x == 1) @{ int a = 42; - /* The call will be tail called (would not be without the - attribute), dereferencing the pointer in the callee is - undefined behavior and there will be a warning emitted + /* The call is a tail call (would not be without the + attribute). Dereferencing the pointer in the callee is + undefined behavior, and there is a warning emitted for this by default (@option{-Wmusttail-local-addr}). */ [[gnu::musttail]] return foo (&a); @} @@ -9354,9 +9354,9 @@ baz (int *x) @{ int a = 42; bar (&a); - /* The call will be tail called (would not be without the - attribute), if bar stores the pointer anywhere, dereferencing - it in foo will be undefined behavior and there will be a warning + /* The call is a tail call (would not be without the + attribute). If bar stores the pointer anywhere, dereferencing + it in foo is undefined behavior. There is a warning emitted for this with @option{-Wextra}, which implies @option{-Wmaybe-musttail-local-addr}. */ [[gnu::musttail]] return foo (nullptr); @@ -9365,8 +9365,8 @@ baz (int *x) @{ S s; /* The s variable requires non-trivial destruction which ought - to be performed after the foo call returns, so this will - be rejected. */ + to be performed after the foo call returns, so this is + rejected. */ [[gnu::musttail]] return foo (&s.s); @} @} @@ -9374,9 +9374,9 @@ baz (int *x) To avoid the @option{-Wmaybe-musttail-local-addr} warning in the above @code{*x == 2} case and similar code, consider defining the -maybe escaped variables in a separate scope which will end before the -return statement if possible to make it clear that the variable is not -live during the call. So +maybe-escaped variables in a separate scope that ends before the +return statement, if that is possible, to make it clear that the +variable is not live during the call. So: @smallexample else if (*x == 2) @@ -9385,17 +9385,17 @@ live during the call. So int a = 42; bar (&a); @} - /* The call will be tail called (would not be without the - attribute), if bar stores the pointer anywhere, dereferencing - it in foo will be undefined behavior and there will be a warning - emitted for this with @option{-Wextra}, which implies - @option{-Wmaybe-musttail-local-addr}. */ + /* The call is a tail call (would not be without the + attribute). If bar stores the pointer anywhere, dereferencing + it in foo is undefined behavior even without tail call + optimization, and there is no warning. */ [[gnu::musttail]] return foo (nullptr); @} @end smallexample -in this case. That is not possible if it is function argument which -is address taken because those are in scope for the whole function. +It is not possible to avoid the warning in this way if the maybe-escaped +variable is a function argument, because those are in scope +for the whole function. @end table @node Attribute Syntax diff --git a/gcc/lto-opts.cc b/gcc/lto-opts.cc index dee1caa..3959598 100644 --- a/gcc/lto-opts.cc +++ b/gcc/lto-opts.cc @@ -82,31 +82,32 @@ lto_write_options (void) subject of merging in lto-wrapper. */ if (!OPTION_SET_P (flag_pic) && !OPTION_SET_P (flag_pie)) { - append_to_collect_gcc_options (&temporary_obstack, &first_p, - global_options.x_flag_pic == 2 - ? "-fPIC" - : global_options.x_flag_pic == 1 - ? "-fpic" - : global_options.x_flag_pie == 2 - ? "-fPIE" - : global_options.x_flag_pie == 1 - ? "-fpie" - : "-fno-pie"); + const char *pic = "-fno-pie"; + if (global_options.x_flag_pie == 2) + pic = "-fPIE"; + else if (global_options.x_flag_pie == 1) + pic = "-fpie"; + else if (global_options.x_flag_pic == 2) + pic = "-fPIC"; + else if (global_options.x_flag_pic == 1) + pic = "-fpic"; + append_to_collect_gcc_options (&temporary_obstack, &first_p, pic); } if (!OPTION_SET_P (flag_cf_protection)) { - append_to_collect_gcc_options ( - &temporary_obstack, &first_p, - global_options.x_flag_cf_protection == CF_NONE - ? "-fcf-protection=none" - : global_options.x_flag_cf_protection == CF_FULL - ? "-fcf-protection=full" - : global_options.x_flag_cf_protection == CF_BRANCH - ? "-fcf-protection=branch" - : global_options.x_flag_cf_protection == CF_RETURN - ? "-fcf-protection=return" - : ""); + const char *cf_protection = NULL; + switch (global_options.x_flag_cf_protection) + { + case CF_NONE: cf_protection = "-fcf-protection=none"; break; + case CF_FULL: cf_protection = "-fcf-protection=full"; break; + case CF_BRANCH: cf_protection = "-fcf-protection=branch"; break; + case CF_RETURN: cf_protection = "-fcf-protection=return"; break; + default: break; + } + if (cf_protection) + append_to_collect_gcc_options (&temporary_obstack, &first_p, + cf_protection); } /* If debug info is enabled append -g. */ diff --git a/gcc/profile.cc b/gcc/profile.cc index 550c85b97..6234dd2 100644 --- a/gcc/profile.cc +++ b/gcc/profile.cc @@ -1341,9 +1341,10 @@ branch_prob (bool thunk) ignored_edges++; } /* Ignore edges after musttail calls. */ - if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)) + if (cfun->has_musttail + && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)) { - gimple_stmt_iterator gsi = gsi_last_bb (e->src); + gimple_stmt_iterator gsi = gsi_last_nondebug_bb (e->src); gimple *stmt = gsi_stmt (gsi); if (stmt && is_gimple_call (stmt) diff --git a/gcc/rtlanal.cc b/gcc/rtlanal.cc index 7ad67af..86a5e47 100644 --- a/gcc/rtlanal.cc +++ b/gcc/rtlanal.cc @@ -5772,7 +5772,7 @@ pattern_cost (rtx pat, bool speed) return 0; cost = set_src_cost (SET_SRC (set), GET_MODE (SET_DEST (set)), speed); - return cost > 0 ? cost : COSTS_N_INSNS (1); + return MAX (COSTS_N_INSNS (1), cost); } /* Calculate the cost of a single instruction. A return value of zero diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 422b365..9bc53e0 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,106 @@ +2025-04-03 Thomas Schwinge <tschwinge@baylibre.com> + + PR target/119573 + * gcc.c-torture/compile/pr46534.c: Don't 'dg-skip-if' nvptx. + * gcc.target/nvptx/decl.c: Adjust. + +2025-04-03 Jason Merrill <jason@redhat.com> + + * g++.dg/cpp2a/spaceship-rewrite6.C: New test. + +2025-04-03 Victor Do Nascimento <victor.donascimento@arm.com> + + PR testsuite/118597 + * gcc.dg/vect/vect-fncall-mask.c: Update test directives. + +2025-04-03 Bob Dubner <rdubner@symas.com> + + * cobol.dg/group2/INSPECT_BACKWARD_REPLACING_LEADING.cob: New testcase. + * cobol.dg/group2/INSPECT_BACKWARD_REPLACING_TRAILING.cob: Likewise. + * cobol.dg/group2/INSPECT_BACKWARD_simple_CONVERTING.cob: Likewise. + * cobol.dg/group2/INSPECT_BACKWARD_simple_REPLACING.cob: Likewise. + * cobol.dg/group2/INSPECT_BACKWARD_simple_TALLYING.cob: Likewise. + * cobol.dg/group2/INSPECT_CONVERTING_NULL.cob: Likewise. + * cobol.dg/group2/INSPECT_CONVERTING_TO_figurative_constant.cob: Likewise. + * cobol.dg/group2/INSPECT_CONVERTING_TO_figurative_constants.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_1.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_2.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_3.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_4.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_5.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_5-f.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_5-r.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_6.cob: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_7.cob: Likewise. + * cobol.dg/group2/INSPECT_No_repeat_conversion_check.cob: Likewise. + * cobol.dg/group2/INSPECT_REPLACING_figurative_constant.cob: Likewise. + * cobol.dg/group2/INSPECT_REPLACING_LEADING_ZEROS_BY_SPACES.cob: Likewise. + * cobol.dg/group2/INSPECT_TALLYING_AFTER.cob: Likewise. + * cobol.dg/group2/INSPECT_TALLYING_BEFORE.cob: Likewise. + * cobol.dg/group2/INSPECT_TALLYING_REPLACING_ISO_Example.cob: Likewise. + * cobol.dg/group2/INSPECT_TRAILING.cob: Likewise. + * cobol.dg/group2/INSPECT_BACKWARD_REPLACING_LEADING.out: New known-good result. + * cobol.dg/group2/INSPECT_BACKWARD_REPLACING_TRAILING.out: Likewise. + * cobol.dg/group2/INSPECT_BACKWARD_simple_CONVERTING.out: Likewise. + * cobol.dg/group2/INSPECT_BACKWARD_simple_REPLACING.out: Likewise. + * cobol.dg/group2/INSPECT_BACKWARD_simple_TALLYING.out: Likewise. + * cobol.dg/group2/INSPECT_CONVERTING_TO_figurative_constants.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_1.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_2.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_3.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_4.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_5-f.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_5.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_5-r.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_6.out: Likewise. + * cobol.dg/group2/INSPECT_ISO_Example_7.out: Likewise. + * cobol.dg/group2/INSPECT_TALLYING_REPLACING_ISO_Example.out: Likewise. + * cobol.dg/group2/INSPECT_TRAILING.out: Likewise. + +2025-04-03 Andrew Pinski <quic_apinski@quicinc.com> + Jakub Jelinek <jakub@redhat.com> + + PR c++/119563 + * g++.dg/cpp0x/pr119563.C: New test. + * g++.dg/cpp/embed-26.C: New test. + +2025-04-03 Christophe Lyon <christophe.lyon@linaro.org> + + * gcc.dg/guality/pr90074.c: Remove xfail for aarch64. + * gcc.dg/guality/pr90716.c: Likewise. + +2025-04-03 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + * gcc.target/i386/pr111673.c (dg-options): Add + -fasynchronous-unwind-tables -fdwarf2-cfi-asm. + * gcc.target/i386/pr82142a.c: Likewise. + * gcc.target/i386/pr82142b.c (dg-options): Add -mno-stackrealign + -fasynchronous-unwind-tables -fdwarf2-cfi-asm. + +2025-04-03 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/riscv/rvv/base/vwaddsub-1.c: Require rv64. + +2025-04-03 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/riscv/mcpu-xiangshan-nanhu.c: Skip on non-rv64. + +2025-04-03 Alexandre Oliva <oliva@adacore.com> + + PR tree-optimization/113281 + * gcc.dg/vect/costmodel/riscv/rvv/pr113281-1.c: XFAIL. + * gcc.dg/vect/costmodel/riscv/rvv/pr113281-2.c: Likewise. + * gcc.dg/vect/costmodel/riscv/rvv/pr113281-5.c: Likewise. + +2025-04-03 Alexandre Oliva <oliva@adacore.com> + + * gcc.dg/tree-ssa/ssa-dom-cse-2.c: XFAIL on riscv lp64. + +2025-04-03 Hongyu Wang <hongyu.wang@intel.com> + + PR target/119539 + * gcc.target/i386/apx-nf-pr119539.c: New test. + 2025-04-02 Jin Ma <jinma@linux.alibaba.com> * gcc.target/riscv/zba-shNadd-09.c: New test. diff --git a/gcc/testsuite/c-c++-common/pr119614-1.c b/gcc/testsuite/c-c++-common/pr119614-1.c new file mode 100644 index 0000000..89105a3 --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr119614-1.c @@ -0,0 +1,28 @@ +/* PR tree-optimization/119614 */ +/* { dg-do compile { target musttail } } */ +/* { dg-options "-O2" } */ + +volatile int v; + +[[gnu::noinline]] const char * +foo (int x) +{ + v += x; + return 0; +} + +const char * +bar (int x) +{ + if (x == 42) + [[gnu::musttail]] return foo (42); + [[gnu::musttail]] return foo (32); +} + +const char * +baz (int x) +{ + if (x == 5) + return foo (42); + return foo (32); +} diff --git a/gcc/testsuite/c-c++-common/pr119614-2.c b/gcc/testsuite/c-c++-common/pr119614-2.c new file mode 100644 index 0000000..8833eee --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr119614-2.c @@ -0,0 +1,28 @@ +/* PR tree-optimization/119614 */ +/* { dg-do compile { target musttail } } */ +/* { dg-options "-O2" } */ + +volatile int v; + +[[gnu::noinline]] const char * +foo (int x) +{ + v += x; + return (const char *) -42; +} + +const char * +bar (int x) +{ + if (x == 42) + [[gnu::musttail]] return foo (42); + [[gnu::musttail]] return foo (32); +} + +const char * +baz (int x) +{ + if (x == 5) + return foo (42); + return foo (32); +} diff --git a/gcc/testsuite/c-c++-common/pr119614-3.c b/gcc/testsuite/c-c++-common/pr119614-3.c new file mode 100644 index 0000000..59ed36b --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr119614-3.c @@ -0,0 +1,28 @@ +/* PR tree-optimization/119614 */ +/* { dg-do compile { target musttail } } */ +/* { dg-options "-O2" } */ + +volatile int v; + +[[gnu::noinline]] double +foo (int x) +{ + v += x; + return 0.5; +} + +double +bar (int x) +{ + if (x == 42) + [[gnu::musttail]] return foo (42); + [[gnu::musttail]] return foo (32); +} + +double +baz (int x) +{ + if (x == 5) + return foo (42); + return foo (32); +} diff --git a/gcc/testsuite/c-c++-common/pr119616.c b/gcc/testsuite/c-c++-common/pr119616.c new file mode 100644 index 0000000..5ffdb8c --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr119616.c @@ -0,0 +1,23 @@ +/* PR tree-optimization/119616 */ +/* { dg-do compile { target external_musttail } } */ +/* { dg-options "-O2" } */ + +int foo (int *); +int bar (int); + +int +baz (int x) +{ + if (!x) + [[gnu::musttail]] return bar (x); + return foo (&x); +} + +int +qux (int x) +{ + if (!x) + [[gnu::musttail]] return bar (x); + foo (&x); + return 1; +} diff --git a/gcc/testsuite/c-c++-common/pr119618.c b/gcc/testsuite/c-c++-common/pr119618.c new file mode 100644 index 0000000..a56e669 --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr119618.c @@ -0,0 +1,21 @@ +/* PR gcov-profile/119618 */ +/* { dg-do compile { target musttail } } */ +/* { dg-options "-fcompare-debug -fprofile-generate -O1" } */ +/* { dg-require-profiling "-fprofile-generate" } */ + +struct S { char s; }; +int foo (void); +int *(*fn) (void); + +int * +bar (void) +{ + if (foo ()) + return 0; + { + struct S s; + do + [[gnu::musttail]] return fn (); + while (0); + } +} diff --git a/gcc/testsuite/g++.dg/cpp/pr119391.C b/gcc/testsuite/g++.dg/cpp/pr119391.C new file mode 100644 index 0000000..6e70efc --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp/pr119391.C @@ -0,0 +1,15 @@ +// PR preprocessor/119391 +// { dg-do preprocess } +// { dg-options "" } + +#if (1 << 63) != -9223372036854775807 - 1 // { dg-warning "integer overflow in preprocessor expression" "" { target c++98_only } } +#warning "Unexpected value" +#endif +#if (3 << 62) != -4611686018427387904 // { dg-warning "integer overflow in preprocessor expression" "" { target c++98_only } } +#warning "Unexpected value" +#endif +#if 1 << 64 // { dg-warning "integer overflow in preprocessor expression" } +#endif +#if (3 << 63) != -9223372036854775807 - 1 // { dg-warning "integer overflow in preprocessor expression" "" { target c++17_down } } +#warning "Unexpected value" +#endif diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-requires41.C b/gcc/testsuite/g++.dg/cpp2a/concepts-requires41.C new file mode 100644 index 0000000..28c9761 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-requires41.C @@ -0,0 +1,25 @@ +// PR c++/117849 +// { dg-do compile { target c++20 } } + +template<int N> +struct array { + constexpr int size() const { return N; } +}; + +struct vector { + int _size = 3; + constexpr int size() const { return _size; } +}; + +template<int N> +struct integral_constant { + constexpr operator int() const { return N; } +}; + +template<class T> +concept StaticSize = requires (T& t) { + typename integral_constant<t.size()>; +}; + +static_assert(StaticSize<array<5>>); +static_assert(!StaticSize<vector>); diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-requires2.C b/gcc/testsuite/g++.dg/cpp2a/lambda-requires2.C new file mode 100644 index 0000000..be5a71a --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-requires2.C @@ -0,0 +1,8 @@ +// PR c++/99546 +// { dg-do compile { target c++20 } } + +int main() { + constexpr auto b = requires { []{}; }; + static_assert(b); + static_assert(!b); // { dg-error "assertion failed" } +} diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-requires3.C b/gcc/testsuite/g++.dg/cpp2a/lambda-requires3.C new file mode 100644 index 0000000..8c4ef06 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-requires3.C @@ -0,0 +1,6 @@ +// PR c++/113925 +// { dg-do compile { target c++20 } } + +template<bool B> +struct b{}; +static_assert(requires { b<([]()consteval{ return true; }())>{}; }); diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-requires4.C b/gcc/testsuite/g++.dg/cpp2a/lambda-requires4.C new file mode 100644 index 0000000..f3bb041 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-requires4.C @@ -0,0 +1,6 @@ +// PR c++/106976 +// { dg-do compile { target c++20 } } + +struct S{ + constexpr static auto s = requires { []; }; // { dg-error "expected '\{'" } +}; diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-requires5.C b/gcc/testsuite/g++.dg/cpp2a/lambda-requires5.C new file mode 100644 index 0000000..c818313 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-requires5.C @@ -0,0 +1,10 @@ +// PR c++/109961 +// { dg-do compile { target c++20 } } + +auto a = requires{ + []( int b ) consteval { + if( b ) { + throw b; + } + }( 0 ); +}; diff --git a/gcc/testsuite/g++.dg/cpp2a/spaceship-rewrite6.C b/gcc/testsuite/g++.dg/cpp2a/spaceship-rewrite6.C new file mode 100644 index 0000000..0ec74e8 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/spaceship-rewrite6.C @@ -0,0 +1,33 @@ +// { dg-do compile { target c++20 } } + +// We wrongly considered D to be ne_comparable because we were looking for a +// corresponding op!= for N::op== in ::, because ::op== happened to be the +// first thing in the lookup set. + +template<bool, typename _Tp = void> +struct enable_if; + +template<typename _Tp> +struct enable_if<true, _Tp> +{ typedef _Tp type; }; + +template <class T, class U> struct A { }; + +namespace N { + struct X { }; + template <class T> auto operator== (const A<T,X>&, const A<T,X>&) + -> typename enable_if<sizeof(T() == T()), bool>::type; + template <class T> auto operator!= (const A<T,X>&, const A<T,X>&) + -> typename enable_if<sizeof(T() != T()), bool>::type; +} + +template<typename T, typename U = T> +concept ne_comparable += requires (const A<T,N::X>& t, const A<U,N::X>& u) { + t != u; +}; + +struct D { }; +int operator==(D, D); +bool operator!=(D, D) = delete; +static_assert( ! ne_comparable<D> ); diff --git a/gcc/testsuite/g++.dg/opt/pr119613.C b/gcc/testsuite/g++.dg/opt/pr119613.C new file mode 100644 index 0000000..432a30c --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/pr119613.C @@ -0,0 +1,22 @@ +// PR middle-end/119613 +// { dg-do compile { target { musttail && { c || c++11 } } } } +// { dg-options "-O0" } + +struct S { S () {} }; +char *foo (S); +void bar (int); + +[[gnu::always_inline]] inline char * +baz (S x) +{ + unsigned i; + &i; + bar (i); + [[gnu::musttail]] return foo (x); +} + +char * +qux (S) +{ + [[gnu::musttail]] return baz (S {}); +} diff --git a/gcc/testsuite/gcc.c-torture/compile/pr46534.c b/gcc/testsuite/gcc.c-torture/compile/pr46534.c index 1894636..7f10bc0 100644 --- a/gcc/testsuite/gcc.c-torture/compile/pr46534.c +++ b/gcc/testsuite/gcc.c-torture/compile/pr46534.c @@ -1,4 +1,3 @@ -/* { dg-skip-if "too big" { nvptx-*-* } } */ /* PR middle-end/46534 */ extern int printf (const char *, ...); diff --git a/gcc/testsuite/gcc.dg/builtin-apply5.c b/gcc/testsuite/gcc.dg/builtin-apply5.c new file mode 100644 index 0000000..16892f7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/builtin-apply5.c @@ -0,0 +1,23 @@ +/* { dg-options "-O2 -Wmissing-noreturn -fgnu89-inline" } */ +/* { dg-additional-options "-mno-mmx" { target { { i?86-*-* x86_64-*-* } && ia32 } } } */ +/* { dg-do compile } */ + +extern void abort (void); + +double +foo (int arg) +{ + if (arg != 116) + abort(); + return arg + 1; +} + +__attribute__((noreturn)) +double +bar (int arg) +{ + foo (arg); + __builtin_return (__builtin_apply ((void (*) ()) foo, /* { dg-warning "'noreturn' function does return" } */ + __builtin_apply_args (), 16)); +} + diff --git a/gcc/testsuite/gcc.dg/torture/pr119599-1.c b/gcc/testsuite/gcc.dg/torture/pr119599-1.c new file mode 100644 index 0000000..4fbd228 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr119599-1.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-options "-fdump-tree-einline" } */ + +/* PR ipa/119599 */ +/* inlining a noreturn function which returns + can cause an ICE when dealing finding an unreachable block. + We should get a __builtin_unreachable after the inliing. */ + + +void baz (void); + +static inline __attribute__((always_inline, noreturn)) void +bar (void) +{ + static volatile int t = 0; + if (t == 0) + baz (); +} /* { dg-warning "function does return" } */ + +void +foo (void) +{ + bar (); +} + +/* After inlining, we should have call to __builtin_unreachable now. */ +/* { dg-final { scan-tree-dump "__builtin_unreachable " "einline" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-fncall-mask.c b/gcc/testsuite/gcc.dg/vect/vect-fncall-mask.c index 554488e..ba1886d 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-fncall-mask.c +++ b/gcc/testsuite/gcc.dg/vect/vect-fncall-mask.c @@ -1,7 +1,7 @@ /* { dg-do compile { target { aarch64*-*-* } } } */ -/* { dg-additional-options "-march=armv8.2-a+sve -fdump-tree-ifcvt-raw -Ofast" { target { aarch64*-*-* } } } */ +/* { dg-additional-options "-march=armv8.2-a+sve -fdump-tree-ifcvt -Ofast" { target { aarch64*-*-* } } } */ -extern int __attribute__ ((simd, const)) fn (int); +extern int __attribute__ ((simd, const)) fn (float); const int N = 20; const float lim = 101.0; @@ -26,6 +26,4 @@ int main (void) return (0); } -/* { dg-final { scan-tree-dump {gimple_assign <gt_expr, _12, _1, 1.01e\+2, NULL>} ifcvt } } */ -/* { dg-final { scan-tree-dump {gimple_assign <bit_not_expr, _34, _12, NULL, NULL>} ifcvt } } */ -/* { dg-final { scan-tree-dump {gimple_call <.MASK_CALL, _3, fn, _2, _34>} ifcvt } } */ +/* { dg-final { scan-tree-dump {(_\d+) = (_\d+) > 1.01e\+2;\n\s*(_\d+) = ~\1;\n\s*_\d+ = .MASK_CALL \(fn, \2, \3\);} ifcvt } } */ diff --git a/gcc/testsuite/gcc.target/arm/mve/mve.exp b/gcc/testsuite/gcc.target/arm/mve/mve.exp index a5d8511..9dc56c9 100644 --- a/gcc/testsuite/gcc.target/arm/mve/mve.exp +++ b/gcc/testsuite/gcc.target/arm/mve/mve.exp @@ -35,6 +35,7 @@ global dg_runtest_extra_prunes set dg_runtest_extra_prunes "" lappend dg_runtest_extra_prunes "warning: switch '-m(cpu|arch)=.*' conflicts with switch '-m(cpu|arch)=.*'" +set saved-dg-do-what-default ${dg-do-what-default} set dg-do-what-default "assemble" # Initialize `dg'. @@ -53,6 +54,8 @@ dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/general-c/*.\[cCS\]]] \ dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cCS\]]] \ "" $DEFAULT_CFLAGS +set dg-do-what-default ${saved-dg-do-what-default} + # All done. set dg_runtest_extra_prunes "" dg-finish diff --git a/gcc/testsuite/gcc.target/i386/pr115910.c b/gcc/testsuite/gcc.target/i386/pr115910.c new file mode 100644 index 0000000..5f1cd9a --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr115910.c @@ -0,0 +1,20 @@ +/* PR target/115910 */ +/* { dg-do compile { target { ! ia32 } } } */ +/* { dg-options "-O2 -march=x86-64 -mtune=generic -masm=att" } */ +/* { dg-final { scan-assembler-times {\timulq\t} 2 } } */ +/* { dg-final { scan-assembler-times {\tshrq\t\$33,} 2 } } */ +/* { dg-final { scan-assembler-not {\tsarl\t} } } */ + +int +foo (int x) +{ + if (x < 0) + __builtin_unreachable (); + return x / 3U; +} + +int +bar (int x) +{ + return x / 3U; +} diff --git a/gcc/testsuite/gcc.target/nvptx/decl.c b/gcc/testsuite/gcc.target/nvptx/decl.c index 190a64d..45dd699 100644 --- a/gcc/testsuite/gcc.target/nvptx/decl.c +++ b/gcc/testsuite/gcc.target/nvptx/decl.c @@ -13,8 +13,8 @@ int Foo () } /* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.visible .global \[^,\r\n\]*glob_export" } } */ -/* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.visible .const \[^,\r\n\]*cst_export" } } */ +/* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.visible .global \[^,\r\n\]*cst_export" } } */ /* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.global \[^,\r\n\]*glob_local" } } */ -/* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.const \[^,\r\n\]*cst_local" } } */ +/* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.global \[^,\r\n\]*cst_local" } } */ /* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.extern .global \[^,\r\n\]*glob_import" } } */ -/* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.extern .const \[^,\r\n\]*cst_import" } } */ +/* { dg-final { scan-assembler "\[\r\n\]\[\t \]*.extern .global \[^,\r\n\]*cst_import" } } */ diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc index 2fa5678..ecf19d2 100644 --- a/gcc/tree-cfg.cc +++ b/gcc/tree-cfg.cc @@ -9799,18 +9799,20 @@ pass_warn_function_return::execute (function *fun) (e = ei_safe_edge (ei)); ) { last = *gsi_last_bb (e->src); - if ((gimple_code (last) == GIMPLE_RETURN - || gimple_call_builtin_p (last, BUILT_IN_RETURN)) - && location == UNKNOWN_LOCATION - && ((location = LOCATION_LOCUS (gimple_location (last))) - != UNKNOWN_LOCATION) - && !optimize) - break; - /* When optimizing, replace return stmts in noreturn functions + /* Warn about __builtin_return .*/ + if (gimple_call_builtin_p (last, BUILT_IN_RETURN) + && location == UNKNOWN_LOCATION) + { + location = LOCATION_LOCUS (gimple_location (last)); + ei_next (&ei); + } + /* Replace return stmts in noreturn functions with __builtin_unreachable () call. */ - if (optimize && gimple_code (last) == GIMPLE_RETURN) + else if (gimple_code (last) == GIMPLE_RETURN) { location_t loc = gimple_location (last); + if (location == UNKNOWN_LOCATION) + location = LOCATION_LOCUS (loc); gimple *new_stmt = gimple_build_builtin_unreachable (loc); gimple_stmt_iterator gsi = gsi_for_stmt (last); gsi_replace (&gsi, new_stmt, true); diff --git a/gcc/tree-tailcall.cc b/gcc/tree-tailcall.cc index 477729c..c8740f9 100644 --- a/gcc/tree-tailcall.cc +++ b/gcc/tree-tailcall.cc @@ -165,8 +165,6 @@ suitable_for_tail_opt_p (gcall *call, bool diag_musttail) static bool suitable_for_tail_call_opt_p (gcall *call, bool diag_musttail) { - tree param; - /* alloca (until we have stack slot life analysis) inhibits sibling call optimizations, but not tail recursion. */ if (cfun->calls_alloca) @@ -204,18 +202,6 @@ suitable_for_tail_call_opt_p (gcall *call, bool diag_musttail) return false; } - /* ??? It is OK if the argument of a function is taken in some cases, - but not in all cases. See PR15387 and PR19616. Revisit for 4.1. */ - if (!diag_musttail || !gimple_call_must_tail_p (call)) - for (param = DECL_ARGUMENTS (current_function_decl); - param; param = DECL_CHAIN (param)) - if (TREE_ADDRESSABLE (param)) - { - maybe_error_musttail (call, _("address of caller arguments taken"), - diag_musttail); - return false; - } - if (diag_musttail && gimple_call_must_tail_p (call) && warn_musttail_local_addr) @@ -565,6 +551,7 @@ find_tail_calls (basic_block bb, struct tailcall **ret, bool only_musttail, basic_block abb; size_t idx; tree var; + bool only_tailr = false; if (!single_succ_p (bb) && (EDGE_COUNT (bb->succs) || !cfun->has_musttail || !diag_musttail)) @@ -660,6 +647,25 @@ find_tail_calls (basic_block bb, struct tailcall **ret, bool only_musttail, if (!suitable_for_tail_call_opt_p (call, diag_musttail)) opt_tailcalls = false; + /* ??? It is OK if the argument of a function is taken in some cases, + but not in all cases. See PR15387 and PR19616. Revisit for 4.1. */ + if (!diag_musttail || !gimple_call_must_tail_p (call)) + for (param = DECL_ARGUMENTS (current_function_decl); + param; param = DECL_CHAIN (param)) + if (TREE_ADDRESSABLE (param)) + { + maybe_error_musttail (call, _("address of caller arguments taken"), + diag_musttail); + /* If current function has musttail calls, we can't disable tail + calls altogether for the whole caller, because those might be + actually fine. So just punt if this exact call is not + a tail recursion. */ + if (cfun->has_musttail) + only_tailr = true; + else + opt_tailcalls = false; + } + /* If the LHS of our call is not just a simple register or local variable, we can't transform this into a tail or sibling call. This situation happens, in (e.g.) "*p = foo()" where foo returns a @@ -794,6 +800,9 @@ find_tail_calls (basic_block bb, struct tailcall **ret, bool only_musttail, tail_recursion = true; } + if (only_tailr && !tail_recursion) + return; + /* Compute live vars if not computed yet. */ if (live_vars == NULL) { @@ -1036,7 +1045,9 @@ find_tail_calls (basic_block bb, struct tailcall **ret, bool only_musttail, && TREE_CONSTANT (ret_var)) if (tree type = gimple_range_type (call)) if (tree callee = gimple_call_fndecl (call)) - if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type)) + if ((INTEGRAL_TYPE_P (type) + || SCALAR_FLOAT_TYPE_P (type) + || POINTER_TYPE_P (type)) && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (callee)), type) && useless_type_conversion_p (TREE_TYPE (ret_var), type) diff --git a/libcpp/expr.cc b/libcpp/expr.cc index 4573752..7bb57a3 100644 --- a/libcpp/expr.cc +++ b/libcpp/expr.cc @@ -53,7 +53,7 @@ static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num, static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num); static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype, location_t); -static cpp_num num_lshift (cpp_num, size_t, size_t); +static cpp_num num_lshift (cpp_reader *, cpp_num, size_t, size_t); static cpp_num num_rshift (cpp_num, size_t, size_t); static cpp_num append_digit (cpp_num, int, int, size_t); @@ -2049,7 +2049,7 @@ num_rshift (cpp_num num, size_t precision, size_t n) /* Shift NUM, of width PRECISION, left by N bits. */ static cpp_num -num_lshift (cpp_num num, size_t precision, size_t n) +num_lshift (cpp_reader *pfile, cpp_num num, size_t precision, size_t n) { if (n >= precision) { @@ -2075,8 +2075,26 @@ num_lshift (cpp_num num, size_t precision, size_t n) } num = num_trim (num, precision); - if (num.unsignedp) + if (num.unsignedp + /* For C++20 or later since P1236R1, there is no overflow for signed + left shifts, it is as if the shift was in uintmax_t and cast + back to intmax_t afterwards. */ + || (CPP_OPTION (pfile, cplusplus) + && CPP_OPTION (pfile, lang) >= CLK_GNUCXX20)) num.overflow = false; + else if (CPP_OPTION (pfile, cplusplus) + && CPP_OPTION (pfile, lang) >= CLK_GNUCXX11 + && num_positive (orig, precision)) + { + /* For C++11 - C++17 since CWG1457, 1 << 63 is allowed because it is + representable in uintmax_t, but 3 << 63 is not. + Test whether num >> (precision - 1 - n) as logical + shift is > 1. */ + maybe_orig = orig; + maybe_orig.unsignedp = true; + maybe_orig = num_rshift (maybe_orig, precision, precision - 1 - n); + num.overflow = maybe_orig.high || maybe_orig.low > 1; + } else { maybe_orig = num_rshift (num, precision, n); @@ -2149,7 +2167,7 @@ num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op) else n = rhs.low; if (op == CPP_LSHIFT) - lhs = num_lshift (lhs, precision, n); + lhs = num_lshift (pfile, lhs, precision, n); else lhs = num_rshift (lhs, precision, n); break; @@ -2347,7 +2365,7 @@ num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op, rhs.unsignedp = true; lhs.unsignedp = true; i = precision - i - 1; - sub = num_lshift (rhs, precision, i); + sub = num_lshift (pfile, rhs, precision, i); result.high = result.low = 0; for (;;) diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index 48d65ef..d09332d 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,27 @@ +2025-04-03 Iain Sandoe <iain@sandoe.co.uk> + + * config.h.in: Regenerate. + * configure: Regenerate. + * configure.ac: Check for availability of strfromf32 and + strfromf64. + * libgcobol.cc (strfromf32, strfromf64): New. + +2025-04-03 Iain Sandoe <iain@sandoe.co.uk> + + PR cobol/119295 + * config.h.in: Regenerate. + * configure: Regenerate. + * configure.ac: Configure random_r and friends + * intrinsic.cc (__gg__random): Use random_r when available. + (__gg__random_next): Likewise. + +2025-04-03 Iain Sandoe <iain@sandoe.co.uk> + + * gfileio.cc: Include config.h. + * gmath.cc: Likewise. + * io.cc: Likewise. + * libgcobol.cc: Likewise. + 2025-04-02 Bob Dubner <rdubner@symas.com> PR cobol/119521 diff --git a/libgcobol/Makefile.am b/libgcobol/Makefile.am index cafb733..4521742 100644 --- a/libgcobol/Makefile.am +++ b/libgcobol/Makefile.am @@ -48,7 +48,7 @@ libgcobol_la_LINK = $(LIBTOOL) --mode=link --tag=CXX $(CXX) \ -Wc,-shared-libgcc \ -version-info $(LIBGCOBOL_VERSION) \ -lstdc++ \ - $(LTLDFLAGS) $(LTLIBICONV) + $(LTLDFLAGS) $(LTLIBICONV) $(LIBM) WARN_CFLAGS = -W -Wall -Wwrite-strings diff --git a/libgcobol/Makefile.in b/libgcobol/Makefile.in index c4a562a..0f0d9b6 100644 --- a/libgcobol/Makefile.in +++ b/libgcobol/Makefile.in @@ -305,6 +305,7 @@ LD = @LD@ LDFLAGS = @LDFLAGS@ LIBGCOBOL_VERSION = @LIBGCOBOL_VERSION@ LIBICONV = @LIBICONV@ +LIBM = @LIBM@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LIBTOOL = @LIBTOOL@ @@ -428,7 +429,7 @@ libgcobol_la_LINK = $(LIBTOOL) --mode=link --tag=CXX $(CXX) \ -Wc,-shared-libgcc \ -version-info $(LIBGCOBOL_VERSION) \ -lstdc++ \ - $(LTLDFLAGS) $(LTLIBICONV) + $(LTLDFLAGS) $(LTLIBICONV) $(LIBM) WARN_CFLAGS = -W -Wall -Wwrite-strings AM_CXXFLAGS = $(CXXFLAGS_FOR_TARGET) diff --git a/libgcobol/charmaps.h b/libgcobol/charmaps.h index 12968fd..6b4e9f5 100644 --- a/libgcobol/charmaps.h +++ b/libgcobol/charmaps.h @@ -297,7 +297,7 @@ extern unsigned char __gg__data_zeros[1] ; extern unsigned char __gg__data_high_values[1] ; extern unsigned char __gg__data_quotes[1] ; extern unsigned char __gg__data_upsi_0[2] ; -extern unsigned char __gg__data_return_code[2] ; +extern short __gg__data_return_code ; // These are the various hardcoded tables used for conversions. extern const unsigned short __gg__one_to_one_values[256]; diff --git a/libgcobol/config.h.in b/libgcobol/config.h.in index b201266..5dd2b50 100644 --- a/libgcobol/config.h.in +++ b/libgcobol/config.h.in @@ -36,6 +36,12 @@ /* Define to 1 if you have the <stdlib.h> header file. */ #undef HAVE_STDLIB_H +/* Define to 1 if you have the `strfromf32' function. */ +#undef HAVE_STRFROMF32 + +/* Define to 1 if you have the `strfromf64' function. */ +#undef HAVE_STRFROMF64 + /* Define to 1 if you have the <strings.h> header file. */ #undef HAVE_STRINGS_H diff --git a/libgcobol/configure b/libgcobol/configure index 44190d7..e7b3b83 100755 --- a/libgcobol/configure +++ b/libgcobol/configure @@ -646,6 +646,7 @@ enable_static enable_shared ENABLE_DARWIN_AT_RPATH_FALSE ENABLE_DARWIN_AT_RPATH_TRUE +LIBM CXXCPP OTOOL64 OTOOL @@ -2520,6 +2521,8 @@ as_fn_append ac_func_list " random_r" as_fn_append ac_func_list " srandom_r" as_fn_append ac_func_list " initstate_r" as_fn_append ac_func_list " setstate_r" +as_fn_append ac_func_list " strfromf32" +as_fn_append ac_func_list " strfromf64" # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false @@ -12906,7 +12909,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 12909 "configure" +#line 12912 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -13012,7 +13015,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 13015 "configure" +#line 13018 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -16346,6 +16349,147 @@ enable_dlopen=yes +LIBM= +case $host in +*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*) + # These system don't have libm, or don't need it + ;; +*-ncr-sysv4.3*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _mwvalidcheckl in -lmw" >&5 +$as_echo_n "checking for _mwvalidcheckl in -lmw... " >&6; } +if ${ac_cv_lib_mw__mwvalidcheckl+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lmw $LIBS" +if test x$gcc_no_link = xyes; then + as_fn_error $? "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5 +fi +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char _mwvalidcheckl (); +int +main () +{ +return _mwvalidcheckl (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_mw__mwvalidcheckl=yes +else + ac_cv_lib_mw__mwvalidcheckl=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mw__mwvalidcheckl" >&5 +$as_echo "$ac_cv_lib_mw__mwvalidcheckl" >&6; } +if test "x$ac_cv_lib_mw__mwvalidcheckl" = xyes; then : + LIBM="-lmw" +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5 +$as_echo_n "checking for cos in -lm... " >&6; } +if ${ac_cv_lib_m_cos+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lm $LIBS" +if test x$gcc_no_link = xyes; then + as_fn_error $? "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5 +fi +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char cos (); +int +main () +{ +return cos (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_m_cos=yes +else + ac_cv_lib_m_cos=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5 +$as_echo "$ac_cv_lib_m_cos" >&6; } +if test "x$ac_cv_lib_m_cos" = xyes; then : + LIBM="$LIBM -lm" +fi + + ;; +*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5 +$as_echo_n "checking for cos in -lm... " >&6; } +if ${ac_cv_lib_m_cos+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lm $LIBS" +if test x$gcc_no_link = xyes; then + as_fn_error $? "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5 +fi +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char cos (); +int +main () +{ +return cos (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_m_cos=yes +else + ac_cv_lib_m_cos=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5 +$as_echo "$ac_cv_lib_m_cos" >&6; } +if test "x$ac_cv_lib_m_cos" = xyes; then : + LIBM="-lm" +fi + + ;; +esac + + if test x$enable_darwin_at_rpath = xyes; then ENABLE_DARWIN_AT_RPATH_TRUE= @@ -16385,6 +16529,13 @@ done +# These are C23, and might not be available in libc. + + + + + + if test "${multilib}" = "yes"; then multilib_arg="--enable-multilib" else diff --git a/libgcobol/configure.ac b/libgcobol/configure.ac index 383b413..6b287a1 100644 --- a/libgcobol/configure.ac +++ b/libgcobol/configure.ac @@ -209,6 +209,7 @@ AM_PROG_LIBTOOL LT_INIT AC_LIBTOOL_DLOPEN +LT_LIB_M AM_CONDITIONAL([ENABLE_DARWIN_AT_RPATH], [test x$enable_darwin_at_rpath = xyes]) @@ -218,6 +219,9 @@ AC_SUBST(enable_static) # These are GLIBC AC_CHECK_FUNCS_ONCE(random_r srandom_r initstate_r setstate_r) +# These are C23, and might not be available in libc. +AC_CHECK_FUNCS_ONCE(strfromf32 strfromf64) + if test "${multilib}" = "yes"; then multilib_arg="--enable-multilib" else diff --git a/libgcobol/constants.cc b/libgcobol/constants.cc index 026f919..d37c791 100644 --- a/libgcobol/constants.cc +++ b/libgcobol/constants.cc @@ -288,7 +288,7 @@ struct cblc_field_t __gg___14_linage_counter6 = { unsigned char __gg__data_upsi_0[2] = {0,0}; -struct cblc_field_t __gg___6_upsi_04 = { +struct cblc_field_t __gg__upsi = { .data = __gg__data_upsi_0 , .capacity = 2 , .allocated = 2 , @@ -307,9 +307,9 @@ struct cblc_field_t __gg___6_upsi_04 = { .dummy = 0 , }; -unsigned char __gg__data_return_code[2] = {0,0}; -struct cblc_field_t __gg___11_return_code6 = { - .data = __gg__data_return_code , +short __gg__data_return_code = 0; +struct cblc_field_t __gg__return_code = { + .data = (unsigned char *)&__gg__data_return_code , .capacity = 2 , .allocated = 2 , .offset = 0 , @@ -319,7 +319,7 @@ struct cblc_field_t __gg___11_return_code6 = { .parent = NULL, .occurs_lower = 0 , .occurs_upper = 0 , - .attr = 0x0 , + .attr = signable_e , .type = FldNumericBin5 , .level = 0 , .digits = 4 , diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index d8f4ded..c163e2c 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -68,6 +68,30 @@ #include "exceptl.h" +#if !defined (HAVE_STRFROMF32) +# if __FLT_MANT_DIG__ == 24 && __FLT_MAX_EXP__ == 128 +static int +strfromf32 (char *s, size_t n, const char *f, float v) +{ + return snprintf (s, n, f, (double) v); +} +# else +# error "It looks like float on this platform is not IEEE754" +# endif +#endif + +#if !defined (HAVE_STRFROMF64) +# if __DBL_MANT_DIG__ == 53 && __DBL_MAX_EXP__ == 1024 +static int +strfromf64 (char *s, size_t n, const char *f, double v) +{ + return snprintf (s, n, f, v); +} +# else +# error "It looks like double on this platform is not IEEE754" +# endif +#endif + // This couldn't be defined in symbols.h because it conflicts with a LEVEL66 // in parse.h #define LEVEL66 (66) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 438865a..f0b1256 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,29 @@ +2025-04-03 Thomas Schwinge <tschwinge@baylibre.com> + + * config/cpu/nvptx/t-nvptx: Remove. + * configure.host [nvptx]: Adjust. + +2025-04-03 Thomas Schwinge <tschwinge@baylibre.com> + + PR target/119573 + * config/cpu/nvptx/t-nvptx (AM_MAKEFLAGS): Don't amend. + +2025-04-03 Tomasz Kamiński <tkaminsk@redhat.com> + + * testsuite/std/format/functions/format.cc: Restored line. + +2025-04-03 Tomasz Kamiński <tkaminsk@redhat.com> + + PR libstdc++/119593 + * include/bits/unicode.h + (__unicode::__literal_encoding_is_unicode<_CharT>): + Corrected handing for UTF-16 and UTF-32 with "LE" or "BE" suffix. + * include/std/format (__formatter_str::_S_character_width): + Define. + (__formatter_str::_S_character_width): Updated passed char + length. + * testsuite/std/format/functions/format.cc: Test for wchar_t. + 2025-04-02 John David Anglin <danglin@gcc.gnu.org> * config/os/hpux/os_defines.h: Only use long long when diff --git a/libstdc++-v3/config/cpu/nvptx/t-nvptx b/libstdc++-v3/config/cpu/nvptx/t-nvptx deleted file mode 100644 index a2f0f2d..0000000 --- a/libstdc++-v3/config/cpu/nvptx/t-nvptx +++ /dev/null @@ -1,7 +0,0 @@ -# Per-file flags, see '../../../configure.host', "inject per-file flags". - -# 'ptxas'/CUDA Driver rejects objects with a lot of global constant data: -# ptxas error : File uses too much global constant data ([...]) -# Cut short the assembly-time check; defer to actual use of the object file. -AM_MAKEFLAGS += CXXFLAGS-src/c++17/floating_to_chars.lo=-Wa,--no-verify -AM_MAKEFLAGS += CXXFLAGS-src/c++20/tzdb.lo=-Wa,--no-verify diff --git a/libstdc++-v3/configure.host b/libstdc++-v3/configure.host index 0bed9df..8375764 100644 --- a/libstdc++-v3/configure.host +++ b/libstdc++-v3/configure.host @@ -374,11 +374,6 @@ case "${host}" in port_specific_symbol_files="\$(srcdir)/../config/os/gnu-linux/arm-eabi-extra.ver" ;; nvptx-*-none) - # For 'make all-target-libstdc++-v3', we need to inject per-file flags: - OPTIMIZE_CXXFLAGS="${OPTIMIZE_CXXFLAGS} \$(CXXFLAGS-\$(subdir)/\$@)" - # ..., see: - tmake_file="$tmake_file cpu/nvptx/t-nvptx" - # For 'make all-target-libstdc++-v3', re 'alloca'/VLA usage: EXTRA_CFLAGS="${EXTRA_CFLAGS} -mfake-ptx-alloca" OPTIMIZE_CXXFLAGS="${OPTIMIZE_CXXFLAGS} -mfake-ptx-alloca" diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 4dc771a..537774c 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -195,6 +195,7 @@ bits_headers = \ ${bits_srcdir}/cow_string.h \ ${bits_srcdir}/deque.tcc \ ${bits_srcdir}/erase_if.h \ + ${bits_srcdir}/formatfwd.h \ ${bits_srcdir}/forward_list.h \ ${bits_srcdir}/forward_list.tcc \ ${bits_srcdir}/fs_dir.h \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 0e3d09b..7b96b22 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -548,6 +548,7 @@ bits_freestanding = \ @GLIBCXX_HOSTED_TRUE@ ${bits_srcdir}/cow_string.h \ @GLIBCXX_HOSTED_TRUE@ ${bits_srcdir}/deque.tcc \ @GLIBCXX_HOSTED_TRUE@ ${bits_srcdir}/erase_if.h \ +@GLIBCXX_HOSTED_TRUE@ ${bits_srcdir}/formatfwd.h \ @GLIBCXX_HOSTED_TRUE@ ${bits_srcdir}/forward_list.h \ @GLIBCXX_HOSTED_TRUE@ ${bits_srcdir}/forward_list.tcc \ @GLIBCXX_HOSTED_TRUE@ ${bits_srcdir}/fs_dir.h \ diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h index 86841cb..886e7e6 100644 --- a/libstdc++-v3/include/bits/basic_string.h +++ b/libstdc++-v3/include/bits/basic_string.h @@ -45,7 +45,9 @@ #include <initializer_list> #endif -#if __cplusplus >= 201703L +#include <bits/version.h> + +#ifdef __glibcxx_string_view // >= C++17 # include <string_view> #endif @@ -53,7 +55,6 @@ # include <charconv> #endif -#include <bits/version.h> #if ! _GLIBCXX_USE_CXX11_ABI # include "cow_string.h" @@ -146,7 +147,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 return __p; } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 // A helper type for avoiding boiler-plate. typedef basic_string_view<_CharT, _Traits> __sv_type; @@ -788,7 +789,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 #endif } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Construct string from a substring of a string_view. * @param __t Source object convertible to string view. @@ -944,7 +945,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Set value to string constructed from a string_view. * @param __svt An object convertible to string_view. @@ -1439,7 +1440,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 { return this->append(__l.begin(), __l.size()); } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Append a string_view. * @param __svt An object convertible to string_view to be appended. @@ -1556,7 +1557,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 append(_InputIterator __first, _InputIterator __last) { return this->replace(end(), end(), __first, __last); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view /** * @brief Append a string_view. * @param __svt An object convertible to string_view to be appended. @@ -1809,7 +1810,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Set value from a string_view. * @param __svt The source object convertible to string_view. @@ -2090,7 +2091,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 return iterator(_M_data() + __pos); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Insert a string_view. * @param __pos Position in string to insert at. @@ -2542,7 +2543,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 { return this->replace(__i1, __i2, __l.begin(), __l.size()); } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Replace range of characters with string_view. * @param __pos The position to replace at. @@ -2741,7 +2742,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 _GLIBCXX_NOEXCEPT { return this->find(__str.data(), __pos, __str.size()); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find position of a string_view. * @param __svt The object convertible to string_view to locate. @@ -2807,7 +2808,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 _GLIBCXX_NOEXCEPT { return this->rfind(__str.data(), __pos, __str.size()); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find last position of a string_view. * @param __svt The object convertible to string_view to locate. @@ -2891,7 +2892,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 _GLIBCXX_NOEXCEPT { return this->find_first_of(__str.data(), __pos, __str.size()); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find position of a character of a string_view. * @param __svt An object convertible to string_view containing @@ -2980,7 +2981,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 _GLIBCXX_NOEXCEPT { return this->find_last_of(__str.data(), __pos, __str.size()); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find last position of a character of string. * @param __svt An object convertible to string_view containing @@ -3068,7 +3069,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 _GLIBCXX_NOEXCEPT { return this->find_first_not_of(__str.data(), __pos, __str.size()); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find position of a character not in a string_view. * @param __svt A object convertible to string_view containing @@ -3155,7 +3156,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 _GLIBCXX_NOEXCEPT { return this->find_last_not_of(__str.data(), __pos, __str.size()); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find last position of a character not in a string_view. * @param __svt An object convertible to string_view containing @@ -3271,7 +3272,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 return __r; } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Compare to a string_view. * @param __svt An object convertible to string_view to compare against. @@ -4605,7 +4606,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 constexpr #endif inline wstring -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 __to_wstring_numeric(string_view __s) #else __to_wstring_numeric(const string& __s) @@ -4808,7 +4809,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } // inline namespace literals #endif // __glibcxx_string_udls -#if __cplusplus >= 201703L +#ifdef __glibcxx_variant // >= C++17 namespace __detail::__variant { template<typename> struct _Never_valueless_alt; // see <variant> diff --git a/libstdc++-v3/include/bits/basic_string.tcc b/libstdc++-v3/include/bits/basic_string.tcc index a5df7cb..02230ac 100644 --- a/libstdc++-v3/include/bits/basic_string.tcc +++ b/libstdc++-v3/include/bits/basic_string.tcc @@ -279,11 +279,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Length of string constructed is easier to propagate inter-procedurally // than difference between iterators. template<typename _CharT, typename _Traits, typename _Alloc> - template<bool _Terminated> + template<bool _Terminated> _GLIBCXX20_CONSTEXPR void basic_string<_CharT, _Traits, _Alloc>:: - _M_construct(const _CharT *__str, size_type __n) + _M_construct(const _CharT* __str, size_type __n) { if (__n > size_type(_S_local_capacity)) { diff --git a/libstdc++-v3/include/bits/cow_string.h b/libstdc++-v3/include/bits/cow_string.h index 740e046..d5b3979 100644 --- a/libstdc++-v3/include/bits/cow_string.h +++ b/libstdc++-v3/include/bits/cow_string.h @@ -467,7 +467,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _S_empty_rep() _GLIBCXX_NOEXCEPT { return _Rep::_S_empty_rep(); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 // A helper type for avoiding boiler-plate. typedef basic_string_view<_CharT, _Traits> __sv_type; @@ -685,7 +685,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : _M_dataplus(_S_construct(__beg, __end, __a), __a) { } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Construct string from a substring of a string_view. * @param __t Source object convertible to string view. @@ -775,7 +775,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Set value to string constructed from a string_view. * @param __svt An object convertible to string_view. @@ -1246,7 +1246,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return this->append(__l.begin(), __l.size()); } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Append a string_view. * @param __svt The object convertible to string_view to be appended. @@ -1338,7 +1338,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION append(_InputIterator __first, _InputIterator __last) { return this->replace(_M_iend(), _M_iend(), __first, __last); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Append a string_view. * @param __svt The object convertible to string_view to be appended. @@ -1496,7 +1496,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return this->assign(__l.begin(), __l.size()); } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Set value from a string_view. * @param __svt The source object convertible to string_view. @@ -1703,7 +1703,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return iterator(_M_data() + __pos); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Insert a string_view. * @param __pos Position in string to insert at. @@ -2092,7 +2092,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return this->replace(__i1, __i2, __l.begin(), __l.end()); } #endif // C++11 -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Replace range of characters with string_view. * @param __pos The position to replace at. @@ -2354,7 +2354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION size_type find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT; -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find position of a string_view. * @param __svt The object convertible to string_view to locate. @@ -2432,7 +2432,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION size_type rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT; -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find last position of a string_view. * @param __svt The object convertible to string_view to locate. @@ -2515,7 +2515,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT { return this->find(__c, __pos); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find position of a character of a string_view. * @param __svt An object convertible to string_view containing @@ -2599,7 +2599,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT { return this->rfind(__c, __pos); } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find last position of a character of string. * @param __svt An object convertible to string_view containing @@ -2680,7 +2680,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION find_first_not_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT; -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find position of a character not in a string_view. * @param __svt An object convertible to string_view containing @@ -2762,7 +2762,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION find_last_not_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT; -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Find last position of a character not in a string_view. * @param __svt An object convertible to string_view containing @@ -2824,7 +2824,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return __r; } -#if __cplusplus >= 201703L +#ifdef __glibcxx_string_view // >= C++17 /** * @brief Compare to a string_view. * @param __svt An object convertible to string_view to compare against. diff --git a/libstdc++-v3/include/bits/formatfwd.h b/libstdc++-v3/include/bits/formatfwd.h new file mode 100644 index 0000000..44922cb --- /dev/null +++ b/libstdc++-v3/include/bits/formatfwd.h @@ -0,0 +1,71 @@ +// <format> Formatting -*- C++ -*- + +// Copyright The GNU Toolchain Authors. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file bits/formatfwd.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{format} + */ + +#ifndef _GLIBCXX_FORMAT_FWD_H +#define _GLIBCXX_FORMAT_FWD_H 1 + +#ifdef _GLIBCXX_SYSHDR +#pragma GCC system_header +#endif + +// <bits/version.h> must have been included before this header: +#ifdef __glibcxx_format // C++ >= 20 && HOSTED + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [format.context], class template basic_format_context + template<typename _Out, typename _CharT> class basic_format_context; + + // [format.parse.ctx], class template basic_format_parse_context + template<typename _CharT> class basic_format_parse_context; + + // [format.formatter], formatter + template<typename _Tp, typename _CharT = char> struct formatter; + +namespace __format +{ +#ifdef _GLIBCXX_USE_WCHAR_T + template<typename _CharT> + concept __char = same_as<_CharT, char> || same_as<_CharT, wchar_t>; +#else + template<typename _CharT> + concept __char = same_as<_CharT, char>; +#endif + + template<__char _CharT> + struct __formatter_int; +} + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std +#endif // __glibcxx_format +#pragma GCC diagnostic pop +#endif // _GLIBCXX_FORMAT_FWD_H diff --git a/libstdc++-v3/include/bits/ranges_uninitialized.h b/libstdc++-v3/include/bits/ranges_uninitialized.h index b558007..12a714b 100644 --- a/libstdc++-v3/include/bits/ranges_uninitialized.h +++ b/libstdc++-v3/include/bits/ranges_uninitialized.h @@ -263,26 +263,6 @@ namespace ranges inline constexpr __uninitialized_value_construct_n_fn uninitialized_value_construct_n; - namespace __detail - { - // This is only intended for finding smaller iterator differences below, - // not as a general purpose replacement for std::min. - struct __mindist_fn - { - template<typename _Dp1, typename _Dp2> - constexpr common_type_t<_Dp1, _Dp2> - operator()(_Dp1 __d1, _Dp2 __d2) const noexcept - { - // Every C++20 iterator I satisfies weakly_incrementable<I> which - // requires signed-integer-like<iter_difference_t<I>>. - static_assert(std::__detail::__is_signed_integer_like<_Dp1>); - static_assert(std::__detail::__is_signed_integer_like<_Dp2>); - return std::min<common_type_t<_Dp1, _Dp2>>(__d1, __d2); - } - }; - inline constexpr __mindist_fn __mindist{}; - } - template<typename _Iter, typename _Out> using uninitialized_copy_result = in_out_result<_Iter, _Out>; @@ -305,10 +285,10 @@ namespace ranges && is_trivially_assignable_v<_OutType&, iter_reference_t<_Iter>>) { - auto __d1 = __ilast - __ifirst; - auto __d2 = __olast - __ofirst; - return ranges::copy_n(std::move(__ifirst), - __detail::__mindist(__d1, __d2), __ofirst); + auto __d = __ilast - __ifirst; + if (auto __d2 = __olast - __ofirst; __d2 < __d) + __d = static_cast<iter_difference_t<_Iter>>(__d2); + return ranges::copy_n(std::move(__ifirst), __d, __ofirst); } else { @@ -356,9 +336,9 @@ namespace ranges && is_trivially_assignable_v<_OutType&, iter_reference_t<_Iter>>) { - auto __d = __olast - __ofirst; - return ranges::copy_n(std::move(__ifirst), - __detail::__mindist(__n, __d), __ofirst); + if (auto __d = __olast - __ofirst; __d < __n) + __n = static_cast<iter_difference_t<_Iter>>(__d); + return ranges::copy_n(std::move(__ifirst), __n, __ofirst); } else { @@ -397,11 +377,12 @@ namespace ranges && is_trivially_assignable_v<_OutType&, iter_rvalue_reference_t<_Iter>>) { - auto __d1 = __ilast - __ifirst; - auto __d2 = __olast - __ofirst; + auto __d = __ilast - __ifirst; + if (auto __d2 = __olast - __ofirst; __d2 < __d) + __d = static_cast<iter_difference_t<_Iter>>(__d2); auto [__in, __out] = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)), - __detail::__mindist(__d1, __d2), __ofirst); + __d, __ofirst); return {std::move(__in).base(), __out}; } else @@ -452,10 +433,11 @@ namespace ranges && is_trivially_assignable_v<_OutType&, iter_rvalue_reference_t<_Iter>>) { - auto __d = __olast - __ofirst; + if (auto __d = __olast - __ofirst; __d < __n) + __n = static_cast<iter_difference_t<_Iter>>(__d); auto [__in, __out] = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)), - __detail::__mindist(__n, __d), __ofirst); + __n, __ofirst); return {std::move(__in).base(), __out}; } else diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def index 1468c04..8f609b4 100644 --- a/libstdc++-v3/include/bits/version.def +++ b/libstdc++-v3/include/bits/version.def @@ -30,6 +30,7 @@ AutoGen Definitions version.tpl; // ftms = { // name = FTM NAME; // [stdname = FTM STANDARD MACRO NAME;] +// [no_stdname = true;] // values = { // v = VALUE FOR FTM IF MATCHING; // [extra_cond = STRING;] @@ -56,7 +57,8 @@ AutoGen Definitions version.tpl; // stdname configures the name of the *standard* macro emitted, i.e. it // replaces only the __cpp_lib_ macro in the emitted definition. Defaults to -// __cpp_lib_${name} +// __cpp_lib_${name}. If no_stdname exists (with any value), the stdname +// define is not emitted. // N.B This list needs to be in topological sort order, as later entries in // this list can and do use the earlier entries. @@ -1404,18 +1406,18 @@ ftms = { }; }; -// ftms = { - // name = format_ranges; +ftms = { + name = format_ranges; // 202207 P2286R8 Formatting Ranges // 202207 P2585R1 Improving default container formatting // LWG3750 Too many papers bump __cpp_lib_format - // TODO: #define __cpp_lib_format_ranges 202207L - // values = { - // v = 202207; - // cxxmin = 23; - // hosted = yes; - // }; -// }; + no_stdname = true; // TODO remove + values = { + v = 1; // TODO 202207 + cxxmin = 23; + hosted = yes; + }; +}; ftms = { name = freestanding_algorithm; diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h index f7c9849..f05c3fd 100644 --- a/libstdc++-v3/include/bits/version.h +++ b/libstdc++-v3/include/bits/version.h @@ -1555,6 +1555,15 @@ #endif /* !defined(__cpp_lib_expected) && defined(__glibcxx_want_expected) */ #undef __glibcxx_want_expected +#if !defined(__cpp_lib_format_ranges) +# if (__cplusplus >= 202100L) && _GLIBCXX_HOSTED +# define __glibcxx_format_ranges 1L +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_format_ranges) +# endif +# endif +#endif /* !defined(__cpp_lib_format_ranges) && defined(__glibcxx_want_format_ranges) */ +#undef __glibcxx_want_format_ranges + #if !defined(__cpp_lib_freestanding_algorithm) # if (__cplusplus >= 202100L) # define __glibcxx_freestanding_algorithm 202311L diff --git a/libstdc++-v3/include/bits/version.tpl b/libstdc++-v3/include/bits/version.tpl index dd5f851..ccda71d 100644 --- a/libstdc++-v3/include/bits/version.tpl +++ b/libstdc++-v3/include/bits/version.tpl @@ -143,13 +143,15 @@ h }*/# /*{(unless (first-for?) "el")}*/if /*{(generate-cond)}*/ # define __glibcxx_/*{name}*/ /*{v}*/L -# if defined(__glibcxx_want_all) || defined(__glibcxx_want_/*{name}*/) +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_/*{name}*/)/*{ + IF (not (exist? "no_stdname")) }*/ # define /*{ ;; Compute the name for this FTM based on stdname/name. (if (exist? "stdname") (get "stdname") (format #f "__cpp_lib_~a" (get "name"))) -}*/ /*{v}*/L +}*/ /*{v}*/L/*{ + ENDIF no_std_name }*/ # endif /*{ ENDFOR values }*/# endif diff --git a/libstdc++-v3/include/std/flat_set b/libstdc++-v3/include/std/flat_set index a7b0b8a..3e15d1a 100644 --- a/libstdc++-v3/include/std/flat_set +++ b/libstdc++-v3/include/std/flat_set @@ -350,12 +350,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return _M_cont.max_size(); } // modifiers - template<typename... _Args> + template<typename _Arg, typename... _Args> pair<iterator, bool> - _M_try_emplace(optional<const_iterator> __hint, _Args&&... __args) + _M_try_emplace(optional<const_iterator> __hint, _Arg&& __arg, _Args&&... __args) { // TODO: Simplify and audit the hint handling. - value_type __k(std::forward<_Args>(__args)...); + auto&& __k = [&] -> decltype(auto) { + if constexpr (sizeof...(_Args) == 0 + && same_as<remove_cvref_t<_Arg>, value_type>) + return std::forward<_Arg>(__arg); + else + return value_type(std::forward<_Arg>(__arg), + std::forward<_Args>(__args)...); + }(); typename container_type::iterator __it; int __r = -1, __s = -1; if (__hint.has_value() @@ -397,12 +404,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return {__it, false}; auto __guard = _M_make_clear_guard(); - __it = _M_cont.insert(__it, std::move(__k)); + __it = _M_cont.insert(__it, std::forward<decltype(__k)>(__k)); __guard._M_disable(); return {__it, true}; } template<typename... _Args> + pair<iterator, bool> + _M_try_emplace(optional<const_iterator> __hint) + { return _M_try_emplace(__hint, value_type()); } + + template<typename... _Args> requires is_constructible_v<value_type, _Args...> __emplace_result_t emplace(_Args&&... __args) diff --git a/libstdc++-v3/include/std/format b/libstdc++-v3/include/std/format index 9ef719e..01a5314 100644 --- a/libstdc++-v3/include/std/format +++ b/libstdc++-v3/include/std/format @@ -52,6 +52,7 @@ #include <string_view> #include <string> #include <bits/monostate.h> +#include <bits/formatfwd.h> #include <bits/ranges_base.h> // input_range, range_reference_t #include <bits/ranges_util.h> // subrange #include <bits/ranges_algobase.h> // ranges::copy @@ -73,9 +74,6 @@ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION - // [format.context], class template basic_format_context - template<typename _Out, typename _CharT> class basic_format_context; - // [format.fmt.string], class template basic_format_string template<typename _CharT, typename... _Args> struct basic_format_string; @@ -178,7 +176,7 @@ namespace __format // [format.formatter], formatter /// The primary template of std::formatter is disabled. - template<typename _Tp, typename _CharT = char> + template<typename _Tp, typename _CharT> struct formatter { formatter() = delete; // No std::formatter specialization for this type. @@ -923,14 +921,6 @@ namespace __format bool _M_hasval = false; }; -#ifdef _GLIBCXX_USE_WCHAR_T - template<typename _CharT> - concept __char = same_as<_CharT, char> || same_as<_CharT, wchar_t>; -#else - template<typename _CharT> - concept __char = same_as<_CharT, char>; -#endif - template<__char _CharT> struct __formatter_str { diff --git a/libstdc++-v3/include/std/vector b/libstdc++-v3/include/std/vector index 0f04334..8bb2543 100644 --- a/libstdc++-v3/include/std/vector +++ b/libstdc++-v3/include/std/vector @@ -157,4 +157,36 @@ _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // __cpp_lib_erase_if +#ifdef __glibcxx_format_ranges // C++ >= 20 && HOSTED +#include <bits/formatfwd.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + // Standard does not constrain accepted _CharT and declares it as formatter + // of Tp that statisfies is-vector-bool-reference<T>, + template<__format::__char _CharT> + struct formatter<_GLIBCXX_STD_C::_Bit_reference, _CharT> + { + // Standard declares this as template accepting unconstrained + // ParseContext type. + constexpr typename basic_format_parse_context<_CharT>::iterator + parse(basic_format_parse_context<_CharT>& __pc) + { return _M_f.template _M_parse<bool>(__pc); } + + // Standard declares this as template accepting unconstrained + // FormatContext type. + template<typename _Out> + typename basic_format_context<_Out, _CharT>::iterator + format(const _GLIBCXX_STD_C::_Bit_reference& __u, + basic_format_context<_Out, _CharT>& __fc) const + { return _M_f.format(static_cast<bool>(__u), __fc); } + + private: + __format::__formatter_int<_CharT> _M_f; + }; +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std +#endif // __glibcxx_format_ranges + #endif /* _GLIBCXX_VECTOR */ diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc index af3b733..5dff0da 100644 --- a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc +++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc @@ -178,12 +178,40 @@ test03() void test_pr101587() { - short in[1]; + short in[1]{}; __gnu_test::test_contiguous_range r(in); // difference_type is integer-like long out[1]; std::span<long> o(out); // difference_type is ptrdiff_t ranges::uninitialized_copy(r, o); ranges::uninitialized_copy_n(ranges::begin(r), 0, o.begin(), o.end()); + + // iterator that has an integer-like class type for difference_type + struct Iter + { + using value_type = long; + using difference_type = std::ranges::__detail::__max_diff_type; + + long& operator*() const { return *p; } + + Iter& operator++() { ++p; return *this; } + Iter operator++(int) { return Iter{p++}; } + + difference_type operator-(Iter i) const { return p - i.p; } + bool operator==(const Iter&) const = default; + + long* p = nullptr; + }; + static_assert(std::sized_sentinel_for<Iter, Iter>); + + std::ranges::subrange<Iter> rmax(Iter{out+0}, Iter{out+1}); + // Check with integer-like class type for output range: + std::ranges::uninitialized_copy(in, rmax); + std::ranges::uninitialized_copy_n(in+0, 1, rmax.begin(), rmax.end()); + + int to[1]; + // And for input range: + std::ranges::uninitialized_copy(rmax, to); + std::ranges::uninitialized_copy_n(rmax.begin(), 1, to+0, to+1); } int diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc index fe82d1f1..3e81244 100644 --- a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc +++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc @@ -188,12 +188,39 @@ test03() void test_pr101587() { - short in[1]; + short in[1]{}; __gnu_test::test_contiguous_range r(in); // difference_type is integer-like long out[1]; std::span<long> o(out); // difference_type is ptrdiff_t ranges::uninitialized_move(r, o); ranges::uninitialized_move_n(ranges::begin(r), 0, o.begin(), o.end()); + + struct Iter + { + using value_type = long; + using difference_type = std::ranges::__detail::__max_diff_type; + + long& operator*() const { return *p; } + + Iter& operator++() { ++p; return *this; } + Iter operator++(int) { return Iter{p++}; } + + difference_type operator-(Iter i) const { return p - i.p; } + bool operator==(const Iter&) const = default; + + long* p = nullptr; + }; + static_assert(std::sized_sentinel_for<Iter, Iter>); + + std::ranges::subrange<Iter> rmax(Iter{out+0}, Iter{out+1}); + // Check with integer-like class type for output range: + std::ranges::uninitialized_move(in, rmax); + std::ranges::uninitialized_move_n(in+0, 1, rmax.begin(), rmax.end()); + + int to[1]; + // And for input range: + std::ranges::uninitialized_copy(rmax, to); + std::ranges::uninitialized_copy_n(rmax.begin(), 1, to+0, to+1); } int diff --git a/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc b/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc index dc3cecd..7d9a33c 100644 --- a/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc +++ b/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc @@ -214,6 +214,27 @@ void test07() #endif } +void +test08() +{ + // PR libstdc++/119620 -- flat_set::emplace always constructs element on the stack + static int copy_counter; + struct A { + A() { } + A(const A&) { ++copy_counter; } + A& operator=(const A&) { ++copy_counter; return *this; } + auto operator<=>(const A&) const = default; + }; + std::vector<A> v; + v.reserve(2); + std::flat_multiset<A> s(std::move(v)); + A a; + s.emplace(a); + VERIFY( copy_counter == 1 ); + s.emplace(a); + VERIFY( copy_counter == 2 ); +} + int main() { @@ -225,4 +246,5 @@ main() test05(); test06(); test07(); + test08(); } diff --git a/libstdc++-v3/testsuite/23_containers/flat_set/1.cc b/libstdc++-v3/testsuite/23_containers/flat_set/1.cc index 90f5855..ed24fab 100644 --- a/libstdc++-v3/testsuite/23_containers/flat_set/1.cc +++ b/libstdc++-v3/testsuite/23_containers/flat_set/1.cc @@ -229,6 +229,25 @@ void test07() #endif } +void +test08() +{ + // PR libstdc++/119620 -- flat_set::emplace always constructs element on the stack + static int copy_counter; + struct A { + A() { } + A(const A&) { ++copy_counter; } + A& operator=(const A&) { ++copy_counter; return *this; } + auto operator<=>(const A&) const = default; + }; + std::flat_set<A> s; + A a; + s.emplace(a); + VERIFY( copy_counter == 1 ); + s.emplace(a); + VERIFY( copy_counter == 1 ); +} + int main() { @@ -240,4 +259,5 @@ main() test05(); test06(); test07(); + test08(); } diff --git a/libstdc++-v3/testsuite/23_containers/vector/bool/format.cc b/libstdc++-v3/testsuite/23_containers/vector/bool/format.cc new file mode 100644 index 0000000..16f6e86 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/vector/bool/format.cc @@ -0,0 +1,67 @@ +// { dg-do run { target c++23 } } +// { dg-timeout-factor 2 } + +#include <format> +#include <vector> +#include <chrono> // For _Widen +#include <testsuite_hooks.h> + +static_assert(!std::formattable<std::vector<bool>::reference, int>); +static_assert(!std::formattable<std::vector<bool>::reference, char32_t>); + +template<typename... Args> +bool +is_format_string_for(const char* str, Args&&... args) +{ + try { + (void) std::vformat(str, std::make_format_args(args...)); + return true; + } catch (const std::format_error&) { + return false; + } +} + +#define WIDEN_(C, S) ::std::chrono::__detail::_Widen<C>(S, L##S) +#define WIDEN(S) WIDEN_(_CharT, S) + +void +test_format_string() +{ + std::vector<bool> v(1, true); + VERIFY( !is_format_string_for("{:?}", v[0]) ); + VERIFY( !is_format_string_for("{:P}", v[0]) ); + + // width needs to be integer type + VERIFY( !is_format_string_for("{:{}}", v[0], 1.0f) ); +} + +template<typename _CharT> +void +test_output() +{ + std::basic_string<_CharT> res; + size_t size = 0; + std::vector<bool> v{true, false}; + + res = std::format(WIDEN("{}"), v[0]); + VERIFY( res == WIDEN("true") ); + + res = std::format(WIDEN("{:s}"), v[1]); + VERIFY( res == WIDEN("false") ); + + res = std::format(WIDEN("{:d} {:#B} {:#o} {:#x}"), v[0], v[1], v[0], v[1]); + VERIFY( res == WIDEN("1 0B0 01 0x0") ); + + res = std::format(WIDEN("{:{}}"), v[0], 6); + VERIFY( res == WIDEN("true ") ); + + res = std::format(WIDEN("{:=^#7X}"), v[1]); + VERIFY( res == WIDEN("==0X0==") ); +} + +int main() +{ + test_format_string(); + test_output<char>(); + test_output<wchar_t>(); +} |