[llvm][utils] Fix SmallVector formatter when type is a pointer

[Michael137]

Summary

Previously types such as SmallVector<clang::Attr, 4> * would
trigger the assertion inside the SmallVector formatter:

assert self.type_size != 0

This happens because the_type.GetTemplateArgumentType(0) returns
None (since the_type is a pointer to the SmallVector).

This patch dereferences the_type if it's a pointer type. We do this
for references already.

[Michael137]

• Remove drive-by change

[Michael137]

• Reword commit message

[dblaikie]

Hmm - it seems weird that the formatter for SmallVector would be involved directly in the formatting of SmallVector*? Could we fix that, so the SmallVector formatter is only used for SmallVector objects, not pointers? (if lldb wants to automatically dereference pointers and print the result - that's a generic feature in lldb that the SmallVector pretty printer wouldn't need to know about?)

(like what does lldb do with int*? Does it print the int (if any) that's pointed to?)

[kastiglione]

Could we fix that, so the SmallVector formatter is only used for SmallVector objects, not pointers?

type synthetic add has:

-p ( --skip-pointers )
     Don't use this format for pointers-to-type objects.

[dblaikie]

In D157961#4649097, @kastiglione wrote:

Could we fix that, so the SmallVector formatter is only used for SmallVector objects, not pointers?

type synthetic add has:

-p ( --skip-pointers )
     Don't use this format for pointers-to-type objects.

Hmm, that seems like an awkward way for lldb to expose this functionality. Judging by the examples here: https://lldb.llvm.org/use/variable.html if you -p, then lldb will still print the contents of what a pointer points to, but using innate printing, instead of teh pretty printer? (the example with a pretty printer for int with -p - if you print out a pointer, you also get the builtin int printing for the thing the pointer points to, but then if you dereference, you get the custom pretty printing) but then if you don't use -p your pretty printer has to handle being passed a pointer? (what about a pointer to pointer? Is it just one level of indirection that's special cased)

Ugh :/

Thanks for listening/pointing me to the docs at least - guess this patch is the right way to go, given lldb's features. Not sure how to make sense of the feature, though.

llvm/utils/lldbDataFormatters.py

def update(self):
         self.begin = self.valobj.GetChildMemberWithName("BeginX")
         self.size = self.valobj.GetChildMemberWithName("Size")
         the_type = self.valobj.GetType()
         # If this is a reference type we have to dereference it to get to the
         # template parameter.
         if the_type.IsReferenceType():
             the_type = the_type.GetDereferencedType()
 
+        if the_type.IsPointerType():
+            the_type = the_type.GetPointeeType()
+
         self.data_type = the_type.GetTemplateArgumentType(0)
         self.type_size = self.data_type.GetByteSize()
         assert self.type_size != 0
 
 
 class ArrayRefSynthProvider:
     """Provider for llvm::ArrayRef"""