freya/mips
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

relocation table hell

Browse source
This commit is contained in:
Freya Murphy 2024-09-09 20:48:08 -04:00
parent d079aac905
commit 0ff948af3d
Signed by: freya
GPG key ID: 744AB800E383AE52
13 changed files with 1315 additions and 821 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
config.mk
View file

@ -5,7 +5,7 @@ LD=cc
CFLAGS += -pipe CFLAGS += -pipe
CFLAGS += -Wall -Wextra -pedantic CFLAGS += -Wall -Wextra -pedantic
CFLAGS += -O3 -g CFLAGS += -O0 -g
# ======================== CONFIG OPTIONS == # ======================== CONFIG OPTIONS ==
# #

8
include/mips32.h
View file

@ -117,6 +117,7 @@ enum mips32_instruction_type {
MIPS32_INS_SRLV, MIPS32_INS_SRLV,
MIPS32_INS_SUB, MIPS32_INS_SUB,
MIPS32_INS_SUBU, MIPS32_INS_SUBU,
MIPS32_INS_SYSCALL,
MIPS32_INS_OR, MIPS32_INS_OR,
MIPS32_INS_ORI, MIPS32_INS_ORI,
MIPS32_INS_NOR, MIPS32_INS_NOR,
@ -447,6 +448,10 @@ MIPS32_INS(SUB, R, .op = MIPS32_OP_SPECIAL, .funct = MIPS32_FUNCT_SUB)
#define MIPS32_FUNCT_SUBU 0b100011 #define MIPS32_FUNCT_SUBU 0b100011
MIPS32_INS(SUBU, R, .op = MIPS32_OP_SPECIAL, .funct = MIPS32_FUNCT_SUBU) MIPS32_INS(SUBU, R, .op = MIPS32_OP_SPECIAL, .funct = MIPS32_FUNCT_SUBU)
/* SYSCALL - syscall */
#define MIPS32_FUNCT_SYSCALL 0b001100
MIPS32_INS(SYSCALL, R, .op = MIPS32_OP_SPECIAL, .funct = MIPS32_FUNCT_SYSCALL)
/* OR - or */ /* OR - or */
#define MIPS32_FUNCT_OR 0b100101 #define MIPS32_FUNCT_OR 0b100101
MIPS32_INS(OR, R, .op = MIPS32_OP_SPECIAL, .funct = MIPS32_FUNCT_OR) MIPS32_INS(OR, R, .op = MIPS32_OP_SPECIAL, .funct = MIPS32_FUNCT_OR)
@ -478,11 +483,14 @@ enum mips32_directive_type {
MIPS32_DIRECTIVE_HALF, MIPS32_DIRECTIVE_HALF,
MIPS32_DIRECTIVE_BYTE, MIPS32_DIRECTIVE_BYTE,
MIPS32_DIRECTIVE_SECTION, MIPS32_DIRECTIVE_SECTION,
MIPS32_DIRECTIVE_EXTERN,
MIPS32_DIRECTIVE_GLOBL,
}; };
/* mip32 directive */ /* mip32 directive */
struct mips32_directive { struct mips32_directive {
enum mips32_directive_type type; enum mips32_directive_type type;
uint32_t len; // used for words, halfs, bytes
union { union {
uint16_t align; uint16_t align;
uint16_t space; uint16_t space;

41
masm/asm.c Normal file
View file

@ -0,0 +1,41 @@
#include <merror.h>
#include <stdlib.h>
#include "asm.h"
int assembler_init(struct assembler *asm, const char *path)
{
if (lexer_init(path, &asm->lexer))
return M_ERROR;
if (parser_init(&asm->lexer, &asm->parser)) {
lexer_free(&asm->lexer);
return M_ERROR;
}
if (strtbl_init(&asm->shstr_tbl)) {
parser_free(&asm->parser);
lexer_free(&asm->lexer);
return M_ERROR;
}
if (strtbl_init(&asm->str_tbl)) {
strtbl_free(&asm->shstr_tbl);
parser_free(&asm->parser);
lexer_free(&asm->lexer);
return M_ERROR;
}
asm->meta = NULL;
return M_SUCCESS;
}
void assembler_free(struct assembler *asm)
{
strtbl_free(&asm->str_tbl);
strtbl_free(&asm->shstr_tbl);
parser_free(&asm->parser);
lexer_free(&asm->lexer);
free(asm->meta);
}

33
masm/asm.h
View file

@ -5,13 +5,16 @@
#include <stddef.h> #include <stddef.h>
#include "lex.h"
#include "parse.h"
struct str_table { struct str_table {
char *ptr; char *ptr;
size_t size; size_t size;
}; };
/* initalize a string table */ /* initalize a string table */
void strtbl_init(struct str_table *str_tbl); int strtbl_init(struct str_table *str_tbl);
/* free a string table */ /* free a string table */
void strtbl_free(struct str_table *str_tbl); void strtbl_free(struct str_table *str_tbl);
@ -22,11 +25,29 @@ int strtbl_get_str(struct str_table *str_tbl, const char *str, size_t *res);
/* get or append a string into the string table */ /* get or append a string into the string table */
int strtbl_write_str(struct str_table *str_tbl, const char *str, size_t *res); int strtbl_write_str(struct str_table *str_tbl, const char *str, size_t *res);
struct assembler { struct section_meta {
struct parser *parser; void *reltbl;
struct str_table str_tbl; uint32_t reltbl_len;
uint32_t reltbl_idx; // reltbl idx in shdr
uint32_t shdr_idx; // sec idx in shdr
uint32_t v_addr;
}; };
struct assembler {
struct lexer lexer;
struct parser parser;
struct str_table shstr_tbl;
struct str_table str_tbl;
struct section_meta *meta;
size_t shstrtbl_idx;
size_t strtbl_idx;
size_t symtbl_idx;
};
int assembler_init(struct assembler *asm, const char *path);
void assembler_free(struct assembler *asm);
/* assemble a mips32 file*/ /* assemble a mips32 file*/
int assemble_file_mips32(char *path); int assemble_file_mips32(char *path);

849
masm/asm_mips32.c
View file

@ -14,352 +14,665 @@
extern char *current_file; extern char *current_file;
#define SHDR_SYMTBL 0 static int handle_directive(struct assembler *asm,
#define SHDR_STRTBL 1 struct mips32_directive *directive)
#define SHDR_SECTIONS 2
static int parse_file(struct parser *parser)
{ {
switch (directive->type) {
case MIPS32_DIRECTIVE_SECTION: {
struct section_table *sec_tbl = &asm->parser.sec_tbl;
struct section *sec;
if (sectbl_get(sec_tbl, &sec, directive->name)
== M_SUCCESS) {
sec_tbl->current = sec;
break;
}
if (sectbl_alloc(sec_tbl, &sec, directive->name))
return M_ERROR;
sec_tbl->current = sec;
break;
}
case MIPS32_DIRECTIVE_ALIGN: {
asm->parser.sec_tbl.current->alignment =
1 << directive->align;
break;
}
case MIPS32_DIRECTIVE_SPACE: {
struct section_entry entry;
entry.type = ENT_NO_DATA;
entry.size = directive->space;
if (sec_push(asm->parser.sec_tbl.current, entry))
return M_ERROR;
break;
}
case MIPS32_DIRECTIVE_WORD: {
for (uint32_t i = 0; i < directive->len; i++) {
struct section_entry entry;
entry.type = ENT_WORD;
entry.word = directive->words[i];
if (sec_push(asm->parser.sec_tbl.current, entry))
return M_ERROR;
}
break;
}
case MIPS32_DIRECTIVE_HALF: {
for (uint32_t i = 0; i < directive->len; i++) {
struct section_entry entry;
entry.type = ENT_HALF;
entry.half = directive->halfs[i];
if (sec_push(asm->parser.sec_tbl.current, entry))
return M_ERROR;
}
break;
}
case MIPS32_DIRECTIVE_BYTE: {
for (uint32_t i = 0; i < directive->len; i++) {
struct section_entry entry;
entry.type = ENT_BYTE;
entry.byte = directive->bytes[i];
if (sec_push(asm->parser.sec_tbl.current, entry))
return M_ERROR;
}
break;
}
case MIPS32_DIRECTIVE_EXTERN: {
struct symbol symbol;
if (symtbl_find(&asm->parser.sym_tbl, NULL, directive->name)
== M_SUCCESS) {
ERROR("cannot extern local symbol '%s'",
directive->name);
return M_ERROR;
}
symbol = (struct symbol) {
.name = "",
.sec = asm->parser.sec_tbl.current,
.index = asm->parser.sec_tbl.current->count,
.flag = SYM_EXTERNAL,
};
strcpy(symbol.name, directive->name);
if (symtbl_push(&asm->parser.sym_tbl, symbol))
return M_ERROR;
break;
}
case MIPS32_DIRECTIVE_GLOBL: {
struct symbol symbol;
if (symtbl_find(&asm->parser.sym_tbl, NULL, directive->name)
== M_SUCCESS) {
symbol.flag = SYM_GLOBAL;
break;
}
symbol = (struct symbol) {
.name = "",
.sec = NULL,
.index = 0,
.flag = SYM_GLOBAL,
};
strcpy(symbol.name, directive->name);
if (symtbl_push(&asm->parser.sym_tbl, symbol))
return M_ERROR;
break;
}
}
return M_SUCCESS;
}
static int parse_file(struct assembler *asm)
{
struct parser *parser = &asm->parser;
while (1) { while (1) {
struct expr expr; struct expr expr;
if (parser_next(parser, &expr)) { if (parser_next(parser, &expr)) {
break; break;
} }
if (expr.type == EXPR_INS) switch (expr.type) {
if (sectbl_push(&parser->sec_tbl, case EXPR_INS:
parser->sec_tbl.current, expr.ins)) struct section_entry entry;
return M_ERROR; entry.type = ENT_INS;
entry.size = sizeof(struct mips32_instruction);
entry.ins = expr.ins;
if (sec_push(parser->sec_tbl.current, entry))
return M_ERROR;
break;
case EXPR_DIRECTIVE:
if (handle_directive(asm, &expr.directive.mips32))
return M_ERROR;
break;
case EXPR_CONSTANT:
case EXPR_LABEL:
// nothing needed to be done
break;
}
}
struct section_meta *meta = malloc(sizeof(struct section_meta) *
parser->sec_tbl.count);
if (meta == NULL) {
ERROR("cannot alloc");
return M_ERROR;
} }
for (uint32_t i = 0; i < parser->ref_tbl.count; i++) { asm->meta = meta;
struct reference *ref = &parser->ref_tbl.references[i];
struct symbol *sym;
struct mips32_instruction *ins;
if (symtbl_find(&parser->sym_tbl, &sym, ref->name)) { size_t ptr = 0;
ERROR("undefined symbol '%s'", ref->name); for (uint32_t i = 0; i < parser->sec_tbl.count; i++) {
return M_ERROR; struct section *sec = &parser->sec_tbl.sections[i];
} meta[i].v_addr = ptr;
ptr += sec_size(sec);
}
ins = &ref->section->ins[ref->index].mips32; return M_SUCCESS;
switch (ref->type) {
case REF_OFFESET:
ins->B_data.offset += sym->position -
(ref->section->start + ref->index);
break;
case REF_TARGET:
ins->J_data.target += sym->position;
break;
}
};
return M_SUCCESS;
} }
static int assemble_phdr(struct assembler *asm, Elf32_Phdr **res, static int assemble_phdr(struct assembler *asm, Elf32_Phdr **res,
uint32_t *res2) uint32_t *res2)
{ {
struct parser *parser = asm->parser; struct parser *parser = &asm->parser;
Elf32_Phdr *phdr = malloc(sizeof(Elf32_Phdr) * Elf32_Phdr *phdr = malloc(sizeof(Elf32_Phdr) *
parser->sec_tbl.count); parser->sec_tbl.count);
size_t ins_sz = sizeof(struct mips32_instruction); if (phdr == NULL) {
ERROR("cannot alloc");
return M_ERROR;;
}
if (phdr == NULL) { for (uint32_t i = 0; i < parser->sec_tbl.count; i++) {
ERROR("cannot alloc"); Elf32_Phdr *hdr = &phdr[i];
return M_ERROR;; struct section *sec = &parser->sec_tbl.sections[i];
} size_t size = sec_size(sec);
hdr->p_type = PT_LOAD;
hdr->p_flags = (sec->execute << 0) |
(sec->write << 1) |
(sec->read << 2);
hdr->p_offset = 0;
hdr->p_vaddr = 0;
hdr->p_paddr = 0;
hdr->p_filesz = size;
hdr->p_memsz = size;
hdr->p_align = sec->alignment;
}
for (uint32_t i = 0; i < parser->sec_tbl.count; i++) { *res = phdr;
Elf32_Phdr *hdr = &phdr[i]; *res2 = parser->sec_tbl.count;
struct section *sec = &parser->sec_tbl.sections[i]; return M_SUCCESS;
hdr->p_type = PT_LOAD;
hdr->p_flags = PF_X | PF_W | PF_R; // FIXME: this is bad
hdr->p_offset = sec->start * ins_sz;
hdr->p_vaddr = sec->start * ins_sz;
hdr->p_paddr = 0x00;
hdr->p_filesz = sec->count * ins_sz;
hdr->p_memsz = sec->count * ins_sz;
hdr->p_align = sec->alignment;
}
*res = phdr;
*res2 = parser->sec_tbl.count;
return M_SUCCESS;
} }
static int assemble_symtbl(struct assembler *asm, Elf32_Sym **res, static int assemble_symtbl(struct assembler *asm, Elf32_Sym **res,
uint32_t *res2) uint32_t *res2)
{ {
Elf32_Sym *stbl = malloc(sizeof(Elf32_Sym) * asm->parser->sym_tbl Elf32_Sym *stbl = malloc(sizeof(Elf32_Sym) * asm->parser.sym_tbl
.count); .count);
size_t size = 0;
if (stbl == NULL) if (stbl == NULL)
return M_ERROR; return M_ERROR;
for (uint32_t i = 0; i < asm->parser->sym_tbl.count; i++) { for (uint32_t i = 0; i < asm->parser.sym_tbl.count; i++) {
struct symbol *sym = &asm->parser->sym_tbl.symbols[i]; struct symbol *sym = &asm->parser.sym_tbl.symbols[i];
size_t str_off; size_t str_off;
unsigned char bind;
unsigned char type = STT_NOTYPE;
if (strtbl_write_str(&asm->str_tbl, sym->name, &str_off)) { if (strtbl_write_str(&asm->str_tbl, sym->name, &str_off)) {
free(stbl); free(stbl);
return M_ERROR; return M_ERROR;
} }
int viz = STB_LOCAL; if (sym->flag != SYM_LOCAL)
switch (sym->flag) { bind = STB_LOCAL;
case SYM_LOCAL: else
viz = STB_LOCAL; bind = STB_GLOBAL;
break;
case SYM_GLOBAL:
case SYM_EXTERNAL:
viz = STB_GLOBAL;
break;
}
stbl[i] = (Elf32_Sym) { stbl[i] = (Elf32_Sym) {
.st_name = str_off, .st_name = str_off,
.st_value = sym->position, .st_value = sym->index,
.st_size = 0, .st_size = 0,
.st_info = (unsigned char) .st_info = ELF32_ST_INFO(bind, type),
ELF32_ST_INFO(SYMINFO_BT_SELF, .st_other = ELF32_ST_VISIBILITY(STV_DEFAULT),
SYMINFO_FLG_DIRECT), .st_shndx = asm->meta[sym->sec->index].shdr_idx,
.st_other = (unsigned char) };
ELF32_ST_VISIBILITY(viz), size = i + 1;
.st_shndx = 0, // FIXME: specify section };
};
};
*res = stbl; *res = stbl;
*res2 = asm->parser->sym_tbl.count; *res2 = size;
return M_SUCCESS; return M_SUCCESS;
}
static int assemble_reltbl_sec(struct assembler *asm, Elf32_Sym *symtbl,
uint32_t symtbl_len, struct section *sec)
{
uint32_t len = 0;
for (uint32_t i = 0; i < asm->parser.ref_tbl.count; i++) {
struct reference *ref = &asm->parser.ref_tbl.references[i];
if (ref->section->index == sec->index) {
len++;
}
}
if (len == 0) {
asm->meta[sec->index].reltbl = NULL;
return M_SUCCESS;
}
Elf32_Rela *reltbl = malloc(sizeof(Elf32_Rela) * len);
if (reltbl == NULL) {
ERROR("cannot alloc");
return M_ERROR;
}
for (uint32_t i = 0; i < asm->parser.ref_tbl.count; i++) {
struct reference *ref = &asm->parser.ref_tbl.references[i];
struct mips32_instruction *ins = &ref->section->
entries[ref->index].ins.mips32;
struct section_meta *meta = &asm->meta[ref->section->index];
if (ref->section->index != sec->index) {
continue;
}
int32_t addend = 0;
unsigned char type = 0;
switch (ref->type) {
case REF_OFFESET:
addend = ins->B_data.offset;
type = R_MIPS_PC16;
break;
case REF_TARGET:
addend = ins->J_data.target;
type = R_MIPS_26;
break;
}
int32_t symidx = -1;
for (uint32_t i = 0; i < symtbl_len; i++) {
Elf32_Sym *sym = &symtbl[i];
const char *str = &asm->str_tbl.ptr[sym->st_name];
if (strcmp(ref->name, str) == 0) {
symidx = i;
break;
}
}
if (symidx == -1) {
ERROR("undefined symbol '%s'", ref->name);
free(reltbl);
return M_ERROR;
}
reltbl[i] = (Elf32_Rela) {
.r_info = ELF32_R_INFO(symidx, type),
.r_addend = addend,
.r_offset = meta->v_addr +
sec_index(ref->section, ref->index),
};
};
asm->meta[sec->index].reltbl_len = len;
asm->meta[sec->index].reltbl = reltbl;
return M_SUCCESS;
}
static int assemble_reltbl(struct assembler *asm, Elf32_Sym *symtbl,
uint32_t symtbl_len)
{
for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
struct section *sec = &asm->parser.sec_tbl.sections[i];
if (assemble_reltbl_sec(asm, symtbl, symtbl_len, sec))
return M_ERROR;
}
return M_SUCCESS;
} }
static int assemble_shdr(struct assembler *asm, Elf32_Shdr **res, static int assemble_shdr(struct assembler *asm, Elf32_Shdr **res,
uint32_t *res2) uint32_t *res2)
{ {
uint32_t entries = 2; // str table and sym tabel uint32_t max_entries = 4; // symtab, strtab, shstrtab
entries += asm->parser->sec_tbl.count; // sections max_entries += asm->parser.sec_tbl.count; // sections
max_entries += asm->parser.sec_tbl.count; // reltabs per section
Elf32_Shdr *shdr = malloc(sizeof(Elf32_Shdr) * entries); Elf32_Shdr *shdr = malloc(sizeof(Elf32_Shdr) * max_entries);
size_t str_off; size_t str_off;
if (strtbl_write_str(&asm->str_tbl, ".shsymtab", &str_off)) { uint32_t count = 0;
free(shdr);
return M_ERROR;
}
// symbol table // eeltables
shdr[SHDR_SYMTBL] = (Elf32_Shdr) { for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
.sh_name = str_off,
.sh_type = SHT_SYMTAB,
.sh_flags = 0,
.sh_addr = 0,
.sh_offset = 0,
.sh_size = 0,
.sh_link = 1,
.sh_info = 0,
.sh_addralign = 1,
.sh_entsize = sizeof(Elf32_Sym),
};
if (strtbl_write_str(&asm->str_tbl, ".shstrtab", &str_off)) { if (asm->meta[i].reltbl == NULL)
free(shdr); continue;
return M_ERROR;
}
// string table struct section *sec = &asm->parser.sec_tbl.sections[i];
shdr[SHDR_STRTBL] = (Elf32_Shdr) { const char *prefix = ".reltab.";
.sh_name = str_off, char reltab_name[MAX_LEX_LENGTH + 8];
.sh_type = SHT_STRTAB,
.sh_flags = SHF_STRINGS,
.sh_addr = 0,
.sh_offset = 0,
.sh_size = 0,
.sh_link = 0,
.sh_info = 0,
.sh_addralign = 1,
.sh_entsize = 0,
};
// for each section strcpy(reltab_name, prefix);
for (uint32_t i = 0; i < asm->parser->sec_tbl.count; i++) { strcat(reltab_name, sec->name);
struct section *sec = &asm->parser->sec_tbl.sections[i];
char name[MAX_LEX_LENGTH+1] = "."; if (strtbl_write_str(&asm->shstr_tbl, reltab_name, &str_off)) {
strcat(name, sec->name); free(shdr);
if (strtbl_write_str(&asm->str_tbl, name, &str_off)) { return M_ERROR;
free(shdr); }
return M_ERROR;
} asm->meta[i].reltbl_idx = count;
shdr[i+SHDR_SECTIONS] = (Elf32_Shdr) { shdr[count++] = (Elf32_Shdr) {
.sh_name = str_off, .sh_name = str_off,
.sh_type = SHT_PROGBITS, .sh_type = SHT_RELA,
.sh_flags = SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR, .sh_flags = 0,
.sh_addr = 0, .sh_addr = 0,
.sh_offset = 0, .sh_offset = 0,
.sh_size = 0, .sh_size = 0,
.sh_link = 0, .sh_link = 0,
.sh_info = 0, .sh_info = 0,
.sh_addralign = sec->alignment, .sh_addralign = 1,
.sh_entsize = sizeof(struct mips32_instruction), .sh_entsize = sizeof(Elf32_Rela),
};
}
// for each section
for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
struct section *sec = &asm->parser.sec_tbl.sections[i];
char name[MAX_LEX_LENGTH+1] = ".";
strcat(name, sec->name);
if (strtbl_write_str(&asm->shstr_tbl, name, &str_off)) {
free(shdr);
return M_ERROR;
}
asm->meta[i].shdr_idx = count;
if (asm->meta[i].reltbl != NULL)
shdr[asm->meta[i].reltbl_idx].sh_info = count;
shdr[count++] = (Elf32_Shdr){
.sh_name = str_off,
.sh_type = SHT_PROGBITS,
.sh_flags = (sec->write << 0) | (sec->execute << 2) |
SHF_ALLOC,
.sh_addr = 0,
.sh_offset = 0,
.sh_size = 0,
.sh_link = 0,
.sh_info = 0,
.sh_addralign = sec->alignment,
.sh_entsize = sizeof(struct mips32_instruction),
}; };
} }
*res = shdr; // symbol table
*res2 = entries; if (strtbl_write_str(&asm->shstr_tbl, ".symtab", &str_off)) {
free(shdr);
return M_ERROR;
}
return M_SUCCESS; asm->symtbl_idx = count;
shdr[count++] = (Elf32_Shdr) {
.sh_name = str_off,
.sh_type = SHT_SYMTAB,
.sh_flags = 0,
.sh_addr = 0,
.sh_offset = 0,
.sh_size = 0,
.sh_link = 1,
.sh_info = 0,
.sh_addralign = 1,
.sh_entsize = sizeof(Elf32_Sym),
};
// string table
if (strtbl_write_str(&asm->shstr_tbl, ".strtab", &str_off)) {
free(shdr);
return M_ERROR;
}
asm->strtbl_idx = count;
shdr[count++] = (Elf32_Shdr) {
.sh_name = str_off,
.sh_type = SHT_STRTAB,
.sh_flags = SHF_STRINGS,
.sh_addr = 0,
.sh_offset = 0,
.sh_size = 0,
.sh_link = 0,
.sh_info = 0,
.sh_addralign = 1,
.sh_entsize = 0,
};
// sh string table
if (strtbl_write_str(&asm->shstr_tbl, ".shstrtab", &str_off)) {
free(shdr);
return M_ERROR;
}
asm->shstrtbl_idx = count;
shdr[count++] = (Elf32_Shdr) {
.sh_name = str_off,
.sh_type = SHT_STRTAB,
.sh_flags = SHF_STRINGS,
.sh_addr = 0,
.sh_offset = 0,
.sh_size = 0,
.sh_link = 0,
.sh_info = 0,
.sh_addralign = 1,
.sh_entsize = 0,
};
for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
if (asm->meta[i].reltbl == NULL)
continue;
shdr[asm->meta[i].reltbl_idx].sh_link = asm->symtbl_idx;
}
*res = shdr;
*res2 = count;
return M_SUCCESS;
} }
static int assemble_file(struct assembler *asm) static int assemble_file(struct assembler *asm)
{ {
Elf32_Phdr *phdr; Elf32_Phdr *phdr;
Elf32_Shdr *shdr; Elf32_Shdr *shdr;
Elf32_Sym *symtbl; Elf32_Sym *symtbl;
uint32_t phdr_len; uint32_t phdr_len;
uint32_t shdr_len; uint32_t shdr_len;
uint32_t symtbl_len; uint32_t symtbl_len;
if (assemble_symtbl(asm, &symtbl, &symtbl_len)) if (assemble_symtbl(asm, &symtbl, &symtbl_len))
return M_ERROR; return M_ERROR;
if (assemble_phdr(asm, &phdr, &phdr_len)) { if (assemble_reltbl(asm, symtbl, symtbl_len)) {
free(symtbl); free(symtbl);
return M_ERROR; return M_ERROR;
} };
if (assemble_shdr(asm, &shdr, &shdr_len)) { if (assemble_phdr(asm, &phdr, &phdr_len)) {
free(symtbl); free(symtbl);
free(phdr); return M_ERROR;
return M_ERROR; }
};
Elf32_Ehdr ehdr = { if (assemble_shdr(asm, &shdr, &shdr_len)) {
.e_ident = { free(symtbl);
[EI_MAG0] = ELFMAG0, free(phdr);
[EI_MAG1] = ELFMAG1, return M_ERROR;
[EI_MAG2] = ELFMAG2, };
[EI_MAG3] = ELFMAG3,
[EI_CLASS] = ELFCLASS32,
[EI_DATA] = ELFDATA2LSB,
[EI_VERSION] = EV_CURRENT,
[EI_OSABI] = ELFOSABI_NONE,
[EI_ABIVERSION] = 0x00,
[EI_PAD] = 0x00,
},
.e_type = ET_REL,
.e_machine = EM_MIPS,
.e_version = EV_CURRENT,
.e_entry = 0x00,
.e_phoff = 0x00,
.e_shoff = 0x00,
.e_flags = EF_MIPS_ARCH_32R6,
.e_ehsize = sizeof(Elf32_Ehdr),
.e_phentsize = sizeof(Elf32_Phdr),
.e_phnum = phdr_len,
.e_shentsize = sizeof(Elf32_Shdr),
.e_shnum = shdr_len,
.e_shstrndx = SHDR_STRTBL,
};
uint32_t ptr = 0; Elf32_Ehdr ehdr = {
.e_ident = {
[EI_MAG0] = ELFMAG0,
[EI_MAG1] = ELFMAG1,
[EI_MAG2] = ELFMAG2,
[EI_MAG3] = ELFMAG3,
[EI_CLASS] = ELFCLASS32,
[EI_DATA] = ELFDATA2LSB,
[EI_VERSION] = EV_CURRENT,
[EI_OSABI] = ELFOSABI_NONE,
[EI_ABIVERSION] = 0x00,
[EI_PAD] = 0x00,
},
.e_type = ET_REL,
.e_machine = EM_MIPS,
.e_version = EV_CURRENT,
.e_entry = 0x00,
.e_phoff = 0x00,
.e_shoff = 0x00,
.e_flags = EF_MIPS_ARCH_32R6,
.e_ehsize = sizeof(Elf32_Ehdr),
.e_phentsize = sizeof(Elf32_Phdr),
.e_phnum = phdr_len,
.e_shentsize = sizeof(Elf32_Shdr),
.e_shnum = shdr_len,
.e_shstrndx = asm->shstrtbl_idx,
};
// we must now correct offets and sizes inside the ehdr, phdr, uint32_t ptr = 0;
// and shdr
ptr += sizeof(Elf32_Ehdr); // we must now correct offets and sizes inside the ehdr, phdr,
// and shdr
ptr += sizeof(Elf32_Ehdr);
// phdr // phdr
ehdr.e_phoff = ptr; ehdr.e_phoff = ptr;
ptr += phdr_len * sizeof(Elf32_Phdr); ptr += phdr_len * sizeof(Elf32_Phdr);
// sections // reltbls
for (uint32_t i = 0; i < asm->parser->sec_tbl.count; i++) { for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
phdr[i].p_offset = ptr; if (asm->meta[i].reltbl == NULL)
phdr[i].p_vaddr = ptr; continue;
shdr[i+SHDR_SECTIONS].sh_offset = ptr; int idx = asm->meta[i].reltbl_idx;
shdr[i+SHDR_SECTIONS].sh_size = phdr[i].p_filesz; int len = asm->meta[i].reltbl_len;
ptr += phdr[i].p_filesz; shdr[idx].sh_offset = ptr;
} shdr[idx].sh_size = len * sizeof(Elf32_Rela);
ptr += len * sizeof(Elf32_Rela);
}
// symtbl // sections
shdr[SHDR_SYMTBL].sh_offset = ptr; for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
shdr[SHDR_SYMTBL].sh_size = symtbl_len * sizeof(Elf32_Sym); int idx = asm->meta[i].shdr_idx;
ptr += symtbl_len * sizeof(Elf32_Sym); phdr[i].p_offset = ptr;
phdr[i].p_vaddr = ptr;
phdr[i].p_paddr = ptr;
shdr[idx].sh_offset = ptr;
shdr[idx].sh_size = phdr[i].p_filesz;
shdr[idx].sh_addr = phdr[i].p_vaddr;
shdr[idx].sh_addralign = phdr[i].p_align;
ptr += phdr[i].p_filesz;
}
// strtbl // symtbl
shdr[SHDR_STRTBL].sh_offset = ptr; shdr[asm->symtbl_idx].sh_offset = ptr;
shdr[SHDR_STRTBL].sh_size = asm->str_tbl.size; shdr[asm->symtbl_idx].sh_link = asm->strtbl_idx;
ptr += asm->str_tbl.size; shdr[asm->symtbl_idx].sh_size = symtbl_len * sizeof(Elf32_Sym);
ptr += symtbl_len * sizeof(Elf32_Sym);
// shdr // strtbl
ehdr.e_shoff = ptr; shdr[asm->strtbl_idx].sh_offset = ptr;
shdr[asm->strtbl_idx].sh_size = asm->str_tbl.size;
ptr += asm->str_tbl.size;
FILE *out = fopen("out.o", "w"); // shstrtbl
shdr[asm->shstrtbl_idx].sh_offset = ptr;
shdr[asm->shstrtbl_idx].sh_size = asm->shstr_tbl.size;
ptr += asm->shstr_tbl.size;
// ehdr // shdr
fwrite(&ehdr, sizeof(Elf32_Ehdr), 1, out); ehdr.e_shoff = ptr;
// phdr FILE *out = fopen("out.o", "w");
fwrite(phdr, sizeof(Elf32_Phdr), phdr_len, out);
// sections // ehdr
for (uint32_t i = 0; i < asm->parser->sec_tbl.count; i++) { fwrite(&ehdr, sizeof(Elf32_Ehdr), 1, out);
struct section *sec = &asm->parser->sec_tbl.sections[i];
for (uint32_t j = 0; j < sec->count; j++) {
struct mips32_instruction *ins = &sec->ins[j].mips32;
fwrite(ins, sizeof(struct mips32_instruction),
1, out);
}
}
// sym tbl // phdr
fwrite(symtbl, sizeof(Elf32_Sym), symtbl_len, out); fwrite(phdr, sizeof(Elf32_Phdr), phdr_len, out);
// str tbl // reltbls
fwrite(asm->str_tbl.ptr, asm->str_tbl.size, 1, out); for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
if (asm->meta[i].reltbl == NULL)
continue;
void *ptr = asm->meta[i].reltbl;
int len = asm->meta[i].reltbl_len;
asm->meta[i].reltbl = NULL;
fwrite(ptr, sizeof(Elf32_Rela), len, out);
}
// shdr // sections
fwrite(shdr, sizeof(Elf32_Shdr), shdr_len, out); for (uint32_t i = 0; i < asm->parser.sec_tbl.count; i++) {
struct section *sec = &asm->parser.sec_tbl.sections[i];
for (uint32_t j = 0; j < sec->count; j++) {
struct section_entry *entry = &sec->entries[j];
size_t size = entry->size;
fwrite(&entry->data, size, 1, out);
while(size % sec->alignment) {
uint8_t zero = 0;
fwrite(&zero, 1, 1, out);
size++;
}
}
}
fclose(out); // sym tbl
fwrite(symtbl, sizeof(Elf32_Sym), symtbl_len, out);
free(shdr); // str tbl
free(phdr); fwrite(asm->str_tbl.ptr, asm->str_tbl.size, 1, out);
free(symtbl);
return M_SUCCESS; // shstr tbl
fwrite(asm->shstr_tbl.ptr, asm->shstr_tbl.size, 1, out);
// shdr
fwrite(shdr, sizeof(Elf32_Shdr), shdr_len, out);
// cleanip
fclose(out);
free(shdr);
free(phdr);
free(symtbl);
return M_SUCCESS;
} }
int assemble_file_mips32(char *path) int assemble_file_mips32(char *path)
{ {
struct lexer lexer; struct assembler asm;
struct parser parser; int res = M_SUCCESS;
current_file = path; current_file = path;
int res = M_SUCCESS;
if (lexer_init(current_file, &lexer)) if (assembler_init(&asm, path))
return M_ERROR; return M_ERROR;
if (mips32_parser_init(&lexer, &parser)) mips32_parser_init(&asm.parser);
return M_ERROR;
if (res == M_SUCCESS) if (res == M_SUCCESS)
res = parse_file(&parser); res = parse_file(&asm);
struct assembler assembler; if (res == M_SUCCESS)
assembler.parser = &parser; res = assemble_file(&asm);
strtbl_init(&assembler.str_tbl);
if (res == M_SUCCESS) assembler_free(&asm);
res = assemble_file(&assembler);
strtbl_free(&assembler.str_tbl); return res;
lexer_free(&lexer);
parser_free(&parser);
return res;
} }

16
masm/parse.c
View file

@ -105,23 +105,27 @@ static int parse_label(struct parser *parser,
struct expr *expr) struct expr *expr)
{ {
struct token token; struct token token;
struct symbol symbol;
uint32_t index;
if (assert_token(parser, TOK_LABEL, &token)) if (assert_token(parser, TOK_LABEL, &token))
return M_ERROR; return M_ERROR;
strcpy(expr->text, token.text); strcpy(expr->text, token.text);
if (symtbl_find(&parser->sym_tbl, NULL, token.text) == M_SUCCESS) { struct symbol *ref;
if (symtbl_find(&parser->sym_tbl, &ref, token.text) == M_SUCCESS) {
if (ref->flag == SYM_GLOBAL && ref->sec == NULL) {
ref->sec = parser->sec_tbl.current;
ref->index = parser->sec_tbl.current->count;
return M_SUCCESS;
}
ERROR_POS(token, "redefined symbol '%s'", token.text); ERROR_POS(token, "redefined symbol '%s'", token.text);
return M_ERROR; return M_ERROR;
} }
index = parser->sec_tbl.current->start + struct symbol symbol;
parser->sec_tbl.current->count;
symbol = (struct symbol) { symbol = (struct symbol) {
.name = "", .name = "",
.position = index, .sec = parser->sec_tbl.current,
.index = parser->sec_tbl.current->count,
.flag = SYM_LOCAL, .flag = SYM_LOCAL,
}; };
strcpy(symbol.name, token.text); strcpy(symbol.name, token.text);

38
masm/parse.h
View file

@ -18,7 +18,6 @@ enum expr_type {
EXPR_INS, EXPR_INS,
EXPR_DIRECTIVE, EXPR_DIRECTIVE,
EXPR_CONSTANT, EXPR_CONSTANT,
EXPR_SEGMENT,
EXPR_LABEL, EXPR_LABEL,
}; };
@ -44,7 +43,8 @@ enum symbol_flag {
struct symbol { struct symbol {
char name[MAX_LEX_LENGTH]; char name[MAX_LEX_LENGTH];
uint32_t position; uint32_t index;
struct section *sec;
enum symbol_flag flag; enum symbol_flag flag;
}; };
@ -62,13 +62,37 @@ int symtbl_push(struct symbol_table *sym_tbl, struct symbol sym);
int symtbl_find(struct symbol_table *sym_tbl, struct symbol **sym, int symtbl_find(struct symbol_table *sym_tbl, struct symbol **sym,
const char name[MAX_LEX_LENGTH]); const char name[MAX_LEX_LENGTH]);
enum section_entry_type {
ENT_INS,
ENT_WORD,
ENT_HALF,
ENT_BYTE,
ENT_NO_DATA,
};
struct section_entry {
enum section_entry_type type;
size_t size;
union {
char data; // to get memory address
union mips_instruction ins;
int32_t word;
int16_t half;
int8_t byte;
};
};
struct section { struct section {
uint32_t count; uint32_t count;
uint32_t len; uint32_t len;
uint32_t start;
uint32_t alignment; uint32_t alignment;
union mips_instruction *ins; uint32_t index; // what index is my section
char name[MAX_LEX_LENGTH]; char name[MAX_LEX_LENGTH];
bool read;
bool write;
bool execute;
struct section_entry *entries;
}; };
struct section_table { struct section_table {
@ -77,7 +101,6 @@ struct section_table {
struct section *sections; struct section *sections;
struct section *current; struct section *current;
char name[MAX_LEX_LENGTH]; char name[MAX_LEX_LENGTH];
uint32_t total_ins;
}; };
int sectbl_init(struct section_table *sec_tbl); int sectbl_init(struct section_table *sec_tbl);
@ -85,10 +108,11 @@ void sectbl_free(struct section_table *sec_tbl);
int sectbl_alloc(struct section_table *sec_tbl, struct section **sec, int sectbl_alloc(struct section_table *sec_tbl, struct section **sec,
const char name[MAX_LEX_LENGTH]); const char name[MAX_LEX_LENGTH]);
int sectbl_push(struct section_table *sec_tbl, struct section *section,
union mips_instruction ins);
int sectbl_get(struct section_table *sec_tbl, struct section **sec, int sectbl_get(struct section_table *sec_tbl, struct section **sec,
const char name[MAX_LEX_LENGTH]); const char name[MAX_LEX_LENGTH]);
int sec_push(struct section *section, struct section_entry entry);
size_t sec_size(struct section *section);
size_t sec_index(struct section *section, uint32_t index);
enum reference_type { enum reference_type {
REF_OFFESET, REF_OFFESET,

955
masm/parse_mips32.c
View file

File diff suppressed because it is too large Load diff

4
masm/parse_mips32.h
View file

@ -5,8 +5,8 @@
#include "parse.h" #include "parse.h"
/* initzlize a mips32 parser*/ /* initzlize a mips32 parser vtable */
int mips32_parser_init(struct lexer *lexer, struct parser *parser); void mips32_parser_init(struct parser *parser);
/* free the mips32 parser */ /* free the mips32 parser */
void mips32_parser_free(struct parser *parser); void mips32_parser_free(struct parser *parser);

10
masm/reftbl.c
View file

@ -12,13 +12,13 @@ int reftbl_init(struct reference_table *ref_tbl)
{ {
ref_tbl->len = RELTBL_INIT_LEN; ref_tbl->len = RELTBL_INIT_LEN;
ref_tbl->count = 0; ref_tbl->count = 0;
ref_tbl->references = malloc(sizeof(struct reference) * ref_tbl->references = malloc(sizeof(struct reference) *
RELTBL_INIT_LEN); RELTBL_INIT_LEN);
if (ref_tbl->references == NULL) { if (ref_tbl->references == NULL) {
ERROR("cannot alloc"); ERROR("cannot alloc");
return M_ERROR; return M_ERROR;
} }
return M_SUCCESS; return M_SUCCESS;
} }

120
masm/sectbl.c
View file

@ -13,13 +13,12 @@ int sectbl_init(struct section_table *sec_tbl)
{ {
sec_tbl->len = SECTBL_INIT_LEN; sec_tbl->len = SECTBL_INIT_LEN;
sec_tbl->count = 0; sec_tbl->count = 0;
sec_tbl->total_ins = 0; sec_tbl->sections = malloc(sizeof(struct section) * SECTBL_INIT_LEN);
sec_tbl->sections = malloc(sizeof(struct section) * SECTBL_INIT_LEN);
if (sec_tbl->sections == NULL) { if (sec_tbl->sections == NULL) {
ERROR("cannot alloc"); ERROR("cannot alloc");
return M_ERROR; return M_ERROR;
} }
if (sectbl_alloc(sec_tbl, &sec_tbl->current, inital_section)) if (sectbl_alloc(sec_tbl, &sec_tbl->current, inital_section))
return M_ERROR; return M_ERROR;
@ -30,11 +29,26 @@ int sectbl_init(struct section_table *sec_tbl)
void sectbl_free(struct section_table *sec_tbl) void sectbl_free(struct section_table *sec_tbl)
{ {
for (uint32_t i = 0; i < sec_tbl->count; i++) { for (uint32_t i = 0; i < sec_tbl->count; i++) {
free(sec_tbl->sections[i].ins); free(sec_tbl->sections[i].entries);
} }
free(sec_tbl->sections); free(sec_tbl->sections);
} }
struct section_settings {
const char *name;
bool read;
bool write;
bool execute;
uint32_t align;
};
static struct section_settings default_section_settings[] = {
{"data", true, true, false, 1},
{"bss", true, true, false, 1},
{"rodata", true, false, false, 1},
{"text", true, false, true, 4},
};
int sectbl_alloc(struct section_table *sec_tbl, struct section **sec, int sectbl_alloc(struct section_table *sec_tbl, struct section **sec,
const char name[MAX_LEX_LENGTH]) const char name[MAX_LEX_LENGTH])
{ {
@ -50,50 +64,46 @@ int sectbl_alloc(struct section_table *sec_tbl, struct section **sec,
} }
struct section *temp; struct section *temp;
temp = &sec_tbl->sections[sec_tbl->count++]; temp = &sec_tbl->sections[sec_tbl->count];
strcpy(temp->name,name); strcpy(temp->name,name);
temp->count = 0; temp->count = 0;
temp->len = SECTBL_INIT_LEN; temp->len = SECTBL_INIT_LEN;
temp->start = sec_tbl->total_ins;
temp->alignment = 1; temp->alignment = 1;
temp->ins = malloc(sizeof(union mips_instruction) * SECTBL_INIT_LEN); temp->read = true;
temp->write = true;
temp->execute = false;
temp->index = sec_tbl->count;
temp->entries = malloc(sizeof(struct section_entry) * SECTBL_INIT_LEN);
if (temp->ins == NULL) { for (int i = 0; i < 4; i++) {
struct section_settings *set = &default_section_settings[i];
if (strcmp(set->name, name) == 0) {
temp->read = set->read;
temp->write = set->write;
temp->execute = set->execute;
temp->alignment = set->align;
break;
}
}
if (temp->entries == NULL) {
ERROR("cannot alloc"); ERROR("cannot alloc");
return M_ERROR; return M_ERROR;
} }
sec_tbl->count++;
*sec = temp; *sec = temp;
return M_SUCCESS; return M_SUCCESS;
} }
int sectbl_push(struct section_table *sec_tbl, struct section *section,
union mips_instruction ins)
{
if (section->count >= section->len) {
section->len *= 2;
section->ins = realloc(section->ins,
sizeof(union mips_instruction) * section->len);
if (section->ins == NULL) {
ERROR("cannot realloc");
return M_ERROR;
}
}
section->ins[section->count++] = ins;
sec_tbl->total_ins++;
return M_SUCCESS;
}
int sectbl_get(struct section_table *sec_tbl, struct section **sec, int sectbl_get(struct section_table *sec_tbl, struct section **sec,
const char name[MAX_LEX_LENGTH]) const char name[MAX_LEX_LENGTH])
{ {
for (uint32_t i = 0; i < sec_tbl->count; i++) { for (uint32_t i = 0; i < sec_tbl->count; i++) {
struct section *temp = &sec_tbl->sections[i]; struct section *temp = &sec_tbl->sections[i];
if (strcmp(name, temp->name) == 0) { if (strcmp(name, temp->name) == 0) {
if (sec != NULL) if (sec != NULL)
*sec = temp; *sec = temp;
return M_SUCCESS; return M_SUCCESS;
} }
@ -101,3 +111,49 @@ int sectbl_get(struct section_table *sec_tbl, struct section **sec,
return M_ERROR; return M_ERROR;
} }
int sec_push(struct section *section, struct section_entry entry)
{
if (section->count >= section->len) {
section->len *= 2;
void *new = realloc(section->entries,
sizeof(struct section_entry) * section->len);
if (new == NULL) {
ERROR("cannot realloc");
return M_ERROR;
}
section->entries = new;
}
section->entries[section->count++] = entry;
return M_SUCCESS;
}
size_t sec_size(struct section *sec)
{
size_t n = 0;
for (uint32_t i = 0; i < sec->count; i++) {
size_t t = sec->entries[i].size;
size_t m = t % sec->alignment;
if (m)
t += sec->alignment - m;
n += t;
}
return n;
}
size_t sec_index(struct section *sec, uint32_t idx)
{
size_t n = 0;
for (uint32_t i = 0; i < idx; i++) {
size_t t = sec->entries[i].size;
size_t m = t % sec->alignment;
if (m)
t += sec->alignment - m;
n += t;
}
return n;
}

55
masm/strtbl.c
View file

@ -6,44 +6,49 @@
int strtbl_get_str(struct str_table *str_tbl, const char *str, size_t *res) int strtbl_get_str(struct str_table *str_tbl, const char *str, size_t *res)
{ {
for (size_t i = 0; i < str_tbl->size; i ++) { for (size_t i = 0; i < str_tbl->size; i ++) {
if (strcmp(str_tbl->ptr + i, str) == 0) { if (strcmp(str_tbl->ptr + i, str) == 0) {
if (res != NULL) if (res != NULL)
*res = i; *res = i;
return M_SUCCESS; return M_SUCCESS;
} }
} }
return M_ERROR; return M_ERROR;
} }
int strtbl_write_str(struct str_table *str_tbl, const char *str, size_t *res) int strtbl_write_str(struct str_table *str_tbl, const char *str, size_t *res)
{ {
if (strtbl_get_str(str_tbl, str, res) == M_SUCCESS) if (strtbl_get_str(str_tbl, str, res) == M_SUCCESS)
return M_SUCCESS; return M_SUCCESS;
size_t len = strlen(str); size_t len = strlen(str);
char *new = realloc(str_tbl->ptr, str_tbl->size + len + 1); char *new = realloc(str_tbl->ptr, str_tbl->size + len + 1);
if (new == NULL) if (new == NULL)
return M_ERROR; return M_ERROR;
str_tbl->ptr = new; str_tbl->ptr = new;
memcpy(str_tbl->ptr + str_tbl->size, str, len + 1); memcpy(str_tbl->ptr + str_tbl->size, str, len + 1);
if (res != NULL) if (res != NULL)
*res = str_tbl->size; *res = str_tbl->size;
str_tbl->size += len + 1; str_tbl->size += len + 1;
return M_SUCCESS; return M_SUCCESS;
} }
void strtbl_init(struct str_table *str_tbl) int strtbl_init(struct str_table *str_tbl)
{ {
str_tbl->size = 1; str_tbl->size = 1;
str_tbl->ptr = malloc(1); str_tbl->ptr = malloc(1);
*str_tbl->ptr = '\0'; if (str_tbl->ptr == NULL) {
ERROR("cannot alloc");
return M_ERROR;
}
*str_tbl->ptr = '\0';
return M_SUCCESS;
} }
void strtbl_free(struct str_table *str_tbl) void strtbl_free(struct str_table *str_tbl)
{ {
free(str_tbl->ptr); free(str_tbl->ptr);
} }

5
masm/test.asm
View file

@ -1,6 +1,9 @@
.text .text
.align 2 .align 2
.globl main
.extern test2
main: main:
add $zero,$t7,$t7 add $zero,$t7,$t7
xori $a0, $v1, 69 xori $a0, $v1, 69
@ -19,4 +22,4 @@ test:
mfhi $s0 mfhi $s0
mtlo $s7 mtlo $s7
j test j test2