Allow dllimport/dllexport on inline functions and get the linkage right

[hans]

Summary

This is important for being able to handle these attributes on classes (PR11170).

[majnemer]

LGTM.

[rnk]

lib/CodeGen/CodeGenModule.cpp

1966

So, this is weird. We're saying that for discardable things, we need to use a linkage that prohibits discarding them.

Maybe it would be better to change the GVA linkage of dllexported things?

test/CodeGen/dllexport.cpp

1 ↗

(On Diff #9405)

This should be in test/CodeGenCXX

21 ↗

(On Diff #9405)

Sure, it seems fine to split this out as a separate change.

test/CodeGen/dllimport.cpp

1 ↗

(On Diff #9405)

This should be in test/CodeGenCXX

[rnk]

lib/CodeGen/CodeGenModule.cpp

1991–1995

Hm, I think I wrote this. I probably should have pushed this up into ASTContext::GetGVALinkageForVariable() to make it return GVA_StrongODR.

[hans]

lib/CodeGen/CodeGenModule.cpp

1966

Yeah, fixing the GVA linkage is probably the right thing to do. I'll give it a shot.

test/CodeGen/dllexport.cpp

1 ↗

(On Diff #9405)

Done.

test/CodeGen/dllimport.cpp

1 ↗

(On Diff #9405)

Done.

[hans]

Moved the tests and moving the DLL-linkage logic to GVA computation.

[rnk]

LGTM with a comment

lib/AST/ASTContext.cpp

7799

This should have a comment about the semantics of dllimport and dllexport, and link to the MSDN doc on dllexport with inline functions:
http://msdn.microsoft.com/en-us/library/xa0d9ste.aspx

[majnemer]

I'm a bit concerned with moving the DLLImport/DLLExport related linkage calculation into Sema out of CodeGen. I have a feeling that this will trigger warn_static_local_in_extern_inline when a static local variable inside of a dllimport'd function.

Considering that other things like VTables and RTTI don't rely on the GVALinakge mechanism and will need the ability to "upgrade" some linkage to a DLLImport/DLLExport friendly linkage, I think I'd rather see a DLLImport/DLLExport handled via a function which takes an arbitrary llvm::GlobalVariable linkage and a Decl and figures out what the final linkage should be.

This kind of upgrading is common inside of CodeGen, GetAddrOfGlobalTemporary is a notable example of this.

[ygao]

include/clang/Basic/DiagnosticSemaKinds.td

2095

Typo. "cannot by applied" => "cannot be applied"

lib/AST/ASTContext.cpp

7799

If the first argument to fixGVALinkageForDLLAttribute() is always the return result of
basicGVALinkageForFunction(), I wonder maybe it is more readable to just call the
basic linkage function from the fix linkage function.

Do we still check somewhere that we do not accept the combination of C99/GNU-inline with dllexport/dllimport?

lib/Sema/SemaDecl.cpp

9767

Do you have a test case for the isInherited() case where the dllimport definition should be allowed?

[hans]

include/clang/Basic/DiagnosticSemaKinds.td

2095

Thanks for catching! Fixed.

lib/AST/ASTContext.cpp

7799

No, with this patch we allow dllimport/export on all inline functions.

Reid pointed out that we would get the linkage wrong for exported functions in C99 mode, and that the reasonable thing to do would be to use MS semantics dllimport/export inline functions. I'll update the patch to do this.

lib/Sema/SemaDecl.cpp

9767

The original code had it, so I figured it was important for some reason.

The check goes all the way back to r61437, and it's not entirely clear what is was for even then. Back then it was possible to have both dllimport and dllexport attributes on the same function, and I suspect the isInherited check has to do with that.

I don't think that check is correct today, so I'm going to remove it and simplify the code here a bit.

[hans]

Fix typo, remove isInherited() check and use MS semantics for inline functions with dllexport in C.

[hans]

Regarding handling the dll linkage in AST or Codegen, I was kind of hoping doing it in AST would help in functions such as ASTContext::DeclMustBeEmitted (but it currently doesn't).

I don't have enough experience here to feel strongly either way, but I do suspect that it will become clearer which solution is best as we get further along the train of patches towards full support for class-level dllimport/dllexport.

I would like to go ahead and commit this now, and am totally open to moving the linkage adjusting code if it seems like a good idea as we go forward.

[rnk]

lib/AST/ASTContext.cpp

7778

Sorry to run you around, but I tested and realized this is inconsistent with what GCC does. GCC seems to treat dllexport similar to extern. I recall Nico Rieck had a patch titled "Sema: Treat dllimport globals without explicit storage class as extern" that did somethign like this.

GCC emits a strong external definition for this code:
inline attribute((dllexport)) void foo() {}

We should do the same.

[rnk]

LGTM

lib/AST/ASTContext.cpp

7778

Based on offline discussion, I'm OK punting on this for now. It's not like we supported it before. Please just put a FIXME here that this is ABI incompatible with GCC.

[hans]

We're having trouble reaching agreement about whether to adjust the GVALinkage for dllimport/export, or doing it in CodeGen as in the first version of the patch.

It would be interesting to hear your opinion on this.

[ygao]

Reid pointed out that we would get the linkage wrong for exported functions in C99 mode, and that the reasonable thing to do would be to use MS semantics dllimport/export inline functions. I'll update the patch to do this.

@rnk. If I recall correctly, Microsoft does not support C99 inline. What does MinGw(64) do in this case?

[hans]

I've gone ahead and committed this in r208925.

Richard didn't feel strongly about either direction for the linkage adjustment.

I'm happy to change this either way if Reid and David wants, and it's possible that new information comes to light as we go down this dll rabbit hole.

include/clang/Basic/DiagnosticSemaKinds.td

def err_declspec_thread_on_thread_variable : Error<
   "thread-local storage specifier">;
 def err_attribute_dll_not_extern : Error<
   "%q0 must have external linkage when declared %q1">;
 def warn_attribute_invalid_on_definition : Warning<
   "'%0' attribute cannot be specified on a definition">,
   InGroup<IgnoredAttributes>;
 def err_attribute_dll_redeclaration : Error<
   "redeclaration of %q0 cannot add %q1 attribute">;
+def err_attribute_dllimport_function_definition : Error<
+  "dllimport cannot be applied to non-inline function definition">;
 def err_attribute_dllimport_data_definition : Error<
   "definition of dllimport data">;
 def err_attribute_weakref_not_static : Error<
   "weakref declaration must have internal linkage">;
 def err_attribute_weakref_not_global_context : Error<
   "weakref declaration of %0 must be in a global context">;
 def err_attribute_weakref_without_alias : Error<
   "weakref declaration of %0 must also have an alias attribute">;

lib/AST/ASTContext.cpp

QualType ASTContext::GetBuiltinType(unsigned Id,
 
   FunctionProtoType::ExtProtoInfo EPI;
   EPI.ExtInfo = EI;
   EPI.Variadic = Variadic;
 
   return getFunctionType(ResType, ArgTypes, EPI);
 }
 
-GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) const {
+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;
static GVALinkage basicGVALinkageForFunction(const ASTContext &Context,
   case TSK_ImplicitInstantiation:
     External = GVA_DiscardableODR;
     break;
   }
 
   if (!FD->isInlined())
     return External;
 
-  if ((!getLangOpts().CPlusPlus && !getLangOpts().MSVCCompat) ||
+  if ((!Context.getLangOpts().CPlusPlus && !Context.getLangOpts().MSVCCompat &&
+       !FD->hasAttr<DLLExportAttr>()) ||
       FD->hasAttr<GNUInlineAttr>()) {
     // 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->getMostRecentDecl()->isMSExternInline())
     return GVA_StrongODR;
 
   return GVA_DiscardableODR;
 }
 
-GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) {
+static GVALinkage adjustGVALinkageForDLLAttribute(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;
+  } else if (D->hasAttr<DLLExportAttr>()) {
+    if (L == GVA_DiscardableODR)
+      return GVA_StrongODR;
+  }
+  return L;
+}
+
+GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) const {
+  return adjustGVALinkageForDLLAttribute(basicGVALinkageForFunction(*this, FD),
+                                         FD);
+}
+
+static GVALinkage basicGVALinkageForVariable(const ASTContext &Context,
+                                             const VarDecl *VD) {
   if (!VD->isExternallyVisible())
     return GVA_Internal;
 
   if (VD->isStaticLocal()) {
     GVALinkage StaticLocalLinkage = GVA_DiscardableODR;
     const DeclContext *LexicalContext = VD->getParentFunctionOrMethod();
     while (LexicalContext && !isa<FunctionDecl>(LexicalContext))
       LexicalContext = LexicalContext->getLexicalParent();
 
     // Let the static local variable inherit it's linkage from the nearest
     // enclosing function.
     if (LexicalContext)
       StaticLocalLinkage =
-          GetGVALinkageForFunction(cast<FunctionDecl>(LexicalContext));
+          Context.GetGVALinkageForFunction(cast<FunctionDecl>(LexicalContext));
 
     // GVA_StrongODR function linkage is stronger than what we need,
     // downgrade to GVA_DiscardableODR.
     // This allows us to discard the variable if we never end up needing it.
     return StaticLocalLinkage == GVA_StrongODR ? GVA_DiscardableODR
                                                : StaticLocalLinkage;
   }
 
   // On Darwin, the backing variable for a C++11 thread_local variable always
   // has internal linkage; all accesses should just be calls to the
   // Itanium-specified entry point, which has the normal linkage of the
   // variable.
   if (VD->getTLSKind() == VarDecl::TLS_Dynamic &&
-      getTargetInfo().getTriple().isMacOSX())
+      Context.getTargetInfo().getTriple().isMacOSX())
     return GVA_Internal;
 
   switch (VD->getTemplateSpecializationKind()) {
   case TSK_Undeclared:
   case TSK_ExplicitSpecialization:
     return GVA_StrongExternal;
 
   case TSK_ExplicitInstantiationDefinition:
     return GVA_StrongODR;
 
   case TSK_ExplicitInstantiationDeclaration:
     return GVA_AvailableExternally;
 
   case TSK_ImplicitInstantiation:
     return GVA_DiscardableODR;
   }
 
   llvm_unreachable("Invalid Linkage!");
 }
 
+GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) {
+  return adjustGVALinkageForDLLAttribute(basicGVALinkageForVariable(*this, VD),
+                                         VD);
+}
+
 bool ASTContext::DeclMustBeEmitted(const Decl *D) {
   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
     if (!VD->isFileVarDecl())
       return false;
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     // We never need to emit an uninstantiated function template.
     if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
       return false;

lib/AST/Decl.cpp

 /// the function to be required.
 ///
 /// Note: This function assumes that we will only get called when isInlined()
 /// would return true for this FunctionDecl.
 bool FunctionDecl::isMSExternInline() const {
   assert(isInlined() && "expected to get called on an inlined function!");
 
   const ASTContext &Context = getASTContext();
-  if (!Context.getLangOpts().MSVCCompat)
+  if (!Context.getLangOpts().MSVCCompat && !hasAttr<DLLExportAttr>())
     return false;
 
   for (const FunctionDecl *FD = this; FD; FD = FD->getPreviousDecl())
     if (FD->getStorageClass() == SC_Extern)
       return true;
 
   return false;
 }

lib/CodeGen/CodeGenModule.cpp

else
       return llvm::GlobalVariable::WeakAnyLinkage;
   }
 
   // We are guaranteed to have a strong definition somewhere else,
   // so we can use available_externally linkage.
   if (Linkage == GVA_AvailableExternally)
     return llvm::Function::AvailableExternallyLinkage;
 
-  // LinkOnceODRLinkage is insufficient if the symbol is required to exist in
-  // the symbol table.  Promote the linkage to WeakODRLinkage to preserve the
-  // semantics of LinkOnceODRLinkage while providing visibility in the symbol
-  // table.
-  llvm::GlobalValue::LinkageTypes OnceLinkage =
-      llvm::GlobalValue::LinkOnceODRLinkage;
-  if (D->hasAttr<DLLExportAttr>() || D->hasAttr<DLLImportAttr>())
-    OnceLinkage = llvm::GlobalVariable::WeakODRLinkage;
-
   // Note that Apple's kernel linker doesn't support symbol
   // coalescing, so we need to avoid linkonce and weak linkages there.
   // Normally, this means we just map to internal, but for explicit
   // instantiations we'll map to external.
 
   // In C++, the compiler has to emit a definition in every translation unit
   // that references the function.  We should use linkonce_odr because
   // a) if all references in this translation unit are optimized away, we
   // don't need to codegen it.  b) if the function persists, it needs to be
   // merged with other definitions. c) C++ has the ODR, so we know the
   // definition is dependable.
   if (Linkage == GVA_DiscardableODR)
-    return !Context.getLangOpts().AppleKext ? OnceLinkage
+    return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
                                             : llvm::Function::InternalLinkage;
 
   // An explicit instantiation of a template has weak linkage, since
   // explicit instantiations can occur in multiple translation units
   // and must all be equivalent. However, we are not allowed to
   // throw away these explicit instantiations.
   if (Linkage == GVA_StrongODR)
     return !Context.getLangOpts().AppleKext ? llvm::Function::WeakODRLinkage
                                             : llvm::Function::ExternalLinkage;
 
   // Destructor variants in the Microsoft C++ ABI are always linkonce_odr thunks
   // emitted on an as-needed basis.
   if (UseThunkForDtorVariant)
-    return OnceLinkage;
+    return llvm::GlobalValue::LinkOnceODRLinkage;
 
   // If required by the ABI, give definitions of static data members with inline
   // initializers at least linkonce_odr linkage.
   if (getCXXABI().isInlineInitializedStaticDataMemberLinkOnce() &&
       isa<VarDecl>(D) &&
       isVarDeclInlineInitializedStaticDataMember(cast<VarDecl>(D)))
-    return OnceLinkage;
+    return llvm::GlobalValue::LinkOnceODRLinkage;
 
   // C++ doesn't have tentative definitions and thus cannot have common
   // linkage.
   if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
       !isVarDeclStrongDefinition(cast<VarDecl>(D), CodeGenOpts.NoCommon))
     return llvm::GlobalVariable::CommonLinkage;
 
   // selectany symbols are externally visible, so use weak instead of

lib/Sema/SemaDecl.cpp

for (ArrayRef<NamedDecl *>::iterator
       }
     }
   }
 
   // Ensure that the function's exception specification is instantiated.
   if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
     ResolveExceptionSpec(D->getLocation(), FPT);
 
-  // Checking attributes of current function definition
-  // dllimport attribute.
-  DLLImportAttr *DA = FD->getAttr<DLLImportAttr>();
-  if (DA && (!FD->hasAttr<DLLExportAttr>())) {
-    // dllimport attribute cannot be directly applied to definition.
-    // Microsoft accepts dllimport for functions defined within class scope. 
-    if (!DA->isInherited() &&
-        !(LangOpts.MicrosoftExt && FD->getLexicalDeclContext()->isRecord())) {
-      Diag(FD->getLocation(),
-           diag::err_attribute_can_be_applied_only_to_symbol_declaration)
-        << DA;
-      FD->setInvalidDecl();
-      return D;
-    }
-  }
+  // dllimport cannot be applied to non-inline function definitions.
+  if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined()) {
+    assert(!FD->hasAttr<DLLExportAttr>());
+    Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
   // We want to attach documentation to original Decl (which might be
   // a function template).
   ActOnDocumentableDecl(D);
   return D;
 }
 
 /// \brief Given the set of return statements within a function body,
 /// compute the variables that are subject to the named return value 

lib/Sema/SemaDeclAttr.cpp

if (!FD && !isa<VarDecl>(D)) {
     // in this case, so only emit a warning when -fms-extensions is not
     // specified.
     if (!S.getLangOpts().MicrosoftExt)
       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
         << Attr.getName() << ExpectedVariableOrFunction;
     return;
   }
 
-  // Currently, the dllimport attribute is ignored for inlined functions.
-  // Warning is emitted.
-  if (FD && FD->isInlineSpecified()) {
-    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
-    return;
-  }
-
   unsigned Index = Attr.getAttributeSpellingListIndex();
   DLLImportAttr *NewAttr = S.mergeDLLImportAttr(D, Attr.getRange(), Index);
   if (NewAttr)
     D->addAttr(NewAttr);
 }
 
 DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range,
                                         unsigned AttrSpellingListIndex) {
   if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
     Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
     D->dropAttr<DLLImportAttr>();
   }
 
   if (D->hasAttr<DLLExportAttr>())
     return NULL;
 
   return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
 }
 
 static void handleDLLExportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
-  // Currently, the dllexport attribute is ignored for inlined functions, unless
-  // the -fkeep-inline-functions flag has been used. Warning is emitted.
-  if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isInlineSpecified()) {
-    // FIXME: ... unless the -fkeep-inline-functions flag has been used.
-    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
-    return;
-  }
-
   unsigned Index = Attr.getAttributeSpellingListIndex();
   DLLExportAttr *NewAttr = S.mergeDLLExportAttr(D, Attr.getRange(), Index);
   if (NewAttr)
     D->addAttr(NewAttr);
 }
 
 MSInheritanceAttr *
 Sema::mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,

test/CodeGen/dllexport.c

+// RUN: %clang_cc1 -triple i686-pc-win32 -std=c99 -O2 -disable-llvm-optzns -emit-llvm < %s | FileCheck %s
+
+#define DLLEXPORT __declspec(dllexport)
+
+inline void DLLEXPORT f() {}
+extern void DLLEXPORT f();
+
+// CHECK: define weak_odr dllexport void @f()

test/CodeGenCXX/dllexport.cpp

+// RUN: %clang_cc1 -triple i686-pc-win32 -x c++ -O2 -disable-llvm-optzns -emit-llvm < %s | FileCheck %s
+
+#define DLLEXPORT __declspec(dllexport)
+
+void DLLEXPORT a();
+// CHECK-DAG: declare dllexport void @"\01?a@@YAXXZ"()
+
+inline void DLLEXPORT b() {}
+// CHECK-DAG: define weak_odr dllexport void @"\01?b@@YAXXZ"()
+
+template <typename T> void c() {}
+template void DLLEXPORT c<int>();
+// CHECK-DAG: define weak_odr dllexport void @"\01??$c@H@@YAXXZ"()
+
+struct S {
+  void DLLEXPORT a() {}
+  // CHECK-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?a@S@@QAEXXZ"
+};
+
+void user() {
+  // FIXME: dllexported functions must be emitted even if they're not referenced in this TU.
+  a();
+  b();
+  &S::a;
+}

test/CodeGenCXX/dllimport.cpp

+// RUN: %clang_cc1 -triple i686-pc-win32 -x c++ -O2 -disable-llvm-optzns -emit-llvm < %s | FileCheck %s
+
+#define DLLIMPORT __declspec(dllimport)
+
+void DLLIMPORT a();
+// CHECK-DAG: declare dllimport void @"\01?a@@YAXXZ"()
+
+inline void DLLIMPORT b() {}
+// CHECK-DAG: define available_externally dllimport void @"\01?b@@YAXXZ"()
+
+template <typename T> inline void c() {} // FIXME: MSVC accepts this without 'inline' too.
+template void DLLIMPORT c<int>();
+// CHECK-DAG: define available_externally dllimport void @"\01??$c@H@@YAXXZ"()
+
+struct S {
+  void DLLIMPORT a() {}
+  // CHECK-DAG: define available_externally dllimport x86_thiscallcc void @"\01?a@S@@QAEXXZ"
+};
+
+void user(S* s) {
+  a();
+  b();
+  c<int>();
+  s->a();
+}

test/Sema/dllexport.c

 
 void __attribute__((dllexport)) decl2A();
 void __declspec(dllexport)      decl2B();
 
 // Export function definition.
 __declspec(dllexport) void def() {}
 
 // Export inline function.
-__declspec(dllexport) inline void inlineFunc1() {} // expected-warning{{'dllexport' attribute ignored}}
+__declspec(dllexport) inline void inlineFunc1() {}
 extern void inlineFunc1();
 
-inline void __attribute__((dllexport)) inlineFunc2() {} // expected-warning{{'dllexport' attribute ignored}}
+inline void __attribute__((dllexport)) inlineFunc2() {}
 extern void inlineFunc2();
 
 // Redeclarations
 __declspec(dllexport) void redecl1();
 __declspec(dllexport) void redecl1();
 
 __declspec(dllexport) void redecl2();
                       void redecl2();

test/Sema/dllimport.c

 // Import function declaration. Check different placements.
 __attribute__((dllimport)) void decl1A(); // Sanity check with __attribute__
 __declspec(dllimport)      void decl1B();
 
 void __attribute__((dllimport)) decl2A();
 void __declspec(dllimport)      decl2B();
 
 // Not allowed on function definitions.
-__declspec(dllimport) void def() {} // expected-error{{'dllimport' attribute can be applied only to symbol declaration}}
+__declspec(dllimport) void def() {} // expected-error{{dllimport cannot be applied to non-inline function definition}}
 
 // Import inline function.
-__declspec(dllimport) inline void inlineFunc1() {} // expected-warning{{'dllimport' attribute ignored}}
-inline void __attribute__((dllimport)) inlineFunc2() {} // expected-warning{{'dllimport' attribute ignored}}
+__declspec(dllimport) inline void inlineFunc1() {}
+inline void __attribute__((dllimport)) inlineFunc2() {}
 
 // Redeclarations
 __declspec(dllimport) void redecl1();
 __declspec(dllimport) void redecl1();
 
 // NB: MSVC issues a warning and makes redecl2/redecl3 dllexport. We follow GCC
 // and drop the dllimport with a warning.
 __declspec(dllimport) void redecl2(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}}

test/SemaCXX/MicrosoftExtensions.cpp

 };
 
 
 class AAA {
 __declspec(dllimport) void f(void) { }
 void f2(void); // expected-note{{previous declaration is here}}
 };
 
-__declspec(dllimport) void AAA::f2(void) { // expected-error{{'dllimport' attribute can be applied only to symbol}}
+__declspec(dllimport) void AAA::f2(void) { // expected-error{{dllimport cannot be applied to non-inline function definition}}
                                            // expected-error@-1{{redeclaration of 'AAA::f2' cannot add 'dllimport' attribute}}
 
 }
 
 
 
 template <class T>
 class BB {

test/SemaCXX/dllexport.cpp

 
 // Export function definition.
 __declspec(dllexport) void def() {}
 
 // extern "C"
 extern "C" __declspec(dllexport) void externC() {}
 
 // Export inline function.
-__declspec(dllexport) inline void inlineFunc1() {} // expected-warning{{'dllexport' attribute ignored}}
-inline void __attribute__((dllexport)) inlineFunc2() {} // expected-warning{{'dllexport' attribute ignored}}
+__declspec(dllexport) inline void inlineFunc1() {}
+inline void __attribute__((dllexport)) inlineFunc2() {}
 
-__declspec(dllexport) inline void inlineDecl(); // expected-warning{{'dllexport' attribute ignored}}
+__declspec(dllexport) inline void inlineDecl();
                              void inlineDecl() {}
 
 __declspec(dllexport) void inlineDef();
                inline void inlineDef() {}
 
 // Redeclarations
 __declspec(dllexport) void redecl1();
 __declspec(dllexport) void redecl1() {}
extern template void exportedFuncTmpl<ExplicitDecl_Exported>();
        template void exportedFuncTmpl<ExplicitDecl_Exported>();
 
 // Export explicit instantiation definition of an exported function template.
 template void exportedFuncTmpl<ExplicitInst_Exported>();
 
 // Export specialization of an exported function template.
 template<> __declspec(dllexport) void exportedFuncTmpl<ExplicitSpec_Exported>();
 template<> __declspec(dllexport) void exportedFuncTmpl<ExplicitSpec_Def_Exported>() {}
-template<> __declspec(dllexport) inline void exportedFuncTmpl<ExplicitSpec_InlineDef_Exported>() {} // expected-warning{{'dllexport' attribute ignored}}
+template<> __declspec(dllexport) inline void exportedFuncTmpl<ExplicitSpec_InlineDef_Exported>() {}
 
 // Not exporting specialization of an exported function template without
 // explicit dllexport.
 template<> void exportedFuncTmpl<ExplicitSpec_NotExported>() {}
 
 
 // Export explicit instantiation declaration of a non-exported function template.
 extern template __declspec(dllexport) void funcTmpl<ExplicitDecl_Exported>();
        template __declspec(dllexport) void funcTmpl<ExplicitDecl_Exported>();
 
 // Export explicit instantiation definition of a non-exported function template.
 template __declspec(dllexport) void funcTmpl<ExplicitInst_Exported>();
 
 // Export specialization of a non-exported function template.
 template<> __declspec(dllexport) void funcTmpl<ExplicitSpec_Exported>();
 template<> __declspec(dllexport) void funcTmpl<ExplicitSpec_Def_Exported>() {}
-template<> __declspec(dllexport) inline void funcTmpl<ExplicitSpec_InlineDef_Exported>() {} // expected-warning{{'dllexport' attribute ignored}}
+template<> __declspec(dllexport) inline void funcTmpl<ExplicitSpec_InlineDef_Exported>() {}
 
 
 
 //===----------------------------------------------------------------------===//
 // Precedence
 //===----------------------------------------------------------------------===//
 
 // dllexport takes precedence over dllimport if both are specified.

test/SemaCXX/dllimport.cpp

 // Import function declaration. Check different placements.
 __attribute__((dllimport)) void decl1A(); // Sanity check with __attribute__
 __declspec(dllimport)      void decl1B();
 
 void __attribute__((dllimport)) decl2A();
 void __declspec(dllimport)      decl2B();
 
 // Not allowed on function definitions.
-__declspec(dllimport) void def() {} // expected-error{{'dllimport' attribute can be applied only to symbol declaration}}
+__declspec(dllimport) void def() {} // expected-error{{dllimport cannot be applied to non-inline function definition}}
 
 // extern  "C"
 extern "C" __declspec(dllexport) void externC();
 
 // Import inline function.
-__declspec(dllimport) inline void inlineFunc1() {} // expected-warning{{'dllimport' attribute ignored}}
-inline void __attribute__((dllimport)) inlineFunc2() {} // expected-warning{{'dllimport' attribute ignored}}
+__declspec(dllimport) inline void inlineFunc1() {}
+inline void __attribute__((dllimport)) inlineFunc2() {}
 
 // Redeclarations
 __declspec(dllimport) void redecl1();
 __declspec(dllimport) void redecl1();
 
 // NB: MSVC issues a warning and makes redecl2/redecl3 dllexport. We follow GCC
 // and drop the dllimport with a warning.
 __declspec(dllimport) void redecl2(); // expected-note{{previous declaration is here}} expected-note{{previous attribute is here}}

 
 
 template<typename T> void funcTmpl() {}
 template<typename T> __declspec(dllimport) void importedFuncTmpl();
 
 // Import specialization of an imported function template. A definition must be
 // declared inline.
 template<> __declspec(dllimport) void importedFuncTmpl<ExplicitSpec_Imported>();
-template<> __declspec(dllimport) void importedFuncTmpl<ExplicitSpec_Def_Imported>() {} // expected-error{{'dllimport' attribute can be applied only to symbol declaration}}
-template<> __declspec(dllimport) inline void importedFuncTmpl<ExplicitSpec_InlineDef_Imported>() {} // expected-warning{{'dllimport' attribute ignored}}
+template<> __declspec(dllimport) void importedFuncTmpl<ExplicitSpec_Def_Imported>() {} // expected-error{{dllimport cannot be applied to non-inline function definition}}
+template<> __declspec(dllimport) inline void importedFuncTmpl<ExplicitSpec_InlineDef_Imported>() {}
 
 // Not importing specialization of an imported function template without
 // explicit dllimport.
 template<> void importedFuncTmpl<ExplicitSpec_NotImported>() {}
 
 
 // Import explicit instantiation declaration of a non-imported function template.
 extern template __declspec(dllimport) void funcTmpl<ExplicitDecl_Imported>();
 
 // Import specialization of a non-imported function template. A definition must
 // be declared inline.
 template<> __declspec(dllimport) void funcTmpl<ExplicitSpec_Imported>();
-template<> __declspec(dllimport) void funcTmpl<ExplicitSpec_Def_Imported>() {} // expected-error{{'dllimport' attribute can be applied only to symbol declaration}}
-template<> __declspec(dllimport) inline void funcTmpl<ExplicitSpec_InlineDef_Imported>() {} // expected-warning{{'dllimport' attribute ignored}}
+template<> __declspec(dllimport) void funcTmpl<ExplicitSpec_Def_Imported>() {} // expected-error{{dllimport cannot be applied to non-inline function definition}}
+template<> __declspec(dllimport) inline void funcTmpl<ExplicitSpec_InlineDef_Imported>() {}