Serialize/Deserialize source locations for instructions (#77281)

This commit adds support for serializing and deserializing source locations for instructions.

Author: usama54321

include/swift/SIL/SILLocation.h

@@ -52,11 +52,9 @@ class SILLocation {
   /// Describes a position in a source file by explicitly storing the file name,
   /// line and column.
   ///
-  /// This is used for parsed locations from a SIL file, for
+  /// This is used for parsed locations from SIL and swiftmodule files, for
   /// "-sil-based-debuginfo" (see SILDebugInfoGenerator) and for the
   /// "compiler-generated" singleton location.
-  /// In future we might also use it for de-serialized locations from a
-  /// swiftmodule file.
   struct FilenameAndLocation : public SILAllocated<FilenameAndLocation> {
     unsigned line;
     uint16_t column;
@@ -263,6 +261,12 @@ class SILLocation {
     assert(filePos && !filePos->filename.empty());
   }
 
+  SILLocation(FilenameAndLocation *filePos, LocationKind K, bool Implicit)
+      : storage(filePos), kindAndFlags(K, FilenameAndLocationKind) {
+    assert(filePos && !filePos->filename.empty());
+    kindAndFlags.fields.implicit = Implicit;
+  }
+
   // It is okay to pass a nullptr, but preferably, a null-location should be
   // created with `invalid()`.
   SILLocation(ASTNodeTy Node, LocationKind K)
@@ -550,8 +554,8 @@ class RegularLocation : public SILLocation {
                   bool isForDebugOnly = true);
   RegularLocation(SourceLoc L, bool Implicit = true)
       : SILLocation(L, RegularKind, Implicit) {}
-  RegularLocation(FilenameAndLocation *filePos)
-    : SILLocation(filePos, RegularKind) {}
+  RegularLocation(FilenameAndLocation *filePos, bool Implicit = false)
+    : SILLocation(filePos, RegularKind, Implicit) {}
 
   /// Convert \p loc to a RegularLocation.
   explicit RegularLocation(SILLocation loc) : SILLocation(loc, RegularKind) {}
@@ -619,8 +623,8 @@ class ReturnLocation : public SILLocation {
   /// Construct the return location for a constructor or a destructor.
   ReturnLocation(BraceStmt *BS);
 
-  ReturnLocation(FilenameAndLocation *filePos)
-    : SILLocation(filePos, ReturnKind) {}
+  ReturnLocation(FilenameAndLocation *filePos, bool Implicit = false)
+    : SILLocation(filePos, ReturnKind, Implicit) {}
 
   static bool isKind(const SILLocation& L) {
     return L.getKind() == ReturnKind;
@@ -640,8 +644,8 @@ class ImplicitReturnLocation : public SILLocation {
 
   ImplicitReturnLocation(AbstractFunctionDecl *AFD);
 
-  ImplicitReturnLocation(FilenameAndLocation *filePos)
-    : SILLocation(filePos, ImplicitReturnKind) {}
+  ImplicitReturnLocation(FilenameAndLocation *filePos, bool Implicit = false)
+    : SILLocation(filePos, ImplicitReturnKind, Implicit) {}
 
   /// Convert \p loc to an ImplicitReturnLocation.
   explicit ImplicitReturnLocation(SILLocation Loc);

lib/SIL/IR/SILLocation.cpp

@@ -137,6 +137,8 @@ SourceLoc SILLocation::getStartSourceLoc() const {
     return SourceLoc();
   if (isSILFile())
     return storage.sourceLoc;
+  if (getStorageKind() == FilenameAndLocationKind)
+    return SourceLoc();
   return getStartSourceLoc(getPrimaryASTNode());
 }
 
@@ -158,6 +160,8 @@ SourceLoc SILLocation::getEndSourceLoc() const {
     return SourceLoc();
   if (isSILFile())
     return storage.sourceLoc;
+  if (getStorageKind() == FilenameAndLocationKind)
+    return SourceLoc();
   return getEndSourceLoc(getPrimaryASTNode());
 }
 

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -993,6 +993,15 @@ static bool diagnoseUnreachableBlock(
     if (Loc.is<ImplicitReturnLocation>() || Loc.isAutoGenerated())
       return false;
 
+    // Without debug info serialization, source locations are deserialized as
+    // implicit by default and as a result this diagnostic is never produced on
+    // deserialized code.  With support for serializing debug info/source
+    // locations, the implicit flag is deserialized properly .  However, this
+    // creates new diagnostic warnings in many tests. Until these tests are
+    // fixed, we suppress these warnings to match existing behavior.
+    if (Loc.isFilenameAndLocation())
+      continue;
+
     // Check if the instruction corresponds to user-written code, also make
     // sure we don't report an error twice for the same instruction.
     if (isUserCode(&*I) && !State->BlocksWithErrors.contains(&B)) {

lib/Serialization/DeserializeSIL.cpp

@@ -394,6 +394,44 @@ SILDeserializer::readNextRecord(SmallVectorImpl<uint64_t> &scratch) {
   return maybeKind;
 }
 
+std::optional<SILLocation> SILDeserializer::readLoc(unsigned kind,
+                                     SmallVectorImpl<uint64_t> &scratch) {
+  unsigned LocationKind, Implicit = 0;
+  SILLocation::FilenameAndLocation *FNameLoc = nullptr;
+  // Each SourceLoc opaque pointer is serialized once. Successive appearences
+  // are serialized as references to earlier serializations, with LocID as the
+  // indexing key
+  if (kind == SIL_SOURCE_LOC_REF) {
+    ValueID LocID;
+    SourceLocRefLayout::readRecord(scratch, LocID, LocationKind, Implicit);
+    if (LocID == 0)
+      return std::optional<SILLocation>();
+    FNameLoc = ParsedLocs[LocID - 1];
+  } else {
+    ValueID Row = 0, Col = 0, FNameID = 0;
+    SourceLocLayout::readRecord(scratch, Row, Col, FNameID, LocationKind, Implicit);
+
+
+    FNameLoc = SILLocation::FilenameAndLocation::alloc(
+        Row, Col, MF->getIdentifierText(FNameID), SILMod);
+
+    ParsedLocs.push_back(FNameLoc);
+  }
+
+  switch(LocationKind) {
+    case SILLocation::ReturnKind:
+      return ReturnLocation(FNameLoc, Implicit);
+    case SILLocation::ImplicitReturnKind:
+      return ImplicitReturnLocation(FNameLoc, Implicit);
+    case SILLocation::InlinedKind:
+    case SILLocation::MandatoryInlinedKind:
+    case SILLocation::CleanupKind:
+    case SILLocation::ArtificialUnreachableKind:
+    case SILLocation::RegularKind:
+      return RegularLocation(FNameLoc, Implicit);
+  }
+}
+
 llvm::Expected<const SILDebugScope *>
 SILDeserializer::readDebugScopes(SILFunction *F,
                                  SmallVectorImpl<uint64_t> &scratch,
@@ -1066,6 +1104,7 @@ llvm::Expected<SILFunction *> SILDeserializer::readSILFunctionChecked(
   BlocksByID.clear();
   UndefinedBlocks.clear();
   ParsedScopes.clear();
+  ParsedLocs.clear();
 
   // The first two IDs are reserved for SILUndef.
   LastValueID = 1;
@@ -1095,6 +1134,9 @@ llvm::Expected<SILFunction *> SILDeserializer::readSILFunctionChecked(
         isFirstScope = false;
       }
       Builder.setCurrentDebugScope(Scope);
+    } else if (kind == SIL_SOURCE_LOC || kind == SIL_SOURCE_LOC_REF) {
+      auto Loc = readLoc(kind, scratch);
+      Builder.applyDebugLocOverride(Loc);
     } else {
       // If CurrentBB is empty, just return fn. The code in readSILInstruction
       // assumes that such a situation means that fn is a declaration. Thus it

lib/Serialization/DeserializeSIL.h

@@ -150,7 +150,10 @@ namespace swift {
     readDebugScopes(SILFunction *F, SmallVectorImpl<uint64_t> &scratch,
                     SILBuilder &Builder, unsigned kind);
     llvm::Expected<unsigned> readNextRecord(SmallVectorImpl<uint64_t> &scratch);
+    std::optional<SILLocation> readLoc(unsigned kind, SmallVectorImpl<uint64_t> &scratch);
+
     llvm::DenseMap<unsigned, const SILDebugScope *> ParsedScopes;
+    llvm::SmallVector<SILLocation::FilenameAndLocation *> ParsedLocs;
 
     SILFunction *getFuncForReference(StringRef Name, SILType Ty, TypeExpansionContext context);
     SILFunction *getFuncForReference(StringRef Name, bool forDebugScope = false);

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 907; // TypeAliasType change
+const uint16_t SWIFTMODULE_VERSION_MINOR = 908; // debug scopes and source locs
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/SILFormat.h

@@ -178,6 +178,8 @@ namespace sil_block {
     SIL_VALUES,
     SIL_DEBUG_SCOPE,
     SIL_DEBUG_SCOPE_REF,
+    SIL_SOURCE_LOC,
+    SIL_SOURCE_LOC_REF
   };
 
   using SILInstNoOperandLayout = BCRecordLayout<
@@ -310,6 +312,22 @@ namespace sil_block {
     SILTypeCategoryField 
   >;
 
+  using SourceLocLayout = BCRecordLayout<
+    SIL_SOURCE_LOC,
+    ValueIDField,
+    ValueIDField,
+    ValueIDField,
+    BCFixed<3>, /// LocationKind
+    BCFixed<1> /// Implicit
+  >;
+
+  using SourceLocRefLayout = BCRecordLayout<
+    SIL_SOURCE_LOC_REF,
+    ValueIDField,
+    BCFixed<3>,
+    BCFixed<1> /// Implicit
+  >;
+
   using SILFunctionLayout =
       BCRecordLayout<SIL_FUNCTION, SILLinkageField,
                      BCFixed<1>,  // transparent

lib/Serialization/Serialization.cpp

@@ -960,6 +960,9 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(sil_block, SIL_PACK_ELEMENT_SET);
   BLOCK_RECORD(sil_block, SIL_DEBUG_SCOPE);
   BLOCK_RECORD(sil_block, SIL_DEBUG_SCOPE_REF);
+  BLOCK_RECORD(sil_block, SIL_SOURCE_LOC);
+  BLOCK_RECORD(sil_block, SIL_SOURCE_LOC_REF);
+
 
   BLOCK(SIL_INDEX_BLOCK);
   BLOCK_RECORD(sil_index_block, SIL_FUNC_NAMES);

lib/Serialization/SerializeSIL.cpp

@@ -162,6 +162,9 @@ namespace {
     using DebugScopeID = DeclID;
     using DebugScopeIDField = DeclIDField;
 
+    using LocationID = DeclID;
+    using LocationIDField = DeclIDField;
+
     Serializer &S;
 
     llvm::BitstreamWriter &Out;
@@ -226,6 +229,7 @@ namespace {
 
     llvm::DenseMap<PointerUnion<const SILDebugScope *, SILFunction *>, DeclID>
         DebugScopeMap;
+    llvm::DenseMap<const void *, unsigned> SourceLocMap;  
 
     /// Give each SILBasicBlock a unique ID.
     llvm::DenseMap<const SILBasicBlock *, unsigned> BasicBlockMap;
@@ -299,6 +303,7 @@ namespace {
 
     /// Serialize and write SILDebugScope graph in post order.
     void writeDebugScopes(const SILDebugScope *Scope, const SourceManager &SM);
+    void writeSourceLoc(SILLocation SLoc, const SourceManager &SM);
 
     void writeNoOperandLayout(const SILInstruction *I) {
       unsigned abbrCode = SILAbbrCodes[SILInstNoOperandLayout::Code];
@@ -600,6 +605,7 @@ void SILSerializer::writeSILFunction(const SILFunction &F, bool DeclOnly) {
   }
 
   DebugScopeMap.clear();
+  SourceLocMap.clear();
 
   if (SerializeDebugInfoSIL)
     writeDebugScopes(F.getDebugScope(), F.getModule().getSourceManager());
@@ -697,6 +703,9 @@ void SILSerializer::writeSILBasicBlock(const SILBasicBlock &BB) {
         writeDebugScopes(Prev, SM);
       }
     }
+    if (SerializeDebugInfoSIL) {
+      writeSourceLoc(SI.getLoc(), SM);
+    }
 
     writeSILInstruction(SI);
   }
@@ -3074,6 +3083,51 @@ void SILSerializer::writeSILProperty(const SILProperty &prop) {
     componentValues);
 }
 
+void SILSerializer::writeSourceLoc(SILLocation Loc, const SourceManager &SM) {
+  auto SLoc = Loc.getSourceLoc();
+  auto OpaquePtr = SLoc.getOpaquePointerValue();
+  uint8_t LocationKind;
+  switch(Loc.getKind()) {
+    case SILLocation::ReturnKind:
+      LocationKind = SILLocation::ReturnKind;
+      break;
+    case SILLocation::ImplicitReturnKind:
+      LocationKind = SILLocation::ImplicitReturnKind;
+      break;
+    case SILLocation::InlinedKind:
+    case SILLocation::MandatoryInlinedKind:
+    case SILLocation::CleanupKind:
+    case SILLocation::ArtificialUnreachableKind:
+    case SILLocation::RegularKind:
+      LocationKind = SILLocation::RegularKind;
+      break;
+  }
+
+  if (SourceLocMap.find(OpaquePtr) != SourceLocMap.end()) {
+    SourceLocRefLayout::emitRecord(Out, ScratchRecord,
+                                   SILAbbrCodes[SourceLocRefLayout::Code],
+                                   SourceLocMap[OpaquePtr], LocationKind, (unsigned)Loc.isImplicit());
+    return;
+  }
+
+  ValueID Row = 0;
+  ValueID Column = 0;
+  ValueID FNameID = 0;
+
+  if (!SLoc.isValid()) {
+    //emit empty source loc
+    SourceLocRefLayout::emitRecord(Out, ScratchRecord, SILAbbrCodes[SourceLocRefLayout::Code], 0, 0, (unsigned)0);
+    return;
+  }
+
+  std::tie(Row, Column) = SM.getPresumedLineAndColumnForLoc(SLoc);
+  FNameID = S.addUniquedStringRef(SM.getDisplayNameForLoc(SLoc));
+  SourceLocMap.insert({OpaquePtr, SourceLocMap.size() + 1});
+  SourceLocLayout::emitRecord(Out, ScratchRecord,
+                              SILAbbrCodes[SourceLocLayout::Code], Row, Column,
+                              FNameID, LocationKind, (unsigned)Loc.isImplicit());
+}
+
 void SILSerializer::writeDebugScopes(const SILDebugScope *Scope,
                                      const SourceManager &SM) {
 
@@ -3387,6 +3441,8 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
   registerSILAbbr<DifferentiabilityWitnessLayout>();
   registerSILAbbr<SILDebugScopeLayout>();
   registerSILAbbr<SILDebugScopeRefLayout>();
+  registerSILAbbr<SourceLocLayout>();
+  registerSILAbbr<SourceLocRefLayout>();
 
   // Write out VTables first because it may require serializations of
   // non-transparent SILFunctions (body is not needed).

test/Serialization/Inputs/def_source_loc.swift

@@ -0,0 +1,8 @@
+@_transparent
+public func foo(x: UInt64) -> UInt64 {
+    if (x > 100) {
+        return 100
+    }
+
+    return 1
+ }