[LLDB] Fix printing a static bool struct member when using "image lookup -t"

[DavidSpickett]

Summary

Fixes #58135

Somehow lldb was able to print the member on its own but when we try
to print the whole type found by "image lookup -t" lldb would crash.

This is because we'd encoded the initial value of the member as an integer.
Which isn't the end of the world because bool is integral for C++.
However, clang has a special AST node to handle literal bool and it
expected us to use that instead.

This adds a new codepath to handle static bool which uses cxxBoolLiteralExpr
and we get the member printed as you'd expect.

For testing I added a struct with just the bool because trying to print
all of "A" crashes as well. Presumably because one of the other member's
types isn't handled properly either.

So for now I just added the bool case, we can merge it with A later.

[DavidSpickett]

For https://github.com/llvm/llvm-project/issues/58135.

[shafik]

clang/include/clang/AST/ExprCXX.h

733 ↗

(On Diff #465034)

I think this makes sense but if we are going to do this refactor then we should clean up all the locations we are currently doing new (Context) CXXBoolLiteralExpr(....) as well.

Maybe that should be the initial PR and then this change would be a follow-up.

[DavidSpickett]

clang/include/clang/AST/ExprCXX.h

733 ↗

(On Diff #465034)

Sounds good to me, I'll do that.

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

36

And just to be clear, this is TODO is resolved in the patch stacked on this one.

[DavidSpickett]

Rebase, Create moved to parent change.

lldb/include/lldb/Symbol/CompilerType.h

public:
   IsBlockPointerType(CompilerType *function_pointer_type_ptr = nullptr) const;
 
   bool IsIntegerType(bool &is_signed) const;
 
   bool IsEnumerationType(bool &is_signed) const;
 
   bool IsIntegerOrEnumerationType(bool &is_signed) const;
 
+  bool IsBooleanType() const;
+
   bool IsPolymorphicClass() const;
 
   /// \param target_type    Can pass nullptr.
   bool IsPossibleDynamicType(CompilerType *target_type, bool check_cplusplus,
                              bool check_objc) const;
 
   bool IsPointerToScalarType() const;
 

lldb/include/lldb/Symbol/TypeSystem.h

virtual bool IsIntegerType(lldb::opaque_compiler_type_t type,
                              bool &is_signed) = 0;
 
   virtual bool IsEnumerationType(lldb::opaque_compiler_type_t type,
                                  bool &is_signed) {
     is_signed = false;
     return false;
   }
 
+  virtual bool IsBooleanType(lldb::opaque_compiler_type_t type) = 0;
+
   virtual bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
                                      CompilerType *target_type, // Can pass NULL
                                      bool check_cplusplus, bool check_objc) = 0;
 
   virtual bool IsPointerType(lldb::opaque_compiler_type_t type,
                              CompilerType *pointee_type) = 0;

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

if (var_type) {
         LLDB_LOG(log, "Failed to add variable to the record type");
         return;
       }
 
       bool unused;
       // TODO: Support float/double static members as well.
       if (!attrs.const_value_form || !ct.IsIntegerOrEnumerationType(unused))
         return;
+
       llvm::Expected<llvm::APInt> const_value_or_err =
           ExtractIntFromFormValue(ct, *attrs.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);
+
+      if (ct.IsBooleanType())
+        TypeSystemClang::SetBoolInitializerForVariable(
+            v, !const_value_or_err->isZero());
+      else
+        TypeSystemClang::SetIntegerInitializerForVariable(v,
+                                                          *const_value_or_err);
     }
     return;
   }
 
   Type *member_type = die.ResolveTypeUID(attrs.encoding_form.Reference());
   if (!member_type) {
     if (attrs.name)
       module_sp->ReportError(

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

bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
                           CompilerType *function_pointer_type_ptr) override;
 
   bool IsIntegerType(lldb::opaque_compiler_type_t type,
                      bool &is_signed) override;
 
   bool IsEnumerationType(lldb::opaque_compiler_type_t type,
                          bool &is_signed) override;
 
+  bool IsBooleanType(lldb::opaque_compiler_type_t type) override;
+
   bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) override;
 
   static bool IsObjCClassType(const CompilerType &type);
 
   static bool IsObjCClassTypeAndHasIVars(const CompilerType &type,
                                          bool check_superclass);
 
   static bool IsObjCObjectOrInterfaceType(const CompilerType &type);
#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
   /// \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);
 
+  static void SetBoolInitializerForVariable(clang::VarDecl *var, bool 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);

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

if (builtin_type->isInteger()) {
       is_signed = builtin_type->isSignedInteger();
       return true;
     }
   }
 
   return false;
 }
 
+bool TypeSystemClang::IsBooleanType(lldb::opaque_compiler_type_t type) {
+  if (!type)
+    return false;
+
+  clang::QualType qual_type(GetCanonicalQualType(type));
+  const clang::BuiltinType *builtin_type =
+      llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
+
+  if (!builtin_type)
+    return false;
+
+  return builtin_type->isBooleanType();
+}
+
 bool TypeSystemClang::IsEnumerationType(lldb::opaque_compiler_type_t type,
                                         bool &is_signed) {
   if (type) {
     const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
         GetCanonicalQualType(type)->getCanonicalTypeInternal());
 
     if (enum_type) {
       IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(),
var_decl->setAccess(
       TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
   record_decl->addDecl(var_decl);
 
   VerifyDecl(var_decl);
 
   return var_decl;
 }
 
+void TypeSystemClang::SetBoolInitializerForVariable(VarDecl *var, bool value) {
+  assert(!var->hasInit() && "variable already initialized");
+
+  QualType qt = var->getType();
+  assert(qt->isSpecificBuiltinType(BuiltinType::Bool) &&
+         "only boolean supported");
+
+  clang::ASTContext &ast = var->getASTContext();
+  var->setInit(CXXBoolLiteralExpr::Create(ast, value, qt.getUnqualifiedType(),
+                                          SourceLocation()));
+}
+
 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");

lldb/source/Symbol/CompilerType.cpp

if (IsValid())
     return m_type_system->IsEnumerationType(m_type, is_signed);
   return false;
 }
 
 bool CompilerType::IsIntegerOrEnumerationType(bool &is_signed) const {
   return IsIntegerType(is_signed) || IsEnumerationType(is_signed);
 }
 
+bool CompilerType::IsBooleanType() const {
+  if (IsValid())
+    return m_type_system->IsBooleanType(m_type);
+  return false;
+}
+
 bool CompilerType::IsPointerType(CompilerType *pointee_type) const {
   if (IsValid()) {
     return m_type_system->IsPointerType(m_type, pointee_type);
   }
   if (pointee_type)
     pointee_type->Clear();
   return false;
 }

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

def test(self):
 
         # 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")
 
         # Test a bool member.
         self.expect_expr("A::bool_val", result_value="true")
 
+        # Test a bool member when printing the struct it is a member of.
+        # TODO: replace this with printing struct A, once doing so doesn't crash lldb.
+        self.expect("image lookup -t StaticBoolStruct",
+                    substrs=["static const bool value = false;"])
+
         # 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")

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

struct ClassWithEnumAlias {
   using EnumAlias = ScopedEnum;
   static constexpr EnumAlias enum_alias = ScopedEnum::scoped_enum_case2;
 
   using EnumAliasAlias = EnumAlias;
   static constexpr EnumAliasAlias enum_alias_alias =
       ScopedEnum::scoped_enum_case1;
 };
 
+struct StaticBoolStruct {
+  static const bool value = false;
+};
+
 int main() {
   A a;
+  StaticBoolStruct sbs;
 
   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;