Native层调试

// ============================================================
// 第一步：定义 LOG_TAG（必须在 #include 之前）
// LOG_TAG 就是 logcat 中 "Tag" 列显示的字符串
// 通常以模块名命名，方便用 logcat -s TAG 过滤
// ============================================================
#define LOG_TAG "MyNativeModule"
 
// ============================================================
// 第二步：引入 Android Log 头文件
// 在 AOSP 源码树中使用：
#include <log/log.h>            // AOSP 项目（system/logging/liblog）
// 在 NDK 项目中使用：
// #include <android/log.h>     // NDK 独立项目
// ============================================================
 
// ============================================================
// 第三步：在代码中直接使用 ALOG 系列宏
// ============================================================
void myFunction(int value) {
    ALOGD("myFunction called with value = %d", value);  // Debug 级别
    ALOGI("Initialization complete");                     // Info 级别
    ALOGW("Buffer size %d may be too small", value);      // Warning 级别
    ALOGE("Failed to open file: %s", strerror(errno));    // Error 级别
    ALOGV("Verbose trace: entering loop");                // Verbose 级别
}

# CMakeLists.txt 中链接 liblog
# find_library 在 NDK sysroot 中查找 liblog.so
find_library(log-lib log)
 
# 将 log-lib 链接到你的 native library
target_link_libraries(
    my_native_lib       # 你的库名
    ${log-lib}          # 链接 liblog
)

// ============================================================
// 宏展开链 (Macro Expansion Chain)
// ============================================================
 
// 第 1 层：用户调用
ALOGD("value = %d", 42);
 
// 第 2 层：ALOGD 展开为 ALOG，传入级别 LOG_DEBUG
// 定义在 log/log.h 中：
// #define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
 
// 第 3 层：ALOG 检查是否可打印，然后调用底层函数
// #define ALOG(priority, tag, ...)
//     LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
 
// 第 4 层：LOG_PRI 最终调用 C 函数
// #define LOG_PRI(priority, tag, ...)
//     android_printLog(priority, tag, __VA_ARGS__)
 
// 第 5 层：android_printLog 是 __android_log_print 的别名
// #define android_printLog(prio, tag, ...)
//     __android_log_print(prio, tag, __VA_ARGS__)
 
// ============================================================
// 最终调用的 C 函数签名（在 liblog.so 中实现）
// ============================================================
// int __android_log_print(int prio,        // 日志级别
//                         const char *tag,  // LOG_TAG 的值
//                         const char *fmt,  // printf 风格的格式串
//                         ...);             // 可变参数

// ============================================================
// ALOGV 的条件编译定义（简化版，来自 log/log.h）
// ============================================================
 
// 除非你显式定义 LOG_NDEBUG=0，否则 LOG_NDEBUG 默认为 1
#ifndef LOG_NDEBUG
#ifdef NDEBUG                    // NDEBUG 是 C/C++ 标准的 release 宏
#define LOG_NDEBUG 1             // Release 构建: 关闭 verbose
#else
#define LOG_NDEBUG 1             // 即使 Debug 构建，默认也是关闭的！
#endif
#endif
 
// 当 LOG_NDEBUG 为 1 时，ALOGV 展开为"什么都不做"
#if LOG_NDEBUG
#define ALOGV(...)               \
    do {                         \
        if (false) {             \
            /* 编译器会完全优化掉这段代码 */  \
            __android_log_print( \
                ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__); \
        }                        \
    } while (0)
#else
// LOG_NDEBUG=0 时，ALOGV 才真正输出
#define ALOGV(...) \
    __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
#endif

// ============================================================
// 条件日志宏 —— 仅当条件为 true 时才输出
// ============================================================
 
// 原型：ALOGD_IF(condition, fmt, ...)
// 当 condition 为 true 时等同于 ALOGD(fmt, ...)
// 当 condition 为 false 时什么都不做
 
bool gDebugEnabled = false;      // 全局调试开关，可通过 property 控制
 
void processFrame(int frameId) {
    // 仅当全局开关打开时才输出 debug 日志
    ALOGD_IF(gDebugEnabled, "Processing frame #%d", frameId);
 
    // 仅当帧号是 100 的倍数时才输出（降低日志洪泛）
    ALOGD_IF(frameId % 100 == 0, "Milestone frame #%d", frameId);
 
    // Error 级别也有条件版本
    int result = doSomething();
    ALOGE_IF(result != 0, "doSomething failed with error %d", result);
}

// 条件宏展开（简化）
#define ALOGD_IF(cond, ...)          \
    do {                              \
        if (cond) {                   \
            ALOGD(__VA_ARGS__);       \   // 条件满足 → 正常打印
        }                             \
    } while (0)

// ============================================================
// NDK 项目中的日志使用方式
// ============================================================
#include <android/log.h>           // NDK 提供的头文件
 
// 定义自己的 LOG_TAG
#define LOG_TAG "MyNDKApp"
 
// ============================================================
// 方式一：直接调用底层函数
// ============================================================
void exampleDirect() {
    // __android_log_print: 格式化打印，类似 printf
    __android_log_print(
        ANDROID_LOG_DEBUG,         // 日志级别枚举
        LOG_TAG,                   // Tag 字符串
        "Direct call: value = %d", // 格式串
        42                         // 参数
    );
 
    // __android_log_write: 直接写入一个字符串（无格式化）
    __android_log_write(
        ANDROID_LOG_ERROR,         // 日志级别
        LOG_TAG,                   // Tag
        "Something went wrong!"    // 纯文本消息
    );
}
 
// ============================================================
// 方式二（推荐）：自己封装宏，模拟 AOSP 风格
// ============================================================
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,  LOG_TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,  LOG_TAG, __VA_ARGS__)
#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
 
void exampleWrapped() {
    LOGD("Wrapped macro: x = %d, y = %f", 10, 3.14);  // 简洁易用
    LOGE("Error code: 0x%08X", 0xDEADBEEF);            // 十六进制格式
}

// ============================================================
// 通过 adb shell 设置运行时日志级别
// ============================================================
 
// 语法: adb shell setprop log.tag.<TAG> <LEVEL>
// LEVEL 可选值: VERBOSE / DEBUG / INFO / WARN / ERROR / SUPPRESS
 
// 示例 1: 将 MyNativeModule 的日志级别设为 WARN
// （只显示 WARN 及以上，DEBUG/INFO 被过滤）
// $ adb shell setprop log.tag.MyNativeModule WARN
 
// 示例 2: 彻底禁止某个 Tag 的所有日志
// $ adb shell setprop log.tag.MyNativeModule SUPPRESS
 
// 示例 3: 打开 Verbose 级别（需配合 LOG_NDEBUG=0 编译）
// $ adb shell setprop log.tag.MyNativeModule VERBOSE

#include <log/log.h>
 
void conditionalWork() {
    // __android_log_is_loggable 检查当前 Tag + 级别是否可输出
    // 返回值: 非零 = 可输出, 0 = 被过滤
    if (__android_log_is_loggable(
            ANDROID_LOG_DEBUG,       // 要检查的级别
            LOG_TAG,                 // 当前 Tag
            ANDROID_LOG_INFO)) {     // 默认最低级别（若 property 未设置）
        // 这里可以执行一些仅调试时需要的耗时操作
        // 例如序列化一个大结构体用于打印
        std::string dump = expensiveDump();
        ALOGD("Dump: %s", dump.c_str());
    }
    // 如果日志被过滤，expensiveDump() 根本不会执行 → 零开销
}

// ============================================================
// log_utils.h —— 生产级日志封装
// ============================================================
#pragma once                       // 防止重复包含
 
#include <android/log.h>           // NDK 底层 API
 
// 模块 Tag，统一管理
#ifndef LOG_TAG
#define LOG_TAG "MyApp"
#endif
 
// ============================================================
// Release 构建开关
// 编译时通过 -DRELEASE_BUILD=1 控制
// ============================================================
#ifndef RELEASE_BUILD
#define RELEASE_BUILD 0            // 默认为 Debug 构建
#endif
 
// ============================================================
// LOGE / LOGW —— 始终可用（生产环境也需要错误日志）
// ============================================================
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,  LOG_TAG, __VA_ARGS__)
 
// ============================================================
// LOGI —— 生产环境保留（重要里程碑信息）
// ============================================================
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
 
// ============================================================
// LOGD —— 仅 Debug 构建有效
// Release 构建中展开为空操作（编译器会完全移除）
// ============================================================
#if RELEASE_BUILD
#define LOGD(...)  do { if (false) { __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__); } } while(0)
#else
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
#endif
 
// ============================================================
// LOGV —— 仅显式开启时有效
// 需要在文件顶部 #define ENABLE_VERBOSE 1 才会生效
// ============================================================
#if defined(ENABLE_VERBOSE) && ENABLE_VERBOSE
#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
#else
#define LOGV(...)  do { if (false) { __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__); } } while(0)
#endif

// ============================================================
// adb logcat 常用命令速查
// ============================================================
 
// 1. 按 Tag 过滤 —— 只显示 MyNativeModule 的 Debug 及以上日志
//    *:S 表示 Silence 其他所有 Tag
// $ adb logcat MyNativeModule:D *:S
 
// 2. 按多个 Tag 过滤
// $ adb logcat MyNativeModule:D AudioFlinger:W *:S
 
// 3. 按进程过滤（需先获取 PID）
// $ adb logcat --pid=12345
 
// 4. 按关键字 grep（Linux/Mac）
// $ adb logcat | grep "Failed"
 
// 5. 清空日志缓冲区（重新开始）
// $ adb logcat -c
 
// 6. 输出并保存到文件
// $ adb logcat -v threadtime > log.txt
 
// 7. 查看 crash buffer（Native Crash 信息）
// $ adb logcat -b crash
 
// 8. 使用 long 格式查看完整时间戳和 PID/TID
// $ adb logcat -v long MyNativeModule:V *:S
 
// 9. 使用 color 格式（终端支持 ANSI 颜色时）
// $ adb logcat -v color

// ❌ 错误：LOG_TAG 未定义就使用 ALOGD
#include <log/log.h>
void foo() {
    ALOGD("hello");   // 编译错误: LOG_TAG undeclared
}
 
// ✅ 正确：先定义 LOG_TAG
#define LOG_TAG "Foo"
#include <log/log.h>
void foo() {
    ALOGD("hello");   // OK
}

int count = 10;
const char* name = "test";
 
// ❌ 危险：%s 期望 char*，传入了 int → 未定义行为 / 崩溃
ALOGD("name = %s, count = %d", count, name);
 
// ✅ 正确：参数顺序与格式说明符一致
ALOGD("name = %s, count = %d", name, count);

std::string msg = "hello world";
 
// ❌ 错误：%s 期望 const char*，不能直接传 std::string
ALOGD("message = %s", msg);       // 未定义行为！
 
// ✅ 正确：使用 .c_str() 获取 C 风格字符串
ALOGD("message = %s", msg.c_str());

// ===== 软件断点原理 - 伪代码演示 =====
 
// 原始内存中的指令（ARM64 示例）
// 地址 0x7F001000: MOV X0, #1    (原始指令)
 
// 第一步：调试器保存原始指令
uint32_t saved_insn = ptrace(PTRACE_PEEKTEXT, pid, 0x7F001000, NULL);
// saved_insn = 0xD2800020 (MOV X0, #1 的机器码)
 
// 第二步：写入 BRK 陷阱指令
uint32_t brk_insn = 0xD4200000; // BRK #0
ptrace(PTRACE_POKETEXT, pid, 0x7F001000, brk_insn);
// 此时地址 0x7F001000 处的指令变为 BRK #0
 
// 第三步：继续执行目标进程
ptrace(PTRACE_CONT, pid, NULL, NULL);
// CPU 执行到 0x7F001000 时触发 SIGTRAP
 
// 第四步：调试器收到信号，暂停进程
int status;
waitpid(pid, &status, 0);
// WIFSTOPPED(status) == true, WSTOPSIG(status) == SIGTRAP
 
// 第五步：用户检查完毕，选择继续执行
// 5a. 恢复原始指令
ptrace(PTRACE_POKETEXT, pid, 0x7F001000, saved_insn);
// 5b. 将 PC 寄存器回退到断点地址（因为 BRK 会让 PC 前进）
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, NULL, &regs);
regs.pc = 0x7F001000; // 回退 PC
ptrace(PTRACE_SETREGS, pid, NULL, &regs);
// 5c. 单步执行一条指令（执行原始的 MOV X0, #1）
ptrace(PTRACE_SINGLESTEP, pid, NULL, NULL);
waitpid(pid, &status, 0);
// 5d. 重新插入断点（以便下次还能命中）
ptrace(PTRACE_POKETEXT, pid, 0x7F001000, brk_insn);
// 5e. 继续运行
ptrace(PTRACE_CONT, pid, NULL, NULL);

// CMakeLists.txt 中确保调试符号的关键配置
// cmake_minimum_required(VERSION 3.18.1)
 
// 方法一：直接设置编译标志
// set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -O0")
// set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
// -g   : 生成 DWARF 调试信息（行号、变量名、类型信息等）
// -O0  : 禁用优化，确保变量不会被优化掉，代码顺序与源码一致
 
// 方法二：使用 CMake 内置变量（推荐）
// set(CMAKE_BUILD_TYPE Debug)
// CMake 会自动为 Debug 类型添加 -g 标志

# ===== 步骤 1：将 lldb-server 推送到设备 =====
# lldb-server 位于 NDK 目录中，需要选择与目标架构匹配的版本
# 例如 arm64-v8a 设备：
adb push $NDK/toolchains/llvm/prebuilt/linux-x86_64/lib/clang/17/lib/linux/aarch64/lldb-server \
    /data/local/tmp/lldb-server
 
# 赋予执行权限
adb shell chmod 755 /data/local/tmp/lldb-server
 
# ===== 步骤 2：在设备上启动 lldb-server =====
# 以 platform 模式启动，监听 Unix domain socket
adb shell run-as com.example.myapp \
    /data/local/tmp/lldb-server platform \
    --server --listen unix-abstract:///com.example.myapp/debug.sock
 
# ===== 步骤 3：设置 ADB 端口转发 =====
# 将主机的 TCP 端口映射到设备上的 lldb-server 端口
adb forward tcp:1234 tcp:1234
 
# 或者如果使用 gdbserver（旧方式）：
# adb forward tcp:5039 tcp:5039
 
# ===== 步骤 4：在主机上启动 lldb 客户端并连接 =====
# 启动 lldb（使用 NDK 自带的版本以确保兼容性）
$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/lldb
 
# 在 lldb 交互界面中连接远程服务器
# (lldb) platform select remote-android
# (lldb) platform connect connect://localhost:1234

# ===== 按函数名设置断点 =====
(lldb) breakpoint set --name main
# 简写形式：
(lldb) b main
# 在名为 main 的所有函数入口处设置断点
 
# ===== 按文件名和行号设置断点 =====
(lldb) breakpoint set --file native-lib.cpp --line 42
# 简写形式：
(lldb) b native-lib.cpp:42
# 在 native-lib.cpp 第 42 行设置断点
 
# ===== 按 C++ 方法签名设置断点（支持正则） =====
(lldb) breakpoint set --func-regex ".*MyService.*onTransact.*"
# 匹配所有类名含 MyService 且方法名含 onTransact 的函数
# 在 Binder 调试中极其有用
 
# ===== 条件断点：只在满足条件时中断 =====
(lldb) breakpoint set --name processFrame --condition "frameIndex > 100"
# 仅当 frameIndex 大于 100 时才触发中断
# 避免在循环前 100 次迭代中反复中断
 
# ===== 一次性断点（命中一次后自动删除） =====
(lldb) breakpoint set --name criticalFunction --one-shot true
# 只中断一次，之后自动移除
 
# ===== 列出所有断点 =====
(lldb) breakpoint list
# 简写：
(lldb) br l
# 显示断点编号、位置、命中次数、启用状态
 
# ===== 删除 / 禁用 / 启用断点 =====
(lldb) breakpoint delete 3      # 删除编号为 3 的断点
(lldb) breakpoint disable 2     # 临时禁用编号为 2 的断点
(lldb) breakpoint enable 2      # 重新启用
 
# ===== 设置 Watchpoint（数据断点） =====
(lldb) watchpoint set variable myGlobalVar
# 当 myGlobalVar 被写入时中断
(lldb) watchpoint set expression -- 0x7F003000
# 当地址 0x7F003000 处的内存被写入时中断
# 追踪内存踩踏问题的利器
(lldb) watchpoint modify -c "myGlobalVar == 42"
# 为 watchpoint 添加条件：只在值变为 42 时中断

# ===== 继续执行（直到下一个断点或程序结束） =====
(lldb) continue
# 简写：
(lldb) c
 
# ===== 单步跳过（Step Over）：执行当前行，不进入函数内部 =====
(lldb) next
# 简写：
(lldb) n
# 如果当前行是 foo()，执行完 foo() 后停在下一行
 
# ===== 单步进入（Step Into）：进入当前行调用的函数 =====
(lldb) step
# 简写：
(lldb) s
# 如果当前行是 foo()，会进入 foo() 的第一行
 
# ===== 单步跳出（Step Out）：执行完当前函数，返回调用者 =====
(lldb) finish
# 当你不小心 step 进了一个不感兴趣的函数时使用
 
# ===== 执行到指定行（Run to Line） =====
(lldb) thread until 85
# 执行到当前文件的第 85 行停下
# 相当于临时设置一个一次性断点然后 continue
 
# ===== 指令级单步（汇编级别） =====
(lldb) si    # Step Instruction：进入
(lldb) ni    # Next Instruction：跳过
# 在分析编译器生成的代码或排查内联汇编问题时使用

# ===== 查看调用栈（Backtrace） =====
(lldb) thread backtrace
# 简写：
(lldb) bt
# 显示当前线程的完整调用栈
# 输出示例：
# frame #0: 0x7a3b1234 libnative-lib.so`processFrame(data=0x7a500000, size=1920) at native-lib.cpp:42
# frame #1: 0x7a3b1100 libnative-lib.so`onFrameAvailable(this=0x7a400000) at camera-handler.cpp:88
# frame #2: 0x7b201000 libcameraservice.so`...
 
# ===== 查看所有线程 =====
(lldb) thread list
# 列出进程中所有线程及其状态
# 带 * 号的是当前活跃线程
 
# ===== 切换线程 =====
(lldb) thread select 3
# 切换到 3 号线程，查看其调用栈和变量
 
# ===== 查看局部变量 =====
(lldb) frame variable
# 简写：
(lldb) v
# 显示当前栈帧中所有局部变量及其值
 
# ===== 查看特定变量（支持表达式） =====
(lldb) frame variable myBuffer
(lldb) p myBuffer          # print 命令，支持表达式求值
(lldb) p myBuffer->size()  # 可以调用对象的方法！
(lldb) p (int*)0x7a500000  # 将地址强制转换为指针查看
(lldb) p/x myInt           # 以十六进制格式显示
(lldb) p/t myInt           # 以二进制格式显示
 
# ===== 查看内存内容 =====
(lldb) memory read 0x7a500000 --count 64 --format x
# 从地址 0x7a500000 开始读取 64 字节，以十六进制显示
# 简写：
(lldb) x/64xb 0x7a500000
# GDB 风格的内存查看命令，LLDB 也兼容
 
# ===== 查看寄存器 =====
(lldb) register read
# 显示所有通用寄存器（ARM64: X0-X30, SP, PC 等）
(lldb) register read pc sp x0
# 只查看特定寄存器

# 1. 使用 register read 直接查看寄存器中的值
(lldb) register read x0 x1 x2
# ARM64 调用约定：前 8 个参数通过 X0-X7 传递
 
# 2. 使用 disassemble 查看当前位置的汇编
(lldb) disassemble --frame
# 简写：
(lldb) di -f
# 显示当前函数的反汇编代码，理解编译器的优化行为
 
# 3. 在编译时使用 -fno-omit-frame-pointer
# 确保帧指针寄存器（FP/X29）被保留，这样即使优化后也能正确回溯调用栈
 
# 4. 使用 __attribute__((noinline)) 阻止关键函数被内联
// void __attribute__((noinline)) criticalFunction() { ... }

# ===== 查看所有线程的调用栈 =====
(lldb) thread backtrace all
# 一次性打印所有线程的完整调用栈
# 在分析死锁时非常有用
 
# ===== 只运行当前线程，冻结其他线程 =====
(lldb) thread continue -t 5
# 有时候你希望只让某个线程执行，以避免竞态条件影响调试
# 注意：这可能导致死锁（如果目标线程等待被冻结的线程）
 
# ===== 查看线程名称（在 Android 中很有用） =====
(lldb) thread list
# Android 系统线程通常有有意义的名称：
# * thread #1: tid = 12345, name = 'main'           (主线程/UI线程)
#   thread #2: tid = 12346, name = 'Binder:1234_1'   (Binder 线程)
#   thread #3: tid = 12347, name = 'RenderThread'     (渲染线程)
#   thread #4: tid = 12348, name = 'FinalizerDaemon'  (GC 终结器)

# ===== 自定义 LLDB 命令：打印 Android Parcel 内容 =====
# 保存为 parcel_printer.py
 
import lldb  # 导入 LLDB Python 模块
 
def print_parcel(debugger, command, result, internal_dict):
    """自定义命令：解析并打印 Parcel 对象的数据区"""
    target = debugger.GetSelectedTarget()      # 获取当前调试目标
    process = target.GetProcess()              # 获取目标进程
    thread = process.GetSelectedThread()       # 获取当前线程
    frame = thread.GetSelectedFrame()          # 获取当前栈帧
 
    # 求值获取 Parcel 指针
    parcel = frame.EvaluateExpression(command) # 对用户输入的表达式求值
    if not parcel.IsValid():                   # 检查求值是否成功
        result.AppendMessage("Invalid expression")
        return
 
    # 读取 Parcel 内部字段
    data_ptr = parcel.GetChildMemberWithName("mData")    # Parcel::mData 数据指针
    data_size = parcel.GetChildMemberWithName("mDataSize") # Parcel::mDataSize 数据大小
 
    size_val = data_size.GetValueAsUnsigned()  # 转为 Python 整数
    ptr_val = data_ptr.GetValueAsUnsigned()    # 获取地址值
 
    # 读取内存内容
    error = lldb.SBError()                     # 错误对象
    memory = process.ReadMemory(ptr_val, size_val, error) # 读取进程内存
 
    if error.Success():                        # 读取成功
        result.AppendMessage(f"Parcel data ({size_val} bytes):")
        hex_dump = ' '.join(f'{b:02x}' for b in memory) # 格式化为十六进制
        result.AppendMessage(hex_dump)
    else:
        result.AppendMessage(f"Failed to read memory: {error}")
 
# 注册自定义命令
def __lldb_init_module(debugger, internal_dict):
    debugger.HandleCommand(
        'command script add -f parcel_printer.print_parcel print_parcel'
    )
    # 之后在 LLDB 中就可以使用：
    # (lldb) print_parcel myParcelPtr

# 方法一：在 LLDB 中手动加载
(lldb) command script import /path/to/parcel_printer.py
 
# 方法二：写入 ~/.lldbinit 自动加载
# echo 'command script import /path/to/parcel_printer.py' >> ~/.lldbinit

# 1. 在 JNI 入口函数设置断点
(lldb) b Java_com_example_myapp_NativeLib_processData
# JNI 函数名遵循固定命名规则：Java_包名_类名_方法名
 
# 2. 命中断点后查看参数
(lldb) p env           # JNIEnv* 指针
(lldb) p thiz          # jobject (this)
(lldb) p inputData     # jbyteArray 等 JNI 类型
 
# 3. 单步执行找到崩溃行
(lldb) n               # 逐行执行
# 当执行到问题行时 LLDB 会捕获到 SIGSEGV
 
# 4. 查看崩溃时的寄存器和内存
(lldb) register read pc    # 查看崩溃发生的精确地址
(lldb) bt                  # 查看完整调用栈
(lldb) p *nullPointer      # 尝试读取可疑指针，确认是否为空

# 1. 当应用 ANR（Application Not Responding）时附加调试器
(lldb) process attach --name com.example.myapp --waitfor
# --waitfor 参数使 LLDB 等待目标进程启动
 
# 2. 暂停所有线程
(lldb) process interrupt
 
# 3. 查看所有线程的调用栈
(lldb) thread backtrace all
# 寻找多个线程都卡在 pthread_mutex_lock / futex 的情况
# 如果线程 A 持有锁 1 等待锁 2，线程 B 持有锁 2 等待锁 1 → 死锁
 
# 4. 查看 mutex 对象确认持有者
(lldb) p *(pthread_mutex_t*)0x7a600100
# 查看 mutex 内部结构，__owner 字段记录了持有该锁的线程 TID

# 1. 查找目标进程 PID
adb shell ps -A | grep surfaceflinger
# 输出：system  1234  1  ...  /system/bin/surfaceflinger
 
# 2. 以 root 身份在设备上启动 lldb-server 并附加
adb shell su -c "/data/local/tmp/lldb-server gdbserver :5039 --attach 1234"
 
# 3. 主机端连接
adb forward tcp:5039 tcp:5039
lldb
(lldb) gdb-remote 5039
 
# 4. 加载符号文件（来自 AOSP 编译产物）
(lldb) target symbols add /path/to/symbols/system/bin/surfaceflinger
(lldb) target symbols add /path/to/symbols/system/lib64/libsurfaceflinger.so

# 告诉 LLDB 不要在 SIGSEGV 时停下，而是传递给进程
(lldb) process handle SIGSEGV --stop false --pass true --notify true
# --stop false  : 不暂停
# --pass true   : 将信号传递给进程（让 ART 自己处理）
# --notify true : 在控制台打印通知

(lldb) breakpoint list --verbose
# 查看断点是否处于 pending 状态

# 命中断点时自动打印信息但不暂停（相当于动态插入 LOG）
(lldb) breakpoint set --name processFrame
(lldb) breakpoint command add 1
> p frameIndex
> p timestamp
> continue
> DONE
# 每次命中时打印变量值，然后自动继续执行

# 使用 NDK 自带的 addr2line 工具
# -C : Demangle C++ 符号名（将 _ZN7MyClass11readElementEi 还原为 MyClass::readElement(int)）
# -f : 显示函数名
# -e : 指定 ELF 文件（必须是 unstripped 的 .so）
# -p : Pretty-print，单行输出
 
# 针对 arm64-v8a 架构
$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-addr2line \
    -C -f -e app/build/intermediates/cmake/debug/obj/arm64-v8a/libnative.so \
    0x00023a4c    # tombstone backtrace 中 #00 的 pc 值
 
# 输出示例：
# MyClass::readElement(int)
# /home/dev/project/jni/parser.cpp:142

# 将 tombstone 中所有属于 libnative.so 的 pc 地址一次性传入
# 每个地址会依次输出对应的函数名和行号
llvm-addr2line -C -f -p \
    -e obj/arm64-v8a/libnative.so \
    0x00023a4c 0x00025b10 0x00028c84 0x0002a100
 
# 输出：
# MyClass::readElement(int) at /home/dev/project/jni/parser.cpp:142
# MyClass::parseBuffer(char const*, unsigned long) at /home/dev/project/jni/parser.cpp:98
# DataProcessor::processData() at /home/dev/project/jni/processor.cpp:55
# Java_com_example_MyClass_nativeInit at /home/dev/project/jni/jni_bridge.cpp:23

# 方式一：实时管道 —— 将 adb logcat 输出管道传给 ndk-stack
# -sym 参数指向包含 unstripped .so 文件的目录
# ndk-stack 会自动识别 logcat 中的 backtrace 段并就地替换为源码位置
adb logcat | ndk-stack -sym app/build/intermediates/cmake/debug/obj/arm64-v8a/
 
# 方式二：离线分析 —— 从已保存的 tombstone 文件中解析
# -dump 参数指定 tombstone 文件路径
# 适用于测试同事发送过来的离线崩溃报告
ndk-stack -sym obj/arm64-v8a/ -dump tombstone_00.txt

// 头文件：位于 AOSP 的 system/core/libutils/include/utils/CallStack.h
#include <utils/CallStack.h>   // CallStack 类定义
#include <utils/Log.h>         // ALOG 系列宏
 
// 在任意需要诊断的函数中调用
void SuspiciousFunction(int param) {
    // 创建 CallStack 对象
    // 构造函数参数 "MyTag" 是日志 Tag，用于 logcat 过滤
    // 第二个参数 1 表示跳过的栈帧数（跳过 CallStack 自身的构造函数帧）
    android::CallStack stack("MyTag", 1);
 
    // CallStack 对象在构造时就已经完成了栈回溯
    // 直接使用 ALOGD 输出不需要额外操作，构造函数内部会自动打印到 logcat
    // 如果需要手动控制输出，可以调用以下方法：
 
    // 方式一：输出到 logcat
    stack.log("MyTag",             // logcat Tag
              ANDROID_LOG_DEBUG,   // 日志级别
              "Suspicious call:"); // 前缀信息
 
    // 方式二：转为 String 存储或发送
    android::String8 traceStr = stack.toString("  ");  // 参数为每行缩进前缀
    // traceStr 内容类似：
    //   #00 pc 00023a4c  libnative.so (SuspiciousFunction+32)
    //   #01 pc 00025b10  libnative.so (CallerFunction+64)
    //   ...
}

#include <unwind.h>    // _Unwind_Backtrace, _Unwind_GetIP
#include <dlfcn.h>     // dladdr, Dl_info
#include <cxxabi.h>    // __cxa_demangle（C++ 符号反修饰）
#include <android/log.h>
#include <cstdlib>     // free
#include <string>
#include <vector>
 
// 日志宏简化
#define LOG_TAG "StackTrace"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
 
// ═══════════════════════════════════════════════════════════
// 辅助结构体：用于在回调中收集所有栈帧的 PC 地址
// ═══════════════════════════════════════════════════════════
struct BacktraceState {
    void** current;   // 当前写入位置的指针
    void** end;       // 缓冲区末尾哨兵，防止越界
};
 
// ═══════════════════════════════════════════════════════════
// 回调函数：_Unwind_Backtrace 每回溯一帧就调用一次
// 返回 _URC_NO_REASON 表示继续回溯
// 返回 _URC_END_OF_STACK 表示终止回溯
// ═══════════════════════════════════════════════════════════
static _Unwind_Reason_Code unwindCallback(
        struct _Unwind_Context* context,  // Unwind 库提供的上下文
        void* arg) {                       // 用户自定义参数（我们传入 BacktraceState）
 
    // 将 void* 还原为我们的结构体指针
    BacktraceState* state = static_cast<BacktraceState*>(arg);
 
    // _Unwind_GetIP 获取当前帧的 Instruction Pointer（即 PC 值）
    uintptr_t pc = _Unwind_GetIP(context);
 
    if (pc != 0) {
        // 如果还没写满缓冲区，存入 PC 值并推进指针
        if (state->current == state->end) {
            return _URC_END_OF_STACK;   // 缓冲区满，停止回溯
        }
        *state->current++ = reinterpret_cast<void*>(pc);
    }
 
    return _URC_NO_REASON;   // 继续回溯下一帧
}
 
// ═══════════════════════════════════════════════════════════
// 核心函数：捕获当前线程的完整堆栈并输出
// skip: 跳过的栈帧数（通常传 1 跳过 captureBacktrace 自身）
// ═══════════════════════════════════════════════════════════
void captureBacktrace(int skip = 1) {
    // 最多捕获 64 层调用深度（足以覆盖绝大多数场景）
    const int MAX_DEPTH = 64;
    void* buffer[MAX_DEPTH];
 
    // 初始化回溯状态
    BacktraceState state = {buffer, buffer + MAX_DEPTH};
 
    // 执行实际的栈回溯（从当前 PC 位置开始，逐帧回调 unwindCallback）
    _Unwind_Backtrace(unwindCallback, &state);
 
    // 计算实际捕获的帧数
    int frameCount = static_cast<int>(state.current - buffer);
 
    LOGD("===== Backtrace (%d frames) =====", frameCount - skip);
 
    // 遍历每一帧，解析地址为可读的符号信息
    for (int i = skip; i < frameCount; ++i) {
        const void* addr = buffer[i];  // 当前帧的 PC 地址
 
        Dl_info info;   // dladdr 的输出结构体
        // dladdr 根据地址查找所在的共享库和最近的符号
        if (dladdr(addr, &info) && info.dli_sname) {
            // ── C++ Name Demangling ──
            // 编译器会将 MyClass::readElement(int) 编码为 _ZN7MyClass11readElementEi
            // __cxa_demangle 将其还原为人类可读的形式
            int status = 0;
            char* demangled = abi::__cxa_demangle(
                info.dli_sname,   // 编码后的符号名
                nullptr,          // 输出缓冲区（nullptr = 自动 malloc）
                nullptr,          // 缓冲区大小（配合上参数）
                &status           // 0=成功，-1=内存错误，-2=非法名称，-3=参数错误
            );
 
            // 计算地址相对于函数起始地址的偏移量（用于和 addr2line 配合）
            uintptr_t offset = reinterpret_cast<uintptr_t>(addr)
                             - reinterpret_cast<uintptr_t>(info.dli_saddr);
 
            LOGD("  #%02d pc %p  %s (%s+%lu)",
                 i - skip,                          // 帧编号
                 addr,                               // 原始 PC 地址
                 info.dli_fname ? info.dli_fname     // 所在 .so 文件路径
                                : "unknown",
                 (status == 0) ? demangled           // 反修饰成功用 demangled 名
                               : info.dli_sname,    // 否则用原始符号名
                 static_cast<unsigned long>(offset));// 函数内偏移
 
            // __cxa_demangle 内部使用 malloc，必须用 free 释放
            if (demangled) free(demangled);
        } else {
            // dladdr 查找失败：可能是 JIT 代码或被 strip 的库
            LOGD("  #%02d pc %p  <unknown>", i - skip, addr);
        }
    }
 
    LOGD("===== End Backtrace =====");
}

void MyClass::readElement(int index) {
    if (index < 0) {
        // 出现异常参数，主动捕获当前堆栈用于诊断
        // 传入 1 跳过 captureBacktrace 本身的帧
        captureBacktrace(1);
    }
    // ... 正常逻辑
}
 
// ── logcat 输出示例 ──
// D/StackTrace: ===== Backtrace (4 frames) =====
// D/StackTrace:   #00 pc 0x7b8c023a4c  libnative.so (MyClass::readElement(int)+44)
// D/StackTrace:   #01 pc 0x7b8c025b10  libnative.so (MyClass::parseBuffer(char const*, unsigned long)+128)
// D/StackTrace:   #02 pc 0x7b8c028c84  libnative.so (DataProcessor::processData()+96)
// D/StackTrace:   #03 pc 0x7b8c02a100  libnative.so (Java_com_example_MyClass_nativeInit+64)
// D/StackTrace: ===== End Backtrace =====

#include <signal.h>     // sigaction, siginfo_t
#include <unistd.h>     // write (async-signal-safe)
#include <string.h>     // strsignal
#include <android/log.h>
 
// ═══════════════════════════════════════════════════════════
// 保存系统原有的信号处理器，以便在我们处理完后恢复
// ═══════════════════════════════════════════════════════════
static struct sigaction oldActions[32];   // 按信号编号索引
 
// 需要拦截的致命信号列表
static const int CAUGHT_SIGNALS[] = {
    SIGSEGV,   // 11 - 段错误（非法内存访问）
    SIGABRT,   // 6  - abort() 调用
    SIGBUS,    // 7  - 总线错误（对齐问题等）
    SIGFPE,    // 8  - 浮点异常（如除零）
    SIGILL,    // 4  - 非法指令
    SIGTRAP,   // 5  - 断点/调试陷阱
};
 
// ═══════════════════════════════════════════════════════════
// 信号处理函数
// 【极重要】此函数运行在信号上下文中，只允许调用
//   async-signal-safe 的函数（如 write, _exit, sigaction）
//   禁止调用 malloc, printf, ALOG 等非安全函数！
// ═══════════════════════════════════════════════════════════
static void crashSignalHandler(
        int sig,             // 信号编号
        siginfo_t* info,     // 信号详细信息（fault addr 等）
        void* ucontext) {    // CPU 寄存器上下文（ucontext_t*）
 
    // ── 1. 在信号安全环境下捕获堆栈 ──
    // 使用之前实现的 buffer 方式捕获（_Unwind_Backtrace 是 async-signal-safe 的）
    const int MAX_DEPTH = 32;
    void* frames[MAX_DEPTH];
    BacktraceState state = {frames, frames + MAX_DEPTH};
    _Unwind_Backtrace(unwindCallback, &state);
    int depth = static_cast<int>(state.current - frames);
 
    // ── 2. 将原始 PC 地址写入预分配的文件 ──
    // 注意：这里不能用 fopen/fprintf，只能用 write() 系统调用
    // 实际项目中通常写入 mmap 的共享内存或预打开的 fd
    int fd = /* 预先打开的崩溃日志文件 fd */ -1;
    if (fd >= 0) {
        for (int i = 0; i < depth; ++i) {
            // 将地址以二进制形式写入文件（后续离线解析）
            write(fd, &frames[i], sizeof(void*));
        }
    }
 
    // ── 3. 恢复系统默认处理器，让 debuggerd 生成正常的 tombstone ──
    // 如果不恢复，进程会陷入死循环（信号被反复触发和捕获）
    sigaction(sig, &oldActions[sig], nullptr);
 
    // ── 4. 重新触发信号，交给系统默认处理（生成 tombstone 并终止进程）──
    raise(sig);
}
 
// ═══════════════════════════════════════════════════════════
// 初始化函数：在 JNI_OnLoad 或模块初始化时调用
// ═══════════════════════════════════════════════════════════
void installCrashHandler() {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
 
    // 使用 sa_sigaction（三参数版本）而非 sa_handler（单参数版本）
    sa.sa_sigaction = crashSignalHandler;
 
    // SA_SIGINFO: 启用三参数回调，可获取 siginfo_t 和 ucontext
    // SA_ONSTACK: 使用备用信号栈（防止栈溢出时无法处理信号）
    sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
 
    // 在处理某个信号时，屏蔽所有其他致命信号，防止嵌套崩溃
    sigemptyset(&sa.sa_mask);
    for (int sig : CAUGHT_SIGNALS) {
        sigaddset(&sa.sa_mask, sig);
    }
 
    // 逐个注册，同时保存旧的 handler
    for (int sig : CAUGHT_SIGNALS) {
        sigaction(sig, &sa, &oldActions[sig]);  // 第三个参数保存原有 action
    }
}

// ── fault addr 接近 0x0（如 0x0, 0x8, 0x10, 0x20）──
// 诊断：空指针（NULL）访问结构体/类的成员变量
// 偏移量即成员在对象中的内存偏移
struct MyStruct {
    int a;          // offset 0x00 (空指针访问 a → fault addr = 0x0)
    int b;          // offset 0x04 (空指针访问 b → fault addr = 0x4)
    double c;       // offset 0x08 (空指针访问 c → fault addr = 0x8)
    char* name;     // offset 0x10 (空指针访问 name → fault addr = 0x10)
};
 
MyStruct* ptr = nullptr;
ptr->name;  // fault addr = 0x10 → 立刻定位到空指针 + 成员 name
 
// ── fault addr 是一个"看起来合理"的大地址（如 0x7b8c023a4c）──
// 诊断：很可能是 use-after-free 或 double-free
// 地址曾经有效，但对象已被释放，内存被回收或重新分配
 
// ── fault addr 包含规律性模式（如 0xDEADBABE, 0xABCDABCD）──
// 诊断：内存被故意填充了 poison pattern（某些 allocator 的调试模式）

class PlayerManager {
    int id;           // offset 0x00
    int level;        // offset 0x04
    double health;    // offset 0x08
    double mana;      // offset 0x10
    int score;        // offset 0x18
    char* name;       // offset 0x20
};

// ASan 影子内存地址计算公式
// ShadowAddr = (AppAddr >> 3) + ShadowOffset
// >> 3 相当于除以 8，因为 8 字节应用内存 -> 1 字节影子内存
// ShadowOffset 是一个平台相关的固定偏移量
 
// 影子字节的值含义：
// 0        : 该 8 字节区域完全可寻址（fully addressable）
// 1~7      : 该 8 字节区域中前 k 字节可寻址，后 (8-k) 字节不可寻址
// 负数(< 0): 该 8 字节区域完全不可寻址（各种负数代表不同的错误类型）
//   0xfa   : Heap left redzone     （堆左侧红区）
//   0xfb   : Heap right redzone    （堆右侧红区）
//   0xfd   : Freed heap region     （已释放的堆区域）
//   0xf1   : Stack left redzone    （栈左侧红区）
//   0xf3   : Stack right redzone   （栈右侧红区）
//   0xf5   : Stack after return    （函数返回后的栈区域）

// ========== 原始代码 ==========
int arr[10];            // 在栈上分配数组
int val = arr[index];   // 读取数组元素
 
// ========== ASan 插桩后的等效伪代码 ==========
int arr[10];                                     // 原始数组分配
// --- ASan 插入的检查逻辑 START ---
char *shadow = (char *)((uintptr_t)&arr[index] >> 3) + kShadowOffset;  // 计算影子地址
if (*shadow != 0) {                              // 检查影子字节：非0表示可能有问题
    int last_accessed_byte = ((uintptr_t)&arr[index] & 7) + sizeof(int) - 1; // 计算 8 字节粒度内的偏移
    if (last_accessed_byte >= *shadow) {         // 最后访问的字节超出可寻址范围
        __asan_report_load4(&arr[index]);        // 报告一次非法的 4 字节读取操作
        // 此函数内部会: 打印详细错误信息 -> 打印堆栈 -> abort()
    }
}
// --- ASan 插入的检查逻辑 END ---
int val = arr[index];   // 原始的内存读取操作

# ==================== CMakeLists.txt ====================
 
# 定义一个 CMake 选项，方便开关 ASan（默认关闭）
option(ENABLE_ASAN "Enable AddressSanitizer" OFF)
 
if(ENABLE_ASAN)
    # -fsanitize=address : 启用 ASan 编译插桩
    # -fno-omit-frame-pointer : 保留帧指针，确保堆栈回溯完整准确
    # -O1 : ASan 官方建议至少使用 -O1 优化，兼顾检测精度与性能
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer -O1")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer -O1")
 
    # 链接阶段也必须加 -fsanitize=address，否则链接器找不到 ASan 运行时库
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
endif()
 
# 你的正常库定义
add_library(native-lib SHARED native-lib.cpp)

// app/build.gradle
android {
    defaultConfig {
        externalNativeBuild {
            cmake {
                // 通过 -D 传递 CMake 选项来启用 ASan
                arguments "-DENABLE_ASAN=ON"
            }
        }
    }
}

#!/system/bin/sh
# ==================== wrap.sh ====================
# 该脚本会在应用进程启动前由 Android 系统执行
# 它的作用是设置 ASan 运行时环境并启动应用
 
# ASAN_OPTIONS 环境变量控制 ASan 的运行时行为
# log_to_syslog=false      : 不输出到 syslog，避免日志混乱
# allow_user_segv_handler=1: 允许应用注册自己的 SIGSEGV handler
# detect_leaks=0           : 关闭内存泄漏检测（Android 上 LSan 支持有限）
export ASAN_OPTIONS="log_to_syslog=false:allow_user_segv_handler=1:detect_leaks=0"
 
# $@ 表示传入的所有参数，即原始的应用启动命令
# 此行实际执行应用的启动
exec "$@"

// wrap.sh 仅在 debuggable 构建中生效
android {
    buildTypes {
        debug {
            debuggable true   // wrap.sh 需要此项为 true 才能被系统执行
        }
    }
}

#include <cstdlib>   // 引入 malloc/free
#include <cstring>   // 引入 memset
 
void heap_overflow_example() {
    // 分配 10 个字节的堆内存
    char *buffer = (char *)malloc(10);
 
    // ❌ 错误：写入第 11 个字节（索引 10），超出分配范围
    // ASan 会检测到该写入踩到了 Right Redzone
    buffer[10] = 'A';
 
    // 释放内存
    free(buffer);
}

void stack_overflow_example() {
    int arr[5];                  // 在栈上分配 5 个 int（20 字节）
 
    // ❌ 循环条件错误：i <= 5 应为 i < 5
    // 当 i == 5 时，arr[5] 越界访问了栈上 arr 之后的 Redzone
    for (int i = 0; i <= 5; i++) {
        arr[i] = i * 100;       // i=5 时触发 stack-buffer-overflow
    }
}

void use_after_free_example() {
    int *ptr = new int(42);      // 在堆上分配一个 int，值为 42
    delete ptr;                  // 释放该内存，ptr 成为悬空指针
 
    // ❌ ptr 已经被释放，但程序仍然通过它读取数据
    // ASan 影子内存中该区域已标记为 0xfd (freed heap region)
    int value = *ptr;            // 触发 heap-use-after-free
    (void)value;                 // 防止编译器 unused 警告
}

void double_free_example() {
    char *data = (char *)malloc(64);  // 分配 64 字节
    free(data);                       // 第一次释放 ✅
 
    // ... 中间可能有大量其他代码 ...
 
    free(data);                       // ❌ 第二次释放同一块内存
    // ASan 报告: attempting double-free on 0x...
}

// 通过环境变量启用: ASAN_OPTIONS=detect_stack_use_after_return=1
 
int *get_local_ptr() {
    int local_var = 999;          // 局部变量，存在于该函数的栈帧中
    return &local_var;            // ❌ 返回局部变量的地址（编译器通常也会警告）
}
 
void use_after_return_example() {
    int *p = get_local_ptr();     // p 指向已失效的栈帧
    int val = *p;                 // ❌ 访问已销毁的栈内存 -> stack-use-after-return
    (void)val;
}

void memory_leak_example() {
    // 分配了 1024 字节，但函数返回前没有释放
    char *leaked = (char *)malloc(1024);
 
    // 用 leaked 做一些操作...
    leaked[0] = 'X';
 
    // ❌ 函数结束，leaked 指针丢失，内存泄漏
    // 如果 detect_leaks=1 且程序正常退出，LSan 会报告此泄漏
}

# HWASan 编译选项（仅支持 arm64-v8a）
if(ENABLE_HWASAN)
    # -fsanitize=hwaddress : 启用 HWASan
    # -fno-omit-frame-pointer : 保留帧指针用于堆栈回溯
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=hwaddress -fno-omit-frame-pointer")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=hwaddress")
endif()

#include <jni.h>       // JNI 头文件
#include <cstring>     // memcpy
#include <cstdlib>     // malloc / free
#include <android/log.h>
 
#define TAG "ASanDemo"
#define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
 
// 模拟一个图像处理函数，存在隐蔽的越界写入
static void process_pixel_data(uint8_t *pixels, int width, int height) {
    int total = width * height;           // 计算像素总数
 
    // ❌ Bug: 循环条件应为 i < total，但写成了 i <= total
    // 当 i == total 时，pixels[total] 越界写入 1 字节
    for (int i = 0; i <= total; i++) {
        pixels[i] = (uint8_t)(i & 0xFF); // 当 i == total 时触发 heap-buffer-overflow
    }
}
 
extern "C" JNIEXPORT void JNICALL
Java_com_example_app_ImageProcessor_nativeProcess(
        JNIEnv *env,
        jobject /* this */,
        jint width,
        jint height) {
 
    ALOGD("开始处理图像: %dx%d", width, height);
 
    int size = width * height;                     // 计算所需缓冲区大小
    uint8_t *buffer = (uint8_t *)malloc(size);     // 分配堆内存
    if (!buffer) {                                 // 检查分配是否成功
        ALOGE("内存分配失败!");
        return;
    }
 
    // 调用存在 Bug 的处理函数
    process_pixel_data(buffer, width, height);     // ← ASan 会在这里报错
 
    ALOGD("处理完成，释放内存");
    free(buffer);                                  // 释放缓冲区
}

# 使用 NDK 的 llvm-addr2line 将地址翻译为源码位置
# -e 指定 so 文件路径（需要带符号的未 strip 版本）
# -f 同时输出函数名
# -C 进行 C++ name demangling（还原可读函数名）
$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-addr2line \
    -e app/build/intermediates/cmake/debug/obj/arm64-v8a/libnative-lib.so \
    -f -C \
    0x12a4 0x1388    # 替换为 ASan 报告中的实际地址

void quiz_function() {
    int *array = new int[100];
    delete[] array;
    array[50] = 42;
}

✅ DO（推荐做法）
──────────────────────────────
1. 在所有 Native 模块中统一定义 LOG_TAG，保持 logcat 输出可过滤
2. CI/CD 流程中归档 unstripped .so，确保线上崩溃可符号化
3. 开发阶段默认开启 ASan，将内存错误消灭在测试期
4. 为关键函数入口/出口添加 ALOGD，形成执行路径"面包屑"
5. 使用 LLDB 的条件断点代替大量临时 LOG，减少代码污染
6. Tombstone 分析时同时关注 memory map，判断地址合法性
 
❌ DON'T（避免事项）
──────────────────────────────
1. 生产包中保留 ALOGV/ALOGD 输出（性能 + 安全风险）
2. 依赖 GDB（已过时），应迁移到 LLDB
3. 在 Release 构建中开启 ASan（严重性能退化）
4. 忽略编译警告（-Wall -Werror 应始终开启）
5. 仅看 backtrace 第一行就下结论（崩溃点 ≠ 根因）
6. 用 strip 后的 .so 做 addr2line（无符号信息，无法解析）

# CMakeLists.txt
cmake_minimum_required(VERSION 3.18)
project(mylib)
 
# 设置编译标志：启用 ASan + 保留帧指针
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
 
# 构建共享库
add_library(mylib SHARED native-lib.cpp)
 
# 链接系统库
target_link_libraries(mylib log)

# 编译标志（已有）
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
# 链接标志（缺失，必须补充）
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")