[SR-648] Add option to create statically linked binaries

- Adds -static-executable option to swiftc to use along with
  -emit-executable

- Only works on Linux for now, adds a stub to replace select
  libdl functions with a fatal error message to catch other
  libs that use dlopen() etc (eg libicu) to aid in debugging
  since they wont work on static binaries anyway and could just
  silently fail otherwise

- Darwin doesnt support static binaries, see
  https://developer.apple.com/library/content/qa/qa1118/_index.html

Author: spevans

include/swift/Option/Options.td

@@ -278,6 +278,12 @@ def no_static_stdlib: Flag<["-"], "no-static-stdlib">,
   Flags<[HelpHidden]>,
   HelpText<"Don't statically link the Swift standard library">;
 
+def static_executable : Flag<["-"], "static-executable">,
+  HelpText<"Statically link the executable">;
+def no_static_executable : Flag<["-"], "no-static-executable">,
+  Flags<[HelpHidden]>,
+  HelpText<"Don't statically link the executable">;
+
 def use_ld : Joined<["-"], "use-ld=">,
   Flags<[DoesNotAffectIncrementalBuild]>,
   HelpText<"Specifies the linker to be used">;

lib/Driver/ToolChains.cpp

@@ -948,6 +948,12 @@ toolchains::Darwin::constructInvocation(const LinkJobAction &job,
   assert(context.Output.getPrimaryOutputType() == types::TY_Image &&
          "Invalid linker output type.");
 
+  if (context.Args.hasFlag(options::OPT_static_executable,
+                           options::OPT_no_static_executable,
+                           false)) {
+    llvm::report_fatal_error("-static-executable is not supported on Darwin");
+  }
+
   const Driver &D = getDriver();
   const llvm::Triple &Triple = getTriple();
 
@@ -1353,9 +1359,38 @@ toolchains::GenericUnix::constructInvocation(const LinkJobAction &job,
 
   // Link the standard library.
   Arguments.push_back("-L");
-  if (context.Args.hasFlag(options::OPT_static_stdlib,
-                            options::OPT_no_static_stdlib,
-                            false)) {
+  if (context.Args.hasFlag(options::OPT_static_executable,
+                           options::OPT_no_static_executable,
+                           false)) {
+    SmallString<128> StaticRuntimeLibPath;
+    getRuntimeStaticLibraryPath(StaticRuntimeLibPath, context.Args, *this);
+    Arguments.push_back(context.Args.MakeArgString(StaticRuntimeLibPath));
+
+    SmallString<128> StaticStubObjectPath = StaticRuntimeLibPath;
+    llvm::sys::path::append(StaticStubObjectPath, "static_stub.o");
+    auto ObjectPath = StaticStubObjectPath.str();
+
+    if (llvm::sys::fs::is_regular_file(ObjectPath)) {
+      // FIXME: It would be better if these were extracted from static_stub.o
+      // using  `swift-autolink-extract'
+      Arguments.push_back(context.Args.MakeArgString(ObjectPath));
+      Arguments.push_back("-static");
+      Arguments.push_back("-Xlinker");
+      Arguments.push_back("--defsym=__swift2_protocol_conformances_start=.swift2_protocol_conformances_start");
+      Arguments.push_back("-Xlinker");
+      Arguments.push_back("--defsym=__swift2_type_metadata_start=.swift2_type_metadata_start");
+      Arguments.push_back("-lswiftCore");
+      Arguments.push_back("-licui18n");
+      Arguments.push_back("-licuuc");
+      Arguments.push_back("-licudata");
+      Arguments.push_back("-lpthread");
+    } else {
+      llvm::report_fatal_error("-static-executable not supported on this platform");
+    }
+  }
+  else if (context.Args.hasFlag(options::OPT_static_stdlib,
+                                options::OPT_no_static_stdlib,
+                                false)) {
     SmallString<128> StaticRuntimeLibPath;
     getRuntimeStaticLibraryPath(StaticRuntimeLibPath, context.Args, *this);
     Arguments.push_back(context.Args.MakeArgString(StaticRuntimeLibPath));

stdlib/public/runtime/CMakeLists.txt

@@ -65,6 +65,7 @@ set(LLVM_OPTIONAL_SOURCES
     MutexPThread.cpp
     MutexWin32.cpp
     CygwinPort.cpp
+    static_stub.c
     ${swift_runtime_sources}
     ${swift_runtime_objc_sources}
     ${swift_runtime_leaks_sources})
@@ -131,3 +132,15 @@ foreach(sdk ${ELFISH_SDKS})
 endforeach()
 
 add_custom_target(section_magic ALL DEPENDS ${object_target_list})
+
+if(SWIFT_BUILD_STATIC_STDLIB)
+  foreach(sdk ${SWIFT_SDKS})
+    if("${sdk}" STREQUAL "LINUX")
+      add_library(static_stub OBJECT static_stub.c)
+      swift_install_in_component(stdlib
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/static_stub.dir/static_stub.c${CMAKE_C_OUTPUT_EXTENSION}"
+        RENAME "static_stub.o"
+        DESTINATION "lib/swift_static/linux")
+    endif()
+  endforeach()
+endif()

stdlib/public/runtime/MetadataLookup.cpp

@@ -80,7 +80,10 @@ static void _addImageTypeMetadataRecordsBlock(const uint8_t *records,
 
 static InspectArgs metadataSectionArgs = {
   _addImageTypeMetadataRecordsBlock,
-  SWIFT_TYPE_METADATA_SECTION
+  SWIFT_TYPE_METADATA_SECTION,
+#if defined(SUPPORTS_STATIC_BINARIES)
+  &__swift2_type_metadata_start
+#endif
 };
 
 #if defined(__APPLE__) && defined(__MACH__)

stdlib/public/runtime/ProtocolConformance.cpp

@@ -217,7 +217,10 @@ static void _addImageProtocolConformancesBlock(const uint8_t *conformances,
 
 static InspectArgs conformanceSectionArgs = {
   _addImageProtocolConformancesBlock,
-  SWIFT_PROTOCOL_CONFORMANCES_SECTION
+  SWIFT_PROTOCOL_CONFORMANCES_SECTION,
+#if defined(SUPPORTS_STATIC_BINARIES)
+  &__swift2_protocol_conformances_start
+#endif
 };
 
 #if defined(__APPLE__) && defined(__MACH__)

stdlib/public/runtime/SectionData.cpp

@@ -49,6 +49,13 @@ swift::_swift_initializeCallbacksForSectionData(
 }
 #elif defined(__ELF__) || defined(__ANDROID__)
 
+#if defined(SUPPORTS_STATIC_BINARIES)
+// If creating a static binary using --static-executable,
+// gold will set these to the data sections via --defsym
+const void *__swift2_protocol_conformances_start = nullptr;
+const void *__swift2_type_metadata_start = nullptr;
+#endif // SUPPORTS_STATIC_BINARIES
+
 static int
 _addImageSectionData(struct dl_phdr_info *info, size_t size, void *data) {
   // inspectArgs contains addImage*Block function and the section name
@@ -79,6 +86,18 @@ _addImageSectionData(struct dl_phdr_info *info, size_t size, void *data) {
 
 void
 swift::_swift_initializeCallbacksForSectionData(InspectArgs *inspectArgs) {
+#if defined(SUPPORTS_STATIC_BINARIES)
+  const void **sectionDataAddr = inspectArgs->sectionDataAddr;
+  assert(sectionDataAddr != nullptr );
+  if (*sectionDataAddr) {
+    auto blockAddr = reinterpret_cast<const uint8_t*>(sectionDataAddr);
+    auto blockSize = *reinterpret_cast<const uint64_t*>(blockAddr);
+    blockAddr += sizeof(blockSize);
+    inspectArgs->fnAddImageBlock(blockAddr, blockSize);
+    return;
+  }
+#endif // SUPPORTS_STATIC_BINARIES
+
   // Search the loaded dls. Unlike the above, this only searches the already
   // loaded ones.
   // FIXME: Find a way to have this continue to happen after.

stdlib/public/runtime/SectionData.h

@@ -36,6 +36,14 @@
 #elif defined(__ELF__)
 #define SWIFT_PROTOCOL_CONFORMANCES_SECTION ".swift2_protocol_conformances_start"
 #define SWIFT_TYPE_METADATA_SECTION ".swift2_type_metadata_start"
+
+#if defined(__linux__)
+#define SUPPORTS_STATIC_BINARIES
+// Add a declaration for each section
+extern const void *__swift2_protocol_conformances_start;
+extern const void *__swift2_type_metadata_start;
+#endif // __linux__
+
 #elif defined(__CYGWIN__) || defined(_MSC_VER)
 #define SWIFT_PROTOCOL_CONFORMANCES_SECTION ".sw2prtc"
 #define SWIFT_TYPE_METADATA_SECTION ".sw2tymd"
@@ -47,6 +55,9 @@ namespace swift {
   struct InspectArgs {
     void (*fnAddImageBlock)(const uint8_t *, size_t);
     const char *sectionName;
+#if defined(SUPPORTS_STATIC_BINARIES)
+    const void **sectionDataAddr;
+#endif
   };
 
 #if defined(__APPLE__) && defined(__MACH__)

stdlib/public/runtime/static_stub.c

@@ -0,0 +1,33 @@
+#if defined(__LINUX__) && defined(__ELF__)
+#error "This only works on Linux/ELF"  // Needs testing on other ELF platforms
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+
+// This forces resolving of these weak symbols but keeps them hidden
+// externally
+const void *unused1 __attribute__ ((unused, visibility("internal"))) = pthread_self;
+const void *unused2 __attribute__ ((unused, visibility("internal"))) = pthread_key_create;
+const void *unused3 __attribute__ ((unused, visibility("internal"))) = pthread_once;
+
+
+// linking libdl into static binaries produces this message:
+// "warning: Using 'dlopen' in statically linked applications requires at
+// runtime the shared libraries from the glibc version used for linking"
+//
+// Instead of letting the calls silently fail, show an error and quit.
+// This is not actually needed, it is just to aid debugging
+
+#define UNSUPPORTED_FUNC(x) void x() {                                \
+  fprintf(stderr, "Unsupported dynamic linker call: %s\n", __func__); \
+  abort();                                                            \
+}
+
+UNSUPPORTED_FUNC(dlopen)
+UNSUPPORTED_FUNC(dlsym)
+UNSUPPORTED_FUNC(dladdr)
+UNSUPPORTED_FUNC(dlclose)
+
+#endif // linux && ELF