[clang] Add the exclude_from_explicit_instantiation attribute

[ldionne]

Summary

This attribute allows excluding a member of a class template from being part
of an explicit template instantiation of that class template. This also makes
sure that code using such a member will not take for granted that an external
instantiation exists in another translation unit. The attribute was discussed
on cfe-dev at [1] and is primarily motivated by the removal of always_inline
in libc++ to control what's part of the ABI (see links in [1]).

[1]: http://lists.llvm.org/pipermail/cfe-dev/2018-August/059024.html

rdar://problem/43428125

[ldionne]

This patch is an early WIP -- I'm just uploading it to serve as a support for a message I'm about to post on cfe-dev. No need to review seriously for now.

[dexonsmith]

+cfe-commits
-llvm-commits

[rsmith]

It'd be good to test that [[no_extern_template]] affects instantiation, not just code generation (eg, put something in the body of the entity that will trigger an error if instantiated, and check that the diagnostic is produced at the right times).

[ldionne]

Fix the tests and remove some warnings that I wasn't able to generate properly
(to avoid false positives).

[ldionne]

I think now's a good time to bikeshed the name of the attribute if you have other suggestions.

[rsmith]

In D51789#1234903, @ldionne wrote:

I think now's a good time to bikeshed the name of the attribute if you have other suggestions.

OK, so the semantics of this attribute are "explicit instantiation declarations or definitions applied to the enclosing class do not apply to this member", right? So it opts the member out of both extern template and (non-extern) template, but only when applied to an enclosing class.

Maybe something like exclude_from_explicit_instantiation? That's a little longer than I'd like, but if it's going to be hidden behind a macro most of the time I could live with it.
Or maybe no_transitive_instantiation? That's less explicit about the purpose of the attribute, but is a more comfortable length.

[ldionne]

In D51789#1235096, @rsmith wrote:

In D51789#1234903, @ldionne wrote:

I think now's a good time to bikeshed the name of the attribute if you have other suggestions.

OK, so the semantics of this attribute are "explicit instantiation declarations or definitions applied to the enclosing class do not apply to this member", right? So it opts the member out of both extern template and (non-extern) template, but only when applied to an enclosing class.

Yes, but it also (obviously) opts the member out when applied to the member itself, not only to an enclosing class.

Maybe something like exclude_from_explicit_instantiation? That's a little longer than I'd like, but if it's going to be hidden behind a macro most of the time I could live with it.

I like this a lot too. I thought about that one and was deterred by the length, but it may be acceptable. Realistically, it's also not an attribute we want people to use most of the time.

Or maybe no_transitive_instantiation? That's less explicit about the purpose of the attribute, but is a more comfortable length.

I'm not sure this one describes what the attribute is doing sufficiently closely.

Unless we get a better suggestion soonish, I'll change it to exclude_from_explicit_instantiation and update the diff.

[rsmith]

In D51789#1235100, @ldionne wrote:

In D51789#1235096, @rsmith wrote:

OK, so the semantics of this attribute are "explicit instantiation declarations or definitions applied to the enclosing class do not apply to this member", right? So it opts the member out of both extern template and (non-extern) template, but only when applied to an enclosing class.

Yes, but it also (obviously) opts the member out when applied to the member itself, not only to an enclosing class.

Assuming I'm understanding you correctly, I don't think the current implementation does that (nor does the documentation change say that), and I think that's a feature not a bug. For example, given:

template<typename T> struct A {
  [[clang::no_extern_template]] void f() {}
  void g() {}
};
template struct A<int>; // instantiates A<int> and definition of A<int>::g(), does not instantiate definition of A<int>::f()
template void A<int>::f(); // instantiates definition of A<int>::f() despite attribute

... the attribute affects the first explicit instantiation but not the second (I think you're saying it should affect both, and make the second explicit instantiation have no effect). I think the current behavior in this patch is appropriate: making the attribute also affect the second case makes it strictly less useful. If you didn't want to actually explictly instantiate A<int>::f(), you can just leave out that explicit instantiation. But the current implementation gives you extra capabilities:

// A<float>::g() is instantiated somewhere else, A<float>::f() still needs to be implicitly instantiated when used
extern template struct A<float>;

// A<int>::f() and A<int>::g() are both instantiated somewhere else
extern template struct A<int>;
extern template void A<int>::f();

You can't do that if an explicit instantiation of a member with the attribute has no effect.

[ldionne]

In D51789#1235113, @rsmith wrote:

In D51789#1235100, @ldionne wrote:

In D51789#1235096, @rsmith wrote:

OK, so the semantics of this attribute are "explicit instantiation declarations or definitions applied to the enclosing class do not apply to this member", right? So it opts the member out of both extern template and (non-extern) template, but only when applied to an enclosing class.

Yes, but it also (obviously) opts the member out when applied to the member itself, not only to an enclosing class.

Assuming I'm understanding you correctly, I don't think the current implementation does that (nor does the documentation change say that), and I think that's a feature not a bug. For example, given:

template<typename T> struct A {
  [[clang::no_extern_template]] void f() {}
  void g() {}
};
template struct A<int>; // instantiates A<int> and definition of A<int>::g(), does not instantiate definition of A<int>::f()
template void A<int>::f(); // instantiates definition of A<int>::f() despite attribute

... the attribute affects the first explicit instantiation but not the second (I think you're saying it should affect both, and make the second explicit instantiation have no effect). I think the current behavior in this patch is appropriate: making the attribute also affect the second case makes it strictly less useful. [...]

Sorry, that's a misunderstanding. We're on the same page. What I meant is that if you apply the attribute to the entity itself but explicitly instantiate the enclosing class, then the entity is not instantiated. It's very obvious, but your previous comment:

So it opts the member out of both extern template and (non-extern) template, but only when applied to an enclosing class.

suggested that it only applied in the following case:

template <class T> struct Foo {
  struct __attribute__((no_extern_template)) nested { static void f() { } };
};

template struct Foo<int>; // Foo<int>::nested::f not instantiated

[ldionne]

Change no_extern_template to exclude_from_explicit_instantiation

[rsmith]

Looks good other than the warning, which I don't yet understand.

clang/include/clang/Basic/DiagnosticSemaKinds.td

4681–4684

Diagnostics should start with a lowercase letter and not end with a period.

That said, I'm not sure I see why this diagnostic is correct / useful. If the entity is never used, then there's no link error. And if it is ever used, then you should get an implicit instantiation like normal, and we already have a diagnostic for the case where an entity is implicitly instantiated and no definition is available.

clang/lib/Sema/SemaTemplateInstantiate.cpp

2586–2587

Nit: we prefer to left-align continuation lines (clang-format will do that for you).

[ldionne]

clang/include/clang/Basic/DiagnosticSemaKinds.td

4681–4684

Diagnostics should start with a lowercase letter and not end with a period.

Done.

That said, I'm not sure I see why this diagnostic is correct / useful. If the entity is never used, then there's no link error. And if it is ever used, then you should get an implicit instantiation like normal, and we already have a diagnostic for the case where an entity is implicitly instantiated and no definition is available.

This is not what happens right now. If you don't provide a definition but you try to call the function, an extern call will be produced (and that will result in a link error because any potential explicit instantiation won't provide the function). For example:

cat <<EOF | ./install/bin/clang++ -cc1 -stdlib=libc++ -xc++ -emit-llvm -o - -
template <class T>
struct Foo {
  __attribute__((exclude_from_explicit_instantiation)) static void static_member_function();
};

extern template struct Foo<int>;

int main() {
  Foo<int>::static_member_function();
}
EOF

Results in the following LLVM IR:

; Function Attrs: noinline norecurse nounwind optnone
define i32 @main() #0 {
entry:
  call void @_ZN3FooIiE22static_member_functionEv()
  ret i32 0
}

declare void @_ZN3FooIiE22static_member_functionEv() #1

I guess we should be getting a warning or an error on the point of implicit instantiation instead, or is this behavior acceptable?

clang/lib/Sema/SemaTemplateInstantiate.cpp

2586–2587

Thanks for the heads up. I ran clang-format on all the lines I touched in this file.

[ldionne]

Reformat warning message and run clang-format on changed lines.

[aaron.ballman]

clang/include/clang/Basic/AttrDocs.td

2990

An example that demonstrates how the attribute behaves would be appreciated. Having some exposition that explains why a user might want to write this attribute themselves would also be good.

[ldionne]

Add example of how to use the attribute, per Aaron's comment.

[ldionne]

I'm thinking about this some more, and I'm wondering whether it would be a viable solution to just exclude members marked with hidden visibility from explicit template instantiations (and declarations thereof). I thought I had been convinced by Hubert that visibility and this attribute should be left separate, but now I'm not sure anymore. I don't think there's a single case of a member function with hidden visibility that we don't want to exclude from explicit instantiations. @rsmith Thoughts?

[rjmccall]

That may work for libc++'s purposes, but it's clearly inappropriate as a compiler rule. There are good reasons why something with hidden visibility would need to be explicitly instantiated. For many programmers, hidden visibility means "this is private to my library", not "this is actually public to my library, but I'm walking an ABI tightrope".

[ldionne]

In D51789#1238396, @rjmccall wrote:

That may work for libc++'s purposes, but it's clearly inappropriate as a compiler rule. There are good reasons why something with hidden visibility would need to be explicitly instantiated.

I take your word for it, but I can't think of any example. For my education, do you have a specific example in mind?

For many programmers, hidden visibility means "this is private to my library", not "this is actually public to my library, but I'm walking an ABI tightrope".

In libc++'s case, the functions we will annotate with exclude_from_explicit_instantiation are private to libc++ too (in the sense that we don't want them part of the ABI and they are not exported from the dylib). Those functions were previously marked with __always_inline__ to make sure they were not part of the ABI.

Note that I'm quite happy with exclude_from_explicit_instantiation as it solves libc++'s problem -- I'm trying to see whether another solution would serve people better while still solving libc++'s problem. (Appart from explicitly exporting functions, typeinfos and vtables like we've talked about on cfe-dev, which is a superior solution to everything else but is left as a future improvement for the time being).

[rjmccall]

In D51789#1238410, @ldionne wrote:

In D51789#1238396, @rjmccall wrote:

That may work for libc++'s purposes, but it's clearly inappropriate as a compiler rule. There are good reasons why something with hidden visibility would need to be explicitly instantiated.

I take your word for it, but I can't think of any example. For my education, do you have a specific example in mind?

I mean, most code doesn't use explicit instantiations to begin with, but — the general idea would be someone using an explicit instantiation, either for compile-time or seperate-compilation reasons, for some type that's entirely private to their library.

Here's an example of it from Swift that happened to be easy to find:

https://github.com/apple/swift/blob/master/lib/SILOptimizer/ARC/RCStateTransitionVisitors.h

The entire template being instantiated there is private to the SILOptimizer library. Swift doesn't use explicit visibility attributes much, preferring to globally assume -fvisibility=hidden, but if we used them, there would definitely be an attribute on that template.

For many programmers, hidden visibility means "this is private to my library", not "this is actually public to my library, but I'm walking an ABI tightrope".

In libc++'s case, the functions we will annotate with exclude_from_explicit_instantiation are private to libc++ too (in the sense that we don't want them part of the ABI and they are not exported from the dylib). Those functions were previously marked with __always_inline__ to make sure they were not part of the ABI.

Yeah, I understand the use case. That's what I was calling an ABI tightrope. The functions you're annotating are still part of libc++'s *logical* interface, they're just not exported by the dylib.

Note that I'm quite happy with exclude_from_explicit_instantiation as it solves libc++'s problem -- I'm trying to see whether another solution would serve people better while still solving libc++'s problem. (Appart from explicitly exporting functions, typeinfos and vtables like we've talked about on cfe-dev, which is a superior solution to everything else but is left as a future improvement for the time being).

Understood.

John.

[rsmith]

clang/include/clang/Basic/DiagnosticSemaKinds.td

4681–4684

I don't think your example is fundamentally any different from:

template <class T>
struct Foo {
  static void static_member_function();
};

int main() {
  Foo<int>::static_member_function();
}

which likewise produces a declaration of _ZN3FooIiE22static_member_functionEv. That case produces a -Wundefined-func-template warning; your example should do the same.

[ldionne]

Fix warnings on undefined entities

[rsmith]

clang/lib/Sema/Sema.cpp

648 ↗

(On Diff #166590)

What's the purpose of this change?

clang/test/SemaCXX/attr-exclude_from_explicit_instantiation.diagnose_on_undefined_entity.cpp

29 ↗

(On Diff #166590)

I generally prefer to use relative line numbers (@-5) rather than absolute ones, so that the test doesn't break if unrelated things are changed earlier in the file.

[ldionne]

clang/lib/Sema/Sema.cpp

648 ↗

(On Diff #166590)

It's so that we diagnose a member function marked with exclude_from_explicit_instantiation that is used but not defined just like we do for an inline function. This causes us to push_back the declaration (line 668 below) into the vector of Undefined-but-used declarations, which we use to trigger a diagnostic somewhere else.

clang/include/clang/Basic/Attr.td

 }
 
 def InternalLinkage : InheritableAttr {
   let Spellings = [Clang<"internal_linkage">];
   let Subjects = SubjectList<[Var, Function, CXXRecord]>;
   let Documentation = [InternalLinkageDocs];
 }
 
+def NoExternTemplate : InheritableAttr {
+  let Spellings = [Clang<"no_extern_template">];
+  let Subjects = SubjectList<[Var, Function, CXXRecord]>;
+  let Documentation = [NoExternTemplateDocs];
+}
+
 def Reinitializes : InheritableAttr {
   let Spellings = [Clang<"reinitializes", 0>];
   let Subjects = SubjectList<[NonStaticNonConstCXXMethod], ErrorDiag>;
   let Documentation = [ReinitializesDocs];
 }
 
 def NoDestroy : InheritableAttr {
   let Spellings = [Clang<"no_destroy", 0>];

clang/include/clang/Basic/AttrDocs.td

def InternalLinkageDocs : Documentation {
   let Content = [{
 The ``internal_linkage`` attribute changes the linkage type of the declaration to internal.
 This is similar to C-style ``static``, but can be used on classes and class methods. When applied to a class definition,
 this attribute affects all methods and static data members of that class.
 This can be used to contain the ABI of a C++ library by excluding unwanted class methods from the export tables.
   }];
 }
 
+def NoExternTemplateDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The ``no_extern_template`` attribute opts-out a member of a class template from
+being part of explicit template instantiations of that class template. This means
+that an explicit instantiation will not instantiate members of the class template
+marked with ``no_extern_template``, but also that code where an extern template
+declaration of the enclosing class template is visible will not take for granted
+that an external instantiation of the class template would provide those members
+(which would otherwise be a link error, since the explicit instantiation won't
+provide those members). This attribute can be used on static and non-static
+member functions of class templates, static data members of class templates
+and member classes of class templates.
+  }];
+}
+
 def DisableTailCallsDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``disable_tail_calls`` attribute instructs the backend to not perform tail call optimization inside the marked function.
 
 For example:
 
   .. code-block:: c

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_used_here : Note<"used here">;
 
 def err_internal_linkage_redeclaration : Error<
   "'internal_linkage' attribute does not appear on the first declaration of %0">;
 def warn_internal_linkage_local_storage : Warning<
   "'internal_linkage' attribute on a non-static local variable is ignored">,
   InGroup<IgnoredAttributes>;
 
+def warn_no_extern_template_local_storage : Warning<
+  "'no_extern_template' attribute on a non-static local variable is ignored">,
+  InGroup<IgnoredAttributes>;
+
 def ext_internal_in_extern_inline : ExtWarn<
   "static %select{function|variable}0 %1 is used in an inline function with "
   "external linkage">, InGroup<StaticInInline>;
 def ext_internal_in_extern_inline_quiet : Extension<
   "static %select{function|variable}0 %1 is used in an inline function with "
   "external linkage">, InGroup<StaticInInline>;
 def warn_static_local_in_extern_inline : Warning<
   "non-constant static local variable in inline function may be different "
   "in different files">, InGroup<StaticLocalInInline>;

clang/lib/Sema/SemaDeclAttr.cpp

case ParsedAttr::AT_SwiftErrorResult:
     handleParameterABIAttr(S, D, AL, ParameterABI::SwiftErrorResult);
     break;
   case ParsedAttr::AT_SwiftIndirectResult:
     handleParameterABIAttr(S, D, AL, ParameterABI::SwiftIndirectResult);
     break;
   case ParsedAttr::AT_InternalLinkage:
     handleInternalLinkageAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_NoExternTemplate:
+    handleSimpleAttribute<NoExternTemplateAttr>(S, D, AL);
+    break;
   case ParsedAttr::AT_LTOVisibilityPublic:
     handleSimpleAttribute<LTOVisibilityPublicAttr>(S, D, AL);
     break;
 
   // Microsoft attributes:
   case ParsedAttr::AT_EmptyBases:
     handleSimpleAttribute<EmptyBasesAttr>(S, D, AL);
     break;

clang/lib/Sema/SemaTemplateInstantiate.cpp

Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
   // things, in case we have an explicit instantiation definition in a PCM, a
   // module, or preamble, and the declaration is in an imported AST.
   assert(
       (TSK == TSK_ExplicitInstantiationDefinition ||
        TSK == TSK_ExplicitInstantiationDeclaration ||
        (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&
       "Unexpected template specialization kind!");
   for (auto *D : Instantiation->decls()) {
+    // Exclude all declarations marked with no_extern_template from the instantiation.
+    if (D->hasAttr<NoExternTemplateAttr>()) {
+      continue;
+    }
+
     bool SuppressNew = false;
     if (auto *Function = dyn_cast<FunctionDecl>(D)) {
       if (FunctionDecl *Pattern
             = Function->getInstantiatedFromMemberFunction()) {
         MemberSpecializationInfo *MSInfo
           = Function->getMemberSpecializationInfo();
         assert(MSInfo && "No member specialization information?");
         if (MSInfo->getTemplateSpecializationKind()
                                                  == TSK_ExplicitSpecialization)
           continue;
 
         if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
                                                    Function,
                                         MSInfo->getTemplateSpecializationKind(),
                                               MSInfo->getPointOfInstantiation(),
                                                    SuppressNew) ||

clang/test/CodeGenCXX/attribute_no_extern_template.explicit_instantiation.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O0 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O1 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O2 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O3 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -Os -o - %s | FileCheck %s
+
+// Test that explicit instantiations do not instantiate entities
+// marked with no_extern_template.
+
+#define NO_EXTERN_TEMPLATE __attribute__((no_extern_template))
+
+template <class T>
+struct Foo {
+  // CHECK-NOT: define weak_odr void @_ZN3FooIiE27non_static_member_function1Ev
+  NO_EXTERN_TEMPLATE
+  inline void non_static_member_function1();
+
+  // CHECK-NOT: define weak_odr void @_ZN3FooIiE27non_static_member_function2Ev
+  NO_EXTERN_TEMPLATE
+  void non_static_member_function2();
+
+  // CHECK-NOT: define weak_odr void @_ZN3FooIiE23static_member_function1Ev
+  NO_EXTERN_TEMPLATE
+  static inline void static_member_function1();
+
+  // CHECK-NOT: define weak_odr void @_ZN3FooIiE23static_member_function2Ev
+  NO_EXTERN_TEMPLATE
+  static void static_member_function2();
+
+  // CHECK-NOT: @_ZN3FooIiE18static_data_memberE = weak_odr global
+  NO_EXTERN_TEMPLATE
+  static int static_data_member;
+
+  struct NO_EXTERN_TEMPLATE member_class {
+    // CHECK-NOT: define weak_odr void @_ZN3FooIiE12member_class26non_static_member_functionEv
+    static void non_static_member_function() { }
+  };
+};
+
+template <class T>
+inline void Foo<T>::non_static_member_function1() { }
+
+template <class T>
+void Foo<T>::non_static_member_function2() { }
+
+template <class T>
+inline void Foo<T>::static_member_function1() { }
+
+template <class T>
+void Foo<T>::static_member_function2() { }
+
+template <class T>
+int Foo<T>::static_data_member = 0;
+
+template struct Foo<int>;

clang/test/CodeGenCXX/attribute_no_extern_template.extern_declaration.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O0 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O1 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O2 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O3 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -Os -o - %s | FileCheck %s
+
+// Test that we do not assume that entities marked with no_extern_template are
+// instantiated in another TU when an extern template declaration is present.
+
+template <class T>
+struct Foo {
+  // Non-static member functions
+  __attribute__((no_extern_template))
+  inline void non_static_member_function1();
+  __attribute__((no_extern_template))
+  void non_static_member_function2();
+
+  // Static member functions
+  __attribute__((no_extern_template))
+  static inline void static_member_function1();
+  __attribute__((no_extern_template))
+  static void static_member_function2();
+
+  // Static data members
+  __attribute__((no_extern_template))
+  static int static_data_member;
+
+  // Member classes
+  struct __attribute__((no_extern_template)) member_class {
+    static void non_static_member_function() { }
+  };
+};
+
+template <class T>
+inline void Foo<T>::non_static_member_function1() { }
+template <class T>
+void Foo<T>::non_static_member_function2() { }
+
+template <class T>
+inline void Foo<T>::static_member_function1() { }
+template <class T>
+void Foo<T>::static_member_function2() { }
+
+template <class T>
+int Foo<T>::static_data_member = 0;
+
+extern template struct Foo<int>;
+
+void use() {
+  Foo<int> f;
+
+  // An inline non-static member function marked as no_extern_template is not
+  // part of the extern template declaration, so no external call must be
+  // emitted.
+  // CHECK-NOT: declare void @_ZN3FooIiE5non_static_member_function1Ev
+  f.non_static_member_function1();
+
+  // A non-inline non-static member function marked as no_extern_template is
+  // not part of the extern template declaration, so no external call must
+  // be emitted.
+  // CHECK-NOT: declare void @_ZN3FooIiE5non_static_member_function2Ev
+  f.non_static_member_function2();
+
+  // An inline static member function marked as no_extern_template is not
+  // part of the extern template declaration, so no external call must
+  // be emitted.
+  // CHECK-NOT: declare void @_ZN3FooIiE5static_member_function1Ev
+  Foo<int>::static_member_function1();
+
+  // A non-inline static member function marked as no_extern_template is not
+  // part of the extern template declaration, so no external call must
+  // be emitted.
+  // CHECK-NOT: declare void @_ZN3FooIiE5static_member_function2Ev
+  Foo<int>::static_member_function2();
+
+  // A static data member marked as no_extern_template is not part of the
+  // extern template declaration, so no external reference must be emitted.
+  // TODO: how to check that?
+  int& odr_use = Foo<int>::static_data_member;
+
+  // A member class marked as no_extern_template is not part of the extern
+  // template declaration (it is not recursively instantiated), so no external
+  // call to its member functions must be emitted.
+  // TODO: How to best check that?
+  Foo<int>::member_class::static_member_function();
+}
+
+// /Users/ldionne/work/clang-attribute/build/bin/clang-8 -cc1 -std=c++11 -triple x86_64-apple-macosx10.14.0 -emit-llvm -stdlib=libc++ -x c++ /Users/ldionne/work/clang-attribute/clang/test/CodeGenCXX/attribute_no_extern_template.cpp -o - | ./build/bin/FileCheck /Users/ldionne/work/clang-attribute/clang/test/CodeGenCXX/attribute_no_extern_template.cpp

clang/test/CodeGenCXX/attribute_no_extern_template.merge_redeclarations.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O0 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O1 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O2 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -O3 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -Os -o - %s | FileCheck %s
+
+// Test that we properly merge the no_extern_template attribute on
+// redeclarations.
+
+template <class T>
+struct Foo {
+  // Declaration without the attribute, definition with the attribute.
+  void func1();
+
+  // Declaration without the attribute, redeclaration without the attribute,
+  // and then definition with the attribute.
+  void func2();
+
+  // Declaration without the attribute, redeclaration with the attribute,
+  // and then definition without the attribute.
+  void func3();
+
+  // Declaration without the attribute, redeclaration with the attribute,
+  // and then definition with the attribute.
+  void func4();
+
+  // Declaration with the attribute, definition without the attribute.
+  __attribute__((no_extern_template)) void func5();
+
+  // Declaration with the attribute, definition with the attribute.
+  __attribute__((no_extern_template)) void func6();
+
+  // Declaration with the attribute, redeclaration without the attribute, and
+  // then definition with the attribute.
+  __attribute__((no_extern_template)) void func7();
+
+  // Declaration with the attribute, redeclaration with the attribute, and
+  // then definition without the attribute.
+  __attribute__((no_extern_template)) void func8();
+};
+
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func1() { }
+
+template <class T>                                     void Foo<T>::func2();
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func2() { }
+
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func3();
+template <class T>                                     void Foo<T>::func3() { }
+
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func4();
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func4() { }
+
+template <class T>                                     void Foo<T>::func5() { }
+
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func6() { }
+
+template <class T>                                     void Foo<T>::func7();
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func7() { }
+
+template <class T> __attribute__((no_extern_template)) void Foo<T>::func8();
+template <class T>                                     void Foo<T>::func8() { }
+
+template struct Foo<int>;
+
+void use() {
+  Foo<int> f;
+
+  // TODO: How to check that?
+  f.func1();
+
+  // TODO: How to check that?
+  f.func2();
+
+  // TODO: How to check that?
+  f.func3();
+
+  // TODO: How to check that?
+  f.func4();
+
+  // TODO: How to check that?
+  f.func5();
+
+  // TODO: How to check that?
+  f.func6();
+
+  // TODO: How to check that?
+  f.func7();
+
+  // TODO: How to check that?
+  f.func8();
+}

clang/test/SemaCXX/attr-no_extern_template.diagnose_when_undefined.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test that a diagnostic is emitted when an entity marked with no_extern_template
+// is not defined in the current TU but an extern template declaration for the
+// enclosing class exists. Since the entity is not defined, we should normally
+// emit a reference to the externally instantiated entity. However, since that
+// entity has been marked with no_extern_template, any extern template
+// instantiation will not provide that entity. Since this pattern is
+// always an error, we diagnose it.
+
+template <class T>
+struct Foo {
+  // Non-static member functions
+  __attribute__((no_extern_template))
+  void non_static_member_function();
+
+  // Static member functions
+  __attribute__((no_extern_template))
+  static void static_member_function();
+
+  // Static data members
+  __attribute__((no_extern_template))
+  static int static_data_member;
+
+  // Member classes
+  struct __attribute__((no_extern_template)) member_class {
+    static void static_member_function();
+  };
+};
+
+extern template struct Foo<int>;
+
+void use() {
+  Foo<int> f;
+
+  f.non_static_member_function(); // TODO: expect failure
+  Foo<int>::static_member_function(); // TODO: expect failure
+  int& odr_use = Foo<int>::static_data_member; // TODO: expect failure
+  Foo<int>::member_class::static_member_function(); // TODO: expect failure
+}

clang/test/SemaCXX/attr-no_extern_template.valid_entities.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test that we diagnose the use of the no_extern_template attribute on
+// entities that are not:
+// - static/non-static member functions of a class template
+// - static data member of a class template
+// - member class of a class template
+
+void function() __attribute__((no_extern_template));
+// expected-warning{{'no_extern_template' attribute only applies to static and non-static member functions of class templates, static data members of class templates and member classes of class templates}}
+
+int variable __attribute__((no_extern_template));
+// expected-warning{{'no_extern_template' attribute only applies to}}
+
+struct __attribute__((no_extern_template)) class_type { };
+// expected-warning{{'no_extern_template' attribute only applies to}}
+
+struct A {
+  int x __attribute__((no_extern_template)); // expected-warning{{'no_extern_template' attribute only applies to}}
+};
+
+enum struct __attribute__((no_extern_template)) E { }; // expected-warning{{'no_extern_template' attribute only applies to}}
+
+namespace Z __attribute__((no_extern_template)) { } // expected-warning{{'no_extern_template' attribute only applies to}}
+
+void g(int a [[clang::no_extern_template]]) { // expected-warning{{'no_extern_template' attribute only applies to}}
+  int x [[clang::no_extern_template]]; // expected-warning{{'no_extern_template' attribute only applies to}}
+  static int y [[clang::no_extern_template]]; // expected-warning{{'no_extern_template' attribute only applies to}}
+}
+
+__attribute__((no_extern_template("foo"))) int h() { } // expected-error{{'no_extern_template' attribute takes no arguments}}