bool custom_test = false;

std::string project_dir;

std::string app_build_script = "jni/Android.mk";

std::string app_application_mk = "jni/Application.mk";

std::string binary_name;

std::string local_binary_path;

std::string device_path;

std::string run_command;

std::string serial;

std::string abi;

int timeout_sec = 20;

bool skip_ndk_build = false;

bool clean_test = false;

WIN32_FILE_ATTRIBUTE_DATA data;

if (!GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &data)) return false;

time = data.ftLastWriteTime;

return true;

FILETIME output_time, input_time;

if (!get_file_time(output, output_time)) return false;

if (!get_file_time(input, input_time)) return true;

return CompareFileTime(&output_time, &input_time) >= 0;

char buf[MAX_PATH];

DWORD len = GetFullPathNameA(path.c_str(), MAX_PATH, buf, NULL);

if (len == 0 || len >= MAX_PATH) return path;

return std::string(buf, len);

char buf[MAX_PATH];

GetModuleFileNameA(NULL, buf, MAX_PATH);

std::string exe_path(buf);

size_t pos = exe_path.find_last_of("\\/");

g_script_dir = exe_path.substr(0, pos);

g_build_dir = g_script_dir + "\\build-windows";

g_acode_dir = g_script_dir + "\\apkUI";

g_apk_output_dir = g_build_dir + "\\bin";

g_zstd_dir = g_script_dir + "\\zstd";

g_zlib_dir = g_script_dir + "\\zlib";

// Search NDK in current directory first

std::string local_ndk = g_script_dir + "\\android-ndk-r30-beta1-windows";

if (dir_exists(local_ndk)) {

g_ndk_dir = local_ndk;

} else {

// Then search in parent directory

std::string p_ndk = g_script_dir + "\\..\\android-ndk-r30-beta1-windows";

char abs_path[MAX_PATH];

if (GetFullPathNameA(p_ndk.c_str(), MAX_PATH, abs_path, NULL)) {

if (dir_exists(abs_path)) {

g_ndk_dir = abs_path;

}

}

}

if (!g_ndk_dir.empty()) {

g_ndk_bin = g_ndk_dir + "\\toolchains\\llvm\\prebuilt\\windows-x86_64\\bin";

}

static const std::string session = "aarch64-ndk-crash";

std::string log_path = g_script_dir + "\\trae-debug-log-" + session + ".ndjson";

SYSTEMTIME st;

GetSystemTime(&st);

char ts[64];

sprintf(ts, "%04d-%02d-%02dT%02d:%02d:%02dZ",

(int)st.wYear, (int)st.wMonth, (int)st.wDay,

(int)st.wHour, (int)st.wMinute, (int)st.wSecond);

std::ofstream ofs(log_path, std::ios::app);

if (!ofs.is_open()) return;

std::string esc;

esc.reserve(detail.size() + 16);

for (char c : detail) {

if (c == '\\') esc += "\\\\";

else if (c == '\"') esc += "\\\"";

else if (c == '\n') esc += "\\n";

else esc += c;

}

ofs << "{"

<< "\"ts\":\"" << ts << "\","

<< "\"session\":\"" << session << "\","

<< "\"event\":\"" << event << "\","

<< "\"detail\":\"" << esc << "\""

<< "}" << std::endl;

const char* vcvars_path = "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Auxiliary\\Build\\vcvars64.bat";

if (file_exists(vcvars_path)) return vcvars_path;

return "";

if (err == 0) return "success";

char* buf = nullptr;

DWORD len = FormatMessageA(

FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

reinterpret_cast<LPSTR>(&buf), 0, NULL);

std::string msg = (len && buf) ? std::string(buf, len) : ("error " + std::to_string(err));

if (buf) LocalFree(buf);

while (!msg.empty() && (msg.back() == '\r' || msg.back() == '\n')) msg.pop_back();

return msg;

if (!file_exists(src)) {

printf("[Error] copy source not found: %s\n", src.c_str());

return false;

}

if (overwrite && file_exists(dst)) {

DWORD attr = GetFileAttributesA(dst.c_str());

if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_READONLY)) {

SetFileAttributesA(dst.c_str(), attr & ~FILE_ATTRIBUTE_READONLY);

}

}

if (CopyFileA(src.c_str(), dst.c_str(), overwrite ? FALSE : TRUE)) {

if (file_exists(dst)) return true;

printf("[Error] copy reported success but destination missing: %s\n", dst.c_str());

return false;

}

DWORD copy_err = GetLastError();

if (overwrite && file_exists(dst)) {

if (DeleteFileA(dst.c_str()) && CopyFileA(src.c_str(), dst.c_str(), TRUE)) {

if (file_exists(dst)) return true;

printf("[Error] copy-after-delete reported success but destination missing: %s\n", dst.c_str());

return false;

}

copy_err = GetLastError();

}

printf("[Error] copy failed: %s -> %s (%s)\n",

src.c_str(), dst.c_str(), format_win32_error(copy_err).c_str());

return false;

size_t begin = 0;

while (begin < input.size() && std::isspace(static_cast<unsigned char>(input[begin]))) begin++;

size_t end = input.size();

while (end > begin && std::isspace(static_cast<unsigned char>(input[end - 1]))) end--;

return input.substr(begin, end - begin);

char buf[32767];

DWORD len = GetEnvironmentVariableA(name, buf, sizeof(buf));

if (len == 0 || len >= sizeof(buf)) return "";

return std::string(buf, len);

char buf[MAX_PATH];

DWORD len = SearchPathA(NULL, name, NULL, MAX_PATH, buf, NULL);

if (len == 0 || len >= MAX_PATH) return "";

return std::string(buf, len);

std::string launcher = search_path_binary("sccache.exe");

if (!launcher.empty()) return launcher;

launcher = search_path_binary("clcache.exe");

return launcher;

std::string bat_file = cwd.empty() ? "build_tmp.bat" : cwd + "\\build_tmp.bat";

FILE *f = fopen(bat_file.c_str(), "wb");

if (!f) return -1;

fprintf(f, "@echo off\r\nchcp 65001 >nul\r\n");

if (!cwd.empty()) fprintf(f, "cd /d \"%s\"\r\n", cwd.c_str());

fprintf(f, "%s\r\n", cmd.c_str());

fprintf(f, "exit /b %%ERRORLEVEL%%\r\n");

fclose(f);

int ret = system(bat_file.c_str());

DeleteFileA(bat_file.c_str());

return ret;

std::string bat_file = cwd.empty() ? "build_tmp.bat" : cwd + "\\build_tmp.bat";

FILE *f = fopen(bat_file.c_str(), "wb");

if (!f) return -1;

fprintf(f, "@echo off\r\nchcp 65001 >nul\r\n");

fprintf(f, "call \"%s\" >nul 2>&1\r\n", vcvars.c_str());

if (!cwd.empty()) fprintf(f, "cd /d \"%s\"\r\n", cwd.c_str());

fprintf(f, "%s\r\n", cmd.c_str());

fprintf(f, "exit /b %%ERRORLEVEL%%\r\n");

fclose(f);

int ret = system(bat_file.c_str());

DeleteFileA(bat_file.c_str());

return ret;

char suffix[32];

sprintf(suffix, "%llu", static_cast<unsigned long long>(GetTickCount64()));

std::string base = cwd.empty() ? g_script_dir : cwd;

std::string bat_file = base + "\\build_capture_" + suffix + ".bat";

std::string out_file = base + "\\build_capture_" + suffix + ".log";

FILE *f = fopen(bat_file.c_str(), "wb");

if (!f) return -1;

fprintf(f, "@echo off\r\nchcp 65001 >nul\r\n");

if (!cwd.empty()) fprintf(f, "cd /d \"%s\"\r\n", cwd.c_str());

fprintf(f, "%s > \"%s\" 2>&1\r\n", cmd.c_str(), out_file.c_str());

fprintf(f, "exit /b %%ERRORLEVEL%%\r\n");

fclose(f);

int ret = system(bat_file.c_str());

DeleteFileA(bat_file.c_str());

std::ifstream in(out_file, std::ios::binary);

if (in.is_open()) {

std::ostringstream ss;

ss << in.rdbuf();

output = ss.str();

in.close();

DeleteFileA(out_file.c_str());

} else {

output.clear();

}

return ret;

const std::string& cwd, DWORD timeout_ms,

bool* timed_out = nullptr) {

if (timed_out) *timed_out = false;

char suffix[32];

sprintf(suffix, "%llu", static_cast<unsigned long long>(GetTickCount64()));

std::string base = cwd.empty() ? g_script_dir : cwd;

std::string bat_file = base + "\\build_capture_" + suffix + ".bat";

std::string out_file = base + "\\build_capture_" + suffix + ".log";

FILE *f = fopen(bat_file.c_str(), "wb");

if (!f) return -1;

fprintf(f, "@echo off\r\nchcp 65001 >nul\r\n");

if (!cwd.empty()) fprintf(f, "cd /d \"%s\"\r\n", cwd.c_str());

fprintf(f, "%s > \"%s\" 2>&1\r\n", cmd.c_str(), out_file.c_str());

fprintf(f, "exit /b %%ERRORLEVEL%%\r\n");

fclose(f);

std::string command_line = "cmd.exe /C \"" + bat_file + "\"";

std::vector<char> cmdline(command_line.begin(), command_line.end());

cmdline.push_back('\0');

STARTUPINFOA si;

PROCESS_INFORMATION pi;

ZeroMemory(&si, sizeof(si));

ZeroMemory(&pi, sizeof(pi));

si.cb = sizeof(si);

si.dwFlags = STARTF_USESHOWWINDOW;

si.wShowWindow = SW_HIDE;

BOOL ok = CreateProcessA(

NULL,

cmdline.data(),

NULL,

NULL,

FALSE,

CREATE_NO_WINDOW,

NULL,

cwd.empty() ? NULL : cwd.c_str(),

&si,

&pi

);

int ret = -1;

if (!ok) {

DeleteFileA(bat_file.c_str());

return -1;

}

DWORD wait_ret = WaitForSingleObject(pi.hProcess, timeout_ms == 0 ? INFINITE : timeout_ms);

if (wait_ret == WAIT_TIMEOUT) {

if (timed_out) *timed_out = true;

TerminateProcess(pi.hProcess, 124);

WaitForSingleObject(pi.hProcess, INFINITE);

ret = 124;

} else {

DWORD exit_code = 0;

if (GetExitCodeProcess(pi.hProcess, &exit_code)) {

ret = static_cast<int>(exit_code);

}

}

CloseHandle(pi.hThread);

CloseHandle(pi.hProcess);

DeleteFileA(bat_file.c_str());

std::ifstream in(out_file, std::ios::binary);

if (in.is_open()) {

std::ostringstream ss;

ss << in.rdbuf();

output = ss.str();

in.close();

DeleteFileA(out_file.c_str());

} else {

output.clear();

}

return ret;

std::string adb = search_path_binary("adb.exe");

if (!adb.empty()) return adb;

const char* envs[] = {"ANDROID_SDK_ROOT", "ANDROID_HOME"};

for (auto env : envs) {

std::string root = get_env_var(env);

if (root.empty()) continue;

std::string candidate = root + "\\platform-tools\\adb.exe";

if (file_exists(candidate)) return candidate;

}

return "";

std::string output;

std::string cmd = "\"" + adb_path + "\" devices";

if (run_cmd_capture(cmd, output) != 0) return "";

std::istringstream iss(output);

std::string line;

std::string first_device;

while (std::getline(iss, line)) {

line = trim_copy(line);

if (line.empty()) continue;

if (line.find("List of devices attached") == 0) continue;

if (line.find("* daemon") == 0) continue;

size_t tab = line.find('\t');

if (tab == std::string::npos) continue;

std::string serial = trim_copy(line.substr(0, tab));

std::string state = trim_copy(line.substr(tab + 1));

if (state != "device") continue;

if (serial.find("emulator-") == 0) return serial;

if (first_device.empty()) first_device = serial;

}

return first_device;

if (abi.find("arm64-v8a") != std::string::npos) return "arm64-v8a";

if (abi.find("armeabi-v7a") != std::string::npos) return "armeabi-v7a";

if (abi.find("x86_64") != std::string::npos) return "x86_64";

if (abi.find("x86") != std::string::npos) return "x86";

return trim_copy(abi);

std::string output;

std::string cmd = "\"" + adb_path + "\" -s " + serial + " shell getprop ro.product.cpu.abi";

if (run_cmd_capture(cmd, output) != 0) return "";

std::istringstream iss(output);

std::string line;

while (std::getline(iss, line)) {

line = normalize_abi(line);

if (!line.empty()) return line;

}

return "";

const std::string candidates[] = {

project_dir + "\\libs\\" + abi + "\\allvm_test",

project_dir + "\\obj\\local\\" + abi + "\\allvm_test"

};

for (const auto& candidate : candidates) {

if (file_exists(candidate)) return candidate;

}

return "";

const std::string& serial,

const std::string& binary_name) {

const char* dirs[] = { "/data/local/tmp", "/data/local/tests" };

for (const char* dir : dirs) {

std::string probe = std::string(dir) + "/.allvm_probe";

std::string cmd = "\"" + adb_path + "\" -s " + serial +

" shell \"touch " + probe +

" >/dev/null 2>&1 && rm -f " + probe + " >/dev/null 2>&1\"";

std::string output;

if (run_cmd_capture(cmd, output, g_script_dir) == 0) {

return std::string(dir) + "/" + binary_name;

}

}

return "/data/local/tmp/" + binary_name;

const std::string& binary_name_or_path) {

if (binary_name_or_path.empty()) return "";

if (file_exists(binary_name_or_path)) {

return get_full_path_copy(binary_name_or_path);

}

const std::string candidates[] = {

project_dir + "\\libs\\" + abi + "\\" + binary_name_or_path,

project_dir + "\\obj\\local\\" + abi + "\\" + binary_name_or_path

};

for (const auto& candidate : candidates) {

if (file_exists(candidate)) return get_full_path_copy(candidate);

}

return "";

std::transform(value.begin(), value.end(), value.begin(),

[](unsigned char c) { return static_cast<char>(std::tolower(c)); });

return value;

value = lower_ascii_copy(std::move(value));

std::string out;

out.reserve(value.size());

bool last_was_space = false;

for (unsigned char c : value) {

if (std::isspace(c)) {

if (!last_was_space) out.push_back(' ');

last_was_space = true;

} else {

out.push_back(static_cast<char>(c));

last_was_space = false;

}

}

return out;

std::string clangxx = g_build_dir + "\\bin\\clang++.exe";

if (!file_exists(clangxx)) {

printf("[Warning] clang++ not found, skipping frame record verification\n");

return true;

}

std::string src = g_script_dir + "\\test\\jni\\frame_record_codegen.cpp";

std::string asm_path = g_script_dir + "\\test\\frame_record_codegen.s";

if (!file_exists(src)) {

printf("[Error] Frame record probe source not found: %s\n", src.c_str());

return false;

}

std::string output;

std::string cmd = "\"" + clangxx +

"\" --target=aarch64-linux-android21 -S -O2 "

"-fno-omit-frame-pointer "

"-mllvm -aarch64-obfuscate-frame-record "

"-mllvm -aarch64-enable-ldst-opt=false "

"\"" + src + "\" -o \"" + asm_path + "\"";

if (run_cmd_capture(cmd, output) != 0) {

if (!output.empty()) printf("%s", output.c_str());

printf("[Error] Failed to compile frame record probe\n");

return false;

}

std::ifstream in(asm_path, std::ios::binary);

if (!in.is_open()) {

printf("[Error] Failed to read generated asm: %s\n", asm_path.c_str());

return false;

}

std::ostringstream ss;

ss << in.rdbuf();

std::string asm_text = ss.str();

in.close();

std::istringstream iss(asm_text);

std::string line;

std::string block;

bool in_symbol = false;

while (std::getline(iss, line)) {

if (!in_symbol) {

if (line.find("frame_record_probe:") != std::string::npos) {

in_symbol = true;

block += line + "\n";

}

continue;

}

bool is_new_symbol = !line.empty() &&

line[0] != '\t' &&

line[0] != ' ' &&

line[0] != '/' &&

line.back() == ':' &&

line.find("frame_record_probe:") == std::string::npos;

if (is_new_symbol || line.rfind(".Lfunc_end", 0) == 0) {

break;

}

block += line + "\n";

}

if (block.empty()) {

printf("[Error] frame_record_probe symbol not found in generated asm\n");

return false;

}

std::replace(block.begin(), block.end(), '\t', ' ');

std::string lower = lower_ascii_copy(block);

auto has = [&](const char* needle) {

return lower.find(needle) != std::string::npos;

};

bool has_split_store = (has("str x29") || has("stur x29")) &&

(has("str x30") || has("stur x30"));

bool has_split_load = (has("ldr x29") || has("ldur x29")) &&

(has("ldr x30") || has("ldur x30"));

bool has_fp_mix = has("add x29, sp") && has("sub x29, x29");

bool has_std_pair = has("stp x29, x30") || has("stp x30, x29") ||

has("ldp x29, x30") || has("ldp x30, x29");

bool has_std_mov = has("mov x29, sp");

if (!has_split_store || !has_split_load || !has_fp_mix || has_std_pair || has_std_mov) {

printf("[Error] frame_record_probe codegen verification failed\n");

printf("-------- frame_record_probe --------\n%s-------- end --------\n", block.c_str());

return false;

}

printf("[Done] frame_record_probe uses split frame record sequence\n");

return true;

std::string clangxx = g_build_dir + "\\bin\\clang++.exe";

if (!file_exists(clangxx)) {

printf("[Warning] clang++ not found, skipping call/ret verification\n");

return true;

}

std::string src = g_script_dir + "\\test\\jni\\call_ret_codegen.cpp";

std::string asm_path = g_script_dir + "\\test\\call_ret_codegen.s";

if (!file_exists(src)) {

printf("[Error] Call/ret probe source not found: %s\n", src.c_str());

return false;

}

std::string output;

std::string cmd = "\"" + clangxx +

"\" --target=aarch64-linux-android21 -S -O2 "

"-mllvm -aarch64-obfuscate-call-ret "

"\"" + src + "\" -o \"" + asm_path + "\"";

if (run_cmd_capture(cmd, output) != 0) {

if (!output.empty()) printf("%s", output.c_str());

printf("[Error] Failed to compile call/ret probe\n");

return false;

}

std::ifstream in(asm_path, std::ios::binary);

if (!in.is_open()) {

printf("[Error] Failed to read generated asm: %s\n", asm_path.c_str());

return false;

}

std::ostringstream ss;

ss << in.rdbuf();

std::string asm_text = ss.str();

in.close();

std::istringstream iss(asm_text);

std::string line;

std::string block;

bool in_symbol = false;

while (std::getline(iss, line)) {

if (!in_symbol) {

if (line.find("call_ret_probe:") != std::string::npos) {

in_symbol = true;

block += line + "\n";

}

continue;

}

bool is_new_symbol = !line.empty() &&

line[0] != '\t' &&

line[0] != ' ' &&

line[0] != '/' &&

line.back() == ':' &&

line.find("call_ret_probe:") == std::string::npos;

if (is_new_symbol || line.rfind(".Lfunc_end", 0) == 0) {

break;

}

block += line + "\n";

}

if (block.empty()) {

printf("[Error] call_ret_probe symbol not found in generated asm\n");

return false;

}

std::replace(block.begin(), block.end(), '\t', ' ');

std::string lower = lower_ascii_copy(block);

auto has = [&](const char* needle) {

return lower.find(needle) != std::string::npos;

};

bool has_target_materialization = has("adrp") && has("target_call") &&

(has(":lo12:target_call") ||

has(" target_call"));

bool has_indirect_call = has_target_materialization && has("blr x");

bool has_br_lr = has("br x30");

bool has_direct_bl = has("bl target_call");

bool has_ret = has("\n ret") || has("\nret");

if (!has_indirect_call || !has_br_lr || has_direct_bl || has_ret) {

printf("[Error] call_ret_probe codegen verification failed\n");

printf("-------- call_ret_probe --------\n%s-------- end --------\n", block.c_str());

return false;

}

printf("[Done] call_ret_probe uses indirect call and BR x30 sequence\n");

return true;

std::string llc = g_build_dir + "\\bin\\llc.exe";

if (!file_exists(llc)) {

printf("[Warning] llc not found, skipping call/ret scratch verification\n");

return true;

}

std::string src = g_script_dir + "\\llvm\\test\\CodeGen\\AArch64\\irobf-call-ret-scratch.mir";

if (!file_exists(src)) {

printf("[Error] Call/ret scratch MIR not found: %s\n", src.c_str());

return false;

}

std::string output;

std::string cmd = "\"" + llc +

"\" -mtriple=aarch64-none-linux-gnu "

"-run-pass=aarch64-call-ret-obfuscation "

"-aarch64-obfuscate-call-ret "

"-verify-machineinstrs=0 -o - "

"\"" + src + "\"";

int mir_ret = run_cmd_capture(cmd, output);

dbg_log("mir_verify_call_ret_scratch_start", cmd);

if (output.empty()) {

printf("[Error] Failed to run call/ret scratch MIR verification\n");

dbg_log("mir_verify_call_ret_scratch_error", "empty_output");

return false;

}

if (mir_ret != 0 && !output.empty()) {

printf("%s", output.c_str());

// Continue to analyze output even if llc returned non-zero,

// as long as the expected patterns are present.

dbg_log("mir_verify_call_ret_scratch_nonzero", std::string("code=") + std::to_string(mir_ret));

}

std::string lower = lower_ascii_copy(output);

auto has = [&](const char* needle) {

return lower.find(needle) != std::string::npos;

};

bool has_indirect_call = has("adrp") && has("addxri") && has("blr");

bool preserves_x16_arg = has("implicit $x16");

bool clobbers_x16 = has("$x16 = adrp") || has("$x16 = addxri") || has("blr $x16");

if (!has_indirect_call || !preserves_x16_arg || clobbers_x16) {

printf("[Error] call/ret scratch MIR verification failed\n");

printf("-------- irobf-call-ret-scratch.mir --------\n%s-------- end --------\n", output.c_str());

dbg_log("mir_verify_call_ret_scratch_fail",

std::string("has_indirect_call=") + (has_indirect_call?"1":"0") +

" preserves_x16_arg=" + (preserves_x16_arg?"1":"0") +

" clobbers_x16=" + (clobbers_x16?"1":"0"));

return false;

}

printf("[Done] scratch MIR keeps x16 live and uses a different call scratch register\n");

dbg_log("mir_verify_call_ret_scratch_ok", "ok");

return true;

std::string llc = g_build_dir + "\\bin\\llc.exe";

if (!file_exists(llc)) {

printf("[Warning] llc not found, skipping opaque predicate verification\n");

return true;

}

std::string objdump = g_build_dir + "\\bin\\llvm-objdump.exe";

if (!file_exists(objdump)) {

printf("[Warning] llvm-objdump not found, skipping opaque predicate object verification\n");

return true;

}

std::string src = g_script_dir + "\\llvm\\test\\CodeGen\\AArch64\\irobf-opaque-predicate-bytes.ll";

if (!file_exists(src)) {

printf("[Error] Opaque predicate probe source not found: %s\n", src.c_str());

return false;

}

std::string asm_path = g_script_dir + "\\test\\opaque_predicate_codegen.s";

std::string obj_path = g_script_dir + "\\test\\opaque_predicate_codegen.o";

std::string output;

std::string asm_cmd = "\"" + llc +

"\" -mtriple=aarch64-linux-gnu -O2 "

"-aarch64-obfuscate-opaque-predicate "

"\"" + src + "\" -o \"" + asm_path + "\"";

if (run_cmd_capture(asm_cmd, output) != 0) {

if (!output.empty()) printf("%s", output.c_str());

printf("[Error] Failed to compile opaque predicate asm probe\n");

return false;

}

std::ifstream in(asm_path, std::ios::binary);

if (!in.is_open()) {

printf("[Error] Failed to read generated asm: %s\n", asm_path.c_str());

return false;

}

std::ostringstream ss;

ss << in.rdbuf();

std::string asm_text = ss.str();

in.close();

std::string lower_asm = normalize_ascii_whitespace(asm_text);

auto asm_has = [&](const char* needle) {

return lower_asm.find(needle) != std::string::npos;

};

bool has_guard_branch = asm_has("cbnz x9");

bool has_dead_bytes = asm_has(".byte 0");

bool has_misaligned_tail = asm_has(".byte 232");

bool has_realign = asm_has(".p2align 2, 0x0");

if (!has_guard_branch || !has_dead_bytes || !has_misaligned_tail || !has_realign) {

printf("[Error] opaque predicate asm verification failed\n");

printf("-------- opaque_predicate_codegen.s --------\n%s-------- end --------\n", asm_text.c_str());

return false;

}

output.clear();

std::string obj_cmd = "\"" + llc +

"\" -mtriple=aarch64-linux-gnu -filetype=obj -O2 "

"-aarch64-obfuscate-opaque-predicate "

"\"" + src + "\" -o \"" + obj_path + "\"";

if (run_cmd_capture(obj_cmd, output) != 0) {

if (!output.empty()) printf("%s", output.c_str());

printf("[Error] Failed to compile opaque predicate object probe\n");

return false;

}

output.clear();

std::string dump_cmd = "\"" + objdump +

"\" -d --triple=aarch64-linux-gnu "

"\"" + obj_path + "\"";

if (run_cmd_capture(dump_cmd, output) != 0) {

if (!output.empty()) printf("%s", output.c_str());

printf("[Error] Failed to disassemble opaque predicate object probe\n");

return false;

}

std::string lower_dump = normalize_ascii_whitespace(output);

auto dump_has = [&](const char* needle) {

return lower_dump.find(needle) != std::string::npos;

};

bool has_udf_encoding = dump_has(".word 0x00000000");

bool has_tail_word = dump_has(".word 0x000003e8");

if (!has_udf_encoding || !has_tail_word) {

printf("[Error] opaque predicate object verification failed\n");

printf("-------- opaque_predicate_codegen.o --------\n%s-------- end --------\n", output.c_str());

return false;

}

printf("[Done] opaque predicate emits dead bytes with UDF encoding and misaligned tail\n");

return true;

std::string ndk_build_bat = g_ndk_dir + "\\ndk-build.bat";

std::string ndk_build_cmd = g_ndk_dir + "\\ndk-build.cmd";

if (g_ndk_dir.empty() || (!file_exists(ndk_build_bat) && !file_exists(ndk_build_cmd))) {

printf("[Error] NDK not found, cannot build test project\n");

return false;

}

std::string project_dir = get_full_path_copy(opts.project_dir);

if (!dir_exists(project_dir)) {

printf("[Error] Test project directory not found: %s\n", project_dir.c_str());

return false;

}

if (opts.clean_test) {

run_cmd("if exist obj rmdir /s /q obj", project_dir);

run_cmd("if exist libs rmdir /s /q libs", project_dir);

}

char jbuf[16];

sprintf(jbuf, "%d", jobs);

std::string ndk_build = file_exists(ndk_build_bat) ? ndk_build_bat : ndk_build_cmd;

std::string ndk_cmd = "\"" + ndk_build + "\" NDK_PROJECT_PATH=. APP_BUILD_SCRIPT=\"" +

opts.app_build_script + "\" NDK_APPLICATION_MK=\"" +

opts.app_application_mk + "\" -j" + jbuf;

dbg_log("ndk_build_start", std::string("cwd=") + project_dir + " cmd=" + ndk_cmd);

int ret = run_cmd(ndk_cmd, project_dir);

dbg_log("ndk_build_end", std::string("ret=") + std::to_string(ret));

if (ret != 0) {

printf("[Error] ndk-build failed for %s (code: %d)\n", project_dir.c_str(), ret);

return false;

}

return true;

std::string adb_path = find_adb();

if (adb_path.empty()) {

printf("[Error] adb not found in PATH / ANDROID_SDK_ROOT / ANDROID_HOME\n");

return false;

}

std::string serial = opts.serial.empty() ? find_test_device(adb_path) : opts.serial;

if (serial.empty()) {

printf("[Error] No connected emulator/device found for adb testing\n");

return false;

}

printf(" -> Using device: %s\n", serial.c_str());

std::string abi = opts.abi.empty() ? detect_device_abi(adb_path, serial) : normalize_abi(opts.abi);

if (abi.empty()) {

printf("[Error] Failed to detect device ABI\n");

return false;

}

printf(" -> Device ABI: %s\n", abi.c_str());

std::string local_binary = opts.local_binary_path;

if (local_binary.empty()) {

local_binary = find_named_binary(get_full_path_copy(opts.project_dir), abi, opts.binary_name);

} else {

local_binary = get_full_path_copy(local_binary);

}

if (local_binary.empty() || !file_exists(local_binary)) {

printf("[Error] Test binary not found\n");

return false;

}

std::string device_path = opts.device_path;

if (device_path.empty()) {

device_path = choose_device_test_path(adb_path, serial, path_basename(local_binary));

}

printf(" -> Local binary: %s\n", local_binary.c_str());

printf(" -> Device path : %s\n", device_path.c_str());

std::string output;

std::string push_cmd = "\"" + adb_path + "\" -s " + serial + " push \"" +

local_binary + "\" \"" + device_path + "\"";

int ret = run_cmd_capture(push_cmd, output);

if (!output.empty()) printf("%s", output.c_str());

if (ret != 0) {

printf("[Error] adb push failed (code: %d)\n", ret);

return false;

}

std::string remote_run = opts.run_command.empty()

? ("chmod 755 \"" + device_path + "\" && \"" + device_path + "\"")

: opts.run_command;

bool timed_out = false;

output.clear();

std::string exec_cmd = "\"" + adb_path + "\" -s " + serial + " shell \"" + remote_run + "\"";

ret = run_cmd_capture_timeout(exec_cmd, output, g_script_dir,

opts.timeout_sec > 0 ? static_cast<DWORD>(opts.timeout_sec) * 1000U : 0U,

&timed_out);

if (!output.empty()) printf("%s", output.c_str());

if (timed_out) {

printf("[Error] Device run timed out after %d seconds\n", opts.timeout_sec);

std::string base = path_basename(device_path);

std::string kill_cmd = "\"" + adb_path + "\" -s " + serial +

" shell \"pkill -f '" + base + "' >/dev/null 2>&1 || true\"";

std::string kill_output;

run_cmd_capture(kill_cmd, kill_output, g_script_dir);

return false;

}

if (ret != 0) {

printf("[Error] Device run failed (code: %d)\n", ret);

return false;

}

return true;

std::string jni_dir = g_script_dir + "\\test\\jni";

const char* required[] = {"Android.mk", "Application.mk", "main.cpp"};

for (const char* name : required) {

std::string path = jni_dir + "\\" + name;

if (!file_exists(path)) {

printf("[Error] Missing handwritten test file: %s\n", path.c_str());

return false;

}

}

return true;

printf("\n[Test] Building handwritten ALLVM_TEST project...\n");

std::string ndk_build_bat = g_ndk_dir + "\\ndk-build.bat";

std::string ndk_build_cmd = g_ndk_dir + "\\ndk-build.cmd";

if (g_ndk_dir.empty() || (!file_exists(ndk_build_bat) && !file_exists(ndk_build_cmd))) {

printf("[Error] NDK not found, cannot run emulator test\n");

return false;

}

std::string adb_path = find_adb();

if (adb_path.empty()) {

printf("[Error] adb not found in PATH / ANDROID_SDK_ROOT / ANDROID_HOME\n");

return false;

}

std::string serial = opts.serial.empty() ? find_test_device(adb_path) : opts.serial;

if (serial.empty()) {

printf("[Error] No connected emulator/device found for adb testing\n");

return false;

}

printf(" -> Using device: %s\n", serial.c_str());

std::string abi = opts.abi.empty() ? detect_device_abi(adb_path, serial) : normalize_abi(opts.abi);

if (abi.empty()) {

printf("[Error] Failed to detect device ABI\n");

return false;

}

printf(" -> Test ABI: %s\n", abi.c_str());

if (!ensure_fla_test_project_exists()) {

return false;

}

std::string test_dir = g_script_dir + "\\test";

if (opts.clean_test) {

run_cmd("if exist obj rmdir /s /q obj", test_dir);

run_cmd("if exist libs rmdir /s /q libs", test_dir);

}

char jbuf[16];

sprintf(jbuf, "%d", jobs);

std::string ndk_build = file_exists(ndk_build_bat) ? ndk_build_bat : ndk_build_cmd;

std::string ndk_cmd = "\"" + ndk_build + "\" NDK_PROJECT_PATH=. APP_BUILD_SCRIPT=jni/Android.mk NDK_APPLICATION_MK=jni/Application.mk APP_ABI=" + abi + " -j" + jbuf;

dbg_log("ndk_build_start", std::string("cwd=") + test_dir + " cmd=" + ndk_cmd);

int ret = run_cmd(ndk_cmd, test_dir);

dbg_log("ndk_build_end", std::string("ret=") + std::to_string(ret));

if (ret != 0) {

printf("[Error] ndk-build test project failed (code: %d)\n", ret);

return false;

}