[LLDB] Add DWARF definitions for the new Mojo language

[wallace]

Summary

The new language Mojo recently received a proper DWARF code, which can be seen in https://dwarfstd.org/languages.html, and this patch adds the basic definitions for using this language in DWARF.

Other languages have also been added to the DWARF spec recently, like HIP, but they are not defined in LLVM. I can add them if anyone thinks that's a good idea.

[rriddle]

LGTM, but deferring to code owners for full approval.

[jloser]

Excited to see this come together!

lldb/include/lldb/lldb-enumerations.h

enum LanguageType {
   eLanguageTypeZig = 0x0027,
   eLanguageTypeCrystal = 0x0028,
   eLanguageTypeC_plus_plus_17 = 0x002a, ///< ISO C++:2017.
   eLanguageTypeC_plus_plus_20 = 0x002b, ///< ISO C++:2020.
   eLanguageTypeC17 = 0x002c,
   eLanguageTypeFortran18 = 0x002d,
   eLanguageTypeAda2005 = 0x002e,
   eLanguageTypeAda2012 = 0x002f,
+  eLanguageTypeMojo = 0x0033,
 
   // Vendor Extensions
   // Note: Language::GetNameForLanguageType
   // assumes these can be used as indexes into array language_names, and
   // Language::SetLanguageFromCString and Language::AsCString assume these can
   // be used as indexes into array g_languages.
-  eLanguageTypeMipsAssembler,           ///< Mips_Assembler.
+  eLanguageTypeMipsAssembler, ///< Mips_Assembler.
   // Mojo will move to the common list of languages once the DWARF committee
   // creates a language code for it.
-  eLanguageTypeMojo,
   eNumLanguageTypes
 };
 
 enum InstrumentationRuntimeType {
   eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
   eInstrumentationRuntimeTypeThreadSanitizer = 0x0001,
   eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002,
   eInstrumentationRuntimeTypeMainThreadChecker = 0x0003,

lldb/source/Target/Language.cpp

static_cast<LanguageType>(
          0x0029)}, // Not yet taken by any language in the DWARF spec
                    // and thus has no entry in LanguageType
     {"c++17", eLanguageTypeC_plus_plus_17},
     {"c++20", eLanguageTypeC_plus_plus_20},
     {"c17", eLanguageTypeC17},
     {"fortran18", eLanguageTypeFortran18},
     {"ada2005", eLanguageTypeAda2005},
     {"ada2012", eLanguageTypeAda2012},
+    {"mojo", eLanguageTypeMojo},
     // Vendor Extensions
     {"assembler", eLanguageTypeMipsAssembler},
-    {"mojo", eLanguageTypeMojo},
     // Now synonyms, in arbitrary order
     {"objc", eLanguageTypeObjC},
     {"objc++", eLanguageTypeObjC_plus_plus},
     {"pascal", eLanguageTypePascal83}};
 
 static uint32_t num_languages =
     sizeof(language_names) / sizeof(struct language_name_pair);
 
bool Language::ImageListTypeScavenger::Find_Impl(
   return result;
 }
 
 std::pair<llvm::StringRef, llvm::StringRef>
 Language::GetFormatterPrefixSuffix(llvm::StringRef type_hint) {
   return std::pair<llvm::StringRef, llvm::StringRef>();
 }
 
-bool Language::DemangledNameContainsPath(llvm::StringRef path, 
+bool Language::DemangledNameContainsPath(llvm::StringRef path,
                                          ConstString demangled) const {
   // The base implementation does a simple contains comparision:
   if (path.empty())
     return false;
-  return demangled.GetStringRef().contains(path);                                         
+  return demangled.GetStringRef().contains(path);
 }
 
 DumpValueObjectOptions::DeclPrintingHelper Language::GetDeclPrintingHelper() {
   return nullptr;
 }
 
 LazyBool Language::IsLogicalTrue(ValueObject &valobj, Status &error) {
   return eLazyBoolCalculate;

llvm/include/llvm-c/DebugInfo.h

typedef enum {
   LLVMDWARFSourceLanguageZig,
   LLVMDWARFSourceLanguageCrystal,
   LLVMDWARFSourceLanguageC_plus_plus_17,
   LLVMDWARFSourceLanguageC_plus_plus_20,
   LLVMDWARFSourceLanguageC17,
   LLVMDWARFSourceLanguageFortran18,
   LLVMDWARFSourceLanguageAda2005,
   LLVMDWARFSourceLanguageAda2012,
+  LLVMDWARFSourceLanguageMojo,
   // Vendor extensions:
   LLVMDWARFSourceLanguageMips_Assembler,
   LLVMDWARFSourceLanguageGOOGLE_RenderScript,
   LLVMDWARFSourceLanguageBORLAND_Delphi
 } LLVMDWARFSourceLanguage;
 
 /**
  * The amount of debug information to emit.

llvm/include/llvm/BinaryFormat/Dwarf.h

inline bool isCPlusPlus(SourceLanguage S) {
   case DW_LANG_hi_user:
   case DW_LANG_Kotlin:
   case DW_LANG_Zig:
   case DW_LANG_Crystal:
   case DW_LANG_C17:
   case DW_LANG_Fortran18:
   case DW_LANG_Ada2005:
   case DW_LANG_Ada2012:
+  case DW_LANG_Mojo:
     result = false;
     break;
   }
 
   return result;
 }
 
 inline bool isFortran(SourceLanguage S) {
inline bool isFortran(SourceLanguage S) {
   case DW_LANG_Kotlin:
   case DW_LANG_Zig:
   case DW_LANG_Crystal:
   case DW_LANG_C_plus_plus_17:
   case DW_LANG_C_plus_plus_20:
   case DW_LANG_C17:
   case DW_LANG_Ada2005:
   case DW_LANG_Ada2012:
+  case DW_LANG_Mojo:
     result = false;
     break;
   }
 
   return result;
 }
 
 inline bool isC(SourceLanguage S) {
inline bool isC(SourceLanguage S) {
   case DW_LANG_lo_user:
   case DW_LANG_hi_user:
   case DW_LANG_Kotlin:
   case DW_LANG_Zig:
   case DW_LANG_Crystal:
   case DW_LANG_Fortran18:
   case DW_LANG_Ada2005:
   case DW_LANG_Ada2012:
+  case DW_LANG_Mojo:
     return false;
   }
   llvm_unreachable("Unknown language kind.");
 }
 
 inline TypeKind getArrayIndexTypeEncoding(SourceLanguage S) {
   return isFortran(S) ? DW_ATE_signed : DW_ATE_unsigned;
 }

llvm/include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DW_LANG(0x0027, Zig, 0, 0, DWARF)
 HANDLE_DW_LANG(0x0028, Crystal, 0, 0, DWARF)
 HANDLE_DW_LANG(0x002a, C_plus_plus_17, 0, 0, DWARF)
 HANDLE_DW_LANG(0x002b, C_plus_plus_20, 0, 0, DWARF)
 HANDLE_DW_LANG(0x002c, C17, 0, 0, DWARF)
 HANDLE_DW_LANG(0x002d, Fortran18, 0, 0, DWARF)
 HANDLE_DW_LANG(0x002e, Ada2005, 0, 0, DWARF)
 HANDLE_DW_LANG(0x002f, Ada2012, 0, 0, DWARF)
+HANDLE_DW_LANG(0x0033, Mojo, 0, 0, DWARF)
 // Vendor extensions:
 HANDLE_DW_LANG(0x8001, Mips_Assembler, std::nullopt, 0, MIPS)
 HANDLE_DW_LANG(0x8e57, GOOGLE_RenderScript, 0, 0, GOOGLE)
 HANDLE_DW_LANG(0xb000, BORLAND_Delphi, 0, 0, BORLAND)
 
 
 // DWARF attribute type encodings.
 HANDLE_DW_ATE(0x01, address, 2, DWARF)

llvm/lib/IR/DIBuilder.cpp

 DICompileUnit *DIBuilder::createCompileUnit(
     unsigned Lang, DIFile *File, StringRef Producer, bool isOptimized,
     StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
     DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
     bool SplitDebugInlining, bool DebugInfoForProfiling,
     DICompileUnit::DebugNameTableKind NameTableKind, bool RangesBaseAddress,
     StringRef SysRoot, StringRef SDK) {
 
-  assert(((Lang <= dwarf::DW_LANG_Ada2012 && Lang >= dwarf::DW_LANG_C89) ||
+  assert(((Lang <= dwarf::DW_LANG_Mojo && Lang >= dwarf::DW_LANG_C89) ||
           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
          "Invalid Language tag");
 
   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
   CUNode = DICompileUnit::getDistinct(
       VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
       SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId,
       SplitDebugInlining, DebugInfoForProfiling, NameTableKind,