Add SBType::GetEnumerationIntegerType method

[werat]

Summary

Add a method for getting the enumeration underlying type.

[werat]

lldb/test/API/python_api/type/TestTypeList.py

156

Afaik this is implementation defined, so maybe this we shouldn't test this.

[JDevlieghere]

lldb/source/API/SBType.cpp

348

You also need to register the new method. You can add the instrumentation automatically with the lldb-instr tool if you remove this line (and the LLDB_RECORD_RESULT or the return value will get wrapped again).

lldb/test/API/python_api/type/TestTypeList.py

156

Yeah, I would either remove it or add a comment saying that it's implementation defined in case someone (downstream) runs into this.

[werat]

Register the new method using lldb-instr.

[werat]

Remove the test case for unscoped enum, because it's implementation defined and can break any moment.

[JDevlieghere]

LGTM

[werat]

lldb/source/API/SBType.cpp

348

Thanks, done!

lldb/test/API/python_api/type/TestTypeList.py

156

I've removed the test case to avoid potential confusion.

[werat]

Thanks for a quick review! Can you please land these changes for me since I don't have commit access.

lldb/bindings/interface/SBType.i

public:
 
     lldb::SBType
     GetUnqualifiedType();
 
     lldb::SBType
     GetCanonicalType();
 
     lldb::SBType
+    GetEnumerationIntegerType();
+
+    lldb::SBType
     GetArrayElementType ();
 
     lldb::SBType
     GetArrayType (uint64_t size);
 
     lldb::SBType
     GetVectorElementType ();
 

lldb/include/lldb/API/SBType.h

public:
 
   lldb::SBType GetArrayElementType();
 
   lldb::SBType GetArrayType(uint64_t size);
 
   lldb::SBType GetVectorElementType();
 
   lldb::SBType GetCanonicalType();
+
+  lldb::SBType GetEnumerationIntegerType();
+
   // Get the "lldb::BasicType" enumeration for a type. If a type is not a basic
   // type eBasicTypeInvalid will be returned
   lldb::BasicType GetBasicType();
 
   // The call below confusing and should really be renamed to "CreateBasicType"
   lldb::SBType GetBasicType(lldb::BasicType type);
 
   uint32_t GetNumberOfFields();

lldb/include/lldb/Symbol/CompilerType.h

public:
   CompilerType GetArrayElementType(ExecutionContextScope *exe_scope) const;
 
   CompilerType GetArrayType(uint64_t size) const;
 
   CompilerType GetCanonicalType() const;
 
   CompilerType GetFullyUnqualifiedType() const;
 
+  CompilerType GetEnumerationIntegerType() const;
+
   /// Returns -1 if this isn't a function of if the function doesn't
   /// have a prototype Returns a value >= 0 if there is a prototype.
   int GetFunctionArgumentCount() const;
 
   CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const;
 
   CompilerType GetFunctionReturnType() const;
 

lldb/include/lldb/Symbol/TypeSystem.h

#endif
   GetArrayElementType(lldb::opaque_compiler_type_t type,
                       ExecutionContextScope *exe_scope) = 0;
 
   virtual CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
                                     uint64_t size);
 
   virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) = 0;
 
+  virtual CompilerType
+  GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) = 0;
+
   // Returns -1 if this isn't a function of if the function doesn't have a
   // prototype Returns a value >= 0 if there is a prototype.
   virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) = 0;
 
   virtual CompilerType
   GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
                                  size_t idx) = 0;
 

lldb/source/API/SBType.cpp

lldb::SBType SBType::GetCanonicalType() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetCanonicalType);
 
   if (IsValid())
     return LLDB_RECORD_RESULT(
         SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))));
   return LLDB_RECORD_RESULT(SBType());
 }
 
+SBType SBType::GetEnumerationIntegerType() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetEnumerationIntegerType);
+
+  if (IsValid()) {
+    return LLDB_RECORD_RESULT(
+        SBType(m_opaque_sp->GetCompilerType(true).GetEnumerationIntegerType()));
+  }
+  return LLDB_RECORD_RESULT(SBType());
+}
+
 lldb::BasicType SBType::GetBasicType() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::BasicType, SBType, GetBasicType);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
   return eBasicTypeInvalid;
 }
 
void RegisterMethods<SBType>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
                        ());
   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
   LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
                        GetMemberFunctionAtIndex, (uint32_t));
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());
+  LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetEnumerationIntegerType, ());
   LLDB_REGISTER_METHOD(lldb::BasicType, SBType, GetBasicType, ());
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetBasicType, (lldb::BasicType));
   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfDirectBaseClasses, ());
   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfVirtualBaseClasses, ());
   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfFields, ());
   LLDB_REGISTER_METHOD(bool, SBType, GetDescription,
                        (lldb::SBStream &, lldb::DescriptionLevel));
   LLDB_REGISTER_METHOD(lldb::SBTypeMember, SBType, GetDirectBaseClassAtIndex,

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

#endif
   CompilerType GetArrayType(lldb::opaque_compiler_type_t type,
                             uint64_t size) override;
 
   CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;
 
   CompilerType
   GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override;
 
+  CompilerType
+  GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) override;
+
   // Returns -1 if this isn't a function of if the function doesn't have a
   // prototype Returns a value >= 0 if there is a prototype.
   int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
                                               size_t idx) override;
 
   CompilerType

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

 CompilerType
 TypeSystemClang::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetType(
         GetFullyUnqualifiedType_Impl(&getASTContext(), GetQualType(type)));
   return CompilerType();
 }
 
+CompilerType
+TypeSystemClang::GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) {
+  if (type)
+    return GetEnumerationIntegerType(GetType(GetCanonicalQualType(type)));
+  return CompilerType();
+}
+
 int TypeSystemClang::GetFunctionArgumentCount(
     lldb::opaque_compiler_type_t type) {
   if (type) {
     const clang::FunctionProtoType *func =
         llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
     if (func)
       return func->getNumParams();
   }

lldb/source/Symbol/CompilerType.cpp

 }
 
 CompilerType CompilerType::GetFullyUnqualifiedType() const {
   if (IsValid())
     return m_type_system->GetFullyUnqualifiedType(m_type);
   return CompilerType();
 }
 
+CompilerType CompilerType::GetEnumerationIntegerType() const {
+  if (IsValid())
+    return m_type_system->GetEnumerationIntegerType(m_type);
+  return CompilerType();
+}
+
 int CompilerType::GetFunctionArgumentCount() const {
   if (IsValid()) {
     return m_type_system->GetFunctionArgumentCount(m_type);
   }
   return -1;
 }
 
 CompilerType CompilerType::GetFunctionArgumentTypeAtIndex(size_t idx) const {

lldb/test/API/python_api/type/TestTypeList.py

def test(self):
         self.DebugSBType(myint_type)
         self.assertTrue(myint_arr_element_type == myint_type)
 
         # Test enum methods.
         enum_type = target.FindFirstType('EnumType')
         self.assertTrue(enum_type)
         self.DebugSBType(enum_type)
         self.assertFalse(enum_type.IsScopedEnumerationType())
+
         scoped_enum_type = target.FindFirstType('ScopedEnumType')
         self.assertTrue(scoped_enum_type)
         self.DebugSBType(scoped_enum_type)
         self.assertTrue(scoped_enum_type.IsScopedEnumerationType())
+        int_scoped_enum_type = scoped_enum_type.GetEnumerationIntegerType()
+        self.assertTrue(int_scoped_enum_type)
+        self.DebugSBType(int_scoped_enum_type)
+        self.assertEquals(int_scoped_enum_type.GetName(), 'int')
+
+        enum_uchar = target.FindFirstType('EnumUChar')
+        self.assertTrue(enum_uchar)
+        self.DebugSBType(enum_uchar)
+        int_enum_uchar = enum_uchar.GetEnumerationIntegerType()
+        self.assertTrue(int_enum_uchar)
+        self.DebugSBType(int_enum_uchar)
+        self.assertEquals(int_enum_uchar.GetName(), 'unsigned char')

lldb/test/API/python_api/type/main.cpp

Task(int i, Task *n):
         id(i),
         next(n),
         type(TASK_TYPE_1)
     {}
 };
 
 enum EnumType {};
 enum class ScopedEnumType {};
+enum class EnumUChar : unsigned char {};
 
 int main (int argc, char const *argv[])
 {
     Task *task_head = new Task(-1, NULL);
     Task *task1 = new Task(1, NULL);
     Task *task2 = new Task(2, NULL);
     Task *task3 = new Task(3, NULL); // Orphaned.
     Task *task4 = new Task(4, NULL);
int main (int argc, char const *argv[])
     // This corresponds to an empty task list.
     Task *empty_task_head = new Task(-1, NULL);
 
     typedef int myint;
     myint myint_arr[] = {1, 2, 3};
 
     EnumType enum_type;
     ScopedEnumType scoped_enum_type;
+    EnumUChar scoped_enum_type_uchar;
 
     return 0; // Break at this line
 }