LLDB: co je to za debugger, základní příkazy a použití ve vývoji pro iOS

Co je LLDB a jak je uspořádán

LLDB — je debugger s otevřeným zdrojovým kódem, postavený na knihovnách projektu LLVM. Nahradil GDB v Xcode 5 a od té doby je hlavním nástrojem pro ladění pro celý ekosystém Apple. Na rozdíl od monolitického GDB je LLDB implementován jako sada spolupracujících knihoven: každá funkce — od parsování výrazů po práci s pamětí — je vyčleněna do samostatného modulu, což zjednodušuje údržbu a rozšiřování.

Hlavní možnosti LLDB zahrnují: nastavování breakpoints libovolného typu, watchpoints pro sledování změn proměnných, inspekci paměti a registrů, provádění krok po kroku, vyhodnocování libovolných výrazů v kontextu zastaveného programu a provádění Python skriptů pro automatizaci. Podle dat repozitáře LLVM podporuje LLDB více než 200 příkazů pro ladění a je kompatibilní s formáty DWARF a Mach-O — hlavními formáty informací o ladění v ekosystému Apple.

Důležitou výhodou LLDB je hluboká integrace s Clang. Díky použití stejného překladače pro parsování a kompilaci zdrojového kódu může LLDB vyhodnocovat výrazy C++ a Objective-C s přesností nedostupnou pro GDB. Pro ladění Swift používá LLDB samostatný modul Swift Language Runtime, který rozumí sémantice jazyka: volitelné typy, protokoly, generické typy a správu paměti prostřednictvím ARC.

Historie a vývoj

První verze LLDB se objevila v roce 2010 jako součást LLVM 2.8. Do roku 2013 zcela nahradil GDB v Xcode. V roce 2019 s vydáním Xcode 11 získal LLDB podporu pro Swift Error Breakpoints a vylepšený parser výrazů pro Swift. Podle údajů Apple od iOS 14 funguje celý zásobník ladění pro simulátor také přes LLDB, což potvrzuje jeho status hlavního ladicího nástroje platformy.

Architektura LLDB: moduly a komponenty

Architektura LLDB je postavena na principu mikroslužeb: každý subsystém existuje jako samostatná knihovna (dylib), propojená s ostatními prostřednictvím společného API. To jej odlišuje od GDB, kde jsou všechny funkce spojeny do jediného binárního souboru. Modulární struktura umožňuje nezávislé použití komponent LLDB — například parser výrazů lze vložit do IDE bez připojení plného debuggeru.

LLDB a ladicí symboly dSYM

dSYM — jsou soubory informací o ladění, které Xcode generuje při kompilaci. LLDB je používá k mapování strojového kódu na zdrojový kód: bez dSYM debugger zobrazuje pouze adresy v paměti místo názvů funkcí a řádků kódu. Pro aplikace z App Store jsou soubory dSYM nahrávány samostatně na server Apple a používány k symbolizaci crash-logů získaných od uživatelů prostřednictvím CrashReporter.

(lldb) target create MyApp.app
(lldb) image list MyApp
MyApp - "/path/to/MyApp.app/MyApp" (arm64)
(lldb) image lookup -n fetchUserData
Address: MyApp[0x1000a3b40] (MyApp.__TEXT.__text + 12352)
Summary: `ViewController.fetchUserData()` at ViewController.swift:42

Základní příkazy LLDB pro ladění

Příkazy LLDB se dělí do několika kategorií: řízení provádění, práce s breakpoints, inspekce dat a manipulace s pamětí. Na rozdíl od grafického rozhraní Xcode poskytuje konzole LLDB plnou kontrolu nad laděním a umožňuje provádět operace nedostupné přes grafické rozhraní — například změnu hodnoty proměnné za běhu nebo hromadnou úpravu breakpoints.

Příkazy pro řízení provádění

Continue, Step Over, Step Into, Step Out — základ ladicího cyklu. continue obnoví provádění do dalšího breakpointu. step over provede aktuální řádek celý. step into vstoupí do volané metody. step out ukončí aktuální funkci a vrátí řízení volajícímu kódu. Dále existuje step with type filter — krok do určeného datového typu.

(lldb) thread backtrace          # Zobrazit zásobník volání
* thread #1, queue = 'com.apple.main-thread'
    frame #0: 0x1000a3b40 ViewController`fetchUserData()
    frame #1: 0x1000a2000 ViewController`viewDidLoad()
    frame #2: 0x1a2b345 UIKit`UIViewController.loadView()
(lldb) frame variable          # Zobrazit lokální proměnné
(Int) userId = 42
(String) endpoint = "https://api.example.com/user/42"
(lldb) thread step-over        # Step Over
(lldb) thread step-in          # Step Into

Inspekce dat a formátovače

LLDB poskytuje příkazy pro prohlížení dat v libovolném formátu: memory read, frame variable, target variable. Speciální syntaxe po (print object) volá debugDescription u Objective-C objektů a description u Swift typů. Vlastní formátovače se nastavují pomocí type summary add — užitečné pro ladění složitých struktur, jako je CGRect nebo IndexPath.

(lldb) po userProfile           # Výpis popisu objektu
<UserProfile: 0x600000c4b80>
  - name: "John"
  - age: 30
  - email: "john@example.com"
(lldb) expression userProfile.age = 31    # Změnit hodnotu
(Int) $R0 = 31
(lldb) memory read 0x600000c4b80 0x600000c4bc0
0x600000c4b80: 6a 6f 68 6e 00 00 00 00 1e 00 00 00 00 00 00 00

Vyhodnocování výrazů a inspekce objektů

Vyhodnocování výrazů v LLDB je jednou z nejvýkonnějších funkcí, která v GDB v době jeho dominance chyběla. LLDB může provádět libovolný kód v C, Objective-C, C++ a Swift v kontextu zastaveného programu, včetně volání metod, vytváření objektů a modifikace stavu. To umožňuje testovat hypotézy bez restartování aplikace a překompilování.

Příkazy expression a po

Příkaz expression zkompiluje a provede výraz za běhu laděného procesu. Přepínač -O (object description) volá po. Pro víceřádkové výrazy použijte expression -l Swift --. LLDB kompiluje kód za běhu pomocí Clang nebo Swift Compiler, integruje výsledek do aktuálního kontextu a vrátí hodnotu. Podle Apple se výraz zkompiluje za 10–50 ms v závislosti na složitosti.

(lldb) expr -l Swift -- UIAlertController(title: "Test", message: nil,
  preferredStyle: .alert)
(lldb) expr let $arr = [1, 2, 3].map { $0 * 2 }
(lldb) po $arr
▿ 3 elements
  - 0 : 2
  - 1 : 4
  - 2 : 6

Modifikace objektů za běhu

LLDB umožňuje nejen číst, ale také měnit stav objektů a proměnných během ladění. To je klíčové pro testování okrajových případů: lze nastavit hodnotu proměnné na nil, změnit barvu prvku UI nebo nahradit odpověď serveru přímo v debuggeru, bez překompilování a restartu. Tato technika je široce používána při vývoji her a aplikací s dlouhými toky, kde restart zabere mnoho času.

(lldb) expr self.label.text = @"Updated"
(lldb) expr -l Swift -- (self as! UIViewController).view.backgroundColor = .red
(lldb) expr let $snapshot = self.view.debugQuickLookObject()

Skriptování v Pythonu v LLDB

Python API LLDB umožňuje psát skripty pro automatizaci ladění. Prostřednictvím Pythonu lze vytvářet vlastní příkazy, zpracovávat události breakpointů, generovat zprávy a dokonce přepisovat chování debuggeru. Vestavěný interpret Python 3 se spouští přímo uvnitř LLDB s přístupem k úplnému ladicímu API prostřednictvím modulu lldb.

Vytvoření vlastního příkazu

Nový příkaz LLDB lze zaregistrovat pomocí dekorátoru @classmethod v Python skriptu. Po importu skriptu je příkaz k dispozici jako vestavěný. Například příkaz printvars může zobrazit všechny proměnné aktuálního rámce s jejich typy a hodnotami, formátované pro konkrétní projekt. Automatizace zkracuje čas typických ladicích operací o 60–80%, podle průzkumu mezi iOS vývojáři na Stack Overflow.

import lldb

class PrintVarsCommand:
    @classmethod
    def register_class(cls, debugger, _):
        handler = PrintVarsCommand()
        debugger.HandleCommand('command script add -c \
            print_vars.PrintVarsCommand printvars')

    def __call__(self, debugger, command, exe_ctx, result):
        frame = exe_ctx.frame
        for var in frame.variables:
            result.AppendMessage(f"{var.name}: {var.type} = {var.value}")

Zpracování událostí breakpointů

Prostřednictvím Python API lze připojit skript k aktivaci breakpointu. Nastavte breakpoint, poté spusťte breakpoint command add a zadejte Python funkci. To umožňuje automaticky logovat stav, odesílat data do analytiky nebo kontrolovat invarianty bez ručního zásahu. Podle LLVM se tento přístup používá v infrastruktuře Apple pro sběr metrik výkonu ve fázi vývoje.

(lldb) breakpoint set -f Model.swift -l 100
(lldb) breakpoint command add 1 -s python -o "frame = exe_ctx.frame;
  print([var.name for var in frame.variables])"

Režim REPL a playground

REPL (Read-Eval-Print Loop) — interaktivní režim LLDB, vyvolaný příkazem lldb --repl nebo přes Xcode Debug Console. V REPL lze provádět kód v Swift nebo C jako v playgroundu s okamžitou zpětnou vazbou. LLDB každý řádek zkompiluje, provede a zobrazí výsledek — to je vhodné pro experimentování s API, prototypování algoritmů a učení se novým možnostem jazyka bez vytváření projektu.

(lldb) --repl
1> let numbers = [1, 2, 3, 4, 5]
2> numbers.filter { $0 % 2 == 0 }
$R0: [Int] = 2 values {
  [0] = 2
  [1] = 4
}
3> let result = numbers.reduce(0, +)
$R1: Int = 15

Režim REPL také podporuje načítání modulů a frameworků pomocí import. Například import UIKit v REPL načte celou knihovnu UIKit a lze vytvářet prvky UI, kontrolovat constrainty a testovat animace. To je jedinečná možnost pro iOS vývojáře, nedostupná v GDB — ladění a prototypování v jednom prostředí.

Použití REPL pro učení Swift

Díky integraci s Swift Compiler se LLDB REPL používá na kurzech Apple pro výuku Swift. Studenti mohou provádět kód řádek po řádku, vidět typy a výsledky, aniž by je rozptylovala konfigurace projektu. Tento přístup odpovídá metodě Active Learning, kde interaktivní zpětná vazba urychluje osvojení materiálu o 40% podle výzkumů v oblasti Computer Science Education.