[embedded] Add a frontend flag to drop all code from a module and emit an empty object file

Author: kubamracek

include/swift/AST/SILOptions.h

@@ -170,6 +170,10 @@ class SILOptions {
   /// Whether to stop the optimization pipeline after serializing SIL.
   bool StopOptimizationAfterSerialization = false;
 
+  /// Whether to drop all SIL after serializing SIL and continue compilation
+  /// with an empty SIL module.
+  bool DropAllSILAfterSerialization = false;
+
   /// Whether to stop the optimization pipeline right before we lower ownership
   /// and go from OSSA to non-ownership SIL.
   bool StopOptimizationBeforeLoweringOwnership = false;

include/swift/Option/FrontendOptions.td

@@ -580,6 +580,10 @@ def enable_single_module_llvm_emission: Flag<["-"], "enable-single-module-llvm-e
   Flags<[FrontendOption, NoInteractiveOption]>,
   HelpText<"Emit LLVM IR into a single LLVM module in multithreaded mode.">;
 
+def emit_empty_object_file : Flag<["-"], "emit-empty-object-file">,
+  Flags<[FrontendOption, NoInteractiveOption]>,
+  HelpText<"Produce a valid but dummy object file when building a library module">;
+
 def stack_promotion_checks : Flag<["-"], "emit-stack-promotion-checks">,
   HelpText<"Emit runtime checks for correct stack promotion of objects.">;
 

include/swift/SIL/SILModule.h

@@ -839,6 +839,9 @@ class SILModule {
   /// Look up a specialized VTable
   SILVTable *lookUpSpecializedVTable(SILType classTy);
 
+  /// Remove all VTables and specialized VTables from the module.
+  void eraseAllVTables();
+
   /// Attempt to lookup the function corresponding to \p Member in the class
   /// hierarchy of \p Class.
   SILFunction *lookUpFunctionInVTable(ClassDecl *Class, SILDeclRef Member);

include/swift/SILOptimizer/PassManager/Passes.def

@@ -452,6 +452,8 @@ PASS(SimplifyUnreachableContainingBlocks, "simplify-unreachable-containing-block
      "Utility pass. Removes all non-term insts from blocks with unreachable terms")
 PASS(SerializeSILPass, "serialize-sil",
      "Utility pass. Serializes the current SILModule")
+PASS(DropAllSILPass, "drop-all-sil",
+     "Utility pass. Drops all SIL from the SILModule")
 PASS(UnitTestRunner, "test-runner",
      "Utility pass.  Parses arguments and runs code with them.")
 PASS(YieldOnceCheck, "yield-once-check",

lib/Frontend/CompilerInvocation.cpp

@@ -2185,6 +2185,10 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
       FEOpts.RequestedAction == FrontendOptions::ActionType::CompileModuleFromInterface)
     Opts.StopOptimizationAfterSerialization = true;
 
+  if (Args.getLastArg(OPT_emit_empty_object_file)) {
+    Opts.DropAllSILAfterSerialization = true;
+  }
+
   // Propagate the typechecker's understanding of
   // -experimental-skip-*-function-bodies to SIL.
   Opts.SkipFunctionBodies = TCOpts.SkipFunctionBodies;

lib/IRGen/GenDecl.cpp

@@ -454,6 +454,11 @@ class PrettySynthesizedFileUnitEmission : public llvm::PrettyStackTraceEntry {
 
 /// Emit all the top-level code in the source file.
 void IRGenModule::emitSourceFile(SourceFile &SF) {
+  if (getSILModule().getOptions().DropAllSILAfterSerialization) {
+    // We're asked to emit an empty IR module
+    return;
+  }
+
   // Type-check the file if we haven't already (this may be necessary for .sil
   // files, which don't get fully type-checked by parsing).
   performTypeChecking(SF);
@@ -1259,6 +1264,11 @@ static bool isLazilyEmittedFunction(SILFunction &f, SILModule &m) {
 
 void IRGenerator::emitGlobalTopLevel(
     const std::vector<std::string> &linkerDirectives) {
+  if (PrimaryIGM->getSILModule().getOptions().DropAllSILAfterSerialization) {
+    // We're asked to emit an empty IR module
+    return;
+  }
+
   // Generate order numbers for the functions in the SIL module that
   // correspond to definitions in the LLVM module.
   unsigned nextOrderNumber = 0;

lib/IRGen/GenReflection.cpp

@@ -1667,6 +1667,11 @@ llvm::ArrayRef<CanType> IRGenModule::getOrCreateSpecialStlibBuiltinTypes() {
 }
 
 void IRGenModule::emitBuiltinReflectionMetadata() {
+  if (getSILModule().getOptions().DropAllSILAfterSerialization) {
+    // We're asked to emit an empty IR module
+    return;
+  }
+
   if (getSwiftModule()->isStdlibModule()) {
     auto SpecialBuiltins = getOrCreateSpecialStlibBuiltinTypes();
     BuiltinTypes.insert(SpecialBuiltins.begin(), SpecialBuiltins.end());

lib/IRGen/IRGenModule.cpp

@@ -1912,7 +1912,7 @@ void IRGenModule::cleanupClangCodeGenMetadata() {
 bool IRGenModule::finalize() {
   const char *ModuleHashVarName = "llvm.swift_module_hash";
   if (IRGen.Opts.OutputKind == IRGenOutputKind::ObjectFile &&
-      !Module.getGlobalVariable(ModuleHashVarName)) {
+      !Module.getGlobalVariable(ModuleHashVarName) && !getSILModule().getOptions().DropAllSILAfterSerialization) {
     // Create a global variable into which we will store the hash of the
     // module (used for incremental compilation).
     // We have to create the variable now (before we emit the global lists).
@@ -1969,6 +1969,14 @@ bool IRGenModule::finalize() {
     if (F.hasDLLImportStorageClass())
       F.setDSOLocal(false);
 
+  if (getSILModule().getOptions().DropAllSILAfterSerialization) {
+    // We're asked to emit an empty IR module, check that that's actually true
+    if (Module.global_size() != 0 || Module.size() != 0) {
+      Module.dump();
+      llvm::report_fatal_error("Module is not empty");
+    }
+  }
+
   return true;
 }
 

lib/SIL/IR/SILModule.cpp

@@ -484,6 +484,16 @@ SILVTable *SILModule::lookUpVTable(const ClassDecl *C,
   return Vtbl;
 }
 
+void SILModule::eraseAllVTables() {
+  for (auto vt : vtables)
+    vt->~SILVTable();
+
+  VTableMap.clear();
+  SpecializedVTableMap.clear();
+  vtables.clear();
+  VTableEntryCache.clear();
+}
+
 SILMoveOnlyDeinit *SILModule::lookUpMoveOnlyDeinit(const NominalTypeDecl *C,
                                                    bool deserializeLazily) {
   if (!C)

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -997,6 +997,9 @@ SILPassPipelinePlan::getPerformancePassPipeline(const SILOptions &Options) {
   if (Options.StopOptimizationAfterSerialization)
     return P;
 
+  if (Options.DropAllSILAfterSerialization)
+    P.addDropAllSILPass();
+
   // After serialization run the function pass pipeline to iteratively lower
   // high-level constructs like @_semantics calls.
   addMidLevelFunctionPipeline(P);
@@ -1055,6 +1058,9 @@ SILPassPipelinePlan::getOnonePassPipeline(const SILOptions &Options) {
   P.startPipeline("Serialization");
   P.addSerializeSILPass();
 
+  if (Options.DropAllSILAfterSerialization)
+    P.addDropAllSILPass();
+
   // Now that we have serialized, propagate debug info.
   P.addMovedAsyncVarDebugInfoPropagator();
 

lib/SILOptimizer/UtilityPasses/CMakeLists.txt

@@ -13,6 +13,7 @@ target_sources(swiftSILOptimizer PRIVATE
   ComputeLoopInfo.cpp
   ConstantEvaluatorTester.cpp
   ConstantEvaluableSubsetChecker.cpp
+  DropAllSILPass.cpp
   EpilogueARCMatcherDumper.cpp
   EpilogueRetainReleaseMatcherDumper.cpp
   FunctionOrderPrinter.cpp

lib/SILOptimizer/UtilityPasses/DropAllSILPass.cpp

@@ -0,0 +1,60 @@
+//===--- DropAllSILPass.cpp -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "drop-all-sil"
+#include "swift/SIL/SILFunction.h"
+#include "swift/SILOptimizer/PassManager/Passes.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+
+using namespace swift;
+
+namespace {
+
+class DropAllSILPass : public SILModuleTransform {
+public:
+  DropAllSILPass() {}
+  
+  void run() override {
+    auto &M = *getModule();
+
+    llvm::SmallVector<SILFunction *, 16> FunctionsToErase;
+    llvm::SmallVector<SILGlobalVariable *, 16> GlobalsToErase;
+
+    for (SILFunction &F : M) {
+      FunctionsToErase.push_back(&F);
+    }
+
+    for (SILGlobalVariable &G : M.getSILGlobals()) {
+      GlobalsToErase.push_back(&G);
+    }
+
+    M.eraseAllVTables();
+
+    for (SILFunction *F : FunctionsToErase) {
+      notifyWillDeleteFunction(F);
+      M.eraseFunction(F);
+      M.removeFromZombieList(F->getName());
+    }
+
+    for (SILGlobalVariable *G : GlobalsToErase) {
+      M.eraseGlobalVariable(G);
+    }
+    
+    invalidateFunctionTables();
+  }
+};
+
+}
+
+SILTransform *swift::createDropAllSILPass() {
+  return new DropAllSILPass();
+}