[CodeView] Add source languages ObjC and ObjC++

[sgraenitz]

Summary

This patch adds llvm::codeview::SourceLanguage entries, DWARF translations, and PDB source file extensions in LLVM and allow LLDB's PDB parsers to recognize them correctly.

The CV_CFL_LANG enum in the Visual Studio 2022 documentation https://learn.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/cv-cfl-lang defines:

CV_CFL_OBJC     = 0x11,
CV_CFL_OBJCXX   = 0x12,

Since the initial commit in D24317, ObjC was emitted as C language and ObjC++ as Masm.

[DavidSpickett]

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

142

Could put the same link from the commit message, here.

llvm/test/DebugInfo/COFF/objc.ll

5–7

Are these checked, should they be?

12–18

Do we need to check for these lines? Just the first few should be fine.

llvm/test/DebugInfo/COFF/objcpp.ll

5–7

Are these checked, should they be?

12–18

Same here.

[sgraenitz]

Maybe I should have noted immediately, that this is mostly following the change for Rust from https://reviews.llvm.org/D115300

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

142

I though about it, but such links will inevitably break again one day and/or lead to outdated information. The old link was very unfortunate. Web search for CV_CFL_LANG Microsoft Debug Interface Access SDK seems more stable. What do you think?

llvm/test/DebugInfo/COFF/objc.ll

5–7

Thanks for taking a look! What we check here is the 17 in language flags. The rest is just to make sure we get the right context. (Same for the others.) Is that your question?

[DavidSpickett]

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

142

Yeah sure, one can google the term instead. Agreed.

It is better than "download this random header file that probably has a strange license" :)

llvm/test/DebugInfo/COFF/objc.ll

5–7

Right but I don't know what that adds once you get beyond the Language line. It's a small thing, so that the test doesn't fail if a new key is added.

[DavidSpickett]

llvm/test/DebugInfo/COFF/objc.ll

5–7

Ignore the previous comment, wrong line.

So yes you can check these, but no one actually does. If you look at the filecheck line it only does OBJ.

Same for the rust change you linked. Unless there is some implicit behaviour here. One way to find out, put a bogus value in there and it should fail.

12–18

So here it's fine to check up to language, mostly, but after that what does it matter? If someone adds a new key the test breaks.

(and granted, it won't happen often if at all but the general principle holds)

[sgraenitz]

Cut down check-lines

llvm/test/DebugInfo/COFF/objc.ll

5–7

The first RUN line will exercise the ASM checks:

; RUN: llc < %s | FileCheck %s --check-prefix=ASM

12–18

Ok, fair enough. Cut it down.

[DavidSpickett]

LGTM

llvm/test/DebugInfo/COFF/objc.ll

5–7

Doh, sometimes I forget how to read.

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

static lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
   case PDB_Lang::Cpp:
     return lldb::LanguageType::eLanguageTypeC_plus_plus;
   case PDB_Lang::C:
     return lldb::LanguageType::eLanguageTypeC;
   case PDB_Lang::Swift:
     return lldb::LanguageType::eLanguageTypeSwift;
   case PDB_Lang::Rust:
     return lldb::LanguageType::eLanguageTypeRust;
+  case PDB_Lang::ObjC:
+    return lldb::LanguageType::eLanguageTypeObjC;
+  case PDB_Lang::ObjCpp:
+    return lldb::LanguageType::eLanguageTypeObjC_plus_plus;
   default:
     return lldb::LanguageType::eLanguageTypeUnknown;
   }
 }
 
 static std::unique_ptr<PDBFile>
 loadMatchingPDBFile(std::string exe_path, llvm::BumpPtrAllocator &allocator) {
   // Try to find a matching PDB for an EXE.

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
   case PDB_Lang::Cpp:
     return lldb::LanguageType::eLanguageTypeC_plus_plus;
   case PDB_Lang::C:
     return lldb::LanguageType::eLanguageTypeC;
   case PDB_Lang::Swift:
     return lldb::LanguageType::eLanguageTypeSwift;
   case PDB_Lang::Rust:
     return lldb::LanguageType::eLanguageTypeRust;
+  case PDB_Lang::ObjC:
+    return lldb::LanguageType::eLanguageTypeObjC;
+  case PDB_Lang::ObjCpp:
+    return lldb::LanguageType::eLanguageTypeObjC_plus_plus;
   default:
     return lldb::LanguageType::eLanguageTypeUnknown;
   }
 }
 
 bool ShouldAddLine(uint32_t requested_line, uint32_t actual_line,
                    uint32_t addr_length) {
   return ((requested_line == 0 || actual_line == requested_line) &&

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

enum class CPUType : uint16_t {
   ARMNT = 0xf4,
   ARM64 = 0xf6,
   HybridX86ARM64 = 0xf7,
   ARM64EC = 0xf8,
   ARM64X = 0xf9,
   D3D11_Shader = 0x100,
 };
 
-/// These values correspond to the CV_CFL_LANG enumeration, and are documented
-/// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
+/// These values correspond to the CV_CFL_LANG enumeration in the Microsoft
+/// Debug Interface Access SDK
 enum SourceLanguage : uint8_t {
   C = 0x00,
   Cpp = 0x01,
   Fortran = 0x02,
   Masm = 0x03,
   Pascal = 0x04,
   Basic = 0x05,
   Cobol = 0x06,
   Link = 0x07,
   Cvtres = 0x08,
   Cvtpgd = 0x09,
   CSharp = 0x0a,
   VB = 0x0b,
   ILAsm = 0x0c,
   Java = 0x0d,
   JScript = 0x0e,
   MSIL = 0x0f,
   HLSL = 0x10,
+  ObjC = 0x11,
+  ObjCpp = 0x12,
 
   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',
 };

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 }
 
 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:
static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
   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;
+  case dwarf::DW_LANG_ObjC:
+    return SourceLanguage::ObjC;
+  case dwarf::DW_LANG_ObjC_plus_plus:
+    return SourceLanguage::ObjCpp;
   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, 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, Rust),
+    CV_ENUM_ENT(SourceLanguage, ObjC),    CV_ENUM_ENT(SourceLanguage, ObjCpp),
 };
 
 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, 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)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, ObjC, OS)
+    CASE_OUTPUT_ENUM_CLASS_STR(PDB_Lang, ObjCpp, "ObjC++", 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()) {
       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)
+              .Case(".m", Lang == PDB_Lang::ObjC)
+              .Case(".mm", Lang == PDB_Lang::ObjCpp)
               .Default(false))
         return File->getFileName();
     }
   }
 
   return SourceFileFullPath;
 }

llvm/test/DebugInfo/COFF/language.ll

 ; 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
+;
+; RUN: sed -e 's/<LANG1>/DW_LANG_ObjC/;s/<LANG2>/ObjC/' %s > %t
+; RUN: llc -filetype=obj -o - %t | llvm-readobj --codeview - | FileCheck %t
+;
+; RUN: sed -e 's/<LANG1>/DW_LANG_ObjC_plus_plus/;s/<LANG2>/ObjCpp/' %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/objc.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   17                      # Flags and language
+
+; OBJ:       Kind: S_COMPILE3 (0x113C)
+; OBJ-NEXT:  Language: ObjC (0x11)
+
+; ModuleID = 'objc.m'
+source_filename = "objc.m"
+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 !5 {
+entry:
+  ret void, !dbg !9
+}
+
+attributes #0 = { uwtable "target-cpu"="x86-64" }
+
+!llvm.module.flags = !{!0, !1, !2}
+!llvm.dbg.cu = !{!3}
+
+!0 = !{i32 8, !"PIC Level", i32 2}
+!1 = !{i32 2, !"CodeView", i32 1}
+!2 = !{i32 2, !"Debug Info Version", i32 3}
+!3 = distinct !DICompileUnit(language: DW_LANG_ObjC, file: !4, producer: "clang version 17.0.0 (https://github.com/llvm/llvm-project a8e9beca6bee1f248ef4be7892802c4d091b7fcb)", isOptimized: false, runtimeVersion: 1, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!4 = !DIFile(filename: "objc.m", directory: "src", checksumkind: CSK_MD5, checksum: "e6ab1d5b7f82464c963a8522037dfa72")
+!5 = distinct !DISubprogram(name: "f", scope: !4, file: !4, line: 1, type: !6, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !3, retainedNodes: !8)
+!6 = !DISubroutineType(types: !7)
+!7 = !{null}
+!8 = !{}
+!9 = !DILocation(line: 1, scope: !5)

llvm/test/DebugInfo/COFF/objcpp.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   18                      # Flags and language
+
+; OBJ:       Kind: S_COMPILE3 (0x113C)
+; OBJ-NEXT:  Language: ObjCpp (0x12)
+
+; ModuleID = 'objcpp.mm'
+source_filename = "objcpp.mm"
+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@@YAXXZ"() #0 !dbg !5 {
+entry:
+  ret void, !dbg !9
+}
+
+attributes #0 = { uwtable "target-cpu"="x86-64" }
+
+!llvm.module.flags = !{!0, !1, !2}
+!llvm.dbg.cu = !{!3}
+
+!0 = !{i32 8, !"PIC Level", i32 2}
+!1 = !{i32 2, !"CodeView", i32 1}
+!2 = !{i32 2, !"Debug Info Version", i32 3}
+!3 = distinct !DICompileUnit(language: DW_LANG_ObjC_plus_plus, file: !4, producer: "clang version 17.0.0 (https://github.com/llvm/llvm-project a8e9beca6bee1f248ef4be7892802c4d091b7fcb)", isOptimized: false, runtimeVersion: 1, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!4 = !DIFile(filename: "objcpp.mm", directory: "src", checksumkind: CSK_MD5, checksum: "e6ab1d5b7f82464c963a8522037dfa72")
+!5 = distinct !DISubprogram(name: "f", linkageName: "?f@@YAXXZ", scope: !4, file: !4, line: 1, type: !6, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !3, retainedNodes: !8)
+!6 = !DISubroutineType(types: !7)
+!7 = !{null}
+!8 = !{}
+!9 = !DILocation(line: 1, scope: !5)

llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp

switch (Lang) {
     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_CASE(SourceLanguage, ObjC, "objc");
+    RETURN_CASE(SourceLanguage, ObjCpp, "objc++");
   }
   return formatUnknownEnum(Lang);
 }
 
 static std::string formatMachineType(CPUType Cpu) {
   switch (Cpu) {
     RETURN_CASE(CPUType, Intel8080, "intel 8080");
     RETURN_CASE(CPUType, Intel8086, "intel 8086");