wash/ivy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

asm: implement assembler output file writing

Browse Source
This commit is contained in:
max 🍓
2024-12-10 22:27:26 +00:00
parent 06e12e4545
commit 9da6a5807a
5 changed files with 317 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

245
asm/assembler/assembler.c
View File

@@ -1,4 +1,5 @@
#include <ivy/asm/assembler.h>
#include <ivy/asm/bin.h>
#include <blue/core/queue.h>
#include <stdlib.h>
#include <string.h>
@@ -7,24 +8,29 @@
#include "assembler.h"
extern struct assembler_scope_type class_scope_type;
extern struct assembler_scope_type lambda_scope_type;
extern struct assembler_scope_type msgh_scope_type;
extern struct assembler_scope_type constpool_scope_type;
static const struct assembler_scope_type *scope_types[] = {
[IVY_ASM_SCOPE_CLASS] = &class_scope_type,
[IVY_ASM_SCOPE_LAMBDA] = &lambda_scope_type,
[IVY_ASM_SCOPE_MSGH] = &msgh_scope_type,
[IVY_ASM_SCOPE_CONSTPOOL] = &constpool_scope_type,
};
static const size_t nr_scope_types = sizeof scope_types / sizeof scope_types[0];
struct ivy_assembler {
FILE *as_fp;
struct assembler_scope *as_scope;
struct asm_table_entry {
b_queue_entry e_entry;
struct ivy_bin_table_entry e_data;
};
enum ivy_static ivy_assembler_create(FILE *fp, struct ivy_assembler **as)
struct ivy_assembler {
struct assembler_scope *as_scope;
b_queue as_table;
FILE *as_data;
size_t as_data_offset;
FILE *as_xdat;
extended_data_key as_next_xdata_key;
};
enum ivy_status ivy_assembler_create(FILE *fp, struct ivy_assembler **as)
{
struct ivy_assembler *out = malloc(sizeof *out);
@@ -34,19 +40,122 @@ enum ivy_static ivy_assembler_create(FILE *fp, struct ivy_assembler **as)
memset(out, 0x0, sizeof *out);
out->as_fp = fp;
out->as_data = fp;
out->as_xdat = tmpfile();
struct ivy_bin_header header = {0};
fseek(fp, 0, SEEK_SET);
fwrite(&header, sizeof header, 1, fp);
*as = out;
return IVY_OK;
}
void ivy_assembler_destroy(struct ivy_assembler *as)
static void pad(struct ivy_assembler *as, unsigned int boundary)
{
while ((as->as_data_offset % boundary) != 0) {
fputc(0, as->as_data);
as->as_data_offset++;
}
}
enum ivy_status ivy_assembler_finish(struct ivy_assembler *as)
{
const size_t buf_len = 4096;
size_t xdat_len = as->as_next_xdata_key;
fseek(as->as_xdat, 0, SEEK_SET);
char *buf = malloc(buf_len);
if (!buf) {
return IVY_ERR_NO_MEMORY;
}
pad(as, 16);
struct ivy_bin_table_entry xdat = {0};
xdat.e_offset = b_i64_htob(as->as_data_offset);
xdat.e_size = b_i32_htob(xdat_len);
xdat.e_type = b_i32_htob(IVY_TABLE_XDAT);
while (1) {
size_t r = fread(buf, 1, buf_len, as->as_xdat);
fwrite(buf, 1, r, as->as_xdat);
as->as_data_offset += r;
if (r == buf_len) {
continue;
}
if (ferror(as->as_xdat)) {
free(buf);
return IVY_ERR_IO_FAILURE;
}
break;
}
free(buf);
unsigned int nr_table_entries = 0;
struct ivy_bin_header header = {0};
header.h_table_offset = b_i64_htob(as->as_data_offset);
header.h_table_len = b_i16_htob(0);
header.h_magic = b_i32_htob(IVY_BIN_MAGIC);
pad(as, 16);
b_queue_iterator it = {0};
b_queue_foreach (&it, &as->as_table) {
struct asm_table_entry *e = b_unbox(struct asm_table_entry, it.entry, e_entry);
size_t w = fwrite(&e->e_data, 1, sizeof e->e_data, as->as_data);
if (w < sizeof e->e_data) {
return IVY_ERR_IO_FAILURE;
}
nr_table_entries++;
}
fwrite(&xdat, 1, sizeof xdat, as->as_data);
nr_table_entries++;
header.h_table_len = b_i16_htob(nr_table_entries * sizeof(struct ivy_bin_table_entry));
fseek(as->as_data, 0, SEEK_SET);
fwrite(&header, 1, sizeof header, as->as_data);
fclose(as->as_xdat);
free(as);
return IVY_OK;
}
size_t assembler_write_data(struct ivy_assembler *as, const void *p, size_t len)
{
size_t offset = as->as_data_offset;
fwrite(p, 1, len, as->as_data);
as->as_data_offset += len;
return offset;
}
extended_data_key assembler_write_extended_data(struct ivy_assembler *as, const void *p, size_t len)
{
extended_data_key key = as->as_next_xdata_key;
fwrite(p, 1, len, as->as_xdat);
as->as_next_xdata_key += len;
return key;
}
enum ivy_status ivy_assembler_begin_scope(
struct ivy_assembler *as, enum ivy_assembler_scope_type type)
struct ivy_assembler *as, enum ivy_assembler_scope_type type,
ivy_assembler_attrib_table attrib)
{
if (type < 0 || type >= nr_scope_types) {
return IVY_ERR_NOT_SUPPORTED;
@@ -66,11 +175,18 @@ enum ivy_status ivy_assembler_begin_scope(
return IVY_ERR_NO_MEMORY;
}
while ((as->as_data_offset % 16) != 0) {
fputc(0, as->as_data);
as->as_data_offset++;
}
scope->s_ops = type_info;
scope->s_type = type;
scope->s_start_offset = as->as_data_offset;
as->as_scope = scope;
if (type_info->s_init_scope) {
type_info->s_init_scope(as, scope);
type_info->s_init_scope(as, scope, attrib);
}
return IVY_OK;
@@ -91,14 +207,47 @@ enum ivy_status ivy_assembler_end_scope(struct ivy_assembler *as)
type_info->s_finish_scope(as, as->as_scope);
}
struct asm_table_entry *entry = malloc(sizeof *entry);
if (!entry) {
return IVY_ERR_NO_MEMORY;
}
memset(entry, 0x0, sizeof *entry);
entry->e_data.e_offset = b_i64_htob(as->as_scope->s_start_offset);
entry->e_data.e_size = b_i32_htob(as->as_data_offset - as->as_scope->s_start_offset);
switch (as->as_scope->s_type) {
case IVY_ASM_SCOPE_CLASS:
entry->e_data.e_type = b_i32_htob(IVY_TABLE_CLASS);
break;
case IVY_ASM_SCOPE_LAMBDA:
entry->e_data.e_type = b_i32_htob(IVY_TABLE_LAMBDA);
break;
case IVY_ASM_SCOPE_MSGH:
entry->e_data.e_type = b_i32_htob(IVY_TABLE_MSGH);
break;
case IVY_ASM_SCOPE_CONSTPOOL:
entry->e_data.e_type = b_i32_htob(IVY_TABLE_POOL);
break;
case IVY_ASM_SCOPE_IMPORT:
entry->e_data.e_type = b_i32_htob(IVY_TABLE_IMPORT);
break;
default:
break;
}
b_queue_push_back(&as->as_table, &entry->e_entry);
free(as->as_scope);
as->as_scope = NULL;
return IVY_OK;
}
enum ivy_status ivy_assembler_put_string(
struct ivy_assembler *as, int index, const char *s)
enum ivy_status ivy_assembler_put_pval(
struct ivy_assembler *as, enum ivy_assembler_pval_type type,
unsigned long index, const void *val)
{
struct assembler_scope *scope = as->as_scope;
@@ -107,15 +256,16 @@ enum ivy_status ivy_assembler_put_string(
}
const struct assembler_scope_type *type_info = scope->s_ops;
if (!type_info || !type_info->s_put_string) {
if (!type_info || !type_info->s_put_pval) {
return IVY_ERR_NOT_SUPPORTED;
}
return type_info->s_put_string(as, scope, index, s);
return type_info->s_put_pval(as, scope, type, index, val);
}
enum ivy_status ivy_assembler_put_ident(
struct ivy_assembler *as, int index, const char *s)
enum ivy_status ivy_assembler_put_xval(
struct ivy_assembler *as, enum ivy_assembler_xval_type type,
const ivy_assembler_attrib_table attrib)
{
struct assembler_scope *scope = as->as_scope;
@@ -124,62 +274,11 @@ enum ivy_status ivy_assembler_put_ident(
}
const struct assembler_scope_type *type_info = scope->s_ops;
if (!type_info || !type_info->s_put_string) {
if (!type_info || !type_info->s_put_xval) {
return IVY_ERR_NOT_SUPPORTED;
}
return type_info->s_put_string(as, scope, index, s);
}
enum ivy_status ivy_assembler_put_atom(
struct ivy_assembler *as, int index, const char *s)
{
struct assembler_scope *scope = as->as_scope;
if (!scope) {
return IVY_ERR_NOT_SUPPORTED;
}
const struct assembler_scope_type *type_info = scope->s_ops;
if (!type_info || !type_info->s_put_atom) {
return IVY_ERR_NOT_SUPPORTED;
}
return type_info->s_put_atom(as, scope, index, s);
}
enum ivy_status ivy_assembler_put_selector(
struct ivy_assembler *as, int index, struct ivy_selector *sel)
{
struct assembler_scope *scope = as->as_scope;
if (!scope) {
return IVY_ERR_NOT_SUPPORTED;
}
const struct assembler_scope_type *type_info = scope->s_ops;
if (!type_info || !type_info->s_put_selector) {
return IVY_ERR_NOT_SUPPORTED;
}
return type_info->s_put_selector(as, scope, index, sel);
}
enum ivy_status ivy_assembler_put_mvar(
struct ivy_assembler *as, int index, const char *name)
{
struct assembler_scope *scope = as->as_scope;
if (!scope) {
return IVY_ERR_NOT_SUPPORTED;
}
const struct assembler_scope_type *type_info = scope->s_ops;
if (!type_info || !type_info->s_put_mvar) {
return IVY_ERR_NOT_SUPPORTED;
}
return type_info->s_put_mvar(as, scope, index, name);
return type_info->s_put_xval(as, scope, type, attrib);
}
enum ivy_status ivy_assembler_put_instr(