Add Rust to CodeView SourceLanguage (CV_CFL_LANG) enum

[arlosi]

Summary

Microsoft has added several new entries to the CV_CFL_LANG enum, including Rust:

https://docs.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/cv-cfl-lang

This change adds Rust to the corresponding LLVM enum and translates dwarf::DW_LANG_Rust to SourceLanguage::Rust in the CodeView AsmPrinter.

This means that Rust will no longer emit as Masm.

[arlosi]

Adds Rust to a few more places that were missed. Test should pass now.

[arlosi]

Ping.

[rnk]

Sounds good. Can you add a basic test to exercise this? Have llc produce an object file from Rust IR, dump it with llvm-pdbutil, and show that it all round trips. It goes next to the other codeview tests (I forget the exact path).

[arlosi]

Add rust.ll test that verifies IR from rustc produces correct CodeView records with 0x15 (Rust) as the language.

[arlosi]

@rnk Thanks for taking a look. I added a test. The test failures currently showing don't look related to this change.

I don't have commit access, so it would be great if you (or someone else) could commit this once approved.

[arlosi]

Re-merging to trigger new build.

[rnk]

Thanks! Will land shortly

llvm/include/llvm/DebugInfo/CodeView/CodeView.h

enum SourceLanguage : uint8_t {
   CSharp = 0x0a,
   VB = 0x0b,
   ILAsm = 0x0c,
   Java = 0x0d,
   JScript = 0x0e,
   MSIL = 0x0f,
   HLSL = 0x10,
 
+  Rust = 0x15,
+
   /// The DMD & Swift compilers emit 'D' and 'S', respectively, for the CV
   /// source language. Microsoft does not have enumerators for them yet.
   D = 'D',
   Swift = 'S',
 };
 
 /// These values correspond to the CV_call_e enumeration, and are documented
 /// at the following locations:

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
   case dwarf::DW_LANG_Cobol85:
     return SourceLanguage::Cobol;
   case dwarf::DW_LANG_Java:
     return SourceLanguage::Java;
   case dwarf::DW_LANG_D:
     return SourceLanguage::D;
   case dwarf::DW_LANG_Swift:
     return SourceLanguage::Swift;
+  case dwarf::DW_LANG_Rust:
+    return SourceLanguage::Rust;
   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;
   }
 }
 

llvm/lib/DebugInfo/CodeView/EnumTables.cpp

static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
     CV_ENUM_ENT(SourceLanguage, Fortran), CV_ENUM_ENT(SourceLanguage, Masm),
     CV_ENUM_ENT(SourceLanguage, Pascal),  CV_ENUM_ENT(SourceLanguage, Basic),
     CV_ENUM_ENT(SourceLanguage, Cobol),   CV_ENUM_ENT(SourceLanguage, Link),
     CV_ENUM_ENT(SourceLanguage, Cvtres),  CV_ENUM_ENT(SourceLanguage, Cvtpgd),
     CV_ENUM_ENT(SourceLanguage, CSharp),  CV_ENUM_ENT(SourceLanguage, VB),
     CV_ENUM_ENT(SourceLanguage, ILAsm),   CV_ENUM_ENT(SourceLanguage, Java),
     CV_ENUM_ENT(SourceLanguage, JScript), CV_ENUM_ENT(SourceLanguage, MSIL),
     CV_ENUM_ENT(SourceLanguage, HLSL),    CV_ENUM_ENT(SourceLanguage, D),
-    CV_ENUM_ENT(SourceLanguage, Swift),
+    CV_ENUM_ENT(SourceLanguage, Swift),   CV_ENUM_ENT(SourceLanguage, Rust),
 };
 
 static const EnumEntry<uint32_t> CompileSym2FlagNames[] = {
     CV_ENUM_CLASS_ENT(CompileSym2Flags, EC),
     CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDbgInfo),
     CV_ENUM_CLASS_ENT(CompileSym2Flags, LTCG),
     CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDataAlign),
     CV_ENUM_CLASS_ENT(CompileSym2Flags, ManagedPresent),

llvm/lib/DebugInfo/PDB/PDBExtras.cpp

switch (Lang) {
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, VB, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, ILAsm, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, Java, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, JScript, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, MSIL, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, HLSL, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, D, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, Swift, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, Rust, OS)
   }
   return OS;
 }
 
 raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_SymType &Tag) {
   switch (Tag) {
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_SymType, Exe, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_SymType, Compiland, OS)

llvm/lib/DebugInfo/PDB/PDBSymbolCompiland.cpp

while (auto File = SrcFiles->getNext()) {
       auto file_extension = sys::path::extension(FileName);
       if (StringSwitch<bool>(file_extension.lower())
               .Case(".cpp", Lang == PDB_Lang::Cpp)
               .Case(".cc", Lang == PDB_Lang::Cpp)
               .Case(".cxx", Lang == PDB_Lang::Cpp)
               .Case(".c", Lang == PDB_Lang::C)
               .Case(".asm", Lang == PDB_Lang::Masm)
               .Case(".swift", Lang == PDB_Lang::Swift)
+              .Case(".rs", Lang == PDB_Lang::Rust)
               .Default(false))
         return File->getFileName();
     }
   }
 
   return SourceFileFullPath;
 }

llvm/test/DebugInfo/COFF/language.ll

 ; RUN: sed -e 's/<LANG1>/DW_LANG_Fortran95/;s/<LANG2>/Fortran/' %s > %t
 ; RUN: llc -filetype=obj -o - %t | llvm-readobj --codeview - | FileCheck %t
 ;
 ; RUN: sed -e 's/<LANG1>/DW_LANG_Fortran03/;s/<LANG2>/Fortran/' %s > %t
 ; RUN: llc -filetype=obj -o - %t | llvm-readobj --codeview - | FileCheck %t
 ;
 ; RUN: sed -e 's/<LANG1>/DW_LANG_Fortran08/;s/<LANG2>/Fortran/' %s > %t
 ; RUN: llc -filetype=obj -o - %t | llvm-readobj --codeview - | FileCheck %t
+;
+; RUN: sed -e 's/<LANG1>/DW_LANG_Rust/;s/<LANG2>/Rust/' %s > %t
+; RUN: llc -filetype=obj -o - %t | llvm-readobj --codeview - | FileCheck %t
 
 ; CHECK:      CodeViewDebugInfo [
 ; CHECK:        Subsection [
 ; CHECK:          SubSectionType: Symbols (0xF1)
 ; CHECK:          Compile3Sym {
 ; CHECK-NEXT:        Kind: S_COMPILE3 (0x113C)
 ; CHECK-NEXT:        Language: <LANG2>
 ; CHECK-NEXT:        Flags [ (0x0)

llvm/test/DebugInfo/COFF/rust.ll

+; RUN: llc < %s | FileCheck %s --check-prefix=ASM
+; RUN: llc -filetype=obj < %s | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+
+; ASM:      .short  4412                    # Record kind: S_COMPILE3
+; ASM-NEXT: .long   21                      # Flags and language
+; ASM-NEXT: .short  208                     # CPUType
+
+; OBJ-LABEL: Compile3Sym {
+; OBJ-NEXT:    Kind: S_COMPILE3 (0x113C)
+; OBJ-NEXT:    Language: Rust (0x15)
+; OBJ-NEXT:    Flags [ (0x0)
+; OBJ-NEXT:    ]
+; OBJ-NEXT:    Machine: X64 (0xD0)
+; OBJ-NEXT:    FrontendVersion: {{[0-9.]*}}
+; OBJ-NEXT:    BackendVersion: {{[0-9.]*}}
+; OBJ-NEXT:    VersionName: clang LLVM (rustc version 1.57.0 (f1edd0429 2021-11-29))
+; OBJ-NEXT:  }
+
+
+; ModuleID = 'main.a61fec89-cgu.0'
+source_filename = "main.a61fec89-cgu.0"
+target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+; Function Attrs: uwtable
+define void @f() unnamed_addr #0 !dbg !6 {
+start:
+  ret void, !dbg !11
+}
+
+attributes #0 = { uwtable "target-cpu"="x86-64" }
+
+!llvm.module.flags = !{!0, !1, !2}
+!llvm.dbg.cu = !{!3}
+
+!0 = !{i32 7, !"PIC Level", i32 2}
+!1 = !{i32 2, !"CodeView", i32 1}
+!2 = !{i32 2, !"Debug Info Version", i32 3}
+!3 = distinct !DICompileUnit(language: DW_LANG_Rust, file: !4, producer: "clang LLVM (rustc version 1.57.0 (f1edd0429 2021-11-29))", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5)
+!4 = !DIFile(filename: "main.rs", directory: "src")
+!5 = !{}
+!6 = distinct !DISubprogram(name: "f", scope: !8, file: !7, line: 13, type: !9, scopeLine: 13, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !3, templateParams: !5, retainedNodes: !5)
+!7 = !DIFile(filename: "main.rs", directory: "src", checksumkind: CSK_SHA1, checksum: "2ac9107db410c2ac03093f537ff521068091fb92")
+!8 = !DINamespace(name: "main", scope: null)
+!9 = !DISubroutineType(types: !10)
+!10 = !{null}
+!11 = !DILocation(line: 14, scope: !12)
+!12 = !DILexicalBlockFile(scope: !6, file: !7, discriminator: 0)

llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp

switch (Lang) {
     RETURN_CASE(SourceLanguage, CSharp, "c#");
     RETURN_CASE(SourceLanguage, ILAsm, "il asm");
     RETURN_CASE(SourceLanguage, Java, "java");
     RETURN_CASE(SourceLanguage, JScript, "javascript");
     RETURN_CASE(SourceLanguage, MSIL, "msil");
     RETURN_CASE(SourceLanguage, HLSL, "hlsl");
     RETURN_CASE(SourceLanguage, D, "d");
     RETURN_CASE(SourceLanguage, Swift, "swift");
+    RETURN_CASE(SourceLanguage, Rust, "rust");
   }
   return formatUnknownEnum(Lang);
 }
 
 static std::string formatMachineType(CPUType Cpu) {
   switch (Cpu) {
     RETURN_CASE(CPUType, Intel8080, "intel 8080");
     RETURN_CASE(CPUType, Intel8086, "intel 8086");