Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/lldb/examples/summaries/cocoa/CFArray.py

@@ -0,0 +1,233 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSArray
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# much less functional than the other two cases below
+# just runs code to get to the count and then returns
+# no children
+
+
+class NSArrayKVC_SynthProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, dict, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        num_children_vo = self.valobj.CreateValueFromExpression(
+            "count", "(int)[" + stream.GetData() + " count]")
+        if num_children_vo.IsValid():
+            return num_children_vo.GetValueAsUnsigned(0)
+        return "<variable is not NSArray>"
+
+# much less functional than the other two cases below
+# just runs code to get to the count and then returns
+# no children
+
+
+class NSArrayCF_SynthProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, dict, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not (self.sys_params.types_cache.ulong):
+            self.sys_params.types_cache.ulong = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        num_children_vo = self.valobj.CreateChildAtOffset(
+            "count", self.sys_params.cfruntime_size, self.sys_params.types_cache.ulong)
+        return num_children_vo.GetValueAsUnsigned(0)
+
+
+class NSArrayI_SynthProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, dict, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.long):
+            self.sys_params.types_cache.long = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeLong)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # skip the isa pointer and get at the size
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        count = self.valobj.CreateChildAtOffset(
+            "count",
+            self.sys_params.pointer_size,
+            self.sys_params.types_cache.long)
+        return count.GetValueAsUnsigned(0)
+
+
+class NSArrayM_SynthProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, dict, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.long):
+            self.sys_params.types_cache.long = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeLong)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # skip the isa pointer and get at the size
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        count = self.valobj.CreateChildAtOffset(
+            "count",
+            self.sys_params.pointer_size,
+            self.sys_params.types_cache.long)
+        return count.GetValueAsUnsigned(0)
+
+# this is the actual synth provider, but is just a wrapper that checks
+# whether valobj is an instance of __NSArrayI or __NSArrayM and sets up an
+# appropriate backend layer to do the computations
+
+
+class NSArray_SynthProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, dict):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.adjust_for_architecture()
+        self.error = False
+        self.wrapper = self.make_wrapper()
+        self.invalid = (self.wrapper is None)
+
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.wrapper is None:
+            return 0
+        return self.wrapper.num_children()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.wrapper is None:
+            return
+        self.wrapper.update()
+
+    # this code acts as our defense against NULL and uninitialized
+    # NSArray pointers, which makes it much longer than it would be otherwise
+    def make_wrapper(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.valobj.GetValueAsUnsigned() == 0:
+            self.error = True
+            return lldb.runtime.objc.objc_runtime.InvalidPointer_Description(
+                True)
+        else:
+            global statistics
+            class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+                self.valobj, statistics)
+            if wrapper:
+                self.error = True
+                return wrapper
+
+        name_string = class_data.class_name()
+
+        logger >> "Class name is " + str(name_string)
+
+        if name_string == '__NSArrayI':
+            wrapper = NSArrayI_SynthProvider(
+                self.valobj, dict, class_data.sys_params)
+            statistics.metric_hit('code_notrun', self.valobj.GetName())
+        elif name_string == '__NSArrayM':
+            wrapper = NSArrayM_SynthProvider(
+                self.valobj, dict, class_data.sys_params)
+            statistics.metric_hit('code_notrun', self.valobj.GetName())
+        elif name_string == '__NSCFArray':
+            wrapper = NSArrayCF_SynthProvider(
+                self.valobj, dict, class_data.sys_params)
+            statistics.metric_hit('code_notrun', self.valobj.GetName())
+        else:
+            wrapper = NSArrayKVC_SynthProvider(
+                self.valobj, dict, class_data.sys_params)
+            statistics.metric_hit(
+                'unknown_class', str(
+                    self.valobj.GetName()) + " seen as " + name_string)
+        return wrapper
+
+
+def CFArray_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = NSArray_SynthProvider(valobj, dict)
+    if not provider.invalid:
+        if provider.error:
+            return provider.wrapper.message()
+        try:
+            summary = int(provider.num_children())
+        except:
+            summary = None
+        logger >> "provider gave me " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSArray>'
+        elif isinstance(summary, basestring):
+            pass
+        else:
+            # we format it like it were a CFString to make it look the same as
+            # the summary from Xcode
+            summary = '@"' + str(summary) + \
+                (" objects" if summary != 1 else " object") + '"'
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F CFArray.CFArray_SummaryProvider NSArray CFArrayRef CFMutableArrayRef")

external/llvm-project/lldb/examples/summaries/cocoa/CFBag.py

@@ -0,0 +1,163 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for CFBag
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the length for an CFBag, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class CFBagRef_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # 12 bytes on i386
+    # 20 bytes on x64
+    # most probably 2 pointers and 4 bytes of data
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.sys_params.is_64_bit:
+            return 20
+        else:
+            return 12
+
+    def length(self):
+        logger = lldb.formatters.Logger.Logger()
+        size = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        return size.GetValueAsUnsigned(0)
+
+
+class CFBagUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def length(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        num_children_vo = self.valobj.CreateValueFromExpression(
+            "count", "(int)CFBagGetCount(" + stream.GetData() + " )")
+        if num_children_vo.IsValid():
+            return num_children_vo.GetValueAsUnsigned(0)
+        return "<variable is not CFBag>"
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    actual_name = name_string
+
+    logger >> "name string got was " + \
+        str(name_string) + " but actual name is " + str(actual_name)
+
+    if class_data.is_cftype():
+        # CFBag does not expose an actual NSWrapper type, so we have to check that this is
+        # an NSCFType and then check we are a pointer-to __CFBag
+        valobj_type = valobj.GetType()
+        if valobj_type.IsValid() and valobj_type.IsPointerType():
+            valobj_type = valobj_type.GetPointeeType()
+            if valobj_type.IsValid():
+                actual_name = valobj_type.GetName()
+        if actual_name == '__CFBag' or \
+           actual_name == 'const struct __CFBag':
+            wrapper = CFBagRef_SummaryProvider(valobj, class_data.sys_params)
+            statistics.metric_hit('code_notrun', valobj)
+            return wrapper
+    wrapper = CFBagUnknown_SummaryProvider(valobj, class_data.sys_params)
+    statistics.metric_hit(
+        'unknown_class',
+        valobj.GetName() +
+        " seen as " +
+        actual_name)
+    return wrapper
+
+
+def CFBag_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.length()
+        except:
+            summary = None
+        logger >> "summary got from provider: " + str(summary)
+        # for some reason, one needs to clear some bits for the count
+        # to be correct when using CF(Mutable)BagRef on x64
+        # the bit mask was derived through experimentation
+        # (if counts start looking weird, then most probably
+        #  the mask needs to be changed)
+        if summary is None:
+            summary = '<variable is not CFBag>'
+        elif isinstance(summary, basestring):
+            pass
+        else:
+            if provider.sys_params.is_64_bit:
+                summary = summary & ~0x1fff000000000000
+            if summary == 1:
+                summary = '@"1 value"'
+            else:
+                summary = '@"' + str(summary) + ' values"'
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F CFBag.CFBag_SummaryProvider CFBagRef CFMutableBagRef")

external/llvm-project/lldb/examples/summaries/cocoa/CFBinaryHeap.py

@@ -0,0 +1,161 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for CFBinaryHeap
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the length for an CFBinaryHeap, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class CFBinaryHeapRef_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # 8 bytes on i386
+    # 16 bytes on x64
+    # most probably 2 pointers
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return 2 * self.sys_params.pointer_size
+
+    def length(self):
+        logger = lldb.formatters.Logger.Logger()
+        size = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        return size.GetValueAsUnsigned(0)
+
+
+class CFBinaryHeapUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def length(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        num_children_vo = self.valobj.CreateValueFromExpression(
+            "count", "(int)CFBinaryHeapGetCount(" + stream.GetData() + " )")
+        if num_children_vo.IsValid():
+            return num_children_vo.GetValueAsUnsigned(0)
+        return '<variable is not CFBinaryHeap>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    actual_name = class_data.class_name()
+
+    logger >> "name string got was " + \
+        str(name_string) + " but actual name is " + str(actual_name)
+
+    if class_data.is_cftype():
+        # CFBinaryHeap does not expose an actual NSWrapper type, so we have to check that this is
+        # an NSCFType and then check we are a pointer-to CFBinaryHeap
+        valobj_type = valobj.GetType()
+        if valobj_type.IsValid() and valobj_type.IsPointerType():
+            valobj_type = valobj_type.GetPointeeType()
+            if valobj_type.IsValid():
+                actual_name = valobj_type.GetName()
+        if actual_name == '__CFBinaryHeap':
+            wrapper = CFBinaryHeapRef_SummaryProvider(
+                valobj, class_data.sys_params)
+            statistics.metric_hit('code_notrun', valobj)
+            return wrapper
+    wrapper = CFBinaryHeapUnknown_SummaryProvider(
+        valobj, class_data.sys_params)
+    statistics.metric_hit(
+        'unknown_class',
+        valobj.GetName() +
+        " seen as " +
+        name_string)
+    return wrapper
+
+
+def CFBinaryHeap_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.length()
+        except:
+            summary = None
+        logger >> "summary got from provider: " + str(summary)
+        # for some reason, one needs to clear some bits for the count
+        # to be correct when using CF(Mutable)BagRef on x64
+        # the bit mask was derived through experimentation
+        # (if counts start looking weird, then most probably
+        #  the mask needs to be changed)
+        if summary is None:
+            summary = '<variable is not CFBinaryHeap>'
+        elif isinstance(summary, basestring):
+            pass
+        else:
+            if provider.sys_params.is_64_bit:
+                summary = summary & ~0x1fff000000000000
+            if summary == 1:
+                return '@"1 item"'
+            else:
+                summary = '@"' + str(summary) + ' items"'
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F CFBinaryHeap.CFBinaryHeap_SummaryProvider CFBinaryHeapRef")

external/llvm-project/lldb/examples/summaries/cocoa/CFBitVector.py

@@ -0,0 +1,206 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# summary provider for CF(Mutable)BitVector
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+# first define some utility functions
+
+
+def byte_index(abs_pos):
+    logger = lldb.formatters.Logger.Logger()
+    return abs_pos / 8
+
+
+def bit_index(abs_pos):
+    logger = lldb.formatters.Logger.Logger()
+    return abs_pos & 7
+
+
+def get_bit(byte, index):
+    logger = lldb.formatters.Logger.Logger()
+    if index < 0 or index > 7:
+        return None
+    return (byte >> (7 - index)) & 1
+
+
+def grab_array_item_data(pointer, index):
+    logger = lldb.formatters.Logger.Logger()
+    return pointer.GetPointeeData(index, 1)
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but a summary for a CF*BitVector, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class CFBitVectorKnown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.uiint_size = self.sys_params.types_cache.NSUInteger.GetByteSize()
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        if not(self.sys_params.types_cache.charptr):
+            self.sys_params.types_cache.charptr = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeChar).GetPointerType()
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # we skip the CFRuntimeBase
+    # then the next CFIndex is the count
+    # then we skip another CFIndex and then we get at a byte array
+    # that wraps the individual bits
+
+    def contents(self):
+        logger = lldb.formatters.Logger.Logger()
+        count_vo = self.valobj.CreateChildAtOffset(
+            "count",
+            self.sys_params.cfruntime_size,
+            self.sys_params.types_cache.NSUInteger)
+        count = count_vo.GetValueAsUnsigned(0)
+        if count == 0:
+            return '(empty)'
+
+        array_vo = self.valobj.CreateChildAtOffset(
+            "data",
+            self.sys_params.cfruntime_size +
+            2 *
+            self.uiint_size,
+            self.sys_params.types_cache.charptr)
+
+        data_list = []
+        cur_byte_pos = None
+        for i in range(0, count):
+            if cur_byte_pos is None:
+                cur_byte_pos = byte_index(i)
+                cur_byte = grab_array_item_data(array_vo, cur_byte_pos)
+                cur_byte_val = cur_byte.uint8[0]
+            else:
+                byte_pos = byte_index(i)
+                # do not fetch the pointee data every single time through
+                if byte_pos != cur_byte_pos:
+                    cur_byte_pos = byte_pos
+                    cur_byte = grab_array_item_data(array_vo, cur_byte_pos)
+                    cur_byte_val = cur_byte.uint8[0]
+            bit = get_bit(cur_byte_val, bit_index(i))
+            if (i % 4) == 0:
+                data_list.append(' ')
+            if bit == 1:
+                data_list.append('1')
+            else:
+                data_list.append('0')
+        return ''.join(data_list)
+
+
+class CFBitVectorUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def contents(self):
+        logger = lldb.formatters.Logger.Logger()
+        return '<unable to summarize this CFBitVector>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    actual_name = name_string
+
+    logger >> "name string got was " + \
+        str(name_string) + " but actual name is " + str(actual_name)
+
+    if class_data.is_cftype():
+        # CFBitVectorRef does not expose an actual NSWrapper type, so we have to check that this is
+        # an NSCFType and then check we are a pointer-to CFBitVectorRef
+        valobj_type = valobj.GetType()
+        if valobj_type.IsValid() and valobj_type.IsPointerType():
+            valobj_type = valobj_type.GetPointeeType()
+            if valobj_type.IsValid():
+                actual_name = valobj_type.GetName()
+        if actual_name == '__CFBitVector' or actual_name == '__CFMutableBitVector':
+            wrapper = CFBitVectorKnown_SummaryProvider(
+                valobj, class_data.sys_params)
+            statistics.metric_hit('code_notrun', valobj)
+        else:
+            wrapper = CFBitVectorUnknown_SummaryProvider(
+                valobj, class_data.sys_params)
+            print actual_name
+    else:
+        wrapper = CFBitVectorUnknown_SummaryProvider(
+            valobj, class_data.sys_params)
+        print name_string
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def CFBitVector_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.contents()
+        except:
+            summary = None
+        logger >> "summary got from provider: " + str(summary)
+        if summary is None or summary == '':
+            summary = '<variable is not CFBitVector>'
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F CFBitVector.CFBitVector_SummaryProvider CFBitVectorRef CFMutableBitVectorRef")

external/llvm-project/lldb/examples/summaries/cocoa/CFDictionary.py

@@ -0,0 +1,263 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSDictionary
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the count for an NSDictionary, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSCFDictionary_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # empirically determined on both 32 and 64bit desktop Mac OS X
+    # probably boils down to 2 pointers and 4 bytes of data, but
+    # the description of __CFDictionary is not readily available so most
+    # of this is guesswork, plain and simple
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.sys_params.is_64_bit:
+            return 20
+        else:
+            return 12
+
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        num_children_vo = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        return num_children_vo.GetValueAsUnsigned(0)
+
+
+class NSDictionaryI_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # we just need to skip the ISA and the count immediately follows
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        num_children_vo = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        value = num_children_vo.GetValueAsUnsigned(0)
+        if value is not None:
+            # the MS6bits on immutable dictionaries seem to be taken by the LSB of capacity
+            # not sure if it is a bug or some weird sort of feature, but masking that out
+            # gets the count right
+            if self.sys_params.is_64_bit:
+                value = value & ~0xFC00000000000000
+            else:
+                value = value & ~0xFC000000
+        return value
+
+
+class NSDictionaryM_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # we just need to skip the ISA and the count immediately follows
+    def offset(self):
+        return self.sys_params.pointer_size
+
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        num_children_vo = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        value = num_children_vo.GetValueAsUnsigned(0)
+        if value is not None:
+            # the MS6bits on immutable dictionaries seem to be taken by the LSB of capacity
+            # not sure if it is a bug or some weird sort of feature, but masking that out
+            # gets the count right
+            if self.sys_params.is_64_bit:
+                value = value & ~0xFC00000000000000
+            else:
+                value = value & ~0xFC000000
+        return value
+
+
+class NSDictionaryUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        num_children_vo = self.valobj.CreateValueFromExpression(
+            "count", "(int)[" + stream.GetData() + " count]")
+        if num_children_vo.IsValid():
+            return num_children_vo.GetValueAsUnsigned(0)
+        return '<variable is not NSDictionary>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == '__NSCFDictionary':
+        wrapper = NSCFDictionary_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    elif name_string == '__NSDictionaryI':
+        wrapper = NSDictionaryI_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    elif name_string == '__NSDictionaryM':
+        wrapper = NSDictionaryM_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSDictionaryUnknown_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def CFDictionary_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.num_children()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            return '<variable is not NSDictionary>'
+        if isinstance(summary, basestring):
+            return summary
+        return str(summary) + (" key/value pairs" if summary !=
+                               1 else " key/value pair")
+    return 'Summary Unavailable'
+
+
+def CFDictionary_SummaryProvider2(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.num_children()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            summary = '<variable is not CFDictionary>'
+        if isinstance(summary, basestring):
+            return summary
+        else:
+            # needed on OSX Mountain Lion
+            if provider.sys_params.is_64_bit:
+                summary = summary & ~0x0f1f000000000000
+            summary = '@"' + str(summary) + \
+                (' entries"' if summary != 1 else ' entry"')
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F CFDictionary.CFDictionary_SummaryProvider NSDictionary")
+    debugger.HandleCommand(
+        "type summary add -F CFDictionary.CFDictionary_SummaryProvider2 CFDictionaryRef CFMutableDictionaryRef")

external/llvm-project/lldb/examples/summaries/cocoa/CFString.py

@@ -0,0 +1,351 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example synthetic children and summary provider for CFString (and related NSString class)
+# the real code is part of the LLDB core
+import lldb
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.Logger
+
+
+def CFString_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = CFStringSynthProvider(valobj, dict)
+    if not provider.invalid:
+        try:
+            summary = provider.get_child_at_index(
+                provider.get_child_index("content"))
+            if isinstance(summary, lldb.SBValue):
+                summary = summary.GetSummary()
+            else:
+                summary = '"' + summary + '"'
+        except:
+            summary = None
+        if summary is None:
+            summary = '<variable is not NSString>'
+        return '@' + summary
+    return ''
+
+
+def CFAttributedString_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    offset = valobj.GetTarget().GetProcess().GetAddressByteSize()
+    pointee = valobj.GetValueAsUnsigned(0)
+    summary = '<variable is not NSAttributedString>'
+    if pointee is not None and pointee != 0:
+        pointee = pointee + offset
+        child_ptr = valobj.CreateValueFromAddress(
+            "string_ptr", pointee, valobj.GetType())
+        child = child_ptr.CreateValueFromAddress(
+            "string_data",
+            child_ptr.GetValueAsUnsigned(),
+            valobj.GetType()).AddressOf()
+        provider = CFStringSynthProvider(child, dict)
+        if not provider.invalid:
+            try:
+                summary = provider.get_child_at_index(
+                    provider.get_child_index("content")).GetSummary()
+            except:
+                summary = '<variable is not NSAttributedString>'
+    if summary is None:
+        summary = '<variable is not NSAttributedString>'
+    return '@' + summary
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F CFString.CFString_SummaryProvider NSString CFStringRef CFMutableStringRef")
+    debugger.HandleCommand(
+        "type summary add -F CFString.CFAttributedString_SummaryProvider NSAttributedString")
+
+
+class CFStringSynthProvider:
+
+    def __init__(self, valobj, dict):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.update()
+
+    # children other than "content" are for debugging only and must not be
+    # used in production code
+    def num_children(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.invalid:
+            return 0
+        return 6
+
+    def read_unicode(self, pointer, max_len=2048):
+        logger = lldb.formatters.Logger.Logger()
+        process = self.valobj.GetTarget().GetProcess()
+        error = lldb.SBError()
+        pystr = u''
+        # cannot do the read at once because the length value has
+        # a weird encoding. better play it safe here
+        while max_len > 0:
+            content = process.ReadMemory(pointer, 2, error)
+            new_bytes = bytearray(content)
+            b0 = new_bytes[0]
+            b1 = new_bytes[1]
+            pointer = pointer + 2
+            if b0 == 0 and b1 == 0:
+                break
+            # rearrange bytes depending on endianness
+            # (do we really need this or is Cocoa going to
+            #  use Windows-compatible little-endian even
+            #  if the target is big endian?)
+            if self.is_little:
+                value = b1 * 256 + b0
+            else:
+                value = b0 * 256 + b1
+            pystr = pystr + unichr(value)
+            # read max_len unicode values, not max_len bytes
+            max_len = max_len - 1
+        return pystr
+
+    # handle the special case strings
+    # only use the custom code for the tested LP64 case
+    def handle_special(self):
+        logger = lldb.formatters.Logger.Logger()
+        if not self.is_64_bit:
+            # for 32bit targets, use safe ObjC code
+            return self.handle_unicode_string_safe()
+        offset = 12
+        pointer = self.valobj.GetValueAsUnsigned(0) + offset
+        pystr = self.read_unicode(pointer)
+        return self.valobj.CreateValueFromExpression(
+            "content", "(char*)\"" + pystr.encode('utf-8') + "\"")
+
+    # last resort call, use ObjC code to read; the final aim is to
+    # be able to strip this call away entirely and only do the read
+    # ourselves
+    def handle_unicode_string_safe(self):
+        return self.valobj.CreateValueFromExpression(
+            "content", "(char*)\"" + self.valobj.GetObjectDescription() + "\"")
+
+    def handle_unicode_string(self):
+        logger = lldb.formatters.Logger.Logger()
+        # step 1: find offset
+        if self.inline:
+            pointer = self.valobj.GetValueAsUnsigned(
+                0) + self.size_of_cfruntime_base()
+            if not self.explicit:
+                # untested, use the safe code path
+                return self.handle_unicode_string_safe()
+            else:
+                # a full pointer is skipped here before getting to the live
+                # data
+                pointer = pointer + self.pointer_size
+        else:
+            pointer = self.valobj.GetValueAsUnsigned(
+                0) + self.size_of_cfruntime_base()
+            # read 8 bytes here and make an address out of them
+            try:
+                char_type = self.valobj.GetType().GetBasicType(
+                    lldb.eBasicTypeChar).GetPointerType()
+                vopointer = self.valobj.CreateValueFromAddress(
+                    "dummy", pointer, char_type)
+                pointer = vopointer.GetValueAsUnsigned(0)
+            except:
+                return self.valobj.CreateValueFromExpression(
+                    "content", '(char*)"@\"invalid NSString\""')
+        # step 2: read Unicode data at pointer
+        pystr = self.read_unicode(pointer)
+        # step 3: return it
+        return pystr.encode('utf-8')
+
+    def handle_inline_explicit(self):
+        logger = lldb.formatters.Logger.Logger()
+        offset = 3 * self.pointer_size
+        offset = offset + self.valobj.GetValueAsUnsigned(0)
+        return self.valobj.CreateValueFromExpression(
+            "content", "(char*)(" + str(offset) + ")")
+
+    def handle_mutable_string(self):
+        logger = lldb.formatters.Logger.Logger()
+        offset = 2 * self.pointer_size
+        data = self.valobj.CreateChildAtOffset(
+            "content", offset, self.valobj.GetType().GetBasicType(
+                lldb.eBasicTypeChar).GetPointerType())
+        data_value = data.GetValueAsUnsigned(0)
+        if self.explicit and self.unicode:
+            return self.read_unicode(data_value).encode('utf-8')
+        else:
+            data_value = data_value + 1
+            return self.valobj.CreateValueFromExpression(
+                "content", "(char*)(" + str(data_value) + ")")
+
+    def handle_UTF8_inline(self):
+        logger = lldb.formatters.Logger.Logger()
+        offset = self.valobj.GetValueAsUnsigned(
+            0) + self.size_of_cfruntime_base()
+        if not self.explicit:
+            offset = offset + 1
+        return self.valobj.CreateValueFromAddress(
+            "content", offset, self.valobj.GetType().GetBasicType(
+                lldb.eBasicTypeChar)).AddressOf()
+
+    def handle_UTF8_not_inline(self):
+        logger = lldb.formatters.Logger.Logger()
+        offset = self.size_of_cfruntime_base()
+        return self.valobj.CreateChildAtOffset(
+            "content", offset, self.valobj.GetType().GetBasicType(
+                lldb.eBasicTypeChar).GetPointerType())
+
+    def get_child_at_index(self, index):
+        logger = lldb.formatters.Logger.Logger()
+        logger >> "Querying for child [" + str(index) + "]"
+        if index == 0:
+            return self.valobj.CreateValueFromExpression(
+                "mutable", str(int(self.mutable)))
+        if index == 1:
+            return self.valobj.CreateValueFromExpression("inline",
+                                                         str(int(self.inline)))
+        if index == 2:
+            return self.valobj.CreateValueFromExpression(
+                "explicit", str(int(self.explicit)))
+        if index == 3:
+            return self.valobj.CreateValueFromExpression(
+                "unicode", str(int(self.unicode)))
+        if index == 4:
+            return self.valobj.CreateValueFromExpression(
+                "special", str(int(self.special)))
+        if index == 5:
+            # we are handling the several possible combinations of flags.
+            # for each known combination we have a function that knows how to
+            # go fetch the data from memory instead of running code. if a string is not
+            # correctly displayed, one should start by finding a combination of flags that
+            # makes it different from these known cases, and provide a new reader function
+            # if this is not possible, a new flag might have to be made up (like the "special" flag
+            # below, which is not a real flag in CFString), or alternatively one might need to use
+            # the ObjC runtime helper to detect the new class and deal with it accordingly
+            # print 'mutable = ' + str(self.mutable)
+            # print 'inline = ' + str(self.inline)
+            # print 'explicit = ' + str(self.explicit)
+            # print 'unicode = ' + str(self.unicode)
+            # print 'special = ' + str(self.special)
+            if self.mutable:
+                return self.handle_mutable_string()
+            elif self.inline and self.explicit and \
+                    self.unicode == False and self.special == False and \
+                    self.mutable == False:
+                return self.handle_inline_explicit()
+            elif self.unicode:
+                return self.handle_unicode_string()
+            elif self.special:
+                return self.handle_special()
+            elif self.inline:
+                return self.handle_UTF8_inline()
+            else:
+                return self.handle_UTF8_not_inline()
+
+    def get_child_index(self, name):
+        logger = lldb.formatters.Logger.Logger()
+        logger >> "Querying for child ['" + str(name) + "']"
+        if name == "content":
+            return self.num_children() - 1
+        if name == "mutable":
+            return 0
+        if name == "inline":
+            return 1
+        if name == "explicit":
+            return 2
+        if name == "unicode":
+            return 3
+        if name == "special":
+            return 4
+
+    # CFRuntimeBase is defined as having an additional
+    # 4 bytes (padding?) on LP64 architectures
+    # to get its size we add up sizeof(pointer)+4
+    # and then add 4 more bytes if we are on a 64bit system
+    def size_of_cfruntime_base(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.pointer_size + 4 + (4 if self.is_64_bit else 0)
+
+    # the info bits are part of the CFRuntimeBase structure
+    # to get at them we have to skip a uintptr_t and then get
+    # at the least-significant byte of a 4 byte array. If we are
+    # on big-endian this means going to byte 3, if we are on
+    # little endian (OSX & iOS), this means reading byte 0
+    def offset_of_info_bits(self):
+        logger = lldb.formatters.Logger.Logger()
+        offset = self.pointer_size
+        if not self.is_little:
+            offset = offset + 3
+        return offset
+
+    def read_info_bits(self):
+        logger = lldb.formatters.Logger.Logger()
+        cfinfo = self.valobj.CreateChildAtOffset(
+            "cfinfo",
+            self.offset_of_info_bits(),
+            self.valobj.GetType().GetBasicType(
+                lldb.eBasicTypeChar))
+        cfinfo.SetFormat(11)
+        info = cfinfo.GetValue()
+        if info is not None:
+            self.invalid = False
+            return int(info, 0)
+        else:
+            self.invalid = True
+            return None
+
+    # calculating internal flag bits of the CFString object
+    # this stuff is defined and discussed in CFString.c
+    def is_mutable(self):
+        logger = lldb.formatters.Logger.Logger()
+        return (self.info_bits & 1) == 1
+
+    def is_inline(self):
+        logger = lldb.formatters.Logger.Logger()
+        return (self.info_bits & 0x60) == 0
+
+    # this flag's name is ambiguous, it turns out
+    # we must skip a length byte to get at the data
+    # when this flag is False
+    def has_explicit_length(self):
+        logger = lldb.formatters.Logger.Logger()
+        return (self.info_bits & (1 | 4)) != 4
+
+    # probably a subclass of NSString. obtained this from [str pathExtension]
+    # here info_bits = 0 and Unicode data at the start of the padding word
+    # in the long run using the isa value might be safer as a way to identify this
+    # instead of reading the info_bits
+    def is_special_case(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.info_bits == 0
+
+    def is_unicode(self):
+        logger = lldb.formatters.Logger.Logger()
+        return (self.info_bits & 0x10) == 0x10
+
+    # preparing ourselves to read into memory
+    # by adjusting architecture-specific info
+    def adjust_for_architecture(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize()
+        self.is_64_bit = self.pointer_size == 8
+        self.is_little = self.valobj.GetTarget().GetProcess(
+        ).GetByteOrder() == lldb.eByteOrderLittle
+
+    # reading info bits out of the CFString and computing
+    # useful values to get at the real data
+    def compute_flags(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.info_bits = self.read_info_bits()
+        if self.info_bits is None:
+            return
+        self.mutable = self.is_mutable()
+        self.inline = self.is_inline()
+        self.explicit = self.has_explicit_length()
+        self.unicode = self.is_unicode()
+        self.special = self.is_special_case()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+        self.compute_flags()

external/llvm-project/lldb/examples/summaries/cocoa/Class.py

@@ -0,0 +1,22 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+import lldb
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.Logger
+
+
+def Class_Summary(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    runtime = lldb.runtime.objc.objc_runtime.ObjCRuntime.runtime_from_isa(
+        valobj)
+    if runtime is None or not runtime.is_valid():
+        return '<error: unknown Class>'
+    class_data = runtime.read_class_data()
+    if class_data is None or not class_data.is_valid():
+        return '<error: unknown Class>'
+    return class_data.class_name()

external/llvm-project/lldb/examples/summaries/cocoa/Logger.py

@@ -0,0 +1,133 @@
+from __future__ import print_function
+import sys
+import os.path
+import inspect
+
+
+class NopLogger:
+
+    def __init__(self):
+        pass
+
+    def write(self, data):
+        pass
+
+    def flush(self):
+        pass
+
+    def close(self):
+        pass
+
+
+class StdoutLogger:
+
+    def __init__(self):
+        pass
+
+    def write(self, data):
+        print(data)
+
+    def flush(self):
+        pass
+
+    def close(self):
+        pass
+
+
+class FileLogger:
+
+    def __init__(self, name):
+        self.file = None
+        try:
+            name = os.path.abspath(name)
+            self.file = open(name, 'a')
+        except:
+            try:
+                self.file = open('formatters.log', 'a')
+            except:
+                pass
+
+    def write(self, data):
+        if self.file is not None:
+            print(data, file=self.file)
+        else:
+            print(data)
+
+    def flush(self):
+        if self.file is not None:
+            self.file.flush()
+
+    def close(self):
+        if self.file is not None:
+            self.file.close()
+            self.file = None
+
+# to enable logging:
+# define lldb.formatters.Logger._lldb_formatters_debug_level to any number greater than 0
+# if you define it to any value greater than 1, the log will be automatically flushed after each write (slower but should make sure most of the stuff makes it to the log even if we crash)
+# if you define it to any value greater than 2, the calling function's details will automatically be logged (even slower, but provides additional details)
+# if you need the log to go to a file instead of on screen, define
+# lldb.formatters.Logger._lldb_formatters_debug_filename to a valid
+# filename
+
+
+class Logger:
+
+    def __init__(self, autoflush=False, logcaller=False):
+        global _lldb_formatters_debug_level
+        global _lldb_formatters_debug_filename
+        self.autoflush = autoflush
+        want_log = False
+        try:
+            want_log = (_lldb_formatters_debug_level > 0)
+        except:
+            pass
+        if not (want_log):
+            self.impl = NopLogger()
+            return
+        want_file = False
+        try:
+            want_file = (_lldb_formatters_debug_filename is not None and _lldb_formatters_debug_filename !=
+                         '' and _lldb_formatters_debug_filename != 0)
+        except:
+            pass
+        if want_file:
+            self.impl = FileLogger(_lldb_formatters_debug_filename)
+        else:
+            self.impl = StdoutLogger()
+        try:
+            self.autoflush = (_lldb_formatters_debug_level > 1)
+        except:
+            self.autoflush = autoflush
+        want_caller_info = False
+        try:
+            want_caller_info = (_lldb_formatters_debug_level > 2)
+        except:
+            pass
+        if want_caller_info:
+            self._log_caller()
+
+    def _log_caller(self):
+        caller = inspect.stack()[2]
+        try:
+            if caller is not None and len(caller) > 3:
+                self.write('Logging from function ' + str(caller))
+            else:
+                self.write(
+                    'Caller info not available - Required caller logging not possible')
+        finally:
+            del caller  # needed per Python docs to avoid keeping objects alive longer than we care
+
+    def write(self, data):
+        self.impl.write(data)
+        if self.autoflush:
+            self.flush()
+
+    def __rshift__(self, data):
+        self.write(data)
+
+    def flush(self):
+        self.impl.flush()
+
+    def close(self):
+        self.impl.close()

external/llvm-project/lldb/examples/summaries/cocoa/NSBundle.py

@@ -0,0 +1,145 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSBundle
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import NSURL
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but a summary for an NSURL, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSBundleKnown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSString):
+            self.sys_params.types_cache.NSString = self.valobj.GetTarget(
+            ).FindFirstType('NSString').GetPointerType()
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # we need to skip the ISA, plus four other values
+    # that are luckily each a pointer in size
+    # which makes our computation trivial :-)
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return 5 * self.sys_params.pointer_size
+
+    def url_text(self):
+        logger = lldb.formatters.Logger.Logger()
+        global statistics
+        text = self.valobj.CreateChildAtOffset(
+            "text", self.offset(), self.sys_params.types_cache.NSString)
+        my_string = text.GetSummary()
+        if (my_string is None) or (my_string == ''):
+            statistics.metric_hit(
+                'unknown_class', str(
+                    self.valobj.GetName()) + " triggered unknown pointer location")
+            return NSBundleUnknown_SummaryProvider(
+                self.valobj, self.sys_params).url_text()
+        else:
+            statistics.metric_hit('code_notrun', self.valobj)
+            return my_string
+
+
+class NSBundleUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def url_text(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        expr = "(NSString*)[" + stream.GetData() + " bundlePath]"
+        url_text_vo = self.valobj.CreateValueFromExpression("path", expr)
+        if url_text_vo.IsValid():
+            return url_text_vo.GetSummary()
+        return '<variable is not NSBundle>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSBundle':
+        wrapper = NSBundleKnown_SummaryProvider(valobj, class_data.sys_params)
+        # [NSBundle mainBundle] does return an object that is
+        # not correctly filled out for our purposes, so we still
+        # end up having to run code in that case
+        # statistics.metric_hit('code_notrun',valobj)
+    else:
+        wrapper = NSBundleUnknown_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSBundle_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.url_text()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None or summary == '':
+            summary = '<variable is not NSBundle>'
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSBundle.NSBundle_SummaryProvider NSBundle")

external/llvm-project/lldb/examples/summaries/cocoa/NSData.py

@@ -0,0 +1,182 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSData
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the length for an NSData, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSConcreteData_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        logger >> "NSConcreteData_SummaryProvider __init__"
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        self.adjust_for_architecture()
+
+    # one pointer is the ISA
+    # then there are 32 bit worth of flags and other data
+    # however, on 64bit systems these are padded to be a full
+    # machine word long, which means we actually have two pointers
+    # worth of data to skip
+    def offset(self):
+        return 2 * self.sys_params.pointer_size
+
+    def length(self):
+        logger = lldb.formatters.Logger.Logger()
+        logger >> "NSConcreteData_SummaryProvider length"
+        size = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        logger >> str(size)
+        logger >> str(size.GetValueAsUnsigned(0))
+        return size.GetValueAsUnsigned(0)
+
+
+class NSDataUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        logger >> "NSDataUnknown_SummaryProvider __init__"
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        self.adjust_for_architecture()
+
+    def length(self):
+        logger = lldb.formatters.Logger.Logger()
+        logger >> "NSDataUnknown_SummaryProvider length"
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        logger >> stream.GetData()
+        num_children_vo = self.valobj.CreateValueFromExpression(
+            "count", "(int)[" + stream.GetData() + " length]")
+        logger >> "still in after expression: " + str(num_children_vo)
+        if num_children_vo.IsValid():
+            logger >> "wow - expr output is valid: " + \
+                str(num_children_vo.GetValueAsUnsigned())
+            return num_children_vo.GetValueAsUnsigned(0)
+        logger >> "invalid expr output - too bad"
+        return '<variable is not NSData>'
+
+
+def GetSummary_Impl(valobj):
+    global statistics
+    logger = lldb.formatters.Logger.Logger()
+    logger >> "NSData GetSummary_Impl"
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        logger >> "got a wrapper summary - using it"
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name: " + name_string
+    if name_string == 'NSConcreteData' or \
+       name_string == 'NSConcreteMutableData' or \
+       name_string == '__NSCFData':
+        wrapper = NSConcreteData_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSDataUnknown_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSData_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    logger >> "NSData_SummaryProvider"
+    provider = GetSummary_Impl(valobj)
+    logger >> "found a summary provider, it is: " + str(provider)
+    if provider is not None:
+        try:
+            summary = provider.length()
+        except:
+            summary = None
+        logger >> "got a summary: it is " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSData>'
+        elif isinstance(summary, basestring):
+            pass
+        else:
+            if summary == 1:
+                summary = '1 byte'
+            else:
+                summary = str(summary) + ' bytes'
+        return summary
+    return 'Summary Unavailable'
+
+
+def NSData_SummaryProvider2(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    logger >> "NSData_SummaryProvider2"
+    provider = GetSummary_Impl(valobj)
+    logger >> "found a summary provider, it is: " + str(provider)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.length()
+        except:
+            summary = None
+        logger >> "got a summary: it is " + str(summary)
+        if summary is None:
+            summary = '<variable is not CFData>'
+        elif isinstance(summary, basestring):
+            pass
+        else:
+            if summary == 1:
+                summary = '@"1 byte"'
+            else:
+                summary = '@"' + str(summary) + ' bytes"'
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSData.NSData_SummaryProvider NSData")
+    debugger.HandleCommand(
+        "type summary add -F NSData.NSData_SummaryProvider2 CFDataRef CFMutableDataRef")

external/llvm-project/lldb/examples/summaries/cocoa/NSDate.py

@@ -0,0 +1,307 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSDate
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import struct
+import time
+import datetime
+import CFString
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# Python promises to start counting time at midnight on Jan 1st on the epoch year
+# hence, all we need to know is the epoch year
+python_epoch = time.gmtime(0).tm_year
+
+osx_epoch = datetime.date(2001, 1, 1).timetuple()
+
+
+def mkgmtime(t):
+    logger = lldb.formatters.Logger.Logger()
+    return time.mktime(t) - time.timezone
+
+osx_epoch = mkgmtime(osx_epoch)
+
+
+def osx_to_python_time(osx):
+    logger = lldb.formatters.Logger.Logger()
+    if python_epoch <= 2001:
+        return osx + osx_epoch
+    else:
+        return osx - osx_epoch
+
+# represent a struct_time as a string in the format used by Xcode
+
+
+def xcode_format_time(X):
+    logger = lldb.formatters.Logger.Logger()
+    return time.strftime('%Y-%m-%d %H:%M:%S %Z', X)
+
+# represent a count-since-epoch as a string in the format used by Xcode
+
+
+def xcode_format_count(X):
+    logger = lldb.formatters.Logger.Logger()
+    return xcode_format_time(time.localtime(X))
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the summary for NSDate, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSTaggedDate_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, info_bits, data, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+        # NSDate is not using its info_bits for info like NSNumber is
+        # so we need to regroup info_bits and data
+        self.data = ((data << 8) | (info_bits << 4))
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def value(self):
+        logger = lldb.formatters.Logger.Logger()
+        # the value of the date-time object is wrapped into the pointer value
+        # unfortunately, it is made as a time-delta after Jan 1 2001 midnight GMT
+        # while all Python knows about is the "epoch", which is a platform-dependent
+        # year (1970 of *nix) whose Jan 1 at midnight is taken as reference
+        value_double = struct.unpack('d', struct.pack('Q', self.data))[0]
+        if value_double == -63114076800.0:
+            return '0001-12-30 00:00:00 +0000'
+        return xcode_format_count(osx_to_python_time(value_double))
+
+
+class NSUntaggedDate_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not (self.sys_params.types_cache.double):
+            self.sys_params.types_cache.double = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeDouble)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def value(self):
+        logger = lldb.formatters.Logger.Logger()
+        value = self.valobj.CreateChildAtOffset(
+            "value", self.offset(), self.sys_params.types_cache.double)
+        value_double = struct.unpack(
+            'd', struct.pack(
+                'Q', value.GetData().uint64[0]))[0]
+        if value_double == -63114076800.0:
+            return '0001-12-30 00:00:00 +0000'
+        return xcode_format_count(osx_to_python_time(value_double))
+
+
+class NSCalendarDate_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not (self.sys_params.types_cache.double):
+            self.sys_params.types_cache.double = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeDouble)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return 2 * self.sys_params.pointer_size
+
+    def value(self):
+        logger = lldb.formatters.Logger.Logger()
+        value = self.valobj.CreateChildAtOffset(
+            "value", self.offset(), self.sys_params.types_cache.double)
+        value_double = struct.unpack(
+            'd', struct.pack(
+                'Q', value.GetData().uint64[0]))[0]
+        return xcode_format_count(osx_to_python_time(value_double))
+
+
+class NSTimeZoneClass_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not (self.sys_params.types_cache.voidptr):
+            self.sys_params.types_cache.voidptr = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeVoid).GetPointerType()
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def timezone(self):
+        logger = lldb.formatters.Logger.Logger()
+        tz_string = self.valobj.CreateChildAtOffset(
+            "tz_name", self.offset(), self.sys_params.types_cache.voidptr)
+        return CFString.CFString_SummaryProvider(tz_string, None)
+
+
+class NSUnknownDate_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def value(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        expr = "(NSString*)[" + stream.GetData() + " description]"
+        num_children_vo = self.valobj.CreateValueFromExpression("str", expr)
+        if num_children_vo.IsValid():
+            return num_children_vo.GetSummary()
+        return '<variable is not NSDate>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSDate' or name_string == '__NSDate' or name_string == '__NSTaggedDate':
+        if class_data.is_tagged():
+            wrapper = NSTaggedDate_SummaryProvider(
+                valobj, class_data.info_bits(), class_data.value(), class_data.sys_params)
+            statistics.metric_hit('code_notrun', valobj)
+        else:
+            wrapper = NSUntaggedDate_SummaryProvider(
+                valobj, class_data.sys_params)
+            statistics.metric_hit('code_notrun', valobj)
+    elif name_string == 'NSCalendarDate':
+        wrapper = NSCalendarDate_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    elif name_string == '__NSTimeZone':
+        wrapper = NSTimeZoneClass_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSUnknownDate_SummaryProvider(valobj)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSDate_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.value()
+        except:
+            summary = None
+        if summary is None:
+            summary = '<variable is not NSDate>'
+        return str(summary)
+    return 'Summary Unavailable'
+
+
+def NSTimeZone_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.timezone()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSTimeZone>'
+        return str(summary)
+    return 'Summary Unavailable'
+
+
+def CFAbsoluteTime_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    try:
+        value_double = struct.unpack(
+            'd', struct.pack(
+                'Q', valobj.GetData().uint64[0]))[0]
+        return xcode_format_count(osx_to_python_time(value_double))
+    except:
+        return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSDate.NSDate_SummaryProvider NSDate")
+    debugger.HandleCommand(
+        "type summary add -F NSDate.CFAbsoluteTime_SummaryProvider CFAbsoluteTime")
+    debugger.HandleCommand(
+        "type summary add -F NSDate.NSTimeZone_SummaryProvider NSTimeZone CFTimeZoneRef")

external/llvm-project/lldb/examples/summaries/cocoa/NSException.py

@@ -0,0 +1,134 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# summary provider for class NSException
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import CFString
+import lldb
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+
+class NSKnownException_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not (self.sys_params.types_cache.id):
+            self.sys_params.types_cache.id = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeObjCID)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def offset_name(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def offset_reason(self):
+        logger = lldb.formatters.Logger.Logger()
+        return 2 * self.sys_params.pointer_size
+
+    def description(self):
+        logger = lldb.formatters.Logger.Logger()
+        name_ptr = self.valobj.CreateChildAtOffset(
+            "name", self.offset_name(), self.sys_params.types_cache.id)
+        reason_ptr = self.valobj.CreateChildAtOffset(
+            "reason", self.offset_reason(), self.sys_params.types_cache.id)
+        return 'name:' + CFString.CFString_SummaryProvider(
+            name_ptr, None) + ' reason:' + CFString.CFString_SummaryProvider(reason_ptr, None)
+
+
+class NSUnknownException_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def description(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        name_vo = self.valobj.CreateValueFromExpression(
+            "name", "(NSString*)[" + stream.GetData() + " name]")
+        reason_vo = self.valobj.CreateValueFromExpression(
+            "reason", "(NSString*)[" + stream.GetData() + " reason]")
+        if name_vo.IsValid() and reason_vo.IsValid():
+            return CFString.CFString_SummaryProvider(
+                name_vo, None) + ' ' + CFString.CFString_SummaryProvider(reason_vo, None)
+        return '<variable is not NSException>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSException':
+        wrapper = NSKnownException_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSUnknownException_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSException_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.description()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSException>'
+        return str(summary)
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSException.NSException_SummaryProvider NSException")

external/llvm-project/lldb/examples/summaries/cocoa/NSIndexSet.py

@@ -0,0 +1,176 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NS(Mutable)IndexSet
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the count of values for an NSIndexSet, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSIndexSetClass_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+                self.sys_params.types_cache.uint32 = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+                self.sys_params.types_cache.uint32 = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        if not(self.sys_params.types_cache.uint32):
+            self.sys_params.types_cache.uint32 = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # NS(Mutable)IndexSet works in one of two modes: when having a compact block of data (e.g. a Range)
+    # the count is stored in the set itself, 3 pointers into it
+    # otherwise, it will store a pointer to an additional data structure (2 pointers into itself) and this
+    # additional structure will contain the count two pointers deep
+    # a bunch of flags allow us to detect an empty set, vs. a one-range set,
+    # vs. a multi-range set
+    def count(self):
+        logger = lldb.formatters.Logger.Logger()
+        mode_chooser_vo = self.valobj.CreateChildAtOffset(
+            "mode_chooser",
+            self.sys_params.pointer_size,
+            self.sys_params.types_cache.uint32)
+        mode_chooser = mode_chooser_vo.GetValueAsUnsigned(0)
+        if self.sys_params.is_64_bit:
+            mode_chooser = mode_chooser & 0x00000000FFFFFFFF
+        # empty set
+        if mode_chooser & 0x01 == 1:
+            return 0
+        # single range
+        if mode_chooser & 0x02 == 2:
+            mode = 1
+        # multi range
+        else:
+            mode = 2
+        if mode == 1:
+            count_vo = self.valobj.CreateChildAtOffset(
+                "count",
+                3 * self.sys_params.pointer_size,
+                self.sys_params.types_cache.NSUInteger)
+        else:
+            count_ptr = self.valobj.CreateChildAtOffset(
+                "count_ptr",
+                2 * self.sys_params.pointer_size,
+                self.sys_params.types_cache.NSUInteger)
+            count_vo = self.valobj.CreateValueFromAddress(
+                "count",
+                count_ptr.GetValueAsUnsigned() +
+                2 *
+                self.sys_params.pointer_size,
+                self.sys_params.types_cache.NSUInteger)
+        return count_vo.GetValueAsUnsigned(0)
+
+
+class NSIndexSetUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def count(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        expr = "(int)[" + stream.GetData() + " count]"
+        num_children_vo = self.valobj.CreateValueFromExpression("count", expr)
+        if num_children_vo.IsValid():
+            return num_children_vo.GetValueAsUnsigned(0)
+        return '<variable is not NSIndexSet>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSIndexSet' or name_string == 'NSMutableIndexSet':
+        wrapper = NSIndexSetClass_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSIndexSetUnknown_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSIndexSet_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.count()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSIndexSet>'
+        if isinstance(summary, basestring):
+            return summary
+        else:
+            summary = str(summary) + (' indexes' if summary != 1 else ' index')
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSIndexSet.NSIndexSet_SummaryProvider NSIndexSet NSMutableIndexSet")

external/llvm-project/lldb/examples/summaries/cocoa/NSMachPort.py

@@ -0,0 +1,141 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSMachPort
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the port number of an NSMachPort, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSMachPortKnown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # one pointer is the ISA
+    # then we have one other internal pointer, plus
+    # 4 bytes worth of flags. hence, these values
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.sys_params.is_64_bit:
+            return 20
+        else:
+            return 12
+
+    def port(self):
+        logger = lldb.formatters.Logger.Logger()
+        vport = self.valobj.CreateChildAtOffset(
+            "port", self.offset(), self.sys_params.types_cache.NSUInteger)
+        return vport.GetValueAsUnsigned(0)
+
+
+class NSMachPortUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def port(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        num_children_vo = self.valobj.CreateValueFromExpression(
+            "port", "(int)[" + stream.GetData() + " machPort]")
+        if num_children_vo.IsValid():
+            return num_children_vo.GetValueAsUnsigned(0)
+        return '<variable is not NSMachPort>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSMachPort':
+        wrapper = NSMachPortKnown_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSMachPortUnknown_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSMachPort_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.port()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSMachPort>'
+        if isinstance(summary, basestring):
+            return summay
+        return 'mach port: ' + str(summary)
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSMachPort.NSMachPort_SummaryProvider NSMachPort")

external/llvm-project/lldb/examples/summaries/cocoa/NSNotification.py

@@ -0,0 +1,126 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSNotification
+# the real summary is now C++ code built into LLDB
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import CFString
+import lldb
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+
+class NSConcreteNotification_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not (self.sys_params.types_cache.id):
+            self.sys_params.types_cache.id = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeObjCID)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # skip the ISA and go to the name pointer
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def name(self):
+        logger = lldb.formatters.Logger.Logger()
+        string_ptr = self.valobj.CreateChildAtOffset(
+            "name", self.offset(), self.sys_params.types_cache.id)
+        return CFString.CFString_SummaryProvider(string_ptr, None)
+
+
+class NSNotificationUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def name(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        name_vo = self.valobj.CreateValueFromExpression(
+            "name", "(NSString*)[" + stream.GetData() + " name]")
+        if name_vo.IsValid():
+            return CFString.CFString_SummaryProvider(name_vo, None)
+        return '<variable is not NSNotification>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSConcreteNotification':
+        wrapper = NSConcreteNotification_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSNotificationUnknown_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSNotification_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.name()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSNotification>'
+        return str(summary)
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSNotification.NSNotification_SummaryProvider NSNotification")

external/llvm-project/lldb/examples/summaries/cocoa/NSNumber.py

@@ -0,0 +1,269 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# example summary provider for NSNumber
+# the real summary is now C++ code built into LLDB
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import struct
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the port number of an NSNumber, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSTaggedNumber_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, info_bits, data, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.info_bits = info_bits
+        self.data = data
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def value(self):
+        logger = lldb.formatters.Logger.Logger()
+        # in spite of the plenty of types made available by the public NSNumber API
+        # only a bunch of these are actually used in the internal implementation
+        # unfortunately, the original type information appears to be lost
+        # so we try to at least recover the proper magnitude of the data
+        if self.info_bits == 0:
+            return '(char)' + \
+                str(ord(ctypes.c_char(chr(self.data % 256)).value))
+        if self.info_bits == 4:
+            return '(short)' + \
+                str(ctypes.c_short(self.data % (256 * 256)).value)
+        if self.info_bits == 8:
+            return '(int)' + str(ctypes.c_int(self.data %
+                                              (256 * 256 * 256 * 256)).value)
+        if self.info_bits == 12:
+            return '(long)' + str(ctypes.c_long(self.data).value)
+        else:
+            return 'unexpected value:(info=' + str(self.info_bits) + \
+                ", value = " + str(self.data) + ')'
+
+
+class NSUntaggedNumber_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.char):
+            self.sys_params.types_cache.char = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeChar)
+        if not(self.sys_params.types_cache.short):
+            self.sys_params.types_cache.short = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeShort)
+        if not(self.sys_params.types_cache.ushort):
+            self.sys_params.types_cache.ushort = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeUnsignedShort)
+        if not(self.sys_params.types_cache.int):
+            self.sys_params.types_cache.int = self.valobj.GetType().GetBasicType(lldb.eBasicTypeInt)
+        if not(self.sys_params.types_cache.long):
+            self.sys_params.types_cache.long = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeLong)
+        if not(self.sys_params.types_cache.ulong):
+            self.sys_params.types_cache.ulong = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+        if not(self.sys_params.types_cache.longlong):
+            self.sys_params.types_cache.longlong = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeLongLong)
+        if not(self.sys_params.types_cache.ulonglong):
+            self.sys_params.types_cache.ulonglong = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeUnsignedLongLong)
+        if not(self.sys_params.types_cache.float):
+            self.sys_params.types_cache.float = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeFloat)
+        if not(self.sys_params.types_cache.double):
+            self.sys_params.types_cache.double = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeDouble)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def value(self):
+        logger = lldb.formatters.Logger.Logger()
+        global statistics
+        # we need to skip the ISA, then the next byte tells us what to read
+        # we then skip one other full pointer worth of data and then fetch the contents
+        # if we are fetching an int64 value, one more pointer must be skipped
+        # to get at our data
+        data_type_vo = self.valobj.CreateChildAtOffset(
+            "dt", self.sys_params.pointer_size, self.sys_params.types_cache.char)
+        data_type = ((data_type_vo.GetValueAsUnsigned(0) % 256) & 0x1F)
+        data_offset = 2 * self.sys_params.pointer_size
+        if data_type == 0B00001:
+            data_vo = self.valobj.CreateChildAtOffset(
+                "data", data_offset, self.sys_params.types_cache.char)
+            statistics.metric_hit('code_notrun', self.valobj)
+            return '(char)' + \
+                str(ord(ctypes.c_char(chr(data_vo.GetValueAsUnsigned(0))).value))
+        elif data_type == 0B0010:
+            data_vo = self.valobj.CreateChildAtOffset(
+                "data", data_offset, self.sys_params.types_cache.short)
+            statistics.metric_hit('code_notrun', self.valobj)
+            return '(short)' + str(
+                ctypes.c_short(
+                    data_vo.GetValueAsUnsigned(0) %
+                    (256 * 256)).value)
+        # IF tagged pointers are possible on 32bit+v2 runtime
+        # (of which the only existing instance should be iOS)
+        # then values of this type might be tagged
+        elif data_type == 0B0011:
+            data_vo = self.valobj.CreateChildAtOffset(
+                "data", data_offset, self.sys_params.types_cache.int)
+            statistics.metric_hit('code_notrun', self.valobj)
+            return '(int)' + str(ctypes.c_int(data_vo.GetValueAsUnsigned(0) %
+                                              (256 * 256 * 256 * 256)).value)
+        # apparently, on is_64_bit architectures, these are the only values that will ever
+        # be represented by a non tagged pointers
+        elif data_type == 0B10001:
+            data_offset = data_offset + 8  # 8 is needed even if we are on 32bit
+            data_vo = self.valobj.CreateChildAtOffset(
+                "data", data_offset, self.sys_params.types_cache.longlong)
+            statistics.metric_hit('code_notrun', self.valobj)
+            return '(long)' + \
+                str(ctypes.c_long(data_vo.GetValueAsUnsigned(0)).value)
+        elif data_type == 0B0100:
+            if self.sys_params.is_64_bit:
+                data_offset = data_offset + self.sys_params.pointer_size
+            data_vo = self.valobj.CreateChildAtOffset(
+                "data", data_offset, self.sys_params.types_cache.longlong)
+            statistics.metric_hit('code_notrun', self.valobj)
+            return '(long)' + \
+                str(ctypes.c_long(data_vo.GetValueAsUnsigned(0)).value)
+        elif data_type == 0B0101:
+            data_vo = self.valobj.CreateChildAtOffset(
+                "data", data_offset, self.sys_params.types_cache.longlong)
+            data_plain = int(
+                str(data_vo.GetValueAsUnsigned(0) & 0x00000000FFFFFFFF))
+            packed = struct.pack('I', data_plain)
+            data_float = struct.unpack('f', packed)[0]
+            statistics.metric_hit('code_notrun', self.valobj)
+            return '(float)' + str(data_float)
+        elif data_type == 0B0110:
+            data_vo = self.valobj.CreateChildAtOffset(
+                "data", data_offset, self.sys_params.types_cache.longlong)
+            data_plain = data_vo.GetValueAsUnsigned(0)
+            data_double = struct.unpack('d', struct.pack('Q', data_plain))[0]
+            statistics.metric_hit('code_notrun', self.valobj)
+            return '(double)' + str(data_double)
+        statistics.metric_hit(
+            'unknown_class', str(
+                valobj.GetName()) + " had unknown data_type " + str(data_type))
+        return 'unexpected: dt = ' + str(data_type)
+
+
+class NSUnknownNumber_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def value(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        expr = "(NSString*)[" + stream.GetData() + " stringValue]"
+        num_children_vo = self.valobj.CreateValueFromExpression("str", expr)
+        if num_children_vo.IsValid():
+            return num_children_vo.GetSummary()
+        return '<variable is not NSNumber>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSNumber' or name_string == '__NSCFNumber':
+        if class_data.is_tagged():
+            wrapper = NSTaggedNumber_SummaryProvider(
+                valobj, class_data.info_bits(), class_data.value(), class_data.sys_params)
+            statistics.metric_hit('code_notrun', valobj)
+        else:
+            # the wrapper might be unable to decipher what is into the NSNumber
+            # and then have to run code on it
+            wrapper = NSUntaggedNumber_SummaryProvider(
+                valobj, class_data.sys_params)
+    else:
+        wrapper = NSUnknownNumber_SummaryProvider(
+            valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSNumber_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.value()
+        except Exception as foo:
+            print foo
+#		except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None:
+            summary = '<variable is not NSNumber>'
+        return str(summary)
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSNumber.NSNumber_SummaryProvider NSNumber")
+    debugger.HandleCommand(
+        "type summary add -F NSNumber.NSNumber_SummaryProvider __NSCFBoolean")
+    debugger.HandleCommand(
+        "type summary add -F NSNumber.NSNumber_SummaryProvider __NSCFNumber")

external/llvm-project/lldb/examples/summaries/cocoa/NSSet.py

@@ -0,0 +1,289 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# summary provider for NSSet
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import CFBag
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but the port number of an NSMachPort, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSCFSet_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # one pointer is the ISA
+    # then we have one other internal pointer, plus
+    # 4 bytes worth of flags. hence, these values
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        if self.sys_params.is_64_bit:
+            return 20
+        else:
+            return 12
+
+    def count(self):
+        logger = lldb.formatters.Logger.Logger()
+        vcount = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        return vcount.GetValueAsUnsigned(0)
+
+
+class NSSetUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def count(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        expr = "(int)[" + stream.GetData() + " count]"
+        num_children_vo = self.valobj.CreateValueFromExpression("count", expr)
+        if num_children_vo.IsValid():
+            return num_children_vo.GetValueAsUnsigned(0)
+        return '<variable is not NSSet>'
+
+
+class NSSetI_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # we just need to skip the ISA and the count immediately follows
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def count(self):
+        logger = lldb.formatters.Logger.Logger()
+        num_children_vo = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        value = num_children_vo.GetValueAsUnsigned(0)
+        if value is not None:
+            # the MSB on immutable sets seems to be taken by some other data
+            # not sure if it is a bug or some weird sort of feature, but masking it out
+            # gets the count right (unless, of course, someone's dictionaries grow
+            #                       too large - but I have not tested this)
+            if self.sys_params.is_64_bit:
+                value = value & ~0xFF00000000000000
+            else:
+                value = value & ~0xFF000000
+        return value
+
+
+class NSSetM_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSUInteger):
+            if self.sys_params.is_64_bit:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedLong)
+            else:
+                self.sys_params.types_cache.NSUInteger = self.valobj.GetType(
+                ).GetBasicType(lldb.eBasicTypeUnsignedInt)
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # we just need to skip the ISA and the count immediately follows
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def count(self):
+        logger = lldb.formatters.Logger.Logger()
+        num_children_vo = self.valobj.CreateChildAtOffset(
+            "count", self.offset(), self.sys_params.types_cache.NSUInteger)
+        return num_children_vo.GetValueAsUnsigned(0)
+
+
+class NSCountedSet_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not (self.sys_params.types_cache.voidptr):
+            self.sys_params.types_cache.voidptr = self.valobj.GetType(
+            ).GetBasicType(lldb.eBasicTypeVoid).GetPointerType()
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # an NSCountedSet is implemented using a CFBag whose pointer just follows
+    # the ISA
+    def offset(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.sys_params.pointer_size
+
+    def count(self):
+        logger = lldb.formatters.Logger.Logger()
+        cfbag_vo = self.valobj.CreateChildAtOffset(
+            "bag_impl", self.offset(), self.sys_params.types_cache.voidptr)
+        return CFBag.CFBagRef_SummaryProvider(
+            cfbag_vo, self.sys_params).length()
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == '__NSCFSet':
+        wrapper = NSCFSet_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    elif name_string == '__NSSetI':
+        wrapper = NSSetI_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    elif name_string == '__NSSetM':
+        wrapper = NSSetM_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    elif name_string == 'NSCountedSet':
+        wrapper = NSCountedSet_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSSetUnknown_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSSet_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        try:
+            summary = provider.count()
+        except:
+            summary = None
+        if summary is None:
+            summary = '<variable is not NSSet>'
+        if isinstance(summary, basestring):
+            return summary
+        else:
+            summary = str(summary) + \
+                (' objects' if summary != 1 else ' object')
+        return summary
+    return 'Summary Unavailable'
+
+
+def NSSet_SummaryProvider2(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.count()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        # for some reason, one needs to clear some bits for the count returned
+        # to be correct when using directly CF*SetRef as compared to NS*Set
+        # this only happens on 64bit, and the bit mask was derived through
+        # experimentation (if counts start looking weird, then most probably
+        #                  the mask needs to be changed)
+        if summary is None:
+            summary = '<variable is not CFSet>'
+        if isinstance(summary, basestring):
+            return summary
+        else:
+            if provider.sys_params.is_64_bit:
+                summary = summary & ~0x1fff000000000000
+            summary = '@"' + str(summary) + \
+                (' values"' if summary != 1 else ' value"')
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSSet.NSSet_SummaryProvider NSSet")
+    debugger.HandleCommand(
+        "type summary add -F NSSet.NSSet_SummaryProvider2 CFSetRef CFMutableSetRef")

external/llvm-project/lldb/examples/summaries/cocoa/NSURL.py

@@ -0,0 +1,153 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+# summary provider for NSURL
+import lldb
+import ctypes
+import lldb.runtime.objc.objc_runtime
+import lldb.formatters.metrics
+import CFString
+import lldb.formatters.Logger
+
+statistics = lldb.formatters.metrics.Metrics()
+statistics.add_metric('invalid_isa')
+statistics.add_metric('invalid_pointer')
+statistics.add_metric('unknown_class')
+statistics.add_metric('code_notrun')
+
+# despite the similary to synthetic children providers, these classes are not
+# trying to provide anything but a summary for an NSURL, so they need not
+# obey the interface specification for synthetic children providers
+
+
+class NSURLKnown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        if not(self.sys_params.types_cache.NSString):
+            self.sys_params.types_cache.NSString = self.valobj.GetTarget(
+            ).FindFirstType('NSString').GetPointerType()
+        if not(self.sys_params.types_cache.NSURL):
+            self.sys_params.types_cache.NSURL = self.valobj.GetTarget(
+            ).FindFirstType('NSURL').GetPointerType()
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    # one pointer is the ISA
+    # then there is one more pointer and 8 bytes of plain data
+    # (which are also present on a 32-bit system)
+    # then there is a pointer to an NSString which is the url text
+    # optionally, the next pointer is another NSURL which is the "base"
+    # of this one when doing NSURLs composition (incidentally, NSURLs can
+    # recurse the base+text mechanism to any desired depth)
+    def offset_text(self):
+        logger = lldb.formatters.Logger.Logger()
+        return 24 if self.sys_params.is_64_bit else 16
+
+    def offset_base(self):
+        logger = lldb.formatters.Logger.Logger()
+        return self.offset_text() + self.sys_params.pointer_size
+
+    def url_text(self):
+        logger = lldb.formatters.Logger.Logger()
+        text = self.valobj.CreateChildAtOffset(
+            "text", self.offset_text(), self.sys_params.types_cache.NSString)
+        base = self.valobj.CreateChildAtOffset(
+            "base", self.offset_base(), self.sys_params.types_cache.NSURL)
+        my_string = CFString.CFString_SummaryProvider(text, None)
+        if len(my_string) > 0 and base.GetValueAsUnsigned(0) != 0:
+            # remove final " from myself
+            my_string = my_string[0:len(my_string) - 1]
+            my_string = my_string + ' -- '
+            my_base_string = NSURL_SummaryProvider(base, None)
+            if len(my_base_string) > 2:
+                # remove @" marker from base URL string
+                my_base_string = my_base_string[2:]
+            my_string = my_string + my_base_string
+        return my_string
+
+
+class NSURLUnknown_SummaryProvider:
+
+    def adjust_for_architecture(self):
+        pass
+
+    def __init__(self, valobj, params):
+        logger = lldb.formatters.Logger.Logger()
+        self.valobj = valobj
+        self.sys_params = params
+        self.update()
+
+    def update(self):
+        logger = lldb.formatters.Logger.Logger()
+        self.adjust_for_architecture()
+
+    def url_text(self):
+        logger = lldb.formatters.Logger.Logger()
+        stream = lldb.SBStream()
+        self.valobj.GetExpressionPath(stream)
+        url_text_vo = self.valobj.CreateValueFromExpression(
+            "url", "(NSString*)[" + stream.GetData() + " description]")
+        if url_text_vo.IsValid():
+            return CFString.CFString_SummaryProvider(url_text_vo, None)
+        return '<variable is not NSURL>'
+
+
+def GetSummary_Impl(valobj):
+    logger = lldb.formatters.Logger.Logger()
+    global statistics
+    class_data, wrapper = lldb.runtime.objc.objc_runtime.Utilities.prepare_class_detection(
+        valobj, statistics)
+    if wrapper:
+        return wrapper
+
+    name_string = class_data.class_name()
+    logger >> "class name is: " + str(name_string)
+
+    if name_string == 'NSURL':
+        wrapper = NSURLKnown_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit('code_notrun', valobj)
+    else:
+        wrapper = NSURLUnknown_SummaryProvider(valobj, class_data.sys_params)
+        statistics.metric_hit(
+            'unknown_class',
+            valobj.GetName() +
+            " seen as " +
+            name_string)
+    return wrapper
+
+
+def NSURL_SummaryProvider(valobj, dict):
+    logger = lldb.formatters.Logger.Logger()
+    provider = GetSummary_Impl(valobj)
+    if provider is not None:
+        if isinstance(
+                provider,
+                lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
+            return provider.message()
+        try:
+            summary = provider.url_text()
+        except:
+            summary = None
+        logger >> "got summary " + str(summary)
+        if summary is None or summary == '':
+            summary = '<variable is not NSURL>'
+        return summary
+    return 'Summary Unavailable'
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "type summary add -F NSURL.NSURL_SummaryProvider NSURL CFURLRef")

external/llvm-project/lldb/examples/summaries/cocoa/Selector.py

@@ -0,0 +1,19 @@
+"""
+LLDB AppKit formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+import lldb
+
+
+def SEL_Summary(valobj, dict):
+    return valobj.Cast(valobj.GetType().GetBasicType(
+        lldb.eBasicTypeChar).GetPointerType()).GetSummary()
+
+
+def SELPointer_Summary(valobj, dict):
+    return valobj.CreateValueFromAddress(
+        'text', valobj.GetValueAsUnsigned(0), valobj.GetType().GetBasicType(
+            lldb.eBasicTypeChar)).AddressOf().GetSummary()

external/llvm-project/lldb/examples/summaries/cocoa/attrib_fromdict.py

@@ -0,0 +1,42 @@
+"""
+Objective-C runtime wrapper for use by LLDB Python formatters
+
+part of The LLVM Compiler Infrastructure
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+"""
+
+
+class AttributesDictionary:
+
+    def __init__(self, allow_reset=True):
+        # need to do it this way to prevent endless recursion
+        self.__dict__['_dictionary'] = {}
+        self.__dict__['_allow_reset'] = allow_reset
+
+    def __getattr__(self, name):
+        if not self._check_exists(name):
+            return None
+        value = self._dictionary[name]
+        return value
+
+    def _set_impl(self, name, value):
+        self._dictionary[name] = value
+
+    def _check_exists(self, name):
+        return name in self._dictionary
+
+    def __setattr__(self, name, value):
+        if self._allow_reset:
+            self._set_impl(name, value)
+        else:
+            self.set_if_necessary(name, value)
+
+    def set_if_necessary(self, name, value):
+        if not self._check_exists(name):
+            self._set_impl(name, value)
+            return True
+        return False
+
+    def __len__(self):
+        return len(self._dictionary)