Initialize static const fields in the AST for expression evaluation

[jarin]

Summary

This patch is for discussion.

Currently, the evaluator does not know about static const fields if
the code does not contain a definition (but only a declaration).

For example:

struct C { static const int f = 42; };
int main() {
  return C::f;  // Evaluating C::f does not work here!
}

This patch tries to fix that by initializing the varDecl of the static
field with the constant value. This works reasonably well when the
static member is only used as rvalue, but any lvalue usage still does
not work because the static member does not have a memory location.

To fix this properly, do we have to teach the materializer about the
static fields, too? What would be the best way to go about that?

[teemperor]

There is actually https://reviews.llvm.org/D81471 that makes this fully work, but it's still waiting on someone to review it :)

[teemperor]

Btw, that patch that I referenced hasn't landed yet (it just lacks the tests and probably rebasing), but I'm OOO for an unknown duration so feel free to land it yourself.

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

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;
   bool is_external =
       false; // On DW_TAG_members, this means the member is static
   uint32_t i;
+  clang::Optional<uint64_t> integer_const_value;
   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
       // word from the base address of the structure.
       //
       // DW_AT_bit_offset indicates how many bits into the word
if (attributes.ExtractFormValueAtIndex(i, form_value)) {
         prop_setter_name = form_value.AsCString();
         break;
       case DW_AT_APPLE_property_attribute:
         prop_attributes = form_value.Unsigned();
         break;
       case DW_AT_external:
         is_external = form_value.Boolean();
         break;
+      case DW_AT_const_value:
+        if (DWARFFormValue::IsDataForm(form_value.Form())) {
+          integer_const_value = form_value.Unsigned();
+        }
+        break;
 
       default:
       case DW_AT_declaration:
       case DW_AT_description:
       case DW_AT_mutable:
       case DW_AT_visibility:
       case DW_AT_sibling:
         break;
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 layout_var_type = var_type->GetLayoutCompilerType();
+      clang::VarDecl *var_decl = TypeSystemClang::AddVariableToRecordType(
+          class_clang_type, name, layout_var_type, accessibility);
+      bool is_signed = false;
+      if (integer_const_value &&
+          layout_var_type.IsIntegerOrEnumerationType(is_signed)) {
+        clang::QualType var_qual_type = var_decl->getType();
+        unsigned var_bit_size =
+            m_ast.getASTContext().getIntWidth(var_qual_type);
+        llvm::APInt init_value(var_bit_size, *integer_const_value, is_signed);
+        TypeSystemClang::SetIntegerInitializerForVariable(var_decl, init_value);
+      }
     }
     return;
   }
 
   if (!is_artificial) {
     Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
 
     clang::FieldDecl *field_decl = nullptr;

lldb/test/API/lang/cpp/static_const_members/Makefile

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

lldb/test/API/lang/cpp/static_const_members/TestStaticConstMembers.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+
+class TestStaticConstMembers(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_static_const_var_definition(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+            lldb.SBFileSpec("main.cpp", False))
+        self.expect_expr("C::static_const_var_i32", result_value="42")
+        self.expect_expr("C::static_constexpr_i32_other", result_value="43")
+
+    @expectedFailureAll()
+    def test_static_const_member_lval(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+            lldb.SBFileSpec("main.cpp", False))
+        self.expect_expr("C::static_const_i32", result_value="40")
+        self.expect_expr("C::static_const_i32_neg", result_value="-40")
+        self.expect_expr("C::static_constexpr_i32", result_value="41")
+        self.expect_expr("C::static_const_ui32", result_value="4294967295")
+        self.expect_expr("C::static_const_enum", result_value="E42")
+        self.expect_expr("C::static_const_i8", result_value="-1")
+
+    def test_static_const_member_rval(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+            lldb.SBFileSpec("main.cpp", False))
+        self.expect_expr("C::static_const_i32 + 2", result_value="42")
+        self.expect_expr("-C::static_const_i32_neg", result_value="40")
+        self.expect_expr("C::static_constexpr_i32 | 0", result_value="41")
+        self.expect_expr("-C::static_const_ui32", result_value="1")
+        self.expect_expr("C::static_const_ui32 + 0u", result_value="4294967295")
+        self.expect_expr("-C::static_constexpr_ui32", result_value="2")
+        self.expect_expr("(int)C::static_const_enum", result_value="42")
+        self.expect_expr("C::static_const_i8 + 0", result_value="-1")
+
+    @expectedFailureAll()
+    def test_static_const_member_address(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break here",
+            lldb.SBFileSpec("main.cpp", False))
+        self.expect_expr("deref(&(C::static_const_var_i32))", result_value="42")
+        self.expect_expr("deref(&(C::static_const_i32))", result_value="40")

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

+enum class E {
+  E0 = 0,
+  E42 = 42,
+};
+
+struct C {
+  static const int static_const_i32 = 40;
+  static const int static_const_i32_neg = -40;
+  static constexpr int static_constexpr_i32 = 41;
+  static const unsigned static_const_ui32 = 0xffffffff;
+  static constexpr unsigned static_constexpr_ui32 = 0xfffffffe;
+  static const int static_const_var_i32;
+  static constexpr int static_constexpr_i32_other = 43;
+  static const E static_const_enum = E::E42;
+  static const char static_const_i8 = -1;
+};
+
+const int C::static_const_var_i32 = 42;
+constexpr int C::static_constexpr_i32_other;
+
+int deref(const int *p) { return *p; }
+
+int main() {
+  const int *pi = &C::static_constexpr_i32_other;
+  int rv = C::static_const_i32 + C::static_const_i32_neg +
+           C::static_constexpr_i32 + (int)C::static_const_ui32 +
+           C::static_const_var_i32 + deref(pi);
+  return rv; // break here
+}