# 鏈接時(shí)找不到符號(hào)定義
/usr/bin/ld: main.o: in function `main':
main.cpp:(.text+0x2a): undefined reference to `foo()'
collect2: error: ld returned 1 exit status

# dlopen 時(shí)找不到符號(hào)
./app: symbol lookup error: ./libplugin.so: undefined symbol: _Z3foov

# 程序啟動(dòng)時(shí)找不到符號(hào)
./app: /usr/lib/libmylib.so: undefined symbol: bar

# 查看動(dòng)態(tài)庫(kù)中的所有符號(hào)
nm -D libmylib.so

# 常用選項(xiàng)組合：按符號(hào)名排序，顯示動(dòng)態(tài)符號(hào)
nm -CD libmylib.so | grep foo

# 輸出含義：
# T / t  — 代碼段中的符號(hào)（大寫(xiě)=全局，小寫(xiě)=局部）
# D / d  — 數(shù)據(jù)段中的符號(hào)
# U      — 未定義符號(hào)（Undefined，需要從其他庫(kù)中解析）
# W      — 弱符號(hào)（Weak）
# A      — 絕對(duì)符號(hào)

$ nm -CD libmylib.so
                 w __gmon_start__
                 U __printf_chk@@GLIBC_2.17    # U = 這個(gè)符號(hào)在本庫(kù)中未定義，需要外部提供
0000000000000690 T my_function                  # T = 這個(gè)符號(hào)在本庫(kù)中定義，全局可見(jiàn)
0000000000000750 T my_class::do_work()          # C++ 方法（已 demangle）
0000000000002010 D my_global_var                # D = 全局變量定義

# 查看動(dòng)態(tài)符號(hào)表
readelf -s libmylib.so

# 查看所有段頭（定位符號(hào)表段是否存在）
readelf -S libmylib.so

# 查看動(dòng)態(tài)段（NEEDED 條目 = 運(yùn)行時(shí)依賴的庫(kù)）
readelf -d libmylib.so

# 查看符號(hào)版本信息
readelf -V libmylib.so

# 查看重定位條目（哪些符號(hào)需要被重定位）
readelf -r libmylib.so

$ readelf -s libmylib.so

Symbol table '.dynsym' contains 15 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __printf_chk@GLIBC_2.17
     2: 0000000000000690   120 FUNC    GLOBAL DEFAULT   11 my_function
     3: 0000000000000750    56 FUNC    GLOBAL DEFAULT   11 _ZN8my_class7do_workEv
                                                                     ↑ 這是 C++ mangled name

$ readelf -d libmylib.so | grep NEEDED
 0x0000000000000001 (NEEDED)             Shared library: [libgcc_s.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]

# 查看符號(hào)表
objdump -T libmylib.so

# 查看所有段頭
objdump -x libmylib.so | head -50

# 反匯編特定函數(shù)（需要非 strip 的庫(kù)）
objdump -d libmylib.so | grep -A 20 '<my_function>'

# 查看程序運(yùn)行時(shí)依賴的所有 .so
ldd ./myapp

# 查看某個(gè) .so 的依賴
ldd libmylib.so

# 典型輸出
$ ldd ./myapp
    linux-vdso.so.1 (0x00007ffc12bfe000)
    libmylib.so => /usr/local/lib/libmylib.so (0x00007f8a1c200000)  # ? 找到了
    libfoo.so => not found                                            # ? 找不到！
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8a1be00000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f8a1c600000)

# 查看符號(hào)綁定過(guò)程（最常用）
LD_DEBUG=symbols ./myapp

# 查看庫(kù)文件查找過(guò)程
LD_DEBUG=libs ./myapp

# 查看重定位過(guò)程
LD_DEBUG=reloc ./myapp

# 查看所有調(diào)試信息
LD_DEBUG=all ./myapp

# 輸出到文件而非 stderr
LD_DEBUG=symbols LD_DEBUG_OUTPUT=/tmp/ld_debug ./myapp

$ LD_DEBUG=symbols ./myapp 2>&1 | grep foo
     10567: symbol=foo;  lookup in file=./myapp [0]
     10567: symbol=foo;  lookup in file=libmylib.so [0]
     10567: symbol=foo;  lookup in file=libc.so.6 [0]
     10567: symbol=foo;  lookup in file=ld-linux-x86-64.so.2 [0]
     10567: symbol=foo;  error: symbol not found          # ← 所有庫(kù)都找遍了，沒(méi)找到

# 還原 mangled 名稱
$ echo '_ZN8my_class7do_workEv' | c++filt
my_class::do_work()

# 結(jié)合 nm 使用
nm libmylib.so | c++filt

# 結(jié)合 grep 使用
nm -D libmylib.so | c++filt | grep 'my_class::do_work'

# 如果是 mangled name（以 _Z 開(kāi)頭），先 demangle
$ c++filt _Z3foov
foo()

# 在所有相關(guān)庫(kù)中搜索該符號(hào)
nm -CD libprovider1.so | grep foo
nm -CD libprovider2.so | grep foo

# 或者用 readelf
readelf -s libprovider1.so | grep foo
readelf -s libprovider2.so | grep foo

# 系統(tǒng)范圍搜索（需要 locate 或 find）
# 方法 1：用 locate 快速定位
locate libfoo.so | xargs -I{} sh -c 'nm -CD {} 2>/dev/null | grep -l foo && echo {}'

# 方法 2：在已知目錄下搜索
for lib in /usr/lib/*.so /usr/local/lib/*.so; do
    nm -CD "$lib" 2>/dev/null | grep -q 'T foo' && echo "$lib"
done

# 檢查依賴鏈
ldd ./myapp | grep libprovider

# 檢查 RPATH/RUNPATH
readelf -d ./myapp | grep -E 'RPATH|RUNPATH'

# 檢查 LD_LIBRARY_PATH
echo $LD_LIBRARY_PATH

# 檢查符號(hào)是否被導(dǎo)出
nm -CD libprovider.so | grep foo
# 如果沒(méi)有 T/D 類型的條目，說(shuō)明符號(hào)未導(dǎo)出

# 檢查符號(hào)是否被 strip 掉
readelf -S libprovider.so | grep -E 'symtab|dynsym'
# 如果 .symtab 不存在但 .dynsym 存在，說(shuō)明被 strip 了（正常）
# 如果 .dynsym 也沒(méi)有，說(shuō)明編譯時(shí)就沒(méi)有導(dǎo)出

# 查看符號(hào)版本要求
readelf -V libprovider.so
objdump -T libprovider.so | grep foo

// libcalc.c — 純 C 庫(kù)
int add(int a, int b) {
    return a + b;
}

// main.cpp — C++ 程序
#include <cstdio>
// ? 缺少 extern "C" 聲明
int add(int a, int b);
int main() {
    printf("%d\n", add(1, 2));
    return 0;
}

# 編譯 C 庫(kù)
gcc -shared -fPIC -o libcalc.so libcalc.c

# 編譯 C++ 程序
g++ main.cpp -L. -lcalc -o main

# 運(yùn)行報(bào)錯(cuò)
$ ./main
./main: symbol lookup error: ./main: undefined symbol: _Z3addii

# 看庫(kù)中導(dǎo)出的符號(hào)名
$ nm -D libcalc.so | grep add
0000000000000690 T add                # C 庫(kù)導(dǎo)出的是 "add"

# 看程序需要的符號(hào)名
$ nm main | grep add
                 U _Z3addii           # C++ 程序找的是 "_Z3addii"（mangled name）

# demangle 確認(rèn)
$ c++filt _Z3addii
add(int, int)

// main.cpp — 正確寫(xiě)法
#include <cstdio>
extern "C" {           // ? 告訴編譯器按 C 的方式查找符號(hào)
    int add(int a, int b);
}
int main() {
    printf("%d\n", add(1, 2));
    return 0;
}

// libcalc.h — 兼容 C 和 C++ 的頭文件
#ifdef __cplusplus
extern "C" {
#endif
int add(int a, int b);
#ifdef __cplusplus
}
#endif

// libfoo.c
int foo() { return 42; }

# ? 編譯 .o 時(shí)沒(méi)有 -fPIC
gcc -c libfoo.c
gcc -shared -o libfoo.so libfoo.o

# 可能出現(xiàn)的警告或錯(cuò)誤
/usr/bin/ld: libfoo.o: relocation R_X86_64_PC32 against symbol `foo' can not be used when making a shared object; recompile with -fPIC

# 檢查 .o 文件的重定位類型
readelf -r libfoo.o | head

# 如果看到 R_X86_64_PC32 而非 R_X86_64_PLT32 / R_X86_64_GOTPCREL，
# 說(shuō)明編譯時(shí)沒(méi)有使用 -fPIC

# ? 編譯 .o 時(shí)加 -fPIC
gcc -fPIC -c libfoo.c
gcc -shared -o libfoo.so libfoo.o

# 或者一步完成
gcc -shared -fPIC -o libfoo.so libfoo.c

// main.cpp
#include "liba.h"    // liba 中的函數(shù)依賴 libb
int main() {
    func_from_a();   // 該函數(shù)內(nèi)部調(diào)用了 func_from_b()
    return 0;
}

# ? 錯(cuò)誤的鏈接順序：liba 在 libb 之前
g++ main.cpp -la -lb -o main
# 報(bào)錯(cuò)：undefined reference to `func_from_b()'

# ? 正確的鏈接順序：被依賴的庫(kù)放后面
g++ main.cpp -la -lb -o main    # 如果 a 依賴 b，應(yīng)該把 b 放在 a 后面

# 確認(rèn)庫(kù)之間的依賴關(guān)系
nm -D liba.so | grep ' U '      # 查看 liba 的未定義符號(hào)
nm -D libb.so | grep ' T '      # 查看 libb 定義了哪些符號(hào)

# 交叉對(duì)比
nm -D liba.so | awk '$1=="U"{print $2}' | while read sym; do
    nm -D libb.so | grep -q " T $sym" && echo "libb provides: $sym"
done

# 編譯時(shí)鏈接了新版本的 libfoo（有 foo@@VER_2.0）
g++ main.cpp -lfoo -o main

# 運(yùn)行時(shí)加載了舊版本的 libfoo（只有 foo@@VER_1.0）
$ LD_LIBRARY_PATH=/old/lib ./main
./main: /old/lib/libfoo.so: version `FOO_2.0' not found

# 查看程序需要的符號(hào)版本
$ objdump -T main | grep FOO
0000000000000000      DF *UND*  0000000000000000  FOO_2.0  foo

# 查看庫(kù)提供的符號(hào)版本
$ objdump -T /old/lib/libfoo.so | grep FOO
0000000000000690 g    DF .text  000000000000001a  FOO_1.0  foo
                                                    ↑ 只有 1.0

$ objdump -T /new/lib/libfoo.so | grep FOO
0000000000000690 g    DF .text  000000000000001a  FOO_2.0  foo
                                                    ↑ 有 2.0

# 查看庫(kù)的版本定義
$ readelf -V /old/lib/libfoo.so
Version definition section '.gnu.version_d' contains 2 entries:
  Addr: 0x00000000000002d8  Offset: 0x0002d8  Link: 3 (.dynstr)
    00000000: Rev: 1  Flags: BASE   Index: 1  Cnt: 1  Name: libfoo.so
    0x001c9880: Rev: 1  Flags: none  Index: 2  Cnt: 1  Name: FOO_1.0

# 方法 1：確保運(yùn)行時(shí)使用正確版本的庫(kù)
LD_LIBRARY_PATH=/new/lib ./main

# 方法 2：使用 LD_PRELOAD 強(qiáng)制加載特定版本
LD_PRELOAD=/new/lib/libfoo.so ./main

# 方法 3：設(shè)置 RPATH 使可執(zhí)行文件記住庫(kù)路徑
g++ -Wl,-rpath,/new/lib main.cpp -lfoo -o main

// main.cpp — 主程序
#include <dlfcn.h>
#include <cstdio>
void host_function() {       // 主程序中定義的函數(shù)
    printf("host_function called\n");
}
int main() {
    // ? 只用了 RTLD_LAZY，沒(méi)有 RTLD_GLOBAL
    void* handle = dlopen("./libplugin.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "%s\n", dlerror());
        return 1;
    }
    typedef void (*plugin_init_t)();
    auto plugin_init = (plugin_init_t)dlsym(handle, "plugin_init");
    plugin_init();
    dlclose(handle);
    return 0;
}

// plugin.cpp — 插件
#include <cstdio>
extern void host_function();  // 引用主程序的符號(hào)
extern "C" void plugin_init() {
    host_function();          // ← 運(yùn)行時(shí)報(bào) undefined symbol
}

# 編譯
g++ -shared -fPIC -o libplugin.so plugin.cpp
g++ -rdynamic -o main main.cpp -ldl    # -rdynamic 讓主程序?qū)С龇?hào)

# 運(yùn)行
$ ./main
./libplugin.so: undefined symbol: host_function

# 確認(rèn)主程序確實(shí)導(dǎo)出了該符號(hào)
$ nm -D main | grep host_function
0000000000001179 T host_function       # ? 主程序?qū)С隽?

# 確認(rèn)插件需要該符號(hào)
$ nm -D libplugin.so | grep host_function
                 U host_function       # U = 未定義，需要外部提供

# 問(wèn)題在于 dlopen 的默認(rèn)作用域

// 方法 1：使用 RTLD_LAZY | RTLD_GLOBAL（推薦）
void* handle = dlopen("./libplugin.so", RTLD_LAZY | RTLD_GLOBAL);

// 方法 2：主程序編譯時(shí)加 -rdynamic（已加），并確保 dlopen 之前符號(hào)可用

// registry.h — 自動(dòng)注冊(cè)模式
#include <map>
#include <string>
struct Registry {
    static std::map<std::string, int>& entries() {
        static std::map<std::string, int> m;
        return m;
    }
};
#define REGISTER(name, val) \
    static bool _reg_##name = (Registry::entries()[#name] = val, true)

// foo_plugin.cpp
#include "registry.h"
REGISTER(foo, 1)    // 全局靜態(tài)變量的構(gòu)造函數(shù)會(huì)執(zhí)行注冊(cè)

// bar_plugin.cpp
#include "registry.h"
REGISTER(bar, 2)

# 編譯為靜態(tài)庫(kù)
g++ -c foo_plugin.cpp -o foo_plugin.o
g++ -c bar_plugin.cpp -o bar_plugin.o
ar rcs libplugins.a foo_plugin.o bar_plugin.o

# 鏈接到動(dòng)態(tài)庫(kù)
g++ -shared -fPIC -o libmyapp.so -L. -lplugins

# 運(yùn)行時(shí)發(fā)現(xiàn)注冊(cè)表中為空！

# 檢查動(dòng)態(tài)庫(kù)中是否有注冊(cè)相關(guān)的符號(hào)
$ nm -D libmyapp.so | grep _reg_
# 空輸出！符號(hào)被丟棄了

# 檢查靜態(tài)庫(kù)中確實(shí)有這些符號(hào)
$ nm libplugins.a | grep _reg_
foo_plugin.o:
0000000000000000 d _reg_foo

bar_plugin.o:
0000000000000000 d _reg_bar

# 方法 1：使用 --whole-archive 強(qiáng)制包含所有符號(hào)
g++ -shared -fPIC -o libmyapp.so \
    -Wl,--whole-archive -L. -lplugins -Wl,--no-whole-archive
# 方法 2：在代碼中顯式引用（不推薦，但簡(jiǎn)單）
# 在某個(gè)會(huì)被引用的函數(shù)中添加：
extern bool _reg_foo;
extern bool _reg_bar;
void force_reference() {
    (void)_reg_foo;
    (void)_reg_bar;
}
# 方法 3：直接用 .o 文件而非靜態(tài)庫(kù)
g++ -shared -fPIC -o libmyapp.so foo_plugin.o bar_plugin.o

# /usr/include/mylib.h — 新版本（v2.0），聲明了 new_api()
# /usr/lib/libmylib.so — 舊版本（v1.0），沒(méi)有 new_api()
# /usr/local/lib/libmylib.so — 新版本（v2.0），有 new_api()

# 編譯時(shí)用了新頭文件
g++ main.cpp -I/usr/include -lmylib -o main

# 鏈接時(shí)找到了舊版庫(kù)
$ ldd main | grep mylib
libmylib.so => /usr/lib/libmylib.so    # ← 舊版！

# 運(yùn)行報(bào)錯(cuò)
$ ./main
./main: symbol lookup error: ./main: undefined symbol: new_api

# 1. 確認(rèn)鏈接了哪個(gè)庫(kù)
ldd main | grep mylib

# 2. 確認(rèn)庫(kù)中是否有該符號(hào)
nm -CD /usr/lib/libmylib.so | grep new_api       # 舊版：沒(méi)有
nm -CD /usr/local/lib/libmylib.so | grep new_api  # 新版：有

# 3. 確認(rèn)頭文件版本
grep new_api /usr/include/mylib.h       # 有聲明

# 方法 1：設(shè)置 LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

# 方法 2：編譯時(shí)設(shè)置 RPATH
g++ main.cpp -I/usr/local/include -L/usr/local/lib -Wl,-rpath,/usr/local/lib -lmylib -o main

# 方法 3：使用 pkg-config 確保一致性
g++ main.cpp $(pkg-config --cflags --libs mylib) -o main

# 在 x86 開(kāi)發(fā)機(jī)上編譯 ARM64 動(dòng)態(tài)庫(kù)
aarch64-linux-gnu-g++ -shared -fPIC -o libfoo.so foo.cpp

# ? 在 x86 機(jī)器上直接用 ldd 檢查 ARM 庫(kù)
$ ldd libfoo.so
    not a dynamic executable

# ? 在 x86 機(jī)器上直接運(yùn)行 ARM 程序
$ ./myapp
bash: ./myapp: cannot execute binary file: Exec format Error

# ? 用本地 nm 查看（雖然能看符號(hào)，但容易忽略架構(gòu)差異）
$ nm -D libfoo.so
# 能輸出符號(hào)，但無(wú)法驗(yàn)證運(yùn)行時(shí)依賴鏈?zhǔn)欠裢暾?

# ? 方法 1：使用交叉編譯工具鏈自帶的工具
aarch64-linux-gnu-nm -D libfoo.so
aarch64-linux-gnu-readelf -s libfoo.so
aarch64-linux-gnu-readelf -d libfoo.so | grep NEEDED
aarch64-linux-gnu-objdump -T libfoo.so

# ? 方法 2：直接在 ARM64 目標(biāo)機(jī)器上排查（最可靠）
# 拷貝到目標(biāo)機(jī)后：
ssh arm-device
nm -D libfoo.so
readelf -d libfoo.so | grep NEEDED
ldd ./myapp        # 在目標(biāo)機(jī)上 ldd 才有意義

# 交叉編譯時(shí)，未正確指定 sysroot
aarch64-linux-gnu-g++ main.cpp -lfoo -o myapp

# 編譯可能成功（因?yàn)檎业搅?x86 的 libfoo.so），但生成的二進(jìn)制是混合架構(gòu)
# 部署到 ARM 機(jī)器后：
$ ./myapp
./myapp: error while loading shared libraries: libfoo.so: wrong ELF class: ELFCLASS64
# 或者
./myapp: /usr/lib/libfoo.so: cannot open shared object file: Exec format error

# 1. 檢查 ELF 文件的架構(gòu)
$ readelf -h libfoo.so | grep -E 'Machine|Class'
  Class:                             ELF64
  Machine:                           AArch64           # ? ARM64

$ readelf -h /usr/lib/libfoo.so | grep -E 'Machine|Class'
  Class:                             ELF64
  Machine:                           Advanced Micro Devices X86-64  # ? x86_64！鏈接了錯(cuò)誤的庫(kù)

# 2. 檢查可執(zhí)行文件依賴的所有庫(kù)的架構(gòu)
$ for lib in $(ldd myapp | awk '{print $3}' | grep -v '^$'); do
    echo "=== $lib ==="
    readelf -h "$lib" 2>/dev/null | grep Machine
done

# 3. 檢查編譯時(shí)鏈接了哪些路徑
$ aarch64-linux-gnu-g++ main.cpp -lfoo -o myapp -v 2>&1 | grep 'LIBRARY_PATH'
# 如果輸出包含 /usr/lib 而非 /usr/aarch64-linux-gnu/lib，說(shuō)明鏈接了 x86 系統(tǒng)庫(kù)

# ? 方法 1：使用 --sysroot 指定目標(biāo)架構(gòu)的根文件系統(tǒng)
aarch64-linux-gnu-g++ main.cpp -lfoo -o myapp \
    --sysroot=/usr/aarch64-linux-gnu

# ? 方法 2：顯式指定庫(kù)搜索路徑
aarch64-linux-gnu-g++ main.cpp -lfoo -o myapp \
    -L/usr/aarch64-linux-gnu/lib

# ? 方法 3：使用 CMake 交叉編譯工具鏈文件（推薦）

# toolchain-aarch64.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)
set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
# 關(guān)鍵：指定 sysroot 和搜索路徑
set(CMAKE_FIND_ROOT_PATH /usr/aarch64-linux-gnu)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

cmake -DCMAKE_TOOLCHAIN_FILE=toolchain-aarch64.cmake ..
make

# 在 x86 開(kāi)發(fā)機(jī)上用較新的交叉編譯工具鏈編譯
aarch64-linux-gnu-g++ -shared -fPIC -o libmyapp.so myapp.cpp

# 部署到 ARM 目標(biāo)機(jī)（可能是較老的嵌入式系統(tǒng)）
$ ./myapp
./myapp: /usr/lib/libstdc++.so.6: version `GLIBCXX_3.4.29' not found
./myapp: /lib/libc.so.6: version `GLIBC_2.33' not found

# 1. 在 x86 開(kāi)發(fā)機(jī)上檢查交叉編譯的庫(kù)需要哪些符號(hào)版本
$ aarch64-linux-gnu-readelf -V libmyapp.so | grep -E 'GLIBC|GLIBCXX'
Version needs section '.gnu.version_r' contains 3 entries:
  0x00008000: Rev: 1  Flags: none  Index: 2  Cnt: 1  Name: GLIBC_2.33
  0x00008010: Rev: 1  Flags: none  Index: 3  Cnt: 1  Name: GLIBCXX_3.4.29

# 2. 在 ARM 目標(biāo)機(jī)上檢查可用的符號(hào)版本
$ strings /usr/lib/libstdc++.so.6 | grep GLIBCXX
GLIBCXX_3.4
GLIBCXX_3.4.9
...
GLIBCXX_3.4.21      # ← 最高只到 3.4.21，遠(yuǎn)低于需要的 3.4.29

$ strings /lib/libc.so.6 | grep GLIBC
GLIBC_2.17
...
GLIBC_2.31          # ← 最高只到 2.31，低于需要的 2.33

# 3. 列出庫(kù)的所有未定義符號(hào)及其版本要求
$ aarch64-linux-gnu-objdump -T libmyapp.so | grep '*UND*'
0000000000000000      DF *UND*  0000000000000000  GLIBC_2.33  memcpy
0000000000000000      DF *UND*  0000000000000000  GLIBCXX_3.4.29  _ZNSt7__cxx1112basic_string...

# 方法 1：使用與目標(biāo)系統(tǒng)匹配的交叉編譯工具鏈版本
# 如果目標(biāo)機(jī)是 Ubuntu 20.04（glibc 2.31），就用對(duì)應(yīng)版本的 sysroot
aarch64-linux-gnu-g++ -shared -fPIC -o libmyapp.so myapp.cpp \
    --sysroot=/path/to/ubuntu20.04-aarch64-sysroot

# 方法 2：將交叉編譯工具鏈的運(yùn)行時(shí)庫(kù)一起部署到目標(biāo)機(jī)
# 拷貝交叉編譯器的 libstdc++ 和 libgcc
scp /usr/aarch64-linux-gnu/lib/libstdc++.so.6.0.29 arm-device:/opt/lib/
scp /usr/aarch64-linux-gnu/lib/libgcc_s.so.1 arm-device:/opt/lib/
# 在目標(biāo)機(jī)上設(shè)置 LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/opt/lib:$LD_LIBRARY_PATH

# 方法 3：靜態(tài)鏈接 C/C++ 運(yùn)行時(shí)（簡(jiǎn)單但增加體積）
aarch64-linux-gnu-g++ -shared -fPIC -o libmyapp.so myapp.cpp \
    -static-libgcc -static-libstdc++

# 方法 4：使用 Docker 構(gòu)建可控的交叉編譯環(huán)境（推薦，可復(fù)現(xiàn)）

# Dockerfile.cross-build
FROM ubuntu:20.04

RUN apt-get update && apt-get install -y \
    gcc-aarch64-linux-gnu \
    g++-aarch64-linux-gnu \
    libc6-dev-arm64-cross \
    libstdc++-8-dev-arm64-cross

# 此環(huán)境中的 glibc/libstdc++ 版本與 Ubuntu 20.04 一致
# 確保編譯出的 .so 在目標(biāo)機(jī)上兼容

# 將 libfoo.so 部署到 ARM 目標(biāo)機(jī)的 /opt/myapp/lib/
$ ./myapp
./myapp: error while loading shared libraries: libfoo.so: cannot open shared object file: No such file or directory

# 但庫(kù)確實(shí)存在
$ ls -la /opt/myapp/lib/libfoo.so
-rwxr-xr-x 1 root root 123456 Apr 24 10:00 /opt/myapp/lib/libfoo.so

# 1. 確認(rèn)動(dòng)態(tài)鏈接器搜索了哪些路徑
$ LD_DEBUG=libs ./myapp 2>&1 | head -20
     1234: find library=libfoo.so [0]; searching
     1234:  search cache=/etc/ld.so.cache
     1234:  search path=/usr/lib:/lib        # ← 默認(rèn)路徑，沒(méi)有 /opt/myapp/lib

# 2. 檢查 ld.so.conf 配置
$ cat /etc/ld.so.conf
include /etc/ld.so.conf.d/*.conf

$ ls /etc/ld.so.conf.d/
libc.conf  # 只包含 /usr/lib

# 3. 檢查可執(zhí)行文件的 RPATH
$ readelf -d myapp | grep -E 'RPATH|RUNPATH'
# 空輸出 — 沒(méi)有設(shè)置 RPATH

# 方法 1：臨時(shí)方案 — 設(shè)置 LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/opt/myapp/lib:$LD_LIBRARY_PATH
./myapp

# 方法 2：永久方案 — 添加到 ld.so.conf
echo "/opt/myapp/lib" > /etc/ld.so.conf.d/myapp.conf
ldconfig                          # 刷新緩存
ldconfig -p | grep libfoo         # 驗(yàn)證緩存中已有該庫(kù)

# 方法 3：編譯時(shí)嵌入 RPATH（推薦）
aarch64-linux-gnu-g++ main.cpp -lfoo -o myapp \
    -Wl,-rpath,/opt/myapp/lib \
    -L/opt/myapp/lib

# 方法 4：使用 $ORIGIN 實(shí)現(xiàn)相對(duì)路徑 RPATH（部署更靈活）
aarch64-linux-gnu-g++ main.cpp -lfoo -o myapp \
    -Wl,-rpath,'$ORIGIN/lib'      # $ORIGIN = 可執(zhí)行文件所在目錄
# 這樣只要 libfoo.so 在 myapp 同級(jí)的 lib/ 目錄下就能找到

# 目標(biāo)機(jī)是 ARM32，但用 ARM64 工具鏈編譯
aarch64-linux-gnu-g++ -shared -fPIC -o libfoo.so foo.cpp

# 部署到 ARM32 目標(biāo)機(jī)
$ ./myapp
./myapp: error while loading shared libraries: ./libfoo.so: wrong ELF class: ELFCLASS64

# 反過(guò)來(lái)：目標(biāo)機(jī)是 ARM64，但用 ARM32 工具鏈編譯
arm-linux-gnueabihf-g++ -shared -fPIC -o libfoo.so foo.cpp

$ ./myapp
./myapp: error while loading shared libraries: ./libfoo.so: wrong ELF class: ELFCLASS32

# 確認(rèn) .so 的架構(gòu)
$ readelf -h libfoo.so | grep -E 'Class|Machine'
  Class:                             ELF64        # 64 位
  Machine:                           AArch64      # ARM64

# 確認(rèn)目標(biāo)機(jī)的架構(gòu)
$ uname -m
armv7l          # ARM32

# 或者
$ dpkg --print-architecture
armhf           # ARM32 硬浮點(diǎn)

# ARM32 (armhf) 交叉編譯
arm-linux-gnueabihf-g++ -shared -fPIC -o libfoo.so foo.cpp

# ARM64 (aarch64) 交叉編譯
aarch64-linux-gnu-g++ -shared -fPIC -o libfoo.so foo.cpp

# 始終在部署前驗(yàn)證架構(gòu)一致性
readelf -h libfoo.so | grep Machine
# Machine:                           ARM            → ARM32
# Machine:                           AArch64        → ARM64

// 1. C/C++ 兼容的頭文件寫(xiě)法
#ifdef __cplusplus
extern "C" {
#endif
void c_api_function(void);
#ifdef __cplusplus
}
#endif
// 2. 導(dǎo)出宏（控制符號(hào)可見(jiàn)性）
#ifdef MYLIB_EXPORTS
    #define MYLIB_API __attribute__((visibility("default")))
#else
    #define MYLIB_API
#endif
MYLIB_API void exported_function(void);
// 3. 隱藏不需要導(dǎo)出的符號(hào)
__attribute__((visibility("hidden"))) void internal_function(void);

# 設(shè)置 -fPIC
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

# 設(shè)置 RPATH
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}")

# 鏈接時(shí)檢查未定義符號(hào)
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined")

# 使用 --whole-archive
target_link_libraries(myapp
    PRIVATE
    "-Wl,--whole-archive"
    plugins
    "-Wl,--no-whole-archive"
)