Changeset 251813 in webkit


Ignore:
Timestamp:
Oct 30, 2019 3:21:06 PM (4 years ago)
Author:
dbates@webkit.org
Message:

Add pretty printer for CompactPointerTuple
​https://bugs.webkit.org/show_bug.cgi?id=203495

Reviewed by Jer Noble.

Source/WTF:

#include <wtf/FastMalloc.h> for the definition of WTF_MAKE_FAST_ALLOCATED.

  • wtf/CompactPointerTuple.h:

Tools:

Make it easy to see the state of a CompactPointerTuple. Now we will print something like:

(WTF::CompactPointerTuple<WTF::String *, unsigned char>) $0 = { type = 7 } {

[0] = 0x00007ffeefbff220 { length = 8, contents = 'résumé' }
[1] = 7

}

for aCompactPointerTuple defined like this:

String aString { "résumé" };
CompactPointerTuple<String*, uint8_t> aCompactPointerTuple { &aString, 7 };

  • lldb/lldbWebKitTester/main.cpp:

(testSummaryProviders):

  • lldb/lldb_webkit.py:

(lldb_init_module):
(lldb_init_module.lldb_webkit):
(WTFCompactPointerTuple_SummaryProvider):
(WTFCompactPointerTupleProvider):
(WTFCompactPointerTupleProvider.init):

(WTFCompactPointerTupleProvider.type_as_string):
(WTFCompactPointerTupleProvider.is_human_readable_type):
The majority of the time CompactPointerTuple will be used with non-character type data. So,
I optimize for this use case and consider the integral value as more readable than than LLDB's
default summary provider that emits the character or equivalent C escape sequence.

(WTFCompactPointerTupleProvider.has_children):
(WTFCompactPointerTupleProvider.num_children):
(WTFCompactPointerTupleProvider.get_child_index):
(WTFCompactPointerTupleProvider.get_child_at_index):
(WTFCompactPointerTupleProvider.update):

  • lldb/lldb_webkit_unittest.py:

(TestSummaryProviders.serial_test_WTFOptionSetProvider_aliased_flag):
(TestSummaryProviders):
(TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_empty):
(TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_simple):
(TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_max_type_value):
(TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_bool):
(TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_empty):
(TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_simple):
(TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_max_type_value):
(TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_simple_bool):

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r251736 r251813  
     12019-10-30  Daniel Bates  <dabates@apple.com>
     2
     3        Add pretty printer for CompactPointerTuple
     4        https://bugs.webkit.org/show_bug.cgi?id=203495
     5
     6        Reviewed by Jer Noble.
     7
     8        #include <wtf/FastMalloc.h> for the definition of WTF_MAKE_FAST_ALLOCATED.
     9
     10        * wtf/CompactPointerTuple.h:
     11
    1122019-10-29  Yusuke Suzuki  <ysuzuki@apple.com>
    213

  • trunk/Source/WTF/wtf/CompactPointerTuple.h

    r251008 r251813  
    2727
    2828#include <type_traits>
     29#include <wtf/FastMalloc.h>
    2930#include <wtf/StdLibExtras.h>
    3031

  • trunk/Tools/ChangeLog

    r251808 r251813  
     12019-10-30  Daniel Bates  <dabates@apple.com>
     2
     3        Add pretty printer for CompactPointerTuple
     4        https://bugs.webkit.org/show_bug.cgi?id=203495
     5
     6        Reviewed by Jer Noble.
     7
     8        Make it easy to see the state of a CompactPointerTuple. Now we will print something like:
     9
     10                (WTF::CompactPointerTuple<WTF::String *, unsigned char>) $0 = { type = 7 } {
     11                  [0] = 0x00007ffeefbff220 { length = 8, contents = 'résumé' }
     12                  [1] = 7
     13                }
     14
     15        for aCompactPointerTuple defined like this:
     16
     17                String aString { "résumé" };
     18                CompactPointerTuple<String*, uint8_t> aCompactPointerTuple { &aString, 7 };
     19
     20        * lldb/lldbWebKitTester/main.cpp:
     21        (testSummaryProviders):
     22        * lldb/lldb_webkit.py:
     23        (__lldb_init_module):
     24        (__lldb_init_module.lldb_webkit):
     25        (WTFCompactPointerTuple_SummaryProvider):
     26        (WTFCompactPointerTupleProvider):
     27        (WTFCompactPointerTupleProvider.__init__):
     28
     29        (WTFCompactPointerTupleProvider.type_as_string):
     30        (WTFCompactPointerTupleProvider.is_human_readable_type):
     31        The majority of the time CompactPointerTuple will be used with non-character type data. So,
     32        I optimize for this use case and consider the integral value as more readable than than LLDB's
     33        default summary provider that emits the character or equivalent C escape sequence.
     34
     35        (WTFCompactPointerTupleProvider.has_children):
     36        (WTFCompactPointerTupleProvider.num_children):
     37        (WTFCompactPointerTupleProvider.get_child_index):
     38        (WTFCompactPointerTupleProvider.get_child_at_index):
     39        (WTFCompactPointerTupleProvider.update):
     40        * lldb/lldb_webkit_unittest.py:
     41        (TestSummaryProviders.serial_test_WTFOptionSetProvider_aliased_flag):
     42        (TestSummaryProviders):
     43        (TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_empty):
     44        (TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_simple):
     45        (TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_max_type_value):
     46        (TestSummaryProviders.serial_test_WTFCompactPointerTuple_SummaryProvider_bool):
     47        (TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_empty):
     48        (TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_simple):
     49        (TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_max_type_value):
     50        (TestSummaryProviders.serial_test_WTFCompactPointerTupleProvider_simple_bool):
     51
    1522019-10-30  Jonathan Bedard  <jbedard@apple.com>
    253

  • trunk/Tools/lldb/lldbWebKitTester/main.cpp

    r237564 r251813  
    2626#include "DumpClassLayoutTesting.h"
    2727#include <stdio.h>
     28#include <wtf/CompactPointerTuple.h>
    2829#include <wtf/HashMap.h>
    2930#include <wtf/HashSet.h>
    … …  
    8788    OptionSet<ExampleFlags> exampleFlagsAliasedFlag { ExampleFlags::AAlias, ExampleFlags::D };
    8889
     90    CompactPointerTuple<String*, uint8_t> exampleCompactPointerTupleEmpty;
     91    CompactPointerTuple<String*, uint8_t> exampleCompactPointerTupleSimple { &an8BitString, 7 };
     92    CompactPointerTuple<String*, uint8_t> exampleCompactPointerTupleMaxTypeValue { &an8BitString, 255 };
     93    CompactPointerTuple<String*, bool> exampleCompactPointerTupleSimpleBool { &an8BitString, true };
     94
    8995    breakForTestingSummaryProviders();
    9096}

  • trunk/Tools/lldb/lldb_webkit.py

    r251220 r251813  
    6767    debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFMediaTime_SummaryProvider WTF::MediaTime')
    6868    debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFOptionSet_SummaryProvider -x "^WTF::OptionSet<.+>$"')
     69    debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFCompactPointerTuple_SummaryProvider -x "^WTF::CompactPointerTuple<.+,.+>$"')
    6970
    7071    debugger.HandleCommand('type summary add -F lldb_webkit.WTFURL_SummaryProvider WTF::URL')
    … …  
    9495    debugger.HandleCommand('type synthetic add -x "^WTF::HashTable<.+>$" --python-class lldb_webkit.WTFHashTableProvider')
    9596    debugger.HandleCommand('type synthetic add -x "^WTF::OptionSet<.+>$" --python-class lldb_webkit.WTFOptionSetProvider')
     97    debugger.HandleCommand('type synthetic add -x "^WTF::CompactPointerTuple<.+,.+>$" --python-class lldb_webkit.WTFCompactPointerTupleProvider')
    9698
    9799    addSummaryAndSyntheticFormattersForRawBitmaskType(debugger, "WebEventFlags", {
    … …  
    167169        return "{ %f }" % (provider.timeValueAsDouble())
    168170    return "{ %d/%d, %f }" % (provider.timeValue(), provider.timeScale(), float(provider.timeValue()) / provider.timeScale())
     171
     172
     173def WTFCompactPointerTuple_SummaryProvider(valobj, dict):
     174    provider = WTFCompactPointerTupleProvider(valobj, dict)
     175    return "{ type = %s }" % provider.type_as_string()
    169176
    170177
    … …  
    843850    def _bitmask(self):
    844851        return self.valobj.GetValueAsUnsigned(0)
     852
     853
     854class WTFCompactPointerTupleProvider(object):
     855
     856    TYPE_MASK = 0xF800000000000007
     857    POINTER_MASK = ~TYPE_MASK
     858
     859    def __init__(self, valobj, internal_dict):
     860        self.valobj = valobj
     861        self._is32Bit = valobj.GetTarget().GetAddressByteSize() == 4
     862        self._pointer = None
     863        self._type = None
     864        self.update()
     865
     866    def type_as_string(self):
     867        if not self.is_human_readable_type():
     868            return "%s" % self._type.GetValueAsUnsigned(0)
     869        return "%s" % self._type.GetValue()
     870
     871    def is_human_readable_type(self):
     872        # The default summary provider for uint8_t, unsigned char emits the ASCII printable character or equivalent
     873        # C escape sequence (e.g. \a = 0x07). Typically the CompactPointerTuple is used to encode non-character integral
     874        # data. In this context it is less readable to use the default summary provider. So, we don't.
     875        return self.valobj.GetType().GetTemplateArgumentType(1).GetBasicType() != lldb.eBasicTypeUnsignedChar
     876
     877    # LLDB overrides
     878    def has_children(self):
     879        return self._type is not None and self._pointer is not None
     880
     881    def num_children(self):
     882        if not self.has_children:
     883            return 0
     884        return 2
     885
     886    def get_child_index(self, name):
     887        if name == '[0]':
     888            return 0
     889        if name == '[1]':
     890            return 1
     891        if self._is32Bit:
     892            if name == 'm_pointer':
     893                return 2
     894            if name == 'm_type':
     895                return 3
     896        else:
     897            if name == 'm_data':
     898                return 2
     899        return None
     900
     901    def get_child_at_index(self, index):
     902        if index < 0 or not self.valobj.IsValid():
     903            return None
     904        if index == 0:
     905            return self._pointer
     906        if index == 1:
     907            return self._type
     908        if self._is32Bit:
     909            if index == 2:
     910                return self._pointer
     911            if index == 3:
     912                return self._type
     913        else:
     914            if index == 2:
     915                return self.valobj.GetChildMemberWithName('m_data')
     916        return None
     917
     918    def update(self):
     919        if self._is32Bit:
     920            self._pointer = self.valobj.GetChildMemberWithName('m_pointer')
     921            self._type = self.valobj.GetChildMemberWithName('m_type')
     922        else:
     923            data = self.valobj.GetChildMemberWithName('m_data').GetValueAsUnsigned(0)
     924            byte_order = self.valobj.GetTarget().GetByteOrder()
     925            address_byte_size = self.valobj.GetTarget().GetAddressByteSize()
     926
     927            pointer_data = lldb.SBData.CreateDataFromUInt64Array(byte_order, address_byte_size, [data & self.POINTER_MASK])
     928            self._pointer = self.valobj.CreateValueFromData('[0]', pointer_data, self.valobj.GetType().GetTemplateArgumentType(0))
     929
     930            type_data = lldb.SBData.CreateDataFromUInt64Array(byte_order, address_byte_size, [(data >> 59 | data << 5) & 0xFF])
     931            type_to_use = self.valobj.GetType().GetTemplateArgumentType(1)
     932            if not self.is_human_readable_type():
     933                type_to_use = self.valobj.GetTarget().GetBasicType(lldb.eBasicTypeUnsignedInt)
     934            self._type = self.valobj.CreateValueFromData('[1]', type_data, type_to_use)
    845935
    846936

  • trunk/Tools/lldb/lldb_webkit_unittest.py

    r249030 r251813  
    205205        self.assertEqual(provider.get_child_at_index(1).GetName(), 'D')
    206206        self.assertEqual(provider.get_child_at_index(1).GetValue(), '8')
     207
     208    # MARK: WTFCompactPointerTuple test cases
     209
     210    def serial_test_WTFCompactPointerTuple_SummaryProvider_empty(self):
     211        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleEmpty')
     212        summary = lldb_webkit.WTFCompactPointerTuple_SummaryProvider(variable, {})
     213        self.assertEqual(summary, "{ type = 0 }")
     214
     215    def serial_test_WTFCompactPointerTuple_SummaryProvider_simple(self):
     216        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleSimple')
     217        summary = lldb_webkit.WTFCompactPointerTuple_SummaryProvider(variable, {})
     218        self.assertEqual(summary, "{ type = 7 }")
     219
     220    def serial_test_WTFCompactPointerTuple_SummaryProvider_max_type_value(self):
     221        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleMaxTypeValue')
     222        summary = lldb_webkit.WTFCompactPointerTuple_SummaryProvider(variable, {})
     223        self.assertEqual(summary, "{ type = 255 }")
     224
     225    def serial_test_WTFCompactPointerTuple_SummaryProvider_bool(self):
     226        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleSimpleBool')
     227        summary = lldb_webkit.WTFCompactPointerTuple_SummaryProvider(variable, {})
     228        self.assertEqual(summary, "{ type = true }")
     229
     230    def serial_test_WTFCompactPointerTupleProvider_empty(self):
     231        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleEmpty')
     232        provider = lldb_webkit.WTFCompactPointerTupleProvider(variable, {})
     233        self.assertEqual(provider.get_child_at_index(0).GetName(), '[0]')
     234        self.assertEqual(provider.get_child_at_index(0).GetValueAsUnsigned(), 0)
     235        self.assertEqual(provider.get_child_at_index(1).GetName(), '[1]')
     236        self.assertEqual(provider.get_child_at_index(1).GetValueAsUnsigned(), 0)
     237
     238    def serial_test_WTFCompactPointerTupleProvider_simple(self):
     239        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleSimple')
     240        provider = lldb_webkit.WTFCompactPointerTupleProvider(variable, {})
     241        self.assertEqual(provider.get_child_at_index(0).GetName(), '[0]')
     242        self.assertNotEqual(provider.get_child_at_index(0).GetValueAsUnsigned(), 0)
     243        self.assertEqual(provider.get_child_at_index(1).GetName(), '[1]')
     244        self.assertEqual(provider.get_child_at_index(1).GetValueAsUnsigned(), 7)
     245
     246    def serial_test_WTFCompactPointerTupleProvider_max_type_value(self):
     247        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleMaxTypeValue')
     248        provider = lldb_webkit.WTFCompactPointerTupleProvider(variable, {})
     249        self.assertEqual(provider.get_child_at_index(0).GetName(), '[0]')
     250        self.assertNotEqual(provider.get_child_at_index(0).GetValueAsUnsigned(), 0)
     251        self.assertEqual(provider.get_child_at_index(1).GetName(), '[1]')
     252        self.assertEqual(provider.get_child_at_index(1).GetValueAsUnsigned(), 255)
     253
     254    def serial_test_WTFCompactPointerTupleProvider_simple_bool(self):
     255        variable = self._sbFrame.FindVariable('exampleCompactPointerTupleSimpleBool')
     256        provider = lldb_webkit.WTFCompactPointerTupleProvider(variable, {})
     257        self.assertEqual(provider.get_child_at_index(0).GetName(), '[0]')
     258        self.assertNotEqual(provider.get_child_at_index(0).GetValueAsUnsigned(), 0)
     259        self.assertEqual(provider.get_child_at_index(1).GetName(), '[1]')
     260        self.assertEqual(provider.get_child_at_index(1).GetValue(), 'true')
Note: See TracChangeset for help on using the changeset viewer.