Add '-emit-archive' option to mark modules as being part of static libraries

include/swift/AST/Decl.h

@@ -602,7 +602,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1,
     /// If the module was or is being compiled with `-enable-testing`.
     TestingEnabled : 1,
 
@@ -624,7 +624,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     ImplicitDynamicEnabled : 1,
 
     // Whether the module is a system module.
-    IsSystemModule : 1
+    IsSystemModule : 1,
+
+    // If the module is a static library.
+    IsStaticLibrary : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,

include/swift/AST/DiagnosticsDriver.def

@@ -64,6 +64,9 @@ ERROR(error_expected_frontend_command,none,
 ERROR(error_cannot_specify__o_for_multiple_outputs,none,
       "cannot specify -o when generating multiple output files", ())
 
+ERROR(error_static_emit_executable_disallowed,none,
+      "-static may not be used with -emit-executable", ())
+
 ERROR(error_unable_to_load_output_file_map, none,
       "unable to load output file map '%1': %0", (StringRef, StringRef))
 

include/swift/AST/Module.h

@@ -338,6 +338,14 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     return getResilienceStrategy() != ResilienceStrategy::Default;
   }
 
+  bool isStaticLibrary() const {
+    return Bits.ModuleDecl.IsStaticLibrary;
+  }
+
+  void setIsStaticLibrary(bool isStaticLibrary = true) {
+    Bits.ModuleDecl.IsStaticLibrary = isStaticLibrary;
+  }
+
   /// Look up a (possibly overloaded) value set at top-level scope
   /// (but with the specified access path, which may come from an import decl)
   /// within the current module.

include/swift/Driver/Action.h

@@ -48,6 +48,7 @@ class Action {
     AutolinkExtractJob,
     REPLJob,
     LinkJob,
+    ArchiveJob,
     GenerateDSYMJob,
     VerifyDebugInfoJob,
     GeneratePCHJob,
@@ -313,7 +314,7 @@ class LinkJobAction : public JobAction {
   LinkJobAction(ArrayRef<const Action *> Inputs, LinkKind K)
       : JobAction(Action::Kind::LinkJob, Inputs, file_types::TY_Image),
         Kind(K) {
-    assert(Kind != LinkKind::None);
+    assert(Kind != LinkKind::None && Kind != LinkKind::StaticLibrary);
   }
 
   LinkKind getKind() const { return Kind; }
@@ -323,6 +324,20 @@ class LinkJobAction : public JobAction {
   }
 };
 
+class ArchiveJobAction : public JobAction {
+  virtual void anchor();
+
+public:
+  ArchiveJobAction(ArrayRef<const Action *> Inputs, LinkKind K)
+      : JobAction(Action::Kind::ArchiveJob, Inputs, file_types::TY_Image) {
+    assert(K == LinkKind::StaticLibrary);
+  }
+
+  static bool classof(const Action *A) {
+    return A->getKind() == Action::Kind::ArchiveJob;
+  }
+};
+
 } // end namespace driver
 } // end namespace swift
 

include/swift/Driver/ToolChain.h

@@ -161,6 +161,9 @@ class ToolChain {
   virtual InvocationInfo constructInvocation(const LinkJobAction &job,
                                              const JobContext &context) const;
 
+  virtual InvocationInfo constructInvocation(const ArchiveJobAction &job,
+                                             const JobContext &context) const;
+
   /// Searches for the given executable in appropriate paths relative to the
   /// Swift binary.
   ///

include/swift/Driver/Util.h

@@ -34,7 +34,8 @@ namespace driver {
   enum class LinkKind {
     None,
     Executable,
-    DynamicLibrary
+    DynamicLibrary,
+    StaticLibrary
   };
 
   /// Used by a Job to request a "filelist": a file containing a list of all

include/swift/Frontend/FrontendOptions.h

@@ -228,6 +228,9 @@ class FrontendOptions {
   /// the Objective-C half should implicitly be visible to the Swift sources.
   bool ImportUnderlyingModule = false;
 
+  /// If set, this module should be built and linked as a static library.
+  bool IsStaticLibrary = false;
+
   /// If set, the header provided in ImplicitObjCHeaderPath will be rewritten
   /// by the Clang importer as part of semantic analysis.
   bool SerializeBridgingHeader = false;

include/swift/IRGen/Linking.h

@@ -1177,7 +1177,7 @@ class LinkInfo {
 
   static LinkInfo get(const UniversalLinkageInfo &linkInfo, StringRef name,
                       SILLinkage linkage, ForDefinition_t isDefinition,
-                      bool isWeakImported);
+                      bool isWeakImported, bool isStaticLibrary);
 
   StringRef getName() const {
     return Name.str();

include/swift/Option/Options.td

@@ -368,6 +368,10 @@ def emit_objc_header_path : Separate<["-"], "emit-objc-header-path">,
          ArgumentIsPath]>,
   MetaVarName<"<path>">, HelpText<"Emit an Objective-C header file to <path>">;
 
+def static : Flag<["-"], "static">,
+  Flags<[FrontendOption, ModuleInterfaceOption, NoInteractiveOption]>,
+  HelpText<"Make this module statically linkable and make the output of -emit-library a static library.">;
+
 def import_cf_types : Flag<["-"], "import-cf-types">,
   Flags<[FrontendOption, HelpHidden]>,
   HelpText<"Recognize and import CF types as class types">;

include/swift/Serialization/ModuleFormat.h

@@ -600,7 +600,8 @@ namespace options_block {
     IS_SIB,
     IS_TESTABLE,
     RESILIENCE_STRATEGY,
-    ARE_PRIVATE_IMPORTS_ENABLED
+    ARE_PRIVATE_IMPORTS_ENABLED,
+    IS_STATIC_LIBRARY
   };
 
   using SDKPathLayout = BCRecordLayout<
@@ -630,6 +631,10 @@ namespace options_block {
     RESILIENCE_STRATEGY,
     BCFixed<2>
   >;
+
+  using IsStaticLibraryLayout = BCRecordLayout<
+    IS_STATIC_LIBRARY
+  >;
 }
 
 /// The record types within the input block.

include/swift/Serialization/Validation.h

@@ -98,6 +98,7 @@ class ExtendedValidationInfo {
     unsigned IsSIB : 1;
     unsigned IsTestable : 1;
     unsigned ResilienceStrategy : 2;
+    unsigned IsStaticLibrary : 1;
   } Bits;
 public:
   ExtendedValidationInfo() : Bits() {}
@@ -135,6 +136,11 @@ class ExtendedValidationInfo {
   void setResilienceStrategy(ResilienceStrategy resilience) {
     Bits.ResilienceStrategy = unsigned(resilience);
   }
+
+  bool isStaticLibrary() const { return Bits.IsStaticLibrary; }
+  void setIsStaticLibrary(bool isStaticLibrary) {
+    Bits.IsStaticLibrary = isStaticLibrary;
+  }
 };
 
 /// Returns info about the serialized AST in the given data.

lib/Driver/Action.cpp

@@ -29,6 +29,7 @@ const char *Action::getClassName(Kind AC) {
   case Kind::AutolinkExtractJob:  return "swift-autolink-extract";
   case Kind::REPLJob:  return "repl";
   case Kind::LinkJob:  return "link";
+  case Kind::ArchiveJob:  return "archive";
   case Kind::GenerateDSYMJob:  return "generate-dSYM";
   case Kind::VerifyDebugInfoJob:  return "verify-debug-info";
   case Kind::GeneratePCHJob:  return "generate-pch";
@@ -57,6 +58,8 @@ void REPLJobAction::anchor() {}
 
 void LinkJobAction::anchor() {}
 
+void ArchiveJobAction::anchor() {}
+
 void GenerateDSYMJobAction::anchor() {}
 
 void VerifyDebugInfoJobAction::anchor() {}

lib/Driver/DarwinToolChains.cpp

@@ -284,6 +284,8 @@ toolchains::Darwin::constructInvocation(const LinkJobAction &job,
   case LinkKind::DynamicLibrary:
     Arguments.push_back("-dylib");
     break;
+  case LinkKind::StaticLibrary:
+    llvm_unreachable("invalid link kind");
   }
 
   assert(Triple.isOSDarwin());

lib/Driver/Driver.cpp

@@ -1255,6 +1255,8 @@ static bool maybeBuildingExecutable(const OutputInfo &OI,
     return true;
   case LinkKind::DynamicLibrary:
     return false;
+  case LinkKind::StaticLibrary:
+    return false;
   case LinkKind::None:
     break;
   }
@@ -1366,15 +1368,24 @@ void Driver::buildOutputInfo(const ToolChain &TC, const DerivedArgList &Args,
 
     switch (OutputModeArg->getOption().getID()) {
     case options::OPT_emit_executable:
+      if (Args.hasArg(options::OPT_static))
+        Diags.diagnose(SourceLoc(),
+                       diag::error_static_emit_executable_disallowed);
+
       OI.LinkAction = LinkKind::Executable;
       OI.CompilerOutputType = file_types::TY_Object;
       break;
 
     case options::OPT_emit_library:
-      OI.LinkAction = LinkKind::DynamicLibrary;
+      OI.LinkAction = Args.hasArg(options::OPT_static) ?
+                      LinkKind::StaticLibrary :
+                      LinkKind::DynamicLibrary;
       OI.CompilerOutputType = file_types::TY_Object;
       break;
 
+    case options::OPT_static:
+      break;
+
     case options::OPT_emit_object:
       OI.CompilerOutputType = file_types::TY_Object;
       break;
@@ -1550,7 +1561,8 @@ void Driver::buildOutputInfo(const ToolChain &TC, const DerivedArgList &Args,
     OI.ModuleName = "REPL";
   } else if (const Arg *A = Args.getLastArg(options::OPT_o)) {
     OI.ModuleName = llvm::sys::path::stem(A->getValue());
-    if (OI.LinkAction == LinkKind::DynamicLibrary &&
+    if ((OI.LinkAction == LinkKind::DynamicLibrary ||
+        OI.LinkAction == LinkKind::StaticLibrary) &&
         !llvm::sys::path::extension(A->getValue()).empty() &&
         StringRef(OI.ModuleName).startswith("lib")) {
       // Chop off a "lib" prefix if we're building a library.
@@ -1949,8 +1961,15 @@ void Driver::buildActions(SmallVectorImpl<const Action *> &TopLevelActions,
   }
 
   if (OI.shouldLink() && !AllLinkerInputs.empty()) {
-    auto *LinkAction = C.createAction<LinkJobAction>(AllLinkerInputs,
-                                                     OI.LinkAction);
+    JobAction *LinkAction = nullptr;
+
+    if (OI.LinkAction == LinkKind::StaticLibrary) {
+      LinkAction = C.createAction<ArchiveJobAction>(AllLinkerInputs,
+                                                    OI.LinkAction);
+    } else {
+      LinkAction = C.createAction<LinkJobAction>(AllLinkerInputs,
+                                                 OI.LinkAction);
+    }
 
     // On ELF platforms there's no built in autolinking mechanism, so we
     // pull the info we need from the .o files directly and pass them as an
@@ -2177,6 +2196,19 @@ static StringRef baseNameForImage(const JobAction *JA, const OutputInfo &OI,
                                   StringRef BaseInput, StringRef BaseName) {
   if (JA->size() == 1 && OI.ModuleNameIsFallback && BaseInput != "-")
     return llvm::sys::path::stem(BaseInput);
+
+  if (auto link = dyn_cast<ArchiveJobAction>(JA)) {
+    Buffer = Triple.isOSWindows() ? "" : "lib";
+    Buffer.append(BaseName);
+
+     if (Triple.isOSWindows())
+        Buffer.append(".lib");
+      else
+        Buffer.append(".a");
+
+    return Buffer.str();
+  }
+
   auto link = dyn_cast<LinkJobAction>(JA);
   if (!link)
     return BaseName;
@@ -2192,6 +2224,7 @@ static StringRef baseNameForImage(const JobAction *JA, const OutputInfo &OI,
     Buffer.append(".dll");
   else
     Buffer.append(".so");
+
   return Buffer.str();
 }
 

lib/Driver/ToolChain.cpp

@@ -100,6 +100,7 @@ std::unique_ptr<Job> ToolChain::constructJob(
       CASE(MergeModuleJob)
       CASE(ModuleWrapJob)
       CASE(LinkJob)
+      CASE(ArchiveJob)
       CASE(GenerateDSYMJob)
       CASE(VerifyDebugInfoJob)
       CASE(GeneratePCHJob)

lib/Driver/ToolChains.cpp

@@ -208,6 +208,7 @@ static void addCommonFrontendArgs(const ToolChain &TC, const OutputInfo &OI,
   inputArgs.AddLastArg(arguments, options::OPT_warnings_as_errors);
   inputArgs.AddLastArg(arguments, options::OPT_sanitize_EQ);
   inputArgs.AddLastArg(arguments, options::OPT_sanitize_coverage_EQ);
+  inputArgs.AddLastArg(arguments, options::OPT_static);
   inputArgs.AddLastArg(arguments, options::OPT_swift_version);
   inputArgs.AddLastArg(arguments, options::OPT_enforce_exclusivity_EQ);
   inputArgs.AddLastArg(arguments, options::OPT_stats_output_dir);
@@ -1078,6 +1079,73 @@ ToolChain::constructInvocation(const LinkJobAction &job,
   llvm_unreachable("linking not implemented for this toolchain");
 }
 
+ToolChain::InvocationInfo
+ToolChain::constructInvocation(const ArchiveJobAction &job,
+                               const JobContext &context) const {
+   assert(context.Output.getPrimaryOutputType() == file_types::TY_Image &&
+         "Invalid linker output type.");
+
+  ArgStringList Arguments;
+
+  // Configure the toolchain.
+  bool isLLVMAR = false;
+  const char *AR = nullptr;
+  if (const Arg *A = context.Args.getLastArg(options::OPT_tools_directory)) {
+    StringRef toolchainPath(A->getValue());
+
+    // If there is an llvm-ar in the toolchain folder, use that instead.
+    if (auto toolchainAR =
+            llvm::sys::findProgramByName("llvm-ar", {toolchainPath})) {
+      AR = context.Args.MakeArgString(toolchainAR.get());
+      isLLVMAR = true;
+    }
+
+  }
+  if (AR == nullptr) {
+    if (auto pathAR = llvm::sys::findProgramByName("llvm-ar", None)) {
+      AR = context.Args.MakeArgString(pathAR.get());
+      isLLVMAR = true;
+    }
+  }
+  if (AR == nullptr) {
+    if (auto pathAR = llvm::sys::findProgramByName("ar", None))
+      AR = context.Args.MakeArgString(pathAR.get());
+  }
+
+  assert(AR &&
+         "neither ar nor llvm-ar was not found in the toolchain directory or system path.");
+
+  if (isLLVMAR) {
+    switch (getTriple().getOS()) {
+    case llvm::Triple::Darwin:
+      Arguments.push_back("--format=darwin");
+      break;
+    case llvm::Triple::FreeBSD:
+      Arguments.push_back("--format=bsd");
+      break;
+    case llvm::Triple::Linux:
+      Arguments.push_back("--format=gnu");
+      break;
+    default:
+      break;
+    }
+  }
+
+  Arguments.push_back("crs");
+
+  Arguments.push_back(
+      context.Args.MakeArgString(context.Output.getPrimaryOutputFilename()));
+
+  addPrimaryInputsOfType(Arguments, context.Inputs, context.Args,
+                         file_types::TY_Object);
+  addInputsOfType(Arguments, context.InputActions, file_types::TY_Object);
+
+  InvocationInfo II{AR, Arguments};
+  II.allowsResponseFiles = true;
+
+  return II;
+}
+
 void ToolChain::addPathEnvironmentVariableIfNeeded(
     Job::EnvironmentVector &env, const char *name, const char *separator,
     options::ID optionID, const ArgList &args, StringRef extraEntry) const {

lib/Driver/UnixToolChains.cpp

@@ -130,6 +130,8 @@ toolchains::GenericUnix::constructInvocation(const LinkJobAction &job,
   case LinkKind::DynamicLibrary:
     Arguments.push_back("-shared");
     break;
+  case LinkKind::StaticLibrary:
+    llvm_unreachable("invalid link kind");
   }
 
   // Select the linker to use.

lib/Driver/WindowsToolChains.cpp

@@ -61,6 +61,8 @@ toolchains::Windows::constructInvocation(const LinkJobAction &job,
   case LinkKind::DynamicLibrary:
     Arguments.push_back("-shared");
     break;
+  case LinkKind::StaticLibrary:
+    llvm_unreachable("invalid link kind");
   }
 
   // Select the linker to use.