Use debug-prefix-map for AT_NAME

[starsid]

Summary

AT_NAME was being emitted before the directory paths were remapped. This
ensures that all paths are remapped before anything is emitted.

An additional test case has been added.

Note that this only works if the replacement string is an absolute path. If not,
then AT_decl_file believes the new path is a relative path, and joins that path
with the compilation directory. I do not know of a good way to resolve this.

[starsid]

improve test

[JDevlieghere]

LGTM with inline comments.

lib/MC/MCContext.cpp

545

I might have missed something, but can't this be a std::string&?

545

I probably would've made this a static non-member function, but I don't think there's anything wrong with a lambda.

[starsid]

I actually do not have permissions to commit the revision. So if you don't want me to make more changes, can you please commit this.

Please let me know if you want me to follow up on the suggested changes in the inline comments.

lib/MC/MCContext.cpp

545

Ack.

Let me know if you actually do want me to convert this to a static non-member function.

545

It can be std::string&, but I thought when your intention is to modify the argument, you take it as a pointer. Sorry, this is my first change following LLVM code style so I am not familiar with what is expected.

[JDevlieghere]

lib/MC/MCContext.cpp

545

No, it's perfectly fine. I was only curious if there was a particular reason that I didn't consider :-)

545

No worries, I don't think they coding standard has an explicit entry on this. I think a non-const ref is the way to go here because passing nullptr doesn't mean anything here. Based on your reply I've made the change before committing, as it didn't seem worth the trouble to have you update the patch.

include/llvm/MC/MCContext.h

public:
     const std::map<const std::string, const std::string> &
     getDebugPrefixMap() const {
       return DebugPrefixMap;
     }
 
     /// Add an entry to the debug prefix map.
     void addDebugPrefixMapEntry(const std::string &From, const std::string &To);
 
-    // Remaps the given path in-place as per the debug prefix map.
-    void RemapDebugPath(std::string *Path);
-
-    // Remaps the compilation dir as per the debug prefix map.
-    void RemapCompilationDir();
+    // Remaps all debug directory paths in-place as per the debug prefix map.
+    void RemapDebugPaths();
 
     /// Get the main file name for use in error messages and debug
     /// info. This can be set to ensure we've got the correct file name
     /// after preprocessing or for -save-temps.
     const std::string &getMainFileName() const { return MainFileName; }
 
     /// Set the main file name and override the default.
     void setMainFileName(StringRef S) { MainFileName = S; }

include/llvm/MC/MCDwarf.h

Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 unsigned FileNumber = 0);
   unsigned getFile(StringRef &Directory, StringRef &FileName,
                    MD5::MD5Result *Checksum, Optional<StringRef> &Source,
                    unsigned FileNumber = 0) {
     return cantFail(tryGetFile(Directory, FileName, Checksum, Source,
                                FileNumber));
   }
 
-  void RemapDwarfDirs(MCContext &Context);
-
   void setRootFile(StringRef Directory, StringRef FileName,
                    MD5::MD5Result *Checksum, Optional<StringRef> Source) {
     Header.CompilationDir = Directory;
     Header.RootFile.Name = FileName;
     Header.RootFile.DirIndex = 0;
     Header.RootFile.Checksum = Checksum;
     Header.RootFile.Source = Source;
     Header.trackMD5Usage(Checksum);

lib/MC/MCContext.cpp

MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
   return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
 }
 
 void MCContext::addDebugPrefixMapEntry(const std::string &From,
                                        const std::string &To) {
   DebugPrefixMap.insert(std::make_pair(From, To));
 }
 
-void MCContext::RemapDebugPath(std::string *Path) {
+void MCContext::RemapDebugPaths() {
+  const auto &DebugPrefixMap = this->DebugPrefixMap;
+  const auto RemapDebugPath = [&DebugPrefixMap](std::string *Path) {
     for (const auto &Entry : DebugPrefixMap)
       if (StringRef(*Path).startswith(Entry.first)) {
         std::string RemappedPath =
             (Twine(Entry.second) + Path->substr(Entry.first.size())).str();
         Path->swap(RemappedPath);
       }
-}
+  };
 
-void MCContext::RemapCompilationDir() {
+  // Remap compilation directory.
   std::string CompDir = CompilationDir.str();
   RemapDebugPath(&CompDir);
   CompilationDir = CompDir;
+
+  // Remap MCDwarfDirs in all compilation units.
+  for (auto &CUIDTablePair : MCDwarfLineTablesCUMap)
+    for (auto &Dir : CUIDTablePair.second.getMCDwarfDirs())
+      RemapDebugPath(&Dir);
 }
 
 //===----------------------------------------------------------------------===//
 // Dwarf Management
 //===----------------------------------------------------------------------===//
 
 /// getDwarfFile - takes a file name and number to place in the dwarf file and
 /// directory tables.  If the file number has already been allocated it is an

lib/MC/MCDwarf.cpp

void MCDwarfLineTable::Emit(MCObjectStreamer *MCOS,
   if (context.getDwarfVersion() >= 5)
     LineStr = MCDwarfLineStr(context);
 
   // Switch to the section where the table will be emitted into.
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection());
 
   // Handle the rest of the Compile Units.
   for (const auto &CUIDTablePair : LineTables) {
-    auto &LineTable = context.getMCDwarfLineTable(CUIDTablePair.first);
-    LineTable.RemapDwarfDirs(MCOS->getContext());
-    LineTable.EmitCU(MCOS, Params, LineStr);
+    CUIDTablePair.second.EmitCU(MCOS, Params, LineStr);
   }
 
   if (LineStr)
     LineStr->emitSection(MCOS);
 }
 
 void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
                                MCSection *Section) const {
MCDwarfLineTableHeader::tryGetFile(StringRef &Directory,
   File.Source = Source;
   if (Source)
     HasSource = true;
 
   // return the allocated FileNumber.
   return FileNumber;
 }
 
-void MCDwarfLineTable::RemapDwarfDirs(MCContext &Context) {
-  for (auto &Dir : Header.MCDwarfDirs)
-    Context.RemapDebugPath(&Dir);
-}
-
 /// Utility function to emit the encoding to a streamer.
 void MCDwarfLineAddr::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                            int64_t LineDelta, uint64_t AddrDelta) {
   MCContext &Context = MCOS->getContext();
   SmallString<256> Tmp;
   raw_svector_ostream OS(Tmp);
   MCDwarfLineAddr::Encode(Context, Params, LineDelta, AddrDelta, OS);
   MCOS->EmitBytes(OS.str());

lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
   insert(new MCFillFragment(Expr, Size, NumValues, Loc));
 }
 
 void MCObjectStreamer::EmitFileDirective(StringRef Filename) {
   getAssembler().addFileName(Filename);
 }
 
 void MCObjectStreamer::FinishImpl() {
-  // Remap the compilation directory before emitting.
-  getContext().RemapCompilationDir();
+  getContext().RemapDebugPaths();
 
   // If we are generating dwarf for assembly source files dump out the sections.
   if (getContext().getGenDwarfForAssembly())
     MCGenDwarfInfo::Emit(this);
 
   // Dump out the dwarf file & directory tables and line tables.
   MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
 
   flushPendingLabels();
   getAssembler().Finish();
 }

test/MC/ELF/debug-prefix-map.s

 // RUN: mkdir -p %t.foo
 // RUN: cp %s %t.foo/src.s
 // RUN: cd %t.foo
 
 // RUN: llvm-mc -triple=x86_64-linux-unknown -g src.s -filetype=obj -o out.o
 // RUN: llvm-dwarfdump -v -debug-info out.o | FileCheck --check-prefix=NO_MAP %s
+
 // RUN: llvm-mc -triple=x86_64-linux-unknown -g src.s -filetype=obj -o out.o -fdebug-prefix-map=%t.foo=src_root
 // RUN: llvm-dwarfdump -v -debug-info out.o | FileCheck --check-prefix=MAP --implicit-check-not ".foo" %s
 
+// RUN: llvm-mc -triple=x86_64-linux-unknown -g %t.foo/src.s -filetype=obj -o out.o -fdebug-prefix-map=%t.foo=/src_root
+// RUN: llvm-dwarfdump -v -debug-info out.o | FileCheck --check-prefix=MAP_ABS --implicit-check-not ".foo" %s
+
 f:
   nop
 
 // NO_MAP: DW_AT_comp_dir [DW_FORM_string] ("{{.*}}.foo")
 
 // MAP: DW_AT_name [DW_FORM_string] ("src.s")
 // MAP: DW_AT_comp_dir [DW_FORM_string] ("src_root")
 // MAP: DW_AT_decl_file [DW_FORM_data4] ("src_root{{(/|\\)}}src.s")
+
+// MAP_ABS: DW_AT_name [DW_FORM_string] ("{{/|\\}}src_root{{(/|\\)}}src.s")
+// MAP_ABS: DW_AT_comp_dir [DW_FORM_string] ("{{/|\\}}src_root")
+// MAP_ABS: DW_AT_decl_file [DW_FORM_data4] ("{{/|\\}}src_root{{(/|\\)}}src.s")