Change error for storage-class to mean linkage, fix lang-linkage diag

[erichkeane]

Summary

Allow multiversioning declarations to match when the actual formal
linkage matches, not just when the storage class is identical.
Additionally, change the ambiguous 'linkage' mismatch to be more
specific and say 'language linkage'.

[aaron.ballman]

LGTM!

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_multiversion_disallowed_other_attr : Error<
   "attribute '%select{target|cpu_specific|cpu_dispatch}0' multiversioning cannot be combined"
   " with attribute %1">;
 def err_multiversion_mismatched_attrs
     : Error<"attributes on multiversioned functions must all match, attribute "
             "%0 %select{is missing|has different arguments}1">;
 def err_multiversion_diff : Error<
   "multiversioned function declaration has a different %select{calling convention"
-  "|return type|constexpr specification|inline specification|storage class|"
-  "linkage}0">;
+  "|return type|constexpr specification|inline specification|linkage|"
+  "language linkage}0">;
 def err_multiversion_doesnt_support : Error<
   "attribute '%select{target|cpu_specific|cpu_dispatch}0' multiversioned functions do not "
   "yet support %select{function templates|virtual functions|"
   "deduced return types|constructors|destructors|deleted functions|"
   "defaulted functions|constexpr functions|consteval function}1">;
 def err_multiversion_not_allowed_on_main : Error<
   "'main' cannot be a multiversioned function">;
 def err_multiversion_not_supported : Error<

clang/lib/Sema/SemaDecl.cpp

enum DoesntSupport {
     ConstexprFuncs = 7,
     ConstevalFuncs = 8,
   };
   enum Different {
     CallingConv = 0,
     ReturnType = 1,
     ConstexprSpec = 2,
     InlineSpec = 3,
-    StorageClass = 4,
-    Linkage = 5,
+    Linkage = 4,
+    LanguageLinkage = 5,
   };
 
   if (NoProtoDiagID.getDiagID() != 0 && OldFD &&
       !OldFD->getType()->getAs<FunctionProtoType>()) {
     Diag(OldFD->getLocation(), NoProtoDiagID);
     Diag(NoteCausedDiagIDAt.first, NoteCausedDiagIDAt.second);
     return true;
   }
if (OldReturnType != NewReturnType)
       return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ReturnType;
 
     if (OldFD->getConstexprKind() != NewFD->getConstexprKind())
       return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << ConstexprSpec;
 
     if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
       return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << InlineSpec;
 
-    if (OldFD->getStorageClass() != NewFD->getStorageClass())
-      return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << StorageClass;
+    if (OldFD->getFormalLinkage() != NewFD->getFormalLinkage())
+      return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << Linkage;
 
     if (!CLinkageMayDiffer && OldFD->isExternC() != NewFD->isExternC())
-      return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << Linkage;
+      return Diag(DiffDiagIDAt.first, DiffDiagIDAt.second) << LanguageLinkage;
 
     if (CheckEquivalentExceptionSpec(
             OldFD->getType()->getAs<FunctionProtoType>(), OldFD->getLocation(),
             NewFD->getType()->getAs<FunctionProtoType>(), NewFD->getLocation()))
       return true;
   }
   return false;
 }

clang/test/SemaCXX/attr-cpuspecific.cpp

 //expected-error@+1 {{attribute 'cpu_specific' multiversioned functions do not yet support constexpr functions}}
 constexpr int __attribute__((cpu_specific(sandybridge))) foo(void);
 
 int __attribute__((cpu_specific(sandybridge))) foo2(void);
 //expected-error@+1 {{attribute 'cpu_specific' multiversioned functions do not yet support constexpr functions}}
 constexpr int __attribute__((cpu_specific(ivybridge))) foo2(void);
 
 static int __attribute__((cpu_specific(sandybridge))) bar(void);
-//expected-error@+1 {{multiversioned function declaration has a different storage class}}
+//expected-error@+1 {{multiversioned function declaration has a different linkage}}
 int __attribute__((cpu_dispatch(ivybridge))) bar(void) {}
 
+// OK
+extern int __attribute__((cpu_specific(sandybridge))) bar2(void);
+int __attribute__((cpu_dispatch(ivybridge))) bar2(void) {}
+
+namespace {
+int __attribute__((cpu_specific(sandybridge))) bar3(void);
+static int __attribute__((cpu_dispatch(ivybridge))) bar3(void) {}
+}
+
+
 inline int __attribute__((cpu_specific(sandybridge))) baz(void);
 //expected-error@+1 {{multiversioned function declaration has a different inline specification}}
 int __attribute__((cpu_specific(ivybridge))) baz(void) {return 1;}
 
 void __attribute__((cpu_specific(atom))) diff_return(void);
 //expected-error@+1 {{multiversioned function declaration has a different return type}}
 int __attribute__((cpu_specific(sandybridge))) diff_return(void);
 
struct S {
 
   // expected-error@+1 {{multiversioned functions do not yet support virtual functions}}
   virtual void __attribute__((cpu_specific(atom))) virt();
 };
 
 extern "C" {
 int __attribute__((cpu_specific(atom))) diff_mangle(void) { return 0; }
 }
-//expected-error@+1 {{multiversioned function declaration has a different linkage}}
+//expected-error@+1 {{multiversioned function declaration has a different language linkage}}
 int __attribute__((cpu_specific(sandybridge))) diff_mangle(void) { return 0; }
 
 __attribute__((cpu_specific(atom))) void DiffDecl();
 namespace N {
 using ::DiffDecl;
 // expected-error@+3 {{declaration conflicts with target of using declaration already in scope}}
 // expected-note@-4 {{target of using declaration}}
 // expected-note@-3 {{using declaration}}

clang/test/SemaCXX/attr-target-mv.cpp

 int __attribute__((target("sse4.2"))) foo2(void) { return 0; }
 //expected-error@+1 {{multiversioned function declaration has a different constexpr specification}}
 constexpr int __attribute__((target("arch=sandybridge"))) foo2(void);
 int __attribute__((target("arch=ivybridge"))) foo2(void) {return 1;}
 int __attribute__((target("default"))) foo2(void) { return 2; }
 
 static int __attribute__((target("sse4.2"))) bar(void) { return 0; }
 static int __attribute__((target("arch=sandybridge"))) bar(void);
-//expected-error@+1 {{multiversioned function declaration has a different storage class}}
+//expected-error@+1 {{multiversioned function declaration has a different linkage}}
 int __attribute__((target("arch=ivybridge"))) bar(void) {return 1;}
 static int __attribute__((target("default"))) bar(void) { return 2; }
 
 int __attribute__((target("sse4.2"))) bar2(void) { return 0; }
-//expected-error@+1 {{multiversioned function declaration has a different storage class}}
+//expected-error@+1 {{multiversioned function declaration has a different linkage}}
 static int __attribute__((target("arch=sandybridge"))) bar2(void);
 int __attribute__((target("arch=ivybridge"))) bar2(void) {return 1;}
 int __attribute__((target("default"))) bar2(void) { return 2; }
 
 
+// no diagnostic, since this doesn't change the linkage.
+int __attribute__((target("sse4.2"))) bar3(void) { return 0; }
+extern int __attribute__((target("arch=sandybridge"))) bar2(void);
+
+namespace {
+int __attribute__((target("sse4.2"))) bar4(void) { return 0; }
+static int __attribute__((target("arch=sandybridge"))) bar4(void);
+}
+
 inline int __attribute__((target("sse4.2"))) baz(void) { return 0; }
 inline int __attribute__((target("arch=sandybridge"))) baz(void);
 //expected-error@+1 {{multiversioned function declaration has a different inline specification}}
 int __attribute__((target("arch=ivybridge"))) baz(void) {return 1;}
 inline int __attribute__((target("default"))) baz(void) { return 2; }
 
 int __attribute__((target("sse4.2"))) baz2(void) { return 0; }
 //expected-error@+1 {{multiversioned function declaration has a different inline specification}}
struct S {
 
   // expected-error@+1 {{multiversioned functions do not yet support virtual functions}}
   virtual void __attribute__((target("default"))) virt();
 };
 
 extern "C" {
 int __attribute__((target("sse4.2"))) diff_mangle(void) { return 0; }
 }
-//expected-error@+1 {{multiversioned function declaration has a different linkage}}
+//expected-error@+1 {{multiversioned function declaration has a different language linkage}}
 int __attribute__((target("arch=sandybridge"))) diff_mangle(void) { return 0; }
 
 // expected-error@+1 {{multiversioned functions do not yet support deduced return types}}
 auto __attribute__((target("default"))) deduced_return(void) { return 0; }
 
 auto __attribute__((target("default"))) trailing_return(void)-> int { return 0; }
 
 __attribute__((target("default"))) void DiffDecl();