Fix Swift and ObjC debugging.

Author: TadeasKriz

LLDBPlugin/lldb/__init__.pyi

@@ -2,9 +2,22 @@
 
 import os
 import subprocess
+import sys
 
 import lldb
 
+
+def tracefunc(frame, event, arg, indent=[0]):
+    if event == "call":
+        indent[0] += 2
+        print("-" * indent[0] + "> call function", frame.f_code.co_name)
+    elif event == "return":
+        print("<" + "-" * indent[0], "exit function", frame.f_code.co_name)
+        indent[0] -= 2
+    return tracefunc
+
+# sys.setprofile(tracefunc)
+
 gradle_invoke = subprocess.Popen(['./gradlew', 'compileSwift'], cwd='test_project')
 gradle_exit_code = gradle_invoke.wait()
 
@@ -28,6 +41,9 @@
 debugger.SetAsync(False)
 
 # debugger.HandleCommand('log enable lldb default')
+# debugger.HandleCommand('log enable lldb default')
+debugger.HandleCommand('log enable lldb commands')
+debugger.HandleCommand('log enable lldb types')
 
 # Import our module
 debugger.HandleCommand('command script import touchlab_kotlin_lldb')
@@ -42,16 +58,17 @@
 
     if process:
         import time
+
         start = time.perf_counter()
-        debugger.HandleCommand('fr v --ptr-depth 16 -- string')
+        debugger.HandleCommand('fr v -T --ptr-depth 16')
         print('HandleCommand took {:.6}s'.format(time.perf_counter() - start))
         process.Continue()
         # debugger.HandleCommand('fr v --ptr-depth 16 -- data')
-        debugger.HandleCommand('fr v --ptr-depth 16')
+        # debugger.HandleCommand('fr v --ptr-depth 16')
 
         process.Kill()
 
 # Finally, dispose of the debugger you just made.
 lldb.SBDebugger.Destroy(debugger)
 # Terminate the debug session
-lldb.SBDebugger.Terminate()
+lldb.SBDebugger.Terminate()

LLDBPlugin/run.py

@@ -19,7 +19,6 @@
 KONAN_INIT_MODULE_NAME = '[0-9a-zA-Z_]+'
 KONAN_INIT_SUFFIX = '_kexe'
 
-
 def __lldb_init_module(debugger: lldb.SBDebugger, _):
     log(lambda: "init start")
 
@@ -28,7 +27,7 @@ def __lldb_init_module(debugger: lldb.SBDebugger, _):
     register_commands(debugger)
     register_hooks(debugger)
 
-    configure_objc_types(debugger)
+    configure_objc_types_init(debugger)
 
     log(lambda: "init end")
 
@@ -39,7 +38,7 @@ def reset_cache():
     LLDBCache.reset()
 
 
-def configure_objc_types(debugger: lldb.SBDebugger):
+def configure_objc_types_init(debugger: lldb.SBDebugger):
     target = debugger.GetDummyTarget()
     breakpoint = target.BreakpointCreateByRegex(
         "^{}({})({})?$".format(KONAN_INIT_PREFIX, KONAN_INIT_MODULE_NAME, KONAN_INIT_SUFFIX)
@@ -89,8 +88,7 @@ def configure_objc_types_breakpoint(frame: lldb.SBFrame, bp_loc: lldb.SBBreakpoi
             )
         )
 
-    debugger = target.debugger
-    category = debugger.GetCategory(KOTLIN_CATEGORY)
+    category = target.debugger.GetCategory(KOTLIN_CATEGORY)
 
     for type_specifier in specifiers_to_register:
         category.AddTypeSummary(

LLDBPlugin/touchlab_kotlin_lldb/__init__.py

@@ -19,9 +19,9 @@ def instance(cls):
     def __init__(self):
         self._debug_buffer_addr: Optional[int] = None
         self._debug_buffer_size: Optional[int] = None
-        self._string_symbol_addr: Optional[int] = None
-        self._list_symbol_addr: Optional[int] = None
-        self._map_symbol_addr: Optional[int] = None
+        self._string_symbol_value: Optional[lldb.value] = None
+        self._list_symbol_value: Optional[lldb.value] = None
+        self._map_symbol_value: Optional[lldb.value] = None
         self._helper_types_declared: bool = False
         self._type_info_type: Optional[lldb.SBType] = None
         self._obj_header_type: Optional[lldb.SBType] = None

LLDBPlugin/touchlab_kotlin_lldb/cache/__init__.py

@@ -20,7 +20,7 @@ def num_children(self):
         return self._children_count
 
     def has_children(self):
-        return self._children_count > 0
+        return True
 
     def get_child_index(self, name):
         log(lambda: "KonanArraySyntheticProvider::get_child_index({})".format(name))

LLDBPlugin/touchlab_kotlin_lldb/types/KonanArraySyntheticProvider.py

@@ -5,19 +5,21 @@
 
 class KonanBaseSyntheticProvider(object):
     def __init__(self, valobj: lldb.SBValue, type_info: lldb.value):
+        super().__init__()
+
         self._valobj: lldb.SBValue = valobj
         self._val: lldb.value = lldb.value(valobj.GetNonSyntheticValue())
         self._type_info: lldb.value = type_info
         self._process: lldb.SBProcess = lldb.debugger.GetSelectedTarget().process
 
-        super().__init__()
-
-        # We need to call it ourselves, because Xcode doesn't seem to call it in some cases
-        self.update()
-
     def update(self) -> bool:
         return False
 
+    def get_type_name(self) -> str:
+        package_name = kotlin_object_to_string(self._process, self._type_info.packageName_.sbvalue.unsigned)
+        relative_name = kotlin_object_to_string(self._process, self._type_info.relativeName_.sbvalue.unsigned)
+        return '{}.{}'.format(package_name, relative_name)
+
     def read_cstring(self, address: int) -> str:
         error = lldb.SBError()
         result = self._process.ReadCStringFromMemory(
@@ -35,4 +37,4 @@ def read_cstring(self, address: int) -> str:
         return result
 
     def to_string(self):
-        return kotlin_object_to_string(self._process, self._valobj.unsigned)
+        return kotlin_object_to_string(self._process, self._valobj.unsigned)

LLDBPlugin/touchlab_kotlin_lldb/types/KonanBaseSyntheticProvider.py

@@ -33,15 +33,15 @@ def update(self):
                 )
 
             self._backing = backing
-        else:
-            self._backing.update()
+
+        self._backing.update()
         return False
 
     def num_children(self):
         return self._backing.num_children()
 
     def has_children(self):
-        return self._backing.has_children()
+        return True
 
     def get_child_index(self, name):
         return self._backing.get_child_index(name)

LLDBPlugin/touchlab_kotlin_lldb/types/KonanListSyntheticProvider.py

@@ -33,20 +33,20 @@ def update(self):
                 raise DebuggerException(
                     "Couldn't find backing for map {:#x}, name: {}".format(self._valobj.unsigned, self._valobj.name)
                 )
+            else:
+                self._keys = keys
+                self._values = values
 
-            self._keys = keys
-            self._values = values
-        else:
-            self._keys.update()
-            self._values.update()
+        self._keys.update()
+        self._values.update()
 
         return False
 
     def num_children(self):
         return self._keys.num_children()
 
     def has_children(self):
-        return self._keys.has_children()
+        return True
 
     def get_child_index(self, name):
         # TODO: Not correct, we need to look at the values which this doesn't do

LLDBPlugin/touchlab_kotlin_lldb/types/KonanMapSyntheticProvider.py

@@ -1,18 +1,20 @@
 import lldb
 
 
-from .base import _TYPE_CONVERSION
+from .base import _TYPE_CONVERSION, type_info_type
 from .KonanBaseSyntheticProvider import KonanBaseSyntheticProvider
 
 
 class KonanObjectSyntheticProvider(KonanBaseSyntheticProvider):
     def __init__(self, valobj: lldb.SBValue, type_info: lldb.value):
         self._children_count = 0
         self._children_names = []
+        self._was_updated = False
 
         super().__init__(valobj, type_info)
 
     def update(self) -> bool:
+        self._was_updated = True
         self._children_count = int(self._type_info.extendedInfo_.fieldsCount_)
         if self._children_count < 0:
             self._children_count = 0
@@ -27,7 +29,7 @@ def num_children(self):
         return self._children_count
 
     def has_children(self):
-        return self._children_count > 0
+        return True
 
     def get_child_index(self, name):
         # if self._children is None:
@@ -40,4 +42,3 @@ def get_child_at_index(self, index):
 
     def get_child_address_at_index(self, index):
         return self._valobj.unsigned + int(self._type_info.extendedInfo_.fieldOffsets_[index])
-

LLDBPlugin/touchlab_kotlin_lldb/types/KonanObjectSyntheticProvider.py

@@ -5,8 +5,8 @@
 from ..util import strip_quotes, log, evaluate
 from ..cache import LLDBCache
 
-KOTLIN_OBJ_HEADER_TYPE = lldb.SBTypeNameSpecifier('ObjHeader *', lldb.eMatchTypeNormal)
-KOTLIN_ARRAY_HEADER_TYPE = lldb.SBTypeNameSpecifier('ArrayHeader *', lldb.eMatchTypeNormal)
+KOTLIN_OBJ_HEADER_TYPE = lldb.SBTypeNameSpecifier('ObjHeader', lldb.eMatchTypeNormal)
+KOTLIN_ARRAY_HEADER_TYPE = lldb.SBTypeNameSpecifier('ArrayHeader', lldb.eMatchTypeNormal)
 KOTLIN_CATEGORY = 'Kotlin'
 
 _TYPE_CONVERSION = [
@@ -55,28 +55,49 @@
 ]
 
 
+def single_pointer(valobj: lldb.SBValue) -> lldb.SBValue:
+    non_synthetic_value = valobj.GetNonSyntheticValue()
+
+    # TODO: Test how this behaves when stopped in C++
+    # In case we've stopped in Swift, this will be true.
+    if non_synthetic_value.type.IsReferenceType():
+        return non_synthetic_value
+
+    while non_synthetic_value.type.GetPointeeType().IsPointerType():
+        non_synthetic_value = non_synthetic_value.Dereference()
+
+    if not non_synthetic_value.type.IsPointerType():
+        non_synthetic_value = non_synthetic_value.AddressOf()
+
+    return non_synthetic_value
+
+
+def obj_header_pointer(valobj: lldb.SBValue) -> lldb.SBValue:
+    return single_pointer(valobj).Cast(obj_header_type())
+
+
 def get_runtime_type(variable):
     return strip_quotes(evaluate("(char *)Konan_DebugGetTypeName({:#x})", variable.unsigned).summary)
 
 
 def type_info_type() -> lldb.SBType:
     self = LLDBCache.instance()
     if self._type_info_type is None:
-        self._type_info_type = evaluate('(TypeInfo*)0x0').type
+        self._type_info_type = evaluate('(TypeInfo*)0x0').GetNonSyntheticValue().type
     return self._type_info_type
 
 
 def obj_header_type() -> lldb.SBType:
     self = LLDBCache.instance()
     if self._obj_header_type is None:
-        self._obj_header_type = evaluate('(ObjHeader*)0x0').type
+        self._obj_header_type = evaluate('(ObjHeader*)0x0').GetNonSyntheticValue().type
     return self._obj_header_type
 
 
 def array_header_type() -> lldb.SBType:
     self = LLDBCache.instance()
     if self._array_header_type is None:
-        self._array_header_type = evaluate('(ArrayHeader*)0x0').type
+        self._array_header_type = evaluate('(ArrayHeader*)0x0').GetNonSyntheticValue().type
     return self._array_header_type
 
 
@@ -96,8 +117,7 @@ def runtime_type_alignment() -> lldb.value:
     return self._runtime_type_alignment
 
 
-def _symbol_loaded_address(name: str, debugger: lldb.SBDebugger) -> int:
-    target: lldb.SBTarget = debugger.GetSelectedTarget()
+def _symbol_loaded_address(name: str, target: lldb.SBTarget) -> int:
     candidates = target.FindSymbols(name)
     # take first
     for candidate in candidates:
@@ -108,25 +128,37 @@ def _symbol_loaded_address(name: str, debugger: lldb.SBDebugger) -> int:
     return 0
 
 
-def get_string_symbol_address() -> int:
+def _get_konan_class_symbol_value(cls_name: str) -> lldb.value:
+    target = lldb.debugger.GetSelectedTarget()
+    address = _symbol_loaded_address(f'kclass:{cls_name}', target)
+    return lldb.value(
+        target.CreateValueFromAddress(
+            cls_name,
+            lldb.SBAddress(address, target),
+            type_info_type(),
+        )
+    )
+
+
+def get_string_symbol() -> lldb.value:
     self = LLDBCache.instance()
-    if self._string_symbol_addr is None:
-        self._string_symbol_addr = _symbol_loaded_address('kclass:kotlin.String', lldb.debugger)
-    return self._string_symbol_addr
+    if self._string_symbol_value is None:
+        self._string_symbol_value = _get_konan_class_symbol_value('kotlin.String')
+    return self._string_symbol_value
 
 
-def get_list_symbol_address() -> int:
+def get_list_symbol() -> lldb.value:
     self = LLDBCache.instance()
-    if self._list_symbol_addr is None:
-        self._list_symbol_addr = _symbol_loaded_address('kclass:kotlin.collections.List', lldb.debugger)
-    return self._list_symbol_addr
+    if self._list_symbol_value is None:
+        self._list_symbol_value = _get_konan_class_symbol_value('kotlin.collections.List')
+    return self._list_symbol_value
 
 
-def get_map_symbol_address() -> int:
+def get_map_symbol() -> lldb.value:
     self = LLDBCache.instance()
-    if self._map_symbol_addr is None:
-        self._map_symbol_addr = _symbol_loaded_address('kclass:kotlin.collections.Map', lldb.debugger)
-    return self._map_symbol_addr
+    if self._map_symbol_value is None:
+        self._map_symbol_value = _get_konan_class_symbol_value('kotlin.collections.Map')
+    return self._map_symbol_value
 
 
 class KnownValueType: