Hojun-Cho
d998425391
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.
118 lines
2.7 KiB
C
118 lines
2.7 KiB
C
/*
|
|
* a.h — w6a-private header. Modelled on Plan 9 cmd/6a/a.h, trimmed
|
|
* to the instruction subset that w6c emits.
|
|
*
|
|
* w6a is line-oriented and has no preprocessor: each non-blank, non-
|
|
* label line is one instruction. We read the whole file into a list
|
|
* of `Aprog`s, then encode and emit ELF64.
|
|
*/
|
|
#ifndef SIX_A_H
|
|
#define SIX_A_H
|
|
|
|
#include "6.out.h"
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
typedef int8_t i8;
|
|
typedef int16_t i16;
|
|
typedef int32_t i32;
|
|
typedef int64_t i64;
|
|
typedef uint8_t u8;
|
|
typedef uint16_t u16;
|
|
typedef uint32_t u32;
|
|
typedef uint64_t u64;
|
|
|
|
typedef struct Aoperand Aoperand;
|
|
typedef struct Aprog Aprog;
|
|
typedef struct Asym Asym;
|
|
typedef struct Areloc Areloc;
|
|
typedef struct Asm Asm;
|
|
|
|
struct Aoperand {
|
|
int type; /* D_NONE, D_AX..D_R15, D_CONST, D_INDIR, D_EXTERN, D_BRANCH */
|
|
int reg; /* base register for D_INDIR */
|
|
i64 offset; /* immediate or displacement */
|
|
const char *sym;
|
|
};
|
|
|
|
struct Aprog {
|
|
int as; /* opcode (A_*) */
|
|
Aoperand from;
|
|
Aoperand to;
|
|
int line;
|
|
const char *label; /* label preceding this prog, if any */
|
|
Aprog *link;
|
|
/* for A_DATA: raw payload bytes interned by the parser */
|
|
u8 *bytes;
|
|
u64 nbytes;
|
|
};
|
|
|
|
struct Asym {
|
|
const char *name;
|
|
int defined; /* 1 if we own its address */
|
|
int is_text; /* if 1, address is in .text */
|
|
int is_data; /* if 1, address is in .data (mutually exclusive with is_text) */
|
|
int is_global; /* exported (TEXT) */
|
|
u64 addr; /* offset within section if defined */
|
|
int idx; /* ELF symtab index, filled at emit time */
|
|
Asym *next;
|
|
};
|
|
|
|
struct Areloc {
|
|
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;
|
|
};
|
|
|
|
struct Asm {
|
|
/* parser state */
|
|
const char *file;
|
|
const char *src;
|
|
u64 srclen;
|
|
u64 pos;
|
|
int line;
|
|
|
|
/* program list */
|
|
Aprog *head, *tail;
|
|
|
|
/* output text section */
|
|
u8 *text;
|
|
u64 textcap, textlen;
|
|
|
|
/* output data section (writable). Empty unless any DATAW directive
|
|
* was seen; in that case obj.c emits an extra .data PROGBITS
|
|
* section with SHF_WRITE. */
|
|
u8 *data;
|
|
u64 datacap, datalen;
|
|
|
|
/* symbols */
|
|
Asym *syms;
|
|
Areloc *relocs;
|
|
|
|
int errs;
|
|
};
|
|
|
|
/* lex.c / parse.c */
|
|
void a_init(Asm*, const char *file, const char *src, u64 len);
|
|
int a_parse(Asm*);
|
|
|
|
/* asm.c */
|
|
int a_encode(Asm*);
|
|
|
|
/* obj.c */
|
|
int a_emit_elf(Asm*, FILE *out);
|
|
|
|
/* helpers */
|
|
Asym *a_intern(Asm*, const char *name);
|
|
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
|