LLDB: milyen debugger ez, fő parancsok és alkalmazás iOS-fejlesztésben

Mi az LLDB és hogyan épül fel

LLDB — egy nyílt forráskódú debugger, amely az LLVM-projekt könyvtáraira épül. Az Xcode 5-ben váltotta fel a GDB-t, és azóta az Apple teljes ökoszisztémájának fő hibakereső eszköze. A monolitikus GDB-vel ellentétben az LLDB együttműködő könyvtárak halmazaként van megvalósítva: minden funkció — a kifejezések elemzésétől a memóriával való munkáig — külön modulba van szervezve, ami egyszerűsíti a karbantartást és bővítést.

Az LLDB fő képességei közé tartozik: bármilyen típusú breakpoints beállítása, watchpoints a változók változásainak nyomon követésére, memória és regiszterek vizsgálata, lépésenkénti végrehajtás, tetszőleges kifejezések kiértékelése a megállított program kontextusában és Python-szkriptek végrehajtása automatizáláshoz. Az LLVM adattár adatai szerint az LLDB több mint 200 hibakeresési parancsot támogat, és kompatibilis a DWARF és Mach-O formátumokkal — az Apple ökoszisztémájában a hibakeresési információ fő formátumaival.

Az LLDB fontos előnye a mély integráció a Clang-gal. Annak köszönhetően, hogy ugyanazt a fordítót használja a forráskód elemzéséhez és fordításához, az LLDB képes a C++ és Objective-C kifejezéseket olyan pontossággal kiértékelni, amely a GDB számára elérhetetlen. A Swift hibakereséshez az LLDB egy külön Swift Language Runtime modult használ, amely érti a nyelv szemantikáját: opcionális típusok, protokollok, generikusok és memóriakezelés ARC-en keresztül.

Történelem és fejlődés

Az LLDB első verziója 2010-ben jelent meg az LLVM 2.8 részeként. 2013-ra teljesen felváltotta a GDB-t az Xcode-ban. 2019-ben az Xcode 11 megjelenésével az LLDB támogatást kapott a Swift Error Breakpoints-hoz és egy továbbfejlesztett kifejezés-elemzőt a Swift számára. Az Apple adatai szerint az iOS 14-től kezdve a szimulátor teljes hibakeresési verme is az LLDB-n keresztül működik, ami megerősíti a platform elsődleges hibakereső eszközeként betöltött státuszát.

LLDB architektúrája: modulok és összetevők

Az LLDB architektúrája a mikroszolgáltatások elvén épül fel: minden alrendszer külön könyvtárként (dylib) létezik, amelyek egy közös API-n keresztül kapcsolódnak egymáshoz. Ez különbözteti meg a GDB-től, ahol az összes funkció egyetlen bináris fájlba van egyesítve. A moduláris szerkezet lehetővé teszi az LLDB-összetevők független használatát — például a kifejezés-elemző beágyazható egy IDE-be anélkül, hogy a teljes debuggert csatlakoztatnánk.

LLDB és dSYM hibakeresési szimbólumok

dSYM — a hibakeresési információ fájljai, amelyeket az Xcode generál a fordítás során. Az LLDB ezeket használja a gépi kód forráskódhoz való hozzárendeléséhez: dSYM nélkül a debugger csak memóriacímeket mutat függvénynevek és kódsorok helyett. Az App Store-alkalmazások esetében a dSYM-fájlok külön feltöltésre kerülnek az Apple szerverére, és a CrashReporter-en keresztül a felhasználóktól kapott crash-logok szimbolizálására használják őket.

(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

Az LLDB alapvető hibakeresési parancsai

Az LLDB parancsai több kategóriába sorolhatók: végrehajtás kezelése, breakpoints kezelése, adatvizsgálat és memóriamanipuláció. Az Xcode grafikus felületével ellentétben az LLDB konzol teljes irányítást biztosít a hibakeresés felett, és lehetővé teszi a grafikus felületen keresztül nem elérhető műveletek végrehajtását — például egy változó értékének menet közbeni módosítását vagy breakpoints tömeges szerkesztését.

Végrehajtást kezelő parancsok

Continue, Step Over, Step Into, Step Out — a hibakeresési ciklus alapjai. A continue folytatja a végrehajtást a következő breakpoint-ig. A step over az aktuális sort hajtja végre teljes egészében. A step into belép a meghívott metódusba. A step out befejezi az aktuális függvényt, és visszaadja a vezérlést a hívó kódnak. Ezen kívül létezik step with type filter — lépés egy meghatározott adattípusig.

(lldb) thread backtrace          # Hívási verem megjelenítése
* 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          # Helyi változók megjelenítése
(Int) userId = 42
(String) endpoint = "https://api.example.com/user/42"
(lldb) thread step-over        # Step Over
(lldb) thread step-in          # Step Into

Adatvizsgálat és formázók

Az LLDB parancsokat biztosít az adatok bármilyen formátumban történő megtekintéséhez: memory read, frame variable, target variable. A speciális po (print object) szintaxis meghívja a debugDescription-t Objective-C objektumoknál és a description-t Swift típusoknál. Egyéni formázók a type summary add segítségével állíthatók be — hasznos az olyan összetett struktúrák hibakereséséhez, mint a CGRect vagy az IndexPath.

(lldb) po userProfile           # Az objektum leírásának kiírása
<UserProfile: 0x600000c4b80>
  - name: "John"
  - age: 30
  - email: "john@example.com"
(lldb) expression userProfile.age = 31    # Érték módosítása
(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

Kifejezések kiértékelése és objektumok vizsgálata

Kifejezések kiértékelése az LLDB-ben az egyik legerősebb funkció, amely hiányzott a GDB-ből a dominanciája idején. Az LLDB képes tetszőleges kódot végrehajtani C, Objective-C, C++ és Swift nyelven a megállított program kontextusában, beleértve metódusok hívását, objektumok létrehozását és állapot módosítását. Ez lehetővé teszi hipotézisek tesztelését az alkalmazás újraindítása és újrafordítása nélkül.

Az expression és po parancsok

Az expression parancs lefordítja és végrehajt egy kifejezést a hibakeresett folyamat futásidejében. A -O (object description) kapcsoló a po-t hívja meg. Többsoros kifejezésekhez használja az expression -l Swift ---t. Az LLDB menet közben fordítja le a kódot a Clang vagy Swift Compiler segítségével, integrálja az eredményt az aktuális kontextusba, és visszaadja az értéket. Az Apple adatai szerint egy kifejezés 10–50 ms alatt fordul le a komplexitástól függően.

(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

Objektumok menet közbeni módosítása

Az LLDB nemcsak olvasni, hanem módosítani is képes az objektumok és változók állapotát hibakeresés közben. Ez kritikus fontosságú a határesetek teszteléséhez: beállítható egy változó értéke nil-re, megváltoztatható egy UI-elem színe, vagy helyettesíthető a szerver válasza közvetlenül a debuggerben, újrafordítás és újraindítás nélkül. Ezt a technikát széles körben használják játékok és hosszú folyamatú alkalmazások fejlesztésében, ahol az újraindítás sok időt vesz igénybe.

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

Python szkriptelés az LLDB-ben

Python API az LLDB-ben lehetővé teszi szkriptek írását a hibakeresés automatizálásához. Python segítségével egyéni parancsok hozhatók létre, breakpoint-események dolgozhatók fel, jelentések generálhatók, sőt a debugger viselkedése is felülírható. A beépített Python 3 interpreter közvetlenül az LLDB-ben indul el, hozzáféréssel a teljes hibakeresési API-hoz a lldb modulon keresztül.

Egyéni parancs létrehozása

Egy új LLDB-parancs regisztrálható a @classmethod dekorátor segítségével egy Python-szkriptben. A szkript importálása után a parancs beépített parancsként válik elérhetővé. Például a printvars parancs megjelenítheti az aktuális keret összes változóját típusaikkal és értékeikkel együtt, egy adott projektre formázva. Az automatizálás 60–80%-kal csökkenti a tipikus hibakeresési műveletek idejét a Stack Overflow-n végzett iOS-fejlesztői felmérés szerint.

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}")

Breakpoint-események kezelése

A Python API-n keresztül szkript csatolható egy breakpoint aktiválódásához. Állítson be breakpoint-ot, majd hajtsa végre a breakpoint command add parancsot, és adjon meg egy Python-függvényt. Ez lehetővé teszi az állapot automatikus naplózását, adatok küldését az analitikába vagy invariánsok ellenőrzését kézi beavatkozás nélkül. Az LLVM adatai szerint ezt a megközelítést az Apple infrastruktúrájában használják teljesítménymutatók gyűjtésére a fejlesztési szakaszban.

(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])"

REPL mód és playground

REPL (Read-Eval-Print Loop) — az LLDB interaktív módja, amely a lldb --repl paranccsal vagy az Xcode Debug Console-on keresztül hívható meg. REPL-ben a Swift vagy C kód úgy hajtható végre, mint egy playground-ban, azonnali visszajelzéssel. Az LLDB minden sort lefordít, végrehajtja, és megjeleníti az eredményt — ez kényelmes az API-kkal való kísérletezéshez, algoritmusok prototipizálásához és a nyelv új képességeinek megtanulásához projekt létrehozása nélkül.

(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

A REPL mód támogatja továbbá modulok és keretrendszerek betöltését az import segítségével. Például az import UIKit a REPL-ben betölti a teljes UIKit könyvtárat, és UI-elemek hozhatók létre, korlátozások ellenőrizhetők és animációk tesztelhetők. Ez egy egyedülálló képesség az iOS-fejlesztők számára, amely nem elérhető a GDB-ben — hibakeresés és prototipizálás egyetlen környezetben.

REPL használata a Swift tanulásához

A Swift Compiler-rel való integrációnak köszönhetően az LLDB REPL-t az Apple tanfolyamain használják a Swift oktatására. A hallgatók soronként hajthatják végre a kódot, láthatják a típusokat és eredményeket anélkül, hogy a projekt konfigurálása elvonná a figyelmüket. Ez a megközelítés összhangban van az Active Learning módszerrel, ahol az interaktív visszajelzés a Computer Science Education kutatásai szerint 40%-kal gyorsítja az anyag elsajátítását.