# 1. 检查依赖库数量
$ ldd your_program | wc -l
# 如果依赖超过 20 个库，移植难度较高

# 2. 检查是否有预编译的第三方库
$ find . -name "*.so" -o -name "*.a" | head -20
# 预编译库需要重新为 musl 编译

# 3. 检查是否有 glibc 专有头文件
$ grep -rn '#include.*\(error\.h\|argp\.h\|execinfo\.h\|obstack\.h\)' src/

# 4. 检查是否有 GNU 扩展函数调用
$ grep -rn 'error_at_line\|argp_parse\|backtrace\|obstack_\|error(' src/

# 5. 检查构建系统
$ ls configure.ac Makefile.am CMakeLists.txt meson.build 2>/dev/null

# 6. 检查是否有条件编译宏
$ grep -rn '__GLIBC__\|_GNU_SOURCE\|GLIBC_PREREQ' src/

/* 1. 条件编译 — 在编译时排除不兼容代码 */
#ifndef __musl__
#include <error.h>
#include <execinfo.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

/* 2. 为缺失函数提供替代实现 */

#ifdef __musl__
/* musl 替代：error() 函数 */
static void my_error(int status, int errnum, const char *fmt, ...) {
    va_list ap;
    fprintf(stderr, "%s: ", program_invocation_name);
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    if (errnum)
        fprintf(stderr, ": %s", strerror(errnum));
    fprintf(stderr, "\n");
    if (status)
        exit(status);
}
#define error my_error
#define error_at_line(status, errnum, file, line, fmt, ...) \
    do { fprintf(stderr, "%s:%d: ", file, line); \
         my_error(status, errnum, fmt, ##__VA_ARGS__); } while(0)
#endif

/* 3. 为 backtrace 提供替代 */
#ifdef __musl__
static void print_backtrace(void) {
    /* 方案 A：使用 libunwind */
    /* 方案 B：使用 -rdynamic + dladdr */
    /* 方案 C：不做任何事 */
    fprintf(stderr, "(backtrace not available)\n");
}
#else
#include <execinfo.h>
static void print_backtrace(void) {
    void *buffer[100];
    int nptrs = backtrace(buffer, 100);
    backtrace_symbols_fd(buffer, nptrs, STDERR_FILENO);
}
#endif

/* 提供函数前向声明 */
#ifdef __musl__
/* 提供必要的声明 */
extern char *program_invocation_name;
extern char *program_invocation_short_name;
#endif

#include <stdlib.h>

/* glibc 提供 __compar_fn_t 类型定义 */
/* musl 中可能不存在，需要自行定义 */
#ifndef __GLIBC__
typedef int (*__compar_fn_t)(const void *, const void *);
#endif

/* 或者直接使用标准的函数指针类型 */
int compare(const void *a, const void *b) {
    return *(const int *)a - *(const int *)b;
}

int main() {
    int arr[] = {3, 1, 4, 1, 5, 9};
    qsort(arr, 6, sizeof(int), compare);
    return 0;
}

#include <dlfcn.h>

/* RTLD_DEEPBIND 是 glibc 扩展 */
#ifndef RTLD_DEEPBIND
#define RTLD_DEEPBIND 0  /* musl 忽略此标志 */
#endif

void *load_plugin(const char *path) {
    /* RTLD_DEEPBIND 在 musl 上被忽略（等同于 0） */
    return dlopen(path, RTLD_LAZY | RTLD_DEEPBIND);
}

#include <malloc.h>

/* MALLOC_MMAP_THRESHOLD_ 是 glibc 专有 */
#ifdef __GLICC__
mallopt(M_MMAP_THRESHOLD_, 65536);
#else
/* musl 不支持此选项 */
#endif

# 方案 1：提供替代实现（推荐）
# 将缺失函数的实现编译为一个单独的文件

$ cat > compat_glibc.c << 'EOF'
/* musl 兼容层 — 提供 glibc 扩展函数的替代实现 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>

/* error() 替代 */
void compat_error(int status, int errnum, const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    if (errnum)
        fprintf(stderr, ": %s", strerror(errnum));
    fprintf(stderr, "\n");
    if (status)
        exit(status);
}

/* backtrace() 替代 — 使用栈帧回溯 */
#ifdef __x86_64__
int compat_backtrace(void **buffer, int size) {
    int count = 0;
    void **frame;
    __asm__ volatile("mov %%rbp, %0" : "=r"(frame));
    while (frame && count < size) {
        buffer[count++] = frame[1]; /* 返回地址 */
        frame = (void **)frame[0];  /* 上一个栈帧 */
    }
    return count;
}
#else
int compat_backtrace(void **buffer, int size) {
    (void)buffer; (void)size;
    return 0;
}
#endif
EOF

$ cat > compat_glibc.h << 'EOF'
#ifndef COMPAT_GLIBC_H
#define COMPAT_GLIBC_H

#ifdef __musl__
#define error compat_error
#define backtrace compat_backtrace
#endif

void compat_error(int status, int errnum, const char *fmt, ...);
int compat_backtrace(void **buffer, int size);

#endif
EOF

# 方案 2：使用第三方兼容库
$ apk add argp-standalone  # Alpine 上的 argp 实现
$ cc -o program program.c -largp

# 在 musl 中，这些库的功能已经内置到 libc 中

# glibc 的链接命令：
$ gcc -o program program.c -lpthread -lm -ldl -lrt -lcrypt

# musl 的链接命令（简化）：
$ musl-gcc -o program program.c -lpthread -lm
# 或者使用条件链接

# Makefile 中的条件链接
CC = gcc
LIBS = -lpthread -lm

# 检测是否为 glibc
ifeq ($(shell ldd --version 2>&1 | grep -c glibc),1)
    LIBS += -ldl -lrt -lcrypt
endif

program: program.c
	$(CC) -o $@ $< $(LIBS)

# CMakeLists.txt 中的条件链接
include(CheckFunctionExists)

check_function_exists(dlopen HAVE_DLOPEN)
if(NOT HAVE_DLOPEN)
    # 可能需要 -ldl
    list(APPEND CMAKE_REQUIRED_LIBRARIES dl)
    check_function_exists(dlopen HAVE_DLOPEN_DL)
endif()

# 检查 crypt
check_function_exists(crypt HAVE_CRYPT)
if(NOT HAVE_CRYPT)
    list(APPEND CMAKE_REQUIRED_LIBRARIES crypt)
endif()

/* program_invocation_name 和 program_invocation_short_name */
/* glibc: 通过 <errno.h> 或 <stdio.h> 可用 */
/* musl:  也提供了这些变量，但需要额外声明 */

#include <stdio.h>
#include <errno.h>

/* 在 glibc 上自动可用，在 musl 上需要声明 */
#ifndef __GLIBC__
extern char *program_invocation_name;
extern char *program_invocation_short_name;
#endif

int main() {
    printf("Program: %s\n", program_invocation_short_name);
    printf("Full: %s\n", program_invocation_name);
    return 0;
}

/* getauxval() 在 glibc 和 musl 都可用 */
#include <sys/auxv.h>
#include <stdio.h>

int main() {
    /* 两者都支持 */
    unsigned long page_size = getauxval(AT_PAGESZ);
    unsigned long hwcap = getauxval(AT_HWCAP);
    const char *platform = (const char *)getauxval(AT_PLATFORM);

    printf("Page size: %lu\n", page_size);
    printf("Platform: %s\n", platform ?: "unknown");
    return 0;
}

/* 检测 libc 类型的完整方案 */
#ifndef LIBC_DETECT_H
#define LIBC_DETECT_H

/* 方案 1：使用内置宏 */
#if defined(__GLIBC__)
#  define LIBC_GLIBC 1
#  define LIBC_NAME "glibc"
#elif defined(__musl__)
#  define LIBC_MUSL 1
#  define LIBC_NAME "musl"
#elif defined(__BIONIC__)
#  define LIBC_BIONIC 1
#  define LIBC_NAME "bionic"
#else
#  define LIBC_UNKNOWN 1
#  define LIBC_NAME "unknown"
#endif

/* 方案 2：运行时检测 */
#include <features.h>
static inline const char *libc_name_runtime(void) {
#ifdef __GLIBC__
    return "glibc " __GLIBC__.__GLIBC_MINOR__;
#else
    /* 尝试读取 /proc/self/maps 检查 */
    return "non-glibc";
#endif
}

#endif /* LIBC_DETECT_H */

/*
 * 推荐方案：将平台差异封装到兼容层
 * 而不是在业务代码中到处使用 #ifdef
 */

/* compat.h — 统一的兼容层接口 */
#ifndef COMPAT_H
#define COMPAT_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

/* 错误报告 */
void die(const char *fmt, ...);
void die_errno(const char *fmt, ...);

/* backtrace */
void print_backtrace(int max_frames);

/* argp 替代 */
int parse_args(int argc, char **argv);

#endif /* COMPAT_H */

/* compat.c — 实现文件，处理所有平台差异 */
#include "compat.h"
#include <stdarg.h>
#include <unistd.h>

void die(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "FATAL: ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    va_end(ap);
    _exit(1);
}

void die_errno(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "FATAL: ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, ": %s\n", strerror(errno));
    va_end(ap);
    _exit(1);
}

void print_backtrace(int max_frames) {
    (void)max_frames;
#ifdef __GLIBC__
#include <execinfo.h>
    void *buffer[128];
    int n = backtrace(buffer, max_frames < 128 ? max_frames : 128);
    backtrace_symbols_fd(buffer, n, STDERR_FILENO);
#else
    fprintf(stderr, "(backtrace not available on this platform)\n");
#endif
}

# configure.ac 中检测 libc
AC_MSG_CHECKING([for musl libc])
AC_COMPILE_IFELSE(
    [AC_LANG_PROGRAM([#include <features.h>
                       #if defined(__musl__)
                       #error "musl detected"
                       #endif], [])],
    [AC_MSG_RESULT([no])],
    [AC_MSG_RESULT([yes])
     AC_DEFINE([HAVE_MUSL], [1], [Using musl libc])])

# CMakeLists.txt 中检测 libc
include(CheckSymbolExists)
include(CheckIncludeFile)

check_include_file("error.h" HAVE_ERROR_H)
check_include_file("argp.h" HAVE_ARGP_H)
check_include_file("execinfo.h" HAVE_EXECINFO_H)

if(HAVE_EXECINFO_H)
    target_compile_definitions(myproject PRIVATE HAVE_EXECINFO_H)
    target_sources(myproject PRIVATE backtrace_util.c)
endif()

# 检测 musl
execute_process(
    COMMAND ldd --version
    OUTPUT_VARIABLE LDD_OUTPUT
    ERROR_VARIABLE LDD_OUTPUT
    OUTPUT_QUIET
)
if(LDD_OUTPUT MATCHES "musl")
    set(HAVE_MUSL TRUE)
    message(STATUS "Detected musl libc")
endif()

# meson.build
cc = meson.get_compiler('c')

# 检测头文件
error_h = cc.has_header('error.h')
argp_h = cc.has_header('argp.h')
execinfo_h = cc.has_header('execinfo.h')

if execinfo_h
    conf.set('HAVE_EXECINFO_H', 1)
endif

# 检测函数
if cc.has_function('backtrace', prefix : '#include <execinfo.h>')
    conf.set('HAVE_BACKTRACE', 1)
endif

# 检测 musl
run_command('ldd', '--version', check: false).stderr().strip().contains('musl')

/* 原始代码 (glibc) — mytool.c */
#include <stdio.h>
#include <stdlib.h>
#include <argp.h>       /* glibc 专有 */
#include <error.h>      /* glibc 专有 */
#include <execinfo.h>   /* glibc 专有 */

static struct argp_option options[] = {
    {"verbose", 'v', 0, 0, "Verbose output"},
    {"count",   'c', "N", 0, "Repeat N times"},
    {0}
};

struct args { int verbose; int count; char *word; };

static error_t parse_opt(int key, char *arg, struct argp_state *state) {
    struct args *a = state->input;
    switch (key) {
        case 'v': a->verbose = 1; break;
        case 'c': a->count = atoi(arg); break;
        case ARGP_KEY_ARG: a->word = arg; break;
        default: return ARGP_ERR_UNKNOWN;
    }
    return 0;
}

static struct argp argp = {options, parse_opt, "WORD", "My tool"};

int main(int argc, char *argv[]) {
    struct args a = {.count = 1};
    argp_parse(&argp, argc, argv, 0, 0, &a);

    if (!a.word)
        error(1, 0, "missing argument");

    for (int i = 0; i < a.count; i++)
        printf("%s\n", a.word);

    return 0;
}

/* 移植后代码 (可移植版) — mytool.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>     /* POSIX 标准 */
#include <stdarg.h>     /* va_list */

/* 兼容层：错误报告 */
static void my_error(int status, int errnum, const char *fmt, ...) {
    fprintf(stderr, "mytool: ");
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    if (errnum) fprintf(stderr, ": %s", strerror(errnum));
    fprintf(stderr, "\n");
    if (status) exit(status);
}

/* 使用 getopt_long 替代 argp */
static struct option long_options[] = {
    {"verbose", no_argument,       0, 'v'},
    {"count",   required_argument, 0, 'c'},
    {"help",    no_argument,       0, 'h'},
    {0, 0, 0, 0}
};

static void usage(void) {
    fprintf(stderr, "Usage: mytool [OPTIONS] WORD\n");
    fprintf(stderr, "  -v, --verbose    Verbose output\n");
    fprintf(stderr, "  -c, --count N    Repeat N times\n");
    fprintf(stderr, "  -h, --help       Show this help\n");
}

int main(int argc, char *argv[]) {
    int verbose = 0, count = 1, opt;

    while ((opt = getopt_long(argc, argv, "vc:h", long_options, NULL)) != -1) {
        switch (opt) {
            case 'v': verbose = 1; break;
            case 'c': count = atoi(optarg); break;
            case 'h': usage(); return 0;
            default:  usage(); return 1;
        }
    }

    if (optind >= argc)
        my_error(1, 0, "missing argument");

    char *word = argv[optind];

    if (verbose)
        fprintf(stderr, "Printing '%s' %d time(s)\n", word, count);

    for (int i = 0; i < count; i++)
        printf("%s\n", word);

    return 0;
}

/* 编译（在 glibc 和 musl 上都能工作）：
 * $ musl-gcc -static -O2 -o mytool mytool.c
 */

#!/bin/bash
# test_portability.sh — 自动化移植性测试

set -e

SRC="$1"
BASE=$(basename "$SRC" .c)

echo "=== Testing portability of $SRC ==="

# 测试 1：glibc 编译
echo "[1/4] Compiling with glibc..."
gcc -Wall -Wextra -O2 -o "${BASE}_glibc" "$SRC" -lpthread -lm && \
    echo "  OK" || echo "  FAILED"

# 测试 2：musl 编译
echo "[2/4] Compiling with musl..."
musl-gcc -Wall -Wextra -O2 -o "${BASE}_musl" "$SRC" -lpthread -lm && \
    echo "  OK" || echo "  FAILED"

# 测试 3：musl 静态链接
echo "[3/4] Static linking with musl..."
musl-gcc -Wall -Wextra -O2 -static -o "${BASE}_musl_static" "$SRC" -lpthread -lm && \
    echo "  OK" || echo "  FAILED"

# 测试 4：检查二进制文件
echo "[4/4] Binary analysis..."
for bin in "${BASE}_glibc" "${BASE}_musl" "${BASE}_musl_static"; do
    if [ -f "$bin" ]; then
        echo "  $bin:"
        echo "    Size: $(ls -lh "$bin" | awk '{print $5}')"
        echo "    Type: $(file "$bin" | cut -d: -f2)"
        ldd "$bin" 2>&1 | head -5 | sed 's/^/    /'
    fi
done

echo "=== Done ==="