Hojun-Cho
2c33228b7e
Plan 9-style w-prefix on the per-arch tools, disambiguating from the
real Plan 9 6c/6a/6l in ref/plan9front/:
cmd/wwc/ → cmd/wcc/ libwwc.a → libwcc.a
cmd/6{c,a,l} → cmd/w6{c,a,l} binary names too
test/wwc/ → test/wcc/ 6 test files w/ w6 prefix
selfhost/cmd mirror in lockstep
bootstrap/amd64/{w6c,w6a,w6l} snapshot binaries (gitignored)
WW_6{C,A,L} → WW_W6{C,A,L} env-var overrides
Plan 9 source-tree refs ("Plan 9 6c shape", ref/plan9front/, etc.)
preserved. Hare-style driver, both C and ww sides:
ww test [path] discover *_test.ww in a directory module, run
each; single-file mode for `ww test foo.ww`
Module-by-name `ww build foo` resolves to foo.ww or foo/foo.ww
via search path (cwd : -I dirs : $WW_LIB)
Default-to-cwd `ww build` / `ww test` build the cwd module
Run pass-through `ww run path arg1 arg2` reaches the program
lib/os: getcwd (79) and getdents64 (217) syscalls power `.` resolution
and directory enumeration on the ww side.
Makefile: wwstage tool deps now include lib/os/os.ww (+ lib/strconv
for wwdump_ww) so lib/* edits force their rebuild instead of leaving
stale binaries — surfaced when test 995 first failed against a stale
w6c_ww built before the lib/os additions.
Test 993 byte-identical parity gate (C-side ww vs ww-side ww_ww on a
build corpus) stays green; all 19 tests pass.
682 lines
22 KiB
Plaintext
682 lines
22 KiB
Plaintext
// selfhost/cmd/w6a/asm.ww — port of cmd/w6a/asm.c.
|
|
//
|
|
// Encode the parsed aprog list into amd64 machine bytes, appending to
|
|
// asm_.text. Relocations for CALL/branch targets that resolve to
|
|
// externals are queued in asm_.relocs.
|
|
//
|
|
// Encoding subset matches what w6c emits — see cmd/w6a/asm.c for the
|
|
// authoritative list. Helpers (rcode/rhi/modrm/emit_rex etc.) are
|
|
// fully ported; a_encode itself is still a stub pending the full
|
|
// switch over A_*.
|
|
|
|
use os;
|
|
use mem;
|
|
use types;
|
|
|
|
// ---- text buffer growth ------------------------------------------------
|
|
|
|
export fn a_emit_byte(a: *asm_, b: u8) void = {
|
|
if (a.textlen + 1u64 > a.textcap) {
|
|
let nc: u64 = a.textcap;
|
|
if (nc == 0u64) { nc = 4096u64; };
|
|
nc = nc * 2u64;
|
|
let nb: *u8 = os.alloc(nc): *u8;
|
|
let i: u64 = 0u64;
|
|
for (i < a.textlen) { nb[i] = a.text[i]; i += 1u64; };
|
|
a.text = nb;
|
|
a.textcap = nc;
|
|
};
|
|
a.text[a.textlen] = b;
|
|
a.textlen += 1u64;
|
|
};
|
|
|
|
export fn a_emit_u32(a: *asm_, v: u32) void = {
|
|
a_emit_byte(a, (v & 255u32): u8);
|
|
a_emit_byte(a, ((v >> 8u32) & 255u32): u8);
|
|
a_emit_byte(a, ((v >> 16u32) & 255u32): u8);
|
|
a_emit_byte(a, ((v >> 24u32) & 255u32): u8);
|
|
};
|
|
|
|
export fn a_addreloc(a: *asm_, off: u64, kind: i32, s: *asym, add: i64) void = {
|
|
let r: *areloc = amalloc(a.a, 48u64): *areloc;
|
|
r.off = off;
|
|
r.kind = kind;
|
|
r.asy = s;
|
|
r.addend = add;
|
|
r.rnext = a.relocs;
|
|
a.relocs = r;
|
|
};
|
|
|
|
// ---- register codes ----------------------------------------------------
|
|
|
|
// Low 3 bits of register encoding.
|
|
fn rcode(r: i32) i32 = {
|
|
if (r == D_AX) { return 0; }; if (r == D_CX) { return 1; };
|
|
if (r == D_DX) { return 2; }; if (r == D_BX) { return 3; };
|
|
if (r == D_SP) { return 4; }; if (r == D_BP) { return 5; };
|
|
if (r == D_SI) { return 6; }; if (r == D_DI) { return 7; };
|
|
if (r == D_R8) { return 0; }; if (r == D_R9) { return 1; };
|
|
if (r == D_R10) { return 2; }; if (r == D_R11) { return 3; };
|
|
if (r == D_R12) { return 4; }; if (r == D_R13) { return 5; };
|
|
if (r == D_R14) { return 6; }; if (r == D_R15) { return 7; };
|
|
if (r == D_X0) { return 0; }; if (r == D_X1) { return 1; };
|
|
if (r == D_X2) { return 2; }; if (r == D_X3) { return 3; };
|
|
if (r == D_X4) { return 4; }; if (r == D_X5) { return 5; };
|
|
if (r == D_X6) { return 6; }; if (r == D_X7) { return 7; };
|
|
if (r == D_X8) { return 0; }; if (r == D_X9) { return 1; };
|
|
if (r == D_X10) { return 2; }; if (r == D_X11) { return 3; };
|
|
if (r == D_X12) { return 4; }; if (r == D_X13) { return 5; };
|
|
if (r == D_X14) { return 6; }; if (r == D_X15) { return 7; };
|
|
return 0;
|
|
};
|
|
|
|
// 1 if r needs the REX high bit (R8..R15 or X8..X15).
|
|
fn rhi(r: i32) i32 = {
|
|
if (r >= D_R8) { if (r <= D_R15) { return 1; }; };
|
|
if (r >= D_X8) { if (r <= D_X15) { return 1; }; };
|
|
return 0;
|
|
};
|
|
|
|
fn is_xmm(r: i32) bool = {
|
|
if (r >= D_X0) { if (r <= D_X15) { return true; }; };
|
|
return false;
|
|
};
|
|
|
|
// ModR/M byte builder.
|
|
fn modrm_byte(mod: i32, reg: i32, rm: i32) u8 = {
|
|
return (((mod & 3) << 6) | ((reg & 7) << 3) | (rm & 7)): u8;
|
|
};
|
|
|
|
// REX prefix; W=1 for 64-bit operand size.
|
|
fn emit_rex(a: *asm_, regbit: i32, rmbit: i32, w: i32) void = {
|
|
let b: u8 = 64u8; // 0x40
|
|
if (w != 0) { b = b | 8u8; };
|
|
if (regbit != 0) { b = b | 4u8; };
|
|
if (rmbit != 0) { b = b | 1u8; };
|
|
if (b != 64u8) { a_emit_byte(a, b); }
|
|
else { if (w != 0) { a_emit_byte(a, b); }; };
|
|
};
|
|
|
|
// ModR/M + (optional) SIB + displacement for [base+disp].
|
|
// Special-cases SP (needs SIB) and BP (forces explicit disp).
|
|
fn emit_modrm_mem(a: *asm_, reg_field: i32, base: i32, disp: i64) void = {
|
|
let rm: i32 = rcode(base);
|
|
let needsib: bool = (rm == 4);
|
|
let forced_disp: bool = false;
|
|
if (rm == 5) { if (disp == 0i64) { forced_disp = true; }; };
|
|
|
|
let mod: i32 = 2;
|
|
if (disp == 0i64) {
|
|
if (!forced_disp) { mod = 0; }
|
|
else { mod = 1; };
|
|
} else {
|
|
if (disp >= -128i64) { if (disp <= 127i64) { mod = 1; }; };
|
|
};
|
|
|
|
a_emit_byte(a, modrm_byte(mod, reg_field, rm));
|
|
if (needsib) {
|
|
a_emit_byte(a, 36u8); // 0x24: scale=0 idx=4(none) base=4
|
|
};
|
|
if (mod == 1) {
|
|
a_emit_byte(a, (disp: u64 & 255u64): u8);
|
|
} else { if (mod == 2) {
|
|
a_emit_u32(a, disp: u32);
|
|
};};
|
|
};
|
|
|
|
// reg→reg "src, dst" generic encoding (89 /r, 01 /r, etc.).
|
|
fn encode_rr(a: *asm_, opcode: u8, src: i32, dst: i32) void = {
|
|
emit_rex(a, rhi(src), rhi(dst), 1);
|
|
a_emit_byte(a, opcode);
|
|
a_emit_byte(a, modrm_byte(3, rcode(src), rcode(dst)));
|
|
};
|
|
|
|
// reg→mem(base, disp) (e.g. MOVQ src reg into mem; opcode = 0x89).
|
|
fn encode_rm(a: *asm_, opcode: u8, src_reg: i32, base: i32, disp: i64) void = {
|
|
emit_rex(a, rhi(src_reg), rhi(base), 1);
|
|
a_emit_byte(a, opcode);
|
|
emit_modrm_mem(a, rcode(src_reg), base, disp);
|
|
};
|
|
|
|
// mem(base, disp) → reg (e.g. MOVQ mem into reg; opcode = 0x8B).
|
|
fn encode_mr(a: *asm_, opcode: u8, dst_reg: i32, base: i32, disp: i64) void = {
|
|
emit_rex(a, rhi(dst_reg), rhi(base), 1);
|
|
a_emit_byte(a, opcode);
|
|
emit_modrm_mem(a, rcode(dst_reg), base, disp);
|
|
};
|
|
|
|
// OPCODE /n imm32 reg form (e.g. ADDQ $imm, reg).
|
|
fn encode_ri_imm32(a: *asm_, opcode: u8, subop: i32, dst: i32, imm: i32) void = {
|
|
emit_rex(a, 0, rhi(dst), 1);
|
|
a_emit_byte(a, opcode);
|
|
a_emit_byte(a, modrm_byte(3, subop, rcode(dst)));
|
|
a_emit_u32(a, imm: u32);
|
|
};
|
|
|
|
// Unary on reg: F7 /n reg, etc.
|
|
fn encode_unary(a: *asm_, opcode: u8, subop: i32, dst: i32) void = {
|
|
emit_rex(a, 0, rhi(dst), 1);
|
|
a_emit_byte(a, opcode);
|
|
a_emit_byte(a, modrm_byte(3, subop, rcode(dst)));
|
|
};
|
|
|
|
// SSE2 helpers. Plan 9 syntax: source first, destination second.
|
|
// For ADDSD-style ops we put dst in the reg field, src in r/m.
|
|
fn sse_rr(a: *asm_, prefix: u8, op2: u8, reg_op: i32, rm_op: i32) void = {
|
|
if (prefix != 0u8) { a_emit_byte(a, prefix); };
|
|
emit_rex(a, rhi(reg_op), rhi(rm_op), 0);
|
|
a_emit_byte(a, 15u8); // 0x0F
|
|
a_emit_byte(a, op2);
|
|
a_emit_byte(a, modrm_byte(3, rcode(reg_op), rcode(rm_op)));
|
|
};
|
|
|
|
fn sse_mr_load(a: *asm_, prefix: u8, op2: u8, reg_op: i32, base: i32, disp: i64) void = {
|
|
if (prefix != 0u8) { a_emit_byte(a, prefix); };
|
|
emit_rex(a, rhi(reg_op), rhi(base), 0);
|
|
a_emit_byte(a, 15u8);
|
|
a_emit_byte(a, op2);
|
|
emit_modrm_mem(a, rcode(reg_op), base, disp);
|
|
};
|
|
|
|
// REX.W variant of sse_rr (CVTTSD2SI / CVTSI2SD).
|
|
fn sse_rr_w(a: *asm_, prefix: u8, op2: u8, reg_op: i32, rm_op: i32) void = {
|
|
if (prefix != 0u8) { a_emit_byte(a, prefix); };
|
|
emit_rex(a, rhi(reg_op), rhi(rm_op), 1);
|
|
a_emit_byte(a, 15u8);
|
|
a_emit_byte(a, op2);
|
|
a_emit_byte(a, modrm_byte(3, rcode(reg_op), rcode(rm_op)));
|
|
};
|
|
|
|
// ---- label resolution / fixups ----------------------------------------
|
|
|
|
fn streq(a: str, b: str) bool = {
|
|
if (a.len != b.len) { return false; };
|
|
let i: i32 = 0;
|
|
for (i < a.len) {
|
|
if (a[i] != b[i]) { return false; };
|
|
i += 1;
|
|
};
|
|
return true;
|
|
};
|
|
|
|
fn resolve_label(a: *asm_, name: str) u64 = {
|
|
let s: *asym = a.syms;
|
|
for (s != nil) {
|
|
if (s.defined != 0) { if (streq(s.name, name)) { return s.addr; }; };
|
|
s = s.snext;
|
|
};
|
|
return 0u64;
|
|
};
|
|
|
|
fn label_defined(a: *asm_, name: str) bool = {
|
|
let s: *asym = a.syms;
|
|
for (s != nil) {
|
|
if (s.defined != 0) { if (streq(s.name, name)) { return true; }; };
|
|
s = s.snext;
|
|
};
|
|
return false;
|
|
};
|
|
|
|
// ---- fixup helper -----------------------------------------------------
|
|
|
|
fn add_fixup(a: *asm_, off: u64, label: str) void = {
|
|
let f: *afixup = amalloc(a.a, 48u64): *afixup;
|
|
f.off = off;
|
|
f.label = label;
|
|
f.fnext = a.fixups;
|
|
a.fixups = f;
|
|
};
|
|
|
|
fn is_gpr(t: i32) bool = {
|
|
if (t >= D_AX) { if (t <= D_R15) { return true; }; };
|
|
return false;
|
|
};
|
|
|
|
// `a_intern` lives in parse.ww — flat-scope concat lets us call it
|
|
// directly without an @symbol declaration here.
|
|
|
|
// ---- a_encode ---------------------------------------------------------
|
|
|
|
export fn a_encode(a: *asm_) i32 = {
|
|
let p: *aprog = a.head;
|
|
for (p != nil) {
|
|
// Define any pending label at the current PC.
|
|
if (p.label.len > 0) {
|
|
let s: *asym = a_intern(a, p.label);
|
|
s.defined = 1;
|
|
s.is_text = 1;
|
|
s.addr = a.textlen;
|
|
};
|
|
let op: i32 = p.as_;
|
|
|
|
if (op == A_NOP) {
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_TEXT) {
|
|
let s: *asym = a_intern(a, p.to.asym);
|
|
s.defined = 1;
|
|
s.is_text = 1;
|
|
s.is_global = 1;
|
|
s.addr = a.textlen;
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_DATA) {
|
|
let s: *asym = a_intern(a, p.to.asym);
|
|
s.defined = 1;
|
|
s.is_text = 1;
|
|
s.is_global = 1;
|
|
s.addr = a.textlen;
|
|
let i: u64 = 0u64;
|
|
for (i < p.nbytes) { a_emit_byte(a, p.bytes[i]); i += 1u64; };
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_RET) {
|
|
a_emit_byte(a, 195u8); // 0xC3
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_SYSCALL) {
|
|
a_emit_byte(a, 15u8);
|
|
a_emit_byte(a, 5u8);
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_PUSHQ) {
|
|
if (rhi(p.to.atype) != 0) { a_emit_byte(a, 65u8); }; // 0x41
|
|
a_emit_byte(a, (80 + rcode(p.to.atype)): u8); // 0x50
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_POPQ) {
|
|
if (rhi(p.to.atype) != 0) { a_emit_byte(a, 65u8); };
|
|
a_emit_byte(a, (88 + rcode(p.to.atype)): u8); // 0x58
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_NEGQ) { encode_unary(a, 247u8, 3, p.to.atype); p = p.link; continue; };
|
|
if (op == A_NOTQ) { encode_unary(a, 247u8, 2, p.to.atype); p = p.link; continue; };
|
|
if (op == A_IDIVQ) { encode_unary(a, 247u8, 7, p.to.atype); p = p.link; continue; };
|
|
if (op == A_DIVQ) { encode_unary(a, 247u8, 6, p.to.atype); p = p.link; continue; };
|
|
|
|
if (op == A_MOVQ) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_CONST) { if (is_gpr(tt)) {
|
|
let v: i64 = p.from.offset;
|
|
if (v >= -2147483648i64) { if (v <= 2147483647i64) {
|
|
encode_ri_imm32(a, 199u8, 0, tt, v: i32);
|
|
p = p.link; continue;
|
|
};};
|
|
// movabs r64, imm64: REX.W B8+rd imm64
|
|
emit_rex(a, 0, rhi(tt), 1);
|
|
a_emit_byte(a, (184 + rcode(tt)): u8);
|
|
let k: i32 = 0;
|
|
for (k < 8) {
|
|
a_emit_byte(a, ((v: u64 >> (k: u64 * 8u64)) & 255u64): u8);
|
|
k += 1;
|
|
};
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_gpr(ft)) { if (is_gpr(tt)) {
|
|
encode_rr(a, 137u8, ft, tt); // 0x89
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
encode_mr(a, 139u8, tt, p.from.reg, p.from.offset); // 0x8B
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_gpr(ft)) { if (tt == D_INDIR) {
|
|
encode_rm(a, 137u8, ft, p.to.reg, p.to.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_CONST) { if (tt == D_INDIR) {
|
|
emit_rex(a, 0, rhi(p.to.reg), 1);
|
|
a_emit_byte(a, 199u8);
|
|
emit_modrm_mem(a, 0, p.to.reg, p.to.offset);
|
|
a_emit_u32(a, p.from.offset: u32);
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_EXTERN) { if (is_gpr(tt)) {
|
|
// RIP-relative load: 48 8B /r mod=00 rm=5 disp32
|
|
emit_rex(a, rhi(tt), 0, 1);
|
|
a_emit_byte(a, 139u8);
|
|
a_emit_byte(a, modrm_byte(0, rcode(tt), 5));
|
|
let reloff: u64 = a.textlen;
|
|
a_emit_u32(a, 0u32);
|
|
let s: *asym = a_intern(a, p.from.asym);
|
|
a_addreloc(a, reloff, 2, s, -4i64);
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_gpr(ft)) { if (tt == D_EXTERN) {
|
|
// RIP-relative store: 48 89 /r mod=00 rm=5 disp32
|
|
emit_rex(a, rhi(ft), 0, 1);
|
|
a_emit_byte(a, 137u8);
|
|
a_emit_byte(a, modrm_byte(0, rcode(ft), 5));
|
|
let reloff: u64 = a.textlen;
|
|
a_emit_u32(a, 0u32);
|
|
let s: *asym = a_intern(a, p.to.asym);
|
|
a_addreloc(a, reloff, 2, s, -4i64);
|
|
p = p.link; continue;
|
|
};};
|
|
os.write(2, "w6a: unsupported MOVQ shape\n".ptr, 27u64);
|
|
a.errs += 1;
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_MOVB) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (is_gpr(ft)) { if (tt == D_INDIR) {
|
|
emit_rex(a, rhi(ft), rhi(p.to.reg), 0);
|
|
a_emit_byte(a, 136u8); // 0x88
|
|
emit_modrm_mem(a, rcode(ft), p.to.reg, p.to.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
emit_rex(a, rhi(tt), rhi(p.from.reg), 0);
|
|
a_emit_byte(a, 138u8); // 0x8A
|
|
emit_modrm_mem(a, rcode(tt), p.from.reg, p.from.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
os.write(2, "w6a: unsupported MOVB shape\n".ptr, 27u64);
|
|
a.errs += 1;
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_MOVZBQ) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
emit_rex(a, rhi(tt), rhi(p.from.reg), 1);
|
|
a_emit_byte(a, 15u8);
|
|
a_emit_byte(a, 182u8); // 0xB6
|
|
emit_modrm_mem(a, rcode(tt), p.from.reg, p.from.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
os.write(2, "w6a: unsupported MOVZBQ shape\n".ptr, 29u64);
|
|
a.errs += 1;
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_MOVL) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (is_gpr(ft)) { if (tt == D_INDIR) {
|
|
emit_rex(a, rhi(ft), rhi(p.to.reg), 0);
|
|
a_emit_byte(a, 137u8);
|
|
emit_modrm_mem(a, rcode(ft), p.to.reg, p.to.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
emit_rex(a, rhi(tt), rhi(p.from.reg), 0);
|
|
a_emit_byte(a, 139u8);
|
|
emit_modrm_mem(a, rcode(tt), p.from.reg, p.from.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_gpr(ft)) { if (is_gpr(tt)) {
|
|
emit_rex(a, rhi(ft), rhi(tt), 0);
|
|
a_emit_byte(a, 137u8);
|
|
a_emit_byte(a, modrm_byte(3, rcode(ft), rcode(tt)));
|
|
p = p.link; continue;
|
|
};};
|
|
os.write(2, "w6a: unsupported MOVL shape\n".ptr, 27u64);
|
|
a.errs += 1;
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_MOVSXD) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
emit_rex(a, rhi(tt), rhi(p.from.reg), 1);
|
|
a_emit_byte(a, 99u8); // 0x63
|
|
emit_modrm_mem(a, rcode(tt), p.from.reg, p.from.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
os.write(2, "w6a: unsupported MOVSXD shape\n".ptr, 29u64);
|
|
a.errs += 1;
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_MOVSD) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (is_xmm(ft)) { if (is_xmm(tt)) {
|
|
sse_rr(a, 242u8, 16u8, tt, ft);
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_INDIR) { if (is_xmm(tt)) {
|
|
sse_mr_load(a, 242u8, 16u8, tt, p.from.reg, p.from.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_xmm(ft)) { if (tt == D_INDIR) {
|
|
sse_mr_load(a, 242u8, 17u8, ft, p.to.reg, p.to.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
os.write(2, "w6a: unsupported MOVSD shape\n".ptr, 28u64);
|
|
a.errs += 1;
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_ADDSD) { sse_rr(a, 242u8, 88u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_SUBSD) { sse_rr(a, 242u8, 92u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_MULSD) { sse_rr(a, 242u8, 89u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_DIVSD) { sse_rr(a, 242u8, 94u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_UCOMISD) { sse_rr(a, 102u8, 46u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_CVTTSD2SI) { sse_rr_w(a, 242u8, 44u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_CVTSI2SD) { sse_rr_w(a, 242u8, 42u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
|
|
if (op == A_MOVSS) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (is_xmm(ft)) { if (is_xmm(tt)) {
|
|
sse_rr(a, 243u8, 16u8, tt, ft); p = p.link; continue;
|
|
};};
|
|
if (ft == D_INDIR) { if (is_xmm(tt)) {
|
|
sse_mr_load(a, 243u8, 16u8, tt, p.from.reg, p.from.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_xmm(ft)) { if (tt == D_INDIR) {
|
|
sse_mr_load(a, 243u8, 17u8, ft, p.to.reg, p.to.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
os.write(2, "w6a: unsupported MOVSS shape\n".ptr, 28u64);
|
|
a.errs += 1;
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_ADDSS) { sse_rr(a, 243u8, 88u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_SUBSS) { sse_rr(a, 243u8, 92u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_MULSS) { sse_rr(a, 243u8, 89u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_DIVSS) { sse_rr(a, 243u8, 94u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_UCOMISS) { sse_rr(a, 0u8, 46u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_CVTTSS2SI) { sse_rr_w(a, 243u8, 44u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_CVTSI2SS) { sse_rr_w(a, 243u8, 42u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_CVTSD2SS) { sse_rr(a, 242u8, 90u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
if (op == A_CVTSS2SD) { sse_rr(a, 243u8, 90u8, p.to.atype, p.from.atype); p = p.link; continue; };
|
|
|
|
if (op == A_ADDQ) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_CONST) { if (is_gpr(tt)) {
|
|
encode_ri_imm32(a, 129u8, 0, tt, p.from.offset: i32); // 0x81
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_CONST) { if (tt == D_INDIR) {
|
|
emit_rex(a, 0, rhi(p.to.reg), 1);
|
|
a_emit_byte(a, 129u8);
|
|
emit_modrm_mem(a, 0, p.to.reg, p.to.offset);
|
|
a_emit_u32(a, p.from.offset: u32);
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_gpr(ft)) { if (tt == D_INDIR) {
|
|
encode_rm(a, 1u8, ft, p.to.reg, p.to.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
encode_mr(a, 3u8, tt, p.from.reg, p.from.offset);
|
|
p = p.link; continue;
|
|
};};
|
|
encode_rr(a, 1u8, ft, tt);
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_SUBQ) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_CONST) { if (is_gpr(tt)) {
|
|
encode_ri_imm32(a, 129u8, 5, tt, p.from.offset: i32);
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_CONST) { if (tt == D_INDIR) {
|
|
emit_rex(a, 0, rhi(p.to.reg), 1);
|
|
a_emit_byte(a, 129u8);
|
|
emit_modrm_mem(a, 5, p.to.reg, p.to.offset);
|
|
a_emit_u32(a, p.from.offset: u32);
|
|
p = p.link; continue;
|
|
};};
|
|
if (is_gpr(ft)) { if (tt == D_INDIR) {
|
|
encode_rm(a, 41u8, ft, p.to.reg, p.to.offset); // 0x29
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
encode_mr(a, 43u8, tt, p.from.reg, p.from.offset); // 0x2B
|
|
p = p.link; continue;
|
|
};};
|
|
encode_rr(a, 41u8, ft, tt);
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_ANDQ) { encode_rr(a, 33u8, p.from.atype, p.to.atype); p = p.link; continue; }; // 0x21
|
|
if (op == A_ORQ) { encode_rr(a, 9u8, p.from.atype, p.to.atype); p = p.link; continue; }; // 0x09
|
|
if (op == A_XORQ) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_CONST) { if (is_gpr(tt)) {
|
|
encode_ri_imm32(a, 129u8, 6, tt, p.from.offset: i32);
|
|
p = p.link; continue;
|
|
};};
|
|
encode_rr(a, 49u8, ft, tt); // 0x31
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_IMULQ) {
|
|
emit_rex(a, rhi(p.to.atype), rhi(p.from.atype), 1);
|
|
a_emit_byte(a, 15u8);
|
|
a_emit_byte(a, 175u8); // 0xAF
|
|
a_emit_byte(a, modrm_byte(3, rcode(p.to.atype), rcode(p.from.atype)));
|
|
p = p.link; continue;
|
|
};
|
|
if (op == A_SHLQ) { encode_unary(a, 211u8, 4, p.to.atype); p = p.link; continue; }; // 0xD3
|
|
if (op == A_SHRQ) { encode_unary(a, 211u8, 5, p.to.atype); p = p.link; continue; };
|
|
if (op == A_CMPQ) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_CONST) { if (is_gpr(tt)) {
|
|
encode_ri_imm32(a, 129u8, 7, tt, p.from.offset: i32);
|
|
p = p.link; continue;
|
|
};};
|
|
encode_rr(a, 57u8, ft, tt); // 0x39
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_LEAQ) {
|
|
let ft: i32 = p.from.atype;
|
|
let tt: i32 = p.to.atype;
|
|
if (ft == D_INDIR) { if (is_gpr(tt)) {
|
|
encode_mr(a, 141u8, tt, p.from.reg, p.from.offset); // 0x8D
|
|
p = p.link; continue;
|
|
};};
|
|
if (ft == D_EXTERN) { if (is_gpr(tt)) {
|
|
emit_rex(a, rhi(tt), 0, 1);
|
|
a_emit_byte(a, 141u8);
|
|
a_emit_byte(a, modrm_byte(0, rcode(tt), 5));
|
|
let reloff: u64 = a.textlen;
|
|
a_emit_u32(a, 0u32);
|
|
let s: *asym = a_intern(a, p.from.asym);
|
|
a_addreloc(a, reloff, 2, s, -4i64);
|
|
p = p.link; continue;
|
|
};};
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_CALL) {
|
|
let tt: i32 = p.to.atype;
|
|
if (tt == D_EXTERN) {
|
|
a_emit_byte(a, 232u8); // 0xE8
|
|
let reloff: u64 = a.textlen;
|
|
a_emit_u32(a, 0u32);
|
|
let s: *asym = a_intern(a, p.to.asym);
|
|
a_addreloc(a, reloff, 4, s, -4i64);
|
|
p = p.link; continue;
|
|
};
|
|
if (tt == D_BRANCH) {
|
|
a_emit_byte(a, 232u8);
|
|
add_fixup(a, a.textlen, p.to.asym);
|
|
a_emit_u32(a, 0u32);
|
|
p = p.link; continue;
|
|
};
|
|
if (is_gpr(tt)) {
|
|
if (rhi(tt) != 0) { a_emit_byte(a, 65u8); };
|
|
a_emit_byte(a, 255u8); // 0xFF
|
|
a_emit_byte(a, modrm_byte(3, 2, rcode(tt)));
|
|
p = p.link; continue;
|
|
};
|
|
p = p.link; continue;
|
|
};
|
|
|
|
if (op == A_JMP) {
|
|
a_emit_byte(a, 233u8); // 0xE9
|
|
add_fixup(a, a.textlen, p.to.asym);
|
|
a_emit_u32(a, 0u32);
|
|
p = p.link; continue;
|
|
};
|
|
|
|
// Conditional jumps. 0x0F + cc + rel32.
|
|
let cc: u8 = 0u8;
|
|
let is_jcc: bool = true;
|
|
if (op == A_JE) { cc = 132u8; } // 0x84
|
|
else { if (op == A_JZ) { cc = 132u8; }
|
|
else { if (op == A_JNE) { cc = 133u8; }
|
|
else { if (op == A_JNZ) { cc = 133u8; }
|
|
else { if (op == A_JL) { cc = 140u8; }
|
|
else { if (op == A_JLE) { cc = 142u8; }
|
|
else { if (op == A_JG) { cc = 143u8; }
|
|
else { if (op == A_JGE) { cc = 141u8; }
|
|
else { if (op == A_JB) { cc = 130u8; }
|
|
else { if (op == A_JBE) { cc = 134u8; }
|
|
else { if (op == A_JA) { cc = 135u8; }
|
|
else { if (op == A_JAE) { cc = 131u8; }
|
|
else { is_jcc = false; };};};};};};};};};};};};
|
|
if (is_jcc) {
|
|
a_emit_byte(a, 15u8);
|
|
a_emit_byte(a, cc);
|
|
add_fixup(a, a.textlen, p.to.asym);
|
|
a_emit_u32(a, 0u32);
|
|
p = p.link; continue;
|
|
};
|
|
|
|
os.write(2, "w6a: unsupported opcode\n".ptr, 23u64);
|
|
a.errs += 1;
|
|
p = p.link;
|
|
};
|
|
|
|
// Second pass: patch fixups (forward label refs).
|
|
let f: *afixup = a.fixups;
|
|
for (f != nil) {
|
|
if (!label_defined(a, f.label)) {
|
|
os.write(2, "w6a: undefined label '".ptr, 21u64);
|
|
let lbl: str = f.label;
|
|
os.write(2, lbl.ptr, lbl.len: u64);
|
|
os.write(2, "'\n".ptr, 2u64);
|
|
a.errs += 1;
|
|
f = f.fnext;
|
|
continue;
|
|
};
|
|
let target: u64 = resolve_label(a, f.label);
|
|
let rel: i64 = target: i64 - (f.off: i64 + 4i64);
|
|
let rel32: u32 = rel: u32;
|
|
a.text[f.off] = (rel32 & 255u32): u8;
|
|
a.text[f.off + 1u64] = ((rel32 >> 8u32) & 255u32): u8;
|
|
a.text[f.off + 2u64] = ((rel32 >> 16u32) & 255u32): u8;
|
|
a.text[f.off + 3u64] = ((rel32 >> 24u32) & 255u32): u8;
|
|
f = f.fnext;
|
|
};
|
|
return a.errs;
|
|
};
|