[llvm-debuginfo-analyzer] LVSourceLanguage: use enum instead of std::variant

Author: jalopezg-git

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

@@ -144,36 +144,8 @@ enum class CPUType : uint16_t {
 /// Debug Interface Access SDK, and are documented here:
 /// https://learn.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/cv-cfl-lang
 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,
-  Swift = 0x13,
-  AliasObj = 0x14,
-  Rust = 0x15,
-  Go = 0x16,
-
-  /// The DMD compiler emits 'D' for the CV source language. Microsoft does not
-  /// have an enumerator for it yet.
-  D = 'D',
-  /// The Swift compiler used to emit 'S' for the CV source language, but
-  /// current versions emit the enumerator defined above.
-  OldSwift = 'S',
+#define CV_LANGUAGE(NAME, ID) NAME = ID,
+#include "CodeViewLanguages.def"
 };
 
 /// These values correspond to the CV_call_e enumeration, and are documented

llvm/include/llvm/DebugInfo/CodeView/CodeViewLanguages.def

@@ -0,0 +1,51 @@
+//===-- CodeViewLanguages.def - All CodeView languages ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// These values correspond to the CV_CFL_LANG enumeration in the Microsoft
+// Debug Interface Access SDK, and are documented here:
+// https://learn.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/cv-cfl-lang
+// This should match the constants there.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CV_LANGUAGE
+#define CV_LANGUAGE(NAME, ID)
+#endif
+
+CV_LANGUAGE(C, 0x00)
+CV_LANGUAGE(Cpp, 0x01)
+CV_LANGUAGE(Fortran, 0x02)
+CV_LANGUAGE(Masm, 0x03)
+CV_LANGUAGE(Pascal, 0x04)
+CV_LANGUAGE(Basic, 0x05)
+CV_LANGUAGE(Cobol, 0x06)
+CV_LANGUAGE(Link, 0x07)
+CV_LANGUAGE(Cvtres, 0x08)
+CV_LANGUAGE(Cvtpgd, 0x09)
+CV_LANGUAGE(CSharp, 0x0a)
+CV_LANGUAGE(VB, 0x0b)
+CV_LANGUAGE(ILAsm, 0x0c)
+CV_LANGUAGE(Java, 0x0d)
+CV_LANGUAGE(JScript, 0x0e)
+CV_LANGUAGE(MSIL, 0x0f)
+CV_LANGUAGE(HLSL, 0x10)
+CV_LANGUAGE(ObjC, 0x11)
+CV_LANGUAGE(ObjCpp, 0x12)
+CV_LANGUAGE(Swift, 0x13)
+CV_LANGUAGE(AliasObj, 0x14)
+CV_LANGUAGE(Rust, 0x15)
+CV_LANGUAGE(Go, 0x16)
+
+// The DMD compiler emits 'D' for the CV source language. Microsoft does not
+// have an enumerator for it yet.
+CV_LANGUAGE(D, 'D')
+/// The Swift compiler used to emit 'S' for the CV source language, but
+// current versions emit the enumerator defined above.
+CV_LANGUAGE(OldSwift, 'S')
+
+#undef CV_LANGUAGE

llvm/include/llvm/DebugInfo/LogicalView/Core/LVElement.h

@@ -19,7 +19,6 @@
 #include "llvm/Support/MathExtras.h"
 #include <map>
 #include <set>
-#include <variant>
 #include <vector>
 
 namespace llvm {
@@ -73,18 +72,39 @@ constexpr unsigned int DWARF_CHAR_BIT = 8u;
 
 /// A source language supported by any of the debug info representations.
 struct LVSourceLanguage {
+  static constexpr unsigned TagDwarf = 0x00;
+  static constexpr unsigned TagCodeView = 0x01;
+
+  enum TaggedLanguage : uint32_t {
+  // DWARF
+#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
+  DW_LANG_##NAME = (TagDwarf << 16) | ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+  // CodeView
+#define CV_LANGUAGE(NAME, ID) CV_LANG_##NAME = (TagCodeView << 16) | ID,
+#include "llvm/DebugInfo/CodeView/CodeViewLanguages.def"
+
+    Invalid = -1U
+  };
+
   LVSourceLanguage() = default;
-  LVSourceLanguage(llvm::dwarf::SourceLanguage SL) : Language(SL) {}
-  LVSourceLanguage(llvm::codeview::SourceLanguage SL) : Language(SL) {}
+  LVSourceLanguage(llvm::dwarf::SourceLanguage SL)
+      : Language(static_cast<TaggedLanguage>((TagDwarf << 16) | SL)) {}
+  LVSourceLanguage(llvm::codeview::SourceLanguage SL)
+      : Language(static_cast<TaggedLanguage>((TagCodeView << 16) | SL)) {}
+  bool operator==(const LVSourceLanguage &SL) const {
+    return get() == SL.get();
+  }
+  bool operator==(const LVSourceLanguage::TaggedLanguage &TL) const {
+    return get() == TL;
+  }
 
-  bool isValid() const { return Language.index() != 0; }
-  template <typename T> T getAs() { return std::get<T>(Language); }
+  bool isValid() const { return Language != Invalid; }
+  TaggedLanguage get() const { return Language; }
   StringRef getName() const;
 
 private:
-  std::variant<std::monostate, llvm::dwarf::SourceLanguage,
-               llvm::codeview::SourceLanguage>
-      Language;
+  TaggedLanguage Language = Invalid;
 };
 
 class LVElement : public LVObject {

llvm/lib/DebugInfo/LogicalView/Core/LVElement.cpp

@@ -23,14 +23,13 @@ using namespace llvm::logicalview;
 StringRef LVSourceLanguage::getName() const {
   if (!isValid())
     return {};
-  switch (Language.index()) {
-  case 1: // DWARF
-    return llvm::dwarf::LanguageString(
-        std::get<llvm::dwarf::SourceLanguage>(Language));
-  case 2: // CodeView
-  {
+  const unsigned Tag = (Language >> 16);
+  switch (Tag) {
+  case LVSourceLanguage::TagDwarf:
+    return llvm::dwarf::LanguageString(Language & 0xffff);
+  case LVSourceLanguage::TagCodeView: {
     static auto LangNames = llvm::codeview::getSourceLanguageNames();
-    return LangNames[std::get<llvm::codeview::SourceLanguage>(Language)].Name;
+    return LangNames[Language & 0xffff].Name;
   }
   default:
     llvm_unreachable("Unsupported language");

llvm/unittests/DebugInfo/LogicalView/CodeViewReaderTest.cpp

@@ -81,8 +81,7 @@ void checkElementPropertiesClangCodeview(LVReader *Reader) {
   EXPECT_EQ(CompileUnit->getName(), "test.cpp");
   LVSourceLanguage Language = CompileUnit->getSourceLanguage();
   EXPECT_TRUE(Language.isValid());
-  ASSERT_EQ(Language.getAs<llvm::codeview::SourceLanguage>(),
-            llvm::codeview::SourceLanguage::Cpp);
+  ASSERT_EQ(Language, LVSourceLanguage::CV_LANG_Cpp);
   ASSERT_EQ(Language.getName(), "Cpp");
 
   EXPECT_EQ(Function->lineCount(), 16u);

llvm/unittests/DebugInfo/LogicalView/DWARFReaderTest.cpp

@@ -78,8 +78,7 @@ void checkElementProperties(LVReader *Reader) {
   EXPECT_EQ(CompileUnit->getName(), "test.cpp");
   LVSourceLanguage Language = CompileUnit->getSourceLanguage();
   EXPECT_TRUE(Language.isValid());
-  EXPECT_EQ(Language.getAs<llvm::dwarf::SourceLanguage>(),
-            llvm::dwarf::DW_LANG_C_plus_plus_14);
+  EXPECT_EQ(Language, LVSourceLanguage::DW_LANG_C_plus_plus_14);
   EXPECT_EQ(Language.getName(), "DW_LANG_C_plus_plus_14");
 
   EXPECT_EQ(CompileUnit->lineCount(), 0u);