From 70a3a1d0638109eb4005ecccfe766f1df95e9ae2 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Tue, 16 Oct 2007 14:18:55 +0000 Subject: [PATCH] 4.1.2-32 --- gcc41-pr32121.patch | 132 ++++++++++++++++++++ gcc41-pr33136.patch | 230 ++++++++++++++++++++++++++++++++++ gcc41-pr33238.patch | 194 +++++++++++++++++++++++++++++ gcc41-pr33619.patch | 77 ++++++++++++ gcc41-pr33639.patch | 84 +++++++++++++ gcc41-pr33744.patch | 67 ++++++++++ gcc41-pr33763.patch | 153 +++++++++++++++++++++++ gcc41-rh317051.patch | 291 +++++++++++++++++++++++++++++++++++++++++++ gcc41-rh330771.patch | 34 +++++ gcc41.spec | 36 +++++- 10 files changed, 1297 insertions(+), 1 deletion(-) create mode 100644 gcc41-pr32121.patch create mode 100644 gcc41-pr33136.patch create mode 100644 gcc41-pr33238.patch create mode 100644 gcc41-pr33619.patch create mode 100644 gcc41-pr33639.patch create mode 100644 gcc41-pr33744.patch create mode 100644 gcc41-pr33763.patch create mode 100644 gcc41-rh317051.patch create mode 100644 gcc41-rh330771.patch diff --git a/gcc41-pr32121.patch b/gcc41-pr32121.patch new file mode 100644 index 0000000..6bf332d --- /dev/null +++ b/gcc41-pr32121.patch @@ -0,0 +1,132 @@ +2007-10-12 Jakub Jelinek + + PR c++/32121 + * parser.c (cp_parser_compound_statement): Handle label-declarations + at the beginning of the compound statement. + (cp_parser_block_declaration): Issue diagnostics about __label__ + not at the beginning of a block. + + * g++.dg/ext/label4.C: Adjust error regexp. + * g++.dg/ext/label7.C: New test. + * g++.dg/ext/label8.C: New test. + * g++.dg/ext/label9.C: New test. + +--- gcc/cp/parser.c (revision 129252) ++++ gcc/cp/parser.c (revision 129253) +@@ -6821,6 +6821,15 @@ cp_parser_expression_statement (cp_parse + compound-statement: + { statement-seq [opt] } + ++ GNU extension: ++ ++ compound-statement: ++ { label-declaration-seq [opt] statement-seq [opt] } ++ ++ label-declaration-seq: ++ label-declaration ++ label-declaration-seq label-declaration ++ + Returns a tree representing the statement. */ + + static tree +@@ -6834,6 +6843,9 @@ cp_parser_compound_statement (cp_parser + return error_mark_node; + /* Begin the compound-statement. */ + compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0); ++ /* If the next keyword is `__label__' we have a label declaration. */ ++ while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL)) ++ cp_parser_label_declaration (parser); + /* Parse an (optional) statement-seq. */ + cp_parser_statement_seq_opt (parser, in_statement_expr); + /* Finish the compound-statement. */ +@@ -7711,7 +7723,6 @@ cp_parser_declaration (cp_parser* parser + + block-declaration: + __extension__ block-declaration +- label-declaration + + C++0x Extension: + +@@ -7772,12 +7783,16 @@ cp_parser_block_declaration (cp_parser * + cp_parser_using_declaration (parser, + /*access_declaration_p=*/false); + } +- /* If the next keyword is `__label__' we have a label declaration. */ ++ /* If the next keyword is `__label__' we have a misplaced label ++ declaration. */ + else if (token1->keyword == RID_LABEL) + { +- if (statement_p) +- cp_parser_commit_to_tentative_parse (parser); +- cp_parser_label_declaration (parser); ++ cp_lexer_consume_token (parser->lexer); ++ error ("%<__label__%> not at the beginning of a block"); ++ cp_parser_skip_to_end_of_statement (parser); ++ /* If the next token is now a `;', consume it. */ ++ if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) ++ cp_lexer_consume_token (parser->lexer); + } + /* If the next token is `static_assert' we have a static assertion. */ + else if (token1->keyword == RID_STATIC_ASSERT) + +--- gcc/testsuite/g++.dg/ext/label9.C (revision 0) ++++ gcc/testsuite/g++.dg/ext/label9.C (revision 129253) +@@ -0,0 +1,10 @@ ++// PR c++/32121 ++// { dg-do compile } ++ ++int f (void) ++{ ++ while (1) ++ __label__ a; // { dg-error "not at the beginning" } ++ for (;;) ++ __label__ b; // { dg-error "not at the beginning" } ++} +--- gcc/testsuite/g++.dg/ext/label4.C (revision 129252) ++++ gcc/testsuite/g++.dg/ext/label4.C (revision 129253) +@@ -3,4 +3,4 @@ + + // { dg-do compile } + +-__label__ *l; // { dg-error "before" } ++__label__ *l; // { dg-error "not at the beginning of" } +--- gcc/testsuite/g++.dg/ext/label7.C (revision 0) ++++ gcc/testsuite/g++.dg/ext/label7.C (revision 129253) +@@ -0,0 +1,12 @@ ++// PR c++/32121 ++// { dg-do compile } ++ ++int f (void) ++{ ++ a:; ++ __label__ a; // { dg-error "not at the beginning" } ++ int b; ++ __label__ c; // { dg-error "not at the beginning" } ++ a:; // { dg-error "duplicate label" } ++ c:; ++} +--- gcc/testsuite/g++.dg/ext/label8.C (revision 0) ++++ gcc/testsuite/g++.dg/ext/label8.C (revision 129253) +@@ -0,0 +1,22 @@ ++// PR c++/32121 ++// { dg-do compile } ++ ++int f (void) ++{ ++ __label__ a, b; ++ __label__ c; ++ a:; ++ b:; ++ c:; ++ { ++ __label__ d; ++ d:; ++ if (0) ++ { ++ __label__ e; ++ __label__ f; ++ f:; ++ e:; ++ } ++ } ++} diff --git a/gcc41-pr33136.patch b/gcc41-pr33136.patch new file mode 100644 index 0000000..ed389aa --- /dev/null +++ b/gcc41-pr33136.patch @@ -0,0 +1,230 @@ +2007-10-15 Jakub Jelinek + + PR tree-optimization/33136 + * opts.c (decode_options): Don't enable flag_ipa_type_escape. + + * gcc.c-torture/execute/20070824-1.c: New test. + * gcc.dg/pr33136-1.c: New test. + * gcc.dg/pr33136-2.c: New test. + * gcc.dg/pr33136-3.c: New test. + +--- gcc/opts.c (revision 129365) ++++ gcc/opts.c (revision 129366) +@@ -473,7 +473,6 @@ decode_options (unsigned int argc, const + flag_cse_skip_blocks = 1; + flag_gcse = 1; + flag_expensive_optimizations = 1; +- flag_ipa_type_escape = 1; + flag_strength_reduce = 1; + flag_rerun_cse_after_loop = 1; + flag_rerun_loop_opt = 1; +--- gcc/testsuite/gcc.c-torture/execute/20070824-1.c (revision 0) ++++ gcc/testsuite/gcc.c-torture/execute/20070824-1.c (revision 129366) +@@ -0,0 +1,24 @@ ++/* PR tree-optimization/33136 */ ++ ++extern void abort (void); ++ ++struct S ++{ ++ struct S *a; ++ int b; ++}; ++ ++int ++main (void) ++{ ++ struct S *s = (struct S *) 0, **p, *n; ++ for (p = &s; *p; p = &(*p)->a); ++ n = (struct S *) __builtin_alloca (sizeof (*n)); ++ n->a = *p; ++ n->b = 1; ++ *p = n; ++ ++ if (!s) ++ abort (); ++ return 0; ++} +--- gcc/testsuite/gcc.dg/pr33136-1.c (revision 0) ++++ gcc/testsuite/gcc.dg/pr33136-1.c (revision 129366) +@@ -0,0 +1,54 @@ ++/* PR tree-optimization/33136 */ ++/* { dg-do run } */ ++/* { dg-options "-O2" } */ ++ ++extern void abort (void); ++ ++struct S ++{ ++ struct S *a; ++ int b; ++ float f; ++}; ++ ++static struct S s; ++ ++static int * ++__attribute__((noinline, const)) ++foo (void) ++{ ++ return &s.b; ++} ++ ++float ++__attribute__((noinline)) ++bar (float *f) ++{ ++ s.f = 1.0; ++ *f = 4.0; ++ return s.f; ++} ++ ++int ++__attribute__((noinline)) ++baz (int *x) ++{ ++ s.b = 1; ++ *x = 4; ++ return s.b; ++} ++ ++int ++t (void) ++{ ++ float f = 8.0; ++ return bar (&f) + baz (foo ()); ++} ++ ++int ++main (void) ++{ ++ if (t () != 5) ++ abort (); ++ return 0; ++} +--- gcc/testsuite/gcc.dg/pr33136-3.c (revision 0) ++++ gcc/testsuite/gcc.dg/pr33136-3.c (revision 129366) +@@ -0,0 +1,60 @@ ++/* PR tree-optimization/33136 */ ++/* { dg-do run } */ ++/* { dg-options "-O2" } */ ++ ++extern void abort (void); ++ ++struct S ++{ ++ void *a; ++ int b[3]; ++ double *c; ++}; ++static double d, e; ++ ++static struct S s; ++ ++static int * ++__attribute__((noinline, const)) ++foo (void) ++{ ++ return (int *) &s.b; ++} ++ ++double * ++__attribute__((noinline)) ++bar (double **f) ++{ ++ s.c = &d; ++ *f = &e; ++ /* As nothing ever takes the address of any double * field in struct S, ++ the write to *f can't alias with the s.c field. */ ++ return s.c; ++} ++ ++int ++__attribute__((noinline)) ++baz (int *x) ++{ ++ s.b[0] = 1; ++ *x = 4; ++ /* Function foo takes address of an int array field in struct S, ++ so *x can alias with the s.b field (and it does in this testcase). */ ++ return s.b[0]; ++} ++ ++int ++__attribute__((noinline)) ++t (void) ++{ ++ double *f = (double *) 0; ++ return 10 * (bar (&f) != &d) + baz (foo ()); ++} ++ ++int ++main (void) ++{ ++ if (t () != 4) ++ abort (); ++ return 0; ++} +--- gcc/testsuite/gcc.dg/pr33136-2.c (revision 0) ++++ gcc/testsuite/gcc.dg/pr33136-2.c (revision 129366) +@@ -0,0 +1,60 @@ ++/* PR tree-optimization/33136 */ ++/* { dg-do run } */ ++/* { dg-options "-O2" } */ ++ ++extern void abort (void); ++ ++struct S ++{ ++ void *a; ++ int b; ++ int *c; ++}; ++static int d, e; ++ ++static struct S s; ++ ++static int * ++__attribute__((noinline, const)) ++foo (void) ++{ ++ return &s.b; ++} ++ ++int * ++__attribute__((noinline)) ++bar (int **f) ++{ ++ s.c = &d; ++ *f = &e; ++ /* As nothing ever takes the address of any int * field in struct S, ++ the write to *f can't alias with the s.c field. */ ++ return s.c; ++} ++ ++int ++__attribute__((noinline)) ++baz (int *x) ++{ ++ s.b = 1; ++ *x = 4; ++ /* Function foo takes address of an int field in struct S, ++ so *x can alias with the s.b field (and it does in this testcase). */ ++ return s.b; ++} ++ ++int ++__attribute__((noinline)) ++t (void) ++{ ++ int *f = (int *) 0; ++ return 10 * (bar (&f) != &d) + baz (foo ()); ++} ++ ++int ++main (void) ++{ ++ if (t () != 4) ++ abort (); ++ return 0; ++} diff --git a/gcc41-pr33238.patch b/gcc41-pr33238.patch new file mode 100644 index 0000000..2ec285a --- /dev/null +++ b/gcc41-pr33238.patch @@ -0,0 +1,194 @@ +2007-09-20 Jakub Jelinek + + PR c/33238 + PR c/27301 + * gimplify.c (gimplify_vla_decl): New function. + (gimplify_decl_expr): Move VLA decl handling to gimplify_vla_decl. + Call it. + (gimplify_target_expr): Handle variable length TARGET_EXPRs. + + * gcc.c-torture/execute/20070919-1.c: New test. + * gcc.dg/pr33238.c: New test. + * gcc.dg/pr27301.c: New test. + +--- gcc/gimplify.c (revision 128628) ++++ gcc/gimplify.c (revision 128629) +@@ -1144,6 +1144,42 @@ gimplify_return_expr (tree stmt, tree *p + return GS_ALL_DONE; + } + ++static void ++gimplify_vla_decl (tree decl, tree *stmt_p) ++{ ++ /* This is a variable-sized decl. Simplify its size and mark it ++ for deferred expansion. Note that mudflap depends on the format ++ of the emitted code: see mx_register_decls(). */ ++ tree t, args, addr, ptr_type; ++ ++ gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p); ++ gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p); ++ ++ /* All occurrences of this decl in final gimplified code will be ++ replaced by indirection. Setting DECL_VALUE_EXPR does two ++ things: First, it lets the rest of the gimplifier know what ++ replacement to use. Second, it lets the debug info know ++ where to find the value. */ ++ ptr_type = build_pointer_type (TREE_TYPE (decl)); ++ addr = create_tmp_var (ptr_type, get_name (decl)); ++ DECL_IGNORED_P (addr) = 0; ++ t = build_fold_indirect_ref (addr); ++ SET_DECL_VALUE_EXPR (decl, t); ++ DECL_HAS_VALUE_EXPR_P (decl) = 1; ++ ++ args = tree_cons (NULL, DECL_SIZE_UNIT (decl), NULL); ++ t = built_in_decls[BUILT_IN_ALLOCA]; ++ t = build_function_call_expr (t, args); ++ t = fold_convert (ptr_type, t); ++ t = build2 (MODIFY_EXPR, void_type_node, addr, t); ++ ++ gimplify_and_add (t, stmt_p); ++ ++ /* Indicate that we need to restore the stack level when the ++ enclosing BIND_EXPR is exited. */ ++ gimplify_ctxp->save_stack = true; ++} ++ + /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation + and initialization explicit. */ + +@@ -1168,39 +1204,7 @@ gimplify_decl_expr (tree *stmt_p) + tree init = DECL_INITIAL (decl); + + if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) +- { +- /* This is a variable-sized decl. Simplify its size and mark it +- for deferred expansion. Note that mudflap depends on the format +- of the emitted code: see mx_register_decls(). */ +- tree t, args, addr, ptr_type; +- +- gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p); +- gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p); +- +- /* All occurrences of this decl in final gimplified code will be +- replaced by indirection. Setting DECL_VALUE_EXPR does two +- things: First, it lets the rest of the gimplifier know what +- replacement to use. Second, it lets the debug info know +- where to find the value. */ +- ptr_type = build_pointer_type (TREE_TYPE (decl)); +- addr = create_tmp_var (ptr_type, get_name (decl)); +- DECL_IGNORED_P (addr) = 0; +- t = build_fold_indirect_ref (addr); +- SET_DECL_VALUE_EXPR (decl, t); +- DECL_HAS_VALUE_EXPR_P (decl) = 1; +- +- args = tree_cons (NULL, DECL_SIZE_UNIT (decl), NULL); +- t = built_in_decls[BUILT_IN_ALLOCA]; +- t = build_function_call_expr (t, args); +- t = fold_convert (ptr_type, t); +- t = build2 (MODIFY_EXPR, void_type_node, addr, t); +- +- gimplify_and_add (t, stmt_p); +- +- /* Indicate that we need to restore the stack level when the +- enclosing BIND_EXPR is exited. */ +- gimplify_ctxp->save_stack = true; +- } ++ gimplify_vla_decl (decl, stmt_p); + + if (init && init != error_mark_node) + { +@@ -4146,8 +4150,15 @@ gimplify_target_expr (tree *expr_p, tree + if (init) + { + /* TARGET_EXPR temps aren't part of the enclosing block, so add it +- to the temps list. */ +- gimple_add_tmp_var (temp); ++ to the temps list. Handle also variable length TARGET_EXPRs. */ ++ if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST) ++ { ++ if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp))) ++ gimplify_type_sizes (TREE_TYPE (temp), pre_p); ++ gimplify_vla_decl (temp, pre_p); ++ } ++ else ++ gimple_add_tmp_var (temp); + + /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the + expression is supposed to initialize the slot. */ +--- gcc/testsuite/gcc.c-torture/execute/20070919-1.c (revision 0) ++++ gcc/testsuite/gcc.c-torture/execute/20070919-1.c (revision 128629) +@@ -0,0 +1,41 @@ ++/* PR c/33238 */ ++ ++typedef __SIZE_TYPE__ size_t; ++int memcmp (const void *, const void *, size_t); ++void abort (void); ++ ++void ++__attribute__((noinline)) ++bar (void *x, void *y) ++{ ++ struct S { char w[8]; } *p = x, *q = y; ++ if (memcmp (p->w, "zyxwvut", 8) != 0) ++ abort (); ++ if (memcmp (q[0].w, "abcdefg", 8) != 0) ++ abort (); ++ if (memcmp (q[1].w, "ABCDEFG", 8) != 0) ++ abort (); ++ if (memcmp (q[2].w, "zyxwvut", 8) != 0) ++ abort (); ++ if (memcmp (q[3].w, "zyxwvut", 8) != 0) ++ abort (); ++} ++ ++void ++__attribute__((noinline)) ++foo (void *x, int y) ++{ ++ struct S { char w[y]; } *p = x, a; ++ int i; ++ a = ({ struct S b; b = p[2]; p[3] = b; }); ++ bar (&a, x); ++} ++ ++int ++main (void) ++{ ++ struct S { char w[8]; } p[4] ++ = { "abcdefg", "ABCDEFG", "zyxwvut", "ZYXWVUT" }; ++ foo (p, 8); ++ return 0; ++} +--- gcc/testsuite/gcc.dg/pr33238.c (revision 0) ++++ gcc/testsuite/gcc.dg/pr33238.c (revision 128629) +@@ -0,0 +1,12 @@ ++/* PR c/33238 */ ++/* { dg-do compile } */ ++/* { dg-options "-std=gnu89" } */ ++ ++void ++reverse (void *x, int y, int z) ++{ ++ struct { char w[z]; } *p = x, a; ++ int i, j; ++ for (i = y - 1, j = 0; j < y / 2; i--, j++) ++ ({ a = p[i]; p[i] = p[j]; p[j] = a; }); ++} +--- gcc/testsuite/gcc.dg/pr27301.c (revision 0) ++++ gcc/testsuite/gcc.dg/pr27301.c (revision 128629) +@@ -0,0 +1,15 @@ ++/* PR c/27301 */ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -std=gnu89" } */ ++ ++void ++foo (void *ptr, long n) ++{ ++ __asm__ __volatile__ ("" :: "m" (({ struct { char x[n]; } *p = ptr; *p; }))); ++} ++ ++void ++bar (void *ptr, long n) ++{ ++ __asm__ __volatile__ ("" :: "m" (*({ struct { char x[n]; } *p = ptr; p; }))); ++} diff --git a/gcc41-pr33619.patch b/gcc41-pr33619.patch new file mode 100644 index 0000000..443aa1e --- /dev/null +++ b/gcc41-pr33619.patch @@ -0,0 +1,77 @@ +2007-10-15 Jakub Jelinek + + PR tree-optimization/33619 + * tree-outof-ssa.c (check_replaceable): Return false for all + calls other than __builtin_expect. + + * gcc.dg/pr33619.c: New test. + +--- gcc/tree-outof-ssa.c 2007-10-11 22:01:41.000000000 +0200 ++++ gcc/tree-outof-ssa.c 2007-10-16 14:28:42.000000000 +0200 +@@ -1570,12 +1570,14 @@ check_replaceable (temp_expr_table_p tab + if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (stmt, 1)))) + return false; + +- /* Calls to functions with side-effects cannot be replaced. */ ++ /* No calls to functions other than __builtin_expect are replaceable. */ + if ((call_expr = get_call_expr_in (stmt)) != NULL_TREE) + { +- int call_flags = call_expr_flags (call_expr); +- if (TREE_SIDE_EFFECTS (call_expr) +- && !(call_flags & (ECF_PURE | ECF_CONST | ECF_NORETURN))) ++ tree fndecl = get_callee_fndecl (call_expr); ++ ++ if (fndecl == NULL_TREE ++ || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL ++ || DECL_FUNCTION_CODE (fndecl) != BUILT_IN_EXPECT) + return false; + } + +--- gcc/testsuite/gcc.dg/pr33619.c (revision 0) ++++ gcc/testsuite/gcc.dg/pr33619.c (revision 129350) +@@ -0,0 +1,45 @@ ++/* PR tree-optimization/33619 */ ++/* { dg-do run } */ ++/* { dg-options "-O2" } */ ++ ++#ifdef __powerpc__ ++# define REG1 __asm__ ("3") ++# define REG2 __asm__ ("4") ++#elif defined __x86_64__ ++# define REG1 __asm__ ("rdi") ++# define REG2 __asm__ ("rsi") ++#else ++# define REG1 ++# define REG2 ++#endif ++ ++static inline void ++bar (unsigned long x, int y) ++{ ++ register unsigned long p1 REG1 = x; ++ register unsigned long p2 REG2 = y; ++ __asm__ volatile ("" : "=r" (p1), "=r" (p2) : "0" (p1), "1" (p2) : "memory"); ++ if (p1 != 0xdeadUL || p2 != 0xbefUL) ++ __builtin_abort (); ++} ++ ++__attribute__((const, noinline)) int ++baz (int x) ++{ ++ return x; ++} ++ ++__attribute__((noinline)) void ++foo (unsigned long *x, int y) ++{ ++ unsigned long a = *x; ++ bar (a, baz (y)); ++} ++ ++int ++main (void) ++{ ++ unsigned long a = 0xdeadUL; ++ foo (&a, 0xbefUL); ++ return 0; ++} diff --git a/gcc41-pr33639.patch b/gcc41-pr33639.patch new file mode 100644 index 0000000..7dccdb4 --- /dev/null +++ b/gcc41-pr33639.patch @@ -0,0 +1,84 @@ +2007-10-03 Andrew Haley + + PR java/33639 + * class.c (mangled_classname): Detect and replace illegal + characters in assembly language symbols. + (gen_indirect_dispatch_tables): Call mangled_classname() on + the type. + +--- gcc/java/class.c (revision 128980) ++++ gcc/java/class.c (revision 128981) +@@ -314,10 +314,63 @@ identifier_subst (const tree old_id, + tree + mangled_classname (const char *prefix, tree type) + { ++ tree result; + tree ident = TYPE_NAME (type); + if (TREE_CODE (ident) != IDENTIFIER_NODE) + ident = DECL_NAME (ident); +- return identifier_subst (ident, prefix, '.', '_', ""); ++ result = identifier_subst (ident, prefix, '.', '_', ""); ++ ++ /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with ++ "_0xXX". Class names containing such chracters are uncommon, but ++ they do sometimes occur in class files. Without this check, ++ these names cause assembly errors. ++ ++ There is a possibility that a real class name could conflict with ++ the identifier we generate, but it is unlikely and will ++ immediately be detected as an assembler error. At some point we ++ should do something more elaborate (perhaps using the full ++ unicode mangling scheme) in order to prevent such a conflict. */ ++ { ++ int i; ++ const int len = IDENTIFIER_LENGTH (result); ++ const char *p = IDENTIFIER_POINTER (result); ++ int illegal_chars = 0; ++ ++ /* Make two passes over the identifier. The first pass is merely ++ to count illegal characters; we need to do this in order to ++ allocate a buffer. */ ++ for (i = 0; i < len; i++) ++ { ++ char c = p[i]; ++ illegal_chars += (! ISALNUM (c) && c != '_' && c != '$'); ++ } ++ ++ /* And the second pass, which is rarely executed, does the ++ rewriting. */ ++ if (illegal_chars != 0) ++ { ++ char *buffer = alloca (illegal_chars * 4 + len + 1); ++ int j; ++ ++ for (i = 0, j = 0; i < len; i++) ++ { ++ char c = p[i]; ++ if (! ISALNUM (c) && c != '_' && c != '$') ++ { ++ buffer[j++] = '_'; ++ sprintf (&buffer[j], "0x%02x", c); ++ j += 4; ++ } ++ else ++ buffer[j++] = c; ++ } ++ ++ buffer[j] = 0; ++ result = get_identifier (buffer); ++ } ++ } ++ ++ return result; + } + + tree +@@ -389,7 +442,7 @@ while (0) + void + gen_indirect_dispatch_tables (tree type) + { +- const char *typename = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); ++ const char *typename = IDENTIFIER_POINTER (mangled_classname ("", type)); + { + tree field = NULL; + char *buf = alloca (strlen (typename) + strlen ("_catch_classes_") + 1); diff --git a/gcc41-pr33744.patch b/gcc41-pr33744.patch new file mode 100644 index 0000000..594fd4d --- /dev/null +++ b/gcc41-pr33744.patch @@ -0,0 +1,67 @@ +2007-10-15 Jakub Jelinek + + PR c++/33744 + * parser.c (cp_parser_parenthesized_expression_list): Set + greater_than_is_operator_p to true in between the parens. + + * g++.dg/template/arg6.C: New test. + +--- gcc/cp/parser.c.jj 2007-10-12 00:28:24.000000000 +0200 ++++ gcc/cp/parser.c 2007-10-15 14:52:02.000000000 +0200 +@@ -4976,6 +4976,7 @@ cp_parser_parenthesized_expression_list + tree expression_list = NULL_TREE; + bool fold_expr_p = is_attribute_list; + tree identifier = NULL_TREE; ++ bool saved_greater_than_is_operator_p; + + /* Assume all the expressions will be constant. */ + if (non_constant_p) +@@ -4984,6 +4985,12 @@ cp_parser_parenthesized_expression_list + if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) + return error_mark_node; + ++ /* Within a parenthesized expression, a `>' token is always ++ the greater-than operator. */ ++ saved_greater_than_is_operator_p ++ = parser->greater_than_is_operator_p; ++ parser->greater_than_is_operator_p = true; ++ + /* Consume expressions until there are no more. */ + if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)) + while (true) +@@ -5069,9 +5076,16 @@ cp_parser_parenthesized_expression_list + if (ending < 0) + goto get_comma; + if (!ending) +- return error_mark_node; ++ { ++ parser->greater_than_is_operator_p ++ = saved_greater_than_is_operator_p; ++ return error_mark_node; ++ } + } + ++ parser->greater_than_is_operator_p ++ = saved_greater_than_is_operator_p; ++ + /* We built up the list in reverse order so we must reverse it now. */ + expression_list = nreverse (expression_list); + if (identifier) +--- gcc/testsuite/g++.dg/template/arg6.C.jj 2007-10-15 14:59:13.000000000 +0200 ++++ gcc/testsuite/g++.dg/template/arg6.C 2007-10-15 14:57:31.000000000 +0200 +@@ -0,0 +1,15 @@ ++// PR c++/33744 ++// { dg-do run } ++ ++template struct A { bool b; A() : b(B) {}; }; ++A a; ++A b; ++A<(bool)(2>1)> c; ++A1))> d; ++A1)> e; ++ ++int ++main () ++{ ++ return (a.b && b.b && c.b && d.b && e.b) ? 0 : 1; ++} diff --git a/gcc41-pr33763.patch b/gcc41-pr33763.patch new file mode 100644 index 0000000..8f111ba --- /dev/null +++ b/gcc41-pr33763.patch @@ -0,0 +1,153 @@ +2007-10-16 Jakub Jelinek + + PR tree-optimization/33763 + * gcc.dg/pr33763.c: New test. + * g++.dg/opt/inline12.C: New test. + +2007-10-14 Jan Hubicka + + PR tree-optimization/33763 + * tree-inline.c (expand_call_inline): Silently ignore always_inline + attribute for redefined extern inline functions. + +--- gcc/tree-inline.c.jj 2007-09-25 12:23:05.000000000 +0200 ++++ gcc/tree-inline.c 2007-10-16 15:27:51.000000000 +0200 +@@ -2059,6 +2059,12 @@ expand_call_inline (basic_block bb, tree + if (!cgraph_inline_p (cg_edge, &reason)) + { + if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) ++ /* For extern inline functions that get redefined we always ++ silently ignored alway_inline flag. Better behaviour would ++ be to be able to keep both bodies and use extern inline body ++ for inlining, but we can't do that because frontends overwrite ++ the body. */ ++ && !cg_edge->callee->local.redefined_extern_inline + /* Avoid warnings during early inline pass. */ + && (!flag_unit_at_a_time || cgraph_global_info_ready)) + { +--- gcc/testsuite/gcc.dg/pr33763.c.jj 2007-10-16 15:20:41.000000000 +0200 ++++ gcc/testsuite/gcc.dg/pr33763.c 2007-10-16 15:20:35.000000000 +0200 +@@ -0,0 +1,60 @@ ++/* PR tree-optimization/33763 */ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++ ++typedef struct ++{ ++ void *a; ++ void *b; ++} T; ++extern void *foo (const char *, const char *); ++extern void *bar (void *, const char *, T); ++extern int baz (const char *, int); ++ ++extern inline __attribute__ ((always_inline, gnu_inline)) int ++baz (const char *x, int y) ++{ ++ return 2; ++} ++ ++int ++baz (const char *x, int y) ++{ ++ return 1; ++} ++ ++int xa, xb; ++ ++static void * ++inl (const char *x, const char *y) ++{ ++ T t = { &xa, &xb }; ++ int *f = (int *) __builtin_malloc (sizeof (int)); ++ const char *z; ++ int o = 0; ++ void *r = 0; ++ ++ for (z = y; *z; z++) ++ { ++ if (*z == 'r') ++ o |= 1; ++ if (*z == 'w') ++ o |= 2; ++ } ++ if (o == 1) ++ *f = baz (x, 0); ++ if (o == 2) ++ *f = baz (x, 1); ++ if (o == 3) ++ *f = baz (x, 2); ++ ++ if (o && *f > 0) ++ r = bar (f, "w", t); ++ return r; ++} ++ ++void * ++foo (const char *x, const char *y) ++{ ++ return inl (x, y); ++} +--- gcc/testsuite/g++.dg/opt/inline12.C.jj 2007-10-16 15:26:01.000000000 +0200 ++++ gcc/testsuite/g++.dg/opt/inline12.C 2007-10-16 15:26:20.000000000 +0200 +@@ -0,0 +1,60 @@ ++// PR tree-optimization/33763 ++// { dg-do compile } ++// { dg-options "-O2" } ++ ++typedef struct ++{ ++ void *a; ++ void *b; ++} T; ++extern void *foo (const char *, const char *); ++extern void *bar (void *, const char *, T); ++extern int baz (const char *, int); ++ ++extern inline __attribute__ ((always_inline, gnu_inline)) int ++baz (const char *x, int y) ++{ ++ return 2; ++} ++ ++int ++baz (const char *x, int y) ++{ ++ return 1; ++} ++ ++int xa, xb; ++ ++static void * ++inl (const char *x, const char *y) ++{ ++ T t = { &xa, &xb }; ++ int *f = (int *) __builtin_malloc (sizeof (int)); ++ const char *z; ++ int o = 0; ++ void *r = 0; ++ ++ for (z = y; *z; z++) ++ { ++ if (*z == 'r') ++ o |= 1; ++ if (*z == 'w') ++ o |= 2; ++ } ++ if (o == 1) ++ *f = baz (x, 0); ++ if (o == 2) ++ *f = baz (x, 1); ++ if (o == 3) ++ *f = baz (x, 2); ++ ++ if (o && *f > 0) ++ r = bar (f, "w", t); ++ return r; ++} ++ ++void * ++foo (const char *x, const char *y) ++{ ++ return inl (x, y); ++} diff --git a/gcc41-rh317051.patch b/gcc41-rh317051.patch new file mode 100644 index 0000000..af4a040 --- /dev/null +++ b/gcc41-rh317051.patch @@ -0,0 +1,291 @@ +2006-07-26 Francois-Xavier Coudert + + * intrinsic.c (add_functions): Add INT2, SHORT, INT8, LONG, + LSTAT, MCLOCK and MCLOCK8 intrinsic functions. + (add_subroutines): Add LSTAT intrinsic subroutine. + * gfortran.h (gfc_generic_isym_id): Add GFC_ISYM_INT2, + GFC_ISYM_INT8, GFC_ISYM_LONG, GFC_ISYM_LSTAT, GFC_ISYM_MCLOCK + and GFC_ISYM_MCLOCK8. + * iresolve.c (gfc_resolve_int2, gfc_resolve_int8, + gfc_resolve_long, gfc_resolve_lstat, gfc_resolve_mclock, + gfc_resolve_mclock8, gfc_resolve_lstat_sub): New functions. + * check.c (gfc_check_intconv): New function. + * trans-intrinsic.c (gfc_conv_intrinsic_function): Add cases for + the added GFC_ISYM_*. + * simplify.c (gfc_simplify_intconv, gfc_simplify_int2, + gfc_simplify_int8, gfc_simplify_long): New functions. + * intrinsic.h (gfc_check_intconv, gfc_simplify_int2, + gfc_simplify_int8, gfc_simplify_long, gfc_resolve_int2, + gfc_resolve_int8, gfc_resolve_long, gfc_resolve_lstat, + gfc_resolve_mclock, gfc_resolve_mclock8, gfc_resolve_lstat_sub): + Add prototypes. + + * gfortran.dg/int_conv_1.f90: New test. + +--- gcc/testsuite/gfortran.dg/int_conv_1.f90 (revision 0) ++++ gcc/testsuite/gfortran.dg/int_conv_1.f90 (revision 115754) +@@ -0,0 +1,36 @@ ++! { dg-do run } ++! { dg-options "-std=gnu" } ++ integer(kind=2) :: i2, j2, k2, l2, m2, n2, o2 ++ integer(kind=4) :: i4, j4 ++ integer(kind=8) :: i8, j8 ++ real :: x ++ complex :: z ++ ++ i2 = huge(i2) / 3 ++ i8 = int8(i2) ++ i4 = long(i2) ++ j2 = short(i2) ++ k2 = int2(i2) ++ l2 = int2(i8) ++ m2 = short(i8) ++ n2 = int2(i4) ++ o2 = short(i4) ++ ++ if (i8 /= i2 .or. i4 /= i2 .or. j2 /= i2 .or. k2 /= i2 & ++ .or. l2 /= i2 .or. m2 /= i2 .or. n2 /= i2 .or. o2 /= i2) call abort ++ ++ x = i2 ++ i8 = int8(x) ++ i4 = long(x) ++ j2 = short(x) ++ k2 = int2(x) ++ if (i8 /= i2 .or. i4 /= i2 .or. j2 /= i2 .or. k2 /= i2) call abort ++ ++ z = i2 + (0.,-42.) ++ i8 = int8(z) ++ i4 = long(z) ++ j2 = short(z) ++ k2 = int2(z) ++ if (i8 /= i2 .or. i4 /= i2 .or. j2 /= i2 .or. k2 /= i2) call abort ++ ++ end +--- gcc/fortran/intrinsic.c (revision 115753) ++++ gcc/fortran/intrinsic.c (revision 115754) +@@ -1535,6 +1535,26 @@ add_functions (void) + + make_generic ("int", GFC_ISYM_INT, GFC_STD_F77); + ++ add_sym_1 ("int2", 1, 0, BT_INTEGER, di, GFC_STD_GNU, ++ gfc_check_intconv, gfc_simplify_int2, gfc_resolve_int2, ++ a, BT_REAL, dr, REQUIRED); ++ ++ make_alias ("short", GFC_STD_GNU); ++ ++ make_generic ("int2", GFC_ISYM_INT2, GFC_STD_GNU); ++ ++ add_sym_1 ("int8", 1, 0, BT_INTEGER, di, GFC_STD_GNU, ++ gfc_check_intconv, gfc_simplify_int8, gfc_resolve_int8, ++ a, BT_REAL, dr, REQUIRED); ++ ++ make_generic ("int8", GFC_ISYM_INT8, GFC_STD_GNU); ++ ++ add_sym_1 ("long", 1, 0, BT_INTEGER, di, GFC_STD_GNU, ++ gfc_check_intconv, gfc_simplify_long, gfc_resolve_long, ++ a, BT_REAL, dr, REQUIRED); ++ ++ make_generic ("long", GFC_ISYM_LONG, GFC_STD_GNU); ++ + add_sym_2 ("ior", 1, 1, BT_INTEGER, di, GFC_STD_F95, + gfc_check_ior, gfc_simplify_ior, gfc_resolve_ior, + i, BT_INTEGER, di, REQUIRED, j, BT_INTEGER, di, REQUIRED); +--- gcc/fortran/intrinsic.h (revision 115753) ++++ gcc/fortran/intrinsic.h (revision 115754) +@@ -74,6 +74,7 @@ try gfc_check_idnint (gfc_expr *); + try gfc_check_ieor (gfc_expr *, gfc_expr *); + try gfc_check_index (gfc_expr *, gfc_expr *, gfc_expr *); + try gfc_check_int (gfc_expr *, gfc_expr *); ++try gfc_check_intconv (gfc_expr *); + try gfc_check_ior (gfc_expr *, gfc_expr *); + try gfc_check_irand (gfc_expr *); + try gfc_check_isatty (gfc_expr *); +@@ -222,6 +223,9 @@ gfc_expr *gfc_simplify_ichar (gfc_expr * + gfc_expr *gfc_simplify_ieor (gfc_expr *, gfc_expr *); + gfc_expr *gfc_simplify_index (gfc_expr *, gfc_expr *, gfc_expr *); + gfc_expr *gfc_simplify_int (gfc_expr *, gfc_expr *); ++gfc_expr *gfc_simplify_int2 (gfc_expr *); ++gfc_expr *gfc_simplify_int8 (gfc_expr *); ++gfc_expr *gfc_simplify_long (gfc_expr *); + gfc_expr *gfc_simplify_ifix (gfc_expr *); + gfc_expr *gfc_simplify_idint (gfc_expr *); + gfc_expr *gfc_simplify_ior (gfc_expr *, gfc_expr *); +@@ -352,6 +356,9 @@ void gfc_resolve_ieor (gfc_expr *, gfc_e + void gfc_resolve_ichar (gfc_expr *, gfc_expr *); + void gfc_resolve_idnint (gfc_expr *, gfc_expr *); + void gfc_resolve_int (gfc_expr *, gfc_expr *, gfc_expr *); ++void gfc_resolve_int2 (gfc_expr *, gfc_expr *); ++void gfc_resolve_int8 (gfc_expr *, gfc_expr *); ++void gfc_resolve_long (gfc_expr *, gfc_expr *); + void gfc_resolve_ior (gfc_expr *, gfc_expr *, gfc_expr *); + void gfc_resolve_isatty (gfc_expr *, gfc_expr *); + void gfc_resolve_ishft (gfc_expr *, gfc_expr *, gfc_expr *); +--- gcc/fortran/gfortran.h (revision 115753) ++++ gcc/fortran/gfortran.h (revision 115754) +@@ -377,6 +377,8 @@ enum gfc_generic_isym_id + GFC_ISYM_IERRNO, + GFC_ISYM_INDEX, + GFC_ISYM_INT, ++ GFC_ISYM_INT2, ++ GFC_ISYM_INT8, + GFC_ISYM_IOR, + GFC_ISYM_IRAND, + GFC_ISYM_ISATTY, +@@ -391,10 +393,11 @@ enum gfc_generic_isym_id + GFC_ISYM_LGT, + GFC_ISYM_LLE, + GFC_ISYM_LLT, +- GFC_ISYM_LOG, + GFC_ISYM_LOC, ++ GFC_ISYM_LOG, + GFC_ISYM_LOG10, + GFC_ISYM_LOGICAL, ++ GFC_ISYM_LONG, + GFC_ISYM_MALLOC, + GFC_ISYM_MATMUL, + GFC_ISYM_MAX, +--- gcc/fortran/iresolve.c (revision 115753) ++++ gcc/fortran/iresolve.c (revision 115754) +@@ -854,6 +854,42 @@ gfc_resolve_int (gfc_expr * f, gfc_expr + + + void ++gfc_resolve_int2 (gfc_expr * f, gfc_expr * a) ++{ ++ f->ts.type = BT_INTEGER; ++ f->ts.kind = 2; ++ ++ f->value.function.name = ++ gfc_get_string ("__int_%d_%c%d", f->ts.kind, gfc_type_letter (a->ts.type), ++ a->ts.kind); ++} ++ ++ ++void ++gfc_resolve_int8 (gfc_expr * f, gfc_expr * a) ++{ ++ f->ts.type = BT_INTEGER; ++ f->ts.kind = 8; ++ ++ f->value.function.name = ++ gfc_get_string ("__int_%d_%c%d", f->ts.kind, gfc_type_letter (a->ts.type), ++ a->ts.kind); ++} ++ ++ ++void ++gfc_resolve_long (gfc_expr * f, gfc_expr * a) ++{ ++ f->ts.type = BT_INTEGER; ++ f->ts.kind = 4; ++ ++ f->value.function.name = ++ gfc_get_string ("__int_%d_%c%d", f->ts.kind, gfc_type_letter (a->ts.type), ++ a->ts.kind); ++} ++ ++ ++void + gfc_resolve_isatty (gfc_expr * f, gfc_expr * u) + { + gfc_typespec ts; +--- gcc/fortran/check.c (revision 115753) ++++ gcc/fortran/check.c (revision 115754) +@@ -1200,6 +1200,16 @@ gfc_check_int (gfc_expr * x, gfc_expr * + + + try ++gfc_check_intconv (gfc_expr * x) ++{ ++ if (numeric_check (x, 0) == FAILURE) ++ return FAILURE; ++ ++ return SUCCESS; ++} ++ ++ ++try + gfc_check_ior (gfc_expr * i, gfc_expr * j) + { + if (type_check (i, 0, BT_INTEGER) == FAILURE) +--- gcc/fortran/trans-intrinsic.c (revision 115753) ++++ gcc/fortran/trans-intrinsic.c (revision 115754) +@@ -3477,6 +3477,9 @@ gfc_conv_intrinsic_function (gfc_se * se + /* Integer conversions are handled separately to make sure we get the + correct rounding mode. */ + case GFC_ISYM_INT: ++ case GFC_ISYM_INT2: ++ case GFC_ISYM_INT8: ++ case GFC_ISYM_LONG: + gfc_conv_intrinsic_int (se, expr, FIX_TRUNC_EXPR); + break; + +--- gcc/fortran/simplify.c (revision 115753) ++++ gcc/fortran/simplify.c (revision 115754) +@@ -1610,6 +1610,66 @@ gfc_simplify_int (gfc_expr * e, gfc_expr + } + + ++static gfc_expr * ++gfc_simplify_intconv (gfc_expr * e, int kind, const char *name) ++{ ++ gfc_expr *rpart, *rtrunc, *result; ++ ++ if (e->expr_type != EXPR_CONSTANT) ++ return NULL; ++ ++ result = gfc_constant_result (BT_INTEGER, kind, &e->where); ++ ++ switch (e->ts.type) ++ { ++ case BT_INTEGER: ++ mpz_set (result->value.integer, e->value.integer); ++ break; ++ ++ case BT_REAL: ++ rtrunc = gfc_copy_expr (e); ++ mpfr_trunc (rtrunc->value.real, e->value.real); ++ gfc_mpfr_to_mpz (result->value.integer, rtrunc->value.real); ++ gfc_free_expr (rtrunc); ++ break; ++ ++ case BT_COMPLEX: ++ rpart = gfc_complex2real (e, kind); ++ rtrunc = gfc_copy_expr (rpart); ++ mpfr_trunc (rtrunc->value.real, rpart->value.real); ++ gfc_mpfr_to_mpz (result->value.integer, rtrunc->value.real); ++ gfc_free_expr (rpart); ++ gfc_free_expr (rtrunc); ++ break; ++ ++ default: ++ gfc_error ("Argument of %s at %L is not a valid type", name, &e->where); ++ gfc_free_expr (result); ++ return &gfc_bad_expr; ++ } ++ ++ return range_check (result, name); ++} ++ ++gfc_expr * ++gfc_simplify_int2 (gfc_expr * e) ++{ ++ return gfc_simplify_intconv (e, 2, "INT2"); ++} ++ ++gfc_expr * ++gfc_simplify_int8 (gfc_expr * e) ++{ ++ return gfc_simplify_intconv (e, 8, "INT8"); ++} ++ ++gfc_expr * ++gfc_simplify_long (gfc_expr * e) ++{ ++ return gfc_simplify_intconv (e, 4, "LONG"); ++} ++ ++ + gfc_expr * + gfc_simplify_ifix (gfc_expr * e) + { diff --git a/gcc41-rh330771.patch b/gcc41-rh330771.patch new file mode 100644 index 0000000..c894f83 --- /dev/null +++ b/gcc41-rh330771.patch @@ -0,0 +1,34 @@ +2007-10-16 Jakub Jelinek + + * Makefile.am (libgcj_tools_la_LIBADD): Add. + * Makefile.in: Regenerated. + +--- libjava/Makefile.am.jj 2007-03-17 09:20:30.000000000 +0100 ++++ libjava/Makefile.am 2007-10-16 15:45:14.000000000 +0200 +@@ -262,6 +262,8 @@ EXTRA_libgcj_la_SOURCES = java/lang/Obje + + libgcj_tools_la_SOURCES = classpath/tools/tools.zip + libgcj_tools_la_GCJFLAGS = $(AM_GCJFLAGS) -findirect-dispatch -fno-indirect-classes -fsource-filename=$(here)/classpath/tools/all-classes.lst ++## See jv_convert_LDADD. ++libgcj_tools_la_LIBADD = -L$(here)/.libs libgcj.la + libgcj_tools_la_LDFLAGS = -rpath $(toolexeclibdir) \ + -version-info `grep -v '^\#' $(srcdir)/libtool-version` + libgcj_tools_la_DEPENDENCIES = libgcj.la libgcj.spec +--- libjava/Makefile.in.jj 2007-07-04 21:11:11.000000000 +0200 ++++ libjava/Makefile.in 2007-10-16 15:56:07.000000000 +0200 +@@ -146,7 +146,6 @@ am__objects_1 = gnu/gcj/xlib/lib_gnu_awt + am_lib_gnu_awt_xlib_la_OBJECTS = $(am__objects_1) + lib_gnu_awt_xlib_la_OBJECTS = $(am_lib_gnu_awt_xlib_la_OBJECTS) + @XLIB_AWT_TRUE@am_lib_gnu_awt_xlib_la_rpath = -rpath $(toolexeclibdir) +-libgcj_tools_la_LIBADD = + am_libgcj_tools_la_OBJECTS = classpath/tools/libgcj_tools_la-tools.lo + libgcj_tools_la_OBJECTS = $(am_libgcj_tools_la_OBJECTS) + am__DEPENDENCIES_1 = gnu/awt.lo gnu/awt/j2d.lo gnu/classpath.lo \ +@@ -894,6 +893,7 @@ libgcj_la_LINK = $(LIBLINK) + EXTRA_libgcj_la_SOURCES = java/lang/Object.java + libgcj_tools_la_SOURCES = classpath/tools/tools.zip + libgcj_tools_la_GCJFLAGS = $(AM_GCJFLAGS) -findirect-dispatch -fno-indirect-classes -fsource-filename=$(here)/classpath/tools/all-classes.lst ++libgcj_tools_la_LIBADD = -L$(here)/.libs libgcj.la + libgcj_tools_la_LDFLAGS = -rpath $(toolexeclibdir) \ + -version-info `grep -v '^\#' $(srcdir)/libtool-version` + diff --git a/gcc41.spec b/gcc41.spec index 85c6360..904e150 100644 --- a/gcc41.spec +++ b/gcc41.spec @@ -1,6 +1,6 @@ %define DATE 20070925 %define gcc_version 4.1.2 -%define gcc_release 31 +%define gcc_release 32 %define _unpackaged_files_terminate_build 0 %define multilib_64_archs sparc64 ppc64 s390x x86_64 %define include_gappletviewer 1 @@ -149,6 +149,15 @@ Patch32: gcc41-virtual-inline-backtrace.patch Patch33: gcc41-c++-gnu-inline-redecl.patch Patch34: gcc41-c++-builtin-redecl.patch Patch35: gcc41-c++-guard-visibility.patch +Patch36: gcc41-pr32121.patch +Patch37: gcc41-pr33136.patch +Patch38: gcc41-pr33238.patch +Patch39: gcc41-pr33619.patch +Patch40: gcc41-pr33639.patch +Patch41: gcc41-pr33744.patch +Patch42: gcc41-pr33763.patch +Patch43: gcc41-rh317051.patch +Patch44: gcc41-rh330771.patch # On ARM EABI systems, we do want -gnueabi to be part of the # target triple. @@ -467,6 +476,15 @@ which are required to run programs compiled with the GNAT. %patch33 -p0 -b .c++-gnu-inline-redecl~ %patch34 -p0 -b .c++-builtin-redecl~ %patch35 -p0 -b .c++-guard-visibility~ +%patch36 -p0 -b .pr32121~ +%patch37 -p0 -b .pr33136~ +%patch38 -p0 -b .pr33238~ +%patch39 -p0 -b .pr33619~ +%patch40 -p0 -b .pr33639~ +%patch41 -p0 -b .pr33744~ +%patch42 -p0 -b .pr33763~ +%patch43 -p0 -b .rh317051~ +%patch44 -p0 -b .rh330771~ 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 @@ -1621,6 +1639,22 @@ fi %doc rpm.doc/changelogs/libmudflap/ChangeLog* %changelog +* Tue Oct 16 2007 Jakub Jelinek 4.1.2-32 +- only allow __label__ at the start of a block (PR c++/32121) +- disable -fipa-type-escape by default (PR tree-optimization/33136) +- VLA handling fix (PR c/33238, PR c/27301) +- disable TER of pure and const function calls except for __builtin_expect + (PR tree-optimization/33619) +- handle classes with characters other than [a-zA-Z0-9_$] in + their names (Andrew Haley, #297961, PR java/33639) +- fix parsing of C++ function-like cast in template argument where cast's + argument uses greater-than operator (PR c++/33744) +- ignore always_inline attribute on redefined extern inline + functions (Jan Hubicka, #329671, PR tree-optimization/33763) +- add support for Fortran int conversion intrinsics (Francois-Xavier + Coudert, #317051) +- link libgcj-tools.so* against libgcj.so* (#330771) + * Wed Oct 3 2007 Jakub Jelinek 4.1.2-31 - fix visibility of C++ guard variables (Jason Merrill) - don't drop DECL_BUILT_IN_CLASS when defining a builtin function