int elfmachine = 3; /* machine = EM_386 */
/* Header and section table of an ack object file. */
-
+
struct outhead outhead;
struct outsect outsect[S_MAX];
+struct outname* outname = NULL;
char* stringarea;
+uint32_t ack_off_char;
+int nstab = 0; /* S_STB symbol count */
+int nsym = 0; /* other symbol count */
char* outputfile = NULL; /* Name of output file, or NULL */
char* program; /* Name of current program: argv[0] */
#define readf(a, b, c) fread((a), (b), (int)(c), input)
#define writef(a, b, c) fwrite((a), (b), (int)(c), output)
-/* Header and program header table of an ELF object file. */
+/* Contents of an ELF object file. */
#define ELF_HEADER_SIZE 0x34
#define PROGRAM_HEADER_SIZE 0x20
#define PROGRAM_HEADER_COUNT 1
-unsigned long codeoffset;
+#define SECTION_HEADER_SIZE 0x28
+#define STAB_SYMBOL_SIZE 12
+#define ELF_SYMBOL_SIZE 16
+
+uint32_t code_offset; /* ELF segment */
+uint32_t stab_offset; /* Debugger symbol table */
+uint32_t symtab_offset; /* ELF symbol table */
+uint32_t strtab_offset; /* String table */
+uint32_t shstrtab_offset; /* Section header string table */
+uint32_t sh_offset; /* ELF section headers */
+
+int sh_count = 0; /* Number of ELF sections */
+int shstrtab_nr = 0; /* Section number of .shstrtab */
+int shstrtab_size;
const char elf_le_ident_string[] = {
0x7F, 'E', 'L', 'F'
};
-/* Output file definitions and such */
-
-#define HDR_LENGTH 32
-
-char hdr[HDR_LENGTH] ;
-
bool verbose = false;
/* Segment numbers understood by aelflod. */
NUM_SEGMENTS
};
-#define N_EXT 040
-#define N_UNDEF 00
-#define N_ABS 01
-#define N_TEXT 02
-#define N_DATA 03
-#define N_BSS 04
-#define N_FN 037
+/*
+ * ELF section numbers count up in the order that we write the ELF
+ * section headers. If we have no debugger symbols, we will skip
+ * .stab and .stabstr, then subtract 2 from all later numbers.
+ */
+enum {
+ N_UNDEF = 0,
+ N_TEXT,
+ N_RODATA,
+ N_DATA,
+ N_BSS,
+ N_STAB,
+ N_STABSTR,
+ N_SYMTAB,
+ N_STRTAB,
+ N_SHSTRTAB,
+ NUM_ELF_SECTIONS,
+};
+const char shstrtab[] =
+ "\0.text\0.rodata\0.data\0.bss\0.stab\0.stabstr\0"
+ ".symtab\0.strtab\0.shstrtab";
+ /* Compiler appends one more "\0". */
+const int sh_name[] = {
+ /* Index of each name in shstrtab: */
+ 0, 1, 7, 15, 21, 26, 32,
+ 41, 49, 57,
+};
/* Produce an error message and exit. */
return (pa->os_base >= align(pb->os_base+pb->os_size, pa->os_lign));
}
+/* Convert a symbol's name index from ack.out to ELF. */
+
+uint32_t cvname(struct outname* n)
+{
+ if (n->on_foff) {
+ /* ack.out: offset from beginning of file
+ * ELF: index in string table
+ * the + 1 because we prepend a '\0' */
+ return n->on_foff - ack_off_char + 1;
+ } else
+ return 0; /* no name */
+}
+
+/* Convert a symbol's type and binding from ack.out to ELF. */
+
+int cvinfo(struct outname* n)
+{
+ int bind, type;
+
+ switch (n->on_type & S_ETC) {
+ case S_SCT:
+ type = 3; /* STT_SECTION */
+ break;
+ case S_FIL:
+ case S_MOD:
+ type = 4; /* STT_FILE */
+ break;
+ default:
+ switch (n->on_type & S_TYP) {
+ case S_MIN + TEXT:
+ type = 2; /* STT_FUNC */
+ break;
+ case S_MIN + ROM:
+ case S_MIN + DATA:
+ case S_MIN + BSS:
+ case S_MIN + NUM_SEGMENTS:
+ type = 1; /* STT_OBJECT */
+ break;
+ default:
+ type = 0; /* STT_NOTYPE */
+ break;
+ }
+ break;
+ }
+
+ if (n->on_type & S_EXT)
+ bind = 1; /* STB_GLOBAL */
+ else
+ bind = 0; /* STB_LOCAL */
+
+ return (bind << 4) | type;
+}
+
+/* Convert a symbol's section index from ack.out to ELF. */
+
+int cvsect(struct outname* n)
+{
+ switch (n->on_type & S_TYP) {
+ case S_ABS:
+ return 0xfff1; /* SHN_ABS */
+ case S_MIN + TEXT:
+ return N_TEXT;
+ case S_MIN + ROM:
+ return N_RODATA;
+ case S_MIN + DATA:
+ return N_DATA;
+ case S_MIN + BSS:
+ case S_MIN + NUM_SEGMENTS:
+ return N_BSS;
+ default:
+ return N_UNDEF;
+ }
+}
+
/* Writes a byte. */
void emit8(unsigned char value)
fileoffset += filesize;
}
+/* The next few functions write parts of the symbol table. */
+
+void emit_stab(void)
+{
+ struct outname* n;
+ int i;
+
+ for (i = 0; i < outhead.oh_nname; i++) {
+ n = &outname[i];
+ if (n->on_type & S_STB) {
+ emit32(cvname(n)); /* name index */
+ emit8(n->on_type >> 8); /* type */
+ emit8(cvsect(n)); /* section */
+ emit16(n->on_desc); /* desc */
+ emit32(n->on_valu); /* value */
+ }
+ }
+}
+
+void emit_symtab(void)
+{
+ struct outname* n;
+ int i;
+
+ for (i = 0; i < outhead.oh_nname; i++) {
+ n = &outname[i];
+ if (!(n->on_type & S_STB)) {
+ emit32(cvname(n)); /* name index */
+ emit32(n->on_valu); /* value */
+ emit32(0); /* size = unknown */
+ emit8(cvinfo(n)); /* info */
+ emit8(0); /* other */
+ emit16(cvsect(n)); /* section */
+ }
+ }
+}
+
+void emit_strtab(void)
+{
+ /* We prepend a '\0' because ELF uses offset 0 for symbols
+ * without a name. */
+ emit8('\0');
+ writef(stringarea, outhead.oh_nchar, 1);
+}
+
+void emit_shstrtab(void)
+{
+ if (nstab) {
+ writef(shstrtab, sizeof(shstrtab), 1);
+ } else {
+ /* Skip .stab and .stabstr */
+ int i = sh_name[N_SYMTAB];
+ writef(shstrtab, sh_name[N_STAB], 1);
+ writef(shstrtab + i, sizeof(shstrtab) - i, 1);
+ }
+}
+
+/* Writes out an ELF section header. */
+
+void emit_sh(int i)
+{
+ uint32_t name, type, flags, addr, offset, size, addralign,
+ link, entsize;
+
+ /* If no debugger symbols, skip .stab and .stabstr */
+ if (nstab == 0 && (i == N_STAB || i == N_STABSTR))
+ return;
+
+ name = sh_name[i];
+ if (nstab == 0 && i >= N_STAB)
+ name -= (sh_name[N_SYMTAB] - sh_name[N_STAB]);
+
+ switch (i) {
+ case N_TEXT:
+ case N_RODATA:
+ case N_DATA:
+ case N_STAB:
+ type = 1; /* SHT_PROGBITS */
+ break;
+ case N_BSS:
+ type = 8; /* SHT_NOBITS */
+ break;
+ case N_SYMTAB:
+ type = 2; /* SHT_SYMTAB */
+ break;
+ case N_STABSTR:
+ case N_STRTAB:
+ type = 3; /* SHT_STRTAB */
+ break;
+ default:
+ type = 0; /* SHT_NULL */
+ break;
+ }
+
+ switch (i) {
+ case N_TEXT:
+ flags = 4|2; /* SHF_EXECINSTR|SHF_ALLOC */
+ addr = outsect[TEXT].os_base;
+ offset = code_offset;
+ size = outsect[TEXT].os_size;
+ addralign = outsect[TEXT].os_lign;
+ break;
+ case N_RODATA:
+ flags = 2; /* SHF_ALLOC */
+ addr = outsect[ROM].os_base;
+ offset = code_offset + outsect[TEXT].os_size;
+ size = outsect[ROM].os_size;
+ addralign = outsect[ROM].os_lign;
+ break;
+ case N_DATA:
+ flags = 2|1; /* SHF_ALLOC|SHF_WRITE */
+ addr = outsect[DATA].os_base;
+ offset = code_offset + outsect[TEXT].os_size +
+ outsect[ROM].os_size;
+ size = outsect[DATA].os_size;
+ addralign = outsect[DATA].os_lign;
+ break;
+ case N_BSS:
+ flags = 2|1; /* SHF_ALLOC|SHF_WRITE */
+ addr = outsect[BSS].os_base;
+ offset = code_offset + outsect[TEXT].os_size +
+ outsect[ROM].os_size + outsect[DATA].os_size;
+ size = outsect[BSS].os_size;
+ addralign = outsect[BSS].os_lign;
+ break;
+ default:
+ flags = addr = offset = size = addralign = 0;
+ break;
+ }
+
+ entsize = 0;
+ switch (i) {
+ case N_STAB:
+ offset = stab_offset;
+ size = STAB_SYMBOL_SIZE * nstab;
+ entsize = STAB_SYMBOL_SIZE;
+ break;
+ case N_SYMTAB:
+ offset = symtab_offset;
+ size = ELF_SYMBOL_SIZE * nsym;
+ entsize = ELF_SYMBOL_SIZE;
+ break;
+ case N_STABSTR:
+ case N_STRTAB:
+ /* .stabstr, .strtab share the string area */
+ offset = strtab_offset;
+ /* the + 1 because we prepend a '\0' */
+ size = 1 + outhead.oh_nchar;
+ break;
+ case N_SHSTRTAB:
+ offset = shstrtab_offset;
+ size = shstrtab_size;
+ break;
+ }
+
+ /* Link .stab to .stabstr and .symtab to .strtab */
+ switch (i) {
+ case N_STAB:
+ link = N_STABSTR;
+ break;
+ case N_SYMTAB:
+ link = N_STRTAB;
+ if (nstab == 0)
+ link -= 2;
+ break;
+ default:
+ link = 0;
+ break;
+ }
+
+ emit32(name);
+ emit32(type);
+ emit32(flags);
+ emit32(addr);
+ emit32(offset);
+ emit32(size);
+ emit32(link);
+ emit32(0); /* info */
+ emit32(addralign);
+ emit32(entsize);
+}
+
/* Macros from modules/src/object/obj.h */
#define Xchar(ch) ((ch) & 0377)
#define uget2(c) (Xchar((c)[0]) | ((unsigned) Xchar((c)[1]) << 8))
return 1 ;
}
+/*
+ * Read the ack.out symbol table and string area. Count symbols.
+ * Seek back to the current file position.
+ */
+int rnames(FILE* f)
+{
+ long told;
+ int i;
+
+ /* If no symbols, then do nothing successfully. */
+ if (outhead.oh_nname == 0)
+ return 1;
+
+ /* Seek to the symbol table. */
+ told = ftell(f);
+ if (told == -1)
+ return 0;
+ ack_off_char = OFF_CHAR(outhead); /* for cvname() */
+ if (fseek(f, OFF_NAME(outhead), SEEK_SET))
+ return 0;
+
+ /* Using calloc(a, b) to check if a * b would overflow. */
+ outname = calloc(outhead.oh_nname, sizeof(outname[0]));
+ if (outname == NULL)
+ fatal("out of memory.");
+ for (i = 0; i < outhead.oh_nname; i++) {
+ char buf[SZ_NAME], *c;
+ if (fread(buf, SZ_NAME, 1, f) != 1)
+ return 0;
+ c = buf;
+ outname[i].on_foff = get4(c); c += 4;
+ outname[i].on_type = uget2(c); c += 2;
+ outname[i].on_desc = uget2(c); c += 2;
+ outname[i].on_valu = get4(c);
+ if (outname[i].on_type & S_STB)
+ nstab++;
+ else
+ nsym++;
+ }
+
+ stringarea = malloc(outhead.oh_nchar);
+ if (stringarea == NULL)
+ fatal("out of memory.");
+ if (fread(stringarea, outhead.oh_nchar, 1, f) != 1)
+ return 0;
+
+ if (fseek(f, told, SEEK_SET))
+ return 0;
+ return 1;
+}
+
int main(int argc, char* argv[])
{
/* General housecleaning and setup. */
break;
case 'h':
- fprintf(stderr, "%s: Syntax: aelflod [-a<number>] [-b] [-h] [-l]\n\t[-m<number>] <inputfile> <outputfile>\n",
+ fprintf(stderr, "%s: Syntax: aelflod [-a<number>] [-b] [-h] [-l]\n\t[-m<number>] [-v] <inputfile> <outputfile>\n",
program);
exit(0);
}
}
+ /* Read the symbol table, then seek back to the section data. */
+
+ if (!rnames(input))
+ fatal("failed to read symbol table.");
+
/* A few checks */
if (outsect[BSS].os_flen != 0)
/* Ensure the base address doesn't overlap the file header. */
- codeoffset = outsect[TEXT].os_base & 0x1FFF;
- if (codeoffset < (ELF_HEADER_SIZE + PROGRAM_HEADER_SIZE*PROGRAM_HEADER_COUNT))
+ code_offset = outsect[TEXT].os_base & 0x1FFF;
+ if (code_offset < (ELF_HEADER_SIZE + PROGRAM_HEADER_SIZE*PROGRAM_HEADER_COUNT))
fatal("base address too small --- overlaps ELF header");
/* Rationalise the memory sizes. */
outsect[DATA].os_size = outsect[BSS ].os_base - outsect[DATA].os_base;
outsect[BSS ].os_size = align(outsect[BSS].os_size, outsect[BSS].os_lign);
+ stab_offset = code_offset + outsect[TEXT].os_size +
+ outsect[ROM].os_size + outsect[DATA].os_size;
+
+ /* If we have symbols, then calculate some offsets. */
+
+ if (outhead.oh_nname) {
+ sh_count = NUM_ELF_SECTIONS;
+ shstrtab_nr = N_SHSTRTAB;
+ shstrtab_size = sizeof(shstrtab);
+ if (nstab == 0) {
+ /* Skip .stab and .stabstr */
+ sh_count -= 2;
+ shstrtab_nr -= 2;
+ shstrtab_size -=
+ (sh_name[N_SYMTAB] - sh_name[N_STAB]);
+ }
+
+ symtab_offset = stab_offset + STAB_SYMBOL_SIZE * nstab;
+ strtab_offset = symtab_offset + ELF_SYMBOL_SIZE * nsym;
+ /* the + 1 because we prepend a '\0' */
+ shstrtab_offset = strtab_offset + 1 + outhead.oh_nchar;
+ sh_offset = shstrtab_offset + shstrtab_size;
+ }
+
/* Write out the ELF file header. */
writef(elf_le_ident_string, 4, 1);
emit32(1); /* ELF version again */
emit32(outsect[TEXT].os_base); /* entry point */
emit32(ELF_HEADER_SIZE); /* program header offset */
- emit32(0); /* section header offset */
+ emit32(sh_offset); /* section header offset */
emit32(0); /* flags */
emit16(ELF_HEADER_SIZE); /* elf header size */
emit16(PROGRAM_HEADER_SIZE); /* program header entry size */
emit16(1); /* number of program header entries */
- emit16(0x28); /* section header entry size */
- emit16(0); /* number of section header entries */
- emit16(0); /* section header string table index = SHN_UNDEF */
+ emit16(SECTION_HEADER_SIZE); /* section header entry size */
+ emit16(sh_count); /* number of section header entries */
+ emit16(shstrtab_nr); /* section header string table index */
/* Write out a single rwx section for the entire program. */
{
- unsigned long filelength = codeoffset +
- outsect[TEXT].os_size +
- outsect[ROM].os_size +
- outsect[DATA].os_size;
-
- unsigned long memlength = filelength +
- outsect[BSS].os_size;
-
- emitphdr(outsect[TEXT].os_base & ~0x1FFF, filelength, memlength,
- 0, 4|2|1);
+ uint32_t filelength = stab_offset;
+ uint32_t memlength = filelength + outsect[BSS].os_size;
+
+ emitphdr(outsect[TEXT].os_base & ~0x1FFF,
+ filelength, memlength, 0, 4|2|1);
}
/* Write padding until the code start. */
-
- fseek(output, codeoffset, SEEK_SET);
+
+ if (fseek(output, code_offset, SEEK_SET))
+ fatal("output seek error");
/* Write out the actual data. */
emits(&outsect[ROM]);
emits(&outsect[DATA]);
+ /* Write out the symbol table and section headers. */
+
+ if (outhead.oh_nname) {
+ int i;
+ if (nstab)
+ emit_stab();
+ emit_symtab();
+ emit_strtab();
+ emit_shstrtab();
+ for (i = 0; i < NUM_ELF_SECTIONS; i++)
+ emit_sh(i);
+ }
+
if (ferror(output))
fatal("output write error");
if (outputfile)
{
uint32_t ss = 0;
printf(" address length\n");
- printf(" ehdr : %08"PRIx32" %08"PRIx32"\n", outsect[TEXT].os_base & ~0x1FFF, codeoffset);
+ printf(" ehdr : %08"PRIx32" %08"PRIx32"\n", outsect[TEXT].os_base & ~0x1FFF, code_offset);
printf(" text : %08"PRIx32" %08"PRIx32"\n", outsect[TEXT].os_base, outsect[TEXT].os_size);
printf(" rom : %08"PRIx32" %08"PRIx32"\n", outsect[ROM].os_base, outsect[ROM].os_size);
printf(" data : %08"PRIx32" %08"PRIx32"\n", outsect[DATA].os_base, outsect[DATA].os_size);
public / ack.git / commitdiff