Record the DWARF version in MCContext

[olista01]

Summary

Record the DWARF version in MCContext, and use it when emitting the dwarf version into the debug info.

[dblaikie]

test/MC/ELF/gen-dwarf.s

2

I'm assuming this is a no-op for now? (well, other than to exercise the codepath - but adding or removing this flag doesn't change any behavior?)

Or perhaps this test case actually verifies the dwarf version?

Could you add another test case (possibly just a new RUN line on this test case with a different check prefix) to verify that if you pass a different dwarf version it appears in the output?

[olista01]

Expand test/MC/ELF/gen-dwarf.s to check that the correct dwarf version is emitted.

[dblaikie]

You can use a common prefix for multiple FileChecks like this:

FileCheck --check-prefix=ASM --check-prefix=V2
FileCheck --check-prefix=ASM --check-prefix=V3

ASM: stuff
V2: byte 2
V3: byte 3
ASM: stuff

Which makes the test a bit simpler to read by removing duplication.

[olista01]

Made test clearer by using multiple --check-prefix's

[dblaikie]

include/llvm/MC/MCContext.h

151

I'd probably make this a uint16_t (and similarly for the get/set functions) since that's the limit on the output.

tools/llvm-mc/llvm-mc.cpp

409

This error case could use test coverage.

(careful about matching on the program name - the program name in windows will be different (.exe suffix) - usually best just to omit that portion of the error message from the match line)

[olista01]

Changed DwarfVersion to uint16_t, increased test coverage of error cases

[olista01]

Ping?

[echristo]

LGTM. Sorry I missed the original.

[olista01]

Thanks, committed revision 207739.

include/llvm/MC/MCContext.h

private:
     /// The string to embed in the debug information for the compile unit, if
     /// non-empty.
     StringRef DwarfDebugFlags;
 
     /// The string to embed in as the dwarf AT_producer for the compile unit, if
     /// non-empty.
     StringRef DwarfDebugProducer;
 
+    /// The maximum version of dwarf that we should emit.
+    uint16_t DwarfVersion;
+
     /// Honor temporary labels, this is useful for debugging semantic
     /// differences between temporary and non-temporary labels (primarily on
     /// Darwin).
     bool AllowTemporaryLabels;
 
     /// The Compile Unit ID that we are currently processing.
     unsigned DwarfCompileUnitID;
 
public:
     }
 
     void setDwarfDebugFlags(StringRef S) { DwarfDebugFlags = S; }
     StringRef getDwarfDebugFlags() { return DwarfDebugFlags; }
 
     void setDwarfDebugProducer(StringRef S) { DwarfDebugProducer = S; }
     StringRef getDwarfDebugProducer() { return DwarfDebugProducer; }
 
+    void setDwarfVersion(uint16_t v) { DwarfVersion = v; }
+    uint16_t getDwarfVersion() const { return DwarfVersion; }
+
     /// @}
 
     char *getSecureLogFile() { return SecureLogFile; }
     raw_ostream *getSecureLog() { return SecureLog; }
     bool getSecureLogUsed() { return SecureLogUsed; }
     void setSecureLog(raw_ostream *Value) {
       SecureLog = Value;
     }

lib/MC/MCDwarf.cpp

static void EmitGenDwarfInfo(MCStreamer *MCOS,
 
   // First part: the header.
 
   // The 4 byte total length of the information for this compilation unit, not
   // including these 4 bytes.
   const MCExpr *Length = MakeStartMinusEndExpr(*MCOS, *InfoStart, *InfoEnd, 4);
   MCOS->EmitAbsValue(Length, 4);
 
-  // The 2 byte DWARF version, which is 2.
-  MCOS->EmitIntValue(2, 2);
+  // The 2 byte DWARF version.
+  MCOS->EmitIntValue(context.getDwarfVersion(), 2);
 
   // The 4 byte offset to the debug abbrevs from the start of the .debug_abbrev,
   // it is at the start of that section so this is zero.
   if (AbbrevSectionSymbol) {
     MCOS->EmitSymbolValue(AbbrevSectionSymbol, 4);
   } else {
     MCOS->EmitIntValue(0, 4);
   }

test/MC/ELF/gen-dwarf.s

-// RUN: llvm-mc -g -triple  i686-pc-linux-gnu %s -filetype=obj -o - | llvm-readobj -r | FileCheck %s
-// RUN: llvm-mc -g -triple  i686-pc-linux-gnu %s -filetype=asm -o - | FileCheck --check-prefix=ASM %s
+// RUN: llvm-mc -g -dwarf-version 2 -triple  i686-pc-linux-gnu %s -filetype=obj -o - | llvm-readobj -r | FileCheck %s
+// RUN: not llvm-mc -g -dwarf-version 1  -triple  i686-pc-linux-gnu %s -filetype=asm -o - 2>&1 | FileCheck --check-prefix=DWARF1 %s
+// RUN: llvm-mc -g -dwarf-version 2 -triple  i686-pc-linux-gnu %s -filetype=asm -o - | FileCheck --check-prefix=ASM --check-prefix=DWARF2 %s
+// RUN: llvm-mc -g -dwarf-version 3 -triple  i686-pc-linux-gnu %s -filetype=asm -o - | FileCheck --check-prefix=ASM --check-prefix=DWARF3 %s
+// RUN: llvm-mc -g -triple  i686-pc-linux-gnu %s -filetype=asm -o - | FileCheck --check-prefix=ASM --check-prefix=DWARF4 %s
+// RUN: not llvm-mc -g -dwarf-version 5  -triple  i686-pc-linux-gnu %s -filetype=asm -o - 2>&1 | FileCheck --check-prefix=DWARF5 %s
 
 
 // Test that on ELF:
 // 1. the debug info has a relocation to debug_abbrev and one to to debug_line.
 // 2. the debug_aranges has relocations to text and debug_line.
 
 
     .text

 // ASM: .section .debug_info
 
 // ASM: .section .debug_abbrev
 // ASM-NEXT: [[ABBREV_LABEL:.Ltmp[0-9]+]]
 
 // Second instance of the section has the CU
 // ASM: .section .debug_info
 // Dwarf version
-// ASM: .short 2
+// DWARF2: .short 2
+// DWARF3: .short 3
+// DWARF4: .short 4
 // ASM-NEXT: .long [[ABBREV_LABEL]]
 // First .byte 1 is the abbreviation number for the compile_unit abbrev
 // ASM: .byte 1
 // ASM-NEXT: .long [[LINE_LABEL:.L[a-z0-9]+]]
 
 // ASM: .section .debug_line
 // ASM-NEXT: [[LINE_LABEL]]
 
+// DWARF1: Dwarf version 1 is not supported.
+// DWARF5: Dwarf version 5 is not supported.

tools/llvm-mc/llvm-mc.cpp

 
 static cl::opt<bool>
 SaveTempLabels("L", cl::desc("Don't discard temporary labels"));
 
 static cl::opt<bool>
 GenDwarfForAssembly("g", cl::desc("Generate dwarf debugging info for assembly "
                                   "source files"));
 
+static cl::opt<int>
+DwarfVersion("dwarf-version", cl::desc("Dwarf version"), cl::init(4));
+
 static cl::opt<std::string>
 DebugCompilationDir("fdebug-compilation-dir",
                     cl::desc("Specifies the debug info's compilation dir"));
 
 static cl::opt<std::string>
 MainFileName("main-file-name",
              cl::desc("Specifies the name we should consider the input file"));
 
int main(int argc, char **argv) {
   std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
   MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr);
   MOFI->InitMCObjectFileInfo(TripleName, RelocModel, CMModel, Ctx);
 
   if (SaveTempLabels)
     Ctx.setAllowTemporaryLabels(false);
 
   Ctx.setGenDwarfForAssembly(GenDwarfForAssembly);
+  if (DwarfVersion < 2 || DwarfVersion > 4) {
+    errs() << ProgName << ": Dwarf version " << DwarfVersion
+           << " is not supported." << '\n';
+    return 1;
+  }
+  Ctx.setDwarfVersion(DwarfVersion);
   if (!DwarfDebugFlags.empty())
     Ctx.setDwarfDebugFlags(StringRef(DwarfDebugFlags));
   if (!DwarfDebugProducer.empty())
     Ctx.setDwarfDebugProducer(StringRef(DwarfDebugProducer));
   if (!DebugCompilationDir.empty())
     Ctx.setCompilationDir(DebugCompilationDir);
   if (!MainFileName.empty())
     Ctx.setMainFileName(MainFileName);