LLDB: bu qanday debugger, asosiy buyruqlar va iOS dasturlashda qo'llanilishi

LLDB nima va u qanday tuzilgan

LLDB — LLVM loyihasi kutubxonalari asosida qurilgan ochiq kodli debugger. U Xcode 5 da GDB ni o'rnini egalladi va shundan beri butun Apple ekosistemasi uchun asosiy debug vositasi hisoblanadi. Monolit GDB dan farqli o'laroq, LLDB o'zaro hamkorlikdagi kutubxonalar to'plami sifatida amalga oshirilgan: har bir funksiya — ifodalarni parsering qilishdan tortib xotira bilan ishlashgacha — alohida modulga ajratilgan, bu texnik xizmat ko'rsatish va kengaytirishni osonlashtiradi.

LLDB ning asosiy imkoniyatlari quyidagilarni o'z ichiga oladi: har qanday turdagi breakpoints o'rnatish, o'zgaruvchilar o'zgarishini kuzatish uchun watchpoints, xotira va registrlarni tekshirish, bosqichma-bosqich bajarish, to'xtatilgan dastur kontekstida ixtiyoriy ifodalarni hisoblash va avtomatlashtirish uchun Python skriptlarini bajarish. LLVM repozitoriy ma'lumotlariga ko'ra, LLDB 200 dan ortiq debug buyruqlarini qo'llab-quvvatlaydi va Apple ekosistemasida debug ma'lumotlarining asosiy formatlari bo'lgan DWARF va Mach-O formatlari bilan mos keladi.

LLDB ning muhim afzalligi — Clang bilan chuqur integratsiyadir. Manba kodini parsering qilish va kompilyatsiya qilish uchun bir xil kompilyatordan foydalanish tufayli LLDB C++ va Objective-C ifodalarini GDB uchun mavjud bo'lmagan aniqlik bilan hisoblashi mumkin. Swift debug qilish uchun LLDB til semantikasini tushunadigan alohida Swift Language Runtime modulidan foydalanadi: ixtiyoriy turlar, protokollar, generiklar va ARC orqali xotira boshqaruvi.

Tarix va evolyutsiya

LLDB ning birinchi versiyasi 2010 yilda LLVM 2.8 ning bir qismi sifatida paydo bo'ldi. 2013 yilga kelib u Xcode da GDB ni to'liq almashtirdi. 2019 yilda Xcode 11 ning chiqarilishi bilan LLDB Swift Error Breakpoints qo'llab-quvvatlash va Swift uchun yaxshilangan ifoda parserini oldi. Apple ma'lumotlariga ko'ra, iOS 14 dan boshlab simulator uchun butun debug stack i ham LLDB orqali ishlaydi, bu uning platformaning asosiy debug vositasi maqomini tasdiqlaydi.

LLDB arxitekturasi: modullar va komponentlar

LLDB arxitekturasi mikroxizmatlar printsipi asosida qurilgan: har bir quyi tizim umumiy API orqali boshqalar bilan bog'langan alohida kutubxona (dylib) sifatida mavjud. Bu uni barcha funksiyalar bitta binar faylda birlashtirilgan GDB dan ajratib turadi. Modulli struktura LLDB komponentlaridan mustaqil foydalanish imkonini beradi — masalan, ifoda parserini to'liq debuggerni ulamasdan IDE ga o'rnatish mumkin.

LLDB va dSYM debug belgilari

dSYM — Xcode kompilyatsiya paytida yaratadigan debug ma'lumotlari fayllari. LLDB ulardan mashina kodini manba kodi bilan bog'lash uchun foydalanadi: dSYM bo'lmasa, debugger funksiya nomlari va kod satrlari o'rniga faqat xotira manzillarini ko'rsatadi. App Store ilovalari uchun dSYM fayllari Apple serveriga alohida yuklanadi va CrashReporter orqali foydalanuvchilardan olingan crash-log larni simvolizatsiya qilish uchun ishlatiladi.

(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

LLDB ning asosiy debug buyruqlari

LLDB buyruqlari bir necha toifaga bo'linadi: bajarishni boshqarish, breakpoints bilan ishlash, ma'lumotlarni tekshirish va xotira manipulyatsiyasi. Xcode GUI dan farqli o'laroq, LLDB konsoli debug ustidan to'liq nazoratni ta'minlaydi va grafik interfeys orqali mavjud bo'lmagan operatsiyalarni bajarishga imkon beradi — masalan, o'zgaruvchi qiymatini joyida o'zgartirish yoki breakpoints larni ommaviy tahrirlash.

Bajarishni boshqarish buyruqlari

Continue, Step Over, Step Into, Step Out — debug siklining asosidir. continue keyingi breakpoint gacha bajarishni davom ettiradi. step over joriy satrni to'liq bajaradi. step into chaqirilgan metod ichiga kiradi. step out joriy funksiyani tugatadi va boshqaruvni chaqiruvchi kodga qaytaradi. Qo'shimcha ravishda step with type filter mavjud — belgilangan ma'lumot turiga qadar qadam.

(lldb) thread backtrace          # Qo'ng'iroqlar stekini ko'rsatish
* 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          # Lokal o'zgaruvchilarni ko'rsatish
(Int) userId = 42
(String) endpoint = "https://api.example.com/user/42"
(lldb) thread step-over        # Step Over
(lldb) thread step-in          # Step Into

Ma'lumotlarni tekshirish va formatlagichlar

LLDB har qanday formatda ma'lumotlarni ko'rish uchun buyruqlarni taqdim etadi: memory read, frame variable, target variable. Maxsus po (print object) sintaksisi Objective-C obyektlarida debugDescription ni va Swift turlarida description ni chaqiradi. Maxsus formatlagichlar type summary add orqali o'rnatiladi — CGRect yoki IndexPath kabi murakkab strukturalarni debug qilish uchun foydali.

(lldb) po userProfile           # Ob'ekt tavsifini chiqarish
<UserProfile: 0x600000c4b80>
  - name: "John"
  - age: 30
  - email: "john@example.com"
(lldb) expression userProfile.age = 31    # Qiymatni o'zgartirish
(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

Ifodalarni hisoblash va obyekt inspeksiyasi

Ifodalarni hisoblash LLDB da GDB hukmronligi davrida mavjud bo'lmagan eng kuchli funksiyalardan biridir. LLDB to'xtatilgan dastur kontekstida C, Objective-C, C++ va Swift tillarida ixtiyoriy kodni bajarishi mumkin, jumladan metodlarni chaqirish, obyektlar yaratish va holatni o'zgartirish. Bu ilovani qayta ishga tushirmasdan va qayta kompilyatsiya qilmasdan gipotezalarni sinab ko'rish imkonini beradi.

expression va po buyruqlari

expression buyrug'i debug qilinayotgan jarayonning ish vaqtida ifodani kompilyatsiya qiladi va bajaradi. -O (object description) flag i po ni chaqiradi. Ko'p satrli ifodalar uchun expression -l Swift -- dan foydalaning. LLDB kodni joyida Clang yoki Swift Compiler orqali kompilyatsiya qiladi, natijani joriy kontekstga integratsiya qiladi va qiymatni qaytaradi. Apple ma'lumotlariga ko'ra, ifoda murakkabligiga qarab 10–50 ms ichida kompilyatsiya qilinadi.

(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

Obyektlarni joyida o'zgartirish

LLDB nafaqat o'qish, balki debug vaqtida obyektlar va o'zgaruvchilar holatini o'zgartirish imkonini ham beradi. Bu chekka holatlarni sinash uchun juda muhim: o'zgaruvchi qiymatini nil ga o'rnatish, UI elementi rangini o'zgartirish yoki server javobini to'g'ridan-to'g'ri debuggerda almashtirish mumkin, qayta kompilyatsiya qilmasdan va qayta ishga tushirmasdan. Bu texnika o'yinlar va uzoq oqimli ilovalarni ishlab chiqishda keng qo'llaniladi, bu erda qayta ishga tushirish ko'p vaqt oladi.

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

LLDB da Python skriptlash

Python API LLDB debug jarayonini avtomatlashtirish uchun skriptlar yozish imkonini beradi. Python orqali maxsus buyruqlar yaratish, breakpoint hodisalarini qayta ishlash, hisobotlar yaratish va hatto debugger xatti-harakatini o'zgartirish mumkin. O'rnatilgan Python 3 interpretatori to'g'ridan-to'g'ri LLDB ichida ishga tushadi va lldb moduli orqali to'liq debug API siga kirish imkoniyatiga ega.

Maxsus buyruq yaratish

Yangi LLDB buyrug'ini Python skriptida @classmethod dekoratori orqali ro'yxatdan o'tkazish mumkin. Skript import qilingandan so'ng, buyruq o'rnatilgan buyruq sifatida mavjud bo'ladi. Masalan, printvars buyrug'i joriy ramkaning barcha o'zgaruvchilarini turlari va qiymatlari bilan, ma'lum bir loyiha uchun formatlangan holda ko'rsatishi mumkin. Avtomatlashtirish odatdagi debug operatsiyalari vaqtini 60–80% ga qisqartiradi, Stack Overflow da iOS dasturchilari o'rtasida o'tkazilgan so'rovnomaga ko'ra.

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 hodisalarini qayta ishlash

Python API orqali breakpoint ishga tushishiga skript biriktirish mumkin. Breakpoint o'rnating, keyin breakpoint command add ni bajaring va Python funksiyasini ko'rsating. Bu avtomatik ravishda holatni loglash, analitikaga ma'lumot yuborish yoki qo'lda aralashmasdan invariantlarni tekshirish imkonini beradi. LLVM ma'lumotlariga ko'ra, bu yondashuv Apple infratuzilmasida ishlab chiqish bosqichida ishlash ko'rsatkichlarini yig'ish uchun qo'llaniladi.

(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 rejimi va playground

REPL (Read-Eval-Print Loop) — lldb --repl buyrug'i yoki Xcode Debug Console orqali chaqiriladigan interaktiv LLDB rejimi. REPL da Swift yoki C tilida kodni playground dagi kabi, bir zumda qayta aloqa bilan bajarish mumkin. LLDB har bir satrni kompilyatsiya qiladi, bajaradi va natijani ko'rsatadi — bu API bilan tajriba o'tkazish, algoritmlarni prototiplash va loyiha yaratmasdan tilning yangi imkoniyatlarini o'rganish uchun qulay.

(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

REPL rejimi shuningdek import orqali modul va freymvorklarni yuklashni qo'llab-quvvatlaydi. Masalan, REPL da import UIKit butun UIKit kutubxonasini yuklaydi va UI elementlari yaratish, constraint larni tekshirish va animatsiyalarni sinash mumkin. Bu iOS dasturchilari uchun GDB da mavjud bo'lmagan noyob imkoniyatdir — debug va prototiplash bir muhitda.

Swift ni o'rganish uchun REPL dan foydalanish

Swift Compiler bilan integratsiya tufayli LLDB REPL Apple kurslarida Swift ni o'rgatish uchun qo'llaniladi. Talabalar kodni satrma-satr bajarishlari, turlar va natijalarni ko'rishlari mumkin, loyiha sozlamalari bilan chalg'imasdan. Bu yondashuv Active Learning metodikasiga mos keladi, bu erda interaktiv qayta aloqa Computer Science Education sohasidagi tadqiqotlarga ko'ra materialni o'zlashtirishni 40% tezlashtiradi.