[lldb][PDB] Constexpr static member values as AST literals

[jackoalan]

Summary

When evaluating an expression referencing a constexpr static member variable, an error is issued because the PDB does not specify a symbol with an address that can be relocated against.

Rather than attempt to resolve the variable's value within the IR execution, the values of all constants can be looked up and incorporated into the AST of the record type as a literal, mirroring the original compiler AST.

This change applies to DIA and native PDB loaders.

[teemperor]

You might also be interested in D81471 which is a very similar patch but for DWARF and only focused on static const integer/enum data members.

One thing I'm curious about is how this is solving (or if it's even supposed to solve) the issue that the expression parser is by default taking the address of lvalues (which will bring us back to the issue that LLDB will try to resolve the symbol)? From what I understand, this patch allows me to to things like expr Class::Member + 1 but not expr Class::Member (because the expression evaluator will rewrite that lvalue to int *$__lldb_expr_result_ptr = &Class::Member).

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

155

What about just doing the switch directly on member_ct.GetBasicTypeEnumeration() and check for eBasicTypeFloat and so on. That's less code to do the same thing without all the casting.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

7321

Passing a too large APSInt into this function will just silently truncate it. I think this should refuse to add the initializer in this case (and we probably should at least log that error somewhere).

lldb/test/Shell/SymbolFile/PDB/Inputs/AstRestoreTest.cpp

27

You might want to also add some static const (not constexpr) integer and enum members to this test.

Also I'm curious what happens if you put a long double as a member? From what I can see the expected behavior is that PDB will not emit that as a constant (as the current code asserts if it encounters long double anywhere).

[jackoalan]

Review changes from @teemperor.

Base on TypeSystemClang::SetIntegerInitializerForVariable from D81471, and add associated TypeSystemClang::SetFloatingInitializerForVariable.

[jackoalan]

Thank you @teemperor, your comments and changes in D81471 are very informative. I didn't realise DWARF had similar issues with static const members.

Curiously, I am able to resolve direct variable expressions without your ASTResultSynthesizer changes. I'm guessing this is due to differences in the MS linking convention for the IR module.

If you're interested, here are lldb.expr logs comparing member evaluation with and without the synthesizer change:
without: https://gist.github.com/jackoalan/f70f223c5e9ec25d6c8e3a5e09940a71
with: https://gist.github.com/jackoalan/e33c878c545c5b270e6f3da44ef57320

Your changes are definitely preferred. The IR execution takes a much more roundabout approach originally, and the change noticeably speeds up evaluation.

lldb/test/Shell/SymbolFile/PDB/Inputs/AstRestoreTest.cpp

27

long double is aliased to double according to MS docs. The constant can be extracted in the same manner.

[jackoalan]

Fix ternary to use corresponding float/double overloaded constructors of APFloat

[jackoalan]

Apply formatting fixes

[aleksandr.urakov]

Hello! Thanks for the patch, generally it looks good to me, the only thing I worry about is scoped enums (please, see the comment below).

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

7324–7331

I'm not sure, can we initialize a member this way if it has a scoped enum type?

[teemperor]

The only remaining issue with the LLDB expression part is that now that SetFloatingInitializerForVariable is based on the D81471 version it no longer makes the member variable a constexpr. Int/Enum members with initialisers can just be const, but for any floating point types this ends ups creating an AST that we usually can't get from the Clang parser (as floats can't be initialised this way). Clang will still codegen that for us, but I think making the floating point VarDecls constexpr could save us from bad surprises in the future (e.g., someone adds an assert to Clang/Sema that const static data members are only initialised when they have integer/enum type). I think marking the variable as constexpr in the two places where you call SetFloatingInitializerForVariable seems like the right place for this (SetFloatingInitializerForVariable probably shouldn't set that flag on its own, that seems like unexpected behaviour from this function).

Otherwise I think auto is used quite frequently and doesn't really fit to LLVM's "auto only if it makes code more readable" policy. I think all the integer types for the type widths should just be their own type (uint32_t makes the code easier to understand than auto). And I don't think LLDB usually does auto in LLDB for types/decls as LLDB has its own type/decl abstraction (CompilerType and CompilerDecl), so that's also confusing.

Beside that this patch looks good to me. Maybe someone that knows more about PDB should also take a look about the PDB-specific parts of the patch.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

7324–7331

(That code is from D81471 so I think I should answer that)

Well, it works and but it relies on CodeGen/Sema not double-checking that we get the enum type (and not the underlying int type). I can inject a CXXStaticCastExpr too and will update D81471. Thanks!

[aleksandr.urakov]

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

7324–7331

Ok, thank you!

[jackoalan]

• Added a test for scoped enums (works as-is but still worth testing).
• Less frivolous use of auto
• Made the floating point vars constexpr to maintain validity in clang's internals.
• AstRestoreTest CLASS tests run for both DIA and Native. A pure NativePDB test that does not depend on MSVC would require extending s_constant.cpp (S_CONSTANT not generated by clang-cl) but I'm not certain how to regenerate the listing file with comments (unless that's done by hand). For now, this change should only be considered relevant for PDBs generated by MSVC.

[jackoalan]

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

7324–7331

Added a test just in case

[aleksandr.urakov]

LGTM, thanks!

[jackoalan]

Thank you! I do not have commit access, so I will need some help with that.

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

bool PdbAstBuilder::CompleteTagDecl(clang::TagDecl &tag) {
   TypeIndex field_list_ti = GetFieldListIndex(cvt);
   CVType field_list_cvt = m_index.tpi().getType(field_list_ti);
   if (field_list_cvt.kind() != LF_FIELDLIST)
     return false;
 
   // Visit all members of this class, then perform any finalization necessary
   // to complete the class.
   CompilerType ct = ToCompilerType(tag_qt);
-  UdtRecordCompleter completer(best_ti, ct, tag, *this, m_index.tpi());
+  UdtRecordCompleter completer(best_ti, ct, tag, *this, m_index);
   auto error =
       llvm::codeview::visitMemberRecordStream(field_list_cvt.data(), completer);
   completer.complete();
 
   status.resolved = true;
   if (!error)
     return true;
 

lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.h

 //===-- UdtRecordCompleter.h ------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_UDTRECORDCOMPLETER_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_UDTRECORDCOMPLETER_H
 
 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 
 #include "PdbSymUid.h"
 
 namespace clang {
 class CXXBaseSpecifier;
 class QualType;
 class TagDecl;
 } // namespace clang
 
 namespace llvm {
 namespace pdb {
 class TpiStream;
+class GlobalsStream;
 }
 } // namespace llvm
 
 namespace lldb_private {
 class Type;
 class CompilerType;
 namespace npdb {
 class PdbAstBuilder;
+class PdbIndex;
 
 class UdtRecordCompleter : public llvm::codeview::TypeVisitorCallbacks {
   using IndexedBase =
       std::pair<uint64_t, std::unique_ptr<clang::CXXBaseSpecifier>>;
 
   union UdtTagRecord {
     UdtTagRecord() {}
     llvm::codeview::UnionRecord ur;
     llvm::codeview::ClassRecord cr;
     llvm::codeview::EnumRecord er;
   } m_cvr;
 
   PdbTypeSymId m_id;
   CompilerType &m_derived_ct;
   clang::TagDecl &m_tag_decl;
   PdbAstBuilder &m_ast_builder;
-  llvm::pdb::TpiStream &m_tpi;
+  PdbIndex &m_index;
   std::vector<IndexedBase> m_bases;
   ClangASTImporter::LayoutInfo m_layout;
 
 public:
   UdtRecordCompleter(PdbTypeSymId id, CompilerType &derived_ct,
                      clang::TagDecl &tag_decl, PdbAstBuilder &ast_builder,
-                     llvm::pdb::TpiStream &tpi);
+                     PdbIndex &index);
 
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   llvm::Error visitKnownMember(llvm::codeview::CVMemberRecord &CVR,            \
                                llvm::codeview::Name##Record &Record) override;
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
 
   void complete();

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

 #include "UdtRecordCompleter.h"
 
 #include "PdbAstBuilder.h"
 #include "PdbIndex.h"
 #include "PdbSymUid.h"
 #include "PdbUtil.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
+#include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 
+#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::npdb;
 
 using Error = llvm::Error;
 
 UdtRecordCompleter::UdtRecordCompleter(PdbTypeSymId id,
                                        CompilerType &derived_ct,
                                        clang::TagDecl &tag_decl,
                                        PdbAstBuilder &ast_builder,
-                                       TpiStream &tpi)
+                                       PdbIndex &index)
     : m_id(id), m_derived_ct(derived_ct), m_tag_decl(tag_decl),
-      m_ast_builder(ast_builder), m_tpi(tpi) {
-  CVType cvt = m_tpi.getType(m_id.index);
+      m_ast_builder(ast_builder), m_index(index) {
+  CVType cvt = m_index.tpi().getType(m_id.index);
   switch (cvt.kind()) {
   case LF_ENUM:
     llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, m_cvr.er));
     break;
   case LF_UNION:
     llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, m_cvr.ur));
     break;
   case LF_CLASS:
   case LF_STRUCTURE:
     llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, m_cvr.cr));
     break;
   default:
     llvm_unreachable("unreachable!");
   }
 }
 
 clang::QualType UdtRecordCompleter::AddBaseClassForTypeIndex(
     llvm::codeview::TypeIndex ti, llvm::codeview::MemberAccess access,
     llvm::Optional<uint64_t> vtable_idx) {
   PdbTypeSymId type_id(ti);
   clang::QualType qt = m_ast_builder.GetOrCreateType(type_id);
 
-  CVType udt_cvt = m_tpi.getType(ti);
+  CVType udt_cvt = m_index.tpi().getType(ti);
 
   std::unique_ptr<clang::CXXBaseSpecifier> base_spec =
       m_ast_builder.clang().CreateBaseClassSpecifier(
           qt.getAsOpaquePtr(), TranslateMemberAccess(access),
           vtable_idx.hasValue(), udt_cvt.kind() == LF_CLASS);
   lldbassert(base_spec);
 
   m_bases.push_back(
clang::QualType member_type =
       m_ast_builder.GetOrCreateType(PdbTypeSymId(static_data_member.Type));
 
   m_ast_builder.CompleteType(member_type);
 
   CompilerType member_ct = m_ast_builder.ToCompilerType(member_type);
 
   lldb::AccessType access =
       TranslateMemberAccess(static_data_member.getAccess());
-  TypeSystemClang::AddVariableToRecordType(
+  auto decl = TypeSystemClang::AddVariableToRecordType(
       m_derived_ct, static_data_member.Name, member_ct, access);
 
+  // Static constant members may be a const[expr] declaration.
+  // Query the symbol's value as the variable initializer if valid.
+  if (member_ct.IsConst()) {
+    auto qual_name = decl->getQualifiedNameAsString();
+
+    auto results =
+        m_index.globals().findRecordsByName(qual_name, m_index.symrecords());
+
+    for (const auto &result : results) {
+      if (result.second.kind() == SymbolKind::S_CONSTANT) {
+        ConstantSym constant(SymbolRecordKind::ConstantSym);
+        cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(result.second,
+                                                                constant));
+
+        auto qual_type = decl->getType();
+        auto type_width = decl->getASTContext().getIntWidth(qual_type);
+        auto constant_width = constant.Value.getBitWidth();
+
+        if (qual_type->isIntegralOrEnumerationType()) {
+          if (type_width >= constant_width) {
+            TypeSystemClang::SetIntegerInitializerForVariable(
+                decl, constant.Value.extOrTrunc(type_width));
+          } else if (Log *log_ast =
+              GetLogIfAllCategoriesSet(LIBLLDB_LOG_AST)) {
+            LLDB_LOG(
+                log_ast,
+                "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) "
+                "which resolves to a wider constant value ({4} bits). "
+                "Ignoring constant.",
+                m_derived_ct.GetTypeName(), static_data_member.Name,
+                member_ct.GetTypeName(), type_width, constant_width);
+          }
+        } else {
+          auto basic_type_enum = member_ct.GetBasicTypeEnumeration();
+          switch (basic_type_enum) {
+          case lldb::eBasicTypeFloat:
+          case lldb::eBasicTypeDouble:
+          case lldb::eBasicTypeLongDouble:
+            if (type_width == constant_width) {
+              TypeSystemClang::SetFloatingInitializerForVariable(
+                  decl, basic_type_enum == lldb::eBasicTypeFloat
+                            ? llvm::APFloat(constant.Value.bitsToFloat())
+                            : llvm::APFloat(constant.Value.bitsToDouble()));
+            } else if (Log *log_ast = GetLogIfAllCategoriesSet(LIBLLDB_LOG_AST)) {
+              LLDB_LOG(log_ast,
+                       "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) "
+                       "which resolves to a constant value of mismatched width "
+                       "({4} bits). Ignoring constant.",
+                       m_derived_ct.GetTypeName(), static_data_member.Name,
+                       member_ct.GetTypeName(), type_width, constant_width);
+            }
+            break;
+          default:
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+
   // FIXME: Add a PdbSymUid namespace for field list members and update
   // the m_uid_to_decl map with this decl.
   return Error::success();
 }
 
 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
                                            NestedTypeRecord &nested) {
   return Error::success();
 }
 
 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
                                            DataMemberRecord &data_member) {
 
   uint64_t offset = data_member.FieldOffset * 8;
   uint32_t bitfield_width = 0;
 
   TypeIndex ti(data_member.Type);
   if (!ti.isSimple()) {
-    CVType cvt = m_tpi.getType(ti);
+    CVType cvt = m_index.tpi().getType(ti);
     if (cvt.kind() == LF_BITFIELD) {
       BitFieldRecord bfr;
       llvm::cantFail(TypeDeserializer::deserializeAs<BitFieldRecord>(cvt, bfr));
       offset += bfr.BitOffset;
       bitfield_width = bfr.BitSize;
       ti = bfr.Type;
     }
   }
Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
 
   return Error::success();
 }
 
 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
                                            OverloadedMethodRecord &overloaded) {
   TypeIndex method_list_idx = overloaded.MethodList;
 
-  CVType method_list_type = m_tpi.getType(method_list_idx);
+  CVType method_list_type = m_index.tpi().getType(method_list_idx);
   assert(method_list_type.kind() == LF_METHODLIST);
 
   MethodOverloadListRecord method_list;
   llvm::cantFail(TypeDeserializer::deserializeAs<MethodOverloadListRecord>(
       method_list_type, method_list));
 
   for (const OneMethodRecord &method : method_list.Methods)
     AddMethod(overloaded.Name, method.Type, method.getAccess(),

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

case PDB_DataKind::Member: {
       break;
     }
     case PDB_DataKind::StaticMember: {
       auto decl = TypeSystemClang::AddVariableToRecordType(
           record_type, member_name.c_str(), member_comp_type, access);
       if (!decl)
         continue;
 
+      // Static constant members may be a const[expr] declaration.
+      // Query the symbol's value as the variable initializer if valid.
+      if (member_comp_type.IsConst()) {
+        auto value = member->getValue();
+        auto qual_type = decl->getType();
+        auto type_width = m_ast.getASTContext().getIntWidth(qual_type);
+        auto constant_width = value.getBitWidth();
+
+        if (qual_type->isIntegralOrEnumerationType()) {
+          if (type_width >= constant_width) {
+            TypeSystemClang::SetIntegerInitializerForVariable(
+                decl, value.toAPSInt().extOrTrunc(type_width));
+          } else if (Log *log_ast =
+              GetLogIfAllCategoriesSet(LIBLLDB_LOG_AST)) {
+            LLDB_LOG(
+                log_ast,
+                "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) "
+                "which resolves to a wider constant value ({4} bits). "
+                "Ignoring constant.",
+                record_type.GetTypeName(), member_name,
+                member_comp_type.GetTypeName(), type_width, constant_width);
+          }
+        } else {
+          switch (member_comp_type.GetBasicTypeEnumeration()) {
+          case lldb::eBasicTypeFloat:
+          case lldb::eBasicTypeDouble:
+          case lldb::eBasicTypeLongDouble:
+            if (type_width == constant_width) {
+              TypeSystemClang::SetFloatingInitializerForVariable(
+                  decl, value.toAPFloat());
+            } else if (Log *log_ast = GetLogIfAllCategoriesSet(LIBLLDB_LOG_AST)) {
+              LLDB_LOG(
+                  log_ast,
+                  "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) which "
+                  "resolves to a constant value of mismatched width ({4} bits). "
+                  "Ignoring constant.",
+                  record_type.GetTypeName(), member_name,
+                  member_comp_type.GetTypeName(), type_width, constant_width);
+            }
+            break;
+          default:
+            break;
+          }
+        }
+
+
+      }
+
       m_uid_to_decl[member->getSymIndexId()] = decl;
 
       break;
     }
     default:
       llvm_unreachable("unsupported PDB data kind");
     }
   }

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTFwd.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
 
   static void SetIsPacked(const CompilerType &type);
 
   static clang::VarDecl *AddVariableToRecordType(const CompilerType &type,
                                                  llvm::StringRef name,
                                                  const CompilerType &var_type,
                                                  lldb::AccessType access);
 
+  /// Initializes a variable with an integer value.
+  /// \param var The variable to initialize. Must not already have an
+  ///            initializer and must have an integer or enum type.
+  /// \param init_value The integer value that the variable should be
+  ///                   initialized to. Has to match the bit width of the
+  ///                   variable type.
+  static void SetIntegerInitializerForVariable(clang::VarDecl *var,
+                                               const llvm::APInt &init_value);
+
+  /// Initializes a variable with a floating point value.
+  /// \param var The variable to initialize. Must not already have an
+  ///            initializer and must have a floating point type.
+  /// \param init_value The float value that the variable should be
+  ///                   initialized to.
+  static void
+  SetFloatingInitializerForVariable(clang::VarDecl *var,
+                                    const llvm::APFloat &init_value);
+
   clang::CXXMethodDecl *AddMethodToCXXRecordType(
       lldb::opaque_compiler_type_t type, llvm::StringRef name,
       const char *mangled_name, const CompilerType &method_type,
       lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline,
       bool is_explicit, bool is_attr_used, bool is_artificial);
 
   void AddMethodOverridesForCXXRecordType(lldb::opaque_compiler_type_t type);
 

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

var_decl->setAccess(
       TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
   record_decl->addDecl(var_decl);
 
   VerifyDecl(var_decl);
 
   return var_decl;
 }
 
+void TypeSystemClang::SetIntegerInitializerForVariable(
+    VarDecl *var, const llvm::APInt &init_value) {
+  assert(!var->hasInit() && "variable already initialized");
+
+  clang::ASTContext &ast = var->getASTContext();
+  QualType qt = var->getType();
+  assert(qt->isIntegralOrEnumerationType() &&
+         "only integer or enum types supported");
+  // If the variable is an enum type, take the underlying integer type as
+  // the type of the integer literal.
+  if (const EnumType *enum_type = llvm::dyn_cast<EnumType>(qt.getTypePtr())) {
+    const EnumDecl *enum_decl = enum_type->getDecl();
+    qt = enum_decl->getIntegerType();
+  }
+  var->setInit(IntegerLiteral::Create(ast, init_value, qt.getUnqualifiedType(),
+                                      SourceLocation()));
+}
+
+void TypeSystemClang::SetFloatingInitializerForVariable(
+    clang::VarDecl *var, const llvm::APFloat &init_value) {
+  assert(!var->hasInit() && "variable already initialized");
+
+  clang::ASTContext &ast = var->getASTContext();
+  QualType qt = var->getType();
+  assert(qt->isFloatingType() && "only floating point types supported");
+  var->setInit(FloatingLiteral::Create(
+      ast, init_value, true, qt.getUnqualifiedType(), SourceLocation()));
+}
+
 clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType(
     lldb::opaque_compiler_type_t type, llvm::StringRef name,
     const char *mangled_name, const CompilerType &method_clang_type,
     lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline,
     bool is_explicit, bool is_attr_used, bool is_artificial) {
   if (!type || !method_clang_type.IsValid() || name.empty())
     return nullptr;
 

lldb/test/Shell/SymbolFile/PDB/Inputs/AstRestoreTest.cpp

public:
 
   static int StaticFunc(const Class &c) {
     return c.PrivateFunc(c.m_inner) + Global + ClassStatic;
   }
 
   const Enum m_ce;
 
   static int ClassStatic;
+  static const int ClassStaticConst = 8;
+  static constexpr int ClassStaticConstexpr = 9;
+  static constexpr float ClassStaticConstexprFloat = 10.f;
+  static constexpr double ClassStaticConstexprDouble = 11.0;
+  static constexpr long double ClassStaticConstexprLongDouble = 12.0;
+  static const Enum ClassStaticConstEnum = Enum_3;
 
 private:
   struct Inner {
     char x;
     short y;
     int z;
   };
 

lldb/test/Shell/SymbolFile/PDB/ast-restore.test

 BASE: }
 
 CLASS: Module: {{.*}}
 CLASS: namespace N0 {
 CLASS:     namespace N1 {
 CLASS:         class Class : public N0::N1::Base {
 CLASS-DAG:             const N0::N1::(anonymous namespace)::Enum m_ce;
 CLASS-DAG:             static int ClassStatic;
+CLASS-DAG:             static const int ClassStaticConst = 8;
+CLASS-DAG:             static const int ClassStaticConstexpr = 9;
+CLASS-DAG:             static const float ClassStaticConstexprFloat = 10.F;
+CLASS-DAG:             static const double ClassStaticConstexprDouble = 11.;
+CLASS-DAG:             static const double ClassStaticConstexprLongDouble = 12.;
+CLASS-DAG:             static const N0::N1::(anonymous namespace)::Enum ClassStaticConstEnum = 8;
 CLASS-DAG:             N0::N1::Class::Inner m_inner;
 CLASS-DAG:             {{(inline )?}}Class(N0::N1::(anonymous namespace)::Enum);
 CLASS-DAG:             static {{(inline )?}}int StaticFunc(const N0::N1::Class &);
 CLASS-DAG:             {{(inline )?}}int PrivateFunc(const N0::N1::Class::Inner &);
 CLASS:         };
 CLASS:     }
 CLASS: }
 

llvm/include/llvm/DebugInfo/PDB/PDBTypes.h

 //===- PDBTypes.h - Defines enums for various fields contained in PDB ----====//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_PDBTYPES_H
 #define LLVM_DEBUGINFO_PDB_PDBTYPES_H
 
+#include "llvm/ADT/APFloat.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBFrameData.h"
 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
 #include <cctype>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
union {
     double Double;
     uint8_t UInt8;
     uint16_t UInt16;
     uint32_t UInt32;
     uint64_t UInt64;
     char *String;
   } Value;
 
+  bool isIntegralType() const {
+    switch (Type) {
+    case Bool:
+    case Int8:
+    case Int16:
+    case Int32:
+    case Int64:
+    case UInt8:
+    case UInt16:
+    case UInt32:
+    case UInt64:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+#define VARIANT_WIDTH(Enum, NumBits)                                           \
+  case PDB_VariantType::Enum:                                                  \
+    return NumBits;
+
+  unsigned getBitWidth() const {
+    switch (Type) {
+      VARIANT_WIDTH(Bool, 1u)
+      VARIANT_WIDTH(Int8, 8u)
+      VARIANT_WIDTH(Int16, 16u)
+      VARIANT_WIDTH(Int32, 32u)
+      VARIANT_WIDTH(Int64, 64u)
+      VARIANT_WIDTH(Single, 32u)
+      VARIANT_WIDTH(Double, 64u)
+      VARIANT_WIDTH(UInt8, 8u)
+      VARIANT_WIDTH(UInt16, 16u)
+      VARIANT_WIDTH(UInt32, 32u)
+      VARIANT_WIDTH(UInt64, 64u)
+    default:
+      assert(false && "Variant::toAPSInt called on non-numeric type");
+      return 0u;
+    }
+  }
+
+#undef VARIANT_WIDTH
+
+#define VARIANT_APSINT(Enum, NumBits, IsUnsigned)                              \
+  case PDB_VariantType::Enum:                                                  \
+    return APSInt(APInt(NumBits, Value.Enum), IsUnsigned);
+
+  APSInt toAPSInt() const {
+    switch (Type) {
+      VARIANT_APSINT(Bool, 1u, true)
+      VARIANT_APSINT(Int8, 8u, false)
+      VARIANT_APSINT(Int16, 16u, false)
+      VARIANT_APSINT(Int32, 32u, false)
+      VARIANT_APSINT(Int64, 64u, false)
+      VARIANT_APSINT(UInt8, 8u, true)
+      VARIANT_APSINT(UInt16, 16u, true)
+      VARIANT_APSINT(UInt32, 32u, true)
+      VARIANT_APSINT(UInt64, 64u, true)
+    default:
+      assert(false && "Variant::toAPSInt called on non-integral type");
+      return APSInt();
+    }
+  }
+
+#undef VARIANT_APSINT
+
+  APFloat toAPFloat() const {
+    // Float constants may be tagged as integers.
+    switch (Type) {
+    case PDB_VariantType::Single:
+    case PDB_VariantType::UInt32:
+    case PDB_VariantType::Int32:
+      return APFloat(Value.Single);
+    case PDB_VariantType::Double:
+    case PDB_VariantType::UInt64:
+    case PDB_VariantType::Int64:
+      return APFloat(Value.Double);
+    default:
+      assert(false && "Variant::toAPFloat called on non-floating-point type");
+      return APFloat::getZero(APFloat::IEEEsingle());
+    }
+  }
+
 #define VARIANT_EQUAL_CASE(Enum)                                               \
   case PDB_VariantType::Enum:                                                  \
     return Value.Enum == Other.Value.Enum;
 
   bool operator==(const Variant &Other) const {
     if (Type != Other.Type)
       return false;
     switch (Type) {