Tools/Scripts/dump-message-log

#!/usr/bin/env python3
"""
LLDB script to dump the contents of WebKit's IPC message log for testing.

Usage in LLDB:
    (lldb) command script import Tools/Scripts/dump-message-log
    (lldb) dump_message_log

The script dumps messages in reverse chronological order (most recent first),
starting from the last written position and stopping when it encounters either:
- An Invalid message name (indicating unwritten slots)
- A full traversal of the buffer (wrapping back to start)
"""

import lldb
import re

def dump_message_log(debugger, command, result, internal_dict):
    """Dumps the contents of IPC::gMessageLog in reverse chronological order"""

    target = debugger.GetSelectedTarget()
    if not target or not target.IsValid():
        print("Error: No valid target selected", file=result)
        return

    process = target.GetProcess()
    if not process or not process.IsValid():
        print("Error: No valid process attached", file=result)
        return

    # Find the global message log
    buffer_var = target.FindFirstGlobalVariable("IPC::gMessageLog")
    if not buffer_var or not buffer_var.IsValid():
        print("Error: Could not find IPC::gMessageLog", file=result)
        print("Make sure the process is using a build with the message log compiled in.", file=result)
        return

    # Get capacity from the type name (e.g., MessageLog<256>)
    buffer_type = buffer_var.GetType()
    type_name = buffer_type.GetName()
    match = re.search(r'MessageLog<(\d+)>', type_name)
    if not match:
        print(f"Error: Could not parse capacity from type name: {type_name}", file=result)
        return

    capacity = int(match.group(1))

    # Get m_index (std::atomic<size_t>)
    # Note: m_index is a private member, but LLDB can access it for debugging
    m_index_var = buffer_var.GetChildMemberWithName("m_index")
    if not m_index_var or not m_index_var.IsValid():
        print("Error: Could not access m_index member", file=result)
        return

    # Extract the actual value from std::atomic
    # Try different member names used by different standard library implementations
    index_value = None
    for atomic_member in ["_M_i", "__a_", "_Value", "Value", "__a"]:
        atomic_storage = m_index_var.GetChildMemberWithName(atomic_member)
        if atomic_storage and atomic_storage.IsValid():
            index_value = atomic_storage.GetValueAsUnsigned()
            break

    if index_value is None:
        # Fallback: try to get value directly
        index_value = m_index_var.GetValueAsUnsigned()
        if index_value == 0xFFFFFFFFFFFFFFFF:  # Likely failed
            print("Error: Could not read m_index value", file=result)
            return

    # Get m_buffer (std::array)
    # Note: m_buffer is a private member, but LLDB can access it for debugging
    m_buffer_var = buffer_var.GetChildMemberWithName("m_buffer")
    if not m_buffer_var or not m_buffer_var.IsValid():
        print("Error: Could not access m_buffer member", file=result)
        return

    # std::array may wrap the actual array in an __elems_ or similar member
    # Try to access it, otherwise use m_buffer_var directly
    elems_var = m_buffer_var.GetChildMemberWithName("__elems_")
    if elems_var and elems_var.IsValid():
        m_buffer_var = elems_var

    # Try to find IPC::MessageName::Invalid
    message_name_type = target.FindFirstType("IPC::MessageName")
    message_name_invalid = None
    if message_name_type and message_name_type.IsValid():
        enum_members = message_name_type.GetEnumMembers()
        for i in range(enum_members.GetSize()):
            member = enum_members.GetTypeEnumMemberAtIndex(i)
            if member.GetName() == "Invalid":
                message_name_invalid = member.GetValueAsUnsigned()
                break

    # Print header
    print("\n" + "=" * 80, file=result)
    print(f"WebKit IPC Message Log Dump (Capacity: {capacity})", file=result)
    print("=" * 80, file=result)
    print("\nMessages (most recent first):\n", file=result)

    # Calculate the last written index
    # m_index points to the NEXT position to write, so last written is (m_index - 1) % capacity
    if index_value == 0:
        last_written = capacity - 1
    else:
        last_written = (index_value - 1) % capacity

    current_index = last_written
    messages_found = 0

    for i in range(capacity):
        # Get array element at current_index
        element = m_buffer_var.GetChildAtIndex(current_index)
        if not element or not element.IsValid():
            print(f"Warning: Could not read buffer[{current_index}]", file=result)
            break

        message_value = element.GetValueAsUnsigned()

        # Stop if we encounter Invalid
        if message_name_invalid is not None and message_value == message_name_invalid:
            print(f"\n[Stopped at Invalid message after {messages_found} messages (at buffer[{current_index}])]", file=result)
            break

        # Try to get the symbolic name
        message_name_str = element.GetValue()
        if message_name_str:
            # Clean up the format (e.g., "IPCTester_EmptyMessage" instead of full enum path)
            message_name_str = message_name_str.replace("IPC::MessageName::", "")
            # Display "Invalid" instead of "Count" since they're semantically invalid messages
            if message_name_str == "Count":
                message_name_str = "Invalid"
        else:
            message_name_str = f"<value={message_value}>"

        print(f"{messages_found}. {message_name_str}", file=result)

        messages_found += 1

        # Move to previous index (wrap around)
        if current_index == 0:
            current_index = capacity - 1
        else:
            current_index -= 1

    print("\n" + "=" * 80 + "\n", file=result)

def __lldb_init_module(debugger, internal_dict):
    """Register the command when the script is loaded"""
    debugger.HandleCommand(
        'command script add -f dump_message_log.dump_message_log dump_message_log'
    )
    print('The "dump_message_log" command has been installed.')

if __name__ == "__main__":
    print("This script is intended to be used within LLDB, not run directly.")
    print("\nUsage in LLDB:")
    print("    (lldb) command script import Tools/Scripts/dump-message-log")
    print("    (lldb) dump_message_log")