[lldb] Add support for using integral const static data members in the expression evaluator

[werat]

Summary

This adds support for using const static integral data members as described by C++11 [class.static.data]p3
to LLDB's expression evaluator.

So far LLDB treated these data members are normal static variables. They already work as intended when they are declared in the class definition and then defined in a namespace scope. However, if they are declared and initialised in the class definition but never defined in a namespace scope, all LLDB expressions that use them will fail to link when LLDB can't find the respective symbol for the variable.

The reason for this is that the data members which are only declared in the class are not emitted into any object file so LLDB can never resolve them. Expressions that use these variables are expected to directly use their constant value if possible. Clang can do this for us during codegen, but it requires that we add the constant value to the VarDecl we generate for these data members.

This patch implements this by:

• parsing the constant values from the debug info and adding it to variable declarations we encounter.
• ensuring that LLDB doesn't implicitly try to take the address of expressions that might be an lvalue that points to such a special data member.

The second change is caused by LLDB's way of storing lvalues in the expression parser. When LLDB parses an expression, it tries to keep the result around via two mechanisms:

1. For lvalues, LLDB generates a static pointer variable and stores the address of the last expression in it: T *$__lldb_expr_result_ptr = &LastExpression
2. For everything else, LLDB generates a static variable of the same type as the last expression and then direct initialises that variable: T $__lldb_expr_result(LastExpression)

If we try to print a special const static data member via something like expr Class::Member, then LLDB will try to take the address of this expression as it's an lvalue. This means LLDB will try to take the address of the variable which causes that Clang can't replace the use with the constant value. There isn't any good way to detect this case (as there a lot of different expressions that could yield an lvalue that points to such a data member), so this patch also changes that we only use the first way of capturing the result if the last expression does not have a type that could potentially indicate it's coming from such a special data member.

This change shouldn't break most workflows for users. The only observable side effect I could find is that the implicit persistent result variables for const int's now have their own memory address:

Before this change:

(lldb) p i
(const int) $0 = 123
(lldb) p &$0
(const int *) $1 = 0x00007ffeefbff8e8
(lldb) p &i
(const int *) $2 = 0x00007ffeefbff8e8

After this change we capture i by value so it has its own value.

(lldb) p i
(const int) $0 = 123
(lldb) p &$0
(const int *) $1 = 0x0000000100155320
(lldb) p &i
(const int *) $2 = 0x00007ffeefbff8e8

[shafik]

I will take a second look later on.

lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

203

Should we assert that this is an lvalue?

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

7286 ↗

(On Diff #269547)

So the name says AddInitToVarDecl but we are asserting only integral or enum type ... seems like the name should be more specific.

[shafik]

lldb/source/Utility/DataExtractor.cpp

882 ↗

(On Diff #269547)

Nice refactoring!

[teemperor]

In D81471#2085395, @shafik wrote:

I will take a second look later on.

Just saying that this is a WIP revision (see the title) just for the sake of linking my status report here, so this isn't actually up for review yet (and that's why that DataExtractor refactoring is in here, it's just to make my CI happy when testing this patch). You're added as reviewer because of your automatic Herald rule.

[jarin]

This looks great! Thank you for the extensive test suite.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2344

Out of curiosity, why can't you just use the APInt as 'result' here?

[teemperor]

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2344

You mean why use APSInt instead of APInt here? That's just because of the required_bits check below (getMinSignedBits is only in APSInt). It's not a complex function, but I rather make it an APSInt than document the MinSignedBits algorithm here.

And the required_bits check is only there because the DWARFFormValue's uint64_t value wasn't checked so far with the specific type in mind (like, having 0xabc for an unsigned char would otherwise just be silently truncated).

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

20

Note to myself: This change and the one below were actually supposed to be its own NFC commit...

[jarin]

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2344

getMinSignedBits seems to be in APInt (see https://github.com/llvm/llvm-project/blob/d110d4aaff31198cd455b68617978019a8339773/llvm/include/llvm/ADT/APInt.h#L1613).

[teemperor]

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2344

Ah that's a good catch, thanks! I assumed that was defined in APSInt. Let me make that just APInt then.

[aprantl]

Very nice!

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2331

In this particular case = 64 might be more readable.

[teemperor]

• Revert unintended NFC cleanup in DWARFASTParserTest
• APSInt -> APInt (Thanks Jaroslav!)

[teemperor]

• Simplify max size to just '64' instead of sizeof(uint64_t) * 8 (thanks Adrian!)
• Update comment to mention APInt instead of APSInt

[shafik]

I am curious about constexpr static as well here.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2331

constexpr

2348

there is no APSInt anymore? right?

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

172

Why not use int32_t although this should never affect us int can be 64 bit, so int32_t is a better reflection of your intent.

172

You can also use constexpr here since numeric_limits methods are all constexpr as well.

219

std::numeric_limits<uint64_t>::max(); or am I missing the intent here?

[jarin]

In D81471#2214720, @shafik wrote:

I am curious about constexpr static as well here.

+1

It would be great to write tests for the static constexpr fields, too.

[jankratochvil]

It does crash with testcase from D92643:

echo 'struct Vars { inline static double inline_static = 1.5; } v; int main() {}'|./bin/clang -Wall -g -x c++ -;./bin/lldb -b ./a.out -o 'p Vars::inline_static'
lldb: lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp:2346: llvm::Expected<llvm::APInt> DWARFASTParserClang::ExtractIntFromFormValue(const lldb_private::CompilerType &, const DWARFFormValue &) const: Assertion `qt->isIntegralOrEnumerationType()' failed.
 #9 0x00007fd1b28454d1 DWARFASTParserClang::ExtractIntFromFormValue(lldb_private::CompilerType const&, DWARFFormValue const&) const lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp:2347:54

The patch also needs a trivial rebase.

[dblaikie]

@labath @jgorbe - looks like this might be useful to pick up/push forward.

[werat]

Taking over the patch (as discussed with @teemperor)

[werat]

• Rebase on latest HEAD
• Address review comments
• Add a check for field being integer/enum

[werat]

Reviving the patch and taking over.

@jankratochvil @shafik @labath can you please take another look? Thanks!

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

172

The tests verify whether the value fits into the type, so the value itself needs to be large to fit things that can't be represented in int32

For example, this will pass if int_min is int32_t:

EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min - 2), llvm::Failed());

[labath]

My only complaint is about the restriction in CanTakeAddressOfLValue. It seems arbitrary. There's anything in C++ or DWARF that would prevent us from having constant-valued variables of class types. It's just that clang/llvm does not know how to emit the DW_AT_const_value for such variables (yet). Gcc does not seem to have that problem (it happily emits a block form for those). So, it feels to me this is just kicking the can down the road, and we will sooner or later need to come up with a better story for this.

I guess the condition we really want to express here is "does this expression refer to a constexpr variable (ideally one without a location)"? And the problem is that clang does not give us the means to detect that?

Is that really the case? Would it maybe be possible to use some c++ magic to get clang to do that for us. Write something like if constexpr (__builtin_constant_p(user_expression)) do_something_rvalue_like(); else assume_regular_lvalue(); ?

[Michael137]

lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

248

Minor: Should we update this documentation?

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2575

Should this be:

if (!attrs.const_value_form || !ct.IsIntegerOrEnumerationType(unused))

?

2582

Can v be nullptr here?

[werat]

In D81471#3632297, @labath wrote:

I guess the condition we really want to express here is "does this expression refer to a constexpr variable (ideally one without a location)"? And the problem is that clang does not give us the means to detect that?

Is that really the case? Would it maybe be possible to use some c++ magic to get clang to do that for us. Write something like if constexpr (__builtin_constant_p(user_expression)) do_something_rvalue_like(); else assume_regular_lvalue(); ?

I think you're right here, but I don't know a better way to express this. My clangfu is not good enough for this yet :)

As I understand it, we can't express it purely in the expression (via __builtin_constant_p or something), because we need to know the answer before executing the expression (it changes the way we do materialization/dematerialization).

Could this be something to improve in the future?

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2575

Whoops, yes, thanks!

2582

Honestly, not sure. Theoretically AddVariableToRecordType can return nullptr, but I've never seen such case. Maybe it only happens when the debug info is malformed? Would that be caught earlier at some stage?
I can add a safe guard here with a log message.

[werat]

Address review comments

[werat]

This comment was removed by werat.

[werat]

Fix condition

[Michael137]

with latest changes LGTM

[labath]

In D81471#3637057, @werat wrote:

In D81471#3632297, @labath wrote:

I guess the condition we really want to express here is "does this expression refer to a constexpr variable (ideally one without a location)"? And the problem is that clang does not give us the means to detect that?

Is that really the case? Would it maybe be possible to use some c++ magic to get clang to do that for us. Write something like if constexpr (__builtin_constant_p(user_expression)) do_something_rvalue_like(); else assume_regular_lvalue(); ?

I think you're right here, but I don't know a better way to express this. My clangfu is not good enough for this yet :)

As I understand it, we can't express it purely in the expression (via __builtin_constant_p or something), because we need to know the answer before executing the expression (it changes the way we do materialization/dematerialization).

Well, yes, either that, or change how the dematerialization works -- prepare for both options and then choose the one that was actually used.

Could this be something to improve in the future?

Well.. maybe... I don't know. I think this is definitely useful, and I don't see much of a downside. The main difference I see is that you won't be able to "modify a constant" via expressions like p const_int, p (int&)$0 = 47, but: a) you will still be able to do that within a single expression; and b) such an operation is unlikely to produce predictable results in anything but pure C (which doesn't really have constants).

So, if noone objects to this, then I think it's fine.

[werat]

In D81471#3641915, @labath wrote:

So, if noone objects to this, then I think it's fine.

I guess nobody objects :)

@labath, @Michael137, can you accept/LGTM the revision?

[stella.stamenova]

Looks like this broke the Windows lldb bot as well: https://lab.llvm.org/buildbot/#/builders/83/builds/21186

[werat]

Relanded in https://github.com/llvm/llvm-project/commit/7d297de95117e783bbfaecbba1f72fc55de05a30

[Michael137]

This seems to cause issues when var->getType() == const llvm::APFloatBase::roundingMode.

The following assertion triggered:

Assertion failed: (type->isIntegerType() && "Illegal type in IntegerLiteral"), function IntegerLiteral, file Expr.cpp, line 892

Reproduces with:

1. lldb -- ./bin/lldb a.out
2. b LookupLocalVariable
3. step a couple of times until decl_context is declared
4. p decl_context

It looks ike the dyn_cast to EnumType fails and thus qt.getUnqualifiedType() which we pass into IntegerLiteral::Create remains an EnumType, which breaks the invariant

Investigating further...

[Michael137]

In D81471#3666071, @Michael137 wrote:

This seems to cause issues when var->getType() == const llvm::APFloatBase::roundingMode.

The following assertion triggered:

Assertion failed: (type->isIntegerType() && "Illegal type in IntegerLiteral"), function IntegerLiteral, file Expr.cpp, line 892

Reproduces with:

1. lldb -- ./bin/lldb a.out
2. b LookupLocalVariable
3. step a couple of times until decl_context is declared
4. p decl_context

It looks ike the dyn_cast to EnumType fails and thus qt.getUnqualifiedType() which we pass into IntegerLiteral::Create remains an EnumType, which breaks the invariant

Investigating further...

Tried to address this in https://reviews.llvm.org/D130213

lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

if (log && log->GetVerbose()) {
     os.flush();
 
     LLDB_LOGF(log, "Transformed method AST:\n%s", s.c_str());
   }
 
   return ret;
 }
 
+/// Returns true if LLDB can take the address of the given lvalue for the sake
+/// of capturing the expression result. Returns false if LLDB should instead
+/// store the expression result in a result variable.
+static bool CanTakeAddressOfLValue(const Expr *lvalue_expr) {
+  assert(lvalue_expr->getValueKind() == VK_LValue &&
+         "lvalue_expr not a lvalue");
+
+  QualType qt = lvalue_expr->getType();
+  // If the lvalue has const-qualified non-volatile integral or enum type, then
+  // the underlying value might come from a const static data member as
+  // described in C++11 [class.static.data]p3. If that's the case, then the
+  // value might not have an address if the user didn't also define the member
+  // in a namespace scope. Taking the address would cause that LLDB later fails
+  // to link the expression, so those lvalues should be stored in a result
+  // variable.
+  if (qt->isIntegralOrEnumerationType() && qt.isConstQualified() &&
+      !qt.isVolatileQualified())
+    return false;
+  return true;
+}
+
 bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
                                                 DeclContext *DC) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   ASTContext &Ctx(*m_ast_context);
 
   if (!Body)
     return false;
do {
 
     last_expr = implicit_cast->getSubExpr();
   } while (false);
 
   // is_lvalue is used to record whether the expression returns an assignable
   // Lvalue or an Rvalue.  This is relevant because they are handled
   // differently.
   //
   // For Lvalues
   //
   //   - In AST result synthesis (here!) the expression E is transformed into an
   //     initialization T *$__lldb_expr_result_ptr = &E.
   //
   //   - In structure allocation, a pointer-sized slot is allocated in the
   //     struct that is to be passed into the expression.
   //
   //   - In IR transformations, reads and writes to $__lldb_expr_result_ptr are
if (log) {
     std::string s = expr_qual_type.getAsString();
 
     LLDB_LOGF(log, "Last statement is an %s with type: %s",
               (is_lvalue ? "lvalue" : "rvalue"), s.c_str());
   }
 
   clang::VarDecl *result_decl = nullptr;
 
-  if (is_lvalue) {
+  if (is_lvalue && CanTakeAddressOfLValue(last_expr)) {
     IdentifierInfo *result_ptr_id;
 
     if (expr_type->isFunctionType())
       result_ptr_id =
           &Ctx.Idents.get("$__lldb_expr_result"); // functions actually should
                                                   // be treated like function
                                                   // pointers
     else

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

public:
   lldb_private::CompilerDeclContext
   GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) override;
 
   lldb_private::ClangASTImporter &GetClangASTImporter();
 
+  /// Extracts an value for a given Clang integer type from a DWARFFormValue.
+  ///
+  /// \param int_type The Clang type that defines the bit size and signedness
+  ///                 of the integer that should be extracted. Has to be either
+  ///                 an integer type or an enum type. For enum types the
+  ///                 underlying integer type will be considered as the
+  ///                 expected integer type that should be extracted.
+  /// \param form_value The DWARFFormValue that contains the integer value.
+  /// \return An APInt containing the same integer value as the given
+  ///         DWARFFormValue with the bit width of the given integer type.
+  ///         Returns an error if the value in the DWARFFormValue does not fit
+  ///         into the given integer type or the integer type isn't supported.
+  llvm::Expected<llvm::APInt>
+  ExtractIntFromFormValue(const lldb_private::CompilerType &int_type,
+                          const DWARFFormValue &form_value) const;
+
 protected:
   /// Protected typedefs and members.
   /// @{
   class DelayedAddObjCClassProperty;
   typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
 
   typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (func_range.GetBaseAddress().IsValid()) {
           return func_sp.get();
         }
       }
     }
   }
   return nullptr;
 }
 
+llvm::Expected<llvm::APInt> DWARFASTParserClang::ExtractIntFromFormValue(
+    const CompilerType &int_type, const DWARFFormValue &form_value) const {
+  clang::QualType qt = ClangUtil::GetQualType(int_type);
+  assert(qt->isIntegralOrEnumerationType());
+  TypeSystemClang &ts = *llvm::cast<TypeSystemClang>(int_type.GetTypeSystem());
+  clang::ASTContext &ast = ts.getASTContext();
+
+  const unsigned type_bits = ast.getIntWidth(qt);
+  const bool is_unsigned = qt->isUnsignedIntegerType();
+
+  // The maximum int size supported at the moment by this function. Limited
+  // by the uint64_t return type of DWARFFormValue::Signed/Unsigned.
+  const std::size_t max_bit_size = sizeof(uint64_t) * 8;
+
+  // For values bigger than 64 bit (e.g. __int128_t values),
+  // DWARFFormValue's Signed/Unsigned functions will return wrong results so
+  // emit an error for now.
+  if (type_bits > max_bit_size) {
+    auto msg = llvm::formatv("Can only parse integers with up to {0} bits, but "
+                             "given integer has {1} bits.",
+                             max_bit_size, type_bits);
+    return llvm::createStringError(llvm::inconvertibleErrorCode(), msg.str());
+  }
+
+  // Construct an APSInt with the maximum bit size and the given integer.
+  llvm::APInt result(max_bit_size, form_value.Unsigned(), !is_unsigned);
+
+  // Calculate how many bits are required to represent the input value.
+  // For unsigned types, take the number of active bits in the APInt.
+  // For signed types, ask APSInt how many bits are required to represent the
+  // signed integer.
+  const unsigned required_bits =
+      is_unsigned ? result.getActiveBits() : result.getMinSignedBits();
+
+  // If the input value doesn't fit into the integer type, return an error.
+  if (required_bits > type_bits) {
+    std::string value_as_str = is_unsigned
+                                   ? std::to_string(form_value.Unsigned())
+                                   : std::to_string(form_value.Signed());
+    auto msg = llvm::formatv("Can't store {0} value {1} in integer with {2} "
+                             "bits.",
+                             (is_unsigned ? "unsigned" : "signed"),
+                             value_as_str, type_bits);
+    return llvm::createStringError(llvm::inconvertibleErrorCode(), msg.str());
+  }
+
+  // Trim the result to the bit width our the int type.
+  if (result.getBitWidth() > type_bits)
+    result = result.trunc(type_bits);
+  return result;
+}
+
 void DWARFASTParserClang::ParseSingleMember(
     const DWARFDIE &die, const DWARFDIE &parent_die,
     const lldb_private::CompilerType &class_clang_type,
     std::vector<int> &member_accessibilities,
     lldb::AccessType default_accessibility,
     DelayedPropertyList &delayed_properties,
     lldb_private::ClangASTImporter::LayoutInfo &layout_info,
     FieldInfo &last_field_info) {
+  Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_TYPE_COMPLETION |
+                                          DWARF_LOG_LOOKUPS);
+
   ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
   const dw_tag_t tag = die.Tag();
   // Get the parent byte size so we can verify any members will fit
   const uint64_t parent_byte_size =
       parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX);
   const uint64_t parent_bit_size =
       parent_byte_size == UINT64_MAX ? UINT64_MAX : parent_byte_size * 8;
 
void DWARFASTParserClang::ParseSingleMember(
   DWARFFormValue encoding_form;
   AccessType accessibility = eAccessNone;
   uint32_t member_byte_offset =
       (parent_die.Tag() == DW_TAG_union_type) ? 0 : UINT32_MAX;
   llvm::Optional<uint64_t> byte_size;
   int64_t bit_offset = 0;
   uint64_t data_bit_offset = UINT64_MAX;
   size_t bit_size = 0;
+  llvm::Optional<DWARFFormValue> const_value_form;
   bool is_external =
       false; // On DW_TAG_members, this means the member is static
   uint32_t i;
   for (i = 0; i < num_attributes && !is_artificial; ++i) {
     const dw_attr_t attr = attributes.AttributeAtIndex(i);
     DWARFFormValue form_value;
     if (attributes.ExtractFormValueAtIndex(i, form_value)) {
       // DW_AT_data_member_location indicates the byte offset of the
if (attributes.ExtractFormValueAtIndex(i, form_value)) {
         bit_offset = form_value.Signed();
         break;
       case DW_AT_bit_size:
         bit_size = form_value.Unsigned();
         break;
       case DW_AT_byte_size:
         byte_size = form_value.Unsigned();
         break;
+      case DW_AT_const_value:
+        const_value_form = form_value;
+        break;
       case DW_AT_data_bit_offset:
         data_bit_offset = form_value.Unsigned();
         break;
       case DW_AT_data_member_location:
         if (form_value.BlockData()) {
           Value initialValue(0);
           Value memberOffset(0);
           const DWARFDataExtractor &debug_info_data = die.GetData();
void DWARFASTParserClang::ParseSingleMember(
 
   // Handle static members
   if (is_external && member_byte_offset == UINT32_MAX) {
     Type *var_type = die.ResolveTypeUID(encoding_form.Reference());
 
     if (var_type) {
       if (accessibility == eAccessNone)
         accessibility = eAccessPublic;
-      TypeSystemClang::AddVariableToRecordType(
-          class_clang_type, name, var_type->GetLayoutCompilerType(),
-          accessibility);
+      CompilerType ct = var_type->GetLayoutCompilerType();
+      clang::VarDecl *v = TypeSystemClang::AddVariableToRecordType(
+          class_clang_type, name, ct, accessibility);
+
+      if (!const_value_form)
+        return;
+      llvm::Expected<llvm::APInt> const_value_or_err =
+          ExtractIntFromFormValue(ct, *const_value_form);
+      if (!const_value_or_err) {
+        LLDB_LOG_ERROR(log, const_value_or_err.takeError(),
+                       "Failed to add const value to variable {1}: {0}",
+                       v->getQualifiedNameAsString());
+        return;
+      }
+      TypeSystemClang::SetIntegerInitializerForVariable(v, *const_value_or_err);
     }
     return;
   }
 
   if (!is_artificial) {
     Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
 
     clang::FieldDecl *field_decl = nullptr;

lldb/test/API/lang/cpp/const_static_integral_member/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/const_static_integral_member/TestConstStaticIntegralMember.py

+"""
+Tests const static data members as specified by C++11 [class.static.data]p3.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+                                          lldb.SBFileSpec("main.cpp"))
+
+        # Test using a simple const static integer member.
+        self.expect_expr("A::int_val", result_value="1")
+
+        # Try accessing the int member via some expressions that still produce
+        # an lvalue.
+        self.expect_expr("a.int_val", result_value="1")
+        self.expect_expr("(A::int_val)", result_value="1")
+        self.expect_expr("+A::int_val", result_value="1")
+        self.expect_expr("1,A::int_val", result_value="1")
+        self.expect_expr("true ? A::int_val : A::int_val", result_value="1")
+
+        # Test a simple integer member that was also defined in a namespace
+        # scope and has an address.
+        self.expect_expr("A::int_val_with_address", result_value="2")
+
+        # Try to take the address of the data member. Should produce a linker
+        # error only if the member doesn't have an address.
+        self.expect("expr const int *i = &A::int_val; *i", error=True,
+                    substrs=["Couldn't lookup symbols:"])
+        self.expect_expr("const int *i = &A::int_val_with_address; *i",
+                         result_value="2")
+
+        # Test a bool member.
+        self.expect_expr("A::bool_val", result_value="true")
+
+        # Test that minimum and maximum values for each data type are right.
+        self.expect_expr("A::char_max == char_max", result_value="true")
+        self.expect_expr("A::uchar_max == uchar_max", result_value="true")
+        self.expect_expr("A::int_max == int_max", result_value="true")
+        self.expect_expr("A::uint_max == uint_max", result_value="true")
+        self.expect_expr("A::long_max == long_max", result_value="true")
+        self.expect_expr("A::ulong_max == ulong_max", result_value="true")
+        self.expect_expr("A::longlong_max == longlong_max", result_value="true")
+        self.expect_expr("A::ulonglong_max == ulonglong_max", result_value="true")
+
+        self.expect_expr("A::char_min == char_min", result_value="true")
+        self.expect_expr("A::uchar_min == uchar_min", result_value="true")
+        self.expect_expr("A::int_min == int_min", result_value="true")
+        self.expect_expr("A::uint_min == uint_min", result_value="true")
+        self.expect_expr("A::long_min == long_min", result_value="true")
+        self.expect_expr("A::ulong_min == ulong_min", result_value="true")
+        self.expect_expr("A::longlong_min == longlong_min", result_value="true")
+        self.expect_expr("A::ulonglong_min == ulonglong_min", result_value="true")
+
+        # Test an unscoped enum.
+        self.expect_expr("A::enum_val", result_value="enum_case2")
+        # Test an unscoped enum with an invalid enum case.
+        self.expect_expr("A::invalid_enum_val", result_value="enum_case1 | enum_case2 | 0x4")
+
+        # Test a scoped enum.
+        self.expect_expr("A::scoped_enum_val", result_value="scoped_enum_case2")
+        # Test an scoped enum with an invalid enum case.
+        self.expect_expr("A::invalid_scoped_enum_val", result_value="scoped_enum_case1 | 0x4")
+
+        # Test an enum with fixed underlying type.
+        self.expect_expr("A::scoped_char_enum_val", result_value="case2")
+        self.expect_expr("A::scoped_ll_enum_val_neg", result_value="case0")
+        self.expect_expr("A::scoped_ll_enum_val", result_value="case2")
+
+        # Try to take the address of a member that doesn't have one.
+        self.expect("expr const int *i = &A::int_val; *i", error=True,
+                    substrs=["Couldn't lookup symbols:"])
+
+    # dsymutil strips the debug info for classes that only have const static
+    # data members without a definition namespace scope.
+    @expectedFailureAll(debug_info=["dsym"])
+    def test_class_with_only_const_static(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.cpp"))
+
+        self.expect_expr("ClassWithOnlyConstStatic::member", result_value="3")

lldb/test/API/lang/cpp/const_static_integral_member/main.cpp

+#include <limits>
+
+enum Enum {
+  enum_case1 = 1,
+  enum_case2 = 2,
+};
+
+enum class ScopedEnum {
+  scoped_enum_case1 = 1,
+  scoped_enum_case2 = 2,
+};
+
+enum class ScopedCharEnum : char {
+  case1 = 1,
+  case2 = 2,
+};
+
+enum class ScopedLongLongEnum : long long {
+  case0 = std::numeric_limits<long long>::min(),
+  case1 = 1,
+  case2 = std::numeric_limits<long long>::max(),
+};
+
+struct A {
+  const static int int_val = 1;
+  const static int int_val_with_address = 2;
+  const static bool bool_val = true;
+
+  const static auto char_max = std::numeric_limits<signed char>::max();
+  const static auto uchar_max = std::numeric_limits<unsigned char>::max();
+  const static auto int_max = std::numeric_limits<int>::max();
+  const static auto uint_max = std::numeric_limits<unsigned>::max();
+  const static auto long_max = std::numeric_limits<long>::max();
+  const static auto ulong_max = std::numeric_limits<unsigned long>::max();
+  const static auto longlong_max = std::numeric_limits<long long>::max();
+  const static auto ulonglong_max =
+      std::numeric_limits<unsigned long long>::max();
+
+  const static auto char_min = std::numeric_limits<char>::min();
+  const static auto uchar_min = std::numeric_limits<unsigned char>::min();
+  const static auto int_min = std::numeric_limits<int>::min();
+  const static auto uint_min = std::numeric_limits<unsigned>::min();
+  const static auto long_min = std::numeric_limits<long>::min();
+  const static auto ulong_min = std::numeric_limits<unsigned long>::min();
+  const static auto longlong_min = std::numeric_limits<long long>::min();
+  const static auto ulonglong_min =
+      std::numeric_limits<unsigned long long>::min();
+
+  const static Enum enum_val = enum_case2;
+  const static Enum invalid_enum_val = static_cast<Enum>(enum_case2 + 5);
+  const static ScopedEnum scoped_enum_val = ScopedEnum::scoped_enum_case2;
+  const static ScopedEnum invalid_scoped_enum_val = static_cast<ScopedEnum>(5);
+  const static ScopedCharEnum scoped_char_enum_val = ScopedCharEnum::case2;
+  const static ScopedLongLongEnum scoped_ll_enum_val_neg =
+      ScopedLongLongEnum::case0;
+  const static ScopedLongLongEnum scoped_ll_enum_val =
+      ScopedLongLongEnum::case2;
+};
+
+const int A::int_val_with_address;
+
+struct ClassWithOnlyConstStatic {
+  const static int member = 3;
+};
+
+int main() {
+  A a;
+
+  auto char_max = A::char_max;
+  auto uchar_max = A::uchar_max;
+  auto int_max = A::int_max;
+  auto uint_max = A::uint_max;
+  auto long_max = A::long_max;
+  auto ulong_max = A::ulong_max;
+  auto longlong_max = A::longlong_max;
+  auto ulonglong_max = A::ulonglong_max;
+
+  auto char_min = A::char_min;
+  auto uchar_min = A::uchar_min;
+  auto int_min = A::int_min;
+  auto uint_min = A::uint_min;
+  auto long_min = A::long_min;
+  auto ulong_min = A::ulong_min;
+  auto longlong_min = A::longlong_min;
+  auto ulonglong_min = A::ulonglong_min;
+
+  int member_copy = ClassWithOnlyConstStatic::member;
+
+  Enum e = A::enum_val;
+  e = A::invalid_enum_val;
+  ScopedEnum se = A::scoped_enum_val;
+  se = A::invalid_scoped_enum_val;
+  ScopedCharEnum sce = A::scoped_char_enum_val;
+  ScopedLongLongEnum sle = A::scoped_ll_enum_val;
+  return 0; // break here
+}

lldb/test/API/lang/cpp/const_static_integral_member_int128/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/const_static_integral_member_int128/TestConstStaticIntegralMemberInt128.py

+"""
+Tests const static data members as specified by C++11 [class.static.data]p3
+with (u)int128_t types.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_int128(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+                                          lldb.SBFileSpec("main.cpp"))
+
+        # Try to use the (u)int128_t data members which are not supported at
+        # the moment. Just verify that LLDB doesn't report an incorrect value
+        # for them and just treats them as normal variables (which will lead
+        # to linker errors as they are not defined anywhere).
+        self.expect("expr A::int128_max", error=True,
+                    substrs=["Couldn't lookup symbols:"])
+        self.expect("expr A::uint128_max", error=True,
+                    substrs=["Couldn't lookup symbols:"])
+        self.expect("expr A::int128_min", error=True,
+                    substrs=["Couldn't lookup symbols:"])
+        self.expect("expr A::uint128_min", error=True,
+                    substrs=["Couldn't lookup symbols:"])

lldb/test/API/lang/cpp/const_static_integral_member_int128/main.cpp

+#include <limits>
+
+struct A {
+  const static auto uint128_max = std::numeric_limits<__uint128_t>::max();
+  const static auto uint128_min = std::numeric_limits<__uint128_t>::min();
+  const static auto int128_max = std::numeric_limits<__int128_t>::max();
+  const static auto int128_min = std::numeric_limits<__int128_t>::min();
+};
+
+int main() {
+  A a;
+
+  auto int128_max = A::int128_max;
+  auto uint128_max = A::uint128_max;
+  auto int128_min = A::int128_min;
+  auto uint128_min = A::uint128_min;
+  return 0; // break here
+}

lldb/unittests/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_unittest(SymbolFileDWARFTests
   DWARFASTParserClangTests.cpp
   SymbolFileDWARFTests.cpp
   XcodeSDKModuleTests.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbPluginObjectFilePECOFF
     lldbPluginSymbolFileDWARF
     lldbPluginSymbolFilePDB
     lldbPluginTypeSystemClang
     lldbUtilityHelpers
     lldbPluginPlatformMacOSX
+    LLVMTestingSupport
   LINK_COMPONENTS
     Support
     DebugInfoPDB
   )
 
 set(test_inputs
    test-dwarf.exe)
 
 add_unittest_inputs(SymbolFileDWARFTests "${test_inputs}")

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 #include "TestingSupport/Symbol/YAMLModuleTester.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 class DWARFASTParserClangTests : public testing::Test {};
 
 class DWARFASTParserClangStub : public DWARFASTParserClang {
 public:
   using DWARFASTParserClang::DWARFASTParserClang;
   using DWARFASTParserClang::LinkDeclContextToDIE;
 
   std::vector<const clang::DeclContext *> GetDeclContextToDIEMapKeys() {
     std::vector<const clang::DeclContext *> keys;
for (int i = 0; i < 4; ++i)
     ast_parser.LinkDeclContextToDIE(decl_ctxs[i], dies[i]);
   ast_parser.EnsureAllDIEsInDeclContextHaveBeenParsed(
       CompilerDeclContext(nullptr, decl_ctxs[1]));
 
   EXPECT_THAT(ast_parser.GetDeclContextToDIEMapKeys(),
               testing::UnorderedElementsAre(decl_ctxs[0], decl_ctxs[3]));
 }
 
+struct ExtractIntFromFormValueTest : public testing::Test {
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
+  TypeSystemClang ts;
+  DWARFASTParserClang parser;
+  ExtractIntFromFormValueTest()
+      : ts("dummy ASTContext", HostInfoBase::GetTargetTriple()), parser(ts) {}
+
+  /// Takes the given integer value, stores it in a DWARFFormValue and then
+  /// tries to extract the value back via
+  /// DWARFASTParserClang::ExtractIntFromFormValue.
+  /// Returns the string representation of the extracted value or the error
+  /// that was returned from ExtractIntFromFormValue.
+  llvm::Expected<std::string> Extract(clang::QualType qt, uint64_t value) {
+    DWARFFormValue form_value;
+    form_value.SetUnsigned(value);
+    llvm::Expected<llvm::APInt> result =
+        parser.ExtractIntFromFormValue(ts.GetType(qt), form_value);
+    if (!result)
+      return result.takeError();
+    llvm::SmallString<16> result_str;
+    result->toStringUnsigned(result_str);
+    return std::string(result_str.str());
+  }
+
+  /// Same as ExtractIntFromFormValueTest::Extract but takes a signed integer
+  /// and treats the result as a signed integer.
+  llvm::Expected<std::string> ExtractS(clang::QualType qt, int64_t value) {
+    DWARFFormValue form_value;
+    form_value.SetSigned(value);
+    llvm::Expected<llvm::APInt> result =
+        parser.ExtractIntFromFormValue(ts.GetType(qt), form_value);
+    if (!result)
+      return result.takeError();
+    llvm::SmallString<16> result_str;
+    result->toStringSigned(result_str);
+    return std::string(result_str.str());
+  }
+};
+
+TEST_F(ExtractIntFromFormValueTest, TestBool) {
+  using namespace llvm;
+  clang::ASTContext &ast = ts.getASTContext();
+
+  EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 0), HasValue("0"));
+  EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 1), HasValue("1"));
+  EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 2), Failed());
+  EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 3), Failed());
+}
+
+TEST_F(ExtractIntFromFormValueTest, TestInt) {
+  using namespace llvm;
+
+  clang::ASTContext &ast = ts.getASTContext();
+
+  // Find the min/max values for 'int' on the current host target.
+  const int64_t int_max = std::numeric_limits<int>::max();
+  const int64_t int_min = std::numeric_limits<int>::min();
+
+  // Check that the bit width of int matches the int width in our type system.
+  ASSERT_EQ(sizeof(int) * 8, ast.getIntWidth(ast.IntTy));
+
+  // Check values around int_min.
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min - 2), llvm::Failed());
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min - 1), llvm::Failed());
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min),
+                       HasValue(std::to_string(int_min)));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min + 1),
+                       HasValue(std::to_string(int_min + 1)));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min + 2),
+                       HasValue(std::to_string(int_min + 2)));
+
+  // Check values around 0.
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, -128), HasValue("-128"));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, -10), HasValue("-10"));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, -1), HasValue("-1"));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 0), HasValue("0"));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 1), HasValue("1"));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 10), HasValue("10"));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 128), HasValue("128"));
+
+  // Check values around int_max.
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max - 2),
+                       HasValue(std::to_string(int_max - 2)));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max - 1),
+                       HasValue(std::to_string(int_max - 1)));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max),
+                       HasValue(std::to_string(int_max)));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max + 1), llvm::Failed());
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max + 5), llvm::Failed());
+
+  // Check some values not near an edge case.
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max / 2),
+                       HasValue(std::to_string(int_max / 2)));
+  EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min / 2),
+                       HasValue(std::to_string(int_min / 2)));
+}
+
+TEST_F(ExtractIntFromFormValueTest, TestUnsignedInt) {
+  using namespace llvm;
+
+  clang::ASTContext &ast = ts.getASTContext();
+  const uint64_t uint_max =
+      (static_cast<uint64_t>(1) << ast.getIntWidth(ast.UnsignedIntTy)) - 1U;
+
+  // Check values around 0.
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, 0), HasValue("0"));
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, 1), HasValue("1"));
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, 1234), HasValue("1234"));
+
+  // Check some values not near an edge case.
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max / 2),
+                       HasValue(std::to_string(uint_max / 2)));
+
+  // Check values around uint_max.
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max - 2),
+                       HasValue(std::to_string(uint_max - 2)));
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max - 1),
+                       HasValue(std::to_string(uint_max - 1)));
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max),
+                       HasValue(std::to_string(uint_max)));
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max + 1),
+                       llvm::Failed());
+  EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max + 2),
+                       llvm::Failed());
+}