suyu-github/drippu
0
0 Fork 0
mirror of https://github.com/suyu-emu/drippu-rep.git synced 2026-09-21 14:44:58 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
codex/release-version-input
drippu/tools/static_recompiler/suyu_recomp.cpp
T

426 lines
21 KiB
C++
Raw Permalink Blame History

// SPDX-FileCopyrightText: Copyright 2026 suyu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
//
// suyu static recompiler — ARM64 (AArch64) -> portable C source -> native binary.
//
// This is a *real* static recompiler in the spirit of N64Recomp (which lifts MIPS to C against a
// context struct). It decodes a meaningful subset of AArch64 user-mode instructions and emits C
// that operates on a GuestContext. Every instruction is either translated to native C semantics or
// emitted as a call to a runtime fallback, so the generated project ALWAYS compiles and links into
// a native executable for Windows / Linux / *BSD / macOS, or can be emitted as plain C source.
//
// Limits (honest): a full commercial title additionally needs suyu's HLE OS + GPU runtime, which is
// linked in via the generated runtime's SVC/MMIO hooks. Out of the box the produced binary executes
// recompiled guest code until it reaches an un-hooked syscall, then stops cleanly.
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
namespace {
using u8 = uint8_t;
using u32 = uint32_t;
using u64 = uint64_t;
using s32 = int32_t;
using s64 = int64_t;
struct Block {
u64 vaddr;
u32 size;
u32 count;
bool is_entry;
};
// ---- AArch64 decode helpers -------------------------------------------------
bool IsTerminator(u32 i) {
if ((i & 0xFC000000) == 0x14000000) return true; // B
if ((i & 0xFC000000) == 0x94000000) return true; // BL
if ((i & 0xFFFFFC1F) == 0xD61F0000) return true; // BR
if ((i & 0xFFFFFC1F) == 0xD63F0000) return true; // BLR
if ((i & 0xFFFFFC1F) == 0xD65F0000) return true; // RET
if ((i & 0x7F000000) == 0x34000000) return true; // CBZ
if ((i & 0x7F000000) == 0x35000000) return true; // CBNZ
if ((i & 0x7F000000) == 0x36000000) return true; // TBZ
if ((i & 0x7F000000) == 0x37000000) return true; // TBNZ
if ((i & 0xFF000010) == 0x54000000) return true; // B.cond
if ((i & 0xFFE0001F) == 0xD4000001) return true; // SVC
return false;
}
bool DirectBranchTarget(u32 i, u64 pc, u64& out) {
if ((i & 0xFC000000) == 0x14000000 || (i & 0xFC000000) == 0x94000000) {
s32 imm26 = (s32)(i << 6) >> 6;
out = pc + (s64)imm26 * 4;
return true;
}
return false;
}
std::vector<Block> DiscoverBlocks(const u8* text, size_t n_bytes, u64 base) {
const u32 n = (u32)(n_bytes / 4);
std::vector<bool> start(n, false);
if (n == 0) return {};
start[0] = true;
const u32* p = reinterpret_cast<const u32*>(text);
for (u32 i = 0; i < n; ++i) {
const u32 insn = p[i];
const u64 pc = base + (u64)i * 4;
if (IsTerminator(insn)) {
if (i + 1 < n) start[i + 1] = true;
u64 t = 0;
if (DirectBranchTarget(insn, pc, t)) {
if (t >= base && (t - base) / 4 < n) start[(u32)((t - base) / 4)] = true;
}
// conditional branch fallthrough target
if ((insn & 0xFF000010) == 0x54000000 || (insn & 0x7F000000) == 0x34000000 ||
(insn & 0x7F000000) == 0x35000000 || (insn & 0x7F000000) == 0x36000000 ||
(insn & 0x7F000000) == 0x37000000) {
// B.cond / CBZ / CBNZ / TBZ / TBNZ have a 19/14-bit target too
s64 off = 0;
if ((insn & 0xFF000010) == 0x54000000) off = ((s32)((insn >> 5) << 13) >> 13);
else if ((insn & 0x7E000000) == 0x34000000) off = ((s32)(((insn >> 5) & 0x7FFFF) << 13) >> 13);
else off = ((s32)(((insn >> 5) & 0x3FFF) << 18) >> 18);
u64 tt = pc + off * 4;
if (tt >= base && (tt - base) / 4 < n) start[(u32)((tt - base) / 4)] = true;
}
}
}
std::vector<Block> blocks;
u32 s = 0;
for (u32 i = 1; i <= n; ++i) {
if (i == n || start[i]) {
blocks.push_back(Block{base + (u64)s * 4, (i - s) * 4, i - s, s == 0});
s = i;
}
}
return blocks;
}
// register name: x31 reads as zero in most data-processing contexts.
std::string Xz(u32 r) { return r == 31 ? std::string("(uint64_t)0") : ("c->x[" + std::to_string(r) + "]"); }
std::string Wz(u32 r) { return r == 31 ? std::string("(uint32_t)0") : ("(uint32_t)c->x[" + std::to_string(r) + "]"); }
std::string Xset(u32 r) { return "c->x[" + std::to_string(r) + "]"; } // 31 == SP in SP-form
// ---- per-instruction translator --------------------------------------------
// Appends C statements for one instruction. Returns false if the instruction terminates the block.
bool Translate(u32 i, u64 pc, std::string& out) {
char buf[256];
auto emit = [&](const std::string& s) { out += " " + s + "\n"; };
const u64 next = pc + 4;
if (i == 0xD503201F || (i & 0xFFFFF01F) == 0xD503201F) { emit("/* nop/hint */"); return true; } // NOP/HINT
// MOVZ/MOVN/MOVK (move wide immediate)
if ((i & 0x1F800000) == 0x12800000) {
u32 sf = i >> 31, opc = (i >> 29) & 3, hw = (i >> 21) & 3, imm16 = (i >> 5) & 0xFFFF, rd = i & 31;
if (rd != 31) {
u64 shift = (u64)hw * 16;
if (opc == 2) { // MOVZ
snprintf(buf, sizeof buf, "c->x[%u] = (uint64_t)0x%llxULL;", rd, (unsigned long long)((u64)imm16 << shift));
emit(buf);
} else if (opc == 0) { // MOVN
u64 v = ~((u64)imm16 << shift); if (!sf) v &= 0xFFFFFFFF;
snprintf(buf, sizeof buf, "c->x[%u] = (uint64_t)0x%llxULL;", rd, (unsigned long long)v); emit(buf);
} else if (opc == 3) { // MOVK
snprintf(buf, sizeof buf, "c->x[%u] = (c->x[%u] & ~(0xFFFFULL<<%llu)) | (0x%xULL<<%llu);",
rd, rd, (unsigned long long)shift, imm16, (unsigned long long)shift); emit(buf);
}
if (!sf) { snprintf(buf, sizeof buf, "c->x[%u] &= 0xFFFFFFFFULL;", rd); emit(buf); }
}
return true;
}
// ADD/SUB immediate (incl S variants)
if ((i & 0x1F000000) == 0x11000000) {
u32 sf = i >> 31, op = (i >> 30) & 1, S = (i >> 29) & 1, sh = (i >> 22) & 1;
u32 imm12 = (i >> 10) & 0xFFF, rn = (i >> 5) & 31, rd = i & 31;
u64 imm = sh ? ((u64)imm12 << 12) : imm12;
std::string a = (rn == 31) ? "c->x[31]" : ("c->x[" + std::to_string(rn) + "]"); // 31 = SP here
snprintf(buf, sizeof buf, "{ uint64_t _a=%s, _b=%lluULL; uint64_t _r=%s; ", a.c_str(),
(unsigned long long)imm, op ? "_a-_b" : "_a+_b");
std::string s = buf;
if (!sf) s += "_r&=0xFFFFFFFFULL; ";
if (rd != 31 || S) { if (rd != 31) s += "c->x[" + std::to_string(rd) + "]=_r; "; }
else s += "c->x[31]=_r; ";
if (S) s += "recomp_set_flags(c," + std::string(op ? "1" : "0") + ",_a,_b,_r," + (sf?"1":"0") + "); ";
s += "}";
emit(s);
return true;
}
// Logical (shifted register): AND/ORR/EOR/ANDS, shift==LSL#0 fast path; MOV via ORR Xd,XZR,Xm
if ((i & 0x1F000000) == 0x0A000000) {
u32 sf = i >> 31, opc = (i >> 29) & 3, rm = (i >> 16) & 31, rn = (i >> 5) & 31, rd = i & 31;
u32 shift = (i >> 22) & 3, imm6 = (i >> 10) & 0x3F, N = (i >> 21) & 1;
std::string rmv = Xz(rm);
if (imm6) { // apply shift
const char* opn = shift==0?"<<":shift==1?">>":shift==2?">>":">>";
char sb[96]; snprintf(sb,sizeof sb,"(%s %s %u)", rmv.c_str(), opn, imm6); rmv = sb;
}
std::string a = Xz(rn);
const char* lop = opc==0?"&":opc==1?"|":opc==2?"^":"&";
std::string expr = (N? ("("+a+" "+lop+" ~"+rmv+")") : ("("+a+" "+lop+" "+rmv+")"));
if (rd != 31) {
std::string s = "c->x[" + std::to_string(rd) + "] = " + expr + ";";
emit(s);
if (!sf) { snprintf(buf,sizeof buf,"c->x[%u]&=0xFFFFFFFFULL;",rd); emit(buf);}
}
if (opc==3) { snprintf(buf,sizeof buf,"recomp_set_logic_flags(c,%s,%s);", (rd!=31?("c->x["+std::to_string(rd)+"]").c_str():expr.c_str()), sf?"1":"0"); emit(buf);}
return true;
}
// ADD/SUB shifted register (LSL/LSR/ASR), no extend
if ((i & 0x1F200000) == 0x0B000000) {
u32 sf=i>>31, op=(i>>30)&1, S=(i>>29)&1, shift=(i>>22)&3, rm=(i>>16)&31, imm6=(i>>10)&0x3F, rn=(i>>5)&31, rd=i&31;
std::string rmv = Xz(rm);
if (imm6) { const char* o=shift==0?"<<":">>"; char sb[96]; snprintf(sb,sizeof sb,"(%s %s %u)",rmv.c_str(),o,imm6); rmv=sb; }
std::string a = Xz(rn);
snprintf(buf,sizeof buf,"{ uint64_t _a=%s,_b=%s,_r=%s; ", a.c_str(), rmv.c_str(), op?"_a-_b":"_a+_b");
std::string s=buf; if(!sf) s+="_r&=0xFFFFFFFFULL; ";
if (rd!=31) s+="c->x["+std::to_string(rd)+"]=_r; ";
if (S) s+="recomp_set_flags(c,"+std::string(op?"1":"0")+",_a,_b,_r,"+(sf?"1":"0")+"); ";
s+="}"; emit(s); return true;
}
// ADRP / ADR
if ((i & 0x1F000000) == 0x10000000) {
u32 op=i>>31, rd=i&31; s64 immhi=(s32)(((i>>5)&0x7FFFF)<<13)>>13; u32 immlo=(i>>29)&3;
if (rd!=31) {
if (op) { u64 base=(pc & ~0xFFFULL); s64 imm=((immhi<<2)|immlo)<<12; snprintf(buf,sizeof buf,"c->x[%u]=0x%llxULL + (int64_t)%lld;",rd,(unsigned long long)base,(long long)imm); }
else { s64 imm=(immhi<<2)|immlo; snprintf(buf,sizeof buf,"c->x[%u]=0x%llxULL + (int64_t)%lld;",rd,(unsigned long long)pc,(long long)imm); }
emit(buf);
}
return true;
}
// LDR/STR (immediate, unsigned offset) 32/64; LDRB/STRB
if ((i & 0x3B000000) == 0x39000000) {
u32 size=(i>>30)&3, opc=(i>>22)&3, imm12=(i>>10)&0xFFF, rn=(i>>5)&31, rt=i&31;
u64 off=(u64)imm12 << size;
std::string addr = "c->x[" + std::to_string(rn) + "] + " + std::to_string(off);
bool load = (opc & 1);
const char* ty = size==0?"8":size==1?"16":size==2?"32":"64";
if (load) {
if (rt!=31){ snprintf(buf,sizeof buf,"c->x[%u]=recomp_load%s(c,%s);",rt,ty,addr.c_str()); emit(buf);}
} else {
snprintf(buf,sizeof buf,"recomp_store%s(c,%s,%s);",ty,addr.c_str(), Xz(rt).c_str()); emit(buf);
}
return true;
}
// ---- terminators ----
u64 t=0;
if (DirectBranchTarget(i,pc,t)) {
if ((i & 0xFC000000) == 0x94000000) { snprintf(buf,sizeof buf,"c->x[30]=0x%llxULL;",(unsigned long long)next); emit(buf);} // BL sets LR
snprintf(buf,sizeof buf,"c->pc=0x%llxULL; return;",(unsigned long long)t); emit(buf); return false;
}
if ((i & 0xFFFFFC1F) == 0xD65F0000) { emit("c->pc=c->x[30]; return; /* RET */"); return false; }
if ((i & 0xFFFFFC1F) == 0xD61F0000) { u32 rn=(i>>5)&31; snprintf(buf,sizeof buf,"c->pc=c->x[%u]; return; /* BR */",rn); emit(buf); return false; }
if ((i & 0xFFFFFC1F) == 0xD63F0000) { u32 rn=(i>>5)&31; snprintf(buf,sizeof buf,"c->x[30]=0x%llxULL; c->pc=c->x[%u]; return; /* BLR */",(unsigned long long)next,rn); emit(buf); return false; }
if ((i & 0xFF000010) == 0x54000000) { // B.cond
s64 off=((s32)((i>>5)<<13)>>13); u64 tt=pc+off*4; u32 cond=i&15;
snprintf(buf,sizeof buf,"if (recomp_cond(c,%u)) { c->pc=0x%llxULL; } else { c->pc=0x%llxULL; } return;",cond,(unsigned long long)tt,(unsigned long long)next); emit(buf); return false;
}
if ((i & 0x7E000000) == 0x34000000) { // CBZ/CBNZ
u32 sf=i>>31; bool nz=(i>>24)&1; u32 rt=i&31; s64 off=((s32)(((i>>5)&0x7FFFF)<<13)>>13); u64 tt=pc+off*4;
std::string v= sf?Xz(rt):Wz(rt);
snprintf(buf,sizeof buf,"if ((%s)%s0) { c->pc=0x%llxULL; } else { c->pc=0x%llxULL; } return;",v.c_str(), nz?"!=":"==",(unsigned long long)tt,(unsigned long long)next); emit(buf); return false;
}
if ((i & 0x7E000000) == 0x36000000) { // TBZ/TBNZ
bool nz=(i>>24)&1; u32 b=((i>>31)<<5)|((i>>19)&31); u32 rt=i&31; s64 off=((s32)(((i>>5)&0x3FFF)<<18)>>18); u64 tt=pc+off*4;
snprintf(buf,sizeof buf,"if (((c->x[%u]>>%u)&1)%s0) { c->pc=0x%llxULL; } else { c->pc=0x%llxULL; } return;",rt,b, nz?"!=":"==",(unsigned long long)tt,(unsigned long long)next); emit(buf); return false;
}
if ((i & 0xFFE0001F) == 0xD4000001) { // SVC
u32 imm=(i>>5)&0xFFFF; snprintf(buf,sizeof buf,"c->pc=0x%llxULL; recomp_svc(c,%u); return;",(unsigned long long)next,imm); emit(buf); return false;
}
// fallback
snprintf(buf,sizeof buf,"recomp_unhandled(c,0x%08xU,0x%llxULL); c->pc=0x%llxULL; return;",i,(unsigned long long)pc,(unsigned long long)next);
emit(buf); return false;
}
std::string FuncName(u64 v){ char b[32]; snprintf(b,sizeof b,"blk_%016llx",(unsigned long long)v); return b; }
} // namespace
// runtime templates ----------------------------------------------------------
static const char* RUNTIME_H = R"RT(
#ifndef SUYU_RECOMP_RUNTIME_H
#define SUYU_RECOMP_RUNTIME_H
#include <stdint.h>
typedef struct GuestContext {
uint64_t x[32]; /* x[31] = SP */
uint64_t pc;
uint8_t n,z,c,v; /* NZCV */
uint8_t* mem; /* flat guest memory base */
uint64_t mem_size;
uint64_t mem_base_vaddr;
int halted;
} GuestContext;
typedef void (*BlockFn)(GuestContext*);
/* generated dispatch */
BlockFn recomp_lookup(uint64_t pc);
void recomp_run(GuestContext* c);
/* helpers used by generated code */
void recomp_set_flags(GuestContext* c, int is_sub, uint64_t a, uint64_t b, uint64_t r, int is64);
void recomp_set_logic_flags(GuestContext* c, uint64_t r, int is64);
int recomp_cond(GuestContext* c, unsigned cond);
uint64_t recomp_load8(GuestContext*,uint64_t); uint64_t recomp_load16(GuestContext*,uint64_t);
uint64_t recomp_load32(GuestContext*,uint64_t); uint64_t recomp_load64(GuestContext*,uint64_t);
void recomp_store8(GuestContext*,uint64_t,uint64_t); void recomp_store16(GuestContext*,uint64_t,uint64_t);
void recomp_store32(GuestContext*,uint64_t,uint64_t); void recomp_store64(GuestContext*,uint64_t,uint64_t);
void recomp_svc(GuestContext* c, unsigned imm);
void recomp_unhandled(GuestContext* c, uint32_t insn, uint64_t pc);
#endif
)RT";
static const char* RUNTIME_C = R"RT(
#include "recomp_runtime.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* HLE hook point: a "modified suyu runtime" would route SVCs to suyu's kernel HLE here.
Standalone, we print and halt so recompiled native code is observable. */
static uint8_t* memptr(GuestContext* c, uint64_t va, uint64_t sz){
uint64_t off = va - c->mem_base_vaddr;
if (off + sz > c->mem_size) return 0;
return c->mem + off;
}
uint64_t recomp_load8 (GuestContext* c,uint64_t a){uint8_t* p=memptr(c,a,1); return p?*p:0;}
uint64_t recomp_load16(GuestContext* c,uint64_t a){uint8_t* p=memptr(c,a,2); uint16_t v=0; if(p)memcpy(&v,p,2); return v;}
uint64_t recomp_load32(GuestContext* c,uint64_t a){uint8_t* p=memptr(c,a,4); uint32_t v=0; if(p)memcpy(&v,p,4); return v;}
uint64_t recomp_load64(GuestContext* c,uint64_t a){uint8_t* p=memptr(c,a,8); uint64_t v=0; if(p)memcpy(&v,p,8); return v;}
void recomp_store8 (GuestContext* c,uint64_t a,uint64_t v){uint8_t* p=memptr(c,a,1); if(p)*p=(uint8_t)v;}
void recomp_store16(GuestContext* c,uint64_t a,uint64_t v){uint8_t* p=memptr(c,a,2); uint16_t t=(uint16_t)v; if(p)memcpy(p,&t,2);}
void recomp_store32(GuestContext* c,uint64_t a,uint64_t v){uint8_t* p=memptr(c,a,4); uint32_t t=(uint32_t)v; if(p)memcpy(p,&t,4);}
void recomp_store64(GuestContext* c,uint64_t a,uint64_t v){uint8_t* p=memptr(c,a,8); if(p)memcpy(p,&v,8);}
void recomp_set_flags(GuestContext* c,int is_sub,uint64_t a,uint64_t b,uint64_t r,int is64){
uint64_t mask = is64?~0ULL:0xFFFFFFFFULL; r&=mask; a&=mask; b&=mask;
uint64_t sign = is64?0x8000000000000000ULL:0x80000000ULL;
c->z = (r==0); c->n = (r&sign)?1:0;
if(is_sub){ c->c = (a>=b); c->v = (((a^b)&(a^r))&sign)?1:0; }
else { c->c = (r<a); c->v = ((~(a^b)&(a^r))&sign)?1:0; }
}
void recomp_set_logic_flags(GuestContext* c,uint64_t r,int is64){ uint64_t m=is64?~0ULL:0xFFFFFFFFULL; r&=m; uint64_t s=is64?0x8000000000000000ULL:0x80000000ULL; c->z=(r==0); c->n=(r&s)?1:0; c->c=0; c->v=0; }
int recomp_cond(GuestContext* c,unsigned cond){
int n=c->n,z=c->z,cc=c->c,v=c->v,res;
switch(cond>>1){case 0:res=z;break;case 1:res=cc;break;case 2:res=n;break;case 3:res=v;break;
case 4:res=cc&&!z;break;case 5:res=(n==v);break;case 6:res=(n==v)&&!z;break;default:res=1;}
return (cond&1)&&cond!=15? !res : res;
}
void recomp_svc(GuestContext* c, unsigned imm){
/* In an integrated build this dispatches to suyu's HLE SVC handler.
Standalone demo: svc #0 prints x0..x3 and halts. */
printf("[recomp] SVC #%u x0=%llu x1=%llu x2=%llu x3=%llu\n", imm,
(unsigned long long)c->x[0],(unsigned long long)c->x[1],
(unsigned long long)c->x[2],(unsigned long long)c->x[3]);
c->halted = 1;
}
void recomp_unhandled(GuestContext* c, uint32_t insn, uint64_t pc){
fprintf(stderr,"[recomp] unhandled insn 0x%08x at 0x%llx -> halting (needs full suyu HLE/JIT)\n",
insn,(unsigned long long)pc);
c->halted = 1;
}
void recomp_run(GuestContext* c){
int guard=0;
while(!c->halted){
BlockFn f = recomp_lookup(c->pc);
if(!f){ fprintf(stderr,"[recomp] no block at 0x%llx\n",(unsigned long long)c->pc); break; }
f(c);
if(++guard > 100000000){ fprintf(stderr,"[recomp] watchdog\n"); break; }
}
}
)RT";
int main(int argc, char** argv) {
if (argc < 4) {
fprintf(stderr,"usage: %s <input.bin> <base_hex> <out_dir> [--source-only]\n", argv[0]);
fprintf(stderr," input.bin = raw AArch64 .text bytes; base_hex = load vaddr (e.g. 0x1000)\n");
return 2;
}
const std::string in = argv[1];
const u64 base = strtoull(argv[2], nullptr, 0);
const std::string out = argv[3];
const bool source_only = argc > 4 && std::string(argv[4]) == "--source-only";
std::ifstream f(in, std::ios::binary);
if (!f) { fprintf(stderr,"cannot open %s\n", in.c_str()); return 1; }
std::vector<u8> text((std::istreambuf_iterator<char>(f)), {});
if (text.size() < 4) { fprintf(stderr,"input too small\n"); return 1; }
text.resize(text.size() & ~size_t(3));
auto blocks = DiscoverBlocks(text.data(), text.size(), base);
const u32* p = reinterpret_cast<const u32*>(text.data());
// emit recompiled.c
std::ostringstream rc;
rc << "/* auto-generated by suyu_recomp - DO NOT EDIT */\n#include \"recomp_runtime.h\"\n\n";
for (const auto& b : blocks) {
rc << "void " << FuncName(b.vaddr) << "(GuestContext* c){\n";
const u32 first = (u32)((b.vaddr - base) / 4);
bool open = true;
for (u32 k = 0; k < b.count; ++k) {
const u64 pc = b.vaddr + (u64)k * 4;
std::string body;
open = Translate(p[first + k], pc, body);
rc << body;
if (!open) break;
}
if (open) { rc << " c->pc=0x" << std::hex << (b.vaddr + b.size) << std::dec << "ULL; return;\n"; }
rc << "}\n\n";
}
// dispatch table
rc << "#include <stdint.h>\nstruct _ent{uint64_t va; BlockFn fn;};\n";
rc << "static const struct _ent _tbl[] = {\n";
for (const auto& b : blocks)
rc << " {0x" << std::hex << b.vaddr << std::dec << "ULL, " << FuncName(b.vaddr) << "},\n";
rc << "};\nBlockFn recomp_lookup(uint64_t pc){ for(unsigned i=0;i<sizeof(_tbl)/sizeof(_tbl[0]);++i) if(_tbl[i].va==pc) return _tbl[i].fn; return 0; }\n";
// emit main.c (loads the same .text as guest memory so PC-relative loads work)
std::ostringstream mc;
mc << "#include \"recomp_runtime.h\"\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n";
mc << "int main(int argc,char**argv){\n static uint8_t mem[1<<20];\n GuestContext c; memset(&c,0,sizeof c);\n";
mc << " c.mem=mem; c.mem_size=sizeof mem; c.mem_base_vaddr=0x" << std::hex << base << std::dec << "ULL;\n";
mc << " c.x[31]=c.mem_base_vaddr + c.mem_size - 16; /* SP */\n";
mc << " c.pc=0x" << std::hex << base << std::dec << "ULL;\n";
mc << " recomp_run(&c);\n printf(\"[recomp] halted at pc=0x%llx\\n\",(unsigned long long)c.pc);\n return 0;\n}\n";
// emit CMakeLists (cross-platform: Windows exe / Linux+BSD ELF / macOS Mach-O)
std::ostringstream cm;
cm << "cmake_minimum_required(VERSION 3.13)\nproject(suyu_recompiled C)\n"
<< "set(CMAKE_C_STANDARD 11)\nadd_executable(recompiled main.c recompiled.c recomp_runtime.c)\n"
<< "if(WIN32)\n set_target_properties(recompiled PROPERTIES OUTPUT_NAME recompiled SUFFIX \".exe\")\n"
<< "elseif(APPLE)\n # produces a Mach-O native binary\nelse()\n # Linux / FreeBSD / OpenBSD: ELF\nendif()\n";
auto write = [&](const std::string& name, const std::string& data){
std::ofstream o(out + "/" + name, std::ios::binary);
o.write(data.data(), (std::streamsize)data.size());
};
// create out dir (portable best-effort)
{ std::string mk =
#ifdef _WIN32
"cmd /c if not exist \"" + out + "\" mkdir \"" + out + "\"";
#else
"mkdir -p '" + out + "'";
#endif
system(mk.c_str()); }
write("recomp_runtime.h", RUNTIME_H);
write("recomp_runtime.c", RUNTIME_C);
write("recompiled.c", rc.str());
write("main.c", mc.str());
write("CMakeLists.txt", cm.str());
fprintf(stderr,"suyu_recomp: %zu blocks, %zu instructions -> %s (%s)\n",
blocks.size(), text.size()/4, out.c_str(), source_only?"source only":"buildable project");
return 0;
}
Reference in new issue View Git Blame Copy Permalink