public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/gcc] rhel-f41-base: 4.1.2-32
@ 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 : 70a3a1d0638109eb4005ecccfe766f1df95e9ae2
Author : Jakub Jelinek <jakub@fedoraproject.org>
Date : 2007-10-16T14:18:55+00:00
Stats : +1297/-1 in 10 file(s)
URL : https://src.fedoraproject.org/rpms/gcc/c/70a3a1d0638109eb4005ecccfe766f1df95e9ae2?branch=rhel-f41-base
Log:
4.1.2-32
---
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 <jakub@redhat.com>
+
+ 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 <jakub@redhat.com>
+
+ 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 <jakub@redhat.com>
+
+ 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 <jakub@redhat.com>
+
+ 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 <aph@redhat.com>
+
+ 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 <jakub@redhat.com>
+
+ 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 <bool B> struct A { bool b; A() : b(B) {}; };
++A<bool(1)> a;
++A<bool(1<2)> b;
++A<(bool)(2>1)> c;
++A<bool((2>1))> d;
++A<bool(2>1)> 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 <jakub@redhat.com>
+
+ PR tree-optimization/33763
+ * gcc.dg/pr33763.c: New test.
+ * g++.dg/opt/inline12.C: New test.
+
+2007-10-14 Jan Hubicka <jh@suse.cz>
+
+ 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 <coudert@clipper.ens.fr>
+
+ * 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 <jakub@redhat.com>
+
+ * 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 <jakub@redhat.com> 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 <jakub@redhat.com> 4.1.2-31
- fix visibility of C++ guard variables (Jason Merrill)
- don't drop DECL_BUILT_IN_CLASS when defining a builtin function
^ 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-32 Jakub Jelinek
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox