Revert "[llvm][formatters] Add LLDB data-formatter for llvm::PointerIntPair"

cross-project-tests/CMakeLists.txt

@@ -18,20 +18,13 @@ add_executable(check-lldb-llvm-support-arrayref
 target_link_libraries(check-lldb-llvm-support-arrayref PRIVATE LLVMSupport)
 target_compile_options(check-lldb-llvm-support-arrayref PRIVATE -g -O0)
 
-add_executable(check-lldb-llvm-support-pointer-int-pair
-        debuginfo-tests/llvm-prettyprinters/lldb/pointer-int-pair.cpp
-)
-target_link_libraries(check-lldb-llvm-support-pointer-int-pair PRIVATE LLVMSupport)
-target_compile_options(check-lldb-llvm-support-pointer-int-pair PRIVATE -g -O0)
-
 set(CROSS_PROJECT_TESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(CROSS_PROJECT_TESTS_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 set(CROSS_PROJECT_TEST_DEPS
   FileCheck
   check-gdb-llvm-support
   check-lldb-llvm-support-arrayref
-  check-lldb-llvm-support-pointer-int-pair
   count
   llvm-ar
   llvm-config

llvm/utils/lldbDataFormatters.py

@@ -57,11 +57,21 @@ def __lldb_init_module(debugger, internal_dict):
         f"-F {__name__}.ConstStringSummaryProvider "
         "lldb_private::ConstString"
     )
-    debugger.HandleCommand(
-        "type synthetic add -w llvm "
-        f"-l {__name__}.PointerIntPairSynthProvider "
-        '-x "^llvm::PointerIntPair<.+>$"'
-    )
+
+    # The synthetic providers for PointerIntPair and PointerUnion are disabled
+    # because of a few issues. One example is template arguments that are
+    # non-pointer types that instead specialize PointerLikeTypeTraits.
+    # debugger.HandleCommand(
+    #     "type synthetic add -w llvm "
+    #     f"-l {__name__}.PointerIntPairSynthProvider "
+    #     '-x "^llvm::PointerIntPair<.+>$"'
+    # )
+    # debugger.HandleCommand(
+    #     "type synthetic add -w llvm "
+    #     f"-l {__name__}.PointerUnionSynthProvider "
+    #     '-x "^llvm::PointerUnion<.+>$"'
+    # )
+
     debugger.HandleCommand(
         "type summary add -w llvm "
         f"-e -F {__name__}.DenseMapSummary "
@@ -207,6 +217,13 @@ def ConstStringSummaryProvider(valobj, internal_dict):
     return ""
 
 
+def get_expression_path(val):
+    stream = lldb.SBStream()
+    if not val.GetExpressionPath(stream):
+        return None
+    return stream.GetData()
+
+
 class PointerIntPairSynthProvider:
     def __init__(self, valobj, internal_dict):
         self.valobj = valobj
@@ -222,101 +239,81 @@ def get_child_index(self, name):
             return 1
         return None
 
-    def _get_raw_value(self):
-        data: SBData = self.value.GetData()
-        error = lldb.SBError()
-        raw_bytes = data.ReadRawData(error, 0, self.ptr_size)
-        if error.Fail():
-            return None
-
-        return raw_bytes
-
-    def _get_pointer(self, pointer_bit_mask: int, pointer_ty: SBType):
-        raw_bytes = self._get_raw_value()
-        if raw_bytes is None:
-            return
-
-        unmasked_pointer = int.from_bytes(raw_bytes, self.byteorder)
-        pointer_value = unmasked_pointer & pointer_bit_mask
-
-        data = lldb.SBData()
-        data.SetDataFromUInt64Array([pointer_value])
-        return self.valobj.CreateValueFromData("Pointer", data, pointer_ty)
-
-    def _get_int(self, int_shift: int, int_mask: int, int_ty: SBType):
-        raw_bytes = self._get_raw_value()
-        if raw_bytes is None:
-            return
-
-        unmasked_pointer = int.from_bytes(raw_bytes, self.byteorder)
-        int_value = (unmasked_pointer >> int_shift) & int_mask
-
-        data = lldb.SBData()
-        data.SetDataFromUInt64Array([int_value])
-        return self.valobj.CreateValueFromData("Int", data, int_ty)
-
     def get_child_at_index(self, index):
+        expr_path = get_expression_path(self.valobj)
         if index == 0:
-            return self.pointer_valobj
+            return self.valobj.CreateValueFromExpression(
+                "Pointer", f"({self.pointer_ty.name}){expr_path}.getPointer()"
+            )
         if index == 1:
-            return self.int_valobj
+            return self.valobj.CreateValueFromExpression(
+                "Int", f"({self.int_ty.name}){expr_path}.getInt()"
+            )
         return None
 
     def update(self):
-        self.byteorder = (
-            "big"
-            if self.valobj.target.GetByteOrder() == lldb.eByteOrderBig
-            else "little"
-        )
-        self.ptr_size = self.valobj.target.GetAddressByteSize()
-        self.value: SBValue = self.valobj.GetChildMemberWithName("Value")
-        if not self.value:
-            return
+        self.pointer_ty = self.valobj.GetType().GetTemplateArgumentType(0)
+        self.int_ty = self.valobj.GetType().GetTemplateArgumentType(2)
 
-        valobj_type = self.valobj.GetType()
 
-        pointer_ty: SBType = valobj_type.GetTemplateArgumentType(0)
-        if not pointer_ty:
-            return
+def parse_template_parameters(typename):
+    """
+    LLDB doesn't support template parameter packs, so let's parse them manually.
+    """
+    result = []
+    start = typename.find("<")
+    end = typename.rfind(">")
+    if start < 1 or end < 2 or end - start < 2:
+        return result
 
-        int_ty: SBType = valobj_type.GetTemplateArgumentType(2)
-        if not int_ty:
-            return
+    nesting_level = 0
+    current_parameter_start = start + 1
 
-        pointer_info = valobj_type.GetTemplateArgumentType(4)
-        if not pointer_info:
-            return
+    for i in range(start + 1, end + 1):
+        c = typename[i]
+        if c == "<":
+            nesting_level += 1
+        elif c == ">":
+            nesting_level -= 1
+        elif c == "," and nesting_level == 0:
+            result.append(typename[current_parameter_start:i].strip())
+            current_parameter_start = i + 1
 
-        mask_and_shift_constants = pointer_info.FindDirectNestedType(
-            "MaskAndShiftConstants"
-        ).GetEnumMembers()
+    result.append(typename[current_parameter_start:i].strip())
 
-        # FIXME: SBAPI should provide a way to retrieve an enum member
-        # by name.
-        pointer_bit_mask: SBTypeEnumMember = (
-            mask_and_shift_constants.GetTypeEnumMemberAtIndex(0)
-        )
-        if pointer_bit_mask.name != "PointerBitMask":
-            return
+    return result
 
-        int_shift: SBTypeEnumMember = mask_and_shift_constants.GetTypeEnumMemberAtIndex(
-            1
-        )
-        if int_shift.name != "IntShift":
-            return
 
-        int_mask: SBTypeEnumMember = mask_and_shift_constants.GetTypeEnumMemberAtIndex(
-            2
-        )
-        if int_mask.name != "IntMask":
-            return
+class PointerUnionSynthProvider:
+    def __init__(self, valobj, internal_dict):
+        self.valobj = valobj
+        self.update()
 
-        self.pointer_valobj = self._get_pointer(
-            pointer_bit_mask.GetValueAsUnsigned(), pointer_ty
+    def num_children(self):
+        return 1
+
+    def get_child_index(self, name):
+        if name == "Ptr":
+            return 0
+        return None
+
+    def get_child_at_index(self, index):
+        if index != 0:
+            return None
+        ptr_type_name = self.template_args[self.active_type_tag]
+        return self.valobj.CreateValueFromExpression(
+            "Ptr", f"({ptr_type_name}){self.val_expr_path}.getPointer()"
         )
-        self.int_valobj = self._get_int(
-            int_shift.GetValueAsUnsigned(), int_mask.GetValueAsUnsigned(), int_ty
+
+    def update(self):
+        self.pointer_int_pair = self.valobj.GetChildMemberWithName("Val")
+        self.val_expr_path = get_expression_path(
+            self.valobj.GetChildMemberWithName("Val")
         )
+        self.active_type_tag = self.valobj.CreateValueFromExpression(
+            "", f"(int){self.val_expr_path}.getInt()"
+        ).GetValueAsSigned()
+        self.template_args = parse_template_parameters(self.valobj.GetType().name)
 
 
 def DenseMapSummary(valobj: lldb.SBValue, _) -> str: