[LLDB][ClangExpression] Fix initialization of static enum alias members

[Michael137]

Summary

IntegerLiteral::Create operates on integer types. For that reason
when we parse DWARF into an AST, when we encounter a constant
initialized enum member variable, we try to determine the underlying
integer type before creating the IntegerLiteral. However, we
currently don't desugar the type and for enum typedefs
dyn_cast<EnumType> fails. In debug builds this triggers following
assert:

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

This patch turns the dyn_cast<EnumType> into a getAs<EnumType>
which dyn_casts the canonical type, allowing us to get to the
underlying integer type.

Testing

• API test
• Manual repro is fixed

[Michael137]

• Remove redundant header

[Michael137]

• Add test case

[Michael137]

• Remove drive-by whitespace change

[Michael137]

• Reword commit

[werat]

I've tried reproducing the test case with lldb built from HEAD on my Linux machine and it seems to work without your patch:

❯ cat ~/src/cpp/const.cc 
enum class ScopedEnum {
  scoped_enum_case1 = 1,
  scoped_enum_case2 = 2,
};

struct A {
  using EnumAlias = ScopedEnum;
  static constexpr EnumAlias e = ScopedEnum::scoped_enum_case2;
};

int main() {
    auto enum_alias_val = A::e;
}

❯ bin/lldb ~/src/cpp/a.out
(lldb) target create "/home/werat/src/cpp/a.out"
Current executable set to '/home/werat/src/cpp/a.out' (x86_64).
(lldb) b main
Breakpoint 1: where = a.out`main + 4 at const.cc:12:10, address = 0x0000000000401114
(lldb) r
Process 2767509 launched: '/home/werat/src/cpp/a.out' (x86_64)
Process 2767509 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000401114 a.out`main at const.cc:12:10
   9    };
   10  
   11   int main() {
-> 12       auto enum_alias_val = A::e;
   13   }
(lldb) p A::e
(const A::EnumAlias) $0 = scoped_enum_case2

Maybe the test case doesn't actually hit the problem you're trying to address?

---

❯ bin/lldb --version
lldb version 15.0.0git (https://github.com/llvm/llvm-project.git revision 2feb99b02c886201c9774f4f24df14299105b321)
  clang revision 2feb99b02c886201c9774f4f24df14299105b321
  llvm revision 2feb99b02c886201c9774f4f24df14299105b321

[Michael137]

In D130213#3668109, @werat wrote:

I've tried reproducing the test case with lldb built from HEAD on my Linux machine and it seems to work without your patch:

❯ cat ~/src/cpp/const.cc 
enum class ScopedEnum {
  scoped_enum_case1 = 1,
  scoped_enum_case2 = 2,
};

struct A {
  using EnumAlias = ScopedEnum;
  static constexpr EnumAlias e = ScopedEnum::scoped_enum_case2;
};

int main() {
    auto enum_alias_val = A::e;
}

❯ bin/lldb ~/src/cpp/a.out
(lldb) target create "/home/werat/src/cpp/a.out"
Current executable set to '/home/werat/src/cpp/a.out' (x86_64).
(lldb) b main
Breakpoint 1: where = a.out`main + 4 at const.cc:12:10, address = 0x0000000000401114
(lldb) r
Process 2767509 launched: '/home/werat/src/cpp/a.out' (x86_64)
Process 2767509 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000401114 a.out`main at const.cc:12:10
   9    };
   10  
   11   int main() {
-> 12       auto enum_alias_val = A::e;
   13   }
(lldb) p A::e
(const A::EnumAlias) $0 = scoped_enum_case2

Maybe the test case doesn't actually hit the problem you're trying to address?

---

❯ bin/lldb --version
lldb version 15.0.0git (https://github.com/llvm/llvm-project.git revision 2feb99b02c886201c9774f4f24df14299105b321)
  clang revision 2feb99b02c886201c9774f4f24df14299105b321
  llvm revision 2feb99b02c886201c9774f4f24df14299105b321

Hmm odd, on my Darwin machine the test consistently crashes

Let me confirm

[aprantl]

@werat did you build with assertions enabled?

This change looks fine to me, but it might be interesting to see where the discrepancy between the platforms comes from.

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

7541

In case someone else is curious what the difference between before and after is:

https://clang.llvm.org/doxygen/Type_8h_source.html#l07302

[Michael137]

In D130213#3668450, @aprantl wrote:

@werat did you build with assertions enabled?

This change looks fine to me, but it might be interesting to see where the discrepancy between the platforms comes from.

Interestingly, @werat's test case crashes for me (without the patch) but only if I explicitly create an instance of struct A. Otherwise, lldb doesn't find A::e.

If a class only has constexpr statics, on Darwin we omit the structure type from DWARF:

0x0000000b: DW_TAG_compile_unit            
              DW_AT_producer    ("Apple clang version 14.0.0 (clang-1400.0.25)")                           
              DW_AT_language    (DW_LANG_C_plus_plus_14)                                                   
              DW_AT_name        ("test.cpp")                                                               
              DW_AT_LLVM_sysroot        ("/Library/Developer/CommandLineTools/SDKs/MacOSX12.5.sdk")        
              DW_AT_APPLE_sdk   ("MacOSX12.5.sdk")                                                         
              DW_AT_stmt_list   (0x00000000)         
              DW_AT_comp_dir    ("/Users/michaelbuch/Git/lldb-build-lambda")                               
              DW_AT_low_pc      (0x0000000100003f9c)                                                                                                                                                                  
              DW_AT_high_pc     (0x0000000100003fb8)                                                       
                                                     
0x00000032:   DW_TAG_enumeration_type                                                                      
                DW_AT_type      (0x000000000000004b "int")                                                 
                DW_AT_enum_class        (true)                                                             
                DW_AT_name      ("ScopedEnum")                                                             
                DW_AT_byte_size (0x04)               
                DW_AT_decl_file ("/Users/michaelbuch/Git/lldb-build-lambda/test.cpp")                      
                DW_AT_decl_line (1)                                                                        
                                                     
0x0000003e:     DW_TAG_enumerator                                                                          
                  DW_AT_name    ("scoped_enum_case1")
                  DW_AT_const_value     (1)                                                                
                                                                                                           
0x00000044:     DW_TAG_enumerator                    
                  DW_AT_name    ("scoped_enum_case2")                                                      
                  DW_AT_const_value     (2)                                                                
                                                                                                           
0x0000004a:     NULL                                                                                       
                                                                                                           
0x0000004b:   DW_TAG_base_type                                                                             
                DW_AT_name      ("int")                                                                    
                DW_AT_encoding  (DW_ATE_signed)                                                            
                DW_AT_byte_size (0x04)                                                                     
                                                                                                           
0x00000052:   DW_TAG_subprogram                                                                            
                DW_AT_low_pc    (0x0000000100003f9c) 
                DW_AT_high_pc   (0x0000000100003fb8)                                                       
                DW_AT_APPLE_omit_frame_ptr      (true)                                                                                                                                                                
                DW_AT_frame_base        (DW_OP_reg31 WSP)                                                  
                DW_AT_name      ("main")
                DW_AT_decl_file ("/Users/michaelbuch/Git/lldb-build-lambda/test.cpp")                      
                DW_AT_decl_line (13)                                                                       
                DW_AT_type      (0x000000000000004b "int")                                                 
                DW_AT_external  (true)

0x0000006b:     DW_TAG_variable
                  DW_AT_location        (DW_OP_fbreg +8)                                                   
                  DW_AT_name    ("enum_alias_val")
                  DW_AT_decl_file       ("/Users/michaelbuch/Git/lldb-build-lambda/test.cpp")              
                  DW_AT_decl_line       (14)
                  DW_AT_type    (0x0000000000000032 "ScopedEnum")                                          

0x00000079:     NULL                                 

0x0000007a:   NULL

This is actually noted in one of the test cases in TestConstStaticIntegralMember.py:

# 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):

Though I'm a little confused why the test does find ClassWithEnumAlias::enum_alias despite it not being instantiated in main

[Michael137]

Though I'm a little confused why the test does find ClassWithEnumAlias::enum_alias despite it not being instantiated in main

Oh nvm, probably just because clang++ on Darwin invokes dsymutil at the end. Whereas in the test suite we don't unless explicitly done

[werat]

In D130213#3668450, @aprantl wrote:

@werat did you build with assertions enabled?

Oh, no, I build in RelWithDebInfo out of habit. I've tried with assertions and then it fails.

However, when ignoring the asserts the result is correct, which makes me wonder whether the assert check is 100% correct.

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

void TypeSystemClang::SetIntegerInitializerForVariable(
   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())) {
+  if (const EnumType *enum_type = qt->getAs<EnumType>()) {
     const EnumDecl *enum_decl = enum_type->getDecl();
     qt = enum_decl->getIntegerType();
   }
   var->setInit(IntegerLiteral::Create(ast, init_value, qt.getUnqualifiedType(),
                                       SourceLocation()));
 }
 
 void TypeSystemClang::SetFloatingInitializerForVariable(

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

def test(self):
         # 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")
 
+        # Test an aliased enum with fixed underlying type.
+        self.expect_expr("ClassWithEnumAlias::enum_alias",
+                         result_value="scoped_enum_case2")
+        self.expect_expr("ClassWithEnumAlias::enum_alias_alias",
+                         result_value="scoped_enum_case1")
+
         # Test taking address.
         if lldbplatformutil.getPlatform() == "windows":
             # On Windows data members without the out-of-class definitions still have
             # valid adresses and the following expression works fine.
             self.expect_expr("const int *i = &A::int_val; *i", result_value="1")
         else:
             # On other platforms (Linux, macos) data members without the out-of-class
             # definitions don't have valid addresses and the following code produces

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

 };
 
 struct ClassWithConstexprs {
   constexpr static int member = 2;
   constexpr static Enum enum_val = enum_case2;
   constexpr static ScopedEnum scoped_enum_val = ScopedEnum::scoped_enum_case2;
 } cwc;
 
+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;
+};
+
 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;
int main() {
   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;
+
+  auto enum_alias_val = ClassWithEnumAlias::enum_alias;
+  auto enum_alias_alias_val = ClassWithEnumAlias::enum_alias_alias;
+
   return 0; // break here
 }