Honor -fdebug-prefix-map when creating function names for the debug info.

[aprantl]

Summary

This adds a callback to PrintingPolicy to allow CGDebugInfo to remap file paths according to -fdebug-prefix-map. Otherwise the debug info (particularly function names for C++ lambdas) may contain paths that should have been remapped in the debug info.

[aprantl]

fix a comment.

[dblaikie]

Can't say I know much abouth the path remapping functionality - what it's used for, where it's implemented in general, etc - so figure someone with more of that knowledge might be best off reviewing this.

[probinson]

lib/CodeGen/CGDebugInfo.cpp

238

Unconditionally?

[aprantl]

In D55137#1315133, @dblaikie wrote:

Can't say I know much abouth the path remapping functionality - what it's used for, where it's implemented in general, etc - so figure someone with more of that knowledge might be best off reviewing this.

One common use-case for path remapping is a build system that builds on a different machine in some local directory, but wanting the debug info appear as if the source code were in a previously agreed-upon path so it can be debugged on another machine were the source code can be found in that same path.

[aprantl]

Only initialize RemapFilePaths when DebugPrefixMap is nonempty. Should be slightly faster.

[probinson]

LGTM aside from a grump about the test, which is totally up to you.

test/CodeGenCXX/debug-prefix-map-lambda.cpp

8

I've never liked tests that hard-code the test file name. FileCheck lets you define variables on the RUN line, is there a lit substitution that will return just the basename?

[aprantl]

test/CodeGenCXX/debug-prefix-map-lambda.cpp

8

Looks like there is not LIT substitution for the filename without the path. At least not a documented one.

include/clang/AST/PrettyPrinter.h

 /// Describes how types, statements, expressions, and declarations should be
 /// printed.
 ///
 /// This type is intended to be small and suitable for passing by value.
 /// It is very frequently copied.
 struct PrintingPolicy {
   /// Create a default printing policy for the specified language.
   PrintingPolicy(const LangOptions &LO)
       : Indentation(2), SuppressSpecifiers(false),
-      SuppressTagKeyword(LO.CPlusPlus),
-      IncludeTagDefinition(false), SuppressScope(false),
-      SuppressUnwrittenScope(false), SuppressInitializers(false),
-      ConstantArraySizeAsWritten(false), AnonymousTagLocations(true),
-      SuppressStrongLifetime(false), SuppressLifetimeQualifiers(false),
-      SuppressTemplateArgsInCXXConstructors(false),
-      Bool(LO.Bool), Restrict(LO.C99),
-      Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
-      UseVoidForZeroParams(!LO.CPlusPlus),
-      TerseOutput(false), PolishForDeclaration(false),
-      Half(LO.Half), MSWChar(LO.MicrosoftExt && !LO.WChar),
-      IncludeNewlines(true), MSVCFormatting(false),
-      ConstantsAsWritten(false), SuppressImplicitBase(false),
-      FullyQualifiedName(false) { }
+        SuppressTagKeyword(LO.CPlusPlus), IncludeTagDefinition(false),
+        SuppressScope(false), SuppressUnwrittenScope(false),
+        SuppressInitializers(false), ConstantArraySizeAsWritten(false),
+        AnonymousTagLocations(true), SuppressStrongLifetime(false),
+        SuppressLifetimeQualifiers(false),
+        SuppressTemplateArgsInCXXConstructors(false), Bool(LO.Bool),
+        Restrict(LO.C99), Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
+        UseVoidForZeroParams(!LO.CPlusPlus), TerseOutput(false),
+        PolishForDeclaration(false), Half(LO.Half),
+        MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true),
+        MSVCFormatting(false), ConstantsAsWritten(false),
+        SuppressImplicitBase(false), FullyQualifiedName(false),
+        RemapFilePaths(false) {}
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
   unsigned ConstantsAsWritten : 1;
 
   /// When true, don't print the implicit 'self' or 'this' expressions.
   unsigned SuppressImplicitBase : 1;
 
   /// When true, print the fully qualified name of function declarations.
   /// This is the opposite of SuppressScope and thus overrules it.
   unsigned FullyQualifiedName : 1;
+
+  /// Whether to apply -fdebug-prefix-map to any file paths.
+  unsigned RemapFilePaths : 1;
+
+  /// When RemapFilePaths is true, this function performs the action.
+  std::function<std::string(StringRef)> remapPath;
 };
   
 } // end namespace clang
 
 #endif

lib/AST/TypePrinter.cpp

if (Policy.AnonymousTagLocations) {
       // We don't have to worry about ElaboratedTypes here because you can't
       // refer to an anonymous type with one.
       if (!HasKindDecoration)
         OS << " " << D->getKindName();
 
       PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
           D->getLocation());
       if (PLoc.isValid()) {
-        OS << " at " << PLoc.getFilename()
-           << ':' << PLoc.getLine()
-           << ':' << PLoc.getColumn();
+        OS << " at ";
+        StringRef File = PLoc.getFilename();
+        if (Policy.RemapFilePaths)
+          OS << Policy.remapPath(File);
+        else
+          OS << File;
+        OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
       }
     }
 
     OS << (Policy.MSVCFormatting ? '\'' : ')');
   }
 
   // If this is a class template specialization, print the template
   // arguments.

lib/CodeGen/CGDebugInfo.h

void collectDefaultFieldsForBlockLiteralDeclare(
       SmallVectorImpl<llvm::Metadata *> &Fields);
 
 public:
   CGDebugInfo(CodeGenModule &CGM);
   ~CGDebugInfo();
 
   void finalize();
 
+  /// Remap a path using the -fdebug-prefix-map.
+  std::string remapDIPath(StringRef Path) const;
+
   /// Register VLA size expression debug node with the qualified type.
   void registerVLASizeExpression(QualType Ty, llvm::Metadata *SizeExpr) {
     SizeExprCache[Ty] = SizeExpr;
   }
 
   /// Module debugging: Support for building PCMs.
   /// @{
   /// Set the main CU's DwoId field to \p Signature.
llvm::DICompositeType *getOrCreateRecordFwdDecl(const RecordType *,
                                                   llvm::DIScope *);
 
   /// Return current directory name.
   StringRef getCurrentDirname();
 
   /// Create new compile unit.
   void CreateCompileUnit();
 
-  /// Remap a given path with the current debug prefix map
-  std::string remapDIPath(StringRef) const;
-
   /// Compute the file checksum debug info for input file ID.
   Optional<llvm::DIFile::ChecksumKind>
   computeChecksum(FileID FID, SmallString<32> &Checksum) const;
 
   /// Get the source of the given file ID.
   Optional<StringRef> getSource(const SourceManager &SM, FileID FID);
 
   /// Get the file debug info descriptor for the input location.

lib/CodeGen/CGDebugInfo.cpp

PrintingPolicy CGDebugInfo::getPrintingPolicy() const {
 
   // If we're emitting codeview, it's important to try to match MSVC's naming so
   // that visualizers written for MSVC will trigger for our class names. In
   // particular, we can't have spaces between arguments of standard templates
   // like basic_string and vector.
   if (CGM.getCodeGenOpts().EmitCodeView)
     PP.MSVCFormatting = true;
 
+  // Apply -fdebug-prefix-map.
+  PP.RemapFilePaths = true;
+  PP.remapPath = [this](StringRef Path) { return remapDIPath(Path); };
   return PP;
 }
 
 StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
   assert(FD && "Invalid FunctionDecl!");
   IdentifierInfo *FII = FD->getIdentifier();
   FunctionTemplateSpecializationInfo *Info =
       FD->getTemplateSpecializationInfo();

test/CodeGenCXX/debug-prefix-map-lambda.cpp

+// RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple \
+// RUN:   -fdebug-prefix-map=%S=/SOURCE_ROOT %s -emit-llvm -o - | FileCheck %s
+
+template <typename T> void b(T) {}
+void c() {
+  // CHECK: !DISubprogram(name: "b<(lambda at
+  // CHECK-SAME:          /SOURCE_ROOT/debug-prefix-map-lambda.cpp
+  // CHECK-SAME:          [[@LINE+1]]:{{[0-9]+}})>"
+  b([]{});
+}