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

w6a+w6l: DATAR directive for absolute-address relocs in .data

Browse Source 
Unblock literal initialisers for str/slice/struct globals by wiring
an R_X86_64_64 relocation kind through both assembler and static
linker.

w6a:
  - new A_DATAR directive, syntax `DATAR slot+off(SB),target(SB)`,
    records an R_X86_64_64 reloc at slot+off in .data pointing at
    target. The slot must be pre-defined by a prior DATAW;
  - parse_operand learned the `name+disp(SB)` shape so the slot's
    byte offset can be addressed explicitly;
  - Areloc carries a `section` flag (0=.text / 1=.data) and obj.c
    splits the reloc list into .rela.text and .rela.data, emitting
    the latter conditionally with sh_info pointing at .data.

w6l:
  - Lrel grows the same `section` flag; obj.c loads `.rela.data`
    sections into the global reloc list with offsets shifted by
    each input's data_off;
  - pass.c handles R_X86_64_64: target VA is data_va+sym.val for
    in_data symbols (else text_va+sym.val), addend is added, and
    the 8-byte slot is patched in l->data (or l->text).

Inputs without DATAR are unaffected — bootstrap, 991 (selfhost .o
diff) and 992 (selfhost exe diff) keep their byte-identical
output. 520_datar covers the new path: asm a DATAW+DATAR pair,
verify .rela.data has exactly one R_X86_64_64 entry, link, run,
confirm the relocated pointer feeds a 5-byte write that prints
"hello".

Selfhost mirror + w6c emission for str/slice/struct literal init
land in follow-ups.
This commit is contained in:
Hojun-Cho
2026-05-12 12:45:11 +09:00
parent 00d1120441
commit d998425391
11 changed files with 353 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/w6a/a.h
View File

@@ -60,8 +60,9 @@ struct Asym {
};
struct Areloc {
u64 off; /* offset within .text where relocation lands */
int kind; /* R_X86_64_PLT32 (4), R_X86_64_PC32 (2) */
u64 off; /* offset within the relocation's section */
int section;/* 0 = .text (most relocs), 1 = .data (DATAR) */
int kind; /* R_X86_64_64 (1), R_X86_64_PC32 (2), R_X86_64_PLT32 (4) */
Asym *sym;
i64 addend;
Areloc *next;
@@ -111,5 +112,6 @@ void a_emit_byte(Asm*, u8);
void a_emit_u32(Asm*, u32);
void a_emit_data_byte(Asm*, u8);
void a_addreloc(Asm*, u64 off, int kind, Asym *s, i64 add);
void a_addreloc_data(Asm*, u64 off, int kind, Asym *s, i64 add);
#endif

37
cmd/w6a/asm.c
View File

@@ -70,6 +70,23 @@ a_addreloc(Asm *a, u64 off, int kind, Asym *s, i64 add)
{
Areloc *r = calloc(1, sizeof *r);
r->off = off;
r->section = 0; /* .text */
r->kind = kind;
r->sym = s;
r->addend = add;
r->next = a->relocs;
a->relocs = r;
}
/* Record a relocation that lives in the .data section. Used by
* DATAR to patch a 64-bit slot with a symbol's runtime VA. obj.c
* separates these into .rela.data when emitting the .o. */
void
a_addreloc_data(Asm *a, u64 off, int kind, Asym *s, i64 add)
{
Areloc *r = calloc(1, sizeof *r);
r->off = off;
r->section = 1; /* .data */
r->kind = kind;
r->sym = s;
r->addend = add;
@@ -335,6 +352,26 @@ a_encode(Asm *a)
a_emit_data_byte(a, p->bytes[i]);
break;
}
case A_DATAR: {
/* DATAR slot+off(SB), target(SB) — record an
* R_X86_64_64 relocation at slot+off in .data
* pointing at target. The slot must already be
* defined by a prior DATAW (which emitted zero
* placeholder bytes the linker will overwrite). */
Asym *holder = a_intern(a, p->from.sym);
if (!holder->defined || !holder->is_data) {
fprintf(stderr,
"w6a: line %d: DATAR slot %s not yet defined as DATAW\n",
p->line, p->from.sym);
a->errs++;
break;
}
Asym *target = a_intern(a, p->to.sym);
u64 reloff = holder->addr + (u64)p->from.offset;
a_addreloc_data(a, reloff, 1 /* R_X86_64_64 */,
target, 0);
break;
}
case A_RET:
a_emit_byte(a, 0xC3);
break;

56
cmd/w6a/obj.c
View File

@@ -111,27 +111,42 @@ typedef struct {
int
a_emit_elf(Asm *a, FILE *f)
{
Buf shstr = {0}, str = {0}, sym = {0}, rela = {0};
Buf shstr = {0}, str = {0}, sym = {0}, rela = {0}, relad = {0};
stput(&shstr, ""); /* idx 0 = empty */
stput(&str, "");
const int has_data = (a->datalen > 0);
int has_data_relocs = 0;
for (Areloc *r = a->relocs; r; r = r->next) {
if (r->section == 1) { has_data_relocs = 1; break; }
}
/* Section indices.
* Without data: 1=.text, 2=.rela.text, 3=.symtab, 4=.strtab, 5=.shstrtab
* With data: 1=.text, 2=.rela.text, 3=.data, 4=.symtab, 5=.strtab, 6=.shstrtab
* Without data, without data-relocs:
* 1=.text, 2=.rela.text, 3=.symtab, 4=.strtab, 5=.shstrtab
* With data, no data-relocs:
* 1=.text, 2=.rela.text, 3=.data, 4=.symtab, 5=.strtab, 6=.shstrtab
* With data + data-relocs:
* 1=.text, 2=.rela.text, 3=.data, 4=.rela.data, 5=.symtab,
* 6=.strtab, 7=.shstrtab
*/
const u16 SH_TEXT = 1;
const u16 SH_DATA = has_data ? 3 : 0;
const u16 SH_SYMTAB = has_data ? 4 : 3;
const u16 SH_STRTAB = has_data ? 5 : 4;
const u16 SH_SHSTR = has_data ? 6 : 5;
const u16 SH_RELAD = (has_data && has_data_relocs) ? 4 : 0;
const u16 SH_SYMTAB = has_data
? (has_data_relocs ? 5 : 4)
: 3;
const u16 SH_STRTAB = (u16)(SH_SYMTAB + 1);
const u16 SH_SHSTR = (u16)(SH_STRTAB + 1);
/* Section name offsets. Append .data's name only when used so the
* .shstrtab buffer stays byte-identical for the no-DATAW case. */
* .shstrtab buffer stays byte-identical for the no-DATAW case.
* Same for .rela.data — only present when data relocs exist. */
u32 shn_text = stput(&shstr, ".text");
u32 shn_rela = stput(&shstr, ".rela.text");
u32 shn_data = has_data ? stput(&shstr, ".data") : 0;
u32 shn_relad = (has_data && has_data_relocs)
? stput(&shstr, ".rela.data") : 0;
u32 shn_symtab = stput(&shstr, ".symtab");
u32 shn_strtab = stput(&shstr, ".strtab");
u32 shn_shstrtab = stput(&shstr, ".shstrtab");
@@ -168,13 +183,14 @@ a_emit_elf(Asm *a, FILE *f)
s->idx = idx++;
}
/* Build relocations */
/* Build relocations — split into two buffers so we can emit
* .rela.text and (conditionally) .rela.data separately. */
for (Areloc *r = a->relocs; r; r = r->next) {
Rela64 re;
re.r_offset = r->off;
re.r_info = ELF64_R_INFO((u64)r->sym->idx, (u64)r->kind);
re.r_addend = r->addend;
bput(&rela, &re, sizeof re);
bput(r->section == 1 ? &relad : &rela, &re, sizeof re);
}
/* Layout offsets in the file */
@@ -182,13 +198,16 @@ a_emit_elf(Asm *a, FILE *f)
u64 off_text = off; off += a->textlen;
u64 off_rela = off; off += rela.n;
u64 off_data = off; if (has_data) off += a->datalen;
u64 off_relad = off; if (has_data && has_data_relocs) off += relad.n;
u64 off_sym = off; off += sym.n;
u64 off_str = off; off += str.n;
u64 off_shstr= off; off += shstr.n;
/* align to 8 */
while (off % 8) off++;
u64 off_shdr = off;
const int NSECT = has_data ? 7 : 6; /* null + reals */
const int NSECT = has_data
? (has_data_relocs ? 8 : 7)
: 6; /* null + reals */
Ehdr eh = {0};
memcpy(eh.e_ident, "\x7f""ELF", 4);
@@ -208,6 +227,7 @@ a_emit_elf(Asm *a, FILE *f)
if (a->textlen) fwrite(a->text, 1, a->textlen, f);
fwrite(rela.p, 1, rela.n, f);
if (has_data) fwrite(a->data, 1, a->datalen, f);
if (has_data && has_data_relocs) fwrite(relad.p, 1, relad.n, f);
fwrite(sym.p, 1, sym.n, f);
fwrite(str.p, 1, str.n, f);
fwrite(shstr.p, 1, shstr.n, f);
@@ -249,6 +269,20 @@ a_emit_elf(Asm *a, FILE *f)
fwrite(&sh, 1, sizeof sh, f);
}
if (has_data && has_data_relocs) {
memset(&sh, 0, sizeof sh);
sh.sh_name = shn_relad;
sh.sh_type = SHT_RELA;
sh.sh_flags = SHF_INFO_LINK;
sh.sh_offset = off_relad;
sh.sh_size = relad.n;
sh.sh_link = SH_SYMTAB;
sh.sh_info = SH_DATA; /* applies to .data */
sh.sh_addralign = 8;
sh.sh_entsize = sizeof(Rela64);
fwrite(&sh, 1, sizeof sh, f);
}
memset(&sh, 0, sizeof sh);
sh.sh_name = shn_symtab;
sh.sh_type = SHT_SYMTAB;
@@ -276,6 +310,6 @@ a_emit_elf(Asm *a, FILE *f)
sh.sh_addralign = 1;
fwrite(&sh, 1, sizeof sh, f);
free(shstr.p); free(str.p); free(sym.p); free(rela.p);
free(shstr.p); free(str.p); free(sym.p); free(rela.p); free(relad.p);
return 0;
}

13
cmd/w6a/parse.c
View File

@@ -121,6 +121,7 @@ opcode_lookup(const char *m)
{ "TEXT", A_TEXT },
{ "DATA", A_DATA },
{ "DATAW", A_DATAW },
{ "DATAR", A_DATAR },
{ NULL, 0 }
};
for (int i = 0; tab[i].m; i++)
@@ -211,6 +212,17 @@ parse_operand(Asm *a, const char *s, Aoperand *out)
while (a_isidcont((unsigned char)*s) && n < 63) buf[n++] = *s++;
buf[n] = 0;
/* Optional `+disp` between the ident and `(SB)`. Used by
* DATAR to address bytes inside an existing .data slot
* (e.g. `DATAR s+8(SB),...`). */
i64 sym_disp = 0;
if (*s == '+') {
s++;
char *end;
sym_disp = a_parsenum(s, &end);
s = end;
}
/* ID(SB) means external symbol */
if (*s == '(') {
char rbuf[8] = {0};
@@ -223,6 +235,7 @@ parse_operand(Asm *a, const char *s, Aoperand *out)
if (r == D_PSB) {
out->type = D_EXTERN;
out->sym = strdup(buf);
out->offset = sym_disp;
return 0;
}
out->type = D_INDIR;

3
cmd/w6c/6.out.h
View File

@@ -41,6 +41,9 @@ enum {
A_TEXT,
A_DATA,
A_DATAW, /* writable DATA: lands in .data (RW) instead of .text */
A_DATAR, /* reloc-only: patch a 64-bit slot in .data with a
* symbol's runtime VA. Pairs with a prior DATAW
* that left zero placeholder bytes. */
A_GLOBL,
A_END,

1
cmd/w6c/txt.c
View File

@@ -26,6 +26,7 @@ anames(int op)
case A_TEXT: return "TEXT";
case A_DATA: return "DATA";
case A_DATAW: return "DATAW";
case A_DATAR: return "DATAR";
case A_GLOBL: return "GLOBL";
case A_END: return "END";
case A_MOVQ: return "MOVQ";

3
cmd/w6l/l.h
View File

@@ -48,7 +48,8 @@ struct Lsym {
};
struct Lrel {
u64 off; /* offset within combined .text */
u64 off; /* offset within the relocation's section */
int section; /* 0 = .text, 1 = .data */
int kind; /* R_X86_64_* */
Lsym *sym;
i64 addend;

26
cmd/w6l/obj.c
View File

@@ -278,9 +278,10 @@ load_image(Lnk *l, const char *path, u8 *buf, u64 len)
if (eh->e_shstrndx >= eh->e_shnum) { free(buf); return -1; }
const char *shstr = (const char *)(buf + sh[eh->e_shstrndx].sh_offset);
/* find .text, .data (optional), .symtab, .strtab, .rela.text */
/* find .text, .data (optional), .symtab, .strtab, .rela.text,
* .rela.data (optional) */
int idx_text = -1, idx_data = -1, idx_symtab = -1, idx_strtab = -1;
int idx_rela = -1;
int idx_rela = -1, idx_relad = -1;
for (u16 i = 0; i < eh->e_shnum; i++) {
const char *nm = shstr + sh[i].sh_name;
if (sh[i].sh_type == SHT_PROGBITS && strcmp(nm, ".text") == 0)
@@ -291,6 +292,8 @@ load_image(Lnk *l, const char *path, u8 *buf, u64 len)
idx_symtab = i;
else if (sh[i].sh_type == SHT_RELA && strcmp(nm, ".rela.text") == 0)
idx_rela = i;
else if (sh[i].sh_type == SHT_RELA && strcmp(nm, ".rela.data") == 0)
idx_relad = i;
}
if (idx_text < 0 || idx_symtab < 0) {
fprintf(stderr, "w6l: %s: missing .text or .symtab\n", path);
@@ -356,6 +359,25 @@ load_image(Lnk *l, const char *path, u8 *buf, u64 len)
for (u64 i = 0; i < nrel; i++) {
Lrel *r = calloc(1, sizeof *r);
r->off = ob->text_off + rt[i].r_offset;
r->section = 0;
r->kind = (int)ELF64_R_TYPE(rt[i].r_info);
u32 sidx = ELF64_R_SYM(rt[i].r_info);
r->sym = (sidx < nsyms) ? map[sidx] : NULL;
r->addend = rt[i].r_addend;
r->next = l->rels;
l->rels = r;
}
}
/* per-object: collect data relocations from .rela.data. The
* .data section in the .o starts at a per-object 0; we shift
* by ob->data_off so r->off indexes the combined .data buffer. */
if (idx_relad >= 0) {
Rela64 *rt = (Rela64 *)(buf + sh[idx_relad].sh_offset);
u64 nrel = sh[idx_relad].sh_size / sizeof(Rela64);
for (u64 i = 0; i < nrel; i++) {
Lrel *r = calloc(1, sizeof *r);
r->off = ob->data_off + rt[i].r_offset;
r->section = 1;
r->kind = (int)ELF64_R_TYPE(rt[i].r_info);
u32 sidx = ELF64_R_SYM(rt[i].r_info);
r->sym = (sidx < nsyms) ? map[sidx] : NULL;

28
cmd/w6l/pass.c
View File

@@ -13,6 +13,7 @@
#include <stdio.h>
#include <string.h>
#define R_X86_64_64 1
#define R_X86_64_PC32 2
#define R_X86_64_PLT32 4
@@ -67,6 +68,13 @@ patch_u32(u8 *p, u32 v)
p[3] = (u8)((v >> 24) & 0xff);
}
static void
patch_u64(u8 *p, u64 v)
{
for (int i = 0; i < 8; i++)
p[i] = (u8)((v >> (i * 8)) & 0xff);
}
int
l_relocate(Lnk *l, u64 text_va, u64 data_va)
{
@@ -76,17 +84,31 @@ l_relocate(Lnk *l, u64 text_va, u64 data_va)
* PLT's virtual address is known. */
if (r->sym->is_dyn) continue;
if (!r->sym->defined) continue;
u64 sym_va = r->sym->in_data
? data_va + r->sym->val
: text_va + r->sym->val;
switch (r->kind) {
case R_X86_64_PC32:
case R_X86_64_PLT32: {
/* PC-relative 32-bit displacement; lands in .text. */
u64 site = text_va + r->off;
u64 sym_va = r->sym->in_data
? data_va + r->sym->val
: text_va + r->sym->val;
i64 rel = (i64)sym_va - (i64)site + r->addend;
patch_u32(l->text + r->off, (u32)(i32)rel);
break;
}
case R_X86_64_64: {
/* Absolute 64-bit: patch the 8-byte slot at the
* given offset within the section. Currently only
* used for data slots holding symbol addresses
* (DATAR). */
u64 v = (u64)((i64)sym_va + r->addend);
if (r->section == 1) {
patch_u64(l->data + r->off, v);
} else {
patch_u64(l->text + r->off, v);
}
break;
}
default:
fprintf(stderr, "w6l: unsupported reloc kind %d\n",
r->kind);