Modified: trunk/Source/WTF/ChangeLog (274462 => 274463)
--- trunk/Source/WTF/ChangeLog 2021-03-16 03:24:06 UTC (rev 274462)
+++ trunk/Source/WTF/ChangeLog 2021-03-16 03:54:53 UTC (rev 274463)
@@ -1,3 +1,12 @@
+2021-03-15 Alex Christensen <[email protected]>
+
+ REGRESSION: (r255611) [ Mac ] 3 lldb tests failing related to HashMap
+ https://bugs.webkit.org/show_bug.cgi?id=207204
+
+ Reviewed by Simon Fraser.
+
+ * wtf/HashTable.h:
+
2021-03-15 Chris Dumez <[email protected]>
RunLoop::isMain() should not need to do any heap allocations
Modified: trunk/Source/WTF/wtf/HashTable.h (274462 => 274463)
--- trunk/Source/WTF/wtf/HashTable.h 2021-03-16 03:24:06 UTC (rev 274462)
+++ trunk/Source/WTF/wtf/HashTable.h 2021-03-16 03:54:53 UTC (rev 274463)
@@ -589,7 +589,10 @@
unsigned deletedCount() const { ASSERT(m_table); return reinterpret_cast_ptr<unsigned*>(m_table)[deletedCountOffset]; }
void setDeletedCount(unsigned count) const { ASSERT(m_table); reinterpret_cast_ptr<unsigned*>(m_table)[deletedCountOffset] = count; }
- ValueType* m_table { nullptr };
+ union {
+ ValueType* m_table { nullptr };
+ unsigned* m_tableForLLDB;
+ };
#if CHECK_HASHTABLE_ITERATORS
public:
Modified: trunk/Tools/ChangeLog (274462 => 274463)
--- trunk/Tools/ChangeLog 2021-03-16 03:24:06 UTC (rev 274462)
+++ trunk/Tools/ChangeLog 2021-03-16 03:54:53 UTC (rev 274463)
@@ -1,3 +1,45 @@
+2021-03-15 Alex Christensen <[email protected]>
+
+ REGRESSION: (r255611) [ Mac ] 3 lldb tests failing related to HashMap
+ https://bugs.webkit.org/show_bug.cgi?id=207204
+
+ Reviewed by Simon Fraser.
+
+ In r255780 I removed WebKit LLDB support for HashTables because the LLDB python API doesn't have a way to
+ do the equivalent of reinterpret_cast. With clever use of a union, I can get a pointer to the table and
+ tell LLDB it is actually a pointer to an unsigned integer array. Then, using pointer->unsigned->pointer
+ transformations I can dereference a negative index. It's gross, but it works and makes the tests pass again.
+
+ * lldb/lldb_webkit.py:
+ (__lldb_init_module):
+ (__lldb_init_module.lldb_webkit):
+ (WTFHashTable_SummaryProvider):
+ (WTFHashMap_SummaryProvider):
+ (WTFHashSet_SummaryProvider):
+ (WTFHashMapProvider):
+ (WTFHashMapProvider.__init__):
+ (WTFHashMapProvider.tableSize):
+ (WTFHashMapProvider.keyCount):
+ (WTFHashSetProvider):
+ (WTFHashSetProvider.__init__):
+ (WTFHashSetProvider.tableSize):
+ (WTFHashSetProvider.keyCount):
+ (WTFHashTableProvider):
+ (WTFHashTableProvider.__init__):
+ (WTFHashTableProvider.metadataWithIndex):
+ (WTFHashTableProvider.tableSize):
+ (WTFHashTableProvider.keyCount):
+ (WTFHashTableProvider.num_children):
+ (WTFHashTableProvider.get_child_index):
+ (WTFHashTableProvider.get_child_at_index):
+ (WTFHashTableProvider.update):
+ (WTFHashTableProvider.has_children):
+ * lldb/lldb_webkit_unittest.py:
+ (TestSummaryProviders):
+ (TestSummaryProviders.serial_test_WTFHashMap_tablesize_and_size):
+ (TestSummaryProviders.serial_test_WTFHashMap_of_vectors_tablesize_and_size):
+ (TestSummaryProviders.serial_test_WTFHashSet_tablesize_and_size):
+
2021-03-15 Jer Noble <[email protected]>
[WK2] Can get stuck in fullscreen mode if node is removed prior to receiving willEnterFullscreen()
Modified: trunk/Tools/lldb/lldb_webkit.py (274462 => 274463)
--- trunk/Tools/lldb/lldb_webkit.py 2021-03-16 03:24:06 UTC (rev 274462)
+++ trunk/Tools/lldb/lldb_webkit.py 2021-03-16 03:54:53 UTC (rev 274463)
@@ -62,6 +62,9 @@
debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFStringView_SummaryProvider WTF::StringView')
debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFAtomString_SummaryProvider WTF::AtomString')
debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFVector_SummaryProvider -x "^WTF::Vector<.+>$"')
+ debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFHashTable_SummaryProvider -x "^WTF::HashTable<.+>$"')
+ debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFHashMap_SummaryProvider -x "^WTF::HashMap<.+>$"')
+ debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFHashSet_SummaryProvider -x "^WTF::HashSet<.+>$"')
debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFMediaTime_SummaryProvider WTF::MediaTime')
debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFOptionSet_SummaryProvider -x "^WTF::OptionSet<.+>$"')
debugger.HandleCommand('type summary add --expand -F lldb_webkit.WTFCompactPointerTuple_SummaryProvider -x "^WTF::CompactPointerTuple<.+,.+>$"')
@@ -90,6 +93,7 @@
# synthetic types (see <https://lldb.llvm.org/varformats.html>)
debugger.HandleCommand('type synthetic add -x "^WTF::Vector<.+>$" --python-class lldb_webkit.WTFVectorProvider')
+ debugger.HandleCommand('type synthetic add -x "^WTF::HashTable<.+>$" --python-class lldb_webkit.WTFHashTableProvider')
debugger.HandleCommand('type synthetic add -x "^WTF::OptionSet<.+>$" --python-class lldb_webkit.WTFOptionSetProvider')
debugger.HandleCommand('type synthetic add -x "^WTF::CompactPointerTuple<.+,.+>$" --python-class lldb_webkit.WTFCompactPointerTupleProvider')
@@ -145,6 +149,21 @@
return "{ size = %d, capacity = %d }" % (provider.size, provider.capacity)
+def WTFHashTable_SummaryProvider(valobj, dict):
+ provider = WTFHashTableProvider(valobj, dict)
+ return "{ tableSize = %d, keyCount = %d }" % (provider.tableSize(), provider.keyCount())
+
+
+def WTFHashMap_SummaryProvider(valobj, dict):
+ provider = WTFHashMapProvider(valobj, dict)
+ return "{ tableSize = %d, keyCount = %d }" % (provider.tableSize(), provider.keyCount())
+
+
+def WTFHashSet_SummaryProvider(valobj, dict):
+ provider = WTFHashSetProvider(valobj, dict)
+ return "{ tableSize = %d, keyCount = %d }" % (provider.tableSize(), provider.keyCount())
+
+
def WTFOptionSet_SummaryProvider(valobj, dict):
provider = WTFOptionSetProvider(valobj, dict)
return "{ size = %d }" % provider.size
@@ -991,6 +1010,78 @@
return True
+class WTFHashMapProvider:
+ def __init__(self, valobj, internal_dict):
+ self.valobj = valobj
+ impl_ptr = self.valobj.GetChildMemberWithName('m_impl')
+ self._hash_table_provider = WTFHashTableProvider(impl_ptr, dict)
+
+ def tableSize(self):
+ return self._hash_table_provider.tableSize()
+
+ def keyCount(self):
+ return self._hash_table_provider.keyCount()
+
+
+class WTFHashSetProvider:
+ def __init__(self, valobj, internal_dict):
+ self.valobj = valobj
+ impl_ptr = self.valobj.GetChildMemberWithName('m_impl')
+ self._hash_table_provider = WTFHashTableProvider(impl_ptr, dict)
+
+ def tableSize(self):
+ return self._hash_table_provider.tableSize()
+
+ def keyCount(self):
+ return self._hash_table_provider.keyCount()
+
+
+class WTFHashTableProvider:
+ def __init__(self, valobj, internal_dict):
+ self.valobj = valobj
+ self.update()
+
+ def metadataWithIndex(self, index):
+ table_pointer = self.valobj.GetChildMemberWithName('m_tableForLLDB')
+ metadata_pointer = table_pointer.GetValueAsUnsigned() + 4 * index
+ byte_order = self.valobj.GetTarget().GetByteOrder()
+ address_byte_size = self.valobj.GetTarget().GetAddressByteSize()
+ pointer_data = lldb.SBData.CreateDataFromUInt64Array(byte_order, address_byte_size, [metadata_pointer])
+ return self.valobj.CreateValueFromData('[0]', pointer_data, table_pointer.GetType()).Dereference().GetValueAsUnsigned()
+
+ def tableSize(self):
+ return self.metadataWithIndex(-1)
+
+ def keyCount(self):
+ return self.metadataWithIndex(-3)
+
+ # Synthetic children provider methods.
+ def num_children(self):
+ return self.tableSize() + 1
+
+ def get_child_index(self, name):
+ if name == "m_table":
+ return self.tableSize()
+ else:
+ return int(name.lstrip('[').rstrip(']'))
+
+ def get_child_at_index(self, index):
+ if index == self.tableSize():
+ return self.valobj.GetChildMemberWithName('m_table')
+ elif index < self.tableSize():
+ table = self.valobj.GetChildMemberWithName('m_table')
+ return table.CreateChildAtOffset('[' + str(index) + ']', index * self.data_size, self.data_type)
+ else:
+ return None
+
+ def update(self):
+ self.data_type = self.valobj.GetType().GetTemplateArgumentType(1)
+ self.data_size = self.data_type.GetByteSize()
+
+ def has_children(self):
+ return True
+
+
class WTFMediaTimeProvider:
def __init__(self, valobj, internal_dict):
self.valobj = valobj
Modified: trunk/Tools/lldb/lldb_webkit_unittest.py (274462 => 274463)
--- trunk/Tools/lldb/lldb_webkit_unittest.py 2021-03-16 03:24:06 UTC (rev 274462)
+++ trunk/Tools/lldb/lldb_webkit_unittest.py 2021-03-16 03:54:53 UTC (rev 274463)
@@ -151,6 +151,23 @@
summary = lldb_webkit.WTFVector_SummaryProvider(variable, {})
self.assertEqual(summary, "{ size = 1, capacity = 16 }")
+ # MARK: WTFHashMap_SummaryProvider and WTFHashSet_SummaryProvider test cases
+
+ def serial_test_WTFHashMap_tablesize_and_size(self):
+ variable = self._sbFrame.FindVariable('hashMapOfInts')
+ summary = lldb_webkit.WTFHashMap_SummaryProvider(variable, {})
+ self.assertEqual(summary, "{ tableSize = 8, keyCount = 2 }")
+
+ def serial_test_WTFHashMap_of_vectors_tablesize_and_size(self):
+ variable = self._sbFrame.FindVariable('hashMapOfVectors')
+ summary = lldb_webkit.WTFHashMap_SummaryProvider(variable, {})
+ self.assertEqual(summary, "{ tableSize = 8, keyCount = 1 }")
+
+ def serial_test_WTFHashSet_tablesize_and_size(self):
+ variable = self._sbFrame.FindVariable('hashSetOfInts')
+ summary = lldb_webkit.WTFHashSet_SummaryProvider(variable, {})
+ self.assertEqual(summary, "{ tableSize = 8, keyCount = 1 }")
+
# MARK: WTFOptionSet_SummaryProvider test cases
def serial_test_WTFOptionSet_SummaryProvider_empty(self):
