GDB and LLDB · 9/12

GDB·LLDB Python 스크립팅 — Pretty-Printer·Custom Command

2026년 5월 24일 · Hawk · 8분 읽기

GDB와 LLDB 모두 Python 인터프리터를 내장합니다. 단순한 매크로는 GDB의 user-defined command로도 되지만, 데이터 구조 시각화나 조건이 복잡한 자동화에는 Python이 거의 유일한 답입니다. STL 컨테이너가 vector<int>{1, 2, 3}처럼 깔끔히 보이는 것도 모두 pretty-printer 덕입니다.

이 장은 GDB Python API의 핵심 객체에서 출발해 어떻게 pretty-printer가 동작하는지, MI 프런트엔드(VSCode 등)가 어떻게 트리를 그리는지, FrameDecorator로 콜스택을 변형, 그리고 LLDB의 SB API까지 다룹니다.

#시작 — 한 줄 Python

1
(gdb) python print("hello from gdb")
2
hello from gdb
3

4
(gdb) python
5
>import os
6
>print(os.getpid())
7
>end
8
12345
9

10
(gdb) source script.py

python ... end로 여러 줄, python <expr>로 한 줄. 외부 파일은 source. .gdbinit에 자동 로드되게 박아 둘 수 있습니다.

GDB가 내장한 Python의 버전은 GDB 빌드 시점의 옵션입니다. python print(sys.version)으로 확인. 보통 Python 3.6+. 대부분의 표준 라이브러리는 쓸 수 있지만, 외부 시스템 Python의 venv·third-party 패키지는 별도 설정이 필요합니다.

1
(gdb) python
2
>>> import sys
3
>>> sys.path.insert(0, '/home/me/venv/lib/python3.10/site-packages')
4
>>> import numpy   # 이제 외부 패키지 사용 가능

LLDB는 script.

1
(lldb) script print("hello")
2
(lldb) command script import my_module.py

LLDB는 lldb 모듈을 직접 import해 외부 스크립트로도 디버거를 원격 제어 가능합니다 (스크립트가 lldb 인스턴스를 생성).

#gdb 모듈 — 진입점

1
import gdb
2

3
gdb.execute("info threads")              # 명령 실행
4
val = gdb.parse_and_eval("my_var + 1")   # 표현식 평가
5
print(val, type(val))                    # gdb.Value, gdb.Type
6

7
frame = gdb.selected_frame()             # 현재 프레임
8
print(frame.name(), frame.pc())
9

10
inferior = gdb.selected_inferior()
11
print(inferior.pid)

핵심 객체.

객체	역할	주요 메서드
`gdb.Value`	디버기 안의 값(int/string/struct/포인터)	`int()`, `string()`, `[key]`, `cast()`, `dereference()`
`gdb.Type`	타입 정보(size, fields, target)	`sizeof`, `fields()`, `target()`, `tag`
`gdb.Frame`	콜스택 한 프레임	`name()`, `pc()`, `function()`, `read_var()`, `older()`, `newer()`
`gdb.Symbol`	변수·함수 심볼	`name`, `type`, `value()`, `is_function`, `addr_class`
`gdb.Breakpoint`	브레이크포인트 (subclass로 stop hook 구현)	`stop()`, `enabled`, `condition`, `commands`
`gdb.Inferior`	프로세스	`pid`, `threads()`, `read_memory()`, `write_memory()`, `search_memory()`
`gdb.Thread`	스레드	`switch()`, `is_stopped()`, `is_running()`
`gdb.Objfile`	로드된 ELF 파일	`filename`, `build_id`, `progspace`

gdb.Value가 가장 자주 다루는 객체입니다. 내부적으로 디버기 메모리의 한 영역을 가리키는 핸들. 산술 연산도 가능.

1
v = gdb.parse_and_eval("my_array")        # gdb.Value
2
length = v['length']                       # 멤버 접근
3
data = v['data']                           # 포인터
4
first = data.dereference()                 # *data
5
nth = data[5]                              # data[5]
6
sliced = data[0:10]                        # 슬라이스 (10개)
7

8
# Python 타입으로 변환
9
n = int(v['count'])
10
s = v['name'].string()                     # C string

#첫 예 — 커스텀 명령

이름 그대로 GDB의 새 명령을 Python으로 정의합니다.

1
import gdb
2

3
class HelloCmd(gdb.Command):
4
    """간단한 인사 명령."""
5

6
    def __init__(self):
7
        super().__init__("hello", gdb.COMMAND_USER)
8

9
    def invoke(self, arg, from_tty):
10
        argv = gdb.string_to_argv(arg)
11
        name = argv[0] if argv else "world"
12
        gdb.write(f"hello, {name}\n")
13

14
HelloCmd()

1
(gdb) source myhello.py
2
(gdb) hello
3
hello, world
4
(gdb) hello GDB
5
hello, GDB

gdb.COMMAND_* 카테고리: BREAKPOINTS, DATA, STACK, RUNNING, USER, SUPPORT. 사용자에게 help <cat>로 분류해 보여 줍니다.

#자동 완성

1
class MyCmd(gdb.Command):
2
    def __init__(self):
3
        super().__init__("mycmd", gdb.COMMAND_USER, gdb.COMPLETE_SYMBOL)
4

5
    def invoke(self, arg, from_tty):
6
        ...

COMPLETE_SYMBOL / COMPLETE_LOCATION / COMPLETE_FILENAME / COMPLETE_COMMAND 중 하나. 탭으로 자동 완성됩니다.

#Prefix 명령 (서브 명령 트리)

1
class MyTop(gdb.Command):
2
    def __init__(self):
3
        super().__init__("my", gdb.COMMAND_USER, prefix=True)
4
    def invoke(self, arg, from_tty):
5
        gdb.execute("help my")    # 인자 없으면 도움말
6

7
class MySub(gdb.Command):
8
    def __init__(self):
9
        super().__init__("my list", gdb.COMMAND_USER)
10
    def invoke(self, arg, from_tty):
11
        gdb.write("listing...\n")
12

13
MyTop(); MySub()

my list 형태로 호출. 큰 도구 모음을 my <sub> 트리로 묶으면 깔끔합니다.

#두 번째 예 — 자동 브레이크포인트 액션

브레이크포인트가 잡힐 때마다 Python으로 처리.

1
import gdb
2

3
class LogAllocs(gdb.Breakpoint):
4
    def __init__(self):
5
        super().__init__("malloc")
6

7
    def stop(self):
8
        size = gdb.parse_and_eval("$rdi")   # x86-64 첫 인자
9
        gdb.write(f"malloc({size})\n")
10
        return False                         # False = 정지하지 말고 계속
11

12
LogAllocs()

stop이 False를 반환하면 사용자에게 제어가 안 넘어가고 자동으로 continue. Ch 5의 commands silent+printf와 같은 효과지만 Python으로 조건을 만들 수 있습니다.

1
def stop(self):
2
    size = int(gdb.parse_and_eval("$rdi"))
3
    if size > 1024 * 1024:
4
        gdb.write(f"big malloc: {size}\n")
5
        # 콜스택까지
6
        gdb.execute("bt 5")
7
        return True  # 큰 할당만 정지
8
    return False

#종합 — 메모리 누수 추적

malloc/free의 짝을 카운트해 어디서 새는지 추적.

1
import gdb
2
from collections import defaultdict
3

4
class MallocTrack(gdb.Breakpoint):
5
    def __init__(self, table):
6
        super().__init__("malloc")
7
        self.table = table
8

9
    def stop(self):
10
        size = int(gdb.parse_and_eval("$rdi"))
11
        # 콜스택 해시
12
        frame = gdb.selected_frame()
13
        callstack = []
14
        for _ in range(5):
15
            frame = frame.older()
16
            if not frame: break
17
            callstack.append(frame.name() or '??')
18
        key = tuple(callstack)
19

20
        # 다음 step에서 반환값(rax) 기록
21
        gdb.events.stop.connect(lambda e: self._record(e, size, key))
22
        return False
23

24
    def _record(self, e, size, key):
25
        ret = int(gdb.parse_and_eval("$rax"))
26
        self.table[ret] = (size, key)
27

28
class FreeTrack(gdb.Breakpoint):
29
    def __init__(self, table):
30
        super().__init__("free")
31
        self.table = table
32
    def stop(self):
33
        addr = int(gdb.parse_and_eval("$rdi"))
34
        self.table.pop(addr, None)
35
        return False
36

37
table = {}
38
MallocTrack(table); FreeTrack(table)
39

40
# 프로그램 종료 시 누수 출력
41
def dump(_evt):
42
    by_stack = defaultdict(lambda: [0, 0])
43
    for addr, (size, stack) in table.items():
44
        by_stack[stack][0] += size
45
        by_stack[stack][1] += 1
46
    for stack, (size, n) in sorted(by_stack.items(), key=lambda x: -x[1][0])[:20]:
47
        print(f"{size:>10} bytes / {n:>6} blocks @ {' -> '.join(stack)}")
48

49
gdb.events.exited.connect(dump)

ASan보다 거칠지만 원리가 보이는 미니 누수 추적기. 실제로는 valgrind나 ASan이 훨씬 견고합니다.

#Pretty-Printer — 구조체를 사람 읽을 형태로

가장 자주 만들어지는 확장. std::vector<int> 같은 STL 컨테이너가 멤버 변수의 원시 형태가 아니라 {1, 2, 3, 4, 5}로 보이는 이유입니다.

#동작 원리

GDB가 print v를 받으면.

v의 타입을 알아냄 (gdb.Value.type).
등록된 pretty-printer 중 이 타입 이름이 매칭되는 게 있는지 확인 (regex).
매칭되면 그 클래스 인스턴스를 만들어 to_string() 호출. 결과를 출력.
children() 메서드가 있으면 자식 노드 순회.
display_hint()가 있으면 그 힌트("array", "map", "string")로 표시 방식 결정.

매칭이 없으면 원시 출력({x = 3, y = 4}).

#단순 printer

1
import gdb
2
import gdb.printing
3

4
class MyPointPrinter:
5
    """struct Point { int x, y; } 용 pretty-printer."""
6

7
    def __init__(self, val):
8
        self.val = val
9

10
    def to_string(self):
11
        x = int(self.val['x'])
12
        y = int(self.val['y'])
13
        return f"Point({x}, {y})"
14

15
def build_pretty_printer():
16
    pp = gdb.printing.RegexpCollectionPrettyPrinter("myproject")
17
    pp.add_printer('Point', '^Point$', MyPointPrinter)
18
    return pp
19

20
gdb.printing.register_pretty_printer(
21
    gdb.current_objfile(),
22
    build_pretty_printer())

이제 print 했을 때:

1
(gdb) print p
2
$1 = Point(3, 4)

원시 형태로 보고 싶으면 /r.

1
(gdb) print /r p
2
$2 = {x = 3, y = 4}

#컬렉션 — children 추가

벡터·맵 같은 시퀀스는 children() 메서드로 원소를 표현합니다.

1
class MyListPrinter:
2
    def __init__(self, val):
3
        self.val = val
4

5
    def to_string(self):
6
        size = int(self.val['size'])
7
        return f"MyList of length {size}"
8

9
    def children(self):
10
        size = int(self.val['size'])
11
        data = self.val['data']
12
        for i in range(size):
13
            yield f"[{i}]", data[i]
14

15
    def display_hint(self):
16
        return "array"

display_hint는 GDB에게 표시 방식을 알림.

hint	표시
`"array"`	`[0] = .., [1] = ..` 인덱스 형식
`"map"`	`[key] = value` 쌍 (children이 key, value 교대 emit)
`"string"`	따옴표 + 이스케이프

MI(머신 인터페이스) 프런트엔드(VSCode 등)가 이 힌트를 이용해 트리 위젯을 그립니다.

#Map printer 예

1
class MyMapPrinter:
2
    def __init__(self, val):
3
        self.val = val
4
    def to_string(self):
5
        return f"MyMap of {int(self.val['size'])} elements"
6
    def children(self):
7
        # children이 (key0, value0, key1, value1, ...) 순서로 emit
8
        node = self.val['root']
9
        for i in range(int(self.val['size'])):
10
            yield f"key{i}", node['key']
11
            yield f"val{i}", node['value']
12
            node = node['next']
13
    def display_hint(self):
14
        return "map"

1
(gdb) print m
2
$1 = MyMap of 3 elements = {
3
  ["foo"] = 1,
4
  ["bar"] = 2,
5
  ["baz"] = 3
6
}

#auto-load — 빌드 시 자동 적용

libfoo.so마다 libfoo.so-gdb.py가 같이 설치돼 있으면 GDB가 그 라이브러리를 로드할 때 자동으로 그 스크립트를 실행합니다 — pretty-printer가 자동 등록.

1
# 라이브러리와 같은 디렉터리에 두기
2
/usr/lib/libfoo.so
3
/usr/lib/libfoo.so-gdb.py    # 라이브러리 로드 시 source됨

배포 시 라이브러리에 따라가는 pretty-printer를 번들로 제공하는 표준 방법. libstdc++의 STL printer가 이런 식으로 배포됩니다.

1
(gdb) set auto-load safe-path /

보안상 알려진 경로만 auto-load가 허용. 신뢰하는 환경에선 /로 풀어 둡니다.

#libstdc++ / libc++ pretty-printer

이미 만들어진 것을 받아 쓰는 게 보통입니다.

1
# libstdc++ (GCC 소스에 포함)
2
$ git clone https://gcc.gnu.org/git/gcc.git
3
$ ls gcc/libstdc++-v3/python/libstdcxx/v6/printers.py

~/.gdbinit에 등록.

1
python
2
import sys
3
sys.path.insert(0, '/path/to/libstdcxx/python')
4
from libstdcxx.v6.printers import register_libstdcxx_printers
5
register_libstdcxx_printers(None)
6
end

대부분의 배포판은 GDB 패키지가 자동으로 등록합니다. macOS의 libc++는 LLVM 소스의 utils/gdb/libcxx/printers.py.

이 패키지 안에 StdVectorPrinter, StdMapPrinter, StdStringPrinter 등 STL의 거의 모든 컨테이너 printer가 있습니다. 새 컨테이너가 추가될 때마다 (std::span, std::flat_map) 같이 갱신됩니다.

#트리 / 그래프 시각화

복잡한 구조는 그래프뷰가 가장 빠릅니다. gdb.Command로 viz 같은 명령을 만들어 자료구조를 DOT으로 출력하면 외부 graphviz로 PNG 변환.

1
import gdb
2

3
class VizTree(gdb.Command):
4
    def __init__(self):
5
        super().__init__("viz_tree", gdb.COMMAND_USER)
6

7
    def invoke(self, arg, from_tty):
8
        root = gdb.parse_and_eval(arg)
9
        with open("/tmp/tree.dot", "w") as f:
10
            f.write("digraph G {\n")
11
            self._walk(root, f)
12
            f.write("}\n")
13
        gdb.write("wrote /tmp/tree.dot\n")
14

15
    def _walk(self, node, f):
16
        if int(node) == 0:
17
            return
18
        val = int(node['value'])
19
        f.write(f'  n{int(node)} [label="{val}"];\n')
20
        for side in ('left', 'right'):
21
            child = node[side]
22
            if int(child) != 0:
23
                f.write(f'  n{int(node)} -> n{int(child)};\n')
24
                self._walk(child, f)
25

26
VizTree()

1
(gdb) viz_tree root
2
wrote /tmp/tree.dot
3
$ dot -Tpng /tmp/tree.dot > tree.png

링크드 리스트·해시 테이블·트리·그래프 — 모두 같은 패턴. 큰 자료구조 디버깅에서 시각화는 콘솔 출력과 비교가 안 됩니다.

#Convenience function

$<name>(...) 형태로 식 안에서 부를 수 있는 함수.

1
import gdb
2

3
class StrLen(gdb.Function):
4
    """문자열 길이를 반환."""
5

6
    def __init__(self):
7
        super().__init__("strlen2")
8

9
    def invoke(self, str_arg):
10
        s = str_arg.string()
11
        return len(s)
12

13
StrLen()

1
(gdb) print $strlen2(msg)
2
$1 = 12

조건부 BP에 쓰면 매우 강력합니다.

1
(gdb) break process if $strlen2(msg) > 100

#Frame filter — 콜스택 가공

특정 라이브러리 프레임을 숨기거나 합치고 싶을 때. 비동기 코드(future/coroutine)의 콜스택을 의미 있는 단위로 묶을 때 자주 씁니다.

1
class SkipBoostFilter:
2
    def __init__(self):
3
        self.name = "skip-boost"
4
        self.priority = 100
5
        self.enabled = True
6
        gdb.frame_filters[self.name] = self
7

8
    def filter(self, frame_iter):
9
        for frame in frame_iter:
10
            name = frame.function() or ""
11
            if "boost::" not in name:
12
                yield frame
13

14
SkipBoostFilter()

#FrameDecorator — 프레임을 변형

원본 프레임을 감싸 function(), address(), frame_args() 등을 가로채 다른 값을 반환할 수 있습니다.

1
from gdb.FrameDecorator import FrameDecorator
2

3
class FoldedCoroFrame(FrameDecorator):
4
    def __init__(self, frame, inner_frames):
5
        super().__init__(frame)
6
        self.inner = inner_frames
7

8
    def function(self):
9
        # 코루틴 awaiter 체인을 한 줄로
10
        names = [f.function() or '??' for f in self.inner]
11
        return ' → '.join(names)

std::coroutine이나 boost::asio의 깊은 콜스택을 논리적 한 단계로 압축하는 데 유용. Stripe·Bloomberg 같은 대형 C++ 환경의 디버깅 인프라가 이런 식으로 비대한 콜스택을 다듬습니다.

#Unwinder — 콜스택 직접 풀기

DWARF로 풀리지 않는 특수 frame이 있으면 (예: JIT 코드, 인터프리터) Python으로 직접 unwinder를 제공.

1
class JitUnwinder(gdb.unwinder.Unwinder):
2
    def __init__(self):
3
        super().__init__("jit-unwinder")
4
    def __call__(self, pending_frame):
5
        pc = pending_frame.read_register("pc")
6
        if not in_jit_region(int(pc)):
7
            return None
8
        # JIT 사이드 테이블에서 frame 정보 추출
9
        next_pc = lookup_jit_frame(int(pc))
10
        sp = pending_frame.read_register("sp")
11
        unwind_info = pending_frame.create_unwind_info(...)
12
        unwind_info.add_saved_register("pc", next_pc)
13
        return unwind_info
14

15
gdb.unwinder.register_unwinder(None, JitUnwinder(), replace=False)

V8, HotSpot JVM 같은 환경의 디버깅 지원이 이 메커니즘 위에 만들어집니다.

#Event 훅

1
def on_stop(event):
2
    print(f"stopped at {gdb.selected_frame().name()}")
3

4
def on_exit(event):
5
    print(f"exit code {event.exit_code}")
6

7
def on_new_obj(event):
8
    print(f"loaded {event.new_objfile.filename}")
9

10
gdb.events.stop.connect(on_stop)
11
gdb.events.exited.connect(on_exit)
12
gdb.events.new_objfile.connect(on_new_obj)

특정 라이브러리가 로드되는 순간 자동으로 BP를 설치하거나, 매 정지 시 콜스택을 외부 파일로 떨어뜨리는 등의 자동화.

#MI — 머신 인터페이스 (IDE 통합)

VSCode·Emacs gud·DDD 같은 프런트엔드는 MI (Machine Interface) 프로토콜로 GDB와 통신합니다. CLI 출력 대신 구조화된 명령·응답.

1
(gdb) -exec-run
2
^running
3
(gdb) -break-insert main
4
^done,bkpt={number="1",type="breakpoint",addr="0x...",func="main",...}

Python pretty-printer는 MI 출력에도 반영됩니다 — VSCode의 변수 패널이 트리로 보이는 이유. display_hint의 "array"/"map"이 MI 응답에 포함돼 IDE가 트리를 그립니다.

직접 MI를 다룰 일은 거의 없지만, IDE 디버깅이 왜 그렇게 보이는지의 답은 여기 있습니다.

#LLDB의 Python — 다른 API

LLDB도 Python 내장이지만 API가 다릅니다.

1
(lldb) script
2
>>> target = lldb.debugger.GetSelectedTarget()
3
>>> process = target.GetProcess()
4
>>> thread = process.GetSelectedThread()
5
>>> frame = thread.GetSelectedFrame()
6
>>> print(frame.GetFunctionName())

핵심 클래스가 SBTarget, SBProcess, SBThread, SBFrame, SBValue. SB는 “Scripted Bridge”. 모두 lldb 모듈에 있습니다.

GDB	LLDB
`gdb.Value`	`lldb.SBValue`
`gdb.Type`	`lldb.SBType`
`gdb.Frame`	`lldb.SBFrame`
`gdb.Inferior`	`lldb.SBProcess`
`gdb.parse_and_eval(...)`	`frame.EvaluateExpression(...)`
`gdb.execute(...)`	`lldb.debugger.HandleCommand(...)`

#LLDB 커스텀 명령

1
import lldb
2

3
def hello(debugger, command, result, internal_dict):
4
    result.PutCString(f"hello, {command or 'world'}")
5

6
def __lldb_init_module(debugger, internal_dict):
7
    debugger.HandleCommand('command script add -f my_cmds.hello hello')

1
(lldb) command script import my_cmds.py
2
(lldb) hello LLDB
3
hello, LLDB

#LLDB pretty-printer

type summary와 type synthetic이 GDB의 pretty-printer 역할.

1
def Point_SummaryProvider(valobj, internal_dict):
2
    x = valobj.GetChildMemberWithName('x').GetValueAsSigned()
3
    y = valobj.GetChildMemberWithName('y').GetValueAsSigned()
4
    return f"Point({x}, {y})"
5

6
class MyListProvider:
7
    def __init__(self, valobj, dict):
8
        self.valobj = valobj
9
    def num_children(self):
10
        return self.valobj.GetChildMemberWithName('size').GetValueAsUnsigned()
11
    def get_child_at_index(self, idx):
12
        data = self.valobj.GetChildMemberWithName('data')
13
        return data.GetChildAtIndex(idx, lldb.eNoDynamicValues, True)
14
    def update(self):
15
        pass

1
(lldb) type summary add -F my_mod.Point_SummaryProvider Point
2
(lldb) type synthetic add -l my_mod.MyListProvider MyList

GDB보다 summary와 synthetic이 분리돼 있어 한 줄 표시(summary)와 자식 트리(synthetic)를 따로 정의합니다.

#LLDB의 platform 추상화

LLDB의 진짜 매력은 외부 스크립트에서 디버거를 제어할 수 있다는 점입니다.

1
#!/usr/bin/env python
2
import lldb
3

4
debugger = lldb.SBDebugger.Create()
5
target = debugger.CreateTarget('./my_prog')
6
target.BreakpointCreateByName('main')
7
process = target.LaunchSimple(None, None, '.')
8
print(process.GetSelectedThread().GetSelectedFrame())

CI에서 자동 디버깅, 자체 디버거 UI, 테스트 자동화 — 모두 가능합니다. GDB도 gdb.execute("python ...")로 비슷한 일이 되지만 LLDB가 더 깔끔.

#실전 — .gdbinit 한 페이지

자주 쓰는 셋업을 모아 두면 모든 세션에 자동 적용.

1
set history save on
2
set history filename ~/.gdb_history
3
set history size 10000
4
set print pretty on
5
set print object on
6
set pagination off
7

8
# 색깔
9
set style sources on
10

11
python
12
import sys
13
sys.path.insert(0, '/usr/share/gcc-13/python')
14
from libstdcxx.v6.printers import register_libstdcxx_printers
15
register_libstdcxx_printers(None)
16

17
# 내 프로젝트 printer
18
sys.path.insert(0, '/home/me/myproj/gdb')
19
import myproj_printers
20
myproj_printers.register_all()
21

22
# 이벤트 훅
23
def on_new_obj(event):
24
    name = event.new_objfile.filename
25
    if 'mylib.so' in name:
26
        gdb.execute('source /opt/mylib-gdb-helpers.py')
27
gdb.events.new_objfile.connect(on_new_obj)
28
end

#자주 쓰는 패턴

메모리 누수 추적 — malloc/free에 Python 브레이크 + 카운터 집계.
무한 루프 진단 — 1초마다 info threads 출력하는 백그라운드 Python.
테스트 자동화 — gdb -batch -ex "source script.py"로 헤드리스 실행.
회귀 검증 — parse_and_eval로 변수 값 비교, 차이가 있으면 gdb.write.
JIT 디버깅 — Custom unwinder + 사이드 테이블 lookup.
포렌식 — 콜스택을 Sentry/Datadog 등 외부로 전송.

#디버깅 자체의 디버깅

Python 스크립트가 조용히 실패하면.

1
(gdb) set python print-stack full

이후 모든 Python 예외의 콜스택이 표시됩니다. 사용자 명령 안에서 try/except로 명시적으로 잡는 것도 좋은 습관.

#정리

python ... end / source / .gdbinit에서 자동 로드.
gdb.Value/Type/Frame이 핵심 객체.
gdb.Command 서브클래스로 새 명령, prefix로 트리 구성.
gdb.Breakpoint.stop으로 자동 처리(False면 정지하지 않고 continue).
pretty-printer = 구조체를 사람 읽을 형태로. to_string+children+display_hint.
display_hint의 array/map/string이 MI를 거쳐 IDE 트리로.
auto-load (libfoo.so-gdb.py)로 라이브러리 따라가는 printer 배포.
libstdc++/libc++ printer는 GCC/LLVM 소스에 있다.
FrameDecorator·Unwinder로 콜스택 변형·JIT 지원.
LLDB는 SB API — 외부 스크립트로 디버거 제어 가능.

#다음 장 예고

Ch 10 — TUI와 프런트엔드. 터미널 UI, cgdb, gdb-dashboard, VSCode/Neovim DAP. 평소 작업 환경을 GDB와 어떻게 연결하나.

GDB·LLDB Python 스크립팅 — Pretty-Printer·Custom Command

#시작 — 한 줄 Python

#gdb 모듈 — 진입점

#첫 예 — 커스텀 명령

#자동 완성

#Prefix 명령 (서브 명령 트리)

#두 번째 예 — 자동 브레이크포인트 액션

#종합 — 메모리 누수 추적

#Pretty-Printer — 구조체를 사람 읽을 형태로

#동작 원리

#단순 printer

#컬렉션 — children 추가

#Map printer 예

#auto-load — 빌드 시 자동 적용

#libstdc++ / libc++ pretty-printer

#트리 / 그래프 시각화

#Convenience function

#Frame filter — 콜스택 가공

#FrameDecorator — 프레임을 변형

#Unwinder — 콜스택 직접 풀기

#Event 훅

#MI — 머신 인터페이스 (IDE 통합)

#LLDB의 Python — 다른 API

#LLDB 커스텀 명령

#LLDB pretty-printer

#LLDB의 platform 추상화

#실전 — .gdbinit 한 페이지

#자주 쓰는 패턴

#디버깅 자체의 디버깅

#정리

#다음 장 예고

#관련 항목

GDB and LLDB · 9 of 12

관련 글

DWARF 디버그 정보 — 디버거가 변수와 라인을 찾는 방식

Breakpoint와 Watchpoint 분석 — Conditional·Hardware·Catchpoint

GDB·LLDB Backtrace와 프레임 이동 — Call Stack 분석

이 글을 참조하는 글 (5)