Add the ability to map DLL storage class to visibility

[bd1976llvm]

Summary

For PlayStation we offer source code compatibility with Microsoft's dllimport/export annotations; however, our file format is based on ELF.

To support this we translate from DLL storage class to ELF visibility at the end of codegen in Clang.

Other toolchains have used similar strategies (e.g. see the documentation for this ARM toolchain - https://developer.arm.com/documentation/dui0530/i/migrating-from-rvct-v3-1-to-rvct-v4-0/changes-to-symbol-visibility-between-rvct-v3-1-and-rvct-v4-0).

This patch adds the ability to perform this translation. Options are provided to support customizing the mapping behaviour.

[rnk]

Seems reasonable. I considered suggesting that this be a module pass, but I don't think it's worth it.

clang/include/clang/Driver/Options.td

4292

I don't think there is any benefit in having two spellings for this flag, one for cc1 and one for the driver. I'm guessing you are copying some prior art here, but I don't think it's necessary. I'd standardize on the _EQ versions, and add the CC1Option flag to the _EQ flags above.

clang/lib/CodeGen/CodeGenModule.cpp

713

This method (Release) is really long, and handles a lot of conceptually unrelated things to do at the end of codegen. Let's try to shorten it. Please move the bulk of this logic out into its own helper. I think it just needs langopts and the module.

724

I'd suggest one loop over M.global_values() to simplify the code. It will also handle ifuncs, for better or worse.

clang/lib/Driver/ToolChains/Clang.cpp

5237

I think if you standardize on the spelling with =, then there's a shorter way to forward driver flags to cc1. I forget the details, though.

[MaskRay]

clang/lib/Driver/ToolChains/Clang.cpp

5237

if (A->getOption().matches(options::OPT_fvisibility_from_dllstorageclass_EQ))
  A->render(Args, CmdArgs);

[MaskRay]

clang/test/Driver/visibility-dllstorageclass.c

1

This is not needed since lib/Target/X86/ code is not used. For -###, usually this is not needed.

33

NOT patterns can easily get stale and not check anything if no positive option is used together.

Can the values "hidden"/"protected" be removed from the pattern?

39

-DAG is actually more difficult to update. Keep the options in order and use -SAME

[bd1976llvm]

clang/include/clang/Driver/Options.td

4292

Thanks - this much better than what I had.

clang/lib/CodeGen/CodeGenModule.cpp

713

Thanks.

724

Thanks - it's shorter and handling ifuncs is a consistency improvement.

clang/lib/Driver/ToolChains/Clang.cpp

5237

Thanks - great suggestions.

clang/test/Driver/visibility-dllstorageclass.c

1

Thanks - obvious now you have pointed this out.

33

They can - thanks!

39

Thanks!

[bd1976llvm]

addressed review comments and made some other improvements:

• reduced options logic using helpers e.g. AddLastArg().
• simplified and fixed PS4 options logic.
• added diagnostic for conflicting with other visibility options and testing for this.
• added testing for unused diagnostics for the -fvisbility-from-dllstorageclass dependent options e.g. for -fvisibility-dllexport if -fvisbility-from-dllstorageclass is not set.
• hardened and tidied tests.

[rnk]

I'm happy with this, but check that @MaskRay is satisfied with it before landing.

[MaskRay]

clang/include/clang/Basic/LangOptions.def

309

Note, other comments are not capitalized.

clang/include/clang/Driver/Options.td

1960

DriverOption should be removed

[bd1976llvm]

Addressed the review comments and made some minor improvements.

I also removed the diagnostic that -fvisibility-from-dllstorageclass is incompatible with other visibility options. I'm sorry to request a change like this after people have said that they are happy with the patch. However, I realised that I haven't tested that diagnostic downstream and I found a case where we were setting a visibility option to work around a bug. Therefore, I would like to remove that error from this upstream patch and experiment with what works best for us w.r.t to incompatibility diagnostics downstream before adding them upstream at a later time.

[bd1976llvm]

clang/include/clang/Basic/LangOptions.def

309

I have uncapitalized - thanks!

clang/include/clang/Driver/Options.td

1960

Thanks.

clang/include/clang/Basic/LangOptions.def

 
 ENUM_LANGOPT(GC, GCMode, 2, NonGC, "Objective-C Garbage Collection mode")
 ENUM_LANGOPT(ValueVisibilityMode, Visibility, 3, DefaultVisibility,
              "default visibility for functions and variables [-fvisibility]")
 ENUM_LANGOPT(TypeVisibilityMode, Visibility, 3, DefaultVisibility,
              "default visibility for types [-ftype-visibility]")
 LANGOPT(SetVisibilityForExternDecls, 1, 0,
         "apply global symbol visibility to external declarations without an explicit visibility")
+LANGOPT(VisibilityDLLStorageClass, 1, 0,
+        "Set the visiblity of globals from their DLL storage class [-fvisibility-from-dllstorageclass]")
+ENUM_LANGOPT(DLLExportVisibility, Visibility, 3, DefaultVisibility,
+             "Visibility for functions and variables with dllexport annotations [-fvisibility-from-dllstorageclass]")
+ENUM_LANGOPT(NoDLLStorageClassVisibility, Visibility, 3, HiddenVisibility,
+             "Visibility for functions and variables without an explicit DLL storage class [-fvisibility-from-dllstorageclass]")
+ENUM_LANGOPT(ExternDeclDLLImportVisibility, Visibility, 3, DefaultVisibility,
+             "Visibility for external declarations with dllimport annotations [-fvisibility-from-dllstorageclass]")
+ENUM_LANGOPT(ExternDeclNoDLLStorageClassVisibility, Visibility, 3, HiddenVisibility,
+             "Visibility for external declarations without an explicit DLL storage class [-fvisibility-from-dllstorageclass]")
 BENIGN_LANGOPT(SemanticInterposition        , 1, 0, "semantic interposition")
 BENIGN_LANGOPT(ExplicitNoSemanticInterposition, 1, 0, "explicitly no semantic interposition")
 ENUM_LANGOPT(StackProtector, StackProtectorMode, 2, SSPOff,
              "stack protector mode")
 ENUM_LANGOPT(TrivialAutoVarInit, TrivialAutoVarInitKind, 2, TrivialAutoVarInitKind::Uninitialized,
              "trivial automatic variable initialization")
 VALUE_LANGOPT(TrivialAutoVarInitStopAfter, 32, 0,
              "stop trivial automatic variable initialization after the specified number of instances. Must be greater than 0.")

clang/include/clang/Driver/Options.td

 def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
 def fregister_global_dtors_with_atexit : Flag<["-"], "fregister-global-dtors-with-atexit">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use atexit or __cxa_atexit to register global destructors">;
 defm use_init_array : OptOutFFlag<"use-init-array", "", "Use .ctors/.dtors instead of .init_array/.fini_array">;
 def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>;
 def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>,
   HelpText<"Generate verbose assembly output">;
 def dA : Flag<["-"], "dA">, Alias<fverbose_asm>;
+defm visibility_from_dllstorageclass : OptInFFlag<"visibility-from-dllstorageclass", "Set the visiblity of symbols in the generated code from their DLL storage class">;
+def fvisibility_dllexport_EQ : Joined<["-"], "fvisibility-dllexport=">, Group<f_Group>,
+  HelpText<"The visibility for dllexport defintions [-fvisibility-from-dllstorageclass]">, Values<"hidden,protected,default">;
+def fvisibility_nodllstorageclass_EQ : Joined<["-"], "fvisibility-nodllstorageclass=">, Group<f_Group>,
+  HelpText<"The visibility for defintiions without an explicit DLL export class [-fvisibility-from-dllstorageclass]">, Values<"hidden,protected,default">;
+def fvisibility_externs_dllimport_EQ : Joined<["-"], "fvisibility-externs-dllimport=">, Group<f_Group>,
+  HelpText<"The visibility for dllimport external declarations [-fvisibility-from-dllstorageclass]">, Values<"hidden,protected,default">;
+def fvisibility_externs_nodllstorageclass_EQ : Joined<["-"], "fvisibility-externs-nodllstorageclass=">, Group<f_Group>,
+  HelpText<"The visibility for external declarations without an explicit DLL dllstorageclass [-fvisibility-from-dllstorageclass]">, Values<"hidden,protected,default">;
 def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>,
   HelpText<"Set the default symbol visibility for all global declarations">, Values<"hidden,default">;
 def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>,
   HelpText<"Give inline C++ member functions hidden visibility by default">,
   Flags<[CC1Option]>;
 def fvisibility_inlines_hidden_static_local_var :
   Flag<["-"], "fvisibility-inlines-hidden-static-local-var">, Group<f_Group>,
   HelpText<"When -fvisibility-inlines-hidden is enabled, static variables in "

 def stack_protector_buffer_size : Separate<["-"], "stack-protector-buffer-size">,
   HelpText<"Lower bound for a buffer to be considered for stack protection">;
 def fvisibility : Separate<["-"], "fvisibility">,
   HelpText<"Default type and symbol visibility">;
 def ftype_visibility : Separate<["-"], "ftype-visibility">,
   HelpText<"Default type visibility">;
 def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">,
   HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">;
+def fvisibility_dllexport : Separate<["-"], "fvisibility-dllexport">,
+  HelpText<"The visibility for dllexport definitions [-fvisibility-from-dllstorageclass]">;
+def fvisibility_nodllstorageclass : Separate<["-"], "fvisibility-nodllstorageclass">,
+  HelpText<"The visibility for definitions without an explicit DLL storage class [-fvisibility-from-dllstorageclass]">;
+def fvisibility_externs_dllimport : Separate<["-"], "fvisibility-externs-dllimport">,
+  HelpText<"The visibility for dllimport external declarations [-fvisibility-from-dllstorageclass]">;
+def fvisibility_externs_nodllstorageclass : Separate<["-"], "fvisibility-externs-nodllstorageclass">,
+  HelpText<"The visibility for external declarations without an explicit DLL storage class [-fvisibility-from-dllstorageclass]">;
 def ftemplate_depth : Separate<["-"], "ftemplate-depth">,
   HelpText<"Maximum depth of recursive template instantiation">;
 def foperator_arrow_depth : Separate<["-"], "foperator-arrow-depth">,
   HelpText<"Maximum number of 'operator->'s to call for a member access">;
 def fconstexpr_depth : Separate<["-"], "fconstexpr-depth">,
   HelpText<"Maximum depth of recursive constexpr function calls">;
 def fconstexpr_steps : Separate<["-"], "fconstexpr-steps">,
   HelpText<"Maximum number of steps in constexpr function evaluation">;

clang/lib/CodeGen/CodeGenModule.cpp

if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
     if (Mismatched > 0)
       Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
 
     if (Missing > 0)
       Diags.Report(diag::warn_profile_data_missing) << Visited << Missing;
   }
 }
 
+static void translateDLLStorageClass(
+    llvm::GlobalValue &GV,
+    llvm::GlobalValue::VisibilityTypes DLLExportVisibility,
+    llvm::GlobalValue::VisibilityTypes NoDLLStorageClassVisibility,
+    llvm::GlobalValue::VisibilityTypes ExternDeclDLLImportVisibility,
+    llvm::GlobalValue::VisibilityTypes ExternDeclNoDLLStorageClassVisibility) {
+  if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
+    return;
+
+  if (GV.isDeclarationForLinker()) {
+    GV.setVisibility(GV.getDLLStorageClass() ==
+                             llvm::GlobalValue::DLLImportStorageClass
+                         ? ExternDeclDLLImportVisibility
+                         : ExternDeclNoDLLStorageClassVisibility);
+  } else {
+    GV.setVisibility(GV.getDLLStorageClass() ==
+                             llvm::GlobalValue::DLLExportStorageClass
+                         ? DLLExportVisibility
+                         : NoDLLStorageClassVisibility);
+  }
+
+  GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
+}
+
 void CodeGenModule::Release() {
   EmitDeferred();
   EmitVTablesOpportunistically();
   applyGlobalValReplacements();
   applyReplacements();
   checkAliases();
   emitMultiVersionFunctions();
   EmitCXXGlobalInitFunc();
if (getCodeGenOpts().EmitVersionIdentMetadata)
     EmitVersionIdentMetadata();
 
   if (!getCodeGenOpts().RecordCommandLine.empty())
     EmitCommandLineMetadata();
 
   getTargetCodeGenInfo().emitTargetMetadata(*this, MangledDeclNames);
 
   EmitBackendOptionsMetadata(getCodeGenOpts());
+
+  // Set visibility from DLL export class
+  // We do this at the end of LLVM IR generation; after any operation
+  // that might affect the DLL storage class or the visibility, and
+  // before anything that might act on these.
+  if (LangOpts.VisibilityDLLStorageClass) {
+    llvm::GlobalValue::VisibilityTypes DLLExportVisibility =
+        GetLLVMVisibility(getLangOpts().getDLLExportVisibility());
+    llvm::GlobalValue::VisibilityTypes NoDLLStorageClassVisibility =
+        GetLLVMVisibility(getLangOpts().getNoDLLStorageClassVisibility());
+    llvm::GlobalValue::VisibilityTypes ExternDeclDLLImportVisibility =
+        GetLLVMVisibility(getLangOpts().getExternDeclDLLImportVisibility());
+    llvm::GlobalValue::VisibilityTypes ExternDeclNoDLLStorageClassVisibility =
+        GetLLVMVisibility(getLangOpts().getExternDeclNoDLLStorageClassVisibility());
+
+    auto &M = getModule();
+    for (llvm::Function &F : M.functions())
+      translateDLLStorageClass(F, DLLExportVisibility, NoDLLStorageClassVisibility,
+                           ExternDeclDLLImportVisibility,
+                           ExternDeclNoDLLStorageClassVisibility);
+
+    for (llvm::GlobalVariable &GV : M.globals())
+      translateDLLStorageClass(GV, DLLExportVisibility, NoDLLStorageClassVisibility,
+                           ExternDeclDLLImportVisibility,
+                           ExternDeclNoDLLStorageClassVisibility);
+
+    for (llvm::GlobalAlias &GA : M.aliases())
+      translateDLLStorageClass(GA, DLLExportVisibility, NoDLLStorageClassVisibility,
+                           ExternDeclDLLImportVisibility,
+                           ExternDeclNoDLLStorageClassVisibility);
+  }
 }
 
 void CodeGenModule::EmitOpenCLMetadata() {
   // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
   // opencl.ocl.version named metadata node.
   // C++ is backwards compatible with OpenCL v2.0.
   // FIXME: We might need to add CXX version at some point too?
   auto Version = LangOpts.OpenCLCPlusPlus ? 200 : LangOpts.OpenCLVersion;

clang/lib/Driver/ToolChains/Clang.cpp

if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
       assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
       CmdArgs.push_back("-fvisibility");
       CmdArgs.push_back("hidden");
       CmdArgs.push_back("-ftype-visibility");
       CmdArgs.push_back("default");
     }
   }
 
+  if (const Arg *A =
+          Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
+                          options::OPT_fno_visibility_from_dllstorageclass)) {
+    if (A->getOption().matches(options::OPT_fvisibility_from_dllstorageclass)) {
+        CmdArgs.push_back("-fvisibility-from-dllstorageclass");
+
+      if (const Arg *E =
+              Args.getLastArg(options::OPT_fvisibility_dllexport_EQ)) {
+        CmdArgs.push_back("-fvisibility-dllexport");
+        CmdArgs.push_back(E->getValue());
+      }
+
+      if (const Arg *E =
+              Args.getLastArg(options::OPT_fvisibility_nodllstorageclass_EQ)) {
+        CmdArgs.push_back("-fvisibility-nodllstorageclass");
+        CmdArgs.push_back(E->getValue());
+      }
+
+      if (const Arg *E =
+              Args.getLastArg(options::OPT_fvisibility_externs_dllimport_EQ)) {
+        CmdArgs.push_back("-fvisibility-externs-dllimport");
+        CmdArgs.push_back(E->getValue());
+      }
+
+      if (const Arg *E = Args.getLastArg(
+              options::OPT_fvisibility_externs_nodllstorageclass_EQ)) {
+        CmdArgs.push_back("-fvisibility-externs-nodllstorageclass");
+        CmdArgs.push_back(E->getValue());
+      }
+    }
+  }
+
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
                            options::OPT_fno_visibility_inlines_hidden_static_local_var);
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
 
   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
 
   // Forward -f (flag) options which we can pass directly.

clang/lib/Driver/ToolChains/PS4CPU.cpp

SanitizerMask toolchains::PS4CPU::getSupportedSanitizers() const {
   Res |= SanitizerKind::Address;
   Res |= SanitizerKind::PointerCompare;
   Res |= SanitizerKind::PointerSubtract;
   Res |= SanitizerKind::Vptr;
   return Res;
 }
 
 void toolchains::PS4CPU::addClangTargetOptions(
-      const ArgList &DriverArgs,
-      ArgStringList &CC1Args,
-      Action::OffloadKind DeviceOffloadingKind) const {
+    const ArgList &DriverArgs, ArgStringList &CC1Args,
   // PS4 does not use init arrays.
   if (DriverArgs.hasArg(options::OPT_fuse_init_array)) {
     Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array);
     getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target)
         << A->getAsString(DriverArgs) << getTriple().str();
   }
 
   CC1Args.push_back("-fno-use-init-array");
+
+  const Arg *A =
+      DriverArgs.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
+                            options::OPT_fno_visibility_from_dllstorageclass);
+  if (!A) {
+    CC1Args.push_back("-fvisibility-from-dllstorageclass");
+
+    CC1Args.push_back("-fvisibility-dllexport");
+    if (const Arg *E =
+            DriverArgs.getLastArg(options::OPT_fvisibility_dllexport_EQ)) {
+      CC1Args.push_back(E->getValue());
+    } else {
+      CC1Args.push_back("protected");
+    }
+
+    CC1Args.push_back("-fvisibility-externs-nodllstorageclass");
+    if (const Arg *E = DriverArgs.getLastArg(
+            options::OPT_fvisibility_externs_nodllstorageclass_EQ)) {
+      CC1Args.push_back(E->getValue());
+    } else {
+      CC1Args.push_back("default");
+    }
+
+    if (const Arg *E = DriverArgs.getLastArg(
+            options::OPT_fvisibility_nodllstorageclass_EQ)) {
+      CC1Args.push_back("-fvisibility-nodllstorageclass");
+      CC1Args.push_back(E->getValue());
+    }
+
+    if (const Arg *E = DriverArgs.getLastArg(
+            options::OPT_fvisibility_externs_dllimport_EQ)) {
+      CC1Args.push_back("-fvisibility-externs-dllimport");
+      CC1Args.push_back(E->getValue());
+    }
+  } else if (!A->getOption().matches(
+                 options::OPT_fno_visibility_from_dllstorageclass)) {
+    if (!DriverArgs.hasArg(options::OPT_fvisibility_dllexport_EQ)) {
+      CC1Args.push_back("-fvisibility-dllexport");
+      CC1Args.push_back("protected");
+    }
+
+    if (!DriverArgs.hasArg(
+            options::OPT_fvisibility_externs_nodllstorageclass_EQ)) {
+      CC1Args.push_back("-fvisibility-externs-nodllstorageclass");
+      CC1Args.push_back("default");
+    }
+  }
 }

clang/lib/Frontend/CompilerInvocation.cpp

if (Args.hasArg(OPT_fvisibility_inlines_hidden_static_local_var))
     Opts.VisibilityInlinesHiddenStaticLocalVar = 1;
 
   if (Args.hasArg(OPT_fvisibility_global_new_delete_hidden))
     Opts.GlobalAllocationFunctionVisibilityHidden = 1;
 
   if (Args.hasArg(OPT_fapply_global_visibility_to_externs))
     Opts.SetVisibilityForExternDecls = 1;
 
+  if (Args.hasArg(OPT_fvisibility_from_dllstorageclass)) {
+    Opts.VisibilityDLLStorageClass = 1;
+
+    // Translate defintions to default visibility by default.
+    if (Arg *O = Args.getLastArg(OPT_fvisibility_dllexport)) {
+      Opts.setDLLExportVisibility(parseVisibility(O, Args, Diags));
+    } else {
+      Opts.setDLLExportVisibility(DefaultVisibility);
+    }
+
+    // Translate defintions without an explict DLL export class to default
+    // visibility by default.
+    if (Arg *O = Args.getLastArg(OPT_fvisibility_nodllstorageclass)) {
+      Opts.setNoDLLStorageClassVisibility(parseVisibility(O, Args, Diags));
+    } else {
+      Opts.setNoDLLStorageClassVisibility(HiddenVisibility);
+    }
+
+    // Translate dllimport external declarations to default visibility by
+    // default.
+    if (Arg *O = Args.getLastArg(OPT_fvisibility_externs_dllimport)) {
+      Opts.setExternDeclDLLImportVisibility(parseVisibility(O, Args, Diags));
+    } else {
+      Opts.setExternDeclDLLImportVisibility(DefaultVisibility);
+    }
+
+    // Translate external declarations without an explicit DLL export class
+    // to hidden visibility by default.
+    if (Arg *O = Args.getLastArg(OPT_fvisibility_externs_nodllstorageclass)) {
+      Opts.setExternDeclNoDLLStorageClassVisibility(
+          parseVisibility(O, Args, Diags));
+    } else {
+      Opts.setExternDeclNoDLLStorageClassVisibility(HiddenVisibility);
+    }
+  }
+
   if (Args.hasArg(OPT_ftrapv)) {
     Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
     // Set the handler, if one is specified.
     Opts.OverflowHandler =
         std::string(Args.getLastArgValue(OPT_ftrapv_handler));
   }
   else if (Args.hasArg(OPT_fwrapv))
     Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);

clang/test/CodeGenCXX/visibility-dllstorageclass.cpp

+// REQUIRES: x86-registered-target
+
+// Test that -fvisibility-from-dllstorageclass translates export class into visibility
+// and that it overrides the effect of visibility options and annotations.
+
+// RUN: %clang_cc1 -triple x86_64-unknown-windows-itanium -fvisibility-from-dllstorageclass -fdeclspec -fvisibility hidden -x c++  %s -S -emit-llvm -o - | FileCheck %s --check-prefixes=DEFAULT
+// RUN: %clang_cc1 -triple x86_64-unknown-windows-itanium -fvisibility-from-dllstorageclass -fvisibility-dllexport hidden -fvisibility-nodllstorageclass protected -fvisibility-externs-dllimport hidden -fvisibility-externs-nodllstorageclass protected -fdeclspec -x c++  %s -S -emit-llvm -o - | FileCheck %s --check-prefixes=EXPLICIT
+
+// Function
+void f() {}
+void __declspec(dllexport) exported_f() {}
+// DEFAULT-DAG: define hidden void @_Z1fv()
+// DEFAULT-DAG: define dso_local  void @_Z10exported_fv()
+// EXPLICIT-DAG: define protected void @_Z1fv()
+// EXPLICIT-DAG: define hidden void @_Z10exported_fv()
+
+// Variable
+int d = 123;
+__declspec(dllexport) int exported_d = 123;
+// DEFAULT-DAG: @d = hidden global
+// DEFAULT-DAG: @exported_d = dso_local global
+// EXPLICIT-DAG: @d = protected global
+// EXPLICIT-DAG: @exported_d = hidden global
+
+// Alias
+extern "C" void aliased() {}
+void a() __attribute__((alias("aliased")));
+void __declspec(dllexport) a_exported() __attribute__((alias("aliased")));
+// DEFAULT-DAG: @_Z1av = hidden alias
+// DEFAULT-DAG: @_Z10a_exportedv = dso_local alias
+// EXPLICIT-DAG: @_Z1av = protected alias
+// EXPLICIT-DAG: @_Z10a_exportedv = hidden alias
+
+// Declaration
+extern void e();
+extern void __declspec(dllimport) imported_e();
+void use_declarations(){e(); imported_e();}
+// DEFAULT-DAG: declare hidden void @_Z1ev()
+// DEFAULT-DAG: declare void @_Z10imported_ev()
+// EXPLICIT-DAG: declare protected void @_Z1ev()
+// EXPLICIT-DAG: declare hidden void @_Z10imported_ev()
+
+// Show that -fvisibility-from-dllstorageclass overrides the effect of visibility annotations.
+
+struct __attribute__((type_visibility("protected"))) t {
+  virtual void foo();
+};
+void t::foo() {}
+// DEFAULT-DAG: @_ZTV1t = hidden unnamed_addr constant
+
+int v __attribute__ ((__visibility__ ("protected"))) = 123;
+// DEFAULT-DAG: @v = hidden global
+
+#pragma GCC visibility push(protected)
+int p = 345;
+#pragma GCC visibility pop
+// DEFAULT-DAG: @p = hidden global

clang/test/Driver/ps4-visibility-dllstorageclass.c

+// REQUIRES: x86-registered-target
+
+// RUN: %clang -### -target x86_64-scei-ps4 %s -o - 2>&1 | \
+// RUN:   FileCheck %s -check-prefix=SET --implicit-check-not="-fvisibility-nodllstorageclass" --implicit-check-not="-fvisibility-externs-dllimport"
+
+// RUN: %clang -### -target x86_64-scei-ps4 -fno-visibility-from-dllstorageclass -fvisibility-from-dllstorageclass %s -o - 2>&1 | \
+// RUN:   FileCheck %s -check-prefix=SET
+
+// SET-DAG: "-fvisibility-from-dllstorageclass"
+// SET-DAG: "-fvisibility-dllexport" "protected"
+// SET-DAG: "-fvisibility-externs-nodllstorageclass" "default"
+
+// RUN: %clang -### -target x86_64-scei-ps4 \
+// RUN:     -fvisibility-from-dllstorageclass \
+// RUN:     -fvisibility-dllexport=hidden \
+// RUN:     -fvisibility-nodllstorageclass=protected \
+// RUN:     -fvisibility-externs-dllimport=hidden \
+// RUN:     -fvisibility-externs-nodllstorageclass=protected \
+// RUN:     -fno-visibility-from-dllstorageclass \
+// RUN:     %s -o - 2>&1 | \
+// RUN:   FileCheck %s -check-prefix=NONE
+
+// NONE-NOT: "-fvisibility-from-dllstorageclass"
+// NONE-NOT: "-fvisibility-dllexport"
+// NONE-NOT: "-fvisibility-nodllstorageclass"
+// NONE-NOT: "-fvisibility-externs-dllimport"
+// NONE-NOT: "-fvisibility-externs-nodllstorageclass"
+
+// RUN: %clang -### -target x86_64-scei-ps4 \
+// RUN:     -fvisibility-nodllstorageclass=protected \
+// RUN:     -fvisibility-externs-dllimport=hidden \
+// RUN:     %s -o - 2>&1 | \
+// RUN:   FileCheck %s -check-prefix=DEFAULTS
+
+// RUN: %clang -### -target x86_64-scei-ps4 \
+// RUN:     -fvisibility-from-dllstorageclass \
+// RUN:     -fvisibility-nodllstorageclass=protected \
+// RUN:     -fvisibility-externs-dllimport=hidden \
+// RUN:     %s -o - 2>&1 | \
+// RUN:   FileCheck %s -check-prefix=DEFAULTS
+
+// DEFAULTS-DAG: "-fvisibility-from-dllstorageclass"
+// DEFAULTS-DAG: "-fvisibility-dllexport" "protected"
+// DEFAULTS-DAG: "-fvisibility-nodllstorageclass" "protected"
+// DEFAULTS-DAG: "-fvisibility-externs-dllimport" "hidden"
+// DEFAULTS-DAG: "-fvisibility-externs-nodllstorageclass" "default"
+
+// RUN: %clang -### -target x86_64-scei-ps4 \
+// RUN:     -fvisibility-dllexport=default \
+// RUN:     -fvisibility-dllexport=hidden \
+// RUN:     -fvisibility-nodllstorageclass=default \
+// RUN:     -fvisibility-nodllstorageclass=protected \
+// RUN:     -fvisibility-externs-dllimport=default \
+// RUN:     -fvisibility-externs-dllimport=hidden \
+// RUN:     -fvisibility-externs-nodllstorageclass=default \
+// RUN:     -fvisibility-externs-nodllstorageclass=protected \
+// RUN:     %s -o - 2>&1 | \
+// RUN:   FileCheck %s -check-prefix=ALL
+
+// RUN: %clang -### -target x86_64-scei-ps4 \
+// RUN:     -fvisibility-from-dllstorageclass \
+// RUN:     -fvisibility-dllexport=default \
+// RUN:     -fvisibility-dllexport=hidden \
+// RUN:     -fvisibility-nodllstorageclass=default \
+// RUN:     -fvisibility-nodllstorageclass=protected \
+// RUN:     -fvisibility-externs-dllimport=default \
+// RUN:     -fvisibility-externs-dllimport=hidden \
+// RUN:     -fvisibility-externs-nodllstorageclass=default \
+// RUN:     -fvisibility-externs-nodllstorageclass=protected \
+// RUN:     %s -o - 2>&1 | \
+// RUN:   FileCheck %s -check-prefix=ALL
+
+// ALL-DAG: "-fvisibility-from-dllstorageclass"
+// ALL-DAG: "-fvisibility-dllexport" "hidden"
+// ALL-DAG: "-fvisibility-nodllstorageclass" "protected"
+// ALL-DAG: "-fvisibility-externs-dllimport" "hidden"
+// ALL-DAG: "-fvisibility-externs-nodllstorageclass" "protected"

clang/test/Driver/visibility-dllstorageclass.c

+// REQUIRES: x86-registered-target
+
+// Check behaviour of -fvisibility-from-dllstorageclass options
+
+// RUN: %clang -target x86_64-unknown-windows-itanium -fdeclspec -S -### %s 2>&1 | FileCheck %s --check-prefixes=NONE,SHARED
+
+// RUN: %clang -target x86_64-unknown-windows-itanium -fdeclspec -fvisibility-from-dllstorageclass -fno-visibility-from-dllstorageclass -S -### %s 2>&1 | \ 
+// RUN:   FileCheck %s --check-prefixes=NONE,SHARED
+
+// RUN: %clang -target x86_64-unknown-windows-itanium -fdeclspec -fno-visibility-from-dllstorageclass -fvisibility-from-dllstorageclass -S -### %s 2>&1 | \ 
+// RUN:   FileCheck %s --check-prefixes=SET,SHARED
+
+// RUN: %clang -target x86_64-unknown-windows-itanium -fdeclspec \
+// RUN:     -fvisibility-dllexport=hidden \
+// RUN:     -fvisibility-nodllstorageclass=protected \
+// RUN:     -fvisibility-externs-dllimport=hidden \
+// RUN:     -fvisibility-externs-nodllstorageclass=protected -S -### %s 2>&1 | \
+// RUN:   FileCheck %s --check-prefixes=NONE,SHARED
+
+// RUN: %clang -target x86_64-unknown-windows-itanium -fdeclspec \
+// RUN:     -fvisibility-from-dllstorageclass \
+// RUN:     -fvisibility-dllexport=default \
+// RUN:     -fvisibility-dllexport=hidden  \
+// RUN:     -fvisibility-nodllstorageclass=default \
+// RUN:     -fvisibility-nodllstorageclass=protected \
+// RUN:     -fvisibility-externs-dllimport=default \
+// RUN:     -fvisibility-externs-dllimport=hidden \
+// RUN:     -fvisibility-externs-nodllstorageclass=default \
+// RUN:     -fvisibility-externs-nodllstorageclass=protected -S -### %s 2>&1 | \
+// RUN:   FileCheck %s --check-prefixes=SET,ALL
+
+// NONE-NOT: "-fvisibility-from-dllstorageclass"
+// SHARED-NOT: "-fvisibility-dllexport" "hidden"
+// SHARED-NOT: "-fvisibility-nodllstorageclass" "protected"
+// SHARED-NOT: "-fvisibility-externs-dllimport" "hidden"
+// SHARED-NOT: "-fvisibility-externs-nodllstorageclass" "protected"
+
+// SET: "-fvisibility-from-dllstorageclass"
+// ALL-DAG: "-fvisibility-dllexport" "hidden"
+// ALL-DAG: "-fvisibility-nodllstorageclass" "protected"
+// ALL-DAG: "-fvisibility-externs-dllimport" "hidden"
+// ALL-DAG: "-fvisibility-externs-nodllstorageclass" "protected"