Initial commit for Debug Scope serialization/deserialization

This patch adds code for serializing and deserializing debug scopes.
During serialization, declarations of functions only referred to by
debug scopes are serialization. During deserialization, these
declarations are deserialized as zombie functions. The deserializer
refuses to deserialize these functions when referred to by the
optimizer, such as during Generic Specialization.

Author: usama54321

include/swift/Frontend/FrontendOptions.h

@@ -125,6 +125,7 @@ class FrontendOptions {
   /// Include local definitions/references in the index data.
   bool IndexIncludeLocals = false;
 
+  bool SerializeDebugInfo = false;
   /// If building a module from interface, ignore compiler flags
   /// specified in the swiftinterface.
   bool ExplicitInterfaceBuild = false;

include/swift/Option/Options.td

@@ -805,6 +805,10 @@ def experimental_package_interface_load:
   Flags<[FrontendOption, HelpHidden]>,
   HelpText<"Enables loading a package interface if in the same package specified with package-name">;
 
+def experimental_serialize_debug_info:
+  Flag<["-"], "experimental-serialize-debug-info">,
+  Flags<[FrontendOption, HelpHidden]>,
+  HelpText<"Enables seriailzation/deserialization of debug scopes">;
 // Diagnostic control options
 def suppress_warnings : Flag<["-"], "suppress-warnings">,
   Flags<[FrontendOption]>,

include/swift/SIL/SILFunction.h

@@ -524,6 +524,7 @@ class SILFunction
          SILFunction *InsertBefore = nullptr,
          const SILDebugScope *DebugScope = nullptr);
 
+  static SILFunction *resurrectFunction(SILModule &M, StringRef name);
   void init(SILLinkage Linkage, StringRef Name, CanSILFunctionType LoweredType,
             GenericEnvironment *genericEnv, IsBare_t isBareSILFunction,
             IsTransparent_t isTrans, SerializedKind_t serializedKind,

include/swift/SIL/SILFunctionBuilder.h

@@ -120,6 +120,8 @@ class SILFunctionBuilder {
   static void setHasOwnership(SILFunction *F, bool newValue) {
     F->setHasOwnership(newValue);
   }
+
+  SILFunction *resurrectFunction(StringRef name);
 };
 
 } // namespace swift

include/swift/Serialization/SerializationOptions.h

@@ -151,6 +151,7 @@ namespace swift {
 
     bool AutolinkForceLoad = false;
     bool SerializeAllSIL = false;
+    bool SerializeDebugInfo = false;
     bool SerializeOptionsForDebugging = false;
     bool IsSIB = false;
     bool DisableCrossModuleIncrementalInfo = false;

lib/Driver/ToolChains.cpp

@@ -204,6 +204,12 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
     arguments.push_back("-disable-objc-interop");
   }
 
+  if (const Arg *arg = inputArgs.getLastArg(
+        options::OPT_experimental_serialize_debug_info)) {
+    arguments.push_back(
+        inputArgs.MakeArgString(Twine("-experimental-serialize-debug-info")));
+  }
+
   if (inputArgs.hasArg(options::OPT_experimental_hermetic_seal_at_link)) {
     arguments.push_back("-enable-llvm-vfe");
     arguments.push_back("-enable-llvm-wme");

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -89,6 +89,7 @@ bool ArgsToFrontendOptionsConverter::convert(
   Opts.IndexSystemModules |= Args.hasArg(OPT_index_system_modules);
   Opts.IndexIgnoreStdlib |= Args.hasArg(OPT_index_ignore_stdlib);
   Opts.IndexIncludeLocals |= Args.hasArg(OPT_index_include_locals);
+  Opts.SerializeDebugInfo |= Args.hasArg(OPT_experimental_serialize_debug_info);
 
   Opts.EmitVerboseSIL |= Args.hasArg(OPT_emit_verbose_sil);
   Opts.EmitSortedSIL |= Args.hasArg(OPT_emit_sorted_sil);

lib/Frontend/Frontend.cpp

@@ -200,6 +200,7 @@ SerializationOptions CompilerInvocation::computeSerializationOptions(
   serializationOpts.ModuleLinkName = opts.ModuleLinkName;
   serializationOpts.UserModuleVersion = opts.UserModuleVersion;
   serializationOpts.AllowableClients = opts.AllowableClients;
+  serializationOpts.SerializeDebugInfo = opts.SerializeDebugInfo;
 
   serializationOpts.PublicDependentLibraries =
       getIRGenOptions().PublicLinkLibraries;

lib/SIL/IR/Linker.cpp

@@ -83,7 +83,7 @@ void SILLinkerVisitor::deserializeAndPushToWorklist(SILFunction *F) {
     Mod.getSILLoader()->lookupSILFunction(F, /*onlyUpdateLinkage*/ false);
   ASSERT(!NewF || NewF == F);
   if (!NewF || F->isExternalDeclaration()) {
-    ASSERT((!hasSharedVisibility(F->getLinkage()) || F->hasForeignBody()) &&
+    ASSERT((!hasSharedVisibility(F->getLinkage()) || F->hasForeignBody() || F->isZombie()) &&
            "cannot deserialize shared function");
     return;
   }

lib/SIL/IR/SILFunction.cpp

@@ -231,6 +231,34 @@ SILFunction::SILFunction(
     initFunction({this}, &libswiftSpecificData, sizeof(libswiftSpecificData));
 }
 
+SILFunction *SILFunction::resurrectFunction(SILModule &M, StringRef name) {
+  llvm::StringMapEntry<SILFunction *> *entry = nullptr;
+  if (!name.empty()) {
+    entry = &*M.FunctionTable.insert(std::make_pair(name, nullptr)).first;
+    PrettyStackTraceSILFunction trace("creating", entry->getValue());
+    assert(!entry->getValue() && "function already exists");
+    name = entry->getKey();
+  }
+
+  SILFunction *fn = M.removeFromZombieList(name);
+  assert(fn);
+
+  assert(fn->empty());
+  fn->init(fn->getLinkage(), name, fn->getLoweredFunctionType(),
+           fn->getGenericEnvironment(), fn->isBare(), fn->isTransparent(),
+           fn->getSerializedKind(), fn->getEntryCount(), fn->isThunk(),
+           fn->getClassSubclassScope(), fn->getInlineStrategy(),
+           fn->getEffectsKind(), fn->getDebugScope(),
+           fn->isDynamicallyReplaceable(), fn->isExactSelfClass(),
+           fn->isDistributed(), fn->isRuntimeAccessible());
+
+  if (entry)
+    entry->setValue(fn);
+
+  M.functions.push_back(fn);
+
+  return fn;
+}
 void SILFunction::init(
     SILLinkage Linkage, StringRef Name, CanSILFunctionType LoweredType,
     GenericEnvironment *genericEnv, IsBare_t isBareSILFunction,

lib/SIL/IR/SILFunctionBuilder.cpp

@@ -431,3 +431,8 @@ SILFunction *SILFunctionBuilder::createFunction(
                              subclassScope, inlineStrategy, EK, InsertBefore,
                              DebugScope);
 }
+
+SILFunction *SILFunctionBuilder::resurrectFunction(
+    StringRef name) {
+  return SILFunction::resurrectFunction(mod, name);
+}

lib/SIL/IR/SILModule.cpp

@@ -350,7 +350,7 @@ SILFunction *SILModule::lookUpFunction(SILDeclRef fnRef) {
 bool SILModule::loadFunction(SILFunction *F, LinkingMode LinkMode) {
   SILFunction *NewF =
     getSILLoader()->lookupSILFunction(F, /*onlyUpdateLinkage*/ false);
-  if (!NewF)
+  if (!NewF || NewF->isZombie())
     return false;
 
   linkFunction(NewF, LinkMode);
@@ -364,7 +364,7 @@ SILFunction *SILModule::loadFunction(StringRef name, LinkingMode LinkMode,
   SILFunction *func = lookUpFunction(name);
   if (!func)
     func = getSILLoader()->lookupSILFunction(name, linkage);
-  if (!func)
+  if (!func || func->isZombie())
     return nullptr;
 
   linkFunction(func, LinkMode);

lib/SIL/Parser/ParseSIL.cpp

@@ -87,11 +87,16 @@ SILParserState::~SILParserState() {
   }
 
   // Turn any debug-info-only function declarations into zombies.
-  for (auto *Fn : PotentialZombieFns)
-    if (Fn->isExternalDeclaration()) {
+  markZombies();
+}
+
+void SILParserState::markZombies() {
+  for (auto *Fn : PotentialZombieFns) {
+    if (Fn->isExternalDeclaration() && !Fn->isZombie()) {
       Fn->setInlined();
       M.eraseFunction(Fn);
     }
+  }
 }
 
 std::unique_ptr<SILModule>
@@ -125,6 +130,11 @@ ParseSILModuleRequest::evaluate(Evaluator &evaluator,
            "Failed to parse SIL but did not emit any errors!");
     return SILModule::createEmptyModule(desc.context, desc.conv, desc.opts);
   }
+
+  //mark functions as zombies before calling SILVerifier as functions referred
+  //to by debug scopes only can fail verifier checks
+  parserState.markZombies();
+
   // If SIL parsing succeeded, verify the generated SIL.
   if (!parser.Diags.hadAnyError() && !DisableInputVerify) {
     silMod->verify(/*SingleFunction=*/true, !ParseIncompleteOSSA);

lib/SIL/Parser/SILParserState.h

@@ -62,6 +62,8 @@ class SILParserState : public SILParserStateBase {
   bool parseSILCoverageMap(Parser &P) override;
   bool parseSILProperty(Parser &P) override;
   bool parseSILScope(Parser &P) override;
+
+  void markZombies();
 };
 
 } // end namespace swift