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

1669

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.

1671

Please, no undocumented attributes.

include/clang/Basic/DiagnosticSemaKinds.td

2744

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

8741

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;

8876

Similar suggestion here.

lib/Sema/SemaDeclAttr.cpp

5374

The declaration does not need to be hoisted here.

5378

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

5385

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

1669

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

1671

Will document.

include/clang/Basic/DiagnosticSemaKinds.td

2744

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

lib/AST/ASTContext.cpp

8741

Ok.

lib/Sema/SemaDeclAttr.cpp

5378

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.

5385

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

1669

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

750

Looks like some debugging code accidentally made it in.

lib/Sema/SemaDecl.cpp

2252

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);

2400

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

5392

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

lib/Sema/SemaTemplate.cpp

8207

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

8218

Same comment here.

8227

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

[aaron.ballman]

include/clang/Basic/Attr.td

1670

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

2175

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

2175

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

750

Thanks!

lib/Sema/SemaDecl.cpp

2400

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

2175

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

2745

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"

2749

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

8730

Elide braces

lib/Sema/SemaDecl.cpp

2259

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

2400

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

8224

Elide braces

[majnemer]

include/clang/Basic/Attr.td

1670

What about variable templates?

lib/Sema/SemaDecl.cpp

2401

Capital letters for variable names.

test/CodeGenCXX/unique-instantiation.cpp

2

Is -O0 needed here?

[loladiro]

include/clang/Basic/Attr.td

1670

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

2749

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

1670

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

1670

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

2749

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

1670

Bump on the question of differences to GCC here.

include/clang/Basic/DiagnosticSemaKinds.td

2749

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

2317–2336

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

2744–2745

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

lib/AST/ASTContext.cpp

8741–8744

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

748–751

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

2317–2336

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

include/clang/Basic/DiagnosticSemaKinds.td

2744–2745

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

lib/AST/ASTContext.cpp

8741–8744

Sounds good.

lib/CodeGen/CGVTables.cpp

748–751

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

8726–8735

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

8726–8735

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

2317–2336

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

2321–2323

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

2749

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

8789

revert this change

lib/Sema/SemaDecl.cpp

2396–2397

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

2398–2399

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

5400

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

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

8063–8066

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

2321–2323

Ok, sounds good.

include/clang/Basic/DiagnosticSemaKinds.td

2749

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

2398–2399

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

5400

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

Ok, I'll try that.

lib/Sema/SemaTemplate.cpp

8063–8066

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/Basic/Attr.td

 }
 
 def Overloadable : Attr {
   let Spellings = [GNU<"overloadable">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [OverloadableDocs];
 }
 
-def Override : InheritableAttr { 
+def Override : InheritableAttr {
   let Spellings = [Keyword<"override">];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 
 def Ownership : InheritableAttr {
   let Spellings = [GNU<"ownership_holds">, GNU<"ownership_returns">,
                    GNU<"ownership_takes">];
def RequireConstantInit : InheritableAttr {
   let Subjects = SubjectList<[GlobalVar], ErrorDiag,
                               "ExpectedStaticOrTLSVar">;
   let Documentation = [RequireConstantInitDocs];
   let LangOpts = [CPlusPlus];
 }
 
 def WorkGroupSizeHint :  InheritableAttr {
   let Spellings = [GNU<"work_group_size_hint">];
-  let Args = [UnsignedArgument<"XDim">, 
+  let Args = [UnsignedArgument<"XDim">,
               UnsignedArgument<"YDim">,
               UnsignedArgument<"ZDim">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
 def InitPriority : InheritableAttr {
   let Spellings = [GNU<"init_priority">];

 }
 
 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<[Var, 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

The syntax of the `declare simd` construct is as follows:
   .. code-block:: c
 
   #pragma omp declare simd [clause[[,] clause] ...] new-line
   [#pragma omp declare simd [clause[[,] clause] ...] new-line]
   [...]
   function definition or declaration
 
 where clause is one of the following:
 
   .. code-block:: c
 
   simdlen(length)
   linear(argument-list[:constant-linear-step])
   aligned(argument-list[:alignment])
   uniform(argument-list)
   inbranch
   notinbranch
.. 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.
   }];
 }
 
 def AnyX86InterruptDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the GNU style ``__attribute__((interrupt))`` attribute on
 x86/x86-64 targets.The compiler generates function entry and exit sequences

include/clang/Basic/DiagnosticSemaKinds.td

def warn_attribute_wrong_decl_type : Warning<
   "|structs, unions, and typedefs"
   "|structs and typedefs"
   "|interface or protocol declarations"
   "|kernel functions"
   "|non-K&R-style functions"
   "|variables, enums, fields and typedefs"
   "|functions, methods, enums, and classes"
   "|structs, classes, variables, functions, and inline namespaces"
-  "|variables, functions, methods, types, enumerations, enumerators, labels, and non-static data members}1">,
+  "|variables, functions, methods, types, enumerations, enumerators, labels, and non-static data members"
+  "|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_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   
+// 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;
 def warn_double_lock : Warning<"acquiring %0 '%1' that is already held">,
   InGroup<ThreadSafetyAnalysis>, DefaultIgnore;

include/clang/Sema/AttributeList.h

enum AttributeDeclKind {
   ExpectedStructOrUnionOrTypedef,
   ExpectedStructOrTypedef,
   ExpectedObjectiveCInterfaceOrProtocol,
   ExpectedKernelFunction,
   ExpectedFunctionWithProtoType,
   ExpectedVariableEnumFieldOrTypedef,
   ExpectedFunctionMethodEnumOrClass,
   ExpectedStructClassVariableFunctionOrInlineNamespace,
-  ExpectedForMaybeUnused
+  ExpectedForMaybeUnused,
+  ExpectedExplicitInstantiation,
+  ExpectedFunctionOrClass
 };
 
 }  // end namespace clang
 
 #endif

include/clang/Sema/Sema.h

 
   void referenceDLLExportedClassMethods();
 
   void propagateDLLAttrToBaseClassTemplate(
       CXXRecordDecl *Class, Attr *ClassAttr,
       ClassTemplateSpecializationDecl *BaseTemplateSpec,
       SourceLocation BaseLoc);
 
+  void checkClassLevelUniqueInstantiation(CXXRecordDecl *Record);
+  void propagateUniqueInstantiation(CXXRecordDecl *Decl);
+
   void CheckCompletedCXXClass(CXXRecordDecl *Record);
   void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
                                          Decl *TagDecl,
                                          SourceLocation LBrac,
                                          SourceLocation RBrac,
                                          AttributeList *AttrList);
   void ActOnFinishCXXMemberDecls();
   void ActOnFinishCXXNonNestedClass(Decl *D);

lib/AST/ASTContext.cpp

QualType ASTContext::GetBuiltinType(unsigned Id,
   EPI.Variadic = Variadic;
   if (getLangOpts().CPlusPlus && BuiltinInfo.isNoThrow(Id))
     EPI.ExceptionSpec.Type =
         getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
 
   return getFunctionType(ResType, ArgTypes, EPI);
 }
 
 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>())
+      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:
     return GVA_AvailableExternally;
 
   case TSK_ImplicitInstantiation:
     External = GVA_DiscardableODR;
     break;
   }
 
+  // It can happen that functions have a unique_instantiation attribute, but
+  // not have TSK_ExplicitInstantiation set (e.g. because they are member functions of a local
+  // class) of a unique_instantiation templated functions. However, that
+  // should only be possible if what we're looking at is a definition (as
+  // opposed to a declaration), so treat it as such.
+  if (FD->hasAttr<UniqueInstantiationAttr>())
+    return GVA_StrongExternal;
+
   if (!FD->isInlined())
     return External;
 
   if ((!Context.getLangOpts().CPlusPlus &&
        !Context.getTargetInfo().getCXXABI().isMicrosoft() &&
        !FD->hasAttr<DLLExportAttr>()) ||
       FD->hasAttr<GNUInlineAttr>()) {
     // FIXME: This doesn't match gcc's behavior for dllexport inline functions.
 
     // GNU or C99 inline semantics. Determine whether this symbol should be
     // externally visible.
     if (FD->isInlineDefinitionExternallyVisible())
       return External;
 
     // C99 inline semantics, where the symbol is not externally visible.
     return GVA_AvailableExternally;
   }
 
   // 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;
+  return  GVA_DiscardableODR;
 }
 
 static GVALinkage adjustGVALinkageForAttributes(const ASTContext &Context,
                                                 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)
static GVALinkage basicGVALinkageForVariable(const ASTContext &Context,
 
   case TSK_ExplicitSpecialization:
     return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
                    VD->isStaticDataMember()
                ? GVA_StrongODR
                : StrongLinkage;
 
   case TSK_ExplicitInstantiationDefinition:
+    if (VD->hasAttr<UniqueInstantiationAttr>())
+      return GVA_StrongExternal;
     return GVA_StrongODR;
 
   case TSK_ExplicitInstantiationDeclaration:
     return GVA_AvailableExternally;
 
   case TSK_ImplicitInstantiation:
     return GVA_DiscardableODR;
   }
 

lib/CodeGen/CGVTables.cpp

CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
   const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD);
   if (keyFunction && !RD->hasAttr<DLLImportAttr>()) {
     // If this class has a key function, use that to determine the
     // linkage of the vtable.
     const FunctionDecl *def = nullptr;
     if (keyFunction->hasBody(def))
       keyFunction = cast<CXXMethodDecl>(def);
 
+    if (keyFunction->hasAttr<UniqueInstantiationAttr>())
+      return llvm::GlobalValue::ExternalLinkage;
+
     switch (keyFunction->getTemplateSpecializationKind()) {
       case TSK_Undeclared:
       case TSK_ExplicitSpecialization:
         assert((def || CodeGenOpts.OptimizationLevel > 0) &&
                "Shouldn't query vtable linkage without key function or "
                "optimizations");
         if (!def && CodeGenOpts.OptimizationLevel > 0)
           return llvm::GlobalVariable::AvailableExternallyLinkage;
 
         if (keyFunction->isInlined())
           return !Context.getLangOpts().AppleKext ?
                    llvm::GlobalVariable::LinkOnceODRLinkage :
                    llvm::Function::InternalLinkage;
 
         return llvm::GlobalVariable::ExternalLinkage;
 
       case TSK_ImplicitInstantiation:
+        // If the key function has strong linkage (say due to
+        // UniqueInstantiationAttr), the VTable should too.
         return !Context.getLangOpts().AppleKext ?
                  llvm::GlobalVariable::LinkOnceODRLinkage :
                  llvm::Function::InternalLinkage;
 
       case TSK_ExplicitInstantiationDefinition:
         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>()) {
+    DiscardableODRLinkage = llvm::GlobalVariable::ExternalLinkage;
+    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>();
+  Attr *OldAttr = Old->getAttr<UniqueInstantiationAttr>();
+
+  // Check that any previous definitions also had this attribute set.
+  if (Old->hasAttr<UniqueInstantiationAttr>() == (NewAttr != nullptr))
+    return;
+    
+  // We may have to allow this if the new definition is not a template
+  // declaration/definition (e.g. for an out-of-line template definition of
+  // a static variable).
+  if (OldAttr) {
+    const VarDecl *NewVD = dyn_cast<const VarDecl>(New);  
+    if (NewVD && NewVD->getTemplateSpecializationKind() == clang::TSK_Undeclared) {
+      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) {
   // This function copies an attribute Attr from a previous declaration to the
   // new declaration D if the new declaration doesn't itself have that attribute
   // yet or if that attribute allows duplicates.
   // If you're adding a new attribute that requires logic different from
   // "use explicit attribute on decl if present, else use attribute from

 }
 
 /// 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];
 
if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {
         }
       }
     } else {
       Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
       Diag(Old->getLocation(), diag::note_previous_declaration);
     }
   }
 
+  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 handleOpenCLNoSVMAttr(Sema &S, Decl *D, const AttributeList &Attr) {
   if (S.LangOpts.OpenCLVersion != 200)
     S.Diag(Attr.getLoc(), diag::err_attribute_requires_opencl_version)
         << Attr.getName() << "2.0" << 0;
   else
     S.Diag(Attr.getLoc(), diag::warn_opencl_attr_deprecated_ignored)
         << Attr.getName() << "2.0";
 }
 
+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);
+  } else if (auto *VD = dyn_cast<VarDecl>(D)) {
+    if (VD->getTemplateSpecializationKind() ==
+            TSK_ExplicitInstantiationDefinition ||
+        VD->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/SemaDeclCXX.cpp

static void DefineImplicitSpecialMember(Sema &S, CXXMethodDecl *MD,
   case Sema::CXXMoveAssignment:
     S.DefineImplicitMoveAssignment(DefaultLoc, MD);
     break;
   case Sema::CXXInvalid:
     llvm_unreachable("Invalid special member.");
   }
 }
 
+/// \brief Check if the new class needs a unique instantiation attribute
+/// based on whether its containing function or class has it
+void Sema::checkClassLevelUniqueInstantiation(CXXRecordDecl *Record) {
+  Decl *D = Record;
+  if (!D || D->hasAttr<UniqueInstantiationAttr>())
+    return;
+  while (DeclContext *DC = D ? D->getDeclContext() : nullptr) {
+    if (isa<FunctionDecl>(DC) || isa<CXXRecordDecl>(DC)) {
+      if (InheritableAttr *Attr =
+              cast<Decl>(DC)->getAttr<UniqueInstantiationAttr>()) {
+        auto *NewAttr = cast<InheritableAttr>(Attr->clone(getASTContext()));
+        NewAttr->setInherited(true);
+        Record->addAttr(NewAttr);
+        propagateUniqueInstantiation(Record);
+      }
+      return;
+    }
+    D = dyn_cast<Decl>(DC);
+  }
+}
+
+void Sema::propagateUniqueInstantiation(CXXRecordDecl *Class) {
+  InheritableAttr *Attr = Class->getAttr<UniqueInstantiationAttr>();
+  if (!Attr)
+    return;
+  for (Decl *Member : Class->decls()) {
+    VarDecl *VD = dyn_cast<VarDecl>(Member);
+    CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);
+    CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member);
+
+    if (!VD && !MD && !RD)
+      continue;
+
+    if (MD) {
+      // Don't process deleted methods.
+      if (MD->isDeleted())
+        continue;
+    }
+
+    if (!cast<NamedDecl>(Member)->isExternallyVisible())
+      continue;
+
+    auto *NewAttr = cast<InheritableAttr>(Attr->clone(getASTContext()));
+    NewAttr->setInherited(true);
+    Member->addAttr(NewAttr);
+  }
+}
+
 /// \brief Perform semantic checks on a class definition that has been
 /// completing, introducing implicitly-declared members, checking for
 /// abstract types, etc.
 void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
   if (!Record)
     return;
 
   if (Record->isAbstract() && !Record->isInvalidDecl()) {
void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
   // really rely on MSVC-compatible layout for.  We must therefore
   // support "ms_struct except for C++ stuff" as a secondary ABI.
   if (Record->isMsStruct(Context) &&
       (Record->isPolymorphic() || Record->getNumBases())) {
     Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
   }
 
   checkClassLevelDLLAttribute(Record);
+
+  checkClassLevelUniqueInstantiation(Record);
 }
 
 /// Look up the special member function that would be called by a special
 /// member function for a subobject of class type.
 ///
 /// \param Class The class type of the subobject.
 /// \param CSM The kind of special member function.
 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.

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->setBraceRange(SourceRange());
+  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);
+    propagateUniqueInstantiation(Def);
   }
 
   return Specialization;
 }
 
 // Explicit instantiation of a member class of a class template.
 DeclResult
 Sema::ActOnExplicitInstantiation(Scope *S,
Sema::ActOnExplicitInstantiation(Scope *S,
 
   // FIXME: We don't have any representation for explicit instantiations of
   // member classes. Such a representation is not needed for compilation, but it
   // should be available for clients that want to see all of the declarations in
   // the source code.
   return TagD;
 }
 
+static void
+DiagnoseUniqueInstantiation(Sema &S, Declarator &D,
+                            TemplateSpecializationKind TSK, bool HadDeclaration,
+                            UniqueInstantiationAttr *NewUniqueInstantiation,
+                            UniqueInstantiationAttr *OldUniqueInstantiation,
+                            clang::SourceLocation OldUniqueInstantiationLoc) {
+  if (NewUniqueInstantiation) {
+    if (TSK == TSK_ExplicitInstantiationDefinition && !HadDeclaration)
+      S.Diag(NewUniqueInstantiation->getLocation(),
+             diag::err_unique_instantiation_no_declaration);
+    else if (HadDeclaration && !OldUniqueInstantiation)
+      S.Diag(NewUniqueInstantiation->getLocation(),
+             diag::err_unique_instantiation_not_previous);
+  } else if (OldUniqueInstantiation) {
+    S.Diag(D.getIdentifierLoc(), diag::err_unique_instantiation_not_previous);
+    S.Diag(OldUniqueInstantiationLoc,
+           diag::note_previous_explicit_instantiation);
+  }
+}
+
 DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
                                             SourceLocation ExternLoc,
                                             SourceLocation TemplateLoc,
                                             Declarator &D) {
   // Explicit instantiations always require a name.
   // TODO: check if/when DNInfo should replace Name.
   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
   DeclarationName Name = NameInfo.getName();
DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
   //   instantiation declaration begins with the extern keyword. [...]
   TemplateSpecializationKind TSK
     = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                            : TSK_ExplicitInstantiationDeclaration;
 
   LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
   LookupParsedName(Previous, S, &D.getCXXScopeSpec());
 
+  // For diagnosing incorrect uses of unique_instantiation
+  UniqueInstantiationAttr *OldUniqueInstantiation = nullptr;
+  SourceLocation OldUniqueInstantiationLoc;
+  bool HadDeclaration;
+
   if (!R->isFunctionType()) {
     // C++ [temp.explicit]p1:
     //   A [...] static data member of a class template can be explicitly
     //   instantiated from the member definition associated with its class
     //   template.
     // C++1y [temp.explicit]p1:
     //   A [...] variable [...] template specialization can be explicitly
     //   instantiated from its template.
if (!PrevTemplate) {
       DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
                                           D.getIdentifierLoc(), TemplateArgs);
       if (Res.isInvalid())
         return true;
 
       // Ignore access control bits, we don't need them for redeclaration
       // checking.
       Prev = cast<VarDecl>(Res.get());
+
+    }
+    HadDeclaration = Prev->getTemplateSpecializationKind() ==
+                     TSK_ExplicitInstantiationDeclaration;
+    OldUniqueInstantiation = Prev->getAttr<UniqueInstantiationAttr>();
+    if (OldUniqueInstantiation) {
+      OldUniqueInstantiationLoc = OldUniqueInstantiation->getLocation();
+      Prev->dropAttr<UniqueInstantiationAttr>();
     }
 
     // C++0x [temp.explicit]p2:
     //   If the explicit instantiation is for a member function, a member class
     //   or a static data member of a class template specialization, the name of
     //   the class template specialization in the qualified-id for the member
     //   name shall be a simple-template-id.
     //
if (!R->isFunctionType()) {
     if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
                                                PrevTSK, POI, HasNoEffect))
       return true;
 
     if (!HasNoEffect) {
       // Instantiate static data member or variable template.
 
       Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
-      if (PrevTemplate) {
-        // Merge attributes.
-        if (AttributeList *Attr = D.getDeclSpec().getAttributes().getList())
-          ProcessDeclAttributeList(S, Prev, Attr);
-      }
+      DiagnoseUniqueInstantiation(*this, D, TSK, HadDeclaration,
+                                  Prev->getAttr<UniqueInstantiationAttr>(),
+                                  OldUniqueInstantiation,
+                                  OldUniqueInstantiationLoc);
       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)
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;
   }
 
+  HadDeclaration = Specialization->getTemplateSpecializationKind() ==
+                   TSK_ExplicitInstantiationDeclaration;
+  OldUniqueInstantiation = Specialization->getAttr<UniqueInstantiationAttr>();
+  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);
 
+  DiagnoseUniqueInstantiation(
+      *this, D, TSK, HadDeclaration,
+      Specialization->getAttr<UniqueInstantiationAttr>(),
+      OldUniqueInstantiation, OldUniqueInstantiationLoc);
+
   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:
   //   If the explicit instantiation is for a member function, a member class
   //   or a static data member of a class template specialization, the name of
   //   the class template specialization in the qualified-id for the member
   //   name shall be a simple-template-id.
   //

test/CodeGenCXX/unique-instantiation.cpp

+// RUN: %clang -std=c++14 -emit-llvm -c -S -o - %s | FileCheck %s
+
+// CHECK: @_Z2piIfE = global float
+// CHECK-NOT: @_Z2piIfE = weak_odr global float
+template <typename T>
+T pi = T(3.1415926535897932385);
+extern template __attribute__((unique_instantiation)) float pi<float>;
+template __attribute__((unique_instantiation)) float pi<float>;
+
+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: _ZZ12functemplateIiEDaT_E11innerStatic = global i32 0, align 4
+// CHECK: @_ZTVZ12functemplateIiEDaT_E5inner = unnamed_addr
+// CHECK: @_ZTSZ12functemplateIiEDaT_E5inner = constant
+// CHECK: @_ZTIZ12functemplateIiEDaT_E5inner = constant
+// CHECK-NOT: @_ZZ12functemplateIiEDaT_E11innerStatic = linkonce_odr global
+// CHECK-NOT: @_ZTVZ12functemplateIiEDaT_E5inner = linkoce_odr unnamed_addr
+// CHECK-NOT: @_ZTSZ12functemplateIiEDaT_E5inner = linkoce_odr unnamed_addr
+// CHECK-NOT: @_ZTIZ12functemplateIiEDaT_E5inner = linkoce_odr unnamed_addr
+template <typename T>
+auto functemplate(T x) {
+  static T innerStatic = x;
+  class inner {
+    T y;
+
+  public:
+    virtual ~inner() {}
+    inner(T y) : y(y) {}
+    T getY() { return y; }
+  };
+  return inner{x}.getY();
+}
+
+// CHECK: define i32 @_Z12functemplateIiEDaT_
+// CHECK: define i32 @_ZZ12functemplateIiEDaT_EN5inner4getYEv
+// CHECK-NOT: define weak_odr i32 @_Z12functemplateIiEDaT_
+// CHECK-NOT: define linkonce_odr i32 @_ZZ12functemplateIiEDaT_EN5inner4getYEv
+extern template auto __attribute__((unique_instantiation)) functemplate<int>(int);
+template auto __attribute__((unique_instantiation)) functemplate<int>(int);
+
+// 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>();
+extern template __attribute__((unique_instantiation)) short bar<short>();
+
+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>();
+
+// CHECK: declare signext i16 @_Z3barIsET_v
+int footest() {
+  auto var = foo<int>{5};
+  auto var2 = foo<int>::bar{5};
+  auto x = bar<int>();
+  auto z = bar<short>();
+  return var.getX();
+}

test/SemaCXX/unique-instantiations.cpp

+// RUN: %clang -cc1 -std=c++14 -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>;
+
+template <typename T>
+T pi = T(3.1415926535897932385);
+extern template __attribute__((unique_instantiation)) float pi<float>;
+template __attribute__((unique_instantiation)) float pi<float>;
+
+// Usages on non-templates
+float __attribute__((unique_instantiation)) notpi(2.71828182845904523536028747135); // expected-error{{'unique_instantiation' attribute only applies to explicit template declarations or definitions}}
+struct __attribute__((unique_instantiation)) bar {};                                // expected-error{{'unique_instantiation' attribute only applies to explicit template declarations or definitions}}
+void __attribute__((unique_instantiation)) func() {}                                // expected-error{{'unique_instantiation' attribute only applies to explicit template declarations or definitions}}
+
+// Usages that violate one of the conditions required conditions
+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>
+T pi1 = T(3.1415926535897932385);
+template __attribute__((unique_instantiation)) float pi1<float>; // 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}}
+
+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>; // expected-note{{previous explicit instantiation is here}}
+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 __attribute__((unique_instantiation)) int * 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}}

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 Func | Var | Class | ObjCInterface:
       return "(S.getLangOpts().CPlusPlus"