public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/gcc] rhel-f41-base: 4.1.2-22
@ 2026-06-29 12:23 Jakub Jelinek
0 siblings, 0 replies; only message in thread
From: Jakub Jelinek @ 2026-06-29 12:23 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/gcc
Branch : rhel-f41-base
Commit : 2d7fb2fe4ba18b4f7c59404b3aad766685495b78
Author : Jakub Jelinek <jakub@fedoraproject.org>
Date : 2007-09-06T12:26:46+00:00
Stats : +687/-1 in 4 file(s)
URL : https://src.fedoraproject.org/rpms/gcc/c/2d7fb2fe4ba18b4f7c59404b3aad766685495b78?branch=rhel-f41-base
Log:
4.1.2-22
---
diff --git a/gcc41-builtin-chk-anticipated.patch b/gcc41-builtin-chk-anticipated.patch
new file mode 100644
index 0000000..15b7846
--- /dev/null
+++ b/gcc41-builtin-chk-anticipated.patch
@@ -0,0 +1,37 @@
+2007-09-06 Jakub Jelinek <jakub@redhat.com>
+
+ PR c++/33289
+ * decl.c (builtin_function_1): Set DECL_ANTICIPATED also
+ on __*_chk non-__builtin_* decls.
+
+ * g++.dg/eh/builtin4.C: New test.
+
+--- gcc/cp/decl.c.jj 2007-08-31 14:28:19.000000000 +0200
++++ gcc/cp/decl.c 2007-09-04 21:28:06.000000000 +0200
+@@ -3517,6 +3529,17 @@ builtin_function_1 (tree decl, tree cont
+ anticipated but not actually declared. */
+ if (name[0] != '_' || name[1] != '_')
+ DECL_ANTICIPATED (decl) = 1;
++ else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
++ {
++ size_t len = strlen (name);
++
++ /* Treat __*_chk fortification functions as anticipated as well,
++ unless they are __builtin_*. */
++ if (len > strlen ("___chk")
++ && memcmp (name + len - strlen ("_chk"),
++ "_chk", strlen ("_chk") + 1) == 0)
++ DECL_ANTICIPATED (decl) = 1;
++ }
+
+ return decl;
+ }
+--- gcc/testsuite/g++.dg/eh/builtin4.C.jj 2007-09-04 22:06:06.000000000 +0200
++++ gcc/testsuite/g++.dg/eh/builtin4.C 2007-09-04 22:07:03.000000000 +0200
+@@ -0,0 +1,6 @@
++// PR c++/33289
++// { dg-do compile }
++
++typedef __SIZE_TYPE__ size_t;
++extern "C" int __sprintf_chk (char *__restrict, int, size_t, const char *, ...) throw ();
++extern "C" int __sprintf_chk (char *__restrict, int, size_t, const char *, ...) throw ();
diff --git a/gcc41-builtin-throw.patch b/gcc41-builtin-throw.patch
new file mode 100644
index 0000000..f9c4eaf
--- /dev/null
+++ b/gcc41-builtin-throw.patch
@@ -0,0 +1,134 @@
+2007-09-06 Jakub Jelinek <jakub@redhat.com>
+
+ * builtin-attrs.def (ATTR_NONNULL_3): New.
+ (DEF_FORMAT_ATTRIBUTE): Use just ATTR_NONNULL_##FA instead of
+ ATTR_NOTHROW_NONNULL_##FA.
+ (DEF_FORMAT_ATTRIBUTE_NOTHROW, DEF_FORMAT_ATTRIBUTE_BOTH): New macros.
+ (ATTR_FORMAT_PRINTF_NOTHROW_2_0, ATTR_PRINTF_NOTHROW_2_3,
+ ATTR_FORMAT_PRINTF_NOTHROW_3_0, ATTR_FORMAT_PRINTF_NOTHROW_3_4,
+ ATTR_FORMAT_PRINTF_NOTHROW_4_0, ATTR_PRINTF_NOTHROW_4_5,
+ ATTR_FORMAT_PRINTF_NOTHROW_5_0, ATTR_FORMAT_PRINTF_NOTHROW_5_6,
+ ATTR_FORMAT_SCANF_NOTHROW_2_0, ATTR_FORMAT_SCANF_NOTHROW_2_3,
+ ATTR_FORMAT_STRFTIME_NOTHROW_3_0, ATTR_FORMAT_STRFMON_NOTHROW_3_4):
+ New.
+ (ATTR_FORMAT_PRINTF_4_0, ATTR_PRINTF_4_5, ATTR_FORMAT_PRINTF_5_0,
+ ATTR_FORMAT_PRINTF_5_6, ATTR_FORMAT_STRFTIME_3_0,
+ ATTR_FORMAT_NOTHROW_3_4): Remove.
+ * builtins.def (snprintf, sprintf, sscanf, vsnprintf, vsprintf,
+ vsscanf, strfmon, strftime, __snprintf_chk, __sprintf_chk,
+ __vsnprintf_chk, __vsprintf_chk): Use ATTR_FORMAT_*_NOTHROW_*
+ instead of ATTR_FORMAT_*_*.
+
+--- gcc/builtin-attrs.def.jj 2007-08-13 15:11:18.000000000 +0200
++++ gcc/builtin-attrs.def 2007-09-03 11:26:13.000000000 +0200
+@@ -118,6 +118,8 @@ DEF_ATTR_TREE_LIST (ATTR_NONNULL_LIST, A
+ DEF_ATTR_TREE_LIST (ATTR_NONNULL_1, ATTR_NONNULL, ATTR_LIST_1, ATTR_NULL)
+ /* Functions whose second parameter is a nonnull pointer. */
+ DEF_ATTR_TREE_LIST (ATTR_NONNULL_2, ATTR_NONNULL, ATTR_LIST_2, ATTR_NULL)
++/* Functions whose third parameter is a nonnull pointer. */
++DEF_ATTR_TREE_LIST (ATTR_NONNULL_3, ATTR_NONNULL, ATTR_LIST_3, ATTR_NULL)
+ /* Nothrow functions with the sentinel(1) attribute. */
+ DEF_ATTR_TREE_LIST (ATTR_NOTHROW_SENTINEL_1, ATTR_SENTINEL, ATTR_LIST_1, \
+ ATTR_NOTHROW_LIST)
+@@ -157,24 +159,38 @@ DEF_ATTR_TREE_LIST (ATTR_MALLOC_NOTHROW_
+ DEF_ATTR_TREE_LIST (ATTR_##TYPE##_##VALUES, ATTR_NULL, \
+ ATTR_##TYPE, ATTR_LIST_##VALUES) \
+ DEF_ATTR_TREE_LIST (ATTR_FORMAT_##TYPE##_##VALUES, ATTR_FORMAT, \
++ ATTR_##TYPE##_##VALUES, ATTR_NONNULL_##FA)
++#define DEF_FORMAT_ATTRIBUTE_NOTHROW(TYPE, FA, VALUES) \
++ DEF_ATTR_TREE_LIST (ATTR_##TYPE##_##VALUES, ATTR_NULL, \
++ ATTR_##TYPE, ATTR_LIST_##VALUES) \
++ DEF_ATTR_TREE_LIST (ATTR_FORMAT_##TYPE##_NOTHROW_##VALUES, ATTR_FORMAT,\
++ ATTR_##TYPE##_##VALUES, ATTR_NOTHROW_NONNULL_##FA)
++#define DEF_FORMAT_ATTRIBUTE_BOTH(TYPE, FA, VALUES) \
++ DEF_ATTR_TREE_LIST (ATTR_##TYPE##_##VALUES, ATTR_NULL, \
++ ATTR_##TYPE, ATTR_LIST_##VALUES) \
++ DEF_ATTR_TREE_LIST (ATTR_FORMAT_##TYPE##_##VALUES, ATTR_FORMAT, \
++ ATTR_##TYPE##_##VALUES, ATTR_NONNULL_##FA) \
++ DEF_ATTR_TREE_LIST (ATTR_FORMAT_##TYPE##_NOTHROW_##VALUES, ATTR_FORMAT,\
+ ATTR_##TYPE##_##VALUES, ATTR_NOTHROW_NONNULL_##FA)
+ DEF_FORMAT_ATTRIBUTE(PRINTF,1,1_0)
+ DEF_FORMAT_ATTRIBUTE(PRINTF,1,1_2)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,2,2_0)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,2,2_3)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,3,3_0)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,3,3_4)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,4,4_0)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,4,4_5)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,5,5_0)
+-DEF_FORMAT_ATTRIBUTE(PRINTF,5,5_6)
++DEF_FORMAT_ATTRIBUTE_BOTH(PRINTF,2,2_0)
++DEF_FORMAT_ATTRIBUTE_BOTH(PRINTF,2,2_3)
++DEF_FORMAT_ATTRIBUTE_BOTH(PRINTF,3,3_0)
++DEF_FORMAT_ATTRIBUTE_BOTH(PRINTF,3,3_4)
++DEF_FORMAT_ATTRIBUTE_NOTHROW(PRINTF,4,4_0)
++DEF_FORMAT_ATTRIBUTE_NOTHROW(PRINTF,4,4_5)
++DEF_FORMAT_ATTRIBUTE_NOTHROW(PRINTF,5,5_0)
++DEF_FORMAT_ATTRIBUTE_NOTHROW(PRINTF,5,5_6)
+ DEF_FORMAT_ATTRIBUTE(SCANF,1,1_0)
+ DEF_FORMAT_ATTRIBUTE(SCANF,1,1_2)
+-DEF_FORMAT_ATTRIBUTE(SCANF,2,2_0)
+-DEF_FORMAT_ATTRIBUTE(SCANF,2,2_3)
+-DEF_FORMAT_ATTRIBUTE(STRFTIME,3,3_0)
+-DEF_FORMAT_ATTRIBUTE(STRFMON,3,3_4)
++DEF_FORMAT_ATTRIBUTE_BOTH(SCANF,2,2_0)
++DEF_FORMAT_ATTRIBUTE_BOTH(SCANF,2,2_3)
++DEF_FORMAT_ATTRIBUTE_NOTHROW(STRFTIME,3,3_0)
++DEF_FORMAT_ATTRIBUTE_NOTHROW(STRFMON,3,3_4)
+ #undef DEF_FORMAT_ATTRIBUTE
++#undef DEF_FORMAT_ATTRIBUTE_NOTHROW
++#undef DEF_FORMAT_ATTRIBUTE_BOTH
+
+ /* Construct a tree for a format_arg attribute. */
+ #define DEF_FORMAT_ARG_ATTRIBUTE(FA) \
+--- gcc/builtins.def.jj 2007-08-30 18:46:59.000000000 +0200
++++ gcc/builtins.def 2007-09-03 10:52:18.000000000 +0200
+@@ -553,16 +553,16 @@ DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTCHAR
+ DEF_LIB_BUILTIN (BUILT_IN_PUTS, "puts", BT_FN_INT_CONST_STRING, ATTR_NONNULL_LIST)
+ DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTS_UNLOCKED, "puts_unlocked", BT_FN_INT_CONST_STRING, ATTR_NONNULL_LIST)
+ DEF_LIB_BUILTIN (BUILT_IN_SCANF, "scanf", BT_FN_INT_CONST_STRING_VAR, ATTR_FORMAT_SCANF_1_2)
+-DEF_C99_BUILTIN (BUILT_IN_SNPRINTF, "snprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_3_4)
+-DEF_LIB_BUILTIN (BUILT_IN_SPRINTF, "sprintf", BT_FN_INT_STRING_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3)
+-DEF_LIB_BUILTIN (BUILT_IN_SSCANF, "sscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_FORMAT_SCANF_2_3)
++DEF_C99_BUILTIN (BUILT_IN_SNPRINTF, "snprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_3_4)
++DEF_LIB_BUILTIN (BUILT_IN_SPRINTF, "sprintf", BT_FN_INT_STRING_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_2_3)
++DEF_LIB_BUILTIN (BUILT_IN_SSCANF, "sscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_FORMAT_SCANF_NOTHROW_2_3)
+ DEF_LIB_BUILTIN (BUILT_IN_VFPRINTF, "vfprintf", BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_2_0)
+ DEF_C99_BUILTIN (BUILT_IN_VFSCANF, "vfscanf", BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_2_0)
+ DEF_LIB_BUILTIN (BUILT_IN_VPRINTF, "vprintf", BT_FN_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_1_0)
+ DEF_C99_BUILTIN (BUILT_IN_VSCANF, "vscanf", BT_FN_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_1_0)
+-DEF_C99_BUILTIN (BUILT_IN_VSNPRINTF, "vsnprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_3_0)
+-DEF_LIB_BUILTIN (BUILT_IN_VSPRINTF, "vsprintf", BT_FN_INT_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_2_0)
+-DEF_C99_BUILTIN (BUILT_IN_VSSCANF, "vsscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_2_0)
++DEF_C99_BUILTIN (BUILT_IN_VSNPRINTF, "vsnprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_3_0)
++DEF_LIB_BUILTIN (BUILT_IN_VSPRINTF, "vsprintf", BT_FN_INT_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_2_0)
++DEF_C99_BUILTIN (BUILT_IN_VSSCANF, "vsscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_NOTHROW_2_0)
+
+ /* Category: ctype builtins. */
+ DEF_LIB_BUILTIN (BUILT_IN_ISALNUM, "isalnum", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LIST)
+@@ -693,8 +693,8 @@ DEF_GCC_BUILTIN (BUILT_IN_RETURN_
+ DEF_GCC_BUILTIN (BUILT_IN_SAVEREGS, "saveregs", BT_FN_PTR_VAR, ATTR_NULL)
+ DEF_GCC_BUILTIN (BUILT_IN_SETJMP, "setjmp", BT_FN_INT_PTR, ATTR_NULL)
+ DEF_GCC_BUILTIN (BUILT_IN_STDARG_START, "stdarg_start", BT_FN_VOID_VALIST_REF_VAR, ATTR_NULL)
+-DEF_EXT_LIB_BUILTIN (BUILT_IN_STRFMON, "strfmon", BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_STRFMON_3_4)
+-DEF_LIB_BUILTIN (BUILT_IN_STRFTIME, "strftime", BT_FN_SIZE_STRING_SIZE_CONST_STRING_CONST_PTR, ATTR_FORMAT_STRFTIME_3_0)
++DEF_EXT_LIB_BUILTIN (BUILT_IN_STRFMON, "strfmon", BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_STRFMON_NOTHROW_3_4)
++DEF_LIB_BUILTIN (BUILT_IN_STRFTIME, "strftime", BT_FN_SIZE_STRING_SIZE_CONST_STRING_CONST_PTR, ATTR_FORMAT_STRFTIME_NOTHROW_3_0)
+ DEF_GCC_BUILTIN (BUILT_IN_TRAP, "trap", BT_FN_VOID, ATTR_NORETURN_NOTHROW_LIST)
+ DEF_GCC_BUILTIN (BUILT_IN_UNWIND_INIT, "unwind_init", BT_FN_VOID, ATTR_NULL)
+ DEF_GCC_BUILTIN (BUILT_IN_UPDATE_SETJMP_BUF, "update_setjmp_buf", BT_FN_VOID_PTR_INT, ATTR_NULL)
+@@ -730,10 +730,10 @@ DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCAT_
+ DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCPY_CHK, "__strcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL)
+ DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCAT_CHK, "__strncat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL)
+ DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCPY_CHK, "__strncpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL)
+-DEF_EXT_LIB_BUILTIN (BUILT_IN_SNPRINTF_CHK, "__snprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_5_6)
+-DEF_EXT_LIB_BUILTIN (BUILT_IN_SPRINTF_CHK, "__sprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_4_5)
+-DEF_EXT_LIB_BUILTIN (BUILT_IN_VSNPRINTF_CHK, "__vsnprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_5_0)
+-DEF_EXT_LIB_BUILTIN (BUILT_IN_VSPRINTF_CHK, "__vsprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_4_0)
++DEF_EXT_LIB_BUILTIN (BUILT_IN_SNPRINTF_CHK, "__snprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_5_6)
++DEF_EXT_LIB_BUILTIN (BUILT_IN_SPRINTF_CHK, "__sprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_4_5)
++DEF_EXT_LIB_BUILTIN (BUILT_IN_VSNPRINTF_CHK, "__vsnprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_5_0)
++DEF_EXT_LIB_BUILTIN (BUILT_IN_VSPRINTF_CHK, "__vsprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_4_0)
+ DEF_EXT_LIB_BUILTIN (BUILT_IN_FPRINTF_CHK, "__fprintf_chk", BT_FN_INT_FILEPTR_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_3_4)
+ DEF_EXT_LIB_BUILTIN (BUILT_IN_PRINTF_CHK, "__printf_chk", BT_FN_INT_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3)
+ DEF_EXT_LIB_BUILTIN (BUILT_IN_VFPRINTF_CHK, "__vfprintf_chk", BT_FN_INT_FILEPTR_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_3_0)
diff --git a/gcc41-builtin-va-arg-pack.patch b/gcc41-builtin-va-arg-pack.patch
new file mode 100644
index 0000000..2ed8632
--- /dev/null
+++ b/gcc41-builtin-va-arg-pack.patch
@@ -0,0 +1,502 @@
+2007-09-05 Jakub Jelinek <jakub@redhat.com>
+
+ * builtins.def (BUILT_IN_VA_ARG_PACK): New built-in.
+ * tree.h (CALL_EXPR_VA_ARG_PACK): Define.
+ * tree-inline.h (copy_body_data): Add call_expr field.
+ * tree-inline.c (expand_call_inline): Initialize call_expr.
+ (copy_bb): Append anonymous inline fn arguments to arguments
+ when inlining a CALL_EXPR_VA_ARG_PACK call.
+ * builtins.c (expand_builtin): Issue an error if
+ BUILT_IN_VA_ARG_PACK is seen during expand.
+ (fold_builtin_1): Don't fold calls with
+ __builtin_va_arg_pack () call as last argument.
+ * gimplify.c (gimplify_call_expr): If last argument to a vararg
+ function is __builtin_va_arg_pack (), decrease number of call
+ arguments and instead set CALL_EXPR_VA_ARG_PACK on the CALL_EXPR.
+ * fold-const.c (fold): Don't fold CALL_EXPRs with
+ CALL_EXPR_VA_ARG_PACK bit set.
+ * expr.c (expand_expr_real_1): Issue an error if
+ CALL_EXPR_VA_ARG_PACK CALL_EXPR is seen during expand.
+ * tree-pretty-print.c (dump_generic_node): Handle printing
+ CALL_EXPR_VA_ARG_PACK bit on CALL_EXPRs.
+ * doc/extend.texi (__builtin_va_arg_pack): Document.
+
+ * gcc.c-torture/execute/va-arg-pack-1.c: New test.
+ * gcc.dg/va-arg-pack-1.c: New test.
+ * gcc.dg/va-arg-pack-1a.c: New test.
+
+--- gcc/builtins.def.jj 2007-09-06 10:19:09.000000000 +0200
++++ gcc/builtins.def 2007-09-06 10:19:24.000000000 +0200
+@@ -665,6 +665,7 @@ DEF_GCC_BUILTIN (BUILT_IN_UPDATE_
+ DEF_GCC_BUILTIN (BUILT_IN_VA_COPY, "va_copy", BT_FN_VOID_VALIST_REF_VALIST_ARG, ATTR_NULL)
+ DEF_GCC_BUILTIN (BUILT_IN_VA_END, "va_end", BT_FN_VOID_VALIST_REF, ATTR_NULL)
+ DEF_GCC_BUILTIN (BUILT_IN_VA_START, "va_start", BT_FN_VOID_VALIST_REF_VAR, ATTR_NULL)
++DEF_GCC_BUILTIN (BUILT_IN_VA_ARG_PACK, "va_arg_pack", BT_FN_INT, ATTR_PURE_NOTHROW_LIST)
+ DEF_EXT_LIB_BUILTIN (BUILT_IN__EXIT, "_exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LIST)
+ DEF_C99_BUILTIN (BUILT_IN__EXIT2, "_Exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LIST)
+
+--- gcc/tree.h.jj 2007-02-20 22:39:12.000000000 +0100
++++ gcc/tree.h 2007-09-06 11:50:56.000000000 +0200
+@@ -411,6 +411,8 @@ struct tree_common GTY(())
+ VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
+ ASM_VOLATILE_P in
+ ASM_EXPR
++ CALL_EXPR_VA_ARG_PACK in
++ CALL_EXPR
+ TYPE_CACHED_VALUES_P in
+ ..._TYPE
+ SAVE_EXPR_RESOLVED_P in
+@@ -1066,6 +1068,11 @@ extern void omp_clause_range_check_faile
+ #define SAVE_EXPR_RESOLVED_P(NODE) \
+ (TREE_CHECK (NODE, SAVE_EXPR)->common.public_flag)
+
++/* Set on a CALL_EXPR if this stdarg call should be passed the argument
++ pack. */
++#define CALL_EXPR_VA_ARG_PACK(NODE) \
++ (CALL_EXPR_CHECK(NODE)->common.public_flag)
++
+ /* In any expression, decl, or constant, nonzero means it has side effects or
+ reevaluation of the whole expression could produce a different value.
+ This is set if any subexpression is a function call, a side effect or a
+--- gcc/tree-inline.h.jj 2007-02-20 22:39:13.000000000 +0100
++++ gcc/tree-inline.h 2007-09-06 10:19:24.000000000 +0200
+@@ -57,6 +57,10 @@ typedef struct copy_body_data
+ /* Current BLOCK. */
+ tree block;
+
++ /* CALL_EXPR if va arg parameter packs should be expanded or NULL
++ is not. */
++ tree call_expr;
++
+ /* Exception region the inlined call lie in. */
+ int eh_region;
+ /* Take region number in the function being copied, add this value and
+--- gcc/tree-inline.c.jj 2007-04-26 09:41:49.000000000 +0200
++++ gcc/tree-inline.c 2007-09-06 12:35:57.000000000 +0200
+@@ -725,6 +725,22 @@ copy_bb (copy_body_data *id, basic_block
+
+ bsi_insert_after (©_bsi, stmt, BSI_NEW_STMT);
+ call = get_call_expr_in (stmt);
++ if (call && CALL_EXPR_VA_ARG_PACK (call) && id->call_expr)
++ {
++ tree arglist, *a, p;
++ TREE_OPERAND (call, 1) = copy_list (TREE_OPERAND (call, 1));
++
++ for (a = &TREE_OPERAND (call, 1); *a; a = &TREE_CHAIN (*a))
++ ;
++
++ p = DECL_ARGUMENTS (id->src_fn);
++ for (arglist = TREE_OPERAND (id->call_expr, 1);
++ p; p = TREE_CHAIN (p), arglist = TREE_CHAIN (arglist))
++ ;
++
++ *a = copy_list (arglist);
++ CALL_EXPR_VA_ARG_PACK (call) = 0;
++ }
+ /* We're duplicating a CALL_EXPR. Find any corresponding
+ callgraph edges and update or duplicate them. */
+ if (call && (decl = get_callee_fndecl (call)))
+@@ -2085,6 +2101,7 @@ expand_call_inline (basic_block bb, tree
+ /* Record the function we are about to inline. */
+ id->src_fn = fn;
+ id->src_node = cg_edge->callee;
++ id->call_expr = t;
+
+ initialize_inlined_parameters (id, args, TREE_OPERAND (t, 2), fn, bb);
+
+--- gcc/builtins.c.jj 2007-08-31 09:47:46.000000000 +0200
++++ gcc/builtins.c 2007-09-06 11:04:56.000000000 +0200
+@@ -5979,6 +5979,12 @@ expand_builtin (tree exp, rtx target, rt
+ case BUILT_IN_ARGS_INFO:
+ return expand_builtin_args_info (arglist);
+
++ case BUILT_IN_VA_ARG_PACK:
++ /* All valid uses of __builtin_va_arg_pack () are removed during
++ inlining. */
++ error ("invalid use of %<__builtin_va_arg_pack ()%>");
++ return const0_rtx;
++
+ /* Return the address of the first anonymous stack arg. */
+ case BUILT_IN_NEXT_ARG:
+ if (fold_builtin_next_arg (arglist))
+@@ -9017,7 +9023,27 @@ fold_builtin_1 (tree fndecl, tree arglis
+ {
+ tree type = TREE_TYPE (TREE_TYPE (fndecl));
+ enum built_in_function fcode;
++ tree a;
++
++ if (arglist)
++ {
++ for (a = arglist; TREE_CHAIN (a); a = TREE_CHAIN (a))
++ ;
+
++ /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
++ instead last argument is __builtin_va_arg_pack (). Defer folding
++ even in that case, until arguments are finalized. */
++ if (TREE_CODE (TREE_VALUE (a)) == CALL_EXPR)
++ {
++ tree fndecl2 = get_callee_fndecl (TREE_VALUE (a));
++ if (fndecl2
++ && TREE_CODE (fndecl2) == FUNCTION_DECL
++ && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
++ && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
++ return NULL_TREE;
++ }
++ }
++
+ if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
+ return targetm.fold_builtin (fndecl, arglist, ignore);
+
+--- gcc/gimplify.c.jj 2007-08-31 09:47:46.000000000 +0200
++++ gcc/gimplify.c 2007-09-06 11:42:01.000000000 +0200
+@@ -2018,6 +2018,55 @@ gimplify_call_expr (tree *expr_p, tree *
+ ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, NULL,
+ is_gimple_call_addr, fb_rvalue);
+
++ if (ret != GS_ERROR && TREE_OPERAND (*expr_p, 1))
++ {
++ int nargs;
++
++ for (nargs = 1, arglist = TREE_OPERAND (*expr_p, 1);
++ TREE_CHAIN (arglist);
++ arglist = TREE_CHAIN (arglist))
++ nargs++;
++
++ if (TREE_CODE (TREE_VALUE (arglist)) == CALL_EXPR)
++ {
++ tree last_arg = TREE_VALUE (arglist);
++ tree last_arg_fndecl = get_callee_fndecl (last_arg);
++
++ if (last_arg_fndecl
++ && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
++ && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
++ && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
++ {
++ tree p = NULL_TREE, *aptr;
++ int i;
++
++ if (decl && DECL_ARGUMENTS (decl))
++ p = DECL_ARGUMENTS (decl);
++ else if (decl)
++ p = TYPE_ARG_TYPES (TREE_TYPE (decl));
++ else if (POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0))))
++ p = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE
++ (TREE_OPERAND (*expr_p, 0))));
++ for (i = 0; p; p = TREE_CHAIN (p))
++ i++;
++
++ if (i < nargs)
++ {
++ TREE_OPERAND (*expr_p, 1)
++ = copy_list (TREE_OPERAND (*expr_p, 1));
++
++ for (aptr = &TREE_OPERAND (*expr_p, 1);
++ TREE_CHAIN (*aptr);
++ aptr = &TREE_CHAIN (*aptr))
++ ;
++
++ *aptr = NULL_TREE;
++ CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
++ }
++ }
++ }
++ }
++
+ if (PUSH_ARGS_REVERSED)
+ TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1));
+ for (arglist = TREE_OPERAND (*expr_p, 1); arglist;
+@@ -2037,7 +2086,7 @@ gimplify_call_expr (tree *expr_p, tree *
+ if (ret != GS_ERROR)
+ {
+ decl = get_callee_fndecl (*expr_p);
+- if (decl && DECL_BUILT_IN (decl))
++ if (decl && DECL_BUILT_IN (decl) && !CALL_EXPR_VA_ARG_PACK (*expr_p))
+ {
+ tree arglist = TREE_OPERAND (*expr_p, 1);
+ tree new = fold_builtin (decl, arglist, !want_value);
+--- gcc/fold-const.c.jj 2007-08-31 09:47:39.000000000 +0200
++++ gcc/fold-const.c 2007-09-06 11:40:55.000000000 +0200
+@@ -10409,6 +10409,8 @@ fold (tree expr)
+ op0 = TREE_OPERAND (t, 0);
+ op1 = TREE_OPERAND (t, 1);
+ op2 = TREE_OPERAND (t, 2);
++ if (code == CALL_EXPR && CALL_EXPR_VA_ARG_PACK (t))
++ return expr;
+ tem = fold_ternary (code, type, op0, op1, op2);
+ return tem ? tem : expr;
+ default:
+--- gcc/expr.c.jj 2007-04-24 22:58:53.000000000 +0200
++++ gcc/expr.c 2007-09-06 10:19:24.000000000 +0200
+@@ -7475,6 +7475,10 @@ expand_expr_real_1 (tree exp, rtx target
+ return expand_expr (OBJ_TYPE_REF_EXPR (exp), target, tmode, modifier);
+
+ case CALL_EXPR:
++ /* All valid uses of __builtin_va_arg_pack () are removed during
++ inlining. */
++ if (CALL_EXPR_VA_ARG_PACK (exp))
++ error ("invalid use of %<__builtin_va_arg_pack ()%>");
+ /* Check for a built-in function. */
+ if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
+ && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
+--- gcc/doc/extend.texi.jj 2007-08-31 13:00:28.000000000 +0200
++++ gcc/doc/extend.texi 2007-09-06 10:19:25.000000000 +0200
+@@ -552,6 +552,32 @@ the containing function. You should spe
+ returned by @code{__builtin_apply}.
+ @end deftypefn
+
++@deftypefn {Built-in Function} __builtin_va_arg_pack ()
++This built-in function represents all anonymous arguments of an inline
++function. It can be used only in inline functions which will be always
++inlined, never compiled as a separate function, such as those using
++@code{__attribute__ ((__always_inline__))} or
++@code{__attribute__ ((__gnu_inline__))} extern inline functions.
++It must be only passed as last argument to some other function
++with variable arguments. This is useful for writing small wrapper
++inlines for variable argument functions, when using preprocessor
++macros is undesirable. For example:
++@smallexample
++extern int myprintf (FILE *f, const char *format, ...);
++extern inline __attribute__ ((__gnu_inline__)) int
++myprintf (FILE *f, const char *format, ...)
++@{
++ int r = fprintf (f, "myprintf: ");
++ if (r < 0)
++ return r;
++ int s = fprintf (f, format, __builtin_va_arg_pack ());
++ if (s < 0)
++ return s;
++ return r + s;
++@}
++@end smallexample
++@end deftypefn
++
+ @node Typeof
+ @section Referring to a Type with @code{typeof}
+ @findex typeof
+--- gcc/tree-pretty-print.c.jj 2007-02-20 22:39:12.000000000 +0100
++++ gcc/tree-pretty-print.c 2007-09-06 10:24:51.000000000 +0200
+@@ -1128,6 +1128,15 @@ dump_generic_node (pretty_printer *buffe
+ op1 = TREE_OPERAND (node, 1);
+ if (op1)
+ dump_generic_node (buffer, op1, spc, flags, false);
++ if (CALL_EXPR_VA_ARG_PACK (node))
++ {
++ if (op1)
++ {
++ pp_character (buffer, ',');
++ pp_space (buffer);
++ }
++ pp_string (buffer, "__builtin_va_arg_pack ()");
++ }
+ pp_character (buffer, ')');
+
+ op1 = TREE_OPERAND (node, 2);
+--- gcc/testsuite/gcc.c-torture/execute/va-arg-pack-1.c.jj 2007-09-06 10:19:25.000000000 +0200
++++ gcc/testsuite/gcc.c-torture/execute/va-arg-pack-1.c 2007-09-06 10:19:25.000000000 +0200
+@@ -0,0 +1,143 @@
++/* __builtin_va_arg_pack () builtin tests. */
++
++#include <stdarg.h>
++
++extern void abort (void);
++
++int v1 = 8;
++long int v2 = 3;
++void *v3 = (void *) &v2;
++struct A { char c[16]; } v4 = { "foo" };
++long double v5 = 40;
++char seen[20];
++int cnt;
++
++__attribute__ ((noinline)) int
++foo1 (int x, int y, ...)
++{
++ int i;
++ long int l;
++ void *v;
++ struct A a;
++ long double ld;
++ va_list ap;
++
++ va_start (ap, y);
++ if (x < 0 || x >= 20 || seen[x])
++ abort ();
++ seen[x] = ++cnt;
++ if (y != 6)
++ abort ();
++ i = va_arg (ap, int);
++ if (i != 5)
++ abort ();
++ switch (x)
++ {
++ case 0:
++ i = va_arg (ap, int);
++ if (i != 9 || v1 != 9)
++ abort ();
++ a = va_arg (ap, struct A);
++ if (__builtin_memcmp (a.c, v4.c, sizeof (a.c)) != 0)
++ abort ();
++ v = (void *) va_arg (ap, struct A *);
++ if (v != (void *) &v4)
++ abort ();
++ l = va_arg (ap, long int);
++ if (l != 3 || v2 != 4)
++ abort ();
++ break;
++ case 1:
++ ld = va_arg (ap, long double);
++ if (ld != 41 || v5 != ld)
++ abort ();
++ i = va_arg (ap, int);
++ if (i != 8)
++ abort ();
++ v = va_arg (ap, void *);
++ if (v != &v2)
++ abort ();
++ break;
++ case 2:
++ break;
++ default:
++ abort ();
++ }
++ va_end (ap);
++ return x;
++}
++
++__attribute__ ((noinline)) int
++foo2 (int x, int y, ...)
++{
++ long long int ll;
++ void *v;
++ struct A a, b;
++ long double ld;
++ va_list ap;
++
++ va_start (ap, y);
++ if (x < 0 || x >= 20 || seen[x])
++ abort ();
++ seen[x] = ++cnt | 64;
++ if (y != 10)
++ abort ();
++ switch (x)
++ {
++ case 11:
++ break;
++ case 12:
++ ld = va_arg (ap, long double);
++ if (ld != 41 || v5 != 40)
++ abort ();
++ a = va_arg (ap, struct A);
++ if (__builtin_memcmp (a.c, v4.c, sizeof (a.c)) != 0)
++ abort ();
++ b = va_arg (ap, struct A);
++ if (__builtin_memcmp (b.c, v4.c, sizeof (b.c)) != 0)
++ abort ();
++ v = va_arg (ap, void *);
++ if (v != &v2)
++ abort ();
++ ll = va_arg (ap, long long int);
++ if (ll != 16LL)
++ abort ();
++ break;
++ case 2:
++ break;
++ default:
++ abort ();
++ }
++ va_end (ap);
++ return x + 8;
++}
++
++__attribute__ ((noinline)) int
++foo3 (void)
++{
++ return 6;
++}
++
++extern inline __attribute__ ((always_inline, gnu_inline)) int
++bar (int x, ...)
++{
++ if (x < 10)
++ return foo1 (x, foo3 (), 5, __builtin_va_arg_pack ());
++ return foo2 (x, foo3 () + 4, __builtin_va_arg_pack ());
++}
++
++int
++main (void)
++{
++ if (bar (0, ++v1, v4, &v4, v2++) != 0)
++ abort ();
++ if (bar (1, ++v5, 8, v3) != 1)
++ abort ();
++ if (bar (2) != 2)
++ abort ();
++ if (bar (v1 + 2) != 19)
++ abort ();
++ if (bar (v1 + 3, v5--, v4, v4, v3, 16LL) != 20)
++ abort ();
++ return 0;
++}
+--- gcc/testsuite/gcc.dg/va-arg-pack-1.c.jj 2007-09-06 10:19:25.000000000 +0200
++++ gcc/testsuite/gcc.dg/va-arg-pack-1.c 2007-09-06 12:52:00.000000000 +0200
+@@ -0,0 +1,46 @@
++/* { dg-do compile } */
++/* { dg-options "-O2" } */
++
++int bar (int, const char *, int, ...);
++int baz (int, const char *, long int);
++
++extern inline __attribute__((always_inline)) int
++f2 (int y, ...)
++{
++ return bar (y, "", __builtin_va_arg_pack ()); /* { dg-error "invalid use of" } */
++}
++
++extern inline __attribute__((always_inline)) int
++f3 (int y, ...)
++{
++ return bar (y, "", 5, __builtin_va_arg_pack ());
++}
++
++extern inline __attribute__((always_inline)) int
++f4 (int y, ...)
++{
++ return bar (y, "", 4, __builtin_va_arg_pack (), 6); /* { dg-error "invalid use of" } */
++}
++
++extern inline __attribute__((always_inline)) int
++f5 (int y, ...)
++{
++ return baz (y, "", __builtin_va_arg_pack ()); /* { dg-error "invalid use of" } */
++}
++
++extern inline __attribute__((always_inline)) int
++f6 (int y, ...)
++{
++ return __builtin_va_arg_pack (); /* { dg-error "invalid use of" } */
++}
++
++int
++test (void)
++{
++ int a = f2 (5, "a", 6);
++ a += f3 (6, "ab", 17LL);
++ a += f4 (7, 1, 2, 3);
++ a += f5 (8, 7L);
++ a += f6 (9);
++ return a;
++}
+--- gcc/testsuite/gcc.dg/va-arg-pack-1a.c.jj 2007-09-06 12:51:51.000000000 +0200
++++ gcc/testsuite/gcc.dg/va-arg-pack-1a.c 2007-09-06 12:52:09.000000000 +0200
+@@ -0,0 +1,11 @@
++/* { dg-do compile } */
++/* { dg-options "-O2" } */
++
++int bar (int, const char *, int, ...);
++int baz (int, const char *, long int);
++
++int
++f1 (int x, ...)
++{
++ return bar (5, "", 6, __builtin_va_arg_pack ()); /* { dg-error "invalid use of" } */
++}
diff --git a/gcc41.spec b/gcc41.spec
index f56a22b..b97c063 100644
--- a/gcc41.spec
+++ b/gcc41.spec
@@ -1,6 +1,6 @@
%define DATE 20070821
%define gcc_version 4.1.2
-%define gcc_release 21
+%define gcc_release 22
%define _unpackaged_files_terminate_build 0
%define multilib_64_archs sparc64 ppc64 s390x x86_64
%define include_gappletviewer 1
@@ -147,6 +147,9 @@ Patch30: gcc41-rh253102.patch
Patch31: gcc41-c++-gnu_inline.patch
Patch32: gcc41-ppc-sync-qihi.patch
Patch33: gcc41-ppc64-ia64-GNU-stack.patch
+Patch34: gcc41-builtin-chk-anticipated.patch
+Patch35: gcc41-builtin-throw.patch
+Patch36: gcc41-builtin-va-arg-pack.patch
# On ARM EABI systems, we do want -gnueabi to be part of the
# target triple.
@@ -463,6 +466,9 @@ which are required to run programs compiled with the GNAT.
%patch31 -p0 -b .c++-gnu_inline~
%patch32 -p0 -b .ppc-sync-qihi~
%patch33 -p0 -b .ppc64-ia64-GNU-stack~
+%patch34 -p0 -b .builtin-chk-anticipated~
+%patch35 -p0 -b .builtin-throw~
+%patch36 -p0 -b .builtin-va-arg-pack~
sed -i -e 's/4\.1\.3/4.1.2/' gcc/BASE-VER gcc/version.c
sed -i -e 's/" (Red Hat[^)]*)"/" (Red Hat %{version}-%{gcc_release})"/' gcc/version.c
@@ -1617,6 +1623,13 @@ fi
%doc rpm.doc/changelogs/libmudflap/ChangeLog*
%changelog
+* Thu Sep 6 2007 Jakub Jelinek <jakub@redhat.com> 4.1.2-22
+- backport __builtin_va_arg_pack () support
+- make sure __builtin_{,v}{,f}{print,scan}f, __builtin_{,f}printf_unlocked
+ and __builtin___{,v}{,f}printf_chk can throw
+- handle __*_chk builtins without __builtin_ in the name as anticipated in
+ C++
+
* Sat Sep 1 2007 Jakub Jelinek <jakub@redhat.com> 4.1.2-21
- fix libmudflap-devel multilib conflict on ppc/ppc64 and sparc/sparc64
(#270281)
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-06-29 12:23 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-06-29 12:23 [rpms/gcc] rhel-f41-base: 4.1.2-22 Jakub Jelinek
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox