From 2d7fb2fe4ba18b4f7c59404b3aad766685495b78 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Sep 06 2007 12:26:46 +0000 Subject: 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 + + 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 + + * 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 + + * 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 ++ ++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 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 4.1.2-21 - fix libmudflap-devel multilib conflict on ppc/ppc64 and sparc/sparc64 (#270281)