Mark Mitchell - Re: PATCH: PR 29487 (original) (raw)

This is the mail archive of the gcc-patches@gcc.gnu.orgmailing list for the GCC project.

• From: Mark Mitchell
• To: John David Anglin
• Cc: gcc-patches at gcc dot gnu dot org, amylaar at gcc dot gnu dot org, danglin at gcc dot gnu dot org
• Date: Thu, 08 Feb 2007 18:59:05 -0800
• Subject: Re: PATCH: PR 29487
• References: <200702080152.l181qCEc019207@hiauly1.hia.nrc.ca>

John David Anglin wrote:

I will add the dg-xfail, as you suggest, before check-in -- assuming that you're HP-UX 10.10 results look OK. (My testing succeeded on x86_64-unknown-linux-gnu, but these linkage issues are of course highly dependent on the target system.)

libstdc++ links again with your patch on HP-UX 10 ;) Testsuite is running but the system is slow. Don't expect any problems since the results using comdat support on HP-UX 11 were ok.

I decided to go ahead and check in the patch (with changes you suggested, thanks!), since I would really like to get 4.1.2 out the door. I've attached the patch I checked in, and will kick of a 4.1.2RC2 build shortly. If your HP-UX 10.10 testing shows a problem, well, we've not really lost much.

Normally, I think it's important to apply to mainline first, and then backport, so that we never run the risk of introducing a regression simply by forgetting to forward-port a patch. But, here, I want to 4.1.2 forward, so I'm going to do the forward ports separately.

Thanks,

-- Mark Mitchell CodeSourcery mark@codesourcery.com (650) 331-3385 x713

2007-02-06 Mark Mitchell mark@codesourcery.com

PR target/29487
* tree.h (DECL_REPLACEABLE_P): New macro.
* except.c (set_nothrow_function_flags): Likewise.

2007-02-06 Mark Mitchell mark@codesourcery.com

PR target/29487
* decl.c (finish_function): Use DECL_REPLACEABLE.
* tree.c (cp_cannot_inline_tree_fn): Likewise.

2007-02-06 Mark Mitchell mark@codesourcery.com

PR c++/29487
* g++.dg/eh/weak1-C: New test.
* g++.dg/eh/weak1-a.cc: Likewise.
* g++.dg/eh/comdat1.C: Likewise.

Index: gcc/tree.h

--- gcc/tree.h (revision 121662) +++ gcc/tree.h (working copy) @@ -2452,6 +2452,26 @@ extern void decl_restrict_base_insert (t something which is DECL_COMDAT. / #define DECL_COMDAT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag) +/ A replaceable function is one which may be replaced at link-time + with an entirely different definition, provided that the + replacement has the same type. For example, functions declared + with attribute((weak)) on most systems are replaceable.
+ + COMDAT functions are not replaceable, since all definitions of the + function must be equivalent. It is important that COMDAT functions + not be treated as replaceable so that use of C++ template + instantiations is not penalized.
+ + For example, DECL_REPLACEABLE is used to determine whether or not a + function (including a template instantiation) which is not + explicitly declared "inline" can be inlined. If the function is + DECL_REPLACEABLE then it is not safe to do the inlining, since the + implementation chosen at link-time may be different. However, a + function that is not DECL_REPLACEABLE can be inlined, since all + versions of the function will be functionally identical. / +#define DECL_REPLACEABLE_P(NODE)
+ (!DECL_COMDAT (NODE) && !targetm.binds_local_p (NODE)) + / The name of the object as the assembler will see it (but before any translations made by ASM_OUTPUT_LABELREF). Often this is the same as DECL_NAME. It is an IDENTIFIER_NODE. */ Index: gcc/testsuite/g++.dg/eh/weak1-a.cc

--- gcc/testsuite/g++.dg/eh/weak1-a.cc (revision 0) +++ gcc/testsuite/g++.dg/eh/weak1-a.cc (revision 0) @@ -0,0 +1,3 @@ +extern void f() { + throw 7; +} Index: gcc/testsuite/g++.dg/eh/weak1.C

--- gcc/testsuite/g++.dg/eh/weak1.C (revision 0) +++ gcc/testsuite/g++.dg/eh/weak1.C (revision 0) @@ -0,0 +1,23 @@ +// PR target/29487 +// { dg-require-weak "" } +// { dg-do run { xfail "hppa*-hp-hpux11." } } +// { dg-additional-sources "weak1-a.cc" } +// { dg-options "-O2" } + +extern attribute((weak)) +void f() { +} + +int main () { + try { + f(); + return 1; + } catch (int i) { + / Although the implementation of f in this file does not throw + any exceptions, it is weak, and may therefore be replaced at + link time. Therefore, the compiler must not optimize away this + catch clause. */ + if (i != 7) + return 2; + } +} Index: gcc/testsuite/g++.dg/eh/comdat1.C

--- gcc/testsuite/g++.dg/eh/comdat1.C (revision 0) +++ gcc/testsuite/g++.dg/eh/comdat1.C (revision 0) @@ -0,0 +1,42 @@ +// PR target/29487 +// { dg-do link } +// { dg-options "-O2" } + +/* This function is not defined. The compiler should optimize away + all calls to it. / +extern void undefined () throw (); + +extern void f1(); + +inline void f2() { + f1(); +} + +/ This function will be COMDAT if not inlined. / +inline void f1() {} + +/ This function will be COMDAT. / +template +void f3() { + if (false) + throw 3; +} + +inline void f4() { + if (false) + throw 7; +} + +int main () { + try { + f1(); + f2(); + f3(); + f4(); + } catch (...) { + / The compiler should recognize that none of the functions above + can throw exceptions, and therefore remove this code as + unreachable. */ + undefined (); + } +} Index: gcc/cp/decl.c

--- gcc/cp/decl.c (revision 121662) +++ gcc/cp/decl.c (working copy) @@ -11010,7 +11010,7 @@ finish_function (int flags) if (!processing_template_decl && !cp_function_chain->can_throw && !flag_non_call_exceptions - && targetm.binds_local_p (fndecl)) + && !DECL_REPLACEABLE_P (fndecl)) TREE_NOTHROW (fndecl) = 1; /* This must come after expand_function_end because cleanups might Index: gcc/cp/tree.c

--- gcc/cp/tree.c (revision 121662) +++ gcc/cp/tree.c (working copy) @@ -2038,13 +2038,9 @@ cp_cannot_inline_tree_fn (tree* fnp) && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL) return 1; - /* Don't auto-inline anything that might not be bound within - this unit of translation. - Exclude comdat functions from this rule. While they can be bound - to the other unit, they all must be the same. This is especially - important so templates can inline. */ - if (!DECL_DECLARED_INLINE_P (fn) && !(targetm.binds_local_p) (fn) - && !DECL_COMDAT (fn)) + / Don't auto-inline functions that might be replaced at link-time + with an alternative definition. */ + if (!DECL_DECLARED_INLINE_P (fn) && DECL_REPLACEABLE_P (fn)) { DECL_UNINLINABLE (fn) = 1; return 1; Index: gcc/except.c

--- gcc/except.c (revision 121662) +++ gcc/except.c (working copy) @@ -2701,7 +2701,10 @@ set_nothrow_function_flags (void) { rtx insn;

• if (!targetm.binds_local_p (current_function_decl))

• /* If we don't know that this implementation of the function will

• actually be used, then we must not set TREE_NOTHROW, since

• callers must not assume that this function does not throw.  */

• if (DECL_REPLACEABLE_P (current_function_decl)) return;

  TREE_NOTHROW (current_function_decl) = 1;

• Follow-Ups:
  • Re: PATCH: PR 29487
    * From: John David Anglin
• References:
  • Re: PATCH: PR 29487
    * From: John David Anglin