Emit S_COMPILE3 CodeView record

[amccarth]

Summary

CodeView has an S_COMPILE3 record to identify the compiler and source language of the compiland.

This record comes first in the debug$S section for the compiland. The debuggers rely on this record to know the source language of the code.

I'm not thrilled about how this infers the CPUType and how it has to parse the compiler version from the producer string in the DICompileUnit. If you know of a better way to get at this information, I'd be happy to improve this patch.

[majnemer]

Forgive my naïveté but under what circumstance does the debugger need to know C vs C++ vs whatever?

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

542–543

This shouldn't map to IA64, that would be Itanium. It's also not correct to map it to X64 because it could be 32-bit sandybridge.

Does MSVC actually change what it sticks in here depending on /arch? If not, I'd just use the ArchType from the Triple to reconstruct this info.

593

Using the triple for this looks weird. I'd grab the cpu name from the TM via Asm->TM.getTargetCPU()

[amccarth]

In D24317#536408, @majnemer wrote:

Forgive my naïveté but under what circumstance does the debugger need to know C vs C++ vs whatever?

It may not _need_ to know, but the Visual Studio debugger does _display_ the source language in places like the call stack. I suppose the source language might be used in evaluating Watch expressions.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

542–543

OK, I'll try to fix that up. I was mostly relying on Wikipedia to figure out how the architectures mapped. I guess I misunderstood what I read.

Does MSVC actually change what it sticks in here depending on /arch? If not, I'd just use the ArchType from the Triple to reconstruct this info.

I don't know how MSVC chooses what goes here. I'll experiment.

It does appear, however, that clang-cl chooses one of these architectures for the triple based on /arch, so I figured these were the important ones to map back into the CodeView type.

593

Thanks! I was looking for something like that but had failed to find it.

I had tried Asm->TM.getMCSubtargetInfo()->getCPU();, but that asserted.

[amccarth]

Simpler approach for getting the CodeView CPUType.

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

575–576

I'd make it a switch on the triple's architecture (Triple(MMI->getModule()->getTargetTriple()).getArch()). Clang also supports ARMNT.

I'd have the default label call report_fatal_error to indicate that the architecture is not supported.

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

531–533

This should be in the anonymous namespace.

575–576

Ah, looks like we can use 0xFFFF for an unknown machine type (https://github.com/Microsoft/microsoft-pdb/blob/e6b1dec61e154b568357537792e1d17a13525d5d/cvdump/dumpsym7.cpp#L256)

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

575–576

Eh, we should just report_fatal_error. Sorry for waffling.

584–586

Apparently, Microsoft tools (like BinScope [https://www.microsoft.com/en-us/download/details.aspx?id=11910]) expect that the backend version is at least 8.0.50727 [1]

I think the backend version should be controlled by LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR and LLVM_VERSION_PATCH instead of whatever is contained in the .ll file. Because of the aforementioned limitation, perhaps we should do something like LLVM_VERSION_MAJOR * 1000 + LLVM_VERSION_MINOR * 10 + LLVM_VERSION_PATCH and use zeros for the other three values.

[1] http://repo.or.cz/nasm.git/commitdiff/1df89ea03902161b76773d0eef48f277b49d918e

[amccarth]

It looks like I have to fix up more tests, too, because the extra record make the subsection size a little larger. I'm working through those now but may not have a new diff until Monday.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

531–533

oops. I had it in there initially until I learned that LLVM style is to prefer file static functions to functions in anonymous namespaces.

584–586

I see your point, but ...

1. I also have to provide the textual compiler version string, and it seems awkward to get that from a different source than the structured data. This seems prone to getting conflicting information.

2. Having the version dependent on the actual build instead of what's in the .ll file makes the test harder to write.

What if I continue to parse the version from the string but roll up the fields as you've described to solve the Binscope expectation problem?

Another possibility is to use the MS compatibility version rather than the Clang version and synthesize a string like "clang in MSVC compatibility mode 1.2.3.4" for the textual compiler version.

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

584–586

Eh, but the frontend is the IR that came from clang and the backend is AsmPrinter's job.
The test issue can be handled by making the FileCheck use a regex.

[amccarth]

Several tests needed updating because the extra S_COMPILE3 record in the Symbols subsection changes the section's size and offsets some relocation information.

Also uses reports distinct front-end and back-end versions per David Majnemer's suggestion.

[majnemer]

LGTM, thanks!

[thakis]

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

509 ↗

(On Diff #71954)

(post-commit nit: since it's in anonymous namespace, the static should probably go now)

[rnk]

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

2100 ↗

(On Diff #71954)

I don't think we want to repeat the compile record in every symbol subsection. We have one symbol subsection per function. MSVC only emits the compiler flags once up front, like this:

CodeViewDebugInfo [
  Section: .debug$S (2)
  Magic: 0x4
  Subsection [
    SubSectionType: Symbols (0xF1)
    SubSectionSize: 0x5C
    ObjectName {
      Signature: 0x0
      ObjectName: C:\src\llvm\build\t.obj
    }
    CompilerFlags3 {
      Language: Cpp (0x1)
      Flags [ (0x6000)
        HotPatch (0x4000)
        SecurityChecks (0x2000)
      ]
      Machine: X64 (0xD0)
      FrontendVersion: 19.0.24210.0
      BackendVersion: 19.0.24210.0
      VersionName: Microsoft (R) Optimizing Compiler
    }
  ]
  Subsection [
    SubSectionType: Symbols (0xF1)
    SubSectionSize: 0x337
    UDT {

[amccarth]

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

2100 ↗

(On Diff #71954)

Good catch. I'll fix that this afternoon and add a test for it.

lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   }
 
   /// Emit the magic version number at the start of a CodeView type or symbol
   /// section. Appears at the front of every .debug$S or .debug$T section.
   void emitCodeViewMagicVersion();
 
   void emitTypeInformation();
 
+  void emitCompilerInformation();
+
   void emitInlineeLinesSubsection();
 
   void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
 
   void emitDebugInfoForGlobals();
 
   void emitDebugInfoForRetainedTypes();
 

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 // This file contains support for writing Microsoft CodeView debug info.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeViewDebug.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/EnumTables.h"
 #include "llvm/DebugInfo/CodeView/FieldListRecordBuilder.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
#ifndef NDEBUG
             llvm_unreachable("produced malformed type record");
           }
 #endif
         }
         OS.EmitBinaryData(Record);
       });
 }
 
+static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
+  switch (DWLang) {
+  case dwarf::DW_LANG_C:
+  case dwarf::DW_LANG_C89:
+  case dwarf::DW_LANG_C99:
+  case dwarf::DW_LANG_C11:
+  case dwarf::DW_LANG_ObjC:
+    return SourceLanguage::C;
+  case dwarf::DW_LANG_C_plus_plus:
+  case dwarf::DW_LANG_C_plus_plus_03:
+  case dwarf::DW_LANG_C_plus_plus_11:
+  case dwarf::DW_LANG_C_plus_plus_14:
+    return SourceLanguage::Cpp;
+  case dwarf::DW_LANG_Fortran77:
+  case dwarf::DW_LANG_Fortran90:
+  case dwarf::DW_LANG_Fortran03:
+  case dwarf::DW_LANG_Fortran08:
+    return SourceLanguage::Fortran;
+  case dwarf::DW_LANG_Pascal83:
+    return SourceLanguage::Pascal;
+  case dwarf::DW_LANG_Cobol74:
+  case dwarf::DW_LANG_Cobol85:
+    return SourceLanguage::Cobol;
+  case dwarf::DW_LANG_Java:
+    return SourceLanguage::Java;
+  default:
+    // There's no CodeView representation for this language, and CV doesn't
+    // have an "unknown" option for the language field, so we'll use MASM,
+    // as it's very low level.
+    return SourceLanguage::Masm;
+  }
+}
+
+static CPUType MapCPUtoCVCPU(StringRef Name) {
+  // There's no direct mapping between LLVM's architecture and CodeView's.
+  // The Microsoft compiler /arch option is mainly about which SIMD instruction
+  // sets the target processor is expected to have.  The clang-cl driver maps
+  // Microsoft /arch options to these LLVM architectures (see getX86TargetCPU in
+  // clang/lib/Driver/Tools.cpp).  This attempts to map those LLVM architectures
+  // into CodeView architectures.
+  return llvm::StringSwitch<CPUType>(Name)
+      .Case("i386", CPUType::Intel80386)
+      .Case("pentium3", CPUType::Pentium3)
+      .Case("pentium4", CPUType::Pentium3)
+      .Case("sandybridge", CPUType::Ia64)
+      .Case("haswell", CPUType::Ia64_2)
+      .Case("i686", CPUType::PentiumPro)
+      .Default(CPUType::Intel80386); // CodeView doesn't have an "unknown" arch.
+}
+
+struct Version {
+  int Part[4];
+};
+
+// Takes a StringRef like "clang 4.0.0.0" and parses out the version number.
+static Version ParseVersion(StringRef Name) {
+  Version V = {0, 0, 0, 0};
+  int N = 0;
+  for (const char C : Name) {
+    if (isdigit(C)) {
+      V.Part[N] *= 10;
+      V.Part[N] += C - '0';
+    } else if (C == '.') {
+      ++N;
+      if (N >= 4)
+        return V;
+    }
+  }
+  return V;
+}
+
+void CodeViewDebug::emitCompilerInformation() {
+  MCContext &Context = MMI->getContext();
+  MCSymbol *CompilerBegin = Context.createTempSymbol(),
+           *CompilerEnd = Context.createTempSymbol();
+  OS.AddComment("Record length");
+  OS.emitAbsoluteSymbolDiff(CompilerEnd, CompilerBegin, 2);
+  OS.EmitLabel(CompilerBegin);
+  OS.AddComment("Record kind: S_COMPILE3");
+  OS.EmitIntValue(SymbolKind::S_COMPILE3, 2);
+  uint32_t Flags = 0;
+
+  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
+  const MDNode *Node = *CUs->operands().begin();
+  const auto *CU = cast<DICompileUnit>(Node);
+
+  // The low byte of the flags indicates the source language.
+  Flags = MapDWLangToCVLang(CU->getSourceLanguage());
+  // TODO:  Figure out which other flags need to be set.
+
+  OS.AddComment("Flags and language");
+  OS.EmitIntValue(Flags, 4);
+
+  OS.AddComment("CPUType");
+  StringRef Triple = Asm->getTargetTriple();
+  StringRef CPUName = Triple.take_front(Triple.find("-"));
+  CPUType CPU = MapCPUtoCVCPU(CPUName);
+  OS.EmitIntValue(static_cast<uint64_t>(CPU), 2);
+
+  StringRef CompilerVersion = CU->getProducer();
+  Version V = ParseVersion(CompilerVersion);
+  OS.AddComment("Frontend version");
+  for (int N = 0; N < 4; ++N)
+    OS.EmitIntValue(V.Part[N], 2);
+  OS.AddComment("Backend version");
+  for (int N = 0; N < 4; ++N)
+    OS.EmitIntValue(V.Part[N], 2);
+
+  OS.AddComment("Null-terminated compiler version string");
+  emitNullTerminatedSymbolName(OS, CompilerVersion);
+
+  OS.EmitLabel(CompilerEnd);
+}
+
 void CodeViewDebug::emitInlineeLinesSubsection() {
   if (InlinedSubprograms.empty())
     return;
 
   OS.AddComment("Inlinee lines subsection");
   MCSymbol *InlineEnd = beginCVSubsection(ModuleSubstreamKind::InlineeLines);
 
   // We don't provide any extra file info.
void CodeViewDebug::emitDebugInfoForFunction(const Function *GV,
   MCSymbol *SymbolsEnd = beginCVSubsection(ModuleSubstreamKind::Symbols);
   {
     MCSymbol *ProcRecordBegin = MMI->getContext().createTempSymbol(),
              *ProcRecordEnd = MMI->getContext().createTempSymbol();
     OS.AddComment("Record length");
     OS.emitAbsoluteSymbolDiff(ProcRecordEnd, ProcRecordBegin, 2);
     OS.EmitLabel(ProcRecordBegin);
 
     if (GV->hasLocalLinkage()) {
       OS.AddComment("Record kind: S_LPROC32_ID");
       OS.EmitIntValue(unsigned(SymbolKind::S_LPROC32_ID), 2);
     } else {
       OS.AddComment("Record kind: S_GPROC32_ID");
       OS.EmitIntValue(unsigned(SymbolKind::S_GPROC32_ID), 2);
     }
 
     // These fields are filled in by tools like CVPACK which run after the fact.
     OS.AddComment("PtrParent");
     OS.EmitIntValue(0, 4);
     OS.AddComment("PtrEnd");
     OS.EmitIntValue(0, 4);
     OS.AddComment("PtrNext");
     OS.EmitIntValue(0, 4);

 
 MCSymbol *CodeViewDebug::beginCVSubsection(ModuleSubstreamKind Kind) {
   MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
            *EndLabel = MMI->getContext().createTempSymbol();
   OS.EmitIntValue(unsigned(Kind), 4);
   OS.AddComment("Subsection size");
   OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4);
   OS.EmitLabel(BeginLabel);
+  if (Kind == ModuleSubstreamKind::Symbols)
+    emitCompilerInformation();
   return EndLabel;
 }
 
 void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) {
   OS.EmitLabel(EndLabel);
   // Every subsection must be aligned to a 4-byte boundary.
   OS.EmitValueToAlignment(4);
 }

test/MC/COFF/cv-compiler-info.ll

+; RUN: llc -mtriple i686-pc-windows-msvc < %s | FileCheck %s
+; ModuleID = 'D:\src\scopes\foo.cpp'
+source_filename = "D:\5Csrc\5Cscopes\5Cfoo.cpp"
+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc19.0.23918"
+
+; Function Attrs: nounwind sspstrong
+define i32 @"\01?foo@@YAHXZ"() #0 !dbg !10 {
+entry:
+  ret i32 42, !dbg !14
+}
+
+attributes #0 = { nounwind sspstrong "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="pentium4" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !7, !8}
+!llvm.ident = !{!9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 4.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+; The debug$S section should begin with an S_COMPILE3 record that identifies the
+; source language and the version of the compiler based on the DICompileUnit.
+; CHECK:  .section  .debug$S,"dr"
+; CHECK:    .p2align  2
+; CHECK:    .long 4                       # Debug section magic
+; CHECK:    .long 241                     # Symbol subsection for foo
+; CHECK:    .long Ltmp3-Ltmp2             # Subsection size
+; CHECK:  Ltmp2:
+; CHECK:    .short  Ltmp5-Ltmp4             # Record length
+; CHECK:  Ltmp4:
+; CHECK:    .short  4412                    # Record kind: S_COMPILE3
+; CHECK:    .long 1                       # Flags and language
+; CHECK:    .short  6                       # CPUType
+; CHECK:    .short  4                       # Frontend version
+; CHECK:    .short  0
+; CHECK:    .short  0
+; CHECK:    .short  0
+; CHECK:    .short  4                       # Backend version
+; CHECK:    .short  0
+; CHECK:    .short  0
+; CHECK:    .short  0
+; CHECK:    .asciz  "clang version 4.0.0 "  # Null-terminated compiler version string
+; CHECK:  Ltmp5:
+!1 = !DIFile(filename: "D:\5Csrc\5Cscopes\5Cfoo.cpp", directory: "D:\5Csrc\5Cscopes\5Cclang")
+!2 = !{}
+!3 = !{i32 6, !"Linker Options", !4}
+!4 = !{!5, !6}
+!5 = !{!"/DEFAULTLIB:libcmtd.lib"}
+!6 = !{!"/DEFAULTLIB:oldnames.lib"}
+!7 = !{i32 2, !"CodeView", i32 1}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{!"clang version 4.0.0 "}
+!10 = distinct !DISubprogram(name: "foo", linkageName: "\01?foo@@YAHXZ", scope: !1, file: !1, line: 1, type: !11, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!11 = !DISubroutineType(types: !12)
+!12 = !{!13}
+!13 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!14 = !DILocation(line: 2, scope: !10)