PR c++/83871 - wrong code for attribute const and pure on distinct template specializations PR c++/83503 - [8 Regression] bogus -Wattributes for const and pure on function template specialization gcc/ChangeLog: PR c++/83871 * gcc/doc/invoke.texi (-Wmissing-attribute): New option. gcc/c-family/ChangeLog: PR c++/83871 * c.opt (-Wmissing-attribute): New option. gcc/cp/ChangeLog: PR c++/83871 PR c++/83503 * cp-tree.h (warn_spec_missing_attributes): New function. ((check_explicit_specialization): Add an argument. Call the above function. * decl.c (duplicate_decls): Avoid applying primary function template's attributes to its explicit specializations. gcc/testsuite/ChangeLog: PR c++/83871 PR c++/83503 * g++.dg/ext/attr-const-pure.C: New test. * g++.dg/ext/attr-malloc.C: New test. * g++.dg/ext/attr-nonnull.C: New test. * g++.dg/ext/attr-nothrow.C: New test. * g++.dg/ext/attr-nothrow-2.C: New test. * g++.dg/ext/attr-returns-nonnull.C: New test. * g++.dg/Wmissing-attribute.C: New test. diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt index 9c71726..a4d5e61 100644 --- a/gcc/c-family/c.opt +++ b/gcc/c-family/c.opt @@ -781,6 +781,11 @@ Wtemplates C++ ObjC++ Var(warn_templates) Warning Warn on primary template declaration. +Wmissing-attribute +C ObjC C++ ObjC++ Var(warn_missing_attribute) Warning LangEnabledBy(C ObjC C++ ObjC++,Wall) +Warn about declarations of entities that may be missing attributes +that related entities have been declared with it. + Wmissing-format-attribute C ObjC C++ ObjC++ Warning Alias(Wsuggest-attribute=format) ; diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index a53f4fd..87b7916 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -6470,7 +6470,8 @@ extern void end_specialization (void); extern void begin_explicit_instantiation (void); extern void end_explicit_instantiation (void); extern void check_unqualified_spec_or_inst (tree, location_t); -extern tree check_explicit_specialization (tree, tree, int, int); +extern tree check_explicit_specialization (tree, tree, int, int, + tree = NULL_TREE); extern int num_template_headers_for_class (tree); extern void check_template_variable (tree); extern tree make_auto (void); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 244a3ef..6e02ba3 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -1971,10 +1971,21 @@ next_arg:; DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl); } - /* Copy all the DECL_... slots specified in the new decl - except for any that we copy here from the old type. */ - DECL_ATTRIBUTES (newdecl) - = (*targetm.merge_decl_attributes) (olddecl, newdecl); + /* True to merge attributes between the declarations, false to + set OLDDECL's attributes to those of NEWDECL (for template + explicit specializations that specify their own attributes + independent of those specified for the primary template). */ + const bool merge_attr = (TREE_CODE (newdecl) != FUNCTION_DECL + || !DECL_TEMPLATE_SPECIALIZATION (newdecl) + || DECL_TEMPLATE_SPECIALIZATION (olddecl)); + + /* Copy all the DECL_... slots specified in the new decl except for + any that we copy here from the old type. */ + if (merge_attr) + DECL_ATTRIBUTES (newdecl) + = (*targetm.merge_decl_attributes) (olddecl, newdecl); + else + DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl); if (DECL_DECLARES_FUNCTION_P (olddecl) && DECL_DECLARES_FUNCTION_P (newdecl)) { @@ -2101,9 +2112,10 @@ next_arg:; } } } - else - /* Merge the data types specified in the two decls. */ + else if (merge_attr) newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl)); + else + newtype = TREE_TYPE (newdecl); if (VAR_P (newdecl)) { @@ -2167,13 +2179,20 @@ next_arg:; && !(processing_template_decl && uses_template_parms (newdecl))) layout_decl (newdecl, 0); - /* Merge the type qualifiers. */ - if (TREE_READONLY (newdecl)) - TREE_READONLY (olddecl) = 1; if (TREE_THIS_VOLATILE (newdecl)) TREE_THIS_VOLATILE (olddecl) = 1; - if (TREE_NOTHROW (newdecl)) - TREE_NOTHROW (olddecl) = 1; + + if (merge_attr) + { + /* Merge the type qualifiers. */ + if (TREE_READONLY (newdecl)) + TREE_READONLY (olddecl) = 1; + } + else + { + /* Set the bits that correspond to the const function attributes. */ + TREE_READONLY (olddecl) = TREE_READONLY (newdecl); + } /* Merge deprecatedness. */ if (TREE_DEPRECATED (newdecl)) @@ -2212,13 +2231,23 @@ next_arg:; |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl); DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl); TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); - TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl); - DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl); DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl); - DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl); TREE_READONLY (newdecl) |= TREE_READONLY (olddecl); - DECL_LOOPING_CONST_OR_PURE_P (newdecl) + DECL_LOOPING_CONST_OR_PURE_P (newdecl) |= DECL_LOOPING_CONST_OR_PURE_P (olddecl); + + if (merge_attr) + { + TREE_NOTHROW (olddecl) |= TREE_NOTHROW (newdecl); + DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl); + DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl); + } + else + { + TREE_NOTHROW (olddecl) = TREE_NOTHROW (newdecl); + DECL_IS_MALLOC (olddecl) = DECL_IS_MALLOC (newdecl); + DECL_PURE_P (olddecl) = DECL_PURE_P (newdecl); + } /* Keep the old RTL. */ COPY_DECL_RTL (olddecl, newdecl); } @@ -2340,17 +2369,18 @@ next_arg:; { tree parm; - /* Merge parameter attributes. */ + /* Merge or assign parameter attributes. */ tree oldarg, newarg; - for (oldarg = DECL_ARGUMENTS(olddecl), - newarg = DECL_ARGUMENTS(newdecl); - oldarg && newarg; - oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) { - DECL_ATTRIBUTES (newarg) - = (*targetm.merge_decl_attributes) (oldarg, newarg); - DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg); - } - + for (oldarg = DECL_ARGUMENTS (olddecl), + newarg = DECL_ARGUMENTS (newdecl); + oldarg && newarg; + oldarg = DECL_CHAIN (oldarg), newarg = DECL_CHAIN (newarg)) + { + DECL_ATTRIBUTES (newarg) + = (*targetm.merge_decl_attributes) (oldarg, newarg); + DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg); + } + if (DECL_TEMPLATE_INSTANTIATION (olddecl) && !DECL_TEMPLATE_INSTANTIATION (newdecl)) { @@ -8912,7 +8942,8 @@ grokfndecl (tree ctype, template_count, 2 * funcdef_flag + 4 * (friendp != 0) + - 8 * concept_p); + 8 * concept_p, + *attrlist); if (decl == error_mark_node) return NULL_TREE; diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index ca73bb1..3bd44ab 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see all methods must be provided in header files; can't use a source file that contains only the method templates and "just win". */ +#include #include "config.h" #include "system.h" #include "coretypes.h" @@ -1473,8 +1474,10 @@ is_specialization_of_friend (tree decl, tree friend_decl) /* Register the specialization SPEC as a specialization of TMPL with the indicated ARGS. IS_FRIEND indicates whether the specialization - is actually just a friend declaration. Returns SPEC, or an - equivalent prior declaration, if available. + is actually just a friend declaration. ATTRLIST is the list of + attributes that the specialization is declared with or NULL when + it isn't. Returns SPEC, or an equivalent prior declaration, if + available. We also store instantiations of field packs in the hash table, even though they are not themselves templates, to make lookup easier. */ @@ -2610,6 +2613,110 @@ check_unqualified_spec_or_inst (tree t, location_t loc) } } +/* Warn for a template specialization SPEC that is missing some of a set + of function or type attributes that the template TEMPL is declared with. + ATTRLIST is a list of additional attributes that SPEC should be taken + to ultimately be declared with. */ + +static void +warn_spec_missing_attributes (tree tmpl, tree spec, tree attrlist) +{ + if (DECL_FUNCTION_TEMPLATE_P (tmpl)) + tmpl = DECL_TEMPLATE_RESULT (tmpl); + + if (TREE_CODE (tmpl) != FUNCTION_DECL) + return; + + /* Avoid warning if either declaration or its type is deprecated. */ + if (TREE_DEPRECATED (tmpl) + || TREE_DEPRECATED (spec)) + return; + + tree tmpl_type = TREE_TYPE (tmpl); + tree spec_type = TREE_TYPE (spec); + + if (TREE_DEPRECATED (tmpl_type) + || TREE_DEPRECATED (spec_type) + || TREE_DEPRECATED (TREE_TYPE (tmpl_type)) + || TREE_DEPRECATED (TREE_TYPE (spec_type))) + return; + + tree tmpl_attrs[] = { DECL_ATTRIBUTES (tmpl), TYPE_ATTRIBUTES (tmpl_type) }; + tree spec_attrs[] = { DECL_ATTRIBUTES (spec), TYPE_ATTRIBUTES (spec_type) }; + + if (!spec_attrs[0]) + spec_attrs[0] = attrlist; + else if (!spec_attrs[1]) + spec_attrs[1] = attrlist; + + /* Avoid warning if the primary has no attributes. */ + if (!tmpl_attrs[0] && !tmpl_attrs[1]) + return; + + /* Avoid warning if either declaration contains an attribute on + the white list below. */ + const char* const whitelist[] = { + "error", "noreturn", "warning" + }; + + for (unsigned i = 0; i != 2; ++i) + for (unsigned j = 0; j != sizeof whitelist / sizeof *whitelist; ++j) + if (lookup_attribute (whitelist[j], tmpl_attrs[i]) + || lookup_attribute (whitelist[j], spec_attrs[i])) + return; + + /* Avoid warning if the difference between the primary and + the specialization is not in one of the attributes below. */ + const char* const blacklist[] = { + "alloc_align", "alloc_size", "assume_aligned", "format", + "format_arg", "malloc", "nonnull", "warn_unused_result" + }; + + /* Put together a list of the black listed attributes that the primary + template is declared with that the specialization is not, in case + it's not apparent from the most recent declaration of the primary. */ + unsigned nattrs = 0; + std::string str; + + for (unsigned i = 0; i != sizeof blacklist / sizeof *blacklist; ++i) + { + for (unsigned j = 0; j != 2; ++j) + { + if (!lookup_attribute (blacklist[i], tmpl_attrs[j])) + continue; + + for (unsigned k = 0; k != 1 + !!spec_attrs[1]; ++k) + { + if (lookup_attribute (blacklist[i], spec_attrs[k])) + break; + + if (str.size ()) + str += ", "; + str += "%<"; + str += blacklist[i]; + str += "%>"; + ++nattrs; + } + } + } + + if (!nattrs) + return; + + if (warning_at (DECL_SOURCE_LOCATION (spec), OPT_Wmissing_attribute, + "explicit specialization %q#D may be missing attributes", + spec)) + { + if (nattrs > 1) + str = G_("missing primary template attributes ") + str; + else + str = G_("missing primary template attribute ") + str; + + inform (DECL_SOURCE_LOCATION (tmpl), str.c_str ()); + } + +} + /* Check to see if the function just declared, as indicated in DECLARATOR, and in DECL, is a specialization of a function template. We may also discover that the declaration is an explicit @@ -2651,7 +2758,8 @@ tree check_explicit_specialization (tree declarator, tree decl, int template_count, - int flags) + int flags, + tree attrlist) { int have_def = flags & 2; int is_friend = flags & 4; @@ -3108,8 +3216,13 @@ check_explicit_specialization (tree declarator, it again. Partial specializations will be registered in process_partial_specialization. */ if (!processing_template_decl) - decl = register_specialization (decl, gen_tmpl, targs, - is_friend, 0); + { + warn_spec_missing_attributes (gen_tmpl, decl, attrlist); + + decl = register_specialization (decl, gen_tmpl, targs, + is_friend, 0); + } + /* A 'structor should already have clones. */ gcc_assert (decl == error_mark_node diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index f3d9336..f50e3f3 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -295,7 +295,7 @@ Objective-C and Objective-C++ Dialects}. -Winvalid-pch -Wlarger-than=@var{len} @gol -Wlogical-op -Wlogical-not-parentheses -Wlong-long @gol -Wmain -Wmaybe-uninitialized -Wmemset-elt-size -Wmemset-transposed-args @gol --Wmisleading-indentation -Wmissing-braces @gol +-Wmisleading-indentation -Wmissing-attribute -Wmissing-braces @gol -Wmissing-field-initializers -Wmissing-include-dirs @gol -Wno-multichar -Wmultistatement-macros -Wnonnull -Wnonnull-compare @gol -Wnormalized=@r{[}none@r{|}id@r{|}nfc@r{|}nfkc@r{]} @gol @@ -3887,6 +3887,7 @@ Options} and @ref{Objective-C and Objective-C++ Dialect Options}. -Wmemset-elt-size @gol -Wmemset-transposed-args @gol -Wmisleading-indentation @r{(only for C/C++)} @gol +-Wmissing-attribute @gol -Wmissing-braces @r{(only for C/ObjC)} @gol -Wmultistatement-macros @gol -Wnarrowing @r{(only for C++)} @gol @@ -4550,6 +4551,17 @@ about the layout of the file that the directive references. This warning is enabled by @option{-Wall} in C and C++. +@item -Wmissing-attribute +@opindex Wmissing-attribute +@opindex Wno-missing-attribute +Warn when a declaration of an entity is missing attributes that a related +entity is declared with whose absence may adversely affect the correctness +of generated code. For example, in C++, the warning is issued when +an explicit specialization of a primary template declared with attribute +@code{malloc} is declared without the attribute. + +This warning is enabled by @option{-Wall}. + @item -Wmissing-braces @opindex Wmissing-braces @opindex Wno-missing-braces diff --git a/gcc/testsuite/g++.dg/Wmissing-attribute.C b/gcc/testsuite/g++.dg/Wmissing-attribute.C new file mode 100644 index 0000000..5ce97cc --- /dev/null +++ b/gcc/testsuite/g++.dg/Wmissing-attribute.C @@ -0,0 +1,122 @@ +// PR c++/83871 - wrong code for attribute const and pure on distinct +// template specializations +// Test to verify that a declaration of an explicit specialization with +// no attributes is diagnosed when the primary template is declared with +// one or more attributes. The warning helps highlight a change in GCC +// 8 from previous versions that copied the attributes from the primary +// to the specialization. It also helps point out simply forgetting to +// declare the specialization with an attribute. +// { dg-do compile } +// { dg-options "-Wmissing-attribute" } + +#define ATTR(list) __attribute__ (list) + + +// Verify that a primary without attributes doesn't cause warnings. +template void fnoattr (); + +template <> void fnoattr(); +template <> void ATTR ((cold)) fnoattr(); +template <> void ATTR ((hot)) fnoattr(); + +// Verify that a noreturn primary also doesn't cause warnings. +template int ATTR ((noreturn)) fnoreturn (); + +template <> int fnoreturn(); +template <> int ATTR ((cold)) fnoreturn(); +template <> int ATTR ((hot)) fnoreturn(); + + +template +void* +ATTR ((malloc, alloc_size (1))) +missing_all (int); // { dg-message "missing primary template attributes \(.malloc., .alloc_size.|.alloc_size., .malloc.\)" } + +template <> +void* +missing_all(int); // { dg-warning "explicit specialization .\[^\n\r\]+. may be missing attributes" } + +// Verify that specifying the same attributes in whatever order +// doesn't trigger the warning, even when other attributes are +// added. +template <> +void* +ATTR ((alloc_size (1), malloc)) +missing_all(int); + +template <> +void* +ATTR ((alloc_size (1))) ATTR ((malloc)) ATTR ((returns_nonnull)) +missing_all(int); // T = char, same as above + +template <> +void* +ATTR ((hot)) ATTR ((alloc_size (1))) ATTR ((malloc)) +missing_all(int); // T = char, same as above + +// Verify that the following attributes suppress the warning. +template <> void* ATTR ((error (""))) missing_all(int); +template <> void* ATTR ((deprecated)) missing_all(int); +template <> void* ATTR ((noreturn)) missing_all(int); +template <> void* ATTR ((warning (""))) missing_all(int); + + +template +void* +ATTR ((malloc, alloc_size (1))) +missing_malloc (int); // { dg-message "missing primary template attribute .malloc." } + +template <> +void* +ATTR ((alloc_size (1))) +missing_malloc(int); // { dg-warning "explicit specialization .\[^\n\r\]+. may be missing attributes" } + +template <> void* ATTR ((malloc, alloc_size (1))) missing_malloc(int); +template <> void* ATTR ((deprecated)) missing_malloc(int); +template <> void* ATTR ((error (""))) missing_malloc(int); +template <> void* ATTR ((noreturn)) missing_malloc(int); +template <> void* ATTR ((warning (""))) missing_malloc(int); + +template +void* +ATTR ((malloc, alloc_size (1))) +missing_alloc_size (int, int); // { dg-message "missing primary template attribute .alloc_size." } + +template <> +void* +ATTR ((malloc)) +missing_alloc_size(int, int); // { dg-warning "explicit specialization .\[^\n\r\]+. may be missing attributes" } + + +template +void* +ATTR ((nonnull (1))) +missing_nonnull (void*); // { dg-message "missing primary template attribute .nonnull." } + +template <> +void* +ATTR ((malloc)) +missing_nonnull(void*); // { dg-warning "explicit specialization .\[^\n\r\]+. may be missing attributes" } + +template <> void* ATTR ((nonnull (1))) missing_nonnull(void*); +template <> void* ATTR ((deprecated)) missing_nonnull(void*); +template <> void* ATTR ((error (""))) missing_nonnull(void*); +template <> void* ATTR ((noreturn)) missing_nonnull(void*); +template <> void* ATTR ((warning (""))) missing_nonnull(void*); + + +template +void* +ATTR ((warn_unused_result)) +missing_wur (); // { dg-message "missing primary template attribute .warn_unused_result." } + +template <> +void* +ATTR ((returns_nonnull)) +missing_wur(); // { dg-warning "explicit specialization .\[^\n\r\]+. may be missing attributes" } + +template <> void* ATTR ((warn_unused_result)) missing_wur(); +template <> void* ATTR ((deprecated)) missing_wur(); +template <> void* ATTR ((error (""))) missing_wur(); +template <> void* ATTR ((noreturn)) missing_wur(); +template <> void* ATTR ((warning (""))) missing_wur(); diff --git a/gcc/testsuite/g++.dg/ext/attr-const-pure.C b/gcc/testsuite/g++.dg/ext/attr-const-pure.C new file mode 100644 index 0000000..6afef6d --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-const-pure.C @@ -0,0 +1,103 @@ +// Bug c++/83503 - bogus -Wattributes for const and pure on function template +// specialization +// { dg-do compile } +// { dg-options "-O -Wall -fdump-tree-optimized" } + +template +int __attribute__ ((pure)) +f (T); + +template <> +int __attribute__ ((const)) f (int); // { dg-bogus "ignoring attribute .const." } + + +template +int __attribute__ ((const)) +g (T); + +template <> +int __attribute__ ((pure)) g (int); // { dg-bogus "ignoring attribute .const." } + +template +int __attribute__ ((const)) +h (T); + +template +int __attribute__ ((pure)) +h (const T*); + +template <> +int h (int); + +template <> +int h (int*); + +int global; + +extern void h_primary_elim (); +extern void h_cstptr_elim (); +extern void h_cstptr_keep (); +extern void h_int_keep (); +extern void h_intptr_keep (); + +void call_primary_elim (double x) +{ + // Only the first call to h(x) must be emitted, the second one + // is expected to be eliminated. + int i0 = h (x); + int i1 = h (x); + + if (i0 != i1) // must be folded into false + h_primary_elim (); // must be eliminated +} + +void call_cstptr_elim (const void *p) +{ + // Only the first call to h(x) must be emitted, the second one + // is expected to be eliminated. This verifies that h*() is treated as const in this context. + int i0 = h (p); + int i1 = h (p); + + if (i0 != i1) // must be folded into false + h_cstptr_elim (); // must be eliminated +} + +void call_cstptr_keep (const void *p) +{ + // Because of the store to the global, both calls to h(p) must + // be emitted. This verifies that h*() is not + // treated as const. + int i0 = h (p); + global = 123; + int i1 = h (p); + + if (i0 != i1) // must not be folded + h_cstptr_keep (); // must be emitted +} + +void call_int_keep (int i) +{ + // Both calls to h(i) must be emitted. + int i0 = h (i); + int i1 = h (i); + + if (i0 != i1) // must not be folded + h_int_keep (); // must be emitted +} + +void call_intptr_keep (int *ip) +{ + // Both calls to h(ip) must be emitted. + int i0 = h (ip); + int i1 = h (ip); + + if (i0 != i1) // must not be folded + h_intptr_keep (); // must be emitted +} + +// { dg-final { scan-tree-dump-not "h_primary_elim" "optimized" } } +// { dg-final { scan-tree-dump-not "h_cstptr_elim" "optimized" } } +// { dg-final { scan-tree-dump-times "h_cstptr_keep" 1 "optimized" } } +// { dg-final { scan-tree-dump-times "h_int_keep" 1 "optimized" } } +// { dg-final { scan-tree-dump-times "h_intptr_keep" 1 "optimized" } } diff --git a/gcc/testsuite/g++.dg/ext/attr-malloc.C b/gcc/testsuite/g++.dg/ext/attr-malloc.C new file mode 100644 index 0000000..ce76abe --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-malloc.C @@ -0,0 +1,45 @@ +// Bug c++/83503 - bogus -Wattributes for const and pure on function template +// specialization +// Test to verify that an explicit template specifialization does not +// "inherit" attribute malloc from a primary template declared with one. +// { dg-do compile } +// { dg-options "-O -Wall -fdump-tree-optimized" } + +template +void* __attribute__ ((malloc)) +f (unsigned); + +template <> +void* +f(unsigned); // { dg-warning "may be missing attributes" } + +static char a[8]; + +void f_void_malloc (); +void f_int_not_malloc (); + +void fv (void) +{ + void *p = f(1); + if (!p) + return; + + if (p == a) // must be false + f_void_malloc (); // should be eliminated +} + + +void fi (void) +{ + void *p = f(1); + if (!p) + return; + + if (p == a) // can be true + f_int_not_malloc (); // must not be eliminated +} + +// Verify that the call to f_void_not_malloc() is eliminated but +// the call to f_int_not_malloc() is retained. +// { dg-final { scan-tree-dump-not "f_void_malloc" "optimized" } } +// { dg-final { scan-tree-dump-times "f_int_not_malloc" 1 "optimized" } } diff --git a/gcc/testsuite/g++.dg/ext/attr-nonnull.C b/gcc/testsuite/g++.dg/ext/attr-nonnull.C new file mode 100644 index 0000000..57d2cb0 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-nonnull.C @@ -0,0 +1,31 @@ +// Bug c++/83871 - wrong code due to attributes on distinct template +// specializations +// Test to verify that an explicit function template specifialization +// does not "inherit" attribute nonnull from an argument declared with +// one in the primary template. +// { dg-do compile } +// { dg-options "-O -Wall -fdump-tree-optimized" } + +template +void __attribute__ ((nonnull (1))) +f (T*, T*, T*); + +template <> +void +f(int*, int*, int*); // { dg-warning "may be missing attributes" } + +template <> +void __attribute__ ((nonnull (3))) +f(float*, float*, float*); + + +void test_nonnull (void) +{ + f(0, 0, 0); // { dg-warning "null argument where non-null required \\\(argument 1\\\)" } + + f(0, 0, 0); // { dg-bogus "null argument" } + + f(0, 0, 0); + // { dg-bogus "null argument where non-null required \\\(argument 1\\\)" "" { target *-*-* } .-1 } + // { dg-warning "null argument where non-null required \\\(argument 3\\\)" "" { target *-*-* } .-2 } +} diff --git a/gcc/testsuite/g++.dg/ext/attr-nothrow-2.C b/gcc/testsuite/g++.dg/ext/attr-nothrow-2.C new file mode 100644 index 0000000..4061f82 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-nothrow-2.C @@ -0,0 +1,36 @@ +/* PR c++/83871 - wrong code for attribute const and pure on distinct + template specializations + { dg-do compile } + { dg-options "-O -fdump-tree-eh" } */ + +void __attribute__ ((nothrow)) f (); + +void ff () throw () +{ + // No exception handling necessary around the call to f(). + f (); +} + +void __attribute__ ((nothrow)) g (); +void g (); + +void gg () throw () +{ + // No exception handling necessary around the call to g(). + g (); +} + +int __attribute__ ((nothrow)) h (); +int __attribute__ ((noreturn)) h (); +int h (); + +int hh () throw () +{ + // No exception handling necessary around the call to h(). + // No -Wreturn-value should be emitted because h is noreturn. + h (); +} + +// Verify that no exception handling code was emitted. +// { dg-final { scan-tree-dump-not "eh_dispatch" "eh" } } +// { dg-final { scan-tree-dump-not "resx" "eh" } } diff --git a/gcc/testsuite/g++.dg/ext/attr-nothrow.C b/gcc/testsuite/g++.dg/ext/attr-nothrow.C new file mode 100644 index 0000000..ae6b674 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-nothrow.C @@ -0,0 +1,47 @@ +// Bug c++/83871 - wrong code due to attributes on distinct template +// specializations +// Test to verify that an explicit template specifialization does not +// "inherit" attribute nothrow from a primary template declared with one. +// { dg-do compile } +// { dg-options "-O -Wall -fdump-tree-optimized" } + +template +void __attribute__ ((nothrow)) +f (); + +template <> +void +f(); + +void f_void_nothrow (); +void f_int_maythrow (); + +void fv (void) +{ + try + { + f(); + } + catch (...) // cannot be be reached + { + f_void_nothrow (); // should be eliminated + } +} + + +void fi (void) +{ + try + { + f(); + } + catch (...) // may be reached + { + f_int_maythrow (); // must not be eliminated + } +} + +// Verify that the call to f_void_nothrow() is eliminated but +// the call to f_int_maythrow() is retained. +// { dg-final { scan-tree-dump-not "f_void_nothrow" "optimized" } } +// { dg-final { scan-tree-dump-times "f_int_maythrow" 1 "optimized" } } diff --git a/gcc/testsuite/g++.dg/ext/attr-returns-nonnull.C b/gcc/testsuite/g++.dg/ext/attr-returns-nonnull.C new file mode 100644 index 0000000..f75f32e --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-returns-nonnull.C @@ -0,0 +1,42 @@ +// Bug c++/83871 - wrong code due to attributes on distinct template +// specializations +// Test to verify that an explicit function template specifialization +// does not "inherit" attribute nonnull from an argument declared with +// one in the primary template. +// { dg-do compile } +// { dg-options "-O -Wall -fdump-tree-optimized" } + +template +void* __attribute__ ((returns_nonnull)) +g (); + +template <> +void* +g(); + +extern void g_void_returns_nonnull (); +extern void g_int_may_return_null (); + +void test_returns_nonnull () +{ + void *p = g(); + if (!p) + g_void_returns_nonnull (); + + (void)&p; +} + +void test_may_return_null () +{ + void *p = g(); + if (!p) + g_int_may_return_null (); + + (void)&p; +} + + +// Verify that the call to g_void_returns_nonnull() is eliminated but +// the call to g_int_may_return_null() is retained. +// { dg-final { scan-tree-dump-not "g_void_returns_nonnull" "optimized" } } +// { dg-final { scan-tree-dump-times "g_int_may_return_null" 1 "optimized" } }