Implement __attribute__((unique_instantiation))

[loladiro]

Summary

This implements a proposal by Doug Gregor on cfe-dev a couple of years ago, to allow the compiler to emit strong symbols for explicit template instantiations. Doug's spec, which I have tried to follow can be found here: http://lists.llvm.org/pipermail/cfe-dev/attachments/20111203/5e1c6c35/attachment.html. I usually work over in LLVM-land and have only contributed the occasional bug fix to clang, so please let me know how this patch can be improved. I'm also not fully done testing it yet (only did so on the toy example I included as a test case), but I wanted to get this out there to get feedback.

[aaron.ballman]

include/clang/Basic/Attr.td

1493

This is not a GCC attribute, so it should not be spelled as such. Since this only applies to C++ code, I would recommend a C++11 spelling (in the clang namespace). If you think this is something C++03 and earlier code would really benefit from, then you could also add a GNU-style spelling.

1495

Please, no undocumented attributes.

include/clang/Basic/DiagnosticSemaKinds.td

2533

Would this make more sense as an option in warn_attribute_wrong_decl_type instead? (there's an err_ version as well if you wish to keep this an error).

Also, please ensure that the attribute is quoted in the diagnostic -- it makes things less confusing for the user.

lib/AST/ASTContext.cpp

8289

I think this would be easier to read (and not have to hoist a declaration out of the switch) as:

if (const auto *CTSD = dyn_cast<>()) {
  if (CTSD->hasAttr<>())
    return GVA_StrongExternal;
}
return GVA_StrongODR;

8393

Similar suggestion here.

lib/Sema/SemaDeclAttr.cpp

4755

The declaration does not need to be hoisted here.

4759

Why is this required as part of the feature design? It seems restrictive.

4766

Is this something that can be handled by mergeDeclAttribute()? I'm not certain how that interplays with templates specifically, but usually we do this sort of logic within a Sema::mergeFooAttr() function.

[loladiro]

Thanks for the quick review.

include/clang/Basic/Attr.td

1493

No, this is C++11 only. Will change the spelling.

1495

Will document.

include/clang/Basic/DiagnosticSemaKinds.td

2533

Ok, so should I add an "explicit template instantiations" option to that err?

lib/AST/ASTContext.cpp

8289

Ok.

lib/Sema/SemaDeclAttr.cpp

4759

This was part of Doug's original Spec, so I implemented it:

A unique explicit instantiation definition shall follow an explicit
instantiation declaration of the same entity. [Note: this
requirement encourages a programming style that uses unique explicit
instantiation declarations (typically in a header) to suppress
implicit instantiations of a template or its members, so that the
unique explicit instantiation definition of that template or its members
is unique. - end note]

I think that makes a decent amount of sense, since you really want to avoid the case where some translation units don't see the extern template declaration.

4766

Hmm, I'm not sure, the goal of this is to ensure that all declarations and definitions of this extern template have the attribute set. It's not really merging per se. Though I suppose it could be made to fit in that framework.

[loladiro]

include/clang/Basic/Attr.td

1493

It doesn't appear like the grammar allows attributes to be specified on explicit template definitions. I'll change the spelling to GNU:

error:
      an attribute list cannot appear here
template struct foo<int> [[clang::unique_instantiation]];
                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                [[clang::unique_instantiation]]
error:
      an attribute list cannot appear here
template struct [[clang::unique_instantiation]] foo<int>;
                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error:
      an attribute list cannot appear here
template [[clang::unique_instantiation]] struct foo<int>;
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error:
      an attribute list cannot appear here
[[clang::unique_instantiation]] template struct foo<int>;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 error generated.
FileCheck error: '-' is empty.

[loladiro]

Address review comments. I had to add a special case to checkNewAttributesAfterDef if we want to use attribute merging for explicit template instantiations, because the Microsoft ABI allows adding dll attributes to the explicit template definition, but not the declaration (which clang considers to be the record's definition).

[loladiro]

Thoughts on allowing this attribute to be specified on the templated class itself, with the intention of never allowing any implicit instantiation? As an example, consider SymbolTableListTraits in LLVM. It can only ever be used as an explicit instantiation (because the full implementation is not available).

[loladiro]

Rebased, added support for unique_instantiation on explicit function templates and fix the case where one record is embedded in another and the outer is explicitly instantiated. Add testcases for all of these.

[loladiro]

Also set the correct linkage on vtables of classes with the new attribute.

[loladiro]

Ok, I have tested this more extensively now. I'm happy with the results. Here's a patch that applies this to LLVM for example: https://gist.github.com/Keno/79b08a4b187c4d950dd0

Before:

$llvm-objdump -weak-bind libLLVM-3.8svn.dylib | wc -l
     300

After:

$llvm-objdump -weak-bind libLLVM-3.8svn.dylib | wc -l
     15

with none of those being LLVM symbols.

[aaron.ballman]

lib/CodeGen/CGVTables.cpp

746

Looks like some debugging code accidentally made it in.

lib/Sema/SemaDecl.cpp

2191

This function has some formatting issues. Also, I feel like some of the code duplication could be removed.

if (old == new)
  return;

Loc = Old->hasAttr ? new->getLocStart() : new->getAttr->getLocation();
S.Diag(Loc, diag::blah);
S.Diag(Old->getLocStart(0, blah);

2310

Isn't this a bit broad? I do agree that we don't want to give incorrect warnings, but it seems like this may inadvertently silence correct warnings as well. If my gut feeling is wrong (which it might be), it would be good to have some test cases confirming that this doesn't silence correct diagnostics.

lib/Sema/SemaDeclAttr.cpp

4773

The formatting of this line seems a bit weird -- did clang-format do this?

lib/Sema/SemaTemplate.cpp

7923

Instead of hasAttr<> followed by getAttr<>, better to just call getAttr<> and handle null.

7936

Same comment here.

7945

Formatting; I would recommend running clang-format over the patch to catch these sort of things.

[aaron.ballman]

include/clang/Basic/Attr.td

1494

This one should be handled in ClangAttrEmitter.cpp; I can see it being used far more frequently than ExpectedExplicitInstantiation, and all the machinery should already be in place to handle it (in CalculateDiagnostic()).

include/clang/Basic/AttrDocs.td

1646

In the unlikely event the user gets this wrong (lol), is there a way to diagnose this on the backend? The wording here makes it sound like it's possible for this to cause silent miscompiles, which would be unfortunate.

[loladiro]

include/clang/Basic/AttrDocs.td

1646

I don't think there is anything that can be really done here. I believe the static linker will link this just fine (there'll be one weak and one strong symbol). The difficulty of course arises with dynamic linkers that won't bother looking for any weak symbols to merge with (at least the OS X one doesn't). I suppose it's not really that different from missing a weak attribute on some declarations but not others.

lib/CodeGen/CGVTables.cpp

746

Thanks!

lib/Sema/SemaDecl.cpp

2310

As far as I know, this is only called from mergeDeclAttributes, which didn't use to be called on these before this patch. I also don't think any attributes but dllexport or unique_instantiation apply to these declarations and those two both need special processing.

[loladiro]

Address review comments and clang-format.

[aaron.ballman]

include/clang/Basic/AttrDocs.td

1646

I don't think there is anything that can be really done here.

That's unfortunate, but I think you may be right. Blech.

include/clang/Basic/DiagnosticSemaKinds.td

2534

Please quote 'unique_instantiation' in the diagnostic (here and in the subsequent uses).

Instead of "something", let's use "a declaration"?

"a explicit template" should be "an explicit template".

Also, diagnostics are not complete sentences, so should not be capitalized or end with a full stop.

Actually, how about this for a new wording:

"'unique_instantiation' attribute only applies to an explicit template declaration or instantiation"

2538

Should say: the 'unique_instantiation' attribute.

Also, I'm not keen on "a particular" as it's very non-specific.

I wonder if we need err_unique_instantiation_no_declaration and err_unique_instantiation_not_previous to be separate diagnostics? Aren't they both effectively saying,

"a 'unique_instantiation' attribute must be specified for all declarations and definitions of the explicit template instantiation"

lib/AST/ASTContext.cpp

8261

Elide braces

lib/Sema/SemaDecl.cpp

2198

hasAttr<> followed by getAttr<> that can be simplified.

2310

As far as I know, this is only called from mergeDeclAttributes, which didn't use to be called on these before this patch. I also don't think any attributes but dllexport or unique_instantiation apply to these declarations and those two both need special processing.

Okay, thanks!

lib/Sema/SemaTemplate.cpp

7942

Elide braces

[majnemer]

include/clang/Basic/Attr.td

1494

What about variable templates?

lib/Sema/SemaDecl.cpp

2311

Capital letters for variable names.

test/CodeGenCXX/unique-instantiation.cpp

2

Is -O0 needed here?

[loladiro]

include/clang/Basic/Attr.td

1494

I hadn't tried before, but looking at this, I'd say they're broken in clang anyway and I'm gonna say fixing that is outside the scope of this revision:

$ cat test.cpp
template <typename T> T n;
extern template int n<int>;
template int n<int>;

int main() {
    return n<int>;
}
$ ./usr/bin/clang++ -std=c++14 -c test.cpp
$ nm test.o
0000000000000000 T main
U _Z1nIiE
$ nm test.o.gcc6
[snip]
00000000060098c u _Z1nIiE

include/clang/Basic/DiagnosticSemaKinds.td

2538

They are checking for two different conditions in the spec. One requires that all explicit template instantiations with this attribute have a declaration, the other that every declaration/definition has the attribute.

test/CodeGenCXX/unique-instantiation.cpp

2

No, removing.

[loladiro]

Address review comments.

[majnemer]

include/clang/Basic/Attr.td

1494

They work ok, clang just thinks that it's a declaration of a variable template. Try this:

template <typename T> T n = T();
extern template int n<int>;
template int n<int>;

[loladiro]

include/clang/Basic/Attr.td

1494

I see. I'll look into adding support for it. Can you explain why my example doesn't work? GCC seems to allow this.

[aaron.ballman]

include/clang/Basic/DiagnosticSemaKinds.td

2538

They are checking for two different conditions in the spec. One requires that all explicit template instantiations with this attribute have a declaration, the other that every declaration/definition has the attribute.

Okay, I see now what this diagnostic is attempting to convey. I think it should read:

def err_unique_instantiation_no_declaration : Error<
  "'unique_instantiation' attribute on an explicit instantiation requires a previous explicit instantiation declaration">;

test/SemaCXX/unique-instantiations.cpp

6

Please spell the entire diagnostic out in expected-error (applies to entire file).

24

Missing tests for correct usage of the attribute. Missing tests of the attribute diagnosing when given arguments.

[loladiro]

include/clang/Basic/Attr.td

1494

Bump on the question of differences to GCC here.

include/clang/Basic/DiagnosticSemaKinds.td

2538

Sounds good.

test/SemaCXX/unique-instantiations.cpp

24

Isn't the correct usage checked for in the CodeGen tests above?

[loladiro]

Address review feedback regarding diagnostic wording/expand tests to full text of diagnostic.

[aaron.ballman]

Modulo the question you and David are discussing about variable templates (for which I don't have an answer handy), I just have a few small testing nits.

test/SemaCXX/unique-instantiations.cpp

25

Isn't the correct usage checked for in the CodeGen tests above?

It is, but those are just tests for code generation, which are all expected to succeed semantically. We generally expect tests in Sema (and related folders) that demonstrate successful cases as well as failure cases for features.

29

The test with unique_instantiation(16) is sufficient, no need for the "Hello World" test as well.

[loladiro]

Rebased and made the small suggested changes to the test cases.

[loladiro]

Add support for variable templates

[loladiro]

Bump, is there anything else that's needed here?

[aaron.ballman]

LGTM, but please wait for David to sign off before committing.

[majnemer]

include/clang/Basic/AttrDocs.td

1736–1755

Instead of using all-caps for emphasis in "ONE" and "MUST", why not bold the text instead? It would catch the eye a little faster.

include/clang/Basic/DiagnosticSemaKinds.td

2533–2534

I can't seem to see any users of err_unique_instantiation_wrong_decl.

lib/AST/ASTContext.cpp

8283–8286

There are a lot of commas here, making it a little hard to read the justification.

Perhaps something along the lines of:

This translation unit is responsible for emitting a unique instantiation of this function regardless of whether or not the function is marked inline.

lib/CodeGen/CGVTables.cpp

744–747

What if the key function is not contained within a record which is marked as UniqueInstantiationAttr but the key function itself is marked UniqueInstantiationAttr?

[loladiro]

include/clang/Basic/AttrDocs.td

1736–1755

Sure! I assume, this follows standard RST conventions where ** is bold?

include/clang/Basic/DiagnosticSemaKinds.td

2533–2534

Yes, it was replaced by adding a case to err_attribute_wrong_decl_type above. Will remove.

lib/AST/ASTContext.cpp

8283–8286

Sounds good.

lib/CodeGen/CGVTables.cpp

744–747

I don't know, I'd be inclined to say the unique instantiation does not apply to the vtable unless it's explicit on the class, but I'd be open to differing opinions.

[loladiro]

Address stylistic concerns brought up by David

[majnemer]

lib/AST/ASTContext.cpp

8257–8266

Function templates can contain class templates which contain functions. I think this code will return false if the outermost function template is the only one annotated with UniqueInstantiationAttr.

[loladiro]

lib/AST/ASTContext.cpp

8257–8266

So you're concerned about this case:

template < typename T > auto foo( T x ) {
  class inner {
      T y;
  public:
      virtual ~inner() {}
      inner(T y) : y(y) {}
      T getY() { return y; }
  };
  return inner{x}.getY();
}

extern template __attribute__((unique_instantiation)) auto foo<int>(int);
template __attribute__((unique_instantiation)) auto foo<int>(int);

Right now the inner class's vtable and method is linkonce_odr. If you think it should be strong I'll look into it.

[loladiro]

Address David's concern about inner classes. David also suggested on IRC to propagate
the unique instantiation attribute down rather than walking the context chain to
check for the attribute. I'll try that out, but wanted to put up a known-good version
with all fixed first.

[loladiro]

Propagate unique instantiation attribute to children rather than later trying to look through the DeclContexts to see if we're contained in one that has the attribute.

[loladiro]

@majnemer Do you like the new approach? Is there anything else to be done here?

[loladiro]

Rebased

[loladiro]

Bumping this again.

[loladiro]

I came across a situation again where this would be useful to have. I know this was approved, but looking it looks like I wanted @majnemer to have another look.

[majnemer]

I think this looks good but I'd like @rsmith to take a look.

[loladiro]

Rebased on current master.

[loladiro]

I found a bug in this which I need to fix, but while I'm at it, in doing more testing on this, I came across the following corner case:

template <typename T>
struct static_separate_template {
    typedef T element;
    static T *a_static_field;
};
extern template struct __attribute__((unique_instantiation)) static_separate_template<int>;
template struct __attribute__((unique_instantiation)) static_separate_template<int>;
extern template struct __attribute__((unique_instantiation)) static_separate_template<char>;
template struct __attribute__((unique_instantiation)) static_separate_template<char>;

template <typename T> typename static_separate_template<T>::element *static_separate_template<T>::a_static_field = nullptr;
template int * __attribute__((unique_instantiation)) static_separate_template<int>::a_static_field;
template char * static_separate_template<char>::a_static_field; // expected-error{{'unique_instantiation' attribute must be specified for all declarations and definitions of this explicit template instantiation}}

How should this be handled? I indicated my inclination in the comment, but I'm open to alternative suggestions.

[loladiro]

I meant
template __attribute__((unique_instantiation)) int * static_separate_template<int>::a_static_field;
of course, though we probably need a better diagnostic for the other spelling (which applies the attribute to the static_separate_template<int>). I'll look into adding a diagnostic.

[loladiro]

Fix for the corner case I found and add it as a test.

[rsmith]

I think this attribute is poorly named. Explicit instantiation definitions are *already* required to be globally unique; see [temp.spec]/5.1:

"For a given template and a given set of template-arguments, an explicit instantiation definition shall appear at most once in a program"

The actual meaning of the attribute is that an explicit instantiation declaration will appear before any use that might trigger implicit instantiation. To that end, something like __attribute__((declared_before_all_uses)) might be clearer.

include/clang/Basic/AttrDocs.td

1736–1755

Yes, this documentation allows arbitrary RST markup. But I don't see the need for strong emphasis here.

1740–1742

The primary description of the attribute should specify what it means, not the consequences of that meaning. In this case, the meaning is that the programmer is guaranteeing to the compiler that an explicit instantiation precedes all implicit instantiations, and the consequence is that we can use strong symbols.

include/clang/Basic/DiagnosticSemaKinds.td

2538

This seems like an unnecessarily-strict rule to me. I don't see a reason to disallow:

// in header
extern template struct __attribute__((whatever_its_called)) X<int>;

// in source file
template struct X<int>;

There doesn't appear to be any safety or correctness concern here. In general, it seems like the attribute is only promising that the explicit instantiation declaration precedes any other instantiation, so the only necessary rule would seem to be: if the attribute is present on any explicit instantiation, the first point of instantiation must be an explicit instantiation declaration that has the attribute.

lib/AST/ASTContext.cpp

8329

revert this change

lib/Sema/SemaDecl.cpp

2306–2307

I assume you mean "explicit instantiation" rather than "explicit template" here (2x).

2308–2309

I have no idea what you mean by this. Did you mean "associated with the explicit instantiation declaration" or something like that?

lib/Sema/SemaDeclAttr.cpp

4772

Why is this rule only applied to explicit instantiations of class templates, and not to function or variable templates?

lib/Sema/SemaDeclCXX.cpp

5666–5685 ↗

(On Diff #76256)

I don't think this is the right way to handle this case. Note that an explicit instantiation declaration/definition for a class is only an explicit instantiation of those members that are defined at the point where the explicit instantiation appears. It seems like the most consistent behavior is probably to add the attributes to the defined class members as part of the process of explicitly instantiating them, in InstantiateClassMembers.

lib/Sema/SemaTemplate.cpp

7785–7788

Do we need this to be here as a special case, duplicated for each kind of decl that can have these attributes, rather than handling it using the normal attribute-handling mechanism in SemaDeclAttr? If so, why?

[loladiro]

Thanks for the review! Sorry, it's been a while since I wrote this code, so I'm not fluent in all the details, but I've replied below. I am not particularly partial to the name, so whatever you feel is best is ok with me.

include/clang/Basic/AttrDocs.td

1740–1742

Ok, sounds good.

include/clang/Basic/DiagnosticSemaKinds.td

2538

While I didn't write the rules (just implemented them from the original proposal), I like the requirement from the point of view of making sure that the explicit instantiation declaration doesn't accidentally get deleted. Those declarations are somewhat odd in that they can be deleted without any semantic loss in functionality (just larger code size/more work for the linker) in the absence of this attribute. However, with this attribute, deleting the declaration would cause a subtle, perhaps hard to track down semantic change, so I like requiring people to be explicit.

lib/Sema/SemaDecl.cpp

2308–2309

Yes, I believe that is what I meant. It's been a while since I wrote this code, but I believe that all I'm trying to say here is that explicit instantiation declarations/definitions are allowed to add attributes after a definition, even though that is not normally allowed.

lib/Sema/SemaDeclAttr.cpp

4772

I don't remember precisely, but I believe (at least when I wrote the patch) that those prior explicit instantiation declarations did not leave an AST node that I could check for.

lib/Sema/SemaDeclCXX.cpp

5666–5685 ↗

(On Diff #76256)

Ok, I'll try that.

lib/Sema/SemaTemplate.cpp

7785–7788

IIRC, the problem was that the new attributes get added to the same node, so we lose the information of whether the attribute was present on the previous declaration.

[mehdi_amini]

In D13330#582607, @rsmith wrote:

I think this attribute is poorly named. Explicit instantiation definitions are *already* required to be globally unique; see [temp.spec]/5.1:

"For a given template and a given set of template-arguments, an explicit instantiation definition shall appear at most once in a program"

So what prevents from emitting these as "strong" symbols without any attribute? We should have the guarantee that we have only one such copy in the program.

include/clang/AST/ASTContext.h

public:
   /// ASTContext is destroyed.
   ///
   /// \param Callback A callback function that will be invoked on destruction.
   ///
   /// \param Data Pointer data that will be provided to the callback function
   /// when it is called.
   void AddDeallocation(void (*Callback)(void*), void *Data);
 
+  static bool containedInUniqueInstantiation(const Decl *D);
   GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const;
   GVALinkage GetGVALinkageForVariable(const VarDecl *VD);
 
   /// \brief Determines if the decl can be CodeGen'ed or deserialized from PCH
   /// lazily, only when used; this is only relevant for function or file scoped
   /// var definitions.
   ///
   /// \returns true if the function/var must be CodeGen'ed/deserialized even if

include/clang/Basic/Attr.td

 }
 
 def Weak : InheritableAttr {
   let Spellings = [GCC<"weak">];
   let Subjects = SubjectList<[Var, Function, CXXRecord]>;
   let Documentation = [Undocumented];
 }
 
+def UniqueInstantiation : InheritableAttr {
+  let Spellings = [GNU<"unique_instantiation">];
+  let Subjects = SubjectList<[Function, CXXRecord], ErrorDiag>;
+  let Documentation = [UniqueInstantiationDocs];
+}
+
 def WeakImport : InheritableAttr {
   let Spellings = [GNU<"weak_import">];
   let Documentation = [Undocumented];
 }
 
 def WeakRef : InheritableAttr {
   let Spellings = [GCC<"weakref">];
   // A WeakRef that has an argument is treated as being an AliasAttr

include/clang/Basic/AttrDocs.td

 
 However, it doesn't prevent tail-call optimization in this case:
 
   .. code-block: c
 
     int __attribute__((not_tail_called)) foo1(int);
 
     int foo2(int a) {
       int (*fn)(int) = &foo1;
 
       // not_tail_called has no effect on an indirect call even if the call can be
       // resolved at compile time.
       return (*fn)(a);
     }
 
 Marking virtual functions as ``not_tail_called`` is an error:
 
.. code-block: c++
     };
 
     class Derived1 : public Base {
     public:
       int foo1() override {
         return callee(); // This call is tail-call optimized.
       }
     };
+  }];
+}
+
+def UniqueInstantiationDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The ``unique_instantiation`` attribute may only be applied to explicit template
+declarations and definitions, i.e. expressions of the form:
+
+  .. code-block:: c++
+
+    // Explicit template declaration (usually found in a .h file)
+    extern template struct __attribute__((unique_instantiation)) my_template<int>;
+
+    // Explicit template definition (in exactly ONE .cpp file)
+    template struct __attribute__((unique_instantiation)) my_template<int>;
+
+
+When the unique_instantiation attribute is specified on an explicit template
+instantiation, the compiler is given license to emit strong symbols for
+this specific explicit template instantiation.
+
+If the attribute is present on one such definition or declaration for a given
+entity, it must be present on all.
+
+Note that to ensure correct execution the user MUST make certain that no
+other translation unit has an implicit instantiation of the same entity. In
+particular this means that any usage of the entity has to be preceeded by an
+appropriate explicit template declaration or definition.
 
+It is thus recommended that explicit template declarations are placed in headers
+to suppress any potential implicit instantiation of the entity. In order to
+encourage this programming style, any explicit template definition with this
+attribute MUST be preceeded by an appropriate declaration.
   }];
 }

include/clang/Basic/DiagnosticSemaKinds.td

def warn_attribute_wrong_decl_type : Warning<
   "variables, functions and labels|fields and global variables|structs|"
   "variables and typedefs|thread-local variables|"
   "variables and fields|variables, data members and tag types|"
   "types and namespaces|Objective-C interfaces|methods and properties|"
   "struct or union|struct, union or class|types|"
   "Objective-C instance methods|init methods of interface or class extension declarations|"
   "variables, functions and classes|Objective-C protocols|"
   "functions and global variables|structs, unions, and typedefs|structs and typedefs|"
-  "interface or protocol declarations|kernel functions|non-K&R-style functions}1">,
+  "interface or protocol declarations|kernel functions|non-K&R-style functions|"
+  "explicit template declarations or definitions|functions and classes}1">,
   InGroup<IgnoredAttributes>;
 def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>;
 def warn_type_attribute_wrong_type : Warning<
   "'%0' only applies to %select{function|pointer|"
   "Objective-C object or block pointer}1 types; type here is %2">,
   InGroup<IgnoredAttributes>;
 def warn_incomplete_encoded_type : Warning<
   "encoding of %0 type is incomplete because %1 component has unknown encoding">,

 def warn_thread_attribute_decl_not_pointer : Warning<
   "%0 only applies to pointer types; type here is %1">,
   InGroup<ThreadSafetyAttributes>, DefaultIgnore;
 def err_attribute_argument_out_of_range : Error<
   "%0 attribute parameter %1 is out of bounds: "
   "%plural{0:no parameters to index into|"
   "1:can only be 1, since there is one parameter|"
   ":must be between 1 and %2}2">;
+def err_unique_instantiation_wrong_decl : Error<
+  "'unique_instantiation' attribute only applies to an explicit template declaration or instantiation">;
+def err_unique_instantiation_no_declaration : Error<
+  "'unique_instantiation' attribute on an explicit instantiation requires a previous explicit instantiation declaration">;
+def err_unique_instantiation_not_previous : Error<
+  "'unique_instantiation' attribute must be specified for all declarations and definitions of this explicit template instantiation">;
 
 // Thread Safety Analysis   
 def warn_unlock_but_no_lock : Warning<"releasing %0 '%1' that was not held">,
   InGroup<ThreadSafetyAnalysis>, DefaultIgnore;
 def warn_unlock_kind_mismatch : Warning<
   "releasing %0 '%1' using %select{shared|exclusive}2 access, expected "
   "%select{shared|exclusive}3 access">,
   InGroup<ThreadSafetyAnalysis>, DefaultIgnore;

include/clang/Sema/AttributeList.h

enum AttributeDeclKind {
   ExpectedObjCInterfaceDeclInitMethod,
   ExpectedFunctionVariableOrClass,
   ExpectedObjectiveCProtocol,
   ExpectedFunctionGlobalVarMethodOrProperty,
   ExpectedStructOrUnionOrTypedef,
   ExpectedStructOrTypedef,
   ExpectedObjectiveCInterfaceOrProtocol,
   ExpectedKernelFunction,
-  ExpectedFunctionWithProtoType
+  ExpectedFunctionWithProtoType,
+  ExpectedExplicitInstantiation,
+  ExpectedFunctionOrClass
 };
 
 }  // end namespace clang
 
 #endif

lib/AST/ASTContext.cpp

QualType ASTContext::GetBuiltinType(unsigned Id,
 
   FunctionProtoType::ExtProtoInfo EPI;
   EPI.ExtInfo = EI;
   EPI.Variadic = Variadic;
 
   return getFunctionType(ResType, ArgTypes, EPI);
 }
 
+bool ASTContext::containedInUniqueInstantiation(const Decl *D) {
+  const RecordDecl *RD;
+  while ((RD = dyn_cast<RecordDecl>(D->getDeclContext()))) {
+    auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
+    if (CTSD && CTSD->hasAttr<UniqueInstantiationAttr>())
+      return true;
+    D = RD;
+  }
+  return false;
+}
+
 static GVALinkage basicGVALinkageForFunction(const ASTContext &Context,
                                              const FunctionDecl *FD) {
   if (!FD->isExternallyVisible())
     return GVA_Internal;
 
   GVALinkage External = GVA_StrongExternal;
   switch (FD->getTemplateSpecializationKind()) {
   case TSK_Undeclared:
   case TSK_ExplicitSpecialization:
     External = GVA_StrongExternal;
     break;
 
   case TSK_ExplicitInstantiationDefinition:
+    if (FD->hasAttr<UniqueInstantiationAttr>() ||
+        Context.containedInUniqueInstantiation(FD)) {
+      // We return GVA_StrongExternal here, instead of going through the logic
+      // below, because even if the definition is available inline, since the
+      // source specified  an explicit template instantiation, we want to make
+      // the symbol available.
+      return GVA_StrongExternal;
+    }
     return GVA_StrongODR;
 
   // C++11 [temp.explicit]p10:
   //   [ Note: The intent is that an inline function that is the subject of
   //   an explicit instantiation declaration will still be implicitly
   //   instantiated when used so that the body can be considered for
   //   inlining, but that no out-of-line copy of the inline function would be
   //   generated in the translation unit. -- end note ]
   case TSK_ExplicitInstantiationDeclaration:
static GVALinkage basicGVALinkageForFunction(const ASTContext &Context,
   }
 
   // Functions specified with extern and inline in -fms-compatibility mode
   // forcibly get emitted.  While the body of the function cannot be later
   // replaced, the function definition cannot be discarded.
   if (FD->isMSExternInline())
     return GVA_StrongODR;
 
   return GVA_DiscardableODR;
 }
 
 static GVALinkage adjustGVALinkageForAttributes(GVALinkage L, const Decl *D) {
   // See http://msdn.microsoft.com/en-us/library/xa0d9ste.aspx
   // dllexport/dllimport on inline functions.
   if (D->hasAttr<DLLImportAttr>()) {
     if (L == GVA_DiscardableODR || L == GVA_StrongODR)
       return GVA_AvailableExternally;
static GVALinkage basicGVALinkageForVariable(const ASTContext &Context,
 
   case TSK_ExplicitSpecialization:
     return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
                    VD->isStaticDataMember()
                ? GVA_StrongODR
                : GVA_StrongExternal;
 
   case TSK_ExplicitInstantiationDefinition:
+    if (Context.containedInUniqueInstantiation(VD))
+      return GVA_StrongExternal;
     return GVA_StrongODR;
 
   case TSK_ExplicitInstantiationDeclaration:
     return GVA_AvailableExternally;
 
   case TSK_ImplicitInstantiation:
     return GVA_DiscardableODR;
   }
 

lib/CodeGen/CGVTables.cpp

switch (keyFunction->getTemplateSpecializationKind()) {
         return llvm::GlobalVariable::ExternalLinkage;
 
       case TSK_ImplicitInstantiation:
         return !Context.getLangOpts().AppleKext ?
                  llvm::GlobalVariable::LinkOnceODRLinkage :
                  llvm::Function::InternalLinkage;
 
       case TSK_ExplicitInstantiationDefinition:
+        // If the key function has strong linkage (say due to
+        // UniqueInstantiationAttr), the VTable should too.
+        if (Context.containedInUniqueInstantiation(keyFunction))
+          return llvm::GlobalVariable::ExternalLinkage;
         return !Context.getLangOpts().AppleKext ?
                  llvm::GlobalVariable::WeakODRLinkage :
                  llvm::Function::InternalLinkage;
   
       case TSK_ExplicitInstantiationDeclaration:
         llvm_unreachable("Should not have been asked to emit this");
     }
   }
 
   // -fapple-kext mode does not support weak linkage, so we must use
   // internal linkage.
   if (Context.getLangOpts().AppleKext)
     return llvm::Function::InternalLinkage;
 
   llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage =
       llvm::GlobalValue::LinkOnceODRLinkage;
   llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage =
       llvm::GlobalValue::WeakODRLinkage;
-  if (RD->hasAttr<DLLExportAttr>()) {
+  if (RD->hasAttr<UniqueInstantiationAttr>() ||
+      Context.containedInUniqueInstantiation(RD)) {
+    NonDiscardableODRLinkage = llvm::GlobalVariable::ExternalLinkage;
+  } else if (RD->hasAttr<DLLExportAttr>()) {
     // Cannot discard exported vtables.
     DiscardableODRLinkage = NonDiscardableODRLinkage;
   } else if (RD->hasAttr<DLLImportAttr>()) {
     // Imported vtables are available externally.
     DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
     NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
   }
 

lib/Sema/SemaDecl.cpp

if (OldAlignasAttr && !NewAlignasAttr &&
     Clone->setInherited(true);
     New->addAttr(Clone);
     AnyAdded = true;
   }
 
   return AnyAdded;
 }
 
+static void checkUniqueInstantiationAttrs(Sema &S, const Decl *New,
+                                          const Decl *Old) {
+  Attr *NewAttr = New->getAttr<UniqueInstantiationAttr>();
+
+  // Check that any previous definitions also had this attribute set.
+  if (Old->hasAttr<UniqueInstantiationAttr>() == (NewAttr != nullptr))
+    return;
+
+  SourceLocation NewLoc = NewAttr ? NewAttr->getLocation() : New->getLocStart();
+  S.Diag(NewLoc, diag::err_unique_instantiation_not_previous);
+  S.Diag(Old->getLocStart(), diag::note_previous_explicit_instantiation);
+}
+
 static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
                                const InheritableAttr *Attr,
                                Sema::AvailabilityMergeKind AMK) {
   InheritableAttr *NewAttr = nullptr;
   unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
   if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
     NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
                                       AA->getIntroduced(), AA->getDeprecated(),

 }
 
 /// checkNewAttributesAfterDef - If we already have a definition, check that
 /// there are no new attributes in this declaration.
 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
   if (!New->hasAttrs())
     return;
 
+  // Explicit template instantiations need special handling because in certain
+  // ABIs explicit template definitions may add attributes over explicit
+  // template declarations. In clang getDefinition() will get the
+  // ClassTemplateSpecializationDecl associated with the class template
+  // declaration, so we'd give incorrect warnings here.
+  if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(New)) {
+    TemplateSpecializationKind Kind = CTSD->getSpecializationKind();
+    if (Kind == TSK_ExplicitInstantiationDeclaration ||
+        Kind == TSK_ExplicitInstantiationDefinition)
+      return;
+  }
+
   const Decl *Def = getDefinition(Old);
   if (!Def || Def == New)
     return;
 
   AttrVec &NewAttributes = New->getAttrs();
   for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
     const Attr *NewAttribute = NewAttributes[I];
 
void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
   }
 
   if (!Old->hasAttrs() && !New->hasAttrs())
     return;
 
   // attributes declared post-definition are currently ignored
   checkNewAttributesAfterDef(*this, New, Old);
 
+  checkUniqueInstantiationAttrs(*this, New, Old);
+
   if (!Old->hasAttrs())
     return;
 
   bool foundAny = New->hasAttrs();
 
   // Ensure that any moving of objects within the allocated map is done before
   // we process them.
   if (!foundAny) New->setAttrs(AttrVec());

lib/Sema/SemaDeclAttr.cpp

static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D,
   D->addAttr(::new (S.Context)
                  NoSanitizeAttr(Attr.getRange(), S.Context, &SanitizerName, 1,
                                 Attr.getAttributeSpellingListIndex()));
 }
 
 static void handleInternalLinkageAttr(Sema &S, Decl *D,
                                       const AttributeList &Attr) {
   if (InternalLinkageAttr *Internal =
           S.mergeInternalLinkageAttr(D, Attr.getRange(), Attr.getName(),
                                      Attr.getAttributeSpellingListIndex()))
     D->addAttr(Internal);
 }
 
+static void handleUniqueInstantiation(Sema &S, Decl *D,
+                                      const AttributeList &Attr) {
+  if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
+    // If this is an explicit instantiation definition. Check that it was
+    // preceeded by an ExplicitInstantiationDeclaration. Note, this
+    // requirement encourages a programming style that uses unique explicit
+    // instantiation declarations (typically in a header) to suppress
+    // implicit instantiations of a template or its members, so that the
+    // unique explicit instantiation definition of that template or its members
+    // is unique.
+    if (CTSD->getSpecializationKind() == TSK_ExplicitInstantiationDefinition) {
+      if (!CTSD->getPreviousDecl())
+        S.Diag(Attr.getLoc(), diag::err_unique_instantiation_no_declaration);
+    }
+    return handleSimpleAttribute<UniqueInstantiationAttr>(S, D, Attr);
+  } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {
+    if (FD->getTemplateSpecializationKind() ==
+            TSK_ExplicitInstantiationDefinition ||
+        FD->getTemplateSpecializationKind() ==
+            TSK_ExplicitInstantiationDeclaration)
+      return handleSimpleAttribute<UniqueInstantiationAttr>(S, D, Attr);
+  }
+  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
+      << Attr.getName() << ExpectedExplicitInstantiation;
+}
+
 /// Handles semantic checking for features that are common to all attributes,
 /// such as checking whether a parameter was properly specified, or the correct
 /// number of arguments were passed, etc.
 static bool handleCommonAttributeFeatures(Sema &S, Scope *scope, Decl *D,
                                           const AttributeList &Attr) {
   // Several attributes carry different semantics than the parsing requires, so
   // those are opted out of the common handling.
   //
case AttributeList::AT_WarnUnused:
     handleSimpleAttribute<WarnUnusedAttr>(S, D, Attr);
     break;
   case AttributeList::AT_WarnUnusedResult:
     handleWarnUnusedResult(S, D, Attr);
     break;
   case AttributeList::AT_Weak:
     handleSimpleAttribute<WeakAttr>(S, D, Attr);
     break;
+  case AttributeList::AT_UniqueInstantiation:
+    handleUniqueInstantiation(S, D, Attr);
+    break;
   case AttributeList::AT_WeakRef:
     handleWeakRefAttr(S, D, Attr);
     break;
   case AttributeList::AT_WeakImport:
     handleWeakImportAttr(S, D, Attr);
     break;
   case AttributeList::AT_TransparentUnion:
     handleTransparentUnionAttr(S, D, Attr);

lib/Sema/SemaTemplate.cpp

= Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
                                                 TemplateArgs,
                                   Context.getTypeDeclType(Specialization));
   Specialization->setTypeAsWritten(WrittenTy);
 
   // Set source locations for keywords.
   Specialization->setExternLoc(ExternLoc);
   Specialization->setTemplateKeywordLoc(TemplateLoc);
   Specialization->setRBraceLoc(SourceLocation());
+  Specialization->setTemplateSpecializationKind(TSK);
 
   if (Attr)
     ProcessDeclAttributeList(S, Specialization, Attr);
 
+  if (PrevDecl)
+    mergeDeclAttributes(Specialization, PrevDecl);
+
   // Add the explicit instantiation into its lexical context. However,
   // since explicit instantiations are never found by name lookup, we
   // just put it into the declaration context directly.
   Specialization->setLexicalDeclContext(CurContext);
   CurContext->addDecl(Specialization);
 
   // Syntax is now OK, so return if it has no other effect on semantics.
   if (HasNoEffect) {
-    // Set the template specialization kind.
-    Specialization->setTemplateSpecializationKind(TSK);
     return Specialization;
   }
 
   // C++ [temp.explicit]p3:
   //   A definition of a class template or class member template
   //   shall be in scope at the point of the explicit instantiation of
   //   the class template or class member template.
   //
if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
         for (auto &B : Def->bases()) {
           if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
                   B.getType()->getAsCXXRecordDecl()))
             propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getLocStart());
         }
       }
     }
 
-    // Set the template specialization kind. Make sure it is set before
-    // instantiating the members which will trigger ASTConsumer callbacks.
-    Specialization->setTemplateSpecializationKind(TSK);
     InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
-  } else {
-
-    // Set the template specialization kind.
-    Specialization->setTemplateSpecializationKind(TSK);
   }
 
   return Specialization;
 }
 
 // Explicit instantiation of a member class of a class template.
 DeclResult
 Sema::ActOnExplicitInstantiation(Scope *S,
if (!HasNoEffect) {
       Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
       if (PrevTemplate) {
         // Merge attributes.
         if (AttributeList *Attr = D.getDeclSpec().getAttributes().getList())
           ProcessDeclAttributeList(S, Prev, Attr);
       }
       if (TSK == TSK_ExplicitInstantiationDefinition)
         InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
     }
 
     // Check the new variable specialization against the parsed input.
     if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
       Diag(T->getTypeLoc().getLocStart(),
            diag::err_invalid_var_template_spec_type)
           << 0 << PrevTemplate << R << Prev->getType();
       Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
           << 2 << PrevTemplate->getDeclName();
       return true;
     }
 
if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
       return true;
 
     // FIXME: We may still want to build some representation of this
     // explicit specialization.
     if (HasNoEffect)
       return (Decl*) nullptr;
   }
 
+  bool HadDeclaration = Specialization->getTemplateSpecializationKind() ==
+                        TSK_ExplicitInstantiationDeclaration;
+  auto *OldUniqueInstantiation =
+      Specialization->getAttr<UniqueInstantiationAttr>();
+  SourceLocation OldUniqueInstantiationLoc;
+  if (OldUniqueInstantiation) {
+    OldUniqueInstantiationLoc = OldUniqueInstantiation->getLocation();
+    Specialization->dropAttr<UniqueInstantiationAttr>();
+  }
+
   Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
   AttributeList *Attr = D.getDeclSpec().getAttributes().getList();
   if (Attr)
     ProcessDeclAttributeList(S, Specialization, Attr);
 
+  auto *NewUniqueInstantiation =
+      Specialization->getAttr<UniqueInstantiationAttr>();
+  if (NewUniqueInstantiation) {
+    if (TSK == TSK_ExplicitInstantiationDefinition && !HadDeclaration)
+      Diag(NewUniqueInstantiation->getLocation(),
+           diag::err_unique_instantiation_no_declaration);
+    else if (HadDeclaration && !OldUniqueInstantiation)
+      Diag(NewUniqueInstantiation->getLocation(),
+           diag::err_unique_instantiation_not_previous);
+  } else if (OldUniqueInstantiation) {
+    Diag(D.getIdentifierLoc(), diag::err_unique_instantiation_not_previous);
+    Diag(OldUniqueInstantiationLoc, diag::note_previous_explicit_instantiation);
+  }
+
   if (Specialization->isDefined()) {
     // Let the ASTConsumer know that this function has been explicitly
     // instantiated now, and its linkage might have changed.
     Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
   } else if (TSK == TSK_ExplicitInstantiationDefinition)
     InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);
 
   // C++0x [temp.explicit]p2:

test/CodeGenCXX/unique-instantiation.cpp

+// RUN: %clang -std=c++11 -emit-llvm -c -S -o - %s | FileCheck %s
+
+template <typename T>
+struct foo {
+  T x;
+  T getX() { return x; }
+  struct bar {
+    T y;
+    bar(T y) : y(y) {}
+  };
+};
+template <typename T>
+T bar();
+
+// CHECK: define i32 @_ZN3fooIiE4getXEv
+// CHECK: define void @_ZN3fooIiE3barC2Ei
+// CHECK-NOT: define weak_odr i32 @_ZN3fooIiE4getXEv
+// CHECK-NOT: define weak_odr void @_ZN3fooIiE3barC2Ei
+extern template struct __attribute__((unique_instantiation)) foo<int>;
+template struct __attribute__((unique_instantiation)) foo<int>;
+
+extern template __attribute__((unique_instantiation)) int bar<int>();
+
+template <typename T>
+T bar() {
+  return (T)0;
+}
+
+// CHECK: define i32 @_Z3barIiET_v()
+// CHECK-NOT: define weak_odr i32 @_Z3barIiET_v()
+template __attribute__((unique_instantiation)) int bar<int>();
+
+int footest() {
+  auto var = foo<int>{5};
+  auto var2 = foo<int>::bar{5};
+  auto x = bar<int>();
+  return var.getX();
+}

test/SemaCXX/unique-instantiations.cpp

+// RUN: %clang -cc1 -std=c++11 -fsyntax-only -verify %s
+
+// Correct usage
+template <typename T>
+struct foo {};
+extern template struct __attribute__((unique_instantiation)) foo<int>;
+template struct __attribute__((unique_instantiation)) foo<int>;
+
+// Various examples of incorrect usage
+template <typename T>
+struct foo1 {};
+template struct __attribute__((unique_instantiation)) foo1<int>; // expected-error{{'unique_instantiation' attribute on an explicit instantiation requires a previous explicit instantiation declaration}}
+
+template <typename T>
+struct foo2 {};
+extern template struct foo2<int>;                                // expected-note{{previous explicit instantiation is here}}
+template struct __attribute__((unique_instantiation)) foo2<int>; // expected-error{{'unique_instantiation' attribute must be specified for all declarations and definitions of this explicit template instantiation}}
+
+template <typename T>
+struct foo3 {};
+extern template struct __attribute__((unique_instantiation)) foo3<int>; // expected-note{{previous explicit instantiation is here}}
+extern template struct foo3<int>;                                       // expected-error{{'unique_instantiation' attribute must be specified for all declarations and definitions of this explicit template instantiation}}
+
+template <typename T>
+struct __attribute__((unique_instantiation)) foo4 {}; // expected-error{{'unique_instantiation' attribute only applies to explicit template declarations or definitions}}
+
+template <typename T>
+struct foo5 {};
+extern template struct __attribute__((unique_instantiation)) foo5<int>; // expected-note{{previous explicit instantiation is here}}
+template struct foo5<int>;                                              // expected-error{{'unique_instantiation' attribute must be specified for all declarations and definitions of this explicit template instantiation}}
+
+template <typename T>
+struct foo6 {};
+extern template struct  __attribute__((unique_instantiation(16))) foo6<int>;    // expected-error{{'unique_instantiation' attribute takes no arguments}}

utils/TableGen/ClangAttrEmitter.cpp

case GenericRecord:
       return "(S.getLangOpts().CPlusPlus ? ExpectedStructOrUnionOrClass : "
                                            "ExpectedStructOrUnion)";
     case Func | ObjCMethod | Block: return "ExpectedFunctionMethodOrBlock";
     case Func | ObjCMethod | Class: return "ExpectedFunctionMethodOrClass";
     case Func | Param:
     case Func | ObjCMethod | Param: return "ExpectedFunctionMethodOrParameter";
     case Func | ObjCMethod: return "ExpectedFunctionOrMethod";
     case Func | Var: return "ExpectedVariableOrFunction";
+    case Func | Class:
+      return "ExpectedFunctionOrClass";
 
     // If not compiling for C++, the class portion does not apply.
     case Func | Var | Class:
       return "(S.getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : "
                                            "ExpectedVariableOrFunction)";
 
     case ObjCMethod | ObjCProp: return "ExpectedMethodOrProperty";
     case ObjCProtocol | ObjCInterface: