[windows-itanium] handle dllimport/export code paths separately and share with PS4

[bd1976llvm]

Summary

Similar to Windows Itanium, PS4 is also an Itanium C++ ABI variant and shares the goal of source code compatibility with Microsoft code that uses dllimport/export.

This change introduces a new function to determine from the triple if an environment aims for compatibility with MS w.r.t these attributes and guards the relevant code paths using that function.

[compnerd]

Thanks, this is definitely a nice cleanup. I would say isDLLStorageEnvironment is a better predicate. Would be nice to get @rnk's opinion (and @mstorsjo, if they are interested).

[rnk]

Will there be any need to check this in LLVM? If not, I would prefer to put this on clang::TargetInfo.

clang/lib/CodeGen/ItaniumCXXABI.cpp

3201 ↗

(On Diff #301237)

CGM also has a getTarget() method to get TargetInfo if the predicate moves there.

[mstorsjo]

In D90299#2362220, @compnerd wrote:

I would say isDLLStorageEnvironment is a better predicate.

That sounds less specific to me, and would imply that it also would cover mingw targets (which it doesn't).

The current suggested name, isDLLImportExportMSCompatible, is more specific, but when I first read it my reaction was that mingw's dllexport/import (in the general cases) for sure works the same as for MSVC - if you consider C functions. So if the name can make it clearer that this covers C++ cases, it'd be more intuitive to me, even though I'm sure it'd become even more of a mouthful then...

[rnk]

I agree, the name could be improved. For prior art, see /Zc:dllexportInlines-, which disables some (but not all) of the dllexport/import semantics in clang-cl.

What we are really talking about here is what should be done when importing or exporting C++ constructs with vague linkage (inline functions, templates). That's what all the affected code has in common. Clang doesn't often use the terminology of vague linkage, so maybe it would be better to use the name comdat somehow.

How about TargetInfo::shouldDLLImportComdatSymbols? You could add in "export" (shouldDLLImportExportComdatSymbols), but GCC also exports comdat things sometimes, and in the cases where this predicate controls export behavior, it's pretty clear that it needs to be done to support the side which would import the symbol (explicit template instantiations).

[bd1976llvm]

In D90299#2362895, @rnk wrote:

I agree, the name could be improved. For prior art, see /Zc:dllexportInlines-, which disables some (but not all) of the dllexport/import semantics in clang-cl.

What we are really talking about here is what should be done when importing or exporting C++ constructs with vague linkage (inline functions, templates). That's what all the affected code has in common. Clang doesn't often use the terminology of vague linkage, so maybe it would be better to use the name comdat somehow.

How about TargetInfo::shouldDLLImportComdatSymbols? You could add in "export" (shouldDLLImportExportComdatSymbols), but GCC also exports comdat things sometimes, and in the cases where this predicate controls export behavior, it's pretty clear that it needs to be done to support the side which would import the symbol (explicit template instantiations).

Thanks for the comments. Naming is always hard! I will adopt @rnk's shouldDLLImportComdatSymbols unless anyone has an objection?

[bd1976llvm]

Addressed review comments.

[bd1976llvm]

clang/lib/CodeGen/ItaniumCXXABI.cpp

3201 ↗

(On Diff #301237)

Thanks!

[rnk]

Please add tests for the common cases:

• exported class with inline methods
• exported explicit class template instantiation
• imported class with inline methods
• imported extern class template declaration

You might be able to piggyback on any windows-itanium dllimport tests, if they exist, since the LLVM IR should match.

[bd1976llvm]

Add tests and prevent SemaTemplate and ItaniumCXXABI code paths from executing for PS4 (for now).

I have had to be a bit more cautious as to which code paths I enable for PS4 (vs the initial diff) as I realised that we need to do more testing downstream to be sure the patches in SemaTemplate and ItaniumCXXABI will work with the propriety schemes that we are currently using. For the SemaTemplate patches I have added an exception for PS4 (that I expect to remove once we have completed further testing) and tests to show that PS4 doesn't follow Windows Itanium here. For the ItaniumCXXABI patches, I have left the patches as specific to Windows Itanium. Those patches handle how dllimport/export interacts with RTTI data; on PS4 we currently have a custom scheme for this. I am hopeful that we can use those patches in the future and I am working on verifying this internally but there is some chance that we might have to use a PS4 specific scheme for this. I also discovered that RTTI dllexport/import tests currently assert with the upstream PS4 target - so I couldn't write tests to show that PS4 doesn't follow the Windows Itanium behaviour here.

There were existing LIT tests covering all of the code paths. I have added a run line with the PS4 triple to the appropriate ones.

The patches in SemaDecl.cpp, SemaDeclAttr.cpp and SemaDeclCXX.cpp are covered by the tests:

• Sema/dllimport.c
• SemaCXX/dllexport.cpp
• SemaCXX/dllimport.cpp
• CodeGenCXX/windows-itanium-dllexport.cpp

The patches in SemaTemplate.cpp are covered by:

• CodeGenCXX/windows-implicit-dllexport-template-specialization.cpp
• CodeGenCXX/windows-itanium-dllexport.cpp

The code changes in ItaniumCXXABI.cpp are covered by:

• CodeGenCXX/windows-itanium-type-info.cpp
• CodeGenCXXwindows-itanium-exceptions.cpp

[bd1976llvm]

I think this needs a re-review as I have deviated from the original simple approach.

[bd1976llvm]

Let me know if you think that more tests need adding. I have added support for LIT based run tests to the build recipe (https://reviews.llvm.org/D88124) I can use this to add any run tests that might be useful for this review.

[compnerd]

clang/include/clang/Basic/TargetInfo.h

1102

I don't think its source compatibility, but rather semantic compatibility. -fdeclspec gives you the source level compatibility - it can process the source, just may not do the same thing.

clang/lib/Sema/SemaDecl.cpp

6513

I think that renaming IsMicrosoft is now warranted.

clang/lib/Sema/SemaTemplate.cpp

9762–9766

Please update the comment (I think we can entirely remove it now given the new name). This probably fits better in the definition of shouldImportDLLImportComdatSymbols now as the condition is completely different now.

[bd1976llvm]

Thanks for the comments. I have updated the diff.

Just to explain a bit more about why I haven't been able to adopt all the Windows Itanium code paths for PS4: I am confident that the Windows Itanium code is correct for PS4 and it passes all of our downstream testing. However, there is a very strict backwards compatibility requirement that is preventing me from using all of these code paths for PS4 (see https://www.youtube.com/watch?v=ATOfCfM9hSg for a talk about ABI compatibility difficulties). For the SemaTemplate paths I am still hopeful that we can adopt this behaviour. For the ItaniumCXXABI paths I think we can eventually adopt these in the future but for the next few years we will need to use a PS4 specific scheme for handling RTTI and vtables with dllimport/export. I will put a WIP review shortly for this scheme.

clang/include/clang/Basic/TargetInfo.h

1102

Thanks.

clang/lib/Sema/SemaDecl.cpp

6513

What would be better though? The MS ABI is the standard for the dllimport/export behaviour. Therefore, I think IsMicrosoft is quite a good name and it fits well with the existing comments.

clang/lib/Sema/SemaTemplate.cpp

9762–9766

The comment seems helpful to me though, no? Also, this comment is rather tied to the matching comment on L9782. Since the MS ABI is standard for dllimport/export behaviour and MinGW is the outlier (in that it does it's own thing, a bit, as far as C++ dllimport/export goes) it seems reasonable that these two are mentioned?

[bd1976llvm]

Updated comment to state that "semantic compatibility" is the goal.

[compnerd]

clang/lib/Sema/SemaDecl.cpp

6513

Then IsMicrosoftABI sounds better :). The problem with the current name is that its confusing between the Microsoft environment and the Microsoft ABI.

clang/lib/Sema/SemaTemplate.cpp

9762–9766

I think I would be okay with retaining the comment with the initial clause In the MS ABI, removed.

[bd1976llvm]

Addressed review comments.

[bd1976llvm]

clang/lib/Sema/SemaDecl.cpp

6513

Done. Thanks.

clang/lib/Sema/SemaTemplate.cpp

9762–9766

Done. Thanks!

[bd1976llvm]

This comment was removed by bd1976llvm.

clang/include/clang/Basic/TargetInfo.h

public:
   /// outside this shared object) and "hidden" (meaning that it isn't)
   /// visibilities, but "protected" is really an ELF-specific concept
   /// with weird semantics designed around the convenience of dynamic
   /// linker implementations.  Which is not to suggest that there's
   /// consistent target-independent semantics for "default" visibility
   /// either; the entire thing is pretty badly mangled.
   virtual bool hasProtectedVisibility() const { return true; }
 
+  /// Does this target aim for semantic compatibility with
+  /// Microsoft C++ code using dllimport/export attributes?
+  virtual bool shouldDLLImportComdatSymbols() const {
+    return getTriple().isWindowsMSVCEnvironment() ||
+           getTriple().isWindowsItaniumEnvironment() || getTriple().isPS4CPU();
+  }
+
   /// An optional hook that targets can implement to perform semantic
   /// checking on attribute((section("foo"))) specifiers.
   ///
   /// In this case, "foo" is passed in to be checked.  If the section
   /// specifier is invalid, the backend should return a non-empty string
   /// that indicates the problem.
   ///
   /// This hook is a simple quality of implementation feature to catch errors

clang/lib/Sema/SemaDecl.cpp

static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl,
   }
 
   // A redeclaration is not allowed to drop a dllimport attribute, the only
   // exceptions being inline function definitions (except for function
   // templates), local extern declarations, qualified friend declarations or
   // special MSVC extension: in the last case, the declaration is treated as if
   // it were marked dllexport.
   bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
-  bool IsMicrosoft =
-      S.Context.getTargetInfo().getCXXABI().isMicrosoft() ||
-      S.Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment();
+  bool IsMicrosoftABI  = S.Context.getTargetInfo().shouldDLLImportComdatSymbols();
   if (const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
     // Ignore static data because out-of-line definitions are diagnosed
     // separately.
     IsStaticDataMember = VD->isStaticDataMember();
     IsDefinition = VD->isThisDeclarationADefinition(S.Context) !=
                    VarDecl::DeclarationOnly;
   } else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
     IsInline = FD->isInlined();
     IsQualifiedFriend = FD->getQualifier() &&
                         FD->getFriendObjectKind() == Decl::FOK_Declared;
   }
 
   if (OldImportAttr && !HasNewAttr &&
-      (!IsInline || (IsMicrosoft && IsTemplate)) && !IsStaticDataMember &&
+      (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember &&
       !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
-    if (IsMicrosoft && IsDefinition) {
+    if (IsMicrosoftABI && IsDefinition) {
       S.Diag(NewDecl->getLocation(),
              diag::warn_redeclaration_without_import_attribute)
           << NewDecl;
       S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
       NewDecl->dropAttr<DLLImportAttr>();
       NewDecl->addAttr(
           DLLExportAttr::CreateImplicit(S.Context, NewImportAttr->getRange()));
     } else {
       S.Diag(NewDecl->getLocation(),
              diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
           << NewDecl << OldImportAttr;
       S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
       S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
       OldDecl->dropAttr<DLLImportAttr>();
       NewDecl->dropAttr<DLLImportAttr>();
     }
-  } else if (IsInline && OldImportAttr && !IsMicrosoft) {
+  } else if (IsInline && OldImportAttr && !IsMicrosoftABI) {
     // In MinGW, seeing a function declared inline drops the dllimport
     // attribute.
     OldDecl->dropAttr<DLLImportAttr>();
     NewDecl->dropAttr<DLLImportAttr>();
     S.Diag(NewDecl->getLocation(),
            diag::warn_dllimport_dropped_from_inline_function)
         << NewDecl << OldImportAttr;
   }

clang/lib/Sema/SemaDeclAttr.cpp

DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D,
   if (D->hasAttr<DLLExportAttr>())
     return nullptr;
 
   return ::new (Context) DLLExportAttr(Context, CI);
 }
 
 static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A) {
   if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
-      (S.Context.getTargetInfo().getCXXABI().isMicrosoft() ||
-       S.Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
+      (S.Context.getTargetInfo().shouldDLLImportComdatSymbols())) {
     S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored) << A;
     return;
   }
 
   if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isInlined() && A.getKind() == ParsedAttr::AT_DLLImport &&
-        !(S.Context.getTargetInfo().getCXXABI().isMicrosoft() ||
-          S.Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
+        !(S.Context.getTargetInfo().shouldDLLImportComdatSymbols())) {
       // MinGW doesn't allow dllimport on inline functions.
       S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
           << A;
       return;
     }
   }
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
-    if ((S.Context.getTargetInfo().getCXXABI().isMicrosoft() ||
-         S.Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment()) &&
+    if ((S.Context.getTargetInfo().shouldDLLImportComdatSymbols()) &&
         MD->getParent()->isLambda()) {
       S.Diag(A.getRange().getBegin(), diag::err_attribute_dll_lambda) << A;
       return;
     }
   }
 
   Attr *NewAttr = A.getKind() == ParsedAttr::AT_DLLExport
                       ? (Attr *)S.mergeDLLExportAttr(D, A)

clang/lib/Sema/SemaDeclCXX.cpp

void Sema::checkClassLevelCodeSegAttribute(CXXRecordDecl *Class) {
   }
 }
 
 /// Check class-level dllimport/dllexport attribute.
 void Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) {
   Attr *ClassAttr = getDLLAttr(Class);
 
   // MSVC inherits DLL attributes to partial class template specializations.
-  if ((Context.getTargetInfo().getCXXABI().isMicrosoft() || 
-       Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment()) && !ClassAttr) {
+  if (Context.getTargetInfo().shouldDLLImportComdatSymbols() && !ClassAttr) {
     if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
       if (Attr *TemplateAttr =
               getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
         auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
         A->setInherited(true);
         ClassAttr = A;
       }
     }
   }
 
   if (!ClassAttr)
     return;
 
   if (!Class->isExternallyVisible()) {
     Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
         << Class << ClassAttr;
     return;
   }
 
-  if ((Context.getTargetInfo().getCXXABI().isMicrosoft() || 
-       Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment()) &&
+  if (Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
       !ClassAttr->isInherited()) {
     // Diagnose dll attributes on members of class with dll attribute.
     for (Decl *Member : Class->decls()) {
       if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
         continue;
       InheritableAttr *MemberAttr = getDLLAttr(Member);
       if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
         continue;
for (Decl *Member : Class->decls()) {
     if (MD) {
       // Don't process deleted methods.
       if (MD->isDeleted())
         continue;
 
       if (MD->isInlined()) {
         // MinGW does not import or export inline methods. But do it for
         // template instantiations.
-        if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
-            !Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment() &&
+        if (!Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
             TSK != TSK_ExplicitInstantiationDeclaration &&
             TSK != TSK_ExplicitInstantiationDefinition)
           continue;
 
         // MSVC versions before 2015 don't export the move assignment operators
         // and move constructor, so don't attempt to import/export them if
         // we have a definition.
         auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);

clang/lib/Sema/SemaTemplate.cpp

if (Def) {
     // TSK_ExplicitInstantiationDefinition
     if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
         (TSK == TSK_ExplicitInstantiationDefinition ||
          DLLImportExplicitInstantiationDef)) {
       // FIXME: Need to notify the ASTMutationListener that we did this.
       Def->setTemplateSpecializationKind(TSK);
 
       if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
-          (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
-           Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
-        // In the MS ABI, an explicit instantiation definition can add a dll
-        // attribute to a template with a previous instantiation declaration.
-        // MinGW doesn't allow this.
+          (Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
+           !Context.getTargetInfo().getTriple().isPS4CPU())) {
+        // An explicit instantiation definition can add a dll attribute to a
+        // template with a previous instantiation declaration. MinGW doesn't
+        // allow this.
         auto *A = cast<InheritableAttr>(
             getDLLAttr(Specialization)->clone(getASTContext()));
         A->setInherited(true);
         Def->addAttr(A);
         dllExportImportClassTemplateSpecialization(*this, Def);
       }
     }
 
     // Fix a TSK_ImplicitInstantiation followed by a
     // TSK_ExplicitInstantiationDefinition
     bool NewlyDLLExported =
         !PreviouslyDLLExported && Specialization->hasAttr<DLLExportAttr>();
     if (Old_TSK == TSK_ImplicitInstantiation && NewlyDLLExported &&
-        (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
-         Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
-      // In the MS ABI, an explicit instantiation definition can add a dll
-      // attribute to a template with a previous implicit instantiation.
-      // MinGW doesn't allow this. We limit clang to only adding dllexport, to
-      // avoid potentially strange codegen behavior.  For example, if we extend
-      // this conditional to dllimport, and we have a source file calling a
-      // method on an implicitly instantiated template class instance and then
-      // declaring a dllimport explicit instantiation definition for the same
-      // template class, the codegen for the method call will not respect the
-      // dllimport, while it will with cl. The Def will already have the DLL
-      // attribute, since the Def and Specialization will be the same in the
-      // case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
+        (Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
+         !Context.getTargetInfo().getTriple().isPS4CPU())) {
+      // An explicit instantiation definition can add a dll attribute to a
+      // template with a previous implicit instantiation. MinGW doesn't allow
+      // this. We limit clang to only adding dllexport, to avoid potentially
+      // strange codegen behavior. For example, if we extend this conditional
+      // to dllimport, and we have a source file calling a method on an
+      // implicitly instantiated template class instance and then declaring a
+      // dllimport explicit instantiation definition for the same template
+      // class, the codegen for the method call will not respect the dllimport,
+      // while it will with cl. The Def will already have the DLL attribute,
+      // since the Def and Specialization will be the same in the case of
+      // Old_TSK == TSK_ImplicitInstantiation, and we already added the
       // attribute to the Specialization; we just need to make it take effect.
       assert(Def == Specialization &&
              "Def and Specialization should match for implicit instantiation");
       dllExportImportClassTemplateSpecialization(*this, Def);
     }
 
     // In MinGW mode, export the template instantiation if the declaration
     // was marked dllexport.

clang/test/CodeGenCXX/dllexport-vtable-thunks.cpp

-// RUN: %clang_cc1 -triple x86_64-windows-gnu -fdeclspec -emit-llvm -o - %s | FileCheck %s
-// RUN: %clang_cc1 -triple x86_64-windows-itanium -fdeclspec -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-windows-gnu     -fdeclspec -emit-llvm -o - %s | FileCheck %s -DDSO_ATTRS="dso_local dllexport"
+// RUN: %clang_cc1 -triple x86_64-windows-itanium -fdeclspec -emit-llvm -o - %s | FileCheck %s -DDSO_ATTRS="dso_local dllexport"
+// RUN: %clang_cc1 -triple x86_64-scei-ps4        -fdeclspec -emit-llvm -o - %s | FileCheck %s -DDSO_ATTRS=dllexport
 
 struct __declspec(dllexport) A {
   virtual void m();
 };
 struct __declspec(dllexport) B {
   virtual void m();
 };
 struct __declspec(dllexport) C : A, B {
   virtual void m();
 };
 void C::m() {}
-// CHECK: define dso_local dllexport void @_ZThn8_N1C1mEv
+// CHECK: define [[DSO_ATTRS]] void @_ZThn8_N1C1mEv
 
 struct Base {
   virtual void m();
 };
 struct __declspec(dllexport) Derived : virtual Base {
   virtual void m();
 };
 void Derived::m() {}
-// CHECK: define dso_local dllexport void @_ZTv0_n24_N7Derived1mEv
+// CHECK: define [[DSO_ATTRS]] void @_ZTv0_n24_N7Derived1mEv

clang/test/CodeGenCXX/windows-implicit-dllexport-template-specialization.cpp

-// RUN: %clang_cc1 -std=c++11 -triple i686-windows -fdeclspec -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-MS
+// RUN: %clang_cc1 -std=c++11 -triple i686-windows         -fdeclspec -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-MS
 // RUN: %clang_cc1 -std=c++11 -triple i686-windows-itanium -fdeclspec -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-IA
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-scei-ps4      -fdeclspec -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-PS4
 
 template <typename>
 struct s {};
 
 template <typename T_>
 class t : s<T_> {};
 
 extern template class t<char>;
 template class __declspec(dllexport) t<char>;
 
 // CHECK-MS: dllexport {{.*}} @"??4?$t@D@@QAEAAV0@ABV0@@Z"
 // CHECK-MS: dllexport {{.*}} @"??4?$s@D@@QAEAAU0@ABU0@@Z"
 
 // CHECK-IA: dllexport {{.*}} @_ZN1tIcEaSERKS0_
 // CHECK-IA: dllexport {{.*}} @_ZN1sIcEaSERKS0_
 
+// CHECK-PS4-NOT: @_ZN1tIcEaSERKS0_
+// CHECK-PS4-NOT: @_ZN1sIcEaSERKS0_

clang/test/CodeGenCXX/windows-itanium-dllexport.cpp

-// RUN: %clang_cc1 -emit-llvm -triple i686-windows-itanium -fdeclspec %s -o - | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple i686-windows-itanium -fdeclspec %s -o - | FileCheck %s --check-prefixes=CHECK,WI
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-scei-ps4 -fdeclspec %s -o - | FileCheck %s --check-prefixes=CHECK,PS4
 
 #define JOIN2(x, y) x##y
 #define JOIN(x, y) JOIN2(x, y)
 #define UNIQ(name) JOIN(name, __LINE__)
 #define USEMEMFUNC(class, func) void (class::*UNIQ(use)())() { return &class::func; }
 
 struct __declspec(dllexport) s {
   void f() {}

 template class __declspec(dllexport) c<int>;
 
 // CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIiEaSERKS0_
 // CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIiE1fEv
 
 extern template class c<char>;
 template class __declspec(dllexport) c<char>;
 
-// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIcEaSERKS0_
-// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIcE1fEv
+// WI: define {{.*}} dllexport {{.*}} @_ZN1cIcEaSERKS0_
+// WI: define {{.*}} dllexport {{.*}} @_ZN1cIcE1fEv
+// PS4-NOT: @_ZN1cIcEaSERKS0_
+// PS4: define weak_odr void @_ZN1cIcE1fEv
 
 c<double> g;
 template class __declspec(dllexport) c<double>;
 
-// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIdEaSERKS0_
-// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIdE1fEv
+// WI: define {{.*}} dllexport {{.*}} @_ZN1cIdEaSERKS0_
+// WI: define {{.*}} dllexport {{.*}} @_ZN1cIdE1fEv
+// PS4-NOT: @_ZN1cIdEaSERKS0_
+// PS4: define weak_odr void @_ZN1cIdE1fEv
 
 template <class T>
 struct outer {
   void f() {}
   struct inner {
     void f() {}
   };
 };
 
 template class __declspec(dllexport) outer<int>;
 
 // CHECK: define {{.*}} dllexport {{.*}} @_ZN5outerIiE1fEv
 // CHECK-NOT: define {{.*}} dllexport {{.*}} @_ZN5outerIiE5inner1fEv
 
 extern template class __declspec(dllimport) outer<char>;
 USEMEMFUNC(outer<char>, f)
 USEMEMFUNC(outer<char>::inner, f)
 
-// CHECK: declare dllimport {{.*}} @_ZN5outerIcE1fEv
-// CHECK: define {{.*}} @_ZN5outerIcE5inner1fEv
+// CHECK-DAG: declare dllimport {{.*}} @_ZN5outerIcE1fEv
+// WI-DAG: define {{.*}} @_ZN5outerIcE5inner1fEv
+// PS4-DAG: declare {{.*}} @_ZN5outerIcE5inner1fEv

clang/test/Sema/dllimport.c

 // RUN: %clang_cc1 -triple i686-win32             -fsyntax-only -fms-extensions -verify -std=c99 -DMS %s
 // RUN: %clang_cc1 -triple x86_64-win32           -fsyntax-only -fms-extensions -verify -std=c11 -DMS %s
 // RUN: %clang_cc1 -triple i686-mingw32           -fsyntax-only -fms-extensions -verify -std=c11 -DGNU %s
 // RUN: %clang_cc1 -triple x86_64-mingw32         -fsyntax-only -fms-extensions -verify -std=c99 -DGNU %s
 // RUN: %clang_cc1 -triple aarch64-win32          -fsyntax-only -fms-extensions -verify -std=c99 -DMS %s
 // RUN: %clang_cc1 -triple i686-windows-itanium   -fsyntax-only -fms-extensions -verify -std=c99 -DWI %s
 // RUN: %clang_cc1 -triple x86_64-windows-itanium -fsyntax-only -fms-extensions -verify -std=c11 -DWI %s
+// RUN: %clang_cc1 -triple x86_64-scei-ps4        -fsyntax-only -fms-extensions -verify -std=c11 -DWI %s
+// RUN: %clang_cc1 -triple x86_64-scei-ps4        -fsyntax-only -fms-extensions -verify -std=c99 -DWI %s
 
 // Invalid usage.
 __declspec(dllimport) typedef int typedef1;
 // expected-warning@-1{{'dllimport' attribute only applies to functions, variables, classes, and Objective-C interfaces}}
 typedef __declspec(dllimport) int typedef2;
 // expected-warning@-1{{'dllimport' attribute only applies to}}
 typedef int __declspec(dllimport) typedef3;
 // expected-warning@-1{{'dllimport' attribute only applies to}}

clang/test/SemaCXX/dllexport.cpp

 // RUN: %clang_cc1 -triple i686-win32             -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DMS %s
 // RUN: %clang_cc1 -triple x86_64-win32           -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template -DMS %s
 // RUN: %clang_cc1 -triple i686-mingw32           -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template %s
 // RUN: %clang_cc1 -triple x86_64-mingw32         -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template %s
 // RUN: %clang_cc1 -triple i686-windows-itanium   -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DWI %s
 // RUN: %clang_cc1 -triple x86_64-windows-itanium -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template -DWI %s
+// RUN: %clang_cc1 -triple x86_64-scei-ps4        -fsyntax-only -fdeclspec      -verify -std=c++1y -Wunsupported-dll-base-class-template -DWI %s
 
 // Helper structs to make templates more expressive.
 struct ImplicitInst_Exported {};
 struct ExplicitDecl_Exported {};
 struct ExplicitInst_Exported {};
 struct ExplicitSpec_Exported {};
 struct ExplicitSpec_Def_Exported {};
 struct ExplicitSpec_InlineDef_Exported {};

clang/test/SemaCXX/dllimport.cpp

 // RUN: %clang_cc1 -triple i686-win32             -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DMS %s
 // RUN: %clang_cc1 -triple x86_64-win32           -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template -DMS %s
 // RUN: %clang_cc1 -triple i686-mingw32           -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template -DGNU %s
 // RUN: %clang_cc1 -triple x86_64-mingw32         -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DGNU %s
 // RUN: %clang_cc1 -triple x86_64-mingw32         -fsyntax-only -fms-extensions -verify -std=c++17 -Wunsupported-dll-base-class-template -DGNU %s
 // RUN: %clang_cc1 -triple i686-windows-itanium   -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DWI %s
 // RUN: %clang_cc1 -triple x86_64-windows-itanium -fsyntax-only -fms-extensions -verify -std=c++17 -Wunsupported-dll-base-class-template -DWI %s
+// RUN: %clang_cc1 -triple x86_64-scei-ps4        -fsyntax-only -fdeclspec      -verify -std=c++11 -Wunsupported-dll-base-class-template -DWI %s
+// RUN: %clang_cc1 -triple x86_64-scei-ps4        -fsyntax-only -fdeclspec      -verify -std=c++17 -Wunsupported-dll-base-class-template -DWI %s
 
 // Helper structs to make templates more expressive.
 struct ImplicitInst_Imported {};
 struct ExplicitDecl_Imported {};
 struct ExplicitInst_Imported {};
 struct ExplicitSpec_Imported {};
 struct ExplicitSpec_Def_Imported {};
 struct ExplicitSpec_InlineDef_Imported {};