Add support for -export_dynamic cmdline option

[pete]

Summary

Hi Nick, Lang

This adds support for the -export_dynamic command line option. In ld64, this prevents global symbols from being dead stripped in executables and dylibs.

I've added tests for all the combinations of executable/dylib/relocatable to make sure we match that behaviour.

Thanks,
Pete

[lhames]

Huh. ld64's man page only describes -export_dynamic as a modifier for dead-stripping during LTO, but it does seem to override -dead_strip for non-LTO cases too.

As far as I can tell your implementation matches ld64's behaviour. You might want to add a test case where the -dead_strip argument is after -export_dynamic to verify that -export_dynamic still takes precedence.

We may also want to talk to Nick to verify this behaviour and potentially update ld64's man-page.

LGTM.

• Lang.

[pete]

In D16026#332043, @lhames wrote:

As far as I can tell your implementation matches ld64's behaviour. You might want to add a test case where the -dead_strip argument is after -export_dynamic to verify that -export_dynamic still takes precedence.

Done. I've added another run line which handles this case.

We may also want to talk to Nick to verify this behaviour and potentially update ld64's man-page.

Will do. I'll double check that this is ok.

Thanks for the review.
Pete

lld/trunk/include/lld/ReaderWriter/MachOLinkingContext.h

enum ObjCConstraint {
     // GC compaction = 16
     objc_retainReleaseForSimulator = 32,
     objc_retainRelease
   };
 
   /// Initializes the context to sane default values given the specified output
   /// file type, arch, os, and minimum os version.  This should be called before
   /// other setXXX() methods.
-  void configure(HeaderFileType type, Arch arch, OS os, uint32_t minOSVersion);
+  void configure(HeaderFileType type, Arch arch, OS os, uint32_t minOSVersion,
+                 bool exportDynamicSymbols);
 
   void addPasses(PassManager &pm) override;
   bool validateImpl(raw_ostream &diagnostics) override;
   std::string demangle(StringRef symbolName) const override;
 
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   uint32_t getCPUType() const;

lld/trunk/lib/Driver/DarwinLdDriver.cpp

case OPT_ios_simulator_version_min:
         return false;
       }
       break;
     }
   } else {
     // No min-os version on command line, check environment variables
   }
 
+  // Handle export_dynamic
+  // FIXME: Should we warn when this applies to something other than a static
+  // executable or dylib?  Those are the only cases where this has an effect.
+  // Note, this has to come before ctx.configure() so that we get the correct
+  // value for _globalsAreDeadStripRoots.
+  bool exportDynamicSymbols = parsedArgs.hasArg(OPT_export_dynamic);
+
   // Now that there's enough information parsed in, let the linking context
   // set up default values.
-  ctx.configure(fileType, arch, os, minOSVersion);
+  ctx.configure(fileType, arch, os, minOSVersion, exportDynamicSymbols);
 
   // Handle -e xxx
   if (llvm::opt::Arg *entry = parsedArgs.getLastArg(OPT_entry))
     ctx.setEntrySymbolName(entry->getValue());
 
   // Handle -o xxx
   if (llvm::opt::Arg *outpath = parsedArgs.getLastArg(OPT_output))
     ctx.setOutputPath(outpath->getValue());

lld/trunk/lib/Driver/DarwinLdOptions.td

def pie : Flag<["-"], "pie">,
      Group<grp_main>;
 def no_pie : Flag<["-"], "no_pie">,
      HelpText<"Do not create Position Independent Executable">,
      Group<grp_main>;
 def stack_size : Separate<["-"], "stack_size">,
      HelpText<"Specifies the maximum stack size for the main thread in a program. "
               "Must be a page-size multiple. (default=8Mb)">,
      Group<grp_main>;
+def export_dynamic : Flag<["-"], "export_dynamic">,
+     HelpText<"Preserves all global symbols in main executables during LTO">,
+     Group<grp_main>;
 
 // dylib executable options
 def grp_dylib : OptionGroup<"opts">, HelpText<"DYLIB EXECUTABLE OPTIONS">;
 def install_name : Separate<["-"], "install_name">,
      MetaVarName<"<path>">,
      HelpText<"The dylib's install name">, Group<grp_dylib>;
 def mark_dead_strippable_dylib : Flag<["-"], "mark_dead_strippable_dylib">,
      HelpText<"Marks the dylib as having no side effects during initialization">,

lld/trunk/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

: _outputMachOType(MH_EXECUTE), _outputMachOTypeStatic(false),
       _printAtoms(false), _testingFileUsage(false), _keepPrivateExterns(false),
       _demangle(false), _archHandler(nullptr), _exportMode(ExportMode::globals),
       _debugInfoMode(DebugInfoMode::addDebugMap), _orderFileEntries(0),
       _flatNamespaceFile(nullptr) {}
 
 MachOLinkingContext::~MachOLinkingContext() {}
 
 void MachOLinkingContext::configure(HeaderFileType type, Arch arch, OS os,
-                                    uint32_t minOSVersion) {
+                                    uint32_t minOSVersion,
+                                    bool exportDynamicSymbols) {
   _outputMachOType = type;
   _arch = arch;
   _os = os;
   _osMinVersion = minOSVersion;
 
   // If min OS not specified on command line, use reasonable defaults.
   if (minOSVersion == 0) {
     switch (_arch) {
switch (os) {
           _pie = true;
        break;
        case OS::iOS_simulator:
         _pie = true;
        break;
        case OS::unknown:
        break;
     }
+    setGlobalsAreDeadStripRoots(exportDynamicSymbols);
     break;
   case llvm::MachO::MH_DYLIB:
-    setGlobalsAreDeadStripRoots(true);
+    setGlobalsAreDeadStripRoots(exportDynamicSymbols);
     break;
   case llvm::MachO::MH_BUNDLE:
     break;
   case llvm::MachO::MH_OBJECT:
     _printRemainingUndefines = false;
     _allowRemainingUndefines = true;
   default:
     break;

lld/trunk/test/mach-o/dead-strip-globals.yaml

+# RUN: lld -flavor darwin -arch x86_64 -dead_strip -export_dynamic %s -dylib %p/Inputs/libSystem.yaml -o %t.dylib -print_atoms | FileCheck -check-prefix=CHECK1 %s
+# RUN: lld -flavor darwin -arch x86_64 -export_dynamic -dead_strip %s -dylib %p/Inputs/libSystem.yaml -o %t.dylib -print_atoms | FileCheck -check-prefix=CHECK1 %s
+# RUN: lld -flavor darwin -arch x86_64 -dead_strip %s -dylib %p/Inputs/libSystem.yaml -o %t2.dylib -print_atoms | FileCheck -check-prefix=CHECK2 %s
+
+#
+# Test that -export_dynamic -dead-strip from removing globals.
+#
+
+---
+defined-atoms:
+  - name:            def
+    scope:           global
+    dead-strip:      never
+  - name:            dead
+    scope:           global
+shared-library-atoms:
+  - name:            dyld_stub_binder
+    load-name:       /usr/lib/libSystem.B.dylib
+    type:            unknown
+...
+
+# CHECK1:       name: def
+# CHECK1:       name: dead
+
+# CHECK2:       name: def
+# CHECK2-NOT:   name: dead
+

lld/trunk/unittests/DriverTests/DarwinLdDriverTest.cpp

 TEST_F(DarwinLdParserTest, DeadStripRootsExe) {
   EXPECT_TRUE(parse("ld", "-arch", "x86_64", "-dead_strip", "foo.o", nullptr));
   EXPECT_FALSE(_ctx.globalsAreDeadStripRoots());
 }
 
 TEST_F(DarwinLdParserTest, DeadStripRootsDylib) {
   EXPECT_TRUE(parse("ld", "-arch", "x86_64", "-dylib", "-dead_strip", "foo.o",
                     nullptr));
+  EXPECT_FALSE(_ctx.globalsAreDeadStripRoots());
+}
+
+TEST_F(DarwinLdParserTest, DeadStripRootsRelocatable) {
+  EXPECT_TRUE(parse("ld", "-arch", "x86_64", "-r", "-dead_strip", "foo.o",
+                    nullptr));
+  EXPECT_FALSE(_ctx.globalsAreDeadStripRoots());
+}
+
+TEST_F(DarwinLdParserTest, DeadStripRootsExportDynamicExe) {
+  EXPECT_TRUE(parse("ld", "-arch", "x86_64", "-dead_strip",
+                    "-export_dynamic", "foo.o", nullptr));
   EXPECT_TRUE(_ctx.globalsAreDeadStripRoots());
 }
 
+TEST_F(DarwinLdParserTest, DeadStripRootsExportDynamicDylib) {
+  EXPECT_TRUE(parse("ld", "-arch", "x86_64", "-dylib", "-dead_strip",
+                    "-export_dynamic", "foo.o",
+                    nullptr));
+  EXPECT_TRUE(_ctx.globalsAreDeadStripRoots());
+}
+
+TEST_F(DarwinLdParserTest, DeadStripRootsExportDynamicRelocatable) {
+  EXPECT_TRUE(parse("ld", "-arch", "x86_64", "-r", "-dead_strip",
+                    "-export_dynamic", "foo.o", nullptr));
+  EXPECT_FALSE(_ctx.globalsAreDeadStripRoots());
+}
+
 TEST_F(DarwinLdParserTest, Arch) {
   EXPECT_TRUE(parse("ld", "-arch", "x86_64", "foo.o", nullptr));
   EXPECT_EQ(MachOLinkingContext::arch_x86_64, _ctx.arch());
   EXPECT_EQ((uint32_t)llvm::MachO::CPU_TYPE_X86_64, _ctx.getCPUType());
   EXPECT_EQ(llvm::MachO::CPU_SUBTYPE_X86_64_ALL, _ctx.getCPUSubType());
 }
 
 TEST_F(DarwinLdParserTest, Arch_x86) {