Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

selfhost/cmd/w6a: drop snake_case from lex/parse/asm/obj exports

Browse Source
This commit is contained in:
Hojun-Cho
2026-05-11 14:28:27 +09:00
parent 4f6f1d8edf
commit f250bcfb3a
7 changed files with 942 additions and 958 deletions
Download Patch File Download Diff File Expand all files Collapse all files

472
selfhost/cmd/w6a/asm.ww
View File

@@ -5,8 +5,8 @@
// 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
// authoritative list. Helpers (rcode/rhi/modrm/emitrex etc.) are
// fully ported; encode itself is still a stub pending the full
// switch over A_*.
use os;
@@ -15,7 +15,7 @@ use types;
// ---- text buffer growth ------------------------------------------------
export fn a_emit_byte(a: *asm_, b: u8) void = {
export fn emitbyte(a: *asm_, b: u8) void = {
if (a.textlen + 1u64 > a.textcap) {
let nc: u64 = a.textcap;
if (nc == 0u64) { nc = 4096u64; };
@@ -30,14 +30,14 @@ export fn a_emit_byte(a: *asm_, b: u8) void = {
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 emitu32(a: *asm_, v: u32) void = {
emitbyte(a, (v & 255u32): u8);
emitbyte(a, ((v >> 8u32) & 255u32): u8);
emitbyte(a, ((v >> 16u32) & 255u32): u8);
emitbyte(a, ((v >> 24u32) & 255u32): u8);
};
export fn a_addreloc(a: *asm_, off: u64, kind: i32, s: *asym, add: i64) void = {
export fn 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;
@@ -77,29 +77,29 @@ fn rhi(r: i32) i32 = {
return 0;
};
fn is_xmm(r: i32) bool = {
fn isxmm(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 = {
fn modrmbyte(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 = {
fn emitrex(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); }; };
if (b != 64u8) { emitbyte(a, b); }
else { if (w != 0) { emitbyte(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 = {
fn emitmodrmmem(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;
@@ -113,78 +113,78 @@ fn emit_modrm_mem(a: *asm_, reg_field: i32, base: i32, disp: i64) void = {
if (disp >= -128i64) { if (disp <= 127i64) { mod = 1; }; };
};
a_emit_byte(a, modrm_byte(mod, reg_field, rm));
emitbyte(a, modrmbyte(mod, reg_field, rm));
if (needsib) {
a_emit_byte(a, 36u8); // 0x24: scale=0 idx=4(none) base=4
emitbyte(a, 36u8); // 0x24: scale=0 idx=4(none) base=4
};
if (mod == 1) {
a_emit_byte(a, (disp: u64 & 255u64): u8);
emitbyte(a, (disp: u64 & 255u64): u8);
} else { if (mod == 2) {
a_emit_u32(a, disp: u32);
emitu32(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)));
fn encoderr(a: *asm_, opcode: u8, src: i32, dst: i32) void = {
emitrex(a, rhi(src), rhi(dst), 1);
emitbyte(a, opcode);
emitbyte(a, modrmbyte(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);
fn encoderm(a: *asm_, opcode: u8, src_reg: i32, base: i32, disp: i64) void = {
emitrex(a, rhi(src_reg), rhi(base), 1);
emitbyte(a, opcode);
emitmodrmmem(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);
fn encodemr(a: *asm_, opcode: u8, dst_reg: i32, base: i32, disp: i64) void = {
emitrex(a, rhi(dst_reg), rhi(base), 1);
emitbyte(a, opcode);
emitmodrmmem(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);
fn encoderiimm32(a: *asm_, opcode: u8, subop: i32, dst: i32, imm: i32) void = {
emitrex(a, 0, rhi(dst), 1);
emitbyte(a, opcode);
emitbyte(a, modrmbyte(3, subop, rcode(dst)));
emitu32(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)));
fn encodeunary(a: *asm_, opcode: u8, subop: i32, dst: i32) void = {
emitrex(a, 0, rhi(dst), 1);
emitbyte(a, opcode);
emitbyte(a, modrmbyte(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 sserr(a: *asm_, prefix: u8, op2: u8, reg_op: i32, rm_op: i32) void = {
if (prefix != 0u8) { emitbyte(a, prefix); };
emitrex(a, rhi(reg_op), rhi(rm_op), 0);
emitbyte(a, 15u8); // 0x0F
emitbyte(a, op2);
emitbyte(a, modrmbyte(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);
fn ssemrload(a: *asm_, prefix: u8, op2: u8, reg_op: i32, base: i32, disp: i64) void = {
if (prefix != 0u8) { emitbyte(a, prefix); };
emitrex(a, rhi(reg_op), rhi(base), 0);
emitbyte(a, 15u8);
emitbyte(a, op2);
emitmodrmmem(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)));
fn sserrw(a: *asm_, prefix: u8, op2: u8, reg_op: i32, rm_op: i32) void = {
if (prefix != 0u8) { emitbyte(a, prefix); };
emitrex(a, rhi(reg_op), rhi(rm_op), 1);
emitbyte(a, 15u8);
emitbyte(a, op2);
emitbyte(a, modrmbyte(3, rcode(reg_op), rcode(rm_op)));
};
// ---- label resolution / fixups ----------------------------------------
@@ -199,7 +199,7 @@ fn streq(a: str, b: str) bool = {
return true;
};
fn resolve_label(a: *asm_, name: str) u64 = {
fn resolvelabel(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; }; };
@@ -208,7 +208,7 @@ fn resolve_label(a: *asm_, name: str) u64 = {
return 0u64;
};
fn label_defined(a: *asm_, name: str) bool = {
fn labeldefined(a: *asm_, name: str) bool = {
let s: *asym = a.syms;
for (s != nil) {
if (s.defined != 0) { if (streq(s.name, name)) { return true; }; };
@@ -219,7 +219,7 @@ fn label_defined(a: *asm_, name: str) bool = {
// ---- fixup helper -----------------------------------------------------
fn add_fixup(a: *asm_, off: u64, label: str) void = {
fn addfixup(a: *asm_, off: u64, label: str) void = {
let f: *afixup = amalloc(a.a, 48u64): *afixup;
f.off = off;
f.label = label;
@@ -227,24 +227,24 @@ fn add_fixup(a: *asm_, off: u64, label: str) void = {
a.fixups = f;
};
fn is_gpr(t: i32) bool = {
fn isgpr(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
// `intern` lives in parse.ww — flat-scope concat lets us call it
// directly without an @symbol declaration here.
// ---- a_encode ---------------------------------------------------------
// ---- encode ----------------------------------------------------------
export fn a_encode(a: *asm_) i32 = {
export fn 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);
let s: *asym = intern(a, p.label);
s.defined = 1;
s.is_text = 1;
s.istext = 1;
s.addr = a.textlen;
};
let op: i32 = p.as_;
@@ -253,105 +253,105 @@ export fn a_encode(a: *asm_) i32 = {
p = p.link; continue;
};
if (op == A_TEXT) {
let s: *asym = a_intern(a, p.to.asym);
let s: *asym = intern(a, p.to.asym);
s.defined = 1;
s.is_text = 1;
s.is_global = 1;
s.istext = 1;
s.isglobal = 1;
s.addr = a.textlen;
p = p.link; continue;
};
if (op == A_DATA) {
let s: *asym = a_intern(a, p.to.asym);
let s: *asym = intern(a, p.to.asym);
s.defined = 1;
s.is_text = 1;
s.is_global = 1;
s.istext = 1;
s.isglobal = 1;
s.addr = a.textlen;
let i: u64 = 0u64;
for (i < p.nbytes) { a_emit_byte(a, p.bytes[i]); i += 1u64; };
for (i < p.nbytes) { emitbyte(a, p.bytes[i]); i += 1u64; };
p = p.link; continue;
};
if (op == A_RET) {
a_emit_byte(a, 195u8); // 0xC3
emitbyte(a, 195u8); // 0xC3
p = p.link; continue;
};
if (op == A_SYSCALL) {
a_emit_byte(a, 15u8);
a_emit_byte(a, 5u8);
emitbyte(a, 15u8);
emitbyte(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
if (rhi(p.to.atype) != 0) { emitbyte(a, 65u8); }; // 0x41
emitbyte(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
if (rhi(p.to.atype) != 0) { emitbyte(a, 65u8); };
emitbyte(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_NEGQ) { encodeunary(a, 247u8, 3, p.to.atype); p = p.link; continue; };
if (op == A_NOTQ) { encodeunary(a, 247u8, 2, p.to.atype); p = p.link; continue; };
if (op == A_IDIVQ) { encodeunary(a, 247u8, 7, p.to.atype); p = p.link; continue; };
if (op == A_DIVQ) { encodeunary(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)) {
if (ft == D_CONST) { if (isgpr(tt)) {
let v: i64 = p.from.offset;
if (v >= -2147483648i64) { if (v <= 2147483647i64) {
encode_ri_imm32(a, 199u8, 0, tt, v: i32);
encoderiimm32(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);
emitrex(a, 0, rhi(tt), 1);
emitbyte(a, (184 + rcode(tt)): u8);
let k: i32 = 0;
for (k < 8) {
a_emit_byte(a, ((v: u64 >> (k: u64 * 8u64)) & 255u64): u8);
emitbyte(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
if (isgpr(ft)) { if (isgpr(tt)) {
encoderr(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
if (ft == D_INDIR) { if (isgpr(tt)) {
encodemr(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);
if (isgpr(ft)) { if (tt == D_INDIR) {
encoderm(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);
emitrex(a, 0, rhi(p.to.reg), 1);
emitbyte(a, 199u8);
emitmodrmmem(a, 0, p.to.reg, p.to.offset);
emitu32(a, p.from.offset: u32);
p = p.link; continue;
};};
if (ft == D_EXTERN) { if (is_gpr(tt)) {
if (ft == D_EXTERN) { if (isgpr(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));
emitrex(a, rhi(tt), 0, 1);
emitbyte(a, 139u8);
emitbyte(a, modrmbyte(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);
emitu32(a, 0u32);
let s: *asym = intern(a, p.from.asym);
addreloc(a, reloff, 2, s, -4i64);
p = p.link; continue;
};};
if (is_gpr(ft)) { if (tt == D_EXTERN) {
if (isgpr(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));
emitrex(a, rhi(ft), 0, 1);
emitbyte(a, 137u8);
emitbyte(a, modrmbyte(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);
emitu32(a, 0u32);
let s: *asym = intern(a, p.to.asym);
addreloc(a, reloff, 2, s, -4i64);
p = p.link; continue;
};};
os.write(2, "w6a: unsupported MOVQ shape\n".ptr, 27u64);
@@ -362,16 +362,16 @@ export fn a_encode(a: *asm_) i32 = {
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);
if (isgpr(ft)) { if (tt == D_INDIR) {
emitrex(a, rhi(ft), rhi(p.to.reg), 0);
emitbyte(a, 136u8); // 0x88
emitmodrmmem(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);
if (ft == D_INDIR) { if (isgpr(tt)) {
emitrex(a, rhi(tt), rhi(p.from.reg), 0);
emitbyte(a, 138u8); // 0x8A
emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset);
p = p.link; continue;
};};
os.write(2, "w6a: unsupported MOVB shape\n".ptr, 27u64);
@@ -382,11 +382,11 @@ export fn a_encode(a: *asm_) i32 = {
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);
if (ft == D_INDIR) { if (isgpr(tt)) {
emitrex(a, rhi(tt), rhi(p.from.reg), 1);
emitbyte(a, 15u8);
emitbyte(a, 182u8); // 0xB6
emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset);
p = p.link; continue;
};};
os.write(2, "w6a: unsupported MOVZBQ shape\n".ptr, 29u64);
@@ -397,22 +397,22 @@ export fn a_encode(a: *asm_) i32 = {
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);
if (isgpr(ft)) { if (tt == D_INDIR) {
emitrex(a, rhi(ft), rhi(p.to.reg), 0);
emitbyte(a, 137u8);
emitmodrmmem(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);
if (ft == D_INDIR) { if (isgpr(tt)) {
emitrex(a, rhi(tt), rhi(p.from.reg), 0);
emitbyte(a, 139u8);
emitmodrmmem(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)));
if (isgpr(ft)) { if (isgpr(tt)) {
emitrex(a, rhi(ft), rhi(tt), 0);
emitbyte(a, 137u8);
emitbyte(a, modrmbyte(3, rcode(ft), rcode(tt)));
p = p.link; continue;
};};
os.write(2, "w6a: unsupported MOVL shape\n".ptr, 27u64);
@@ -423,10 +423,10 @@ export fn a_encode(a: *asm_) i32 = {
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);
if (ft == D_INDIR) { if (isgpr(tt)) {
emitrex(a, rhi(tt), rhi(p.from.reg), 1);
emitbyte(a, 99u8); // 0x63
emitmodrmmem(a, rcode(tt), p.from.reg, p.from.offset);
p = p.link; continue;
};};
os.write(2, "w6a: unsupported MOVSXD shape\n".ptr, 29u64);
@@ -437,16 +437,16 @@ export fn a_encode(a: *asm_) i32 = {
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);
if (isxmm(ft)) { if (isxmm(tt)) {
sserr(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);
if (ft == D_INDIR) { if (isxmm(tt)) {
ssemrload(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);
if (isxmm(ft)) { if (tt == D_INDIR) {
ssemrload(a, 242u8, 17u8, ft, p.to.reg, p.to.offset);
p = p.link; continue;
};};
os.write(2, "w6a: unsupported MOVSD shape\n".ptr, 28u64);
@@ -454,26 +454,26 @@ export fn a_encode(a: *asm_) i32 = {
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_ADDSD) { sserr(a, 242u8, 88u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_SUBSD) { sserr(a, 242u8, 92u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_MULSD) { sserr(a, 242u8, 89u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_DIVSD) { sserr(a, 242u8, 94u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_UCOMISD) { sserr(a, 102u8, 46u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_CVTTSD2SI) { sserrw(a, 242u8, 44u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_CVTSI2SD) { sserrw(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 (isxmm(ft)) { if (isxmm(tt)) {
sserr(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);
if (ft == D_INDIR) { if (isxmm(tt)) {
ssemrload(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);
if (isxmm(ft)) { if (tt == D_INDIR) {
ssemrload(a, 243u8, 17u8, ft, p.to.reg, p.to.offset);
p = p.link; continue;
};};
os.write(2, "w6a: unsupported MOVSS shape\n".ptr, 28u64);
@@ -481,115 +481,115 @@ export fn a_encode(a: *asm_) i32 = {
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_ADDSS) { sserr(a, 243u8, 88u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_SUBSS) { sserr(a, 243u8, 92u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_MULSS) { sserr(a, 243u8, 89u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_DIVSS) { sserr(a, 243u8, 94u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_UCOMISS) { sserr(a, 0u8, 46u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_CVTTSS2SI) { sserrw(a, 243u8, 44u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_CVTSI2SS) { sserrw(a, 243u8, 42u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_CVTSD2SS) { sserr(a, 242u8, 90u8, p.to.atype, p.from.atype); p = p.link; continue; };
if (op == A_CVTSS2SD) { sserr(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
if (ft == D_CONST) { if (isgpr(tt)) {
encoderiimm32(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);
emitrex(a, 0, rhi(p.to.reg), 1);
emitbyte(a, 129u8);
emitmodrmmem(a, 0, p.to.reg, p.to.offset);
emitu32(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);
if (isgpr(ft)) { if (tt == D_INDIR) {
encoderm(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);
if (ft == D_INDIR) { if (isgpr(tt)) {
encodemr(a, 3u8, tt, p.from.reg, p.from.offset);
p = p.link; continue;
};};
encode_rr(a, 1u8, ft, tt);
encoderr(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);
if (ft == D_CONST) { if (isgpr(tt)) {
encoderiimm32(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);
emitrex(a, 0, rhi(p.to.reg), 1);
emitbyte(a, 129u8);
emitmodrmmem(a, 5, p.to.reg, p.to.offset);
emitu32(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
if (isgpr(ft)) { if (tt == D_INDIR) {
encoderm(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
if (ft == D_INDIR) { if (isgpr(tt)) {
encodemr(a, 43u8, tt, p.from.reg, p.from.offset); // 0x2B
p = p.link; continue;
};};
encode_rr(a, 41u8, ft, tt);
encoderr(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_ANDQ) { encoderr(a, 33u8, p.from.atype, p.to.atype); p = p.link; continue; }; // 0x21
if (op == A_ORQ) { encoderr(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);
if (ft == D_CONST) { if (isgpr(tt)) {
encoderiimm32(a, 129u8, 6, tt, p.from.offset: i32);
p = p.link; continue;
};};
encode_rr(a, 49u8, ft, tt); // 0x31
encoderr(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)));
emitrex(a, rhi(p.to.atype), rhi(p.from.atype), 1);
emitbyte(a, 15u8);
emitbyte(a, 175u8); // 0xAF
emitbyte(a, modrmbyte(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_SHLQ) { encodeunary(a, 211u8, 4, p.to.atype); p = p.link; continue; }; // 0xD3
if (op == A_SHRQ) { encodeunary(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);
if (ft == D_CONST) { if (isgpr(tt)) {
encoderiimm32(a, 129u8, 7, tt, p.from.offset: i32);
p = p.link; continue;
};};
encode_rr(a, 57u8, ft, tt); // 0x39
encoderr(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
if (ft == D_INDIR) { if (isgpr(tt)) {
encodemr(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));
if (ft == D_EXTERN) { if (isgpr(tt)) {
emitrex(a, rhi(tt), 0, 1);
emitbyte(a, 141u8);
emitbyte(a, modrmbyte(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);
emitu32(a, 0u32);
let s: *asym = intern(a, p.from.asym);
addreloc(a, reloff, 2, s, -4i64);
p = p.link; continue;
};};
p = p.link; continue;
@@ -598,32 +598,32 @@ export fn a_encode(a: *asm_) i32 = {
if (op == A_CALL) {
let tt: i32 = p.to.atype;
if (tt == D_EXTERN) {
a_emit_byte(a, 232u8); // 0xE8
emitbyte(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);
emitu32(a, 0u32);
let s: *asym = intern(a, p.to.asym);
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);
emitbyte(a, 232u8);
addfixup(a, a.textlen, p.to.asym);
emitu32(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)));
if (isgpr(tt)) {
if (rhi(tt) != 0) { emitbyte(a, 65u8); };
emitbyte(a, 255u8); // 0xFF
emitbyte(a, modrmbyte(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);
emitbyte(a, 233u8); // 0xE9
addfixup(a, a.textlen, p.to.asym);
emitu32(a, 0u32);
p = p.link; continue;
};
@@ -644,10 +644,10 @@ export fn a_encode(a: *asm_) i32 = {
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);
emitbyte(a, 15u8);
emitbyte(a, cc);
addfixup(a, a.textlen, p.to.asym);
emitu32(a, 0u32);
p = p.link; continue;
};
@@ -659,7 +659,7 @@ export fn a_encode(a: *asm_) i32 = {
// Second pass: patch fixups (forward label refs).
let f: *afixup = a.fixups;
for (f != nil) {
if (!label_defined(a, f.label)) {
if (!labeldefined(a, f.label)) {
os.write(2, "w6a: undefined label '".ptr, 21u64);
let lbl: str = f.label;
os.write(2, lbl.ptr, lbl.len: u64);
@@ -668,7 +668,7 @@ export fn a_encode(a: *asm_) i32 = {
f = f.fnext;
continue;
};
let target: u64 = resolve_label(a, f.label);
let target: u64 = resolvelabel(a, f.label);
let rel: i64 = target: i64 - (f.off: i64 + 4i64);
let rel32: u32 = rel: u32;
a.text[f.off] = (rel32 & 255u32): u8;

10
selfhost/cmd/w6a/lex.ww
View File

@@ -4,25 +4,25 @@
// itself is in parse.ww; here we keep tokenisers for identifiers and
// numbers so parse.ww stays focused on syntax.
export fn a_isidstart(c: i32) bool = {
export fn isidstart(c: i32) bool = {
if (c == 95) { return true; };
if (c >= 65) { if (c <= 90) { return true; }; }; // A-Z
if (c >= 97) { if (c <= 122) { return true; }; }; // a-z
return false;
};
export fn a_isidcont(c: i32) bool = {
if (a_isidstart(c)) { return true; };
export fn isidcont(c: i32) bool = {
if (isidstart(c)) { return true; };
if (c >= 48) { if (c <= 57) { return true; }; }; // 0-9
if (c == 46) { return true; }; // .
return false;
};
// a_parsenum — read a leading [+-]?[0x|0X|0]?digits from p[0..n-1].
// parsenum — read a leading [+-]?[0x|0X|0]?digits from p[0..n-1].
// Returns (value, consumed). Stops at first non-digit.
// Plain Plan 9-style: $123 / $0x1f / $-7. Decimal default; 0x prefix
// for hex; 0 prefix for octal when followed by a digit (else just 0).
export fn a_parsenum(p: *u8, n: u64) (i64, u64) = {
export fn parsenum(p: *u8, n: u64) (i64, u64) = {
let i: u64 = 0u64;
let neg: bool = false;
if (i < n) {

950
selfhost/cmd/w6a/main.combined.ww
View File

File diff suppressed because it is too large Load Diff

8
selfhost/cmd/w6a/main.ww
View File

@@ -93,10 +93,10 @@ export fn main(argc: i32, argv: **u8) i32 = {
let asm: asm_;
let nlen: u64 = cstrlen(src);
let fname: str = astrndup(ar, src, nlen);
a_init(&asm, ar, fname, buf, blen);
init(&asm, ar, fname, buf, blen);
if (a_parse(&asm) != 0) { return 1; };
if (a_encode(&asm) != 0) { return 1; };
if (parse(&asm) != 0) { return 1; };
if (encode(&asm) != 0) { return 1; };
// Open output for write.
let fd: i32 = os.open(out, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 420i32); // 0o644
@@ -104,7 +104,7 @@ export fn main(argc: i32, argv: **u8) i32 = {
os.write(2, "w6a: cannot open output\n".ptr, 23u64);
return 1;
};
let rc: i32 = a_emit_elf(&asm, fd);
let rc: i32 = emitelf(&asm, fd);
os.close(fd);
return rc;
};

168
selfhost/cmd/w6a/obj.ww
View File

@@ -44,20 +44,20 @@ def RELA_SZ: u64 = 24u64;
// ---- LE byte writers (own the bytes — write into a *u8 + offset) ----
fn wr_u8(p: *u8, off: u64, v: u8) void = { p[off] = v; };
fn wr_u16(p: *u8, off: u64, v: u16) void = {
fn wru8(p: *u8, off: u64, v: u8) void = { p[off] = v; };
fn wru16(p: *u8, off: u64, v: u16) void = {
p[off] = (v & 255u16): u8;
p[off + 1u64] = ((v >> 8u16) & 255u16): u8;
};
fn wr_u32(p: *u8, off: u64, v: u32) void = {
fn wru32(p: *u8, off: u64, v: u32) void = {
p[off] = (v & 255u32): u8;
p[off + 1u64] = ((v >> 8u32) & 255u32): u8;
p[off + 2u64] = ((v >> 16u32) & 255u32): u8;
p[off + 3u64] = ((v >> 24u32) & 255u32): u8;
};
fn wr_u64(p: *u8, off: u64, v: u64) void = {
wr_u32(p, off, (v & 4294967295u64): u32);
wr_u32(p, off + 4u64, ((v >> 32u64) & 4294967295u64): u32);
fn wru64(p: *u8, off: u64, v: u64) void = {
wru32(p, off, (v & 4294967295u64): u32);
wru32(p, off + 4u64, ((v >> 32u64) & 4294967295u64): u32);
};
// ---- growable byte buffer ---------------------------------------------
@@ -69,14 +69,14 @@ type buf = struct {
cap: u64,
};
fn buf_init(b: *buf, a: *arena) void = {
fn bufinit(b: *buf, a: *arena) void = {
b.a = a;
b.cap = 256u64;
b.n = 0u64;
b.p = amalloc(a, b.cap): *u8;
};
fn buf_grow(b: *buf, need: u64) void = {
fn bufgrow(b: *buf, need: u64) void = {
if (b.n + need <= b.cap) { return; };
let nc: u64 = b.cap;
for (nc < b.n + need) { nc = nc * 2u64; };
@@ -87,8 +87,8 @@ fn buf_grow(b: *buf, need: u64) void = {
b.cap = nc;
};
fn buf_putb(b: *buf, src: *u8, n: u64) void = {
buf_grow(b, n);
fn bufputb(b: *buf, src: *u8, n: u64) void = {
bufgrow(b, n);
let i: u64 = 0u64;
for (i < n) { b.p[b.n + i] = src[i]; i += 1u64; };
b.n += n;
@@ -96,9 +96,9 @@ fn buf_putb(b: *buf, src: *u8, n: u64) void = {
// Write a NUL-terminated C-string copy of `s` into b. Returns offset
// where it started (suitable for st_name / sh_name fields).
fn buf_put_cstr(b: *buf, s: str) u32 = {
fn bufputcstr(b: *buf, s: str) u32 = {
let off: u32 = b.n: u32;
buf_grow(b, s.len: u64 + 1u64);
bufgrow(b, s.len: u64 + 1u64);
let i: i32 = 0;
for (i < s.len) { b.p[b.n] = s[i]; b.n += 1u64; i += 1; };
b.p[b.n] = 0u8;
@@ -106,31 +106,31 @@ fn buf_put_cstr(b: *buf, s: str) u32 = {
return off;
};
// ---- emit_elf ---------------------------------------------------------
// ---- emitelf ---------------------------------------------------------
export fn a_emit_elf(a: *asm_, fd: i32) i32 = {
let shstr: buf; buf_init(&shstr, a.a);
let str_: buf; buf_init(&str_, a.a);
let sym: buf; buf_init(&sym, a.a);
let rela: buf; buf_init(&rela, a.a);
export fn emitelf(a: *asm_, fd: i32) i32 = {
let shstr: buf; bufinit(&shstr, a.a);
let str_: buf; bufinit(&str_, a.a);
let sym: buf; bufinit(&sym, a.a);
let rela: buf; bufinit(&rela, a.a);
// Index 0 = empty.
let zero: u8 = 0u8;
buf_putb(&shstr, &zero, 1u64);
buf_putb(&str_, &zero, 1u64);
bufputb(&shstr, &zero, 1u64);
bufputb(&str_, &zero, 1u64);
// Section name offsets.
let shn_text: u32 = buf_put_cstr(&shstr, ".text");
let shn_rela: u32 = buf_put_cstr(&shstr, ".rela.text");
let shn_symtab: u32 = buf_put_cstr(&shstr, ".symtab");
let shn_strtab: u32 = buf_put_cstr(&shstr, ".strtab");
let shn_shstrtab: u32 = buf_put_cstr(&shstr, ".shstrtab");
let shn_text: u32 = bufputcstr(&shstr, ".text");
let shn_rela: u32 = bufputcstr(&shstr, ".rela.text");
let shn_symtab: u32 = bufputcstr(&shstr, ".symtab");
let shn_strtab: u32 = bufputcstr(&shstr, ".strtab");
let shn_shstrtab: u32 = bufputcstr(&shstr, ".shstrtab");
// Symbol 0 — STN_UNDEF (24 zero bytes).
let zsym: [24]u8;
let zi: i32 = 0;
for (zi < 24) { zsym[zi] = 0u8; zi += 1; };
buf_putb(&sym, zsym.ptr, 24u64);
bufputb(&sym, zsym.ptr, 24u64);
let SH_TEXT: u16 = 1u16;
@@ -141,17 +141,17 @@ export fn a_emit_elf(a: *asm_, fd: i32) i32 = {
let entry: [24]u8;
let ei: i32 = 0;
for (ei < 24) { entry[ei] = 0u8; ei += 1; };
let st_name: u32 = buf_put_cstr(&str_, s.name);
wr_u32(entry.ptr, 0u64, st_name);
let st_name: u32 = bufputcstr(&str_, s.name);
wru32(entry.ptr, 0u64, st_name);
if (s.defined != 0) {
wr_u8(entry.ptr, 4u64, ((STB_GLOBAL << 4u8) | STT_FUNC));
wr_u16(entry.ptr, 6u64, SH_TEXT);
wr_u64(entry.ptr, 8u64, s.addr);
wru8(entry.ptr, 4u64, ((STB_GLOBAL << 4u8) | STT_FUNC));
wru16(entry.ptr, 6u64, SH_TEXT);
wru64(entry.ptr, 8u64, s.addr);
} else {
wr_u8(entry.ptr, 4u64, ((STB_GLOBAL << 4u8) | STT_NOTYPE));
wr_u16(entry.ptr, 6u64, 0u16);
wru8(entry.ptr, 4u64, ((STB_GLOBAL << 4u8) | STT_NOTYPE));
wru16(entry.ptr, 6u64, 0u16);
};
buf_putb(&sym, entry.ptr, 24u64);
bufputb(&sym, entry.ptr, 24u64);
s.idx = idx;
idx += 1;
s = s.snext;
@@ -161,11 +161,11 @@ export fn a_emit_elf(a: *asm_, fd: i32) i32 = {
let r: *areloc = a.relocs;
for (r != nil) {
let entry: [24]u8;
wr_u64(entry.ptr, 0u64, r.off);
wru64(entry.ptr, 0u64, r.off);
let r_info: u64 = (r.asy.idx: u64 << 32u64) | (r.kind: u64 & 4294967295u64);
wr_u64(entry.ptr, 8u64, r_info);
wr_u64(entry.ptr, 16u64, r.addend: u64);
buf_putb(&rela, entry.ptr, 24u64);
wru64(entry.ptr, 8u64, r_info);
wru64(entry.ptr, 16u64, r.addend: u64);
bufputb(&rela, entry.ptr, 24u64);
r = r.rnext;
};
@@ -191,19 +191,19 @@ export fn a_emit_elf(a: *asm_, fd: i32) i32 = {
eh[4] = ELFCLASS64;
eh[5] = ELFDATA2LSB;
eh[6] = EV_CURRENT_W: u8;
wr_u16(eh.ptr, 16u64, ET_REL_W);
wr_u16(eh.ptr, 18u64, EM_X86_64_W);
wr_u32(eh.ptr, 20u64, EV_CURRENT_W);
wr_u64(eh.ptr, 24u64, 0u64); // e_entry
wr_u64(eh.ptr, 32u64, 0u64); // e_phoff
wr_u64(eh.ptr, 40u64, off_shdr); // e_shoff
wr_u32(eh.ptr, 48u64, 0u32); // e_flags
wr_u16(eh.ptr, 52u64, 64u16); // e_ehsize
wr_u16(eh.ptr, 54u64, 0u16); // e_phentsize
wr_u16(eh.ptr, 56u64, 0u16); // e_phnum
wr_u16(eh.ptr, 58u64, 64u16); // e_shentsize
wr_u16(eh.ptr, 60u64, NSECT); // e_shnum
wr_u16(eh.ptr, 62u64, 5u16); // e_shstrndx
wru16(eh.ptr, 16u64, ET_REL_W);
wru16(eh.ptr, 18u64, EM_X86_64_W);
wru32(eh.ptr, 20u64, EV_CURRENT_W);
wru64(eh.ptr, 24u64, 0u64); // e_entry
wru64(eh.ptr, 32u64, 0u64); // e_phoff
wru64(eh.ptr, 40u64, off_shdr); // e_shoff
wru32(eh.ptr, 48u64, 0u32); // e_flags
wru16(eh.ptr, 52u64, 64u16); // e_ehsize
wru16(eh.ptr, 54u64, 0u16); // e_phentsize
wru16(eh.ptr, 56u64, 0u16); // e_phnum
wru16(eh.ptr, 58u64, 64u16); // e_shentsize
wru16(eh.ptr, 60u64, NSECT); // e_shnum
wru16(eh.ptr, 62u64, 5u16); // e_shstrndx
if (os.writefull(fd, eh.ptr, 64u64) != 64i64) { return -1; };
if (a.textlen > 0u64) {
@@ -238,55 +238,55 @@ export fn a_emit_elf(a: *asm_, fd: i32) i32 = {
// .text
sn = 0;
for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
wr_u32(shbuf.ptr, 0u64, shn_text);
wr_u32(shbuf.ptr, 4u64, SHT_PROGBITS_C);
wr_u64(shbuf.ptr, 8u64, SHF_ALLOC | SHF_EXECINSTR);
wr_u64(shbuf.ptr, 24u64, off_text);
wr_u64(shbuf.ptr, 32u64, a.textlen);
wr_u64(shbuf.ptr, 48u64, 1u64); // sh_addralign
wru32(shbuf.ptr, 0u64, shn_text);
wru32(shbuf.ptr, 4u64, SHT_PROGBITS_C);
wru64(shbuf.ptr, 8u64, SHF_ALLOC | SHF_EXECINSTR);
wru64(shbuf.ptr, 24u64, off_text);
wru64(shbuf.ptr, 32u64, a.textlen);
wru64(shbuf.ptr, 48u64, 1u64); // sh_addralign
os.writefull(fd, shbuf.ptr, 64u64);
// .rela.text
sn = 0;
for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
wr_u32(shbuf.ptr, 0u64, shn_rela);
wr_u32(shbuf.ptr, 4u64, SHT_RELA_C);
wr_u64(shbuf.ptr, 8u64, SHF_INFO_LINK);
wr_u64(shbuf.ptr, 24u64, off_rela);
wr_u64(shbuf.ptr, 32u64, rela.n);
wr_u32(shbuf.ptr, 40u64, 3u32); // sh_link = symtab idx
wr_u32(shbuf.ptr, 44u64, 1u32); // sh_info = .text idx
wr_u64(shbuf.ptr, 48u64, 8u64);
wr_u64(shbuf.ptr, 56u64, RELA_SZ);
wru32(shbuf.ptr, 0u64, shn_rela);
wru32(shbuf.ptr, 4u64, SHT_RELA_C);
wru64(shbuf.ptr, 8u64, SHF_INFO_LINK);
wru64(shbuf.ptr, 24u64, off_rela);
wru64(shbuf.ptr, 32u64, rela.n);
wru32(shbuf.ptr, 40u64, 3u32); // sh_link = symtab idx
wru32(shbuf.ptr, 44u64, 1u32); // sh_info = .text idx
wru64(shbuf.ptr, 48u64, 8u64);
wru64(shbuf.ptr, 56u64, RELA_SZ);
os.writefull(fd, shbuf.ptr, 64u64);
// .symtab
sn = 0;
for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
wr_u32(shbuf.ptr, 0u64, shn_symtab);
wr_u32(shbuf.ptr, 4u64, SHT_SYMTAB_C);
wr_u64(shbuf.ptr, 24u64, off_sym);
wr_u64(shbuf.ptr, 32u64, sym.n);
wr_u32(shbuf.ptr, 40u64, 4u32); // sh_link = strtab
wr_u32(shbuf.ptr, 44u64, 1u32); // sh_info = one local (STN_UNDEF)
wr_u64(shbuf.ptr, 48u64, 8u64);
wr_u64(shbuf.ptr, 56u64, SYM_SZ);
wru32(shbuf.ptr, 0u64, shn_symtab);
wru32(shbuf.ptr, 4u64, SHT_SYMTAB_C);
wru64(shbuf.ptr, 24u64, off_sym);
wru64(shbuf.ptr, 32u64, sym.n);
wru32(shbuf.ptr, 40u64, 4u32); // sh_link = strtab
wru32(shbuf.ptr, 44u64, 1u32); // sh_info = one local (STN_UNDEF)
wru64(shbuf.ptr, 48u64, 8u64);
wru64(shbuf.ptr, 56u64, SYM_SZ);
os.writefull(fd, shbuf.ptr, 64u64);
// .strtab
sn = 0;
for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
wr_u32(shbuf.ptr, 0u64, shn_strtab);
wr_u32(shbuf.ptr, 4u64, SHT_STRTAB_C);
wr_u64(shbuf.ptr, 24u64, off_str);
wr_u64(shbuf.ptr, 32u64, str_.n);
wr_u64(shbuf.ptr, 48u64, 1u64);
wru32(shbuf.ptr, 0u64, shn_strtab);
wru32(shbuf.ptr, 4u64, SHT_STRTAB_C);
wru64(shbuf.ptr, 24u64, off_str);
wru64(shbuf.ptr, 32u64, str_.n);
wru64(shbuf.ptr, 48u64, 1u64);
os.writefull(fd, shbuf.ptr, 64u64);
// .shstrtab
sn = 0;
for (sn < 64) { shbuf[sn] = 0u8; sn += 1; };
wr_u32(shbuf.ptr, 0u64, shn_shstrtab);
wr_u32(shbuf.ptr, 4u64, SHT_STRTAB_C);
wr_u64(shbuf.ptr, 24u64, off_shstr);
wr_u64(shbuf.ptr, 32u64, shstr.n);
wr_u64(shbuf.ptr, 48u64, 1u64);
wru32(shbuf.ptr, 0u64, shn_shstrtab);
wru32(shbuf.ptr, 4u64, SHT_STRTAB_C);
wru64(shbuf.ptr, 24u64, off_shstr);
wru64(shbuf.ptr, 32u64, shstr.n);
wru64(shbuf.ptr, 48u64, 1u64);
os.writefull(fd, shbuf.ptr, 64u64);
return 0;

288
selfhost/cmd/w6a/parse.ww
View File

@@ -15,7 +15,7 @@ use mem;
use lex;
use types;
fn streq_lit(p: *u8, n: u64, lit: str) bool = {
fn streqlit(p: *u8, n: u64, lit: str) bool = {
if (n != lit.len: u64) { return false; };
let i: u64 = 0u64;
for (i < n) {
@@ -26,109 +26,109 @@ fn streq_lit(p: *u8, n: u64, lit: str) bool = {
return true;
};
// opcode_lookup — name (length-bounded *u8) → A_*. Returns 0 (A_NOP)
// opcodelookup — name (length-bounded *u8) → A_*. Returns 0 (A_NOP)
// if not found.
fn opcode_lookup(p: *u8, n: u64) i32 = {
if (streq_lit(p, n, "MOVQ")) { return A_MOVQ; };
if (streq_lit(p, n, "MOVL")) { return A_MOVL; };
if (streq_lit(p, n, "MOVB")) { return A_MOVB; };
if (streq_lit(p, n, "MOVZBQ")) { return A_MOVZBQ; };
if (streq_lit(p, n, "MOVSXD")) { return A_MOVSXD; };
if (streq_lit(p, n, "MOVSD")) { return A_MOVSD; };
if (streq_lit(p, n, "ADDSD")) { return A_ADDSD; };
if (streq_lit(p, n, "SUBSD")) { return A_SUBSD; };
if (streq_lit(p, n, "MULSD")) { return A_MULSD; };
if (streq_lit(p, n, "DIVSD")) { return A_DIVSD; };
if (streq_lit(p, n, "UCOMISD")) { return A_UCOMISD; };
if (streq_lit(p, n, "CVTTSD2SI")) { return A_CVTTSD2SI; };
if (streq_lit(p, n, "CVTSI2SD")) { return A_CVTSI2SD; };
if (streq_lit(p, n, "MOVSS")) { return A_MOVSS; };
if (streq_lit(p, n, "ADDSS")) { return A_ADDSS; };
if (streq_lit(p, n, "SUBSS")) { return A_SUBSS; };
if (streq_lit(p, n, "MULSS")) { return A_MULSS; };
if (streq_lit(p, n, "DIVSS")) { return A_DIVSS; };
if (streq_lit(p, n, "UCOMISS")) { return A_UCOMISS; };
if (streq_lit(p, n, "CVTTSS2SI")) { return A_CVTTSS2SI; };
if (streq_lit(p, n, "CVTSI2SS")) { return A_CVTSI2SS; };
if (streq_lit(p, n, "CVTSD2SS")) { return A_CVTSD2SS; };
if (streq_lit(p, n, "CVTSS2SD")) { return A_CVTSS2SD; };
if (streq_lit(p, n, "ADDQ")) { return A_ADDQ; };
if (streq_lit(p, n, "SUBQ")) { return A_SUBQ; };
if (streq_lit(p, n, "IMULQ")) { return A_IMULQ; };
if (streq_lit(p, n, "IDIVQ")) { return A_IDIVQ; };
if (streq_lit(p, n, "DIVQ")) { return A_DIVQ; };
if (streq_lit(p, n, "NEGQ")) { return A_NEGQ; };
if (streq_lit(p, n, "NOTQ")) { return A_NOTQ; };
if (streq_lit(p, n, "ANDQ")) { return A_ANDQ; };
if (streq_lit(p, n, "ORQ")) { return A_ORQ; };
if (streq_lit(p, n, "XORQ")) { return A_XORQ; };
if (streq_lit(p, n, "SHLQ")) { return A_SHLQ; };
if (streq_lit(p, n, "SHRQ")) { return A_SHRQ; };
if (streq_lit(p, n, "CMPQ")) { return A_CMPQ; };
if (streq_lit(p, n, "PUSHQ")) { return A_PUSHQ; };
if (streq_lit(p, n, "POPQ")) { return A_POPQ; };
if (streq_lit(p, n, "LEAQ")) { return A_LEAQ; };
if (streq_lit(p, n, "CALL")) { return A_CALL; };
if (streq_lit(p, n, "RET")) { return A_RET; };
if (streq_lit(p, n, "JMP")) { return A_JMP; };
if (streq_lit(p, n, "JE")) { return A_JE; };
if (streq_lit(p, n, "JNE")) { return A_JNE; };
if (streq_lit(p, n, "JL")) { return A_JL; };
if (streq_lit(p, n, "JLE")) { return A_JLE; };
if (streq_lit(p, n, "JG")) { return A_JG; };
if (streq_lit(p, n, "JGE")) { return A_JGE; };
if (streq_lit(p, n, "JB")) { return A_JB; };
if (streq_lit(p, n, "JBE")) { return A_JBE; };
if (streq_lit(p, n, "JA")) { return A_JA; };
if (streq_lit(p, n, "JAE")) { return A_JAE; };
if (streq_lit(p, n, "JZ")) { return A_JZ; };
if (streq_lit(p, n, "JNZ")) { return A_JNZ; };
if (streq_lit(p, n, "SYSCALL")) { return A_SYSCALL; };
if (streq_lit(p, n, "TEXT")) { return A_TEXT; };
if (streq_lit(p, n, "DATA")) { return A_DATA; };
fn opcodelookup(p: *u8, n: u64) i32 = {
if (streqlit(p, n, "MOVQ")) { return A_MOVQ; };
if (streqlit(p, n, "MOVL")) { return A_MOVL; };
if (streqlit(p, n, "MOVB")) { return A_MOVB; };
if (streqlit(p, n, "MOVZBQ")) { return A_MOVZBQ; };
if (streqlit(p, n, "MOVSXD")) { return A_MOVSXD; };
if (streqlit(p, n, "MOVSD")) { return A_MOVSD; };
if (streqlit(p, n, "ADDSD")) { return A_ADDSD; };
if (streqlit(p, n, "SUBSD")) { return A_SUBSD; };
if (streqlit(p, n, "MULSD")) { return A_MULSD; };
if (streqlit(p, n, "DIVSD")) { return A_DIVSD; };
if (streqlit(p, n, "UCOMISD")) { return A_UCOMISD; };
if (streqlit(p, n, "CVTTSD2SI")) { return A_CVTTSD2SI; };
if (streqlit(p, n, "CVTSI2SD")) { return A_CVTSI2SD; };
if (streqlit(p, n, "MOVSS")) { return A_MOVSS; };
if (streqlit(p, n, "ADDSS")) { return A_ADDSS; };
if (streqlit(p, n, "SUBSS")) { return A_SUBSS; };
if (streqlit(p, n, "MULSS")) { return A_MULSS; };
if (streqlit(p, n, "DIVSS")) { return A_DIVSS; };
if (streqlit(p, n, "UCOMISS")) { return A_UCOMISS; };
if (streqlit(p, n, "CVTTSS2SI")) { return A_CVTTSS2SI; };
if (streqlit(p, n, "CVTSI2SS")) { return A_CVTSI2SS; };
if (streqlit(p, n, "CVTSD2SS")) { return A_CVTSD2SS; };
if (streqlit(p, n, "CVTSS2SD")) { return A_CVTSS2SD; };
if (streqlit(p, n, "ADDQ")) { return A_ADDQ; };
if (streqlit(p, n, "SUBQ")) { return A_SUBQ; };
if (streqlit(p, n, "IMULQ")) { return A_IMULQ; };
if (streqlit(p, n, "IDIVQ")) { return A_IDIVQ; };
if (streqlit(p, n, "DIVQ")) { return A_DIVQ; };
if (streqlit(p, n, "NEGQ")) { return A_NEGQ; };
if (streqlit(p, n, "NOTQ")) { return A_NOTQ; };
if (streqlit(p, n, "ANDQ")) { return A_ANDQ; };
if (streqlit(p, n, "ORQ")) { return A_ORQ; };
if (streqlit(p, n, "XORQ")) { return A_XORQ; };
if (streqlit(p, n, "SHLQ")) { return A_SHLQ; };
if (streqlit(p, n, "SHRQ")) { return A_SHRQ; };
if (streqlit(p, n, "CMPQ")) { return A_CMPQ; };
if (streqlit(p, n, "PUSHQ")) { return A_PUSHQ; };
if (streqlit(p, n, "POPQ")) { return A_POPQ; };
if (streqlit(p, n, "LEAQ")) { return A_LEAQ; };
if (streqlit(p, n, "CALL")) { return A_CALL; };
if (streqlit(p, n, "RET")) { return A_RET; };
if (streqlit(p, n, "JMP")) { return A_JMP; };
if (streqlit(p, n, "JE")) { return A_JE; };
if (streqlit(p, n, "JNE")) { return A_JNE; };
if (streqlit(p, n, "JL")) { return A_JL; };
if (streqlit(p, n, "JLE")) { return A_JLE; };
if (streqlit(p, n, "JG")) { return A_JG; };
if (streqlit(p, n, "JGE")) { return A_JGE; };
if (streqlit(p, n, "JB")) { return A_JB; };
if (streqlit(p, n, "JBE")) { return A_JBE; };
if (streqlit(p, n, "JA")) { return A_JA; };
if (streqlit(p, n, "JAE")) { return A_JAE; };
if (streqlit(p, n, "JZ")) { return A_JZ; };
if (streqlit(p, n, "JNZ")) { return A_JNZ; };
if (streqlit(p, n, "SYSCALL")) { return A_SYSCALL; };
if (streqlit(p, n, "TEXT")) { return A_TEXT; };
if (streqlit(p, n, "DATA")) { return A_DATA; };
return A_NOP;
};
// reg_lookup — name → D_*. Returns D_NONE if not found.
fn reg_lookup(p: *u8, n: u64) i32 = {
if (streq_lit(p, n, "AX")) { return D_AX; };
if (streq_lit(p, n, "BX")) { return D_BX; };
if (streq_lit(p, n, "CX")) { return D_CX; };
if (streq_lit(p, n, "DX")) { return D_DX; };
if (streq_lit(p, n, "SP")) { return D_SP; };
if (streq_lit(p, n, "BP")) { return D_BP; };
if (streq_lit(p, n, "SI")) { return D_SI; };
if (streq_lit(p, n, "DI")) { return D_DI; };
if (streq_lit(p, n, "R8")) { return D_R8; };
if (streq_lit(p, n, "R9")) { return D_R9; };
if (streq_lit(p, n, "R10")) { return D_R10; };
if (streq_lit(p, n, "R11")) { return D_R11; };
if (streq_lit(p, n, "R12")) { return D_R12; };
if (streq_lit(p, n, "R13")) { return D_R13; };
if (streq_lit(p, n, "R14")) { return D_R14; };
if (streq_lit(p, n, "R15")) { return D_R15; };
if (streq_lit(p, n, "X0")) { return D_X0; };
if (streq_lit(p, n, "X1")) { return D_X1; };
if (streq_lit(p, n, "X2")) { return D_X2; };
if (streq_lit(p, n, "X3")) { return D_X3; };
if (streq_lit(p, n, "X4")) { return D_X4; };
if (streq_lit(p, n, "X5")) { return D_X5; };
if (streq_lit(p, n, "X6")) { return D_X6; };
if (streq_lit(p, n, "X7")) { return D_X7; };
if (streq_lit(p, n, "X8")) { return D_X8; };
if (streq_lit(p, n, "X9")) { return D_X9; };
if (streq_lit(p, n, "X10")) { return D_X10; };
if (streq_lit(p, n, "X11")) { return D_X11; };
if (streq_lit(p, n, "X12")) { return D_X12; };
if (streq_lit(p, n, "X13")) { return D_X13; };
if (streq_lit(p, n, "X14")) { return D_X14; };
if (streq_lit(p, n, "X15")) { return D_X15; };
if (streq_lit(p, n, "SB")) { return D_PSB; };
if (streq_lit(p, n, "FP")) { return D_PFP; };
// reglookup — name → D_*. Returns D_NONE if not found.
fn reglookup(p: *u8, n: u64) i32 = {
if (streqlit(p, n, "AX")) { return D_AX; };
if (streqlit(p, n, "BX")) { return D_BX; };
if (streqlit(p, n, "CX")) { return D_CX; };
if (streqlit(p, n, "DX")) { return D_DX; };
if (streqlit(p, n, "SP")) { return D_SP; };
if (streqlit(p, n, "BP")) { return D_BP; };
if (streqlit(p, n, "SI")) { return D_SI; };
if (streqlit(p, n, "DI")) { return D_DI; };
if (streqlit(p, n, "R8")) { return D_R8; };
if (streqlit(p, n, "R9")) { return D_R9; };
if (streqlit(p, n, "R10")) { return D_R10; };
if (streqlit(p, n, "R11")) { return D_R11; };
if (streqlit(p, n, "R12")) { return D_R12; };
if (streqlit(p, n, "R13")) { return D_R13; };
if (streqlit(p, n, "R14")) { return D_R14; };
if (streqlit(p, n, "R15")) { return D_R15; };
if (streqlit(p, n, "X0")) { return D_X0; };
if (streqlit(p, n, "X1")) { return D_X1; };
if (streqlit(p, n, "X2")) { return D_X2; };
if (streqlit(p, n, "X3")) { return D_X3; };
if (streqlit(p, n, "X4")) { return D_X4; };
if (streqlit(p, n, "X5")) { return D_X5; };
if (streqlit(p, n, "X6")) { return D_X6; };
if (streqlit(p, n, "X7")) { return D_X7; };
if (streqlit(p, n, "X8")) { return D_X8; };
if (streqlit(p, n, "X9")) { return D_X9; };
if (streqlit(p, n, "X10")) { return D_X10; };
if (streqlit(p, n, "X11")) { return D_X11; };
if (streqlit(p, n, "X12")) { return D_X12; };
if (streqlit(p, n, "X13")) { return D_X13; };
if (streqlit(p, n, "X14")) { return D_X14; };
if (streqlit(p, n, "X15")) { return D_X15; };
if (streqlit(p, n, "SB")) { return D_PSB; };
if (streqlit(p, n, "FP")) { return D_PFP; };
return D_NONE;
};
export fn a_init(a: *asm_, ar: *arena, file: str, src: *u8, len: u64) void = {
export fn init(a: *asm_, ar: *arena, file: str, src: *u8, len: u64) void = {
a.a = ar;
a.file = file;
a.src = src;
@@ -146,20 +146,12 @@ export fn a_init(a: *asm_, ar: *arena, file: str, src: *u8, len: u64) void = {
a.errs = 0;
};
fn streq_str(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;
};
// `streq(str,str)` lives in asm.ww — same bundle, single definition.
export fn a_intern(a: *asm_, name: str) *asym = {
export fn intern(a: *asm_, name: str) *asym = {
let s: *asym = a.syms;
for (s != nil) {
if (streq_str(s.name, name)) { return s; };
if (streq(s.name, name)) { return s; };
s = s.snext;
};
let n: *asym = amalloc(a.a, 64u64): *asym;
@@ -179,8 +171,8 @@ fn perr(a: *asm_, msg: str) void = {
a.errs += 1;
};
// dup_str — copy n bytes from p into a fresh heap str.
fn dup_str(a: *arena, p: *u8, n: u64) str = {
// dupstr — copy n bytes from p into a fresh heap str.
fn dupstr(a: *arena, p: *u8, n: u64) str = {
return astrndup(a, p, n);
};
@@ -188,7 +180,7 @@ fn dup_str(a: *arena, p: *u8, n: u64) str = {
// Read next line into a fresh heap buffer; returns (ptr, len) or (nil,0)
// at EOF. Advances a.pos past the newline.
fn next_line(a: *asm_) (*u8, u64) = {
fn nextline(a: *asm_) (*u8, u64) = {
if (a.pos >= a.srclen) { return nil, 0u64; };
let start: u64 = a.pos;
for (a.pos < a.srclen) {
@@ -213,7 +205,7 @@ fn next_line(a: *asm_) (*u8, u64) = {
return buf, n;
};
fn skip_ws(p: *u8, off: u64, n: u64) u64 = {
fn skipws(p: *u8, off: u64, n: u64) u64 = {
let i: u64 = off;
for (i < n) {
if (p[i] != 32u8) { if (p[i] != 9u8) { return i; }; };
@@ -222,16 +214,16 @@ fn skip_ws(p: *u8, off: u64, n: u64) u64 = {
return i;
};
// parse_operand — parse one operand from p[off..n), populate out.
// parseoperand — parse one operand from p[off..n), populate out.
// Returns new offset (clamped to n on error).
fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
let off: u64 = skip_ws(p, off_in, n);
fn parseoperand(a: *asm_, p: *u8, offin: u64, n: u64, out: *aoperand) u64 = {
let off: u64 = skipws(p, offin, n);
out.atype = D_NONE;
out.reg = 0;
out.offset = 0i64;
let empty_str: str;
empty_str.ptr = nil; empty_str.len = 0;
out.asym = empty_str;
let empty: str;
empty.ptr = nil; empty.len = 0;
out.asym = empty;
if (off >= n) { return off; };
let c0: u8 = p[off];
@@ -240,7 +232,7 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
off += 1u64;
let v: i64;
let used: u64;
v, used = a_parsenum(p + off, n - off);
v, used = parsenum(p + off, n - off);
out.atype = D_CONST;
out.offset = v;
return off + used;
@@ -254,7 +246,7 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
if (p[off] == 41u8) { off = off; off += 0u64; } // no-op marker
else { off += 1u64; continue; };
let rn: u64 = off - rstart;
let r: i32 = reg_lookup(p + rstart, rn);
let r: i32 = reglookup(p + rstart, rn);
if (r == 0) { perr(a, "bad register in indirect"); return n; };
out.atype = D_INDIR;
out.reg = r;
@@ -275,7 +267,7 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
if (is_num) {
let v: i64;
let used: u64;
v, used = a_parsenum(p + off, n - off);
v, used = parsenum(p + off, n - off);
let after: u64 = off + used;
if (after < n) { if (p[after] == 40u8) { // '('
let rstart: u64 = after + 1u64;
@@ -284,7 +276,7 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
if (p[cur2] == 41u8) { cur2 = cur2; cur2 += 0u64; }
else { cur2 += 1u64; continue; };
let rn: u64 = cur2 - rstart;
let r: i32 = reg_lookup(p + rstart, rn);
let r: i32 = reglookup(p + rstart, rn);
if (r == 0) { perr(a, "bad register"); return n; };
out.atype = D_INDIR;
out.reg = r;
@@ -300,10 +292,10 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
};
// IDENT — register, symbol(SB), or branch label
if (a_isidstart(c0: i32)) {
if (isidstart(c0: i32)) {
let istart: u64 = off;
for (off < n) {
if (a_isidcont(p[off]: i32)) { off += 1u64; continue; };
if (isidcont(p[off]: i32)) { off += 1u64; continue; };
off = off; off += 0u64; // loop break
let in_: u64 = off - istart;
// IDENT(SB) — external
@@ -314,10 +306,10 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
if (p[cur2] == 41u8) { cur2 = cur2; cur2 += 0u64; }
else { cur2 += 1u64; continue; };
let rn: u64 = cur2 - rstart;
let r: i32 = reg_lookup(p + rstart, rn);
let r: i32 = reglookup(p + rstart, rn);
if (r == D_PSB) {
out.atype = D_EXTERN;
out.asym = dup_str(a.a, p + istart, in_);
out.asym = dupstr(a.a, p + istart, in_);
} else {
out.atype = D_INDIR;
out.reg = r;
@@ -328,21 +320,21 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
perr(a, "missing ')'");
return n;
};};
let r: i32 = reg_lookup(p + istart, in_);
let r: i32 = reglookup(p + istart, in_);
if (r != D_NONE) {
out.atype = r;
return off;
};
out.atype = D_BRANCH;
out.asym = dup_str(a.a, p + istart, in_);
out.asym = dupstr(a.a, p + istart, in_);
return off;
};
// EOF inside ident
let in_: u64 = off - istart;
let r: i32 = reg_lookup(p + istart, in_);
let r: i32 = reglookup(p + istart, in_);
if (r != D_NONE) { out.atype = r; return off; };
out.atype = D_BRANCH;
out.asym = dup_str(a.a, p + istart, in_);
out.asym = dupstr(a.a, p + istart, in_);
return off;
};
@@ -351,7 +343,7 @@ fn parse_operand(a: *asm_, p: *u8, off_in: u64, n: u64, out: *aoperand) u64 = {
};
// Append a fresh aprog to the list with given opcode and label.
fn add_prog(a: *asm_, opc: i32, lbl: str) *aprog = {
fn addprog(a: *asm_, opc: i32, lbl: str) *aprog = {
let pr: *aprog = amalloc(a.a, 96u64): *aprog;
pr.as_ = opc;
pr.line = a.line;
@@ -373,18 +365,18 @@ fn add_prog(a: *asm_, opc: i32, lbl: str) *aprog = {
return pr;
};
export fn a_parse(a: *asm_) i32 = {
export fn parse(a: *asm_) i32 = {
let pending: str;
pending.ptr = nil; pending.len = 0;
for (true) {
let line: *u8;
let n: u64;
line, n = next_line(a);
line, n = nextline(a);
if (line == nil) { return a.errs; };
// skip leading ws
let i: u64 = skip_ws(line, 0u64, n);
let i: u64 = skipws(line, 0u64, n);
// blank or //-comment
if (i >= n) { a.line += 1; continue; };
if (i + 1u64 < n) {
@@ -398,19 +390,19 @@ export fn a_parse(a: *asm_) i32 = {
// through to mnemonic parsing so e.g. `TEXT foo,$0` (which
// also starts with an idchar in column 0) gets parsed.
if (line[0u64] != 9u8) {
if (a_isidstart(line[i]: i32)) {
if (isidstart(line[i]: i32)) {
let q: u64 = i;
let scan_id: bool = true;
for (scan_id) {
if (q >= n) { scan_id = false; }
else { if (a_isidcont(line[q]: i32)) { q += 1u64; }
else { if (isidcont(line[q]: i32)) { q += 1u64; }
else { scan_id = false; }; };
};
if (q < n) { if (line[q] == 58u8) { // ':'
let nm: str = dup_str(a.a, line + i, q - i);
let nm: str = dupstr(a.a, line + i, q - i);
// Pending label gets a NOP prog so addresses pin.
if (pending.len > 0) {
let np: *aprog = add_prog(a, A_NOP, pending);
let np: *aprog = addprog(a, A_NOP, pending);
};
pending = nm;
a.line += 1;
@@ -431,7 +423,7 @@ export fn a_parse(a: *asm_) i32 = {
else { m += 1u64; }; }; };
};
let mlen: u64 = m - mstart;
let opc: i32 = opcode_lookup(line + mstart, mlen);
let opc: i32 = opcodelookup(line + mstart, mlen);
if (opc == 0) {
if (mlen > 0u64) {
perr(a, "unknown opcode");
@@ -440,11 +432,11 @@ export fn a_parse(a: *asm_) i32 = {
a.line += 1; continue;
};
let pr: *aprog = add_prog(a, opc, pending);
let pr: *aprog = addprog(a, opc, pending);
pending.ptr = nil; pending.len = 0;
// Skip ws after mnemonic
let r0: u64 = skip_ws(line, m, n);
let r0: u64 = skipws(line, m, n);
if (opc == A_TEXT) {
// TEXT name,$framesize — find first ',' as the end of name.
@@ -458,14 +450,14 @@ export fn a_parse(a: *asm_) i32 = {
};
let to_op: *aoperand = pr.to;
to_op.atype = D_EXTERN;
to_op.asym = dup_str(a.a, line + r0, comma_pos - r0);
to_op.asym = dupstr(a.a, line + r0, comma_pos - r0);
if (comma_pos < n) {
let p2: u64 = comma_pos + 1u64;
p2 = skip_ws(line, p2, n);
p2 = skipws(line, p2, n);
if (p2 < n) { if (line[p2] == 36u8) { p2 += 1u64; }; };
let v: i64;
let used: u64;
v, used = a_parsenum(line + p2, n - p2);
v, used = parsenum(line + p2, n - p2);
let from_op: *aoperand = pr.from;
from_op.atype = D_CONST;
from_op.offset = v;
@@ -485,7 +477,7 @@ export fn a_parse(a: *asm_) i32 = {
};
let to_op: *aoperand = pr.to;
to_op.atype = D_EXTERN;
to_op.asym = dup_str(a.a, line + r0, lparen - r0);
to_op.asym = dupstr(a.a, line + r0, lparen - r0);
// Skip past `(SB)` to land just after ')'.
let p2: u64 = lparen;
let scan_d2: bool = true;
@@ -571,10 +563,10 @@ export fn a_parse(a: *asm_) i32 = {
};
if (comma >= 0i64) {
let cu: u64 = comma: u64;
parse_operand(a, line, r0, cu, pr.from);
parse_operand(a, line + (cu + 1u64), 0u64, n - (cu + 1u64), pr.to);
parseoperand(a, line, r0, cu, pr.from);
parseoperand(a, line + (cu + 1u64), 0u64, n - (cu + 1u64), pr.to);
} else { if (r0 < n) {
parse_operand(a, line, r0, n, pr.to);
parseoperand(a, line, r0, n, pr.to);
};};
a.line += 1;

4
selfhost/cmd/w6a/types.ww
View File

@@ -149,8 +149,8 @@ type aprog = struct {
type asym = struct {
name: str,
defined: i32,
is_text: i32,
is_global: i32,
istext: i32,
isglobal: i32,
addr: u64,
idx: i32,
snext: *asym,