Merge pull request #63125 from DougGregor/debug-info-dump-macro-expansion-buffers

Author: DougGregor

include/swift/Basic/SourceManager.h

@@ -72,6 +72,10 @@ class GeneratedSourceInfo {
 
   /// The custom attribute for an attached macro.
   CustomAttr *attachedMacroCustomAttr = nullptr;
+
+  /// The name of the source file on disk that was created to hold the
+  /// contents of this file for external clients.
+  StringRef onDiskBufferCopyFileName = StringRef();
 };
 
 /// This class manages and owns source buffers.
@@ -253,11 +257,18 @@ class SourceManager {
   ///
   /// \p BufferID must be a valid buffer ID.
   ///
+  /// \p ForceGeneratedSourceToDisk can be set to true to create a temporary
+  /// file on-disk for buffers containing generated source code, returning the
+  /// name of that temporary file.
+  ///
   /// This should not be used for displaying information about the \e contents
   /// of a buffer, since lines within the buffer may be marked as coming from
   /// other files using \c #sourceLocation. Use #getDisplayNameForLoc instead
   /// in that case.
-  StringRef getIdentifierForBuffer(unsigned BufferID) const;
+  StringRef getIdentifierForBuffer(
+      unsigned BufferID,
+      bool ForceGeneratedSourceToDisk = false
+  ) const;
 
   /// Returns a SourceRange covering the entire specified buffer.
   ///
@@ -289,10 +300,15 @@ class SourceManager {
   /// Returns a buffer identifier suitable for display to the user containing
   /// the given source location.
   ///
+  /// \p ForceGeneratedSourceToDisk can be set to true to create a temporary
+  /// file on-disk for buffers containing generated source code, returning the
+  /// name of that temporary file.
+  ///
   /// This respects \c #sourceLocation directives and the 'use-external-names'
   /// directive in VFS overlay files. If you need an on-disk file name, use
   /// #getIdentifierForBuffer instead.
-  StringRef getDisplayNameForLoc(SourceLoc Loc) const;
+  StringRef getDisplayNameForLoc(
+      SourceLoc Loc, bool ForceGeneratedSourceToDisk = false) const;
 
   /// Returns the line and column represented by the given source location.
   ///

include/swift/SIL/SILLocation.h

@@ -410,7 +410,12 @@ class SILLocation {
   }
 
   /// Extract the line, column, and filename from \p Loc.
-  static FilenameAndLocation decode(SourceLoc Loc, const SourceManager &SM);
+  ///
+  /// \p ForceGeneratedSourceToDisk can be set to true to create a temporary
+  /// file on-disk for buffers containing generated source code, returning the
+  /// name of that temporary file.
+  static FilenameAndLocation decode(SourceLoc Loc, const SourceManager &SM,
+                                    bool ForceGeneratedSourceToDisk = false);
 
   /// Return the decoded FilenameAndLocation.
   /// In case the location has a separate AST node for debugging, this node is

lib/AST/Attr.cpp

@@ -1311,6 +1311,15 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DAK_Declaration: {
+    Printer.printAttrName("@declaration");
+    Printer << "(";
+    auto Attr = cast<DeclarationAttr>(this);
+    Printer << getMacroRoleString(Attr->getMacroRole());
+    Printer << ")";
+    break;
+  }
+
   case DAK_Attached: {
     Printer.printAttrName("@attached");
     Printer << "(";

lib/Basic/SourceLoc.cpp

@@ -12,9 +12,11 @@
 
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/SourceManager.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Signals.h"
 
 using namespace swift;
 
@@ -43,13 +45,14 @@ SourceLoc SourceManager::getIDEInspectionTargetLoc() const {
       .getAdvancedLoc(IDEInspectionTargetOffset);
 }
 
-StringRef SourceManager::getDisplayNameForLoc(SourceLoc Loc) const {
+StringRef SourceManager::getDisplayNameForLoc(SourceLoc Loc, bool ForceGeneratedSourceToDisk) const {
   // Respect #line first
   if (auto VFile = getVirtualFile(Loc))
     return VFile->Name;
 
   // Next, try the stat cache
-  auto Ident = getIdentifierForBuffer(findBufferContainingLoc(Loc));
+  auto Ident = getIdentifierForBuffer(
+      findBufferContainingLoc(Loc), ForceGeneratedSourceToDisk);
   auto found = StatusCache.find(Ident);
   if (found != StatusCache.end()) {
     return found->second.getName();
@@ -184,9 +187,56 @@ SourceManager::getIDForBufferIdentifier(StringRef BufIdentifier) const {
   return It->second;
 }
 
-StringRef SourceManager::getIdentifierForBuffer(unsigned bufferID) const {
+/// Dump the contents of the given memory buffer to a file, returning the
+/// name of that file (when successful) and \c None otherwise.
+static Optional<std::string>
+dumpBufferToFile(const llvm::MemoryBuffer *buffer) {
+  // Create file in the system temporary directory.
+  SmallString<128> tempFileModel;
+  llvm::sys::path::system_temp_directory(true, tempFileModel);
+  llvm::sys::path::append(
+      tempFileModel, "swift-generated-sources-%%%%%%.swift");
+
+  // Open up a unique file.
+  int tempFD = 0;
+  SmallString<128> tempFileName;
+  if (llvm::sys::fs::createUniqueFile(tempFileModel, tempFD, tempFileName))
+    return None;
+
+  // Dump the contents there.
+  auto contents = buffer->getBuffer();
+  llvm::raw_fd_ostream out(tempFD, true);
+  out << contents;
+  if (contents.empty() || contents.back() != '\n')
+    out << "\n";
+  out.flush();
+
+  llvm::sys::DontRemoveFileOnSignal(tempFileName);
+  return tempFileName.str().str();
+}
+
+StringRef SourceManager::getIdentifierForBuffer(
+    unsigned bufferID, bool ForceGeneratedSourceToDisk
+) const {
   auto *buffer = LLVMSourceMgr.getMemoryBuffer(bufferID);
   assert(buffer && "invalid buffer ID");
+
+  // If this is generated source code, and we're supposed to force it to disk
+  // so external clients can see it, do so now.
+  if (ForceGeneratedSourceToDisk) {
+    if (auto generatedInfo = getGeneratedSourceInfo(bufferID)) {
+      if (generatedInfo->onDiskBufferCopyFileName.empty()) {
+        if (auto newFileNameOpt = dumpBufferToFile(buffer)) {
+          generatedInfo->onDiskBufferCopyFileName =
+              strdup(newFileNameOpt->c_str());
+        }
+      }
+
+      if (!generatedInfo->onDiskBufferCopyFileName.empty())
+        return generatedInfo->onDiskBufferCopyFileName;
+    }
+  }
+
   return buffer->getBufferIdentifier();
 }
 

lib/Frontend/PrintingDiagnosticConsumer.cpp

@@ -861,13 +861,14 @@ class AnnotatedSourceSnippet {
 
   void render(raw_ostream &Out) {
     // Print the excerpt for each file.
-    unsigned lineNumberIndent =
-        std::max_element(FileExcerpts.begin(), FileExcerpts.end(),
-                         [](auto &a, auto &b) {
-                           return a.second.getPreferredLineNumberIndent() <
-                                  b.second.getPreferredLineNumberIndent();
-                         })
-            ->second.getPreferredLineNumberIndent();
+    unsigned lineNumberIndent = 0;
+    if (!FileExcerpts.empty()) {
+      lineNumberIndent = std::max_element(FileExcerpts.begin(), FileExcerpts.end(),
+          [](auto &a, auto &b) {
+            return a.second.getPreferredLineNumberIndent() <
+              b.second.getPreferredLineNumberIndent();
+          })->second.getPreferredLineNumberIndent();
+    }
     for (auto excerpt : FileExcerpts)
       excerpt.second.render(lineNumberIndent, Out);
 

lib/IRGen/IRGenDebugInfo.cpp

@@ -111,7 +111,6 @@ static bool equalWithoutExistentialTypes(Type t1, Type t2) {
 }
 
 class IRGenDebugInfoImpl : public IRGenDebugInfo {
-  friend class IRGenDebugInfoImpl;
   const IRGenOptions &Opts;
   ClangImporter &CI;
   SourceManager &SM;
@@ -395,6 +394,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     return false;
   }
 
+public:
   llvm::MDNode *createInlinedAt(const SILDebugScope *DS) {
     auto *CS = DS->InlinedCallSite;
     if (!CS)
@@ -414,6 +414,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     InlinedAtCache.insert({CS, llvm::TrackingMDNodeRef(InlinedAt)});
     return InlinedAt;
   }
+private:
 
 #ifndef NDEBUG
   /// Perform a couple of sanity checks on scopes.
@@ -2951,8 +2952,10 @@ void IRGenDebugInfoImpl::emitTypeMetadata(IRGenFunction &IGF,
 SILLocation::FilenameAndLocation
 IRGenDebugInfoImpl::decodeSourceLoc(SourceLoc SL) {
   auto &Cached = FilenameAndLocationCache[SL.getOpaquePointerValue()];
-  if (Cached.filename.empty())
-    Cached = sanitizeCodeViewFilenameAndLocation(SILLocation::decode(SL, SM));
+  if (Cached.filename.empty()) {
+    Cached = sanitizeCodeViewFilenameAndLocation(
+        SILLocation::decode(SL, SM, /*ForceGeneratedSourceToDisk=*/true));
+  }
   return Cached;
 }
 
@@ -3103,16 +3106,17 @@ ArtificialLocation::ArtificialLocation(const SILDebugScope *DS,
   if (DI) {
     unsigned Line = 0;
     auto *Scope = DI->getOrCreateScope(DS);
-    if (static_cast<IRGenDebugInfoImpl *>(DI)->getDebugInfoFormat() ==
-        IRGenDebugInfoFormat::CodeView) {
+    auto DII = static_cast<IRGenDebugInfoImpl *>(DI);
+    if (DII->getDebugInfoFormat() == IRGenDebugInfoFormat::CodeView) {
       // In CodeView, line zero is not an artificial line location and so we
       // try to use the location of the scope.
       if (auto *LB = dyn_cast<llvm::DILexicalBlock>(Scope))
         Line = LB->getLine();
       else if (auto *SP = dyn_cast<llvm::DISubprogram>(Scope))
         Line = SP->getLine();
     }
-    auto DL = llvm::DILocation::get(Scope->getContext(), Line, 0, Scope);
+    auto DL = llvm::DILocation::get(Scope->getContext(), Line, 0, Scope,
+                                    DII->createInlinedAt(DS));
     Builder.SetCurrentDebugLocation(DL);
   }
 }

lib/SIL/IR/SILLocation.cpp

@@ -137,10 +137,11 @@ DeclContext *SILLocation::getAsDeclContext() const {
 }
 
 SILLocation::FilenameAndLocation SILLocation::decode(SourceLoc Loc,
-                                              const SourceManager &SM) {
+                                              const SourceManager &SM,
+                                              bool ForceGeneratedSourceToDisk) {
   FilenameAndLocation DL;
   if (Loc.isValid()) {
-    DL.filename = SM.getDisplayNameForLoc(Loc);
+    DL.filename = SM.getDisplayNameForLoc(Loc, ForceGeneratedSourceToDisk);
     std::tie(DL.line, DL.column) = SM.getPresumedLineAndColumnForLoc(Loc);
   }
   return DL;

lib/SIL/Verifier/SILVerifier.cpp

@@ -5889,6 +5889,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       // map and go on.
       auto *DS = SI.getDebugScope();
       assert(DS && "Each instruction should have a debug scope");
+
+      // We don't support this verification on inlined call sites yet.
+      if (DS->InlinedCallSite)
+        continue;
+
       if (!AlreadySeenScopes.count(DS)) {
         AlreadySeenScopes.insert(DS);
         LastSeenScope = DS;

lib/SILGen/SILGenExpr.cpp

@@ -5995,6 +5995,8 @@ RValue RValueEmitter::visitMacroExpansionExpr(MacroExpansionExpr *E,
                                               SGFContext C) {
   auto *rewritten = E->getRewritten();
   assert(rewritten && "Macro should have been rewritten by SILGen");
+  MacroScope scope(SGF, CleanupLocation(rewritten), E, E->getMacroName(),
+                   E->getMacroNameLoc());
   return visit(rewritten, C);
 }
 

lib/SILGen/SILGenFunction.cpp

@@ -16,6 +16,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SILGenFunction.h"
+#include "Cleanup.h"
 #include "RValue.h"
 #include "SILGenFunctionBuilder.h"
 #include "Scope.h"
@@ -157,6 +158,57 @@ DeclName SILGenModule::getMagicFunctionName(SILDeclRef ref) {
   llvm_unreachable("Unhandled SILDeclRefKind in switch.");
 }
 
+void SILGenFunction::enterDebugScope(SILLocation Loc, bool isBindingScope,
+                                     Optional<SILLocation> MacroExpansion,
+                                     DeclNameRef MacroName,
+                                     DeclNameLoc MacroNameLoc) {
+  auto *Parent = DebugScopeStack.size() ? DebugScopeStack.back().getPointer()
+                                        : F.getDebugScope();
+  auto *Scope = Parent;
+  // Don't nest a scope for Loc under Parent unless it's actually different.
+  if (RegularLocation(Parent->getLoc()) != RegularLocation(Loc)) {
+    SILDebugScope *InlinedAt = nullptr;
+    // Create an inline scope for a macro expansion.
+    if (MacroExpansion && MacroName && MacroNameLoc.isValid()) {
+      InlinedAt = new (SGM.M) SILDebugScope(RegularLocation(*MacroExpansion),
+                                            &getFunction(), Parent);
+      SILGenFunctionBuilder B(SGM);
+      auto ExtInfo = SILFunctionType::ExtInfo::getThin();
+      auto FunctionType = SILFunctionType::get(
+          nullptr, ExtInfo, SILCoroutineKind::None,
+          ParameterConvention::Direct_Unowned, /*Params*/ {}, /*yields*/ {},
+          /*Results*/ {}, None, SubstitutionMap(), SubstitutionMap(),
+          SGM.M.getASTContext());
+      SILFunction *MacroFn = B.getOrCreateFunction(
+          Loc, MacroName.getBaseIdentifier().str(),
+          SILLinkage::DefaultForDeclaration, FunctionType, IsNotBare,
+          IsNotTransparent, IsNotSerialized, IsNotDynamic, IsNotDistributed,
+          IsNotRuntimeAccessible);
+      auto MacroScope = new (SGM.M) SILDebugScope(Loc, MacroFn);
+      Parent = MacroScope;
+    }
+    Scope = new (SGM.M)
+        SILDebugScope(RegularLocation(Loc), &getFunction(), Parent, InlinedAt);
+  }
+  DebugScopeStack.emplace_back(Scope, isBindingScope);
+  B.setCurrentDebugScope(Scope);
+}
+
+  /// Return to the previous debug scope.
+void SILGenFunction::leaveDebugScope() {
+  // Pop any 'guard' scopes first.
+  while (DebugScopeStack.back().getInt())
+    DebugScopeStack.pop_back();
+
+  // Pop the scope we're leaving now.
+  DebugScopeStack.pop_back();
+  if (DebugScopeStack.size())
+    B.setCurrentDebugScope(DebugScopeStack.back().getPointer());
+  // Don't reset the debug scope after leaving the outermost scope,
+  // because the debugger is not expecting the function epilogue to
+  // be in a different scope.
+}
+
 std::tuple<ManagedValue, SILType>
 SILGenFunction::emitSiblingMethodRef(SILLocation loc,
                                      SILValue selfValue,

lib/SILGen/SILGenFunction.h

@@ -598,31 +598,13 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// \param isBindingScope If true, this is a scope for the bindings introduced
   /// by a let expression. This scope ends when the next innermost BraceStmt
   /// ends.
-  void enterDebugScope(SILLocation Loc, bool isBindingScope = false) {
-    auto *Parent = DebugScopeStack.size() ? DebugScopeStack.back().getPointer()
-                                          : F.getDebugScope();
-    auto *DS = Parent;
-    // Don't nest a scope for Loc under Parent unless it's actually different.
-    if (RegularLocation(DS->getLoc()) != RegularLocation(Loc))
-      DS = new (SGM.M) SILDebugScope(RegularLocation(Loc), &getFunction(), DS);
-    DebugScopeStack.emplace_back(DS, isBindingScope);
-    B.setCurrentDebugScope(DS);
-  }
+  void enterDebugScope(SILLocation Loc, bool isBindingScope = false,
+                       Optional<SILLocation> MacroExpansion = {},
+                       DeclNameRef MacroName = {},
+                       DeclNameLoc MacroNameLoc = {});
 
   /// Return to the previous debug scope.
-  void leaveDebugScope() {
-    // Pop any 'guard' scopes first.
-    while (DebugScopeStack.back().getInt())
-      DebugScopeStack.pop_back();
-
-    // Pop the scope we're leaving now.
-    DebugScopeStack.pop_back();
-    if (DebugScopeStack.size())
-      B.setCurrentDebugScope(DebugScopeStack.back().getPointer());
-    // Don't reset the debug scope after leaving the outermost scope,
-    // because the debugger is not expecting the function epilogue to
-    // be in a different scope.
-  }
+  void leaveDebugScope();
 
   std::unique_ptr<Initialization>
   prepareIndirectResultInit(AbstractionPattern origResultType,