abanoub-ashraf/ios-debugging

iOS Debugging Expert

You are an expert in iOS debugging. When this skill activates, help diagnose and fix issues efficiently.

LLDB Commands

Basic Commands

# Print variable
(lldb) po myVariable
(lldb) p myVariable          # Prints with type info
(lldb) v myVariable          # Frame variable (faster)

# Print expression
(lldb) e print("Debug")
(lldb) expression myVar = 42

# Print object description
(lldb) po self
(lldb) po [self description]

# View memory
(lldb) memory read myPointer
(lldb) x/16xb myPointer      # 16 bytes in hex

Breakpoint Commands

# List breakpoints
(lldb) breakpoint list
(lldb) br l

# Set breakpoint
(lldb) b MyClass.myMethod
(lldb) breakpoint set -n viewDidLoad
(lldb) b -f ViewController.swift -l 42

# Conditional breakpoint
(lldb) breakpoint set -n fetchUser -c 'userId == "123"'

# Breakpoint action
(lldb) breakpoint command add 1
> po self.state
> continue
> DONE

# Disable/Enable
(lldb) breakpoint disable 1
(lldb) breakpoint enable 1

# Delete
(lldb) breakpoint delete 1

Watchpoints

# Watch variable changes
(lldb) watchpoint set variable myProperty
(lldb) w s v self.count

# Watch expression
(lldb) watchpoint set expression -- &myVariable

# List watchpoints
(lldb) watchpoint list

Navigation

# Step over
(lldb) next
(lldb) n

# Step into
(lldb) step
(lldb) s

# Step out
(lldb) finish
(lldb) f

# Continue
(lldb) continue
(lldb) c

# View call stack
(lldb) bt                    # Backtrace
(lldb) bt all                # All threads

# Switch frames
(lldb) frame select 3
(lldb) up                    # Go up one frame
(lldb) down                  # Go down one frame

Thread Commands

# List threads
(lldb) thread list

# Switch thread
(lldb) thread select 2

# Thread backtrace
(lldb) thread backtrace

# Thread info
(lldb) thread info

Memory Debugging

# View heap allocations
(lldb) command script import lldb.macosx.heap
(lldb) ptr_refs 0x12345678

# Object reference count
(lldb) p CFGetRetainCount(myObject)

# Memory regions
(lldb) memory region myPointer

Xcode Debugging Features

View Debugger

Debug → View Debugging → Capture View Hierarchy

Features:
- 3D view of view hierarchy
- Inspect constraints
- Find overlapping views
- Check hidden views

Memory Graph Debugger

Debug → Debug Memory Graph

Look for:
- Purple exclamation marks (leaks)
- Retain cycles in reference chains
- Unexpected strong references

Network Link Conditioner

Settings → Developer → Network Link Conditioner

Test with:
- 3G, Edge, LTE profiles
- 100% Loss
- High Latency

Console Logging

os.log (Recommended)

import os

private let logger = Logger(subsystem: "com.app.myapp", category: "networking")

func fetchData() {
    logger.debug("Starting fetch")
    logger.info("Fetching from \(url, privacy: .public)")
    logger.warning("Slow response: \(duration)s")
    logger.error("Failed: \(error.localizedDescription)")
    logger.fault("Critical: Database corrupted")
}

// With privacy
logger.info("User: \(userID, privacy: .private)")
logger.info("Count: \(count, privacy: .public)")

Filter in Console.app

1. Open Console.app
2. Select your device/simulator
3. Filter by:
   - Subsystem: com.app.myapp
   - Category: networking
   - Type: Error, Fault

Print with Context

func debugPrint(_ items: Any..., file: String = #file, function: String = #function, line: Int = #line) {
    #if DEBUG
    let fileName = (file as NSString).lastPathComponent
    print("[\(fileName):\(line)] \(function) →", items)
    #endif
}

// Output: [ViewController.swift:42] viewDidLoad() → Starting

Crash Log Analysis

Symbolication

# Find dSYM
mdfind -name .dSYM | xargs -I{} dwarfdump -u {}

# Symbolicate crash log
symbolicatecrash crash.log MyApp.dSYM > symbolicated.log

# Using atos
atos -arch arm64 -o MyApp.dSYM/Contents/Resources/DWARF/MyApp -l 0x100000000 0x100001234

Common Crash Types

EXC_BAD_ACCESS

Cause: Accessing deallocated memory
Debug:
1. Enable Zombie Objects (Scheme → Diagnostics)
2. Enable Address Sanitizer
3. Check for force unwrapping optionals

EXC_BREAKPOINT

Cause: Swift runtime error (force unwrap nil, array bounds)
Debug:
1. Check stack trace for fatalError
2. Look for implicitly unwrapped optionals
3. Check array indices

SIGABRT

Cause: Assertion failure or abort() called
Debug:
1. Check console for assertion message
2. Look for precondition failures
3. Check for unhandled exceptions

Instruments

Time Profiler

# Find CPU bottlenecks
1. Product → Profile → Time Profiler
2. Record app usage
3. Look for heavy stack traces
4. Expand call tree to find hot spots

Allocations

# Track memory usage
1. Product → Profile → Allocations
2. Look for:
   - Memory growth over time
   - Large allocations
   - Transient allocations in loops

Leaks

# Find memory leaks
1. Product → Profile → Leaks
2. Red bars indicate leaks
3. Expand to see allocation stack trace
4. Common causes:
   - Strong reference cycles in closures
   - Delegate not weak
   - Timer not invalidated

Network

# Analyze network calls
1. Product → Profile → Network
2. See all HTTP requests
3. Check response times
4. Identify redundant calls

Common Debugging Scenarios

Finding Retain Cycles

// Add to suspected class
deinit {
    print("✅ \(Self.self) deallocated")
}

// If deinit never prints → retain cycle

// Common fixes:
class MyClass {
    // Weak delegate
    weak var delegate: MyDelegate?

    // Weak self in closures
    someService.fetch { [weak self] result in
        guard let self else { return }
        self.handleResult(result)
    }

    // Weak capture in Combine
    cancellable = publisher
        .sink { [weak self] value in
            self?.handle(value)
        }
}

Debugging Async Issues

// Add task identifiers
func fetchData() async {
    let taskID = UUID().uuidString.prefix(8)
    print("[\(taskID)] Start fetch")

    defer { print("[\(taskID)] End fetch") }

    // ... fetch logic
}

// Check thread
print("Thread: \(Thread.current)")
print("Is main: \(Thread.isMainThread)")

Debugging SwiftUI

// Print body evaluations
var body: some View {
    let _ = print("🔄 \(Self.self) body evaluated")

    VStack {
        // ...
    }
}

// Use Self._printChanges() (iOS 15+)
var body: some View {
    let _ = Self._printChanges()

    VStack {
        // ...
    }
}

Debugging Layout

// Visual debug
.border(.red)
.background(.blue.opacity(0.3))

// Print sizes
.background(GeometryReader { geo in
    Color.clear.onAppear {
        print("Size: \(geo.size)")
    }
})

Environment Variables

Scheme Settings

Product → Scheme → Edit Scheme → Run → Arguments

Environment Variables:
- CFNETWORK_DIAGNOSTICS=3     # Network debugging
- SQLITE_ENABLE_THREAD_ASSERTIONS=1
- CA_DEBUG_TRANSACTIONS=1     # Core Animation

Arguments Passed On Launch:
- -com.apple.CoreData.SQLDebug 1
- -com.apple.CoreData.Logging.stderr 1

Malloc Debugging

# In scheme environment variables:
MallocStackLogging=1          # Log allocations
MallocScribble=1              # Fill freed memory with 0x55
MallocGuardEdges=1            # Guard pages around allocations

Quick Debug Checklist

App Crashes

1. ✅ Read crash log exception type
2. ✅ Check stack trace for your code
3. ✅ Enable Zombie Objects if EXC_BAD_ACCESS
4. ✅ Add exception breakpoint

Memory Issues

1. ✅ Run Memory Graph Debugger
2. ✅ Check for purple leak indicators
3. ✅ Verify deinit is called
4. ✅ Profile with Instruments Leaks

Performance Issues

1. ✅ Profile with Time Profiler
2. ✅ Check main thread usage
3. ✅ Look for excessive allocations
4. ✅ Check for layout thrashing

UI Issues

1. ✅ Use View Debugger
2. ✅ Check constraint conflicts
3. ✅ Verify on main thread
4. ✅ Check for clipped content