[DWARF] Make -g with empty assembler source work better.

[probinson]

Summary

This was sometimes causing clang or llvm-mc to crash, and in other
cases could emit a bogus DWARF line-table header. This should be a
cleaner and more complete fix than r352541.

Addresses PR40538.

[aprantl]

clang/tools/driver/cc1as_main.cpp

336

Why not move this to line 411?

llvm/lib/MC/MCDwarf.cpp

1018

Are there guaranteed to be >1 MCDwarfFiles?

[probinson]

clang/tools/driver/cc1as_main.cpp

336

Because on line 341, we std::move(*Buffer) into SrcMgr. I could try to figure out how to extract it from SrcMgr afterward, I guess.

llvm/lib/MC/MCDwarf.cpp

1018

Yes, because MCDwarfFiles[0] is never used. If it's non-empty, size will be at least 2. I could expand on the comment to say so; there's another place where I have a comment like that.

[probinson]

Address review comments & rebase.

[dblaikie]

llvm/lib/MC/MCContext.cpp

586

No need for the "(void)" here - this function isn't marked NO_DISCARD or anything liek that, by the looks of it?

[probinson]

llvm/lib/MC/MCContext.cpp

586

No, it's not. Wasn't entirely sure what the criteria were. I'll remove this.

clang/test/Misc/cc1as-asm-debug.s

 // Run cc1as with debug on empty file. Needs a known name so we can check it.
 // REQUIRES: x86-registered-target
 // RUN: rm -rf %t && mkdir -p %t
 // RUN: cp %s %t/comment.s
 // RUN: %clang -cc1as -triple x86_64-linux-gnu -filetype asm -debug-info-kind=limited -dwarf-version=4 %t/comment.s | FileCheck %s
 // RUN: %clang -cc1as -triple x86_64-linux-gnu -filetype asm -debug-info-kind=limited -dwarf-version=5 %t/comment.s | FileCheck %s
 // Asm output actually emits the .section directives twice.
 // CHECK: {{\.}}section .debug_info
 // CHECK: {{\.}}section .debug_info
 // CHECK-NOT: {{\.}}section
-// CHECK: .ascii "comment.s"
+// Look for this as a relative path.
+// CHECK: .ascii "{{[^\\/].*}}comment.s"

clang/tools/driver/cc1as_main.cpp

static bool ExecuteAssembler(AssemblerInvocation &Opts,
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
       MemoryBuffer::getFileOrSTDIN(Opts.InputFile);
 
   if (std::error_code EC = Buffer.getError()) {
     Error = EC.message();
     return Diags.Report(diag::err_fe_error_reading) << Opts.InputFile;
   }
 
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
-  SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());
+  unsigned BufferIndex = SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());
 
   // Record the location of the include directories so that the lexer can find
   // it later.
   SrcMgr.setIncludeDirs(Opts.IncludePaths);
 
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(Opts.Triple));
   assert(MRI && "Unable to create target register info!");
 
static bool ExecuteAssembler(AssemblerInvocation &Opts,
   if (Opts.GenDwarfForAssembly)
     Ctx.setGenDwarfForAssembly(true);
   if (!Opts.DwarfDebugFlags.empty())
     Ctx.setDwarfDebugFlags(StringRef(Opts.DwarfDebugFlags));
   if (!Opts.DwarfDebugProducer.empty())
     Ctx.setDwarfDebugProducer(StringRef(Opts.DwarfDebugProducer));
   if (!Opts.DebugCompilationDir.empty())
     Ctx.setCompilationDir(Opts.DebugCompilationDir);
+  else {
+    // If no compilation dir is set, try to use the current directory.
+    SmallString<128> CWD;
+    if (!sys::fs::current_path(CWD))
+      Ctx.setCompilationDir(CWD);
+  }
   if (!Opts.DebugPrefixMap.empty())
     for (const auto &KV : Opts.DebugPrefixMap)
       Ctx.addDebugPrefixMapEntry(KV.first, KV.second);
   if (!Opts.MainFileName.empty())
     Ctx.setMainFileName(StringRef(Opts.MainFileName));
   Ctx.setDwarfVersion(Opts.DwarfVersion);
+  if (Opts.GenDwarfForAssembly)
+    Ctx.setGenDwarfRootFile(Opts.InputFile,
+                            SrcMgr.getMemoryBuffer(BufferIndex)->getBuffer());
 
   // Build up the feature string from the target feature list.
   std::string FS;
   if (!Opts.Features.empty()) {
     FS = Opts.Features[0];
     for (unsigned i = 1, e = Opts.Features.size(); i != e; ++i)
       FS += "," + Opts.Features[i];
   }

llvm/include/llvm/MC/MCContext.h

public:
     bool getGenDwarfForAssembly() { return GenDwarfForAssembly; }
     void setGenDwarfForAssembly(bool Value) { GenDwarfForAssembly = Value; }
     unsigned getGenDwarfFileNumber() { return GenDwarfFileNumber; }
 
     void setGenDwarfFileNumber(unsigned FileNumber) {
       GenDwarfFileNumber = FileNumber;
     }
 
+    /// Specifies information about the "root file" for assembler clients
+    /// (e.g., llvm-mc). Assumes compilation dir etc. have been set up.
+    void setGenDwarfRootFile(StringRef FileName, StringRef Buffer);
+
     const SetVector<MCSection *> &getGenDwarfSectionSyms() {
       return SectionsForRanges;
     }
 
     bool addGenDwarfSection(MCSection *Sec) {
       return SectionsForRanges.insert(Sec);
     }
 

llvm/include/llvm/MC/MCDwarf.h

void resetRootFile() {
     assert(Header.MCDwarfFiles.empty());
     Header.RootFile.Name.clear();
     Header.resetMD5Usage();
     Header.HasSource = false;
   }
 
   bool hasRootFile() const { return !Header.RootFile.Name.empty(); }
 
+  const MCDwarfFile &getRootFile() const { return Header.RootFile; }
+
   // Report whether MD5 usage has been consistent (all-or-none).
   bool isMD5UsageConsistent() const { return Header.isMD5UsageConsistent(); }
 
   MCSymbol *getLabel() const {
     return Header.Label;
   }
 
   void setLabel(MCSymbol *Label) {

llvm/lib/MC/MCContext.cpp

 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCSymbolMachO.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdlib>
 #include <tuple>
 #include <utility>
 
for (auto &CUIDTablePair : MCDwarfLineTablesCUMap)
     for (auto &Dir : CUIDTablePair.second.getMCDwarfDirs())
       RemapDebugPath(Dir);
 }
 
 //===----------------------------------------------------------------------===//
 // Dwarf Management
 //===----------------------------------------------------------------------===//
 
+void MCContext::setGenDwarfRootFile(StringRef InputFileName, StringRef Buffer) {
+  // MCDwarf needs the root file as well as the compilation directory.
+  // If we find a '.file 0' directive that will supersede these values.
+  MD5::MD5Result *Cksum = nullptr;
+  if (getDwarfVersion() >= 5) {
+    MD5 Hash;
+    Cksum = (MD5::MD5Result *)allocate(sizeof(MD5::MD5Result), 1);
+    Hash.update(Buffer);
+    Hash.final(*Cksum);
+  }
+  // Canonicalize the root filename. It cannot be empty, and should not
+  // repeat the compilation dir.
+  StringRef FileName =
+      !getMainFileName().empty() ? StringRef(getMainFileName()) : InputFileName;
+  if (FileName.empty() || FileName == "-")
+    FileName = "<stdin>";
+  if (FileName.consume_front(getCompilationDir()))
+    (void)FileName.consume_front(llvm::sys::path::get_separator());
+  assert(!FileName.empty());
+  setMCLineTableRootFile(
+      /*CUID=*/0, getCompilationDir(), FileName, Cksum, None);
+}
+
 /// 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
 /// error and zero is returned and the client reports the error, else the
 /// allocated file number is returned.  The file numbers may be in any order.
 Expected<unsigned> MCContext::getDwarfFile(StringRef Directory,
                                            StringRef FileName,
                                            unsigned FileNumber,
                                            MD5::MD5Result *Checksum,

llvm/lib/MC/MCDwarf.cpp

if (HasAllMD5) {
     MCOS->EmitULEB128IntValue(dwarf::DW_FORM_data16);
   }
   if (HasSource) {
     MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_LLVM_source);
     MCOS->EmitULEB128IntValue(LineStr ? dwarf::DW_FORM_line_strp
                                       : dwarf::DW_FORM_string);
   }
   // Then the counted list of files. The root file is file #0, then emit the
-  // files as provide by .file directives.  To accommodate assembler source
-  // written for DWARF v4 but trying to emit v5, if we didn't see a root file
-  // explicitly, replicate file #1.
-  MCOS->EmitULEB128IntValue(MCDwarfFiles.size());
+  // files as provide by .file directives.
+  // MCDwarfFiles has an unused element [0] so use size() not size()+1.
+  // But sometimes MCDwarfFiles is empty, in which case we still emit one file.
+  MCOS->EmitULEB128IntValue(MCDwarfFiles.empty() ? 1 : MCDwarfFiles.size());
+  // To accommodate assembler source written for DWARF v4 but trying to emit
+  // v5: If we didn't see a root file explicitly, replicate file #1.
+  assert((!RootFile.Name.empty() || MCDwarfFiles.size() >= 1) &&
+         "No root file and no .file directives");
   emitOneV5FileEntry(MCOS, RootFile.Name.empty() ? MCDwarfFiles[1] : RootFile,
                      HasAllMD5, HasSource, LineStr);
   for (unsigned i = 1; i < MCDwarfFiles.size(); ++i)
     emitOneV5FileEntry(MCOS, MCDwarfFiles[i], HasAllMD5, HasSource, LineStr);
 }
 
 std::pair<MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
static void EmitGenDwarfInfo(MCStreamer *MCOS,
 
   // AT_name, the name of the source file.  Reconstruct from the first directory
   // and file table entries.
   const SmallVectorImpl<std::string> &MCDwarfDirs = context.getMCDwarfDirs();
   if (MCDwarfDirs.size() > 0) {
     MCOS->EmitBytes(MCDwarfDirs[0]);
     MCOS->EmitBytes(sys::path::get_separator());
   }
-  const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles =
-    MCOS->getContext().getMCDwarfFiles();
-  MCOS->EmitBytes(MCDwarfFiles[1].Name);
+  const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles = context.getMCDwarfFiles();
+  // MCDwarfFiles might be empty if we have an empty source file.
+  // If it's not empty, [0] is unused and [1] is the first actual file.
+  assert(MCDwarfFiles.empty() || MCDwarfFiles.size() >= 2);
+  const MCDwarfFile &RootFile =
+      MCDwarfFiles.empty()
+          ? context.getMCDwarfLineTable(/*CUID=*/0).getRootFile()
+          : MCDwarfFiles[1];
+  MCOS->EmitBytes(RootFile.Name);
   MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
 
   // AT_comp_dir, the working directory the assembly was done in.
   if (!context.getCompilationDir().empty()) {
     MCOS->EmitBytes(context.getCompilationDir());
     MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
   }
 

llvm/lib/MC/MCParser/AsmParser.cpp

 
 bool AsmParser::enabledGenDwarfForAssembly() {
   // Check whether the user specified -g.
   if (!getContext().getGenDwarfForAssembly())
     return false;
   // If we haven't encountered any .file directives (which would imply that
   // the assembler source was produced with debug info already) then emit one
   // describing the assembler source file itself.
-  if (getContext().getGenDwarfFileNumber() == 0)
+  if (getContext().getGenDwarfFileNumber() == 0) {
+    const MCDwarfFile &RootFile =
+        getContext().getMCDwarfLineTable(/*CUID=*/0).getRootFile();
     getContext().setGenDwarfFileNumber(getStreamer().EmitDwarfFileDirective(
-        0, StringRef(), getContext().getMainFileName()));
+        /*CUID=*/0, getContext().getCompilationDir(), RootFile.Name,
+        RootFile.Checksum, RootFile.Source));
+  }
   return true;
 }
 
 bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
   // Create the initial section, if requested.
   if (!NoInitialTextSection)
     Out.InitSections(false);
 
while (Lexer.isNot(AsmToken::Eof)) {
     // parseStatement returned true so may need to emit an error.
     printPendingErrors();
 
     // Skipping to the next line if needed.
     if (!getLexer().isAtStartOfStatement())
       eatToEndOfStatement();
   }
 
-  // Make sure we get proper DWARF even for empty files.
-  (void)enabledGenDwarfForAssembly();
-
   getTargetParser().onEndOfFile();
   printPendingErrors();
 
   // All errors should have been emitted.
   assert(!hasPendingError() && "unexpected error from parseStatement");
 
   getTargetParser().flushPendingInstructions(getStreamer());
 

llvm/test/MC/ELF/debug-prefix-map.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_name [DW_FORM_string] ("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")

llvm/tools/llvm-mc/llvm-mc.cpp

if (!sys::fs::current_path(CWD))
       Ctx.setCompilationDir(CWD);
   }
   for (const auto &Arg : DebugPrefixMap) {
     const auto &KV = StringRef(Arg).split('=');
     Ctx.addDebugPrefixMapEntry(KV.first, KV.second);
   }
   if (!MainFileName.empty())
     Ctx.setMainFileName(MainFileName);
-  if (GenDwarfForAssembly && DwarfVersion >= 5) {
-    // DWARF v5 needs the root file as well as the compilation directory.
-    // If we find a '.file 0' directive that will supersede these values.
-    MD5 Hash;
-    MD5::MD5Result *Cksum =
-        (MD5::MD5Result *)Ctx.allocate(sizeof(MD5::MD5Result), 1);
-    Hash.update(Buffer->getBuffer());
-    Hash.final(*Cksum);
-    Ctx.setMCLineTableRootFile(
-        /*CUID=*/0, Ctx.getCompilationDir(),
-        !MainFileName.empty() ? MainFileName : InputFilename, Cksum, None);
-  }
+  if (GenDwarfForAssembly)
+    Ctx.setGenDwarfRootFile(InputFilename, Buffer->getBuffer());
 
   // Package up features to be passed to target/subtarget
   std::string FeaturesStr;
   if (MAttrs.size()) {
     SubtargetFeatures Features;
     for (unsigned i = 0; i != MAttrs.size(); ++i)
       Features.AddFeature(MAttrs[i]);
     FeaturesStr = Features.getString();