From fcccfe7dd006abb3833220f48837ab5e8b03f233 Mon Sep 17 00:00:00 2001 From: Mitya Selivanov Date: Wed, 17 Jul 2024 20:42:51 +0200 Subject: Add section info values --- bxgen.c | 1209 +++++++++++++++------------------------------------------------ 1 file changed, 291 insertions(+), 918 deletions(-) (limited to 'bxgen.c') diff --git a/bxgen.c b/bxgen.c index 30f2b9f..af34b1a 100755 --- a/bxgen.c +++ b/bxgen.c @@ -99,6 +99,10 @@ exit $? # */ #define TESTING 1 #endif +#ifndef LOG_LEVEL +#define LOG_LEVEL 4 +#endif + // ================================================================ // // Basic declarations @@ -126,7 +130,7 @@ typedef char c8; // 8-bit character enum { // Log level - ERROR = 0, + ERROR = 1, WARNING, INFO, VERBOSE, @@ -364,7 +368,7 @@ i64 io_read(i64 f, i64 size, void *data, void *user_data); i64 io_write(i64 f, i64 size, void *data, void *user_data); void io_chmod_exe(i64 f, void *user_data); -void bx_log(i32 log_level, c8 *message, u32 line, c8 *file); +void bx_log(i32 log_level, u32 line, c8 *file, c8 *format, ...); void bx_assert(b8 condition, c8 *message, u32 line, c8 *file); void io_dispatch(i16 op, i64 *id, i64 *size, void *data, void *user_data); @@ -413,25 +417,29 @@ void l_static(i64 unit, c8 *static_library); do { \ b8 ok_ = (condition); \ if (!ok_) { \ - bx_log(ERROR, error_string, __LINE__, __FILE__); \ + bx_log(ERROR, __LINE__, __FILE__, error_string); \ return fail_result; \ } \ } while (0) #else -# define BX_CHECK(condition, error_string, fail_result) \ +# define BX_CHECK(condition, error_string, fail_result) \ bx_assert((condition), error_string, __LINE__, __FILE__) #endif -#define BX_LAX(condition, error_string) \ - do { \ - if (!(condition)) { \ - bx_log(WARNING, error_string, __LINE__, __FILE__); \ - } \ - } while (0) +#ifdef NDEBUG +# define BX_LAX(condition, error_string) \ + do { \ + if (!(condition)) \ + bx_log(WARNING, __LINE__, __FILE__, error_string); \ + } while (0) +#else +# define BX_LAX(condition, error_string) \ + bx_assert((condition), error_string, __LINE__, __FILE__) +#endif #ifdef NDEBUG -# define BX_FAIL(error_string, fail_result) \ - bx_log(ERROR, error_string, __LINE__, __FILE__); \ +# define BX_FAIL(error_string, fail_result) \ + bx_log(ERROR, __LINE__, __FILE__, error_string); \ return fail_result #else # define BX_FAIL(error_string, fail_result) \ @@ -439,8 +447,11 @@ void l_static(i64 unit, c8 *static_library); return fail_result #endif -#define BX_LOG(log_level, message) bx_log(log_level, message, __LINE__, __FILE__) -#define BX_TRACE BX_LOG(TRACE,"") +#define BX_LOG(log_level, ...) \ + do { \ + if (log_level <= LOG_LEVEL) \ + bx_log(log_level, __LINE__, __FILE__, __VA_ARGS__); \ + } while (0) i64 bx_align(i64 x, i64 a) { BX_CHECK(a > 0, "Invalid arguments", 0); @@ -1209,11 +1220,25 @@ enum { ELF_REL_ENTRY_SIZE = 16, ELF_RELA_ENTRY_SIZE = 24, + SEC_NONE = 0, + SEC_PROGRAM, + SEC_SYMBOLS, + SEC_STRINGS, + SEC_RELA, + SEC_HASH, + SEC_DYNAMIC, + SEC_NOTE, + SEC_ZEROS, + SEC_REL, + SEC_GROUP, + SYM_NONE = 0, SYM_PROC, SYM_DATA, - SYM_DATA_UNDEFINED, + SYM_DATA_COMMON, SYM_DATA_THREAD_LOCAL, + SYM_SECTION, + SYM_LOOS, BIND_LOCAL = 0, BIND_GLOBAL, @@ -1252,8 +1277,10 @@ typedef struct { typedef struct { Offset_Size name; - u32 type; - u64 flags; + u32 type_; + b8 alloc; + b8 write; + b8 exec; u64 alignment; u64 entry_size; u32 num_entries; @@ -1351,7 +1378,7 @@ Offset_Size elf_name_in_string_table( Offset_Size string_table, u32 name_offset ) { - if (name_offset == 0 || name_offset >= string_table.size) + if (name_offset == 0) return (Offset_Size) { .offset = 0, .size = 0, @@ -1389,10 +1416,7 @@ u16 elf_find_section_index_by_name( return i; } - BX_LOG(TRACE, name); - BX_LAX(0, "Not found"); - - return 0; + BX_FAIL("Section not found", 0); } Section_Header elf_section( @@ -1407,12 +1431,26 @@ Section_Header elf_section( u32 name_index = read_u32(LE, begin, end); u64 size = read_u64(LE, begin + 32, end); u64 entry_size = read_u64(LE, begin + 56, end); - u32 num_entries = entry_size > 0 ? size / entry_size : 0; + u32 num_entries = entry_size > 0 ? (size / entry_size) : 0; + u32 type = read_u32(LE, begin + 4, end); + u64 flags = read_u64(LE, begin + 8, end); return (Section_Header) { .name = elf_name_in_string_table(b, names, name_index), - .type = read_u32(LE, begin + 4, end), - .flags = read_u64(LE, begin + 8, end), + .type_ = type == 1 ? SEC_PROGRAM : + type == 2 ? SEC_SYMBOLS : + type == 3 ? SEC_STRINGS : + type == 4 ? SEC_RELA : + type == 5 ? SEC_HASH : + type == 6 ? SEC_DYNAMIC : + type == 7 ? SEC_NOTE : + type == 8 ? SEC_ZEROS : + type == 9 ? SEC_REL : + type == 10 ? SEC_GROUP : + SEC_NONE, + .alloc = (flags & 2) == 2, + .write = (flags & 1) == 1, + .exec = (flags & 4) == 4, .alignment = read_u64(LE, begin + 48, end), .entry_size = entry_size, .num_entries = num_entries, @@ -1486,11 +1524,15 @@ Symbol_Entry elf_symbol( BX_CHECK(dst.size == 0 || sym_value + sym_size <= dst.size, "Buffer overflow", (Symbol_Entry) {0}); - u8 type = (sym_info & 0xf) == 1 ? SYM_DATA : - (sym_info & 0xf) == 2 ? SYM_PROC : - (sym_info & 0xf) == 5 ? SYM_DATA_UNDEFINED : - (sym_info & 0xf) == 6 ? SYM_DATA_THREAD_LOCAL : - SYM_NONE; + u8 type = (sym_info & 0xf) == 1 ? SYM_DATA : + (sym_info & 0xf) == 2 ? SYM_PROC : + (sym_info & 0xf) == 3 ? SYM_SECTION : + (sym_info & 0xf) == 5 ? SYM_DATA_COMMON : + (sym_info & 0xf) == 6 ? SYM_DATA_THREAD_LOCAL : + (sym_info & 0xf) == 10 ? SYM_LOOS : + SYM_NONE; + + BX_CHECK(type != SYM_NONE || (sym_info & 0xf) == 0, "Unknown symbol type", (Symbol_Entry) {0}); u8 bind = (sym_info >> 4) == 1 ? BIND_GLOBAL : (sym_info >> 4) == 2 ? BIND_WEAK : @@ -1689,921 +1731,248 @@ void unit_write(Pool *pool, i64 unit, u16 target, i64 io_out, void *io_user_data // Intermediate buffer // - // if (0) - { - u8 static im_buffer[1024 * 1024 * 300]; // 300 MB - i64 static im_offsets[10000]; - i64 im_num = 0; - i64 im_size = 0; - - // Read all dependency files into the memory - // - { - u8 static in_buffer[1024 * 1024 * 100]; // 100 MB - - Unit *u = &pool->entities[unit].unit; - - for (i64 link_index = 0; link_index < u->num_links; ++link_index) { - i64 id = u->links[link_index]; - if (id == UNDEFINED) - continue; - Unit *l = &pool->entities[id].unit; - BX_CHECK(pool->entities[id].is_enabled, "Internal",); - BX_CHECK(l->type == UNIT_LIBRARY_STATIC, "Link type not supported",); - BX_CHECK(l->name_size > 0 && l->name_size <= MAX_NAME_SIZE, "Link name too big",); - - i64 f = io_open_read(l->name_size, l->name, io_user_data); - io_seek(f, 0, IO_SEEK_END, io_user_data); - - i64 in_size = io_tell(f, io_user_data); - BX_CHECK(in_size <= (i64) (sizeof in_buffer), "AR file too big",); - - io_seek(f, 0, IO_SEEK_BEGIN, io_user_data); - i64 n = io_read(f, in_size, in_buffer, io_user_data); - BX_CHECK(n == in_size, "Read failed",); - - io_close(f, io_user_data); - - // ======================================================== - // - // Read AR library - - u8 *ar_begin = in_buffer; - u8 *ar_end = in_buffer + in_size; - - BX_CHECK(bx_mem_eq(ar_begin, AR_MAGIC, 8), "Invalid AR file",); - - u8 *f_begin = ar_begin + 8; - - while (f_begin + 60 < ar_end) { - u8 *f_id = f_begin; - u8 *f_size = f_begin + 48; - u8 *f_end = f_begin + 58; - u8 *f_data = f_begin + 60; - - i64 fn_size; - { - c8 buf[7] = {0}; - bx_mem_cpy(buf, f_size, 6); - fn_size = atoi(buf); - } - - fn_size = bx_align(fn_size, 2); - - BX_CHECK(bx_mem_eq(f_end, "\x60\x0a", 2), "Invalid AR file",); - BX_CHECK(f_begin + fn_size <= ar_end, "Buffer overflow",); - - if (!bx_mem_eq(f_id, AR_SYMBOL_TABLE, 16) && - !bx_mem_eq(f_id, AR_STRING_TABLE, 16)) { - // Read ELF object file - - i64 delta_size = bx_align(fn_size, X86_64_ALIGNMENT); - - BX_CHECK(im_size + delta_size < (i64) (sizeof im_buffer), "Out of memory",); - BX_CHECK(im_num + 1 < (i64) (sizeof im_offsets / sizeof *im_offsets), "Out of memory",); - - bx_mem_cpy(im_buffer + im_size, f_data, fn_size); - - im_offsets[im_num] = im_size; - im_size += delta_size; - im_offsets[++im_num] = im_size; - } - - f_begin = f_data + fn_size; - } - } - - // ========================================================== - // - // Process ELF object files - - for (i64 elf_index = 0; elf_index < im_num; ++elf_index) { - u8 *elf_begin = im_buffer + im_offsets[elf_index]; - u8 *elf_end = im_buffer + im_offsets[elf_index + 1]; - - u8 osabi = read_u8(LE, elf_begin + 7, elf_end); - - BX_CHECK( read_u8 (LE, elf_begin, elf_end) == ELF_MAGIC[0], "Invalid ELF file",); - BX_CHECK( read_u8 (LE, elf_begin + 1, elf_end) == ELF_MAGIC[1], "Invalid ELF file",); - BX_CHECK( read_u8 (LE, elf_begin + 2, elf_end) == ELF_MAGIC[2], "Invalid ELF file",); - BX_CHECK( read_u8 (LE, elf_begin + 3, elf_end) == ELF_MAGIC[3], "Invalid ELF file",); - - BX_CHECK( read_u8 (LE, elf_begin + 4, elf_end) == ELF_64, "Unsupported ELF file",); - BX_CHECK( read_u8 (LE, elf_begin + 5, elf_end) == ELF_2_LE, "Unsupported ELF file",); - BX_CHECK( read_u8 (LE, elf_begin + 6, elf_end) == ELF_VERSION, "Unsupported ELF file",); - BX_CHECK( osabi == ELF_SYS_V || osabi == ELF_LINUX, "Unsupported ELF file",); - BX_CHECK( read_u8 (LE, elf_begin + 8, elf_end) == ELF_ABI_VERSION, "Unsupported ELF file",); - BX_CHECK( read_u16(LE, elf_begin + 16, elf_end) == ELF_RELOCATABLE, "Unsupported ELF file",); - BX_CHECK( read_u16(LE, elf_begin + 18, elf_end) == ELF_X86_64, "Unsupported ELF file",); - BX_CHECK( read_u32(LE, elf_begin + 20, elf_end) == ELF_VERSION, "Unsupported ELF file",); - - BX_LAX( read_u64(LE, elf_begin + 24, elf_end) == 0, "Invalid ELF file"); // entry - BX_LAX( read_u64(LE, elf_begin + 32, elf_end) == 0, "Invalid ELF file"); // program header offset - BX_LAX( read_u32(LE, elf_begin + 48, elf_end) == 0, "Invalid ELF file"); // flags - BX_LAX( read_u16(LE, elf_begin + 52, elf_end) == ELF_HEADER_SIZE, "Invalid ELF file"); - BX_LAX( read_u16(LE, elf_begin + 54, elf_end) == 0, "Invalid ELF file"); // program header size - BX_LAX( read_u16(LE, elf_begin + 56, elf_end) == 0, "Invalid ELF file"); // num program headers - BX_LAX( read_u16(LE, elf_begin + 58, elf_end) == ELF_SECTION_HEADER_SIZE, "Invalid ELF file"); - - Buffer_Context buf = { - .begin = im_buffer, - .end = im_buffer + im_offsets[im_num], - .elf = { - .offset = im_offsets[elf_index], - .size = im_offsets[elf_index + 1] - im_offsets[elf_index], - }, - }; - - Offset_Num section_headers = elf_section_headers(buf); - // Offset_Size section_names = elf_section_names_data(buf); - Offset_Size symbol_names = elf_find_section_by_name(buf, SECTION_STRTAB, sizeof SECTION_STRTAB - 1).data; - - for (u16 sec_index = 0; sec_index < section_headers.num; ++sec_index) { - Section_Header section = elf_section(buf, sec_index); - - if (section.type == 2 || section.type == 4 || section.type == 9) // sym/rela/rel - printf("\"%s", "\x1b[32m"); - else if ((section.flags & 2) != 0) // alloc - printf("\"%s", "\x1b[34m"); - else if (section.type == 3) // string table - printf("\"%s", "\x1b[33m"); - else - printf("\"%s", "\x1b[31m"); - - c8 *name = elf_name_from_offset(buf, section.name); - printf("%s", name); - printf("%s\"", "\x1b[37m"); - printf("%*s", - (i32) (section.name.size < 30 ? 30 - section.name.size : 1), ""); - - printf( - "%-10s", - section.type >= 1 && section.type <= 9 ? - (c8 *[]) { - "Program", - "Symbols", - "Strings", - "Rel add", - "Hash", - "Dynamic", - "Note", - "Zeros", - "Rel", - }[section.type - 1] : - section.type == 17 ? - "Group" : - "" - ); - - if ((section.flags & 2) == 2) - printf("R"); - else - printf("_"); - if ((section.flags & 1) == 1) - printf("W"); - else - printf("_"); - if ((section.flags & 4) == 4) - printf("X"); - else - printf("_"); - - if (section.data.size > 0) - printf(" - %lld bytes", section.data.size); - - printf("\n"); - - switch (section.type) { - case 2: { // sym - for (u32 sym_index = 0; sym_index < section.num_entries; ++sym_index) { - Symbol_Entry sym = elf_symbol(buf, section.data, symbol_names, (u16) sym_index); - printf(" %s\n", elf_name_from_offset(buf, sym.name)); - } - } break; - - case 4: { // rela - } break; - - case 9: { // rel - } break; - - default:; - } - } - - printf("\n"); - } - - // ========================================================== - } - return; - } - - // ============================================================== + u8 static im_buffer[1024 * 1024 * 300]; // 300 MB + i64 static im_offsets[10000]; + i64 im_num = 0; + i64 im_size = 0; - // Read dependencies + // Read all dependency files into the memory // { + u8 static in_buffer[1024 * 1024 * 100]; // 100 MB + Unit *u = &pool->entities[unit].unit; - for (i64 i = 0; i < u->num_links; ++i) { - if (u->links[i] == UNDEFINED) + for (i64 link_index = 0; link_index < u->num_links; ++link_index) { + i64 id = u->links[link_index]; + if (id == UNDEFINED) continue; - - i64 index = u->links[i]; - Unit *l = &pool->entities[index].unit; - - BX_CHECK(pool->entities[index].is_enabled, "",); - BX_CHECK(l->type == UNIT_LIBRARY_STATIC, "",); - BX_CHECK(l->name_size > 0 && l->name_size <= MAX_NAME_SIZE, "",); + Unit *l = &pool->entities[id].unit; + BX_CHECK(pool->entities[id].is_enabled, "Internal",); + BX_CHECK(l->type == UNIT_LIBRARY_STATIC, "Link type not supported",); + BX_CHECK(l->name_size > 0 && l->name_size <= MAX_NAME_SIZE, "Link name too big",); i64 f = io_open_read(l->name_size, l->name, io_user_data); + io_seek(f, 0, IO_SEEK_END, io_user_data); + + i64 in_size = io_tell(f, io_user_data); + BX_CHECK(in_size <= (i64) (sizeof in_buffer), "AR file too big",); - c8 buf0_[MAX_NAME_SIZE + 1] = { 0 }; - bx_mem_cpy(buf0_, l->name, l->name_size); - printf("\nReading `%s` library...\n\n", buf0_); + io_seek(f, 0, IO_SEEK_BEGIN, io_user_data); + i64 n = io_read(f, in_size, in_buffer, io_user_data); + BX_CHECK(n == in_size, "Read failed",); - i64 n = 0, current_offset = 0; + io_close(f, io_user_data); - // ========================================================== + // ======================================================== // // Read AR library - u8 magic[8]; - - n = io_read(f, sizeof magic, magic, io_user_data); if (n == 0) continue; - current_offset += n; - - BX_CHECK(magic[0] == '!', "",); - BX_CHECK(magic[1] == '<', "",); - BX_CHECK(magic[2] == 'a', "",); - BX_CHECK(magic[3] == 'r', "",); - BX_CHECK(magic[4] == 'c', "",); - BX_CHECK(magic[5] == 'h', "",); - BX_CHECK(magic[6] == '>', "",); - BX_CHECK(magic[7] == '\n', "",); - - u32 static offsets[10000] = { 0 }; - c8 static symbols[10000][256] = { 0 }; - b8 static found[10000] = { 0 }; - i64 num_symbols = 0; - - for (;;) { - c8 id[17] = { 0 }; - c8 timestamp[13] = { 0 }; - c8 owner[7] = { 0 }; - c8 group[7] = { 0 }; - c8 mode[9] = { 0 }; - c8 size[11] = { 0 }; - c8 end[2] = { 0 }; - - i64 file_offset = current_offset; - - n = io_read(f, (sizeof id) - 1, id, io_user_data); if (n == 0) break; current_offset += n; - n = io_read(f, (sizeof timestamp) - 1, timestamp, io_user_data); if (n == 0) break; current_offset += n; - n = io_read(f, (sizeof owner) - 1, owner, io_user_data); if (n == 0) break; current_offset += n; - n = io_read(f, (sizeof group) - 1, group, io_user_data); if (n == 0) break; current_offset += n; - n = io_read(f, (sizeof mode) - 1, mode, io_user_data); if (n == 0) break; current_offset += n; - n = io_read(f, (sizeof size) - 1, size, io_user_data); if (n == 0) break; current_offset += n; - n = io_read(f, sizeof end, end, io_user_data); if (n == 0) break; current_offset += n; - - BX_CHECK(end[0] == '\x60', "",); - BX_CHECK(end[1] == '\x0a', "",); - - if (bx_mem_eq(id, AR_SYMBOL_TABLE, 16)) { - // AR symbol table - // - - u32 num_be; - n = io_read(f, 4, &num_be, io_user_data); if (n == 0) break; - current_offset += n; - - num_symbols = - (( num_be & 0xffu) << 24) | - (((num_be >> 8) & 0xffu) << 16) | - (((num_be >> 16) & 0xffu) << 8) | - ((num_be >> 24) & 0xffu); - - printf("Symbol table - %lld symbols.\n\n", num_symbols); - BX_CHECK(num_symbols <= (i64) (sizeof offsets / sizeof *offsets), "",); - - for (u32 j = 0; j < num_symbols; ++j) { - u32 offset_be; - n = io_read(f, 4, &offset_be, io_user_data); if (n == 0) break; - current_offset += n; - - offsets[j] = - (( offset_be & 0xffu) << 24) | - (((offset_be >> 8) & 0xffu) << 16) | - (((offset_be >> 16) & 0xffu) << 8) | - ((offset_be >> 24) & 0xffu); - } - if (n == 0) break; - - i64 num_bytes = 0; - - for (u32 j = 0; j < num_symbols; ++j) { - i64 symbol_size = 0; - for (;; ++symbol_size) { - c8 c; - n = io_read(f, 1, &c, io_user_data); if (n == 0) break; - current_offset += n; - ++num_bytes; - if (c == '\0') - break; - BX_CHECK(symbol_size < 256, "",); - if (symbol_size < 256) - symbols[j][symbol_size] = c; - } - if (n == 0) break; - } - if (n == 0) break; - - if ((num_bytes & 1) == 1) { - // align - io_seek(f, 1, IO_SEEK_CURSOR, io_user_data); - current_offset += 1; - } - } else if (bx_mem_eq(id, AR_STRING_TABLE, 16)) { - // String table - // - - i64 num_bytes = atoi(size); - if ((num_bytes & 1) == 1) - ++num_bytes; // align - - b8 has_line = 0; - - while (num_bytes > 0) { - c8 c; - n = io_read(f, 1, &c, io_user_data); if (n == 0) break; - current_offset += n; - num_bytes -= n; - if (c == '\0') { - if (has_line) { - printf("\n"); - has_line = 0; - } - } else { - if (c == '/') { - if (!has_line) - printf(""); - } else - printf("%c", c); - has_line = 1; - } - } - } else { - if (bx_find_char(id, id + 16, '/') != NULL) - *bx_find_char(id, id + 16, '/') = '\0'; - if (bx_find_char(size, size + 6, ' ') != NULL) - *bx_find_char(size, size + 6, ' ') = '\0'; - - printf("%08llx %-16s - %5s bytes\n\n", - file_offset, - id, - size); - - // Search for symbols pointing to the current file - // - { - b8 symbol_found = 0; - for (i64 symbol_index = 0; symbol_index < num_symbols; ++symbol_index) - if (offsets[symbol_index] == file_offset) { - printf(" %-50s\n", - symbols[symbol_index]); - found[symbol_index] = 1; - symbol_found = 1; - } - if (!symbol_found) - printf(" \n"); - } - - // ====================================================== - // - // Decode ELF object file - - i64 num_bytes = atoi(size); - if ((num_bytes & 1) == 1) - ++num_bytes; // align - - i64 begin_offset = current_offset; - - u8 buf[16]; - n = io_read(f, sizeof buf, buf, io_user_data); if (n == 0) break; - current_offset += n; - num_bytes -= n; - - BX_CHECK(buf[0] == 0x7f, "",); - BX_CHECK(buf[1] == 'E', "",); - BX_CHECK(buf[2] == 'L', "",); - BX_CHECK(buf[3] == 'F', "",); - - BX_CHECK(buf[4] == ELF_64, "",); - BX_CHECK(buf[5] == ELF_2_LE, "",); - BX_CHECK(buf[6] == ELF_VERSION, "",); - BX_CHECK(buf[7] == ELF_SYS_V || buf[7] == ELF_LINUX, "",); - BX_CHECK(buf[8] == ELF_ABI_VERSION, "",); - - #define READ(x) do { \ - n = io_read(f, sizeof (x), \ - &(x), \ - io_user_data); \ - current_offset += n; \ - num_bytes -= n; \ - } while (0) - - u64 section_header_offset; - u16 num_sections; - u16 strings_index; - u64 strings_offset; - - u64 symbol_names_offset; - u64 symbol_names_size; - b8 symbol_names_found = 0; - - // ELF header - // - { - u16 type; - u16 machine; - u32 ver; - u64 entry; - u64 program_header_offset; - u32 flags; - u16 elf_header_size; - u16 program_header_size; - u16 num_program_headers; - u16 section_header_size; - - READ(type); - READ(machine); - READ(ver); - READ(entry); - READ(program_header_offset); - READ(section_header_offset); - READ(flags); - READ(elf_header_size); - READ(program_header_size); - READ(num_program_headers); - READ(section_header_size); - READ(num_sections); - READ(strings_index); - - BX_CHECK(type == ELF_RELOCATABLE, "",); - BX_CHECK(machine == ELF_X86_64, "",); - BX_CHECK(ver == ELF_VERSION, "",); - - BX_CHECK(entry == 0, "",); - BX_CHECK(program_header_offset == 0, "",); - BX_CHECK(flags == 0, "",); - BX_CHECK(elf_header_size == 64, "",); - BX_CHECK(program_header_size == 0, "",); - BX_CHECK(num_program_headers == 0, "",); - BX_CHECK(section_header_size == 64, "",); - - u64 section_offset = section_header_offset - (current_offset - begin_offset); - - io_seek(f, section_offset, IO_SEEK_CURSOR, io_user_data); - num_bytes -= section_offset; - current_offset += section_offset; - - // Find offset to the section name string table data - // - { - i64 prev_offset = current_offset; - io_seek(f, - begin_offset + section_header_offset + strings_index * 64 + 24, - IO_SEEK_BEGIN, io_user_data); - - n = io_read(f, 8, &strings_offset, io_user_data); if (n == 0) break; - - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - } - - // Find offset to the symbol string table data - // - { - i64 prev_offset = current_offset; - i64 prev_num_bytes = num_bytes; - - for (u16 i = 0; i < num_sections; ++i) { - io_seek(f, - begin_offset + section_header_offset + i * 64, - IO_SEEK_BEGIN, io_user_data); - u32 name; - u64 offset; - u64 size; - - READ(name); - io_seek(f, 20, IO_SEEK_CURSOR, io_user_data); - READ(offset); - READ(size); - - // Search for the name in the string table - // - - io_seek(f, - begin_offset + strings_offset + name, - IO_SEEK_BEGIN, io_user_data); - - c8 buf[8]; - n = io_read(f, sizeof buf, buf, io_user_data); if (n == 0) break; - - if (!bx_mem_eq(buf, SECTION_STRTAB, sizeof SECTION_STRTAB - 1)) - continue; - - symbol_names_offset = offset; - symbol_names_size = size; - symbol_names_found = 1; - break; - } - - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - num_bytes = prev_num_bytes; - } - } - - for (u16 i = 0; i < num_sections; ++i) { - u32 name; - u32 type; - u64 flags; - u64 addr; - u64 offset; - u64 size; - u32 link; - u32 info; - u64 addralign; - u64 entsize; - - READ(name); - READ(type); - READ(flags); - READ(addr); - READ(offset); - READ(size); - READ(link); - READ(info); - READ(addralign); - READ(entsize); - - if (type == 0) { - printf("\n"); - continue; - } - - if (type == 2 || type == 4 || type == 9) // sym/rela/rel - printf("%s", "\x1b[32m"); - else if ((flags & 2) != 0) // alloc - printf("%s", "\x1b[34m"); - else if (type == 3) // string table - printf("%s", "\x1b[33m"); - else - printf("%s", "\x1b[31m"); - - // NOTE - // Only alloc (flags & 2) sections should be written to the output binary. - - // Search for the name in the string table - // - { - i64 prev_offset = current_offset; - io_seek(f, - begin_offset + strings_offset + name, - IO_SEEK_BEGIN, io_user_data); - - i32 padding = 50; - - printf(" "); - - for (;; --padding) { - c8 c; - n = io_read(f, 1, &c, io_user_data); if (n == 0) break; - if (c == '\0') - break; - printf("%c", c); - } - - if (padding > 0) - printf("%*s", padding, ""); - - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - } - - printf("%s", "\x1b[37m"); - - printf( - "%-10s", - type >= 1 && type <= 9 ? - (c8 *[]) { - "Program", - "Symbols", - "Strings", - "Rel add", - "Hash", - "Dynamic", - "Note", - "Zeros", - "Rel", - }[type - 1] : - type == 17 ? - "Group" : - "" - ); - - if ((flags & 2) == 2) - printf("R"); - else - printf("_"); - if ((flags & 1) == 1) - printf("W"); - else - printf("_"); - if ((flags & 4) == 4) - printf("X"); - else - printf("_"); - - if (size > 0) - printf(" - %lld bytes", size); - - printf("\n"); - - switch (type) { - // ================================================== - // - // Symbols - - case 2: { - // Find symbol addresses - // - - BX_CHECK(entsize == 24, "",); - - i64 prev_offset = current_offset; - i64 prev_num_bytes = num_bytes; - io_seek(f, - begin_offset + offset, - IO_SEEK_BEGIN, io_user_data); - current_offset = begin_offset + offset; - - printf("\n"); - - for (num_bytes = size; num_bytes > 0;) { - BX_CHECK(symbol_names_found, "",); - - u32 sym_name; - u8 sym_info; - u8 sym_other; - u16 sym_shndx; - u64 sym_value; - u64 sym_size; - - READ(sym_name); BX_CHECK(n != 0, "",); - READ(sym_info); BX_CHECK(n != 0, "",); - READ(sym_other); BX_CHECK(n != 0, "",); - READ(sym_shndx); BX_CHECK(n != 0, "",); - READ(sym_value); BX_CHECK(n != 0, "",); - READ(sym_size); BX_CHECK(n != 0, "",); - - printf(" "); - - if (sym_name != 0) { - if (sym_name < symbol_names_size) { - // Search for the symbol name in the string table - // - - i64 prev_offset = current_offset; - io_seek(f, - begin_offset + symbol_names_offset + sym_name, - IO_SEEK_BEGIN, io_user_data); - - i32 padding = 48; - - if ((sym_info & 0xf) == 1 || - (sym_info & 0xf) == 2) - printf("%s", "\x1b[32m"); - - printf("\""); - - for (;; --padding) { - c8 c; - n = io_read(f, 1, &c, io_user_data); if (n == 0) break; - if (c == '\0') - break; - printf("%c", c); - } - - printf("\""); - if ((sym_info & 0xf) == 1 || - (sym_info & 0xf) == 2) - printf("%s", "\x1b[37m"); - if (padding > 0) - printf("%*s", padding, ""); - - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - } else - printf("%-50d", sym_name); - } else - printf("%*s", 50, ""); - - printf("%08llx ", sym_value); // symbol address - - printf("%-8s ", - (sym_info & 0xf) <= 4 ? (c8 *[]) { - "No type", - "Data", - "Func", - "Section", - "File", - }[sym_info & 0xf] : "" - ); - - printf("%-3d", sym_shndx); - - if (sym_size != 0) - printf("- %lld bytes", sym_size); - printf("\n"); - } - - printf("\n"); - - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - num_bytes = prev_num_bytes; - } break; - - // ================================================== - // - // Relocarions without addends - - case 9: { - BX_CHECK(entsize == 16, "",); - - i64 prev_offset = current_offset; - i64 prev_num_bytes = num_bytes; - io_seek(f, begin_offset + offset, IO_SEEK_BEGIN, io_user_data); - current_offset = begin_offset + offset; - - printf("\n"); - - for (num_bytes = size; num_bytes > 0;) { - u64 rel_offset; - u64 rel_info; - - READ(rel_offset); BX_CHECK(n != 0, "",); - READ(rel_info); BX_CHECK(n != 0, "",); - - u32 rel_sym = (u32) (rel_info >> 32); - u32 rel_type = (u32) (rel_info & 0xffffffff); - - printf(" "); - - printf("%08llx sym %-2d type %-2d", rel_offset, rel_sym, rel_type); - printf("\n"); - } - - printf("\n"); - - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - num_bytes = prev_num_bytes; - } break; - - // ================================================== - // - // Relocarions with addends - // - // for .rela.NAME: - // - // .NAME[rela_offset] <- calc_reloc( - // B = base_memory_address - // P = rela_offset - // A = rela_addent - // S = .symtab[rela_sym].sym_value - // Z = .symtab[rela_sym].sym_size - // ) - - case 4: { - BX_CHECK(entsize == 24, "",); - - i64 prev_offset = current_offset; - i64 prev_num_bytes = num_bytes; - io_seek(f, begin_offset + offset, IO_SEEK_BEGIN, io_user_data); - current_offset = begin_offset + offset; - - printf("\n"); + u8 *ar_begin = in_buffer; + u8 *ar_end = in_buffer + in_size; - for (num_bytes = size; num_bytes > 0;) { - u64 rela_offset; - u64 rela_info; - i64 rela_addent; + BX_CHECK(bx_mem_eq(ar_begin, AR_MAGIC, 8), "Invalid AR file",); - READ(rela_offset); BX_CHECK(n != 0, "",); - READ(rela_info); BX_CHECK(n != 0, "",); - READ(rela_addent); BX_CHECK(n != 0, "",); + u8 *f_begin = ar_begin + 8; - u32 rela_sym = (u32) (rela_info >> 32); - u32 rela_type = (u32) (rela_info & 0xffffffff); + while (f_begin + 60 < ar_end) { + u8 *f_id = f_begin; + u8 *f_size = f_begin + 48; + u8 *f_end = f_begin + 58; + u8 *f_data = f_begin + 60; - printf(" "); - - printf("%08llx sym %-2d type %-2d add %-2lld", rela_offset, rela_sym, rela_type, rela_addent); - - // Check value from destination address - // - { - i64 prev_offset = current_offset; - i64 prev_num_bytes = num_bytes; - - u64 sym_size = 0; - - // Go to the symbol table - for (u64 j = 0; j < num_sections; ++j) { - io_seek(f, begin_offset + section_header_offset + j * 64 + 4, IO_SEEK_BEGIN, io_user_data); - u32 type; - READ(type); - - if (type != 2) continue; - - io_seek(f, 16, IO_SEEK_CURSOR, io_user_data); - u64 offset; - READ(offset); - - io_seek(f, begin_offset + offset + rela_sym * 24 + 16, IO_SEEK_BEGIN, io_user_data); - READ(sym_size); - - break; - } + i64 fn_size; + { + c8 buf[7] = {0}; + bx_mem_cpy(buf, f_size, 6); + fn_size = atoi(buf); + } - if (sym_size > 0) { - // NOTE Ad hok - // Go to the previous section - io_seek(f, begin_offset + section_header_offset + (i - 1) * 64 + 24, IO_SEEK_BEGIN, io_user_data); + fn_size = bx_align(fn_size, 2); - u64 offset; - u64 size; - READ(offset); - READ(size); + BX_CHECK(bx_mem_eq(f_end, "\x60\x0a", 2), "Invalid AR file",); + BX_CHECK(f_begin + fn_size <= ar_end, "Buffer overflow",); - if (size > 0) { - io_seek(f, begin_offset + offset + rela_offset, IO_SEEK_BEGIN, io_user_data); - u8 static buf[4]; - if (sym_size > 4) - sym_size = 4; - io_read(f, sym_size, buf, io_user_data); + if (!bx_mem_eq(f_id, AR_SYMBOL_TABLE, 16) && + !bx_mem_eq(f_id, AR_STRING_TABLE, 16)) { + // Read ELF object file - for (u32 k = 0; k < sym_size; ++k) - BX_CHECK(buf[k] == 0, "",); - } - } + i64 delta_size = bx_align(fn_size, X86_64_ALIGNMENT); - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - num_bytes = prev_num_bytes; - } + BX_CHECK(im_size + delta_size < (i64) (sizeof im_buffer), "Out of memory",); + BX_CHECK(im_num + 1 < (i64) (sizeof im_offsets / sizeof *im_offsets), "Out of memory",); - printf("\n"); - } + bx_mem_cpy(im_buffer + im_size, f_data, fn_size); - printf("\n"); + im_offsets[im_num] = im_size; + im_size += delta_size; + im_offsets[++im_num] = im_size; + } - io_seek(f, prev_offset, IO_SEEK_BEGIN, io_user_data); - current_offset = prev_offset; - num_bytes = prev_num_bytes; - } break; + f_begin = f_data + fn_size; + } + } - // ================================================== + // ========================================================== + // + // Process ELF object files + + for (i64 elf_index = 0; elf_index < im_num; ++elf_index) { + u8 *elf_begin = im_buffer + im_offsets[elf_index]; + u8 *elf_end = im_buffer + im_offsets[elf_index + 1]; + + u8 osabi = read_u8(LE, elf_begin + 7, elf_end); + + BX_CHECK( read_u8 (LE, elf_begin, elf_end) == ELF_MAGIC[0], "Invalid ELF file",); + BX_CHECK( read_u8 (LE, elf_begin + 1, elf_end) == ELF_MAGIC[1], "Invalid ELF file",); + BX_CHECK( read_u8 (LE, elf_begin + 2, elf_end) == ELF_MAGIC[2], "Invalid ELF file",); + BX_CHECK( read_u8 (LE, elf_begin + 3, elf_end) == ELF_MAGIC[3], "Invalid ELF file",); + + BX_CHECK( read_u8 (LE, elf_begin + 4, elf_end) == ELF_64, "Unsupported ELF file",); + BX_CHECK( read_u8 (LE, elf_begin + 5, elf_end) == ELF_2_LE, "Unsupported ELF file",); + BX_CHECK( read_u8 (LE, elf_begin + 6, elf_end) == ELF_VERSION, "Unsupported ELF file",); + BX_CHECK( osabi == ELF_SYS_V || osabi == ELF_LINUX, "Unsupported ELF file",); + BX_CHECK( read_u8 (LE, elf_begin + 8, elf_end) == ELF_ABI_VERSION, "Unsupported ELF file",); + BX_CHECK( read_u16(LE, elf_begin + 16, elf_end) == ELF_RELOCATABLE, "Unsupported ELF file",); + BX_CHECK( read_u16(LE, elf_begin + 18, elf_end) == ELF_X86_64, "Unsupported ELF file",); + BX_CHECK( read_u32(LE, elf_begin + 20, elf_end) == ELF_VERSION, "Unsupported ELF file",); + + BX_LAX( read_u64(LE, elf_begin + 24, elf_end) == 0, "Invalid ELF file"); // entry + BX_LAX( read_u64(LE, elf_begin + 32, elf_end) == 0, "Invalid ELF file"); // program header offset + BX_LAX( read_u32(LE, elf_begin + 48, elf_end) == 0, "Invalid ELF file"); // flags + BX_LAX( read_u16(LE, elf_begin + 52, elf_end) == ELF_HEADER_SIZE, "Invalid ELF file"); + BX_LAX( read_u16(LE, elf_begin + 54, elf_end) == 0, "Invalid ELF file"); // program header size + BX_LAX( read_u16(LE, elf_begin + 56, elf_end) == 0, "Invalid ELF file"); // num program headers + BX_LAX( read_u16(LE, elf_begin + 58, elf_end) == ELF_SECTION_HEADER_SIZE, "Invalid ELF file"); + + Buffer_Context buf = { + .begin = im_buffer, + .end = im_buffer + im_offsets[im_num], + .elf = { + .offset = im_offsets[elf_index], + .size = im_offsets[elf_index + 1] - im_offsets[elf_index], + }, + }; + + Offset_Num section_headers = elf_section_headers(buf); + + for (u16 sec_index = 0; sec_index < section_headers.num; ++sec_index) { + Section_Header section = elf_section(buf, sec_index); + + if (section.type_ == SEC_SYMBOLS || + section.type_ == SEC_RELA || + section.type_ == SEC_REL) + printf("\"%s", "\x1b[32m"); + else if (section.alloc) + printf("\"%s", "\x1b[34m"); + else if (section.type_ == SEC_STRINGS) + printf("\"%s", "\x1b[33m"); + else + printf("\"%s", "\x1b[31m"); + + c8 *name = elf_name_from_offset(buf, section.name); + printf("%s", name); + printf("%s\"", "\x1b[37m"); + printf("%*s", + (i32) (section.name.size < 30 ? 30 - section.name.size : 1), ""); + + printf( + "%-10s", + (c8 *[]) { + "", + "Program", + "Symbols", + "Strings", + "Rel add", + "Hash", + "Dynamic", + "Note", + "Zeros", + "Rel", + "Group", + }[section.type_] + ); + + if (section.alloc) + printf("R"); + else + printf("_"); + if (section.write) + printf("W"); + else + printf("_"); + if (section.exec) + printf("X"); + else + printf("_"); + + if (section.data.size > 0) + printf(" - %lld bytes", section.data.size); - default:; - } - } + printf("\n"); - printf("\n"); + switch (section.type_) { + case SEC_SYMBOLS: { + Offset_Size symbol_names = elf_find_section_by_name(buf, SECTION_STRTAB, sizeof SECTION_STRTAB - 1).data; + + for (u32 sym_index = 0; sym_index < section.num_entries; ++sym_index) { + Symbol_Entry sym = elf_symbol(buf, section.data, symbol_names, (u16) sym_index); + + c8 *name = elf_name_from_offset(buf, sym.name); + + i32 len = *name == '\0' ? 4 : (i32) sym.name.size; + + printf(" "); + if (*name != '\0') + printf("\""); + + if (sym.bind == BIND_GLOBAL) + printf("\x1b[32m"); + else if (sym.bind == BIND_WEAK) + printf("\x1b[35m"); + else + printf("\x1b[31m"); + + if (*name != '\0') + printf("%s", name); + else + printf(""); + printf("\x1b[37m"); + + if (*name != '\0') + printf("\""); + + printf(" "); + if (len < 32) + printf("%.*s ", 32 - len, "........................................"); + printf(" "); + + switch (sym.type) { + case SYM_PROC: printf("\x1b[32mproc "); break; + case SYM_DATA: printf("\x1b[32mdata "); break; + case SYM_DATA_COMMON: printf("\x1b[33mdata "); break; + case SYM_DATA_THREAD_LOCAL: printf("\x1b[35mdata "); break; + case SYM_SECTION: printf("\x1b[31msection"); break; + case SYM_LOOS: printf("\x1b[31mloos "); break; + default: printf(" "); + } + printf("\x1b[37m"); + printf("\n"); + } + } break; - io_seek(f, num_bytes, IO_SEEK_CURSOR, io_user_data); - current_offset += num_bytes; + case SEC_RELA: { + } break; - #undef READ + case SEC_REL: { + } break; - // ====================================================== + default:; } } - for (i64 symbol_index = 0; symbol_index < num_symbols; ++symbol_index) - if (!found[symbol_index]) - printf(" ? : %-16s - %-50s\n", - "", - symbols[symbol_index]); - - // ========================================================== - - io_close(f, io_user_data); + printf("\n"); } } } @@ -2660,25 +2029,29 @@ void io_chmod_exe(i64 f, void *user_data) { #include #include #include +#include #ifdef __unix__ #include #include #endif -#define BX_LOGF(log_level, ...) \ - do { \ - c8 buf[1024] = {0}; \ - sprintf(buf, __VA_ARGS__); \ - BX_LOG(log_level, buf); \ - } while (0) +void bx_log(i32 log_level, u32 line, c8 *file, c8 *format, ...) { + if (file == NULL || format == NULL) + return; -void bx_log(i32 log_level, c8 *message, u32 line, c8 *file) { - if (*message == '\0' && log_level != TRACE) { + if (*format == '\0' && log_level != TRACE) { fprintf(log_level == ERROR || log_level == WARNING ? stderr : stdout, "\n"); return; } + c8 message[256]; + + va_list ap; + va_start(ap, format); + vsprintf(message, format, ap); + va_end(ap); + fflush(stdout); i32 len = 56 - (i32) bx_str_len_or(message, message + 56, 56); switch (log_level) { @@ -2729,7 +2102,7 @@ void bx_assert(b8 condition, c8 *message, u32 line, c8 *file) { if (condition) return; - bx_log(ERROR, message, line, file); + bx_log(ERROR, line, file, message); exit(-1); } -- cgit v1.2.3