From 1c518bfa075c3ca681c147c4862fd6be5112d688 Mon Sep 17 00:00:00 2001 From: Nikita Smith Date: Mon, 31 Mar 2025 22:53:10 -0700 Subject: [PATCH] prefix COFF machine enums with "Type" --- src/codeview/codeview.c | 48 ++++++++++++------------ src/coff/coff.c | 22 +++++------ src/coff/coff.h | 55 ++++++++++++++------------- src/coff/coff_enum.c | 60 +++++++++++++++--------------- src/coff/coff_parse.c | 30 +++++++-------- src/ctrl/ctrl_core.c | 4 +- src/demon/win32/demon_core_win32.c | 4 +- src/linker/lnk.c | 34 ++++++++--------- src/linker/lnk_config.c | 48 ++++++++++++------------ src/linker/lnk_import_table.c | 10 ++--- src/linker/lnk_lib.c | 2 +- src/linker/lnk_reloc.c | 6 +-- src/linker/lnk_section_table.c | 4 +- src/linker/rdi/rdi_coff.c | 48 ++++++++++++------------ src/pe/pe.c | 14 +++---- src/radcon/radcon_coff.c | 48 ++++++++++++------------ src/raddump/raddump.c | 24 ++++++------ 17 files changed, 230 insertions(+), 231 deletions(-) diff --git a/src/codeview/codeview.c b/src/codeview/codeview.c index 4836c249..fbae1c89 100644 --- a/src/codeview/codeview.c +++ b/src/codeview/codeview.c @@ -14,30 +14,30 @@ cv_arch_from_coff_machine(COFF_MachineType machine) CV_Arch arch = 0; switch(machine) { - case COFF_Machine_X64: arch = CV_Arch_X64; break; - case COFF_Machine_X86: arch = CV_Arch_8086; break; - case COFF_Machine_Am33: arch = CV_Arch_AM33; break; - case COFF_Machine_Arm: NotImplemented; break; - case COFF_Machine_Arm64: arch = CV_Arch_ARM64; break; - case COFF_Machine_ArmNt: arch = CV_Arch_ARMNT; break; - case COFF_Machine_Ebc: arch = CV_Arch_EBC; break; - case COFF_Machine_Ia64: arch = CV_Arch_IA64; break; - case COFF_Machine_M32R: arch = CV_Arch_M32R; break; - case COFF_Machine_Mips16: arch = CV_Arch_MIPS16; break; - case COFF_Machine_MipsFpu: NotImplemented; break; - case COFF_Machine_MipsFpu16: NotImplemented; break; - case COFF_Machine_PowerPc: NotImplemented; break; - case COFF_Machine_PowerPcFp: arch = CV_Arch_PPCFP; break; - case COFF_Machine_R4000: NotImplemented; break; - case COFF_Machine_RiscV32: NotImplemented; break; - case COFF_Machine_RiscV64: NotImplemented; break; - case COFF_Machine_RiscV128: NotImplemented; break; - case COFF_Machine_Sh3: arch = CV_Arch_SH3; break; - case COFF_Machine_Sh3Dsp: arch = CV_Arch_SH3DSP; break; - case COFF_Machine_Sh4: arch = CV_Arch_SH4; break; - case COFF_Machine_Sh5: NotImplemented; break; - case COFF_Machine_Thumb: arch = CV_Arch_THUMB; break; - case COFF_Machine_WceMipsV2: NotImplemented; break; + case COFF_MachineType_X64: arch = CV_Arch_X64; break; + case COFF_MachineType_X86: arch = CV_Arch_8086; break; + case COFF_MachineType_Am33: arch = CV_Arch_AM33; break; + case COFF_MachineType_Arm: NotImplemented; break; + case COFF_MachineType_Arm64: arch = CV_Arch_ARM64; break; + case COFF_MachineType_ArmNt: arch = CV_Arch_ARMNT; break; + case COFF_MachineType_Ebc: arch = CV_Arch_EBC; break; + case COFF_MachineType_Ia64: arch = CV_Arch_IA64; break; + case COFF_MachineType_M32R: arch = CV_Arch_M32R; break; + case COFF_MachineType_Mips16: arch = CV_Arch_MIPS16; break; + case COFF_MachineType_MipsFpu: NotImplemented; break; + case COFF_MachineType_MipsFpu16: NotImplemented; break; + case COFF_MachineType_PowerPc: NotImplemented; break; + case COFF_MachineType_PowerPcFp: arch = CV_Arch_PPCFP; break; + case COFF_MachineType_R4000: NotImplemented; break; + case COFF_MachineType_RiscV32: NotImplemented; break; + case COFF_MachineType_RiscV64: NotImplemented; break; + case COFF_MachineType_RiscV128: NotImplemented; break; + case COFF_MachineType_Sh3: arch = CV_Arch_SH3; break; + case COFF_MachineType_Sh3Dsp: arch = CV_Arch_SH3DSP; break; + case COFF_MachineType_Sh4: arch = CV_Arch_SH4; break; + case COFF_MachineType_Sh5: NotImplemented; break; + case COFF_MachineType_Thumb: arch = CV_Arch_THUMB; break; + case COFF_MachineType_WceMipsV2: NotImplemented; break; } return arch; } diff --git a/src/coff/coff.c b/src/coff/coff.c index 0f2ba099..cc3cdd4e 100644 --- a/src/coff/coff.c +++ b/src/coff/coff.c @@ -174,8 +174,8 @@ internal U64 coff_apply_size_from_reloc(COFF_MachineType machine, COFF_RelocType x) { switch (machine) { - case COFF_Machine_X64: return coff_apply_size_from_reloc_x64(x); - case COFF_Machine_X86: return coff_apply_size_from_reloc_x86(x); + case COFF_MachineType_X64: return coff_apply_size_from_reloc_x64(x); + case COFF_MachineType_X86: return coff_apply_size_from_reloc_x86(x); default: NotImplemented; } return 0; @@ -221,7 +221,7 @@ coff_make_import_header_by_name(Arena *arena, flags |= COFF_ImportBy_Name << COFF_ImportHeader_ImportByShift; COFF_ImportHeader header = {0}; - header.sig1 = COFF_Machine_Unknown; + header.sig1 = COFF_MachineType_Unknown; header.sig2 = max_U16; header.version = 0; header.machine = machine; @@ -264,7 +264,7 @@ coff_make_import_header_by_ordinal(Arena *arena, flags |= COFF_ImportBy_Ordinal << COFF_ImportHeader_ImportByShift; COFF_ImportHeader header = {0}; - header.sig1 = COFF_Machine_Unknown; + header.sig1 = COFF_MachineType_Unknown; header.sig2 = max_U16; header.version = 0; header.machine = machine; @@ -298,8 +298,8 @@ coff_word_size_from_machine(COFF_MachineType machine) { U64 result = 0; switch (machine) { - case COFF_Machine_X64: result = 8; break; - case COFF_Machine_X86: result = 4; break; + case COFF_MachineType_X64: result = 8; break; + case COFF_MachineType_X86: result = 4; break; } return result; } @@ -332,11 +332,11 @@ arch_from_coff_machine(COFF_MachineType machine) { Arch result = Arch_Null; switch (machine) { - case COFF_Machine_Unknown: break; - case COFF_Machine_X86: result = Arch_x86; break; - case COFF_Machine_X64: result = Arch_x64; break; - case COFF_Machine_Arm: result = Arch_arm32; break; - case COFF_Machine_Arm64: result = Arch_arm64; break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X86: result = Arch_x86; break; + case COFF_MachineType_X64: result = Arch_x64; break; + case COFF_MachineType_Arm: result = Arch_arm32; break; + case COFF_MachineType_Arm64: result = Arch_arm64; break; } return result; } diff --git a/src/coff/coff.h b/src/coff/coff.h index c109a966..6ff6c1af 100644 --- a/src/coff/coff.h +++ b/src/coff/coff.h @@ -47,32 +47,31 @@ enum typedef U16 COFF_MachineType; enum { - // TODO(rjf): COFF_Machine prefix -> COFF_MachineType prefix - COFF_Machine_Unknown = 0x0, - COFF_Machine_X86 = 0x14c, - COFF_Machine_X64 = 0x8664, - COFF_Machine_Am33 = 0x1d3, - COFF_Machine_Arm = 0x1c0, - COFF_Machine_Arm64 = 0xaa64, - COFF_Machine_ArmNt = 0x1c4, - COFF_Machine_Ebc = 0xebc, - COFF_Machine_Ia64 = 0x200, - COFF_Machine_M32R = 0x9041, - COFF_Machine_Mips16 = 0x266, - COFF_Machine_MipsFpu = 0x366, - COFF_Machine_MipsFpu16 = 0x466, - COFF_Machine_PowerPc = 0x1f0, - COFF_Machine_PowerPcFp = 0x1f1, - COFF_Machine_R4000 = 0x166, - COFF_Machine_RiscV32 = 0x5032, - COFF_Machine_RiscV64 = 0x5064, - COFF_Machine_RiscV128 = 0x5128, - COFF_Machine_Sh3 = 0x1a2, - COFF_Machine_Sh3Dsp = 0x1a3, - COFF_Machine_Sh4 = 0x1a6, - COFF_Machine_Sh5 = 0x1a8, - COFF_Machine_Thumb = 0x1c2, - COFF_Machine_WceMipsV2 = 0x169 + COFF_MachineType_Unknown = 0x0, + COFF_MachineType_X86 = 0x14c, + COFF_MachineType_X64 = 0x8664, + COFF_MachineType_Am33 = 0x1d3, + COFF_MachineType_Arm = 0x1c0, + COFF_MachineType_Arm64 = 0xaa64, + COFF_MachineType_ArmNt = 0x1c4, + COFF_MachineType_Ebc = 0xebc, + COFF_MachineType_Ia64 = 0x200, + COFF_MachineType_M32R = 0x9041, + COFF_MachineType_Mips16 = 0x266, + COFF_MachineType_MipsFpu = 0x366, + COFF_MachineType_MipsFpu16 = 0x466, + COFF_MachineType_PowerPc = 0x1f0, + COFF_MachineType_PowerPcFp = 0x1f1, + COFF_MachineType_R4000 = 0x166, + COFF_MachineType_RiscV32 = 0x5032, + COFF_MachineType_RiscV64 = 0x5064, + COFF_MachineType_RiscV128 = 0x5128, + COFF_MachineType_Sh3 = 0x1a2, + COFF_MachineType_Sh3Dsp = 0x1a3, + COFF_MachineType_Sh4 = 0x1a6, + COFF_MachineType_Sh5 = 0x1a8, + COFF_MachineType_Thumb = 0x1c2, + COFF_MachineType_WceMipsV2 = 0x169 }; typedef struct COFF_FileHeader @@ -88,7 +87,7 @@ typedef struct COFF_FileHeader typedef struct COFF_BigObjHeader { - U16 sig1; // COFF_Machine_Unknown + U16 sig1; // COFF_MachineType_Unknown U16 sig2; // max_U16 U16 version; // 2 COFF_MachineType machine; @@ -548,7 +547,7 @@ enum typedef struct COFF_ImportHeader { - U16 sig1; // COFF_Machine_Unknown + U16 sig1; // COFF_MachineType_Unknown U16 sig2; // max_U16 U16 version; // 0 COFF_MachineType machine; diff --git a/src/coff/coff_enum.c b/src/coff/coff_enum.c index 7636a78b..ccd96eeb 100644 --- a/src/coff/coff_enum.c +++ b/src/coff/coff_enum.c @@ -21,31 +21,31 @@ read_only struct String8 string; COFF_MachineType machine; } g_coff_machine_map[] = { - { str8_lit_comp(""), COFF_Machine_Unknown }, - { str8_lit_comp("X86"), COFF_Machine_X86 }, - { str8_lit_comp("Amd64"), COFF_Machine_X64 }, - { str8_lit_comp("X64"), COFF_Machine_X64 }, - { str8_lit_comp("Am33"), COFF_Machine_Am33 }, - { str8_lit_comp("Arm"), COFF_Machine_Arm }, - { str8_lit_comp("Arm64"), COFF_Machine_Arm64 }, - { str8_lit_comp("ArmNt"), COFF_Machine_ArmNt }, - { str8_lit_comp("Ebc"), COFF_Machine_Ebc }, - { str8_lit_comp("Ia64"), COFF_Machine_Ia64 }, - { str8_lit_comp("M32r"), COFF_Machine_M32R }, - { str8_lit_comp("Mips16"), COFF_Machine_Mips16 }, - { str8_lit_comp("MipsFpu"), COFF_Machine_MipsFpu }, - { str8_lit_comp("MipsFpu16"), COFF_Machine_MipsFpu16 }, - { str8_lit_comp("PowerPc"), COFF_Machine_PowerPc }, - { str8_lit_comp("PowerPcFp"), COFF_Machine_PowerPcFp }, - { str8_lit_comp("R4000"), COFF_Machine_R4000 }, - { str8_lit_comp("RiscV32"), COFF_Machine_RiscV32 }, - { str8_lit_comp("RiscV64"), COFF_Machine_RiscV64 }, - { str8_lit_comp("Sh3"), COFF_Machine_Sh3 }, - { str8_lit_comp("Sh3Dsp"), COFF_Machine_Sh3Dsp }, - { str8_lit_comp("Sh4"), COFF_Machine_Sh4 }, - { str8_lit_comp("Sh5"), COFF_Machine_Sh5 }, - { str8_lit_comp("Thumb"), COFF_Machine_Thumb }, - { str8_lit_comp("WceMipsV2"), COFF_Machine_WceMipsV2 }, + { str8_lit_comp(""), COFF_MachineType_Unknown }, + { str8_lit_comp("X86"), COFF_MachineType_X86 }, + { str8_lit_comp("Amd64"), COFF_MachineType_X64 }, + { str8_lit_comp("X64"), COFF_MachineType_X64 }, + { str8_lit_comp("Am33"), COFF_MachineType_Am33 }, + { str8_lit_comp("Arm"), COFF_MachineType_Arm }, + { str8_lit_comp("Arm64"), COFF_MachineType_Arm64 }, + { str8_lit_comp("ArmNt"), COFF_MachineType_ArmNt }, + { str8_lit_comp("Ebc"), COFF_MachineType_Ebc }, + { str8_lit_comp("Ia64"), COFF_MachineType_Ia64 }, + { str8_lit_comp("M32r"), COFF_MachineType_M32R }, + { str8_lit_comp("Mips16"), COFF_MachineType_Mips16 }, + { str8_lit_comp("MipsFpu"), COFF_MachineType_MipsFpu }, + { str8_lit_comp("MipsFpu16"), COFF_MachineType_MipsFpu16 }, + { str8_lit_comp("PowerPc"), COFF_MachineType_PowerPc }, + { str8_lit_comp("PowerPcFp"), COFF_MachineType_PowerPcFp }, + { str8_lit_comp("R4000"), COFF_MachineType_R4000 }, + { str8_lit_comp("RiscV32"), COFF_MachineType_RiscV32 }, + { str8_lit_comp("RiscV64"), COFF_MachineType_RiscV64 }, + { str8_lit_comp("Sh3"), COFF_MachineType_Sh3 }, + { str8_lit_comp("Sh3Dsp"), COFF_MachineType_Sh3Dsp }, + { str8_lit_comp("Sh4"), COFF_MachineType_Sh4 }, + { str8_lit_comp("Sh5"), COFF_MachineType_Sh5 }, + { str8_lit_comp("Thumb"), COFF_MachineType_Thumb }, + { str8_lit_comp("WceMipsV2"), COFF_MachineType_WceMipsV2 }, }; read_only static struct { @@ -446,10 +446,10 @@ internal String8 coff_string_from_reloc(COFF_MachineType machine, COFF_RelocType x) { switch (machine) { - case COFF_Machine_X86: return coff_string_from_reloc_x86(x); - case COFF_Machine_X64: return coff_string_from_reloc_x64(x); - case COFF_Machine_Arm: return coff_string_from_reloc_arm(x); - case COFF_Machine_Arm64: return coff_string_from_reloc_arm64(x); + case COFF_MachineType_X86: return coff_string_from_reloc_x86(x); + case COFF_MachineType_X64: return coff_string_from_reloc_x64(x); + case COFF_MachineType_Arm: return coff_string_from_reloc_arm(x); + case COFF_MachineType_Arm64: return coff_string_from_reloc_arm64(x); } return str8_zero(); } @@ -462,7 +462,7 @@ coff_machine_from_string(String8 string) return g_coff_machine_map[i].machine; } } - return COFF_Machine_Unknown; + return COFF_MachineType_Unknown; } internal COFF_ImportType diff --git a/src/coff/coff_parse.c b/src/coff/coff_parse.c index 3e0aaee4..166be2ae 100644 --- a/src/coff/coff_parse.c +++ b/src/coff/coff_parse.c @@ -7,7 +7,7 @@ coff_is_big_obj(String8 raw_coff) B32 is_big_obj = 0; if (raw_coff.size >= sizeof(COFF_BigObjHeader)) { COFF_BigObjHeader *file_header32 = (COFF_BigObjHeader*)(raw_coff.str); - is_big_obj = file_header32->sig1 == COFF_Machine_Unknown && + is_big_obj = file_header32->sig1 == COFF_MachineType_Unknown && file_header32->sig2 == max_U16 && file_header32->version >= 2 && MemoryCompare(file_header32->magic, g_coff_big_header_magic, sizeof(file_header32->magic)) == 0; @@ -26,19 +26,19 @@ coff_is_obj(String8 raw_coff) // validate machine B32 is_machine_type_valid = 0; switch (header->machine) { - case COFF_Machine_Unknown: - case COFF_Machine_X86: case COFF_Machine_X64: - case COFF_Machine_Am33: case COFF_Machine_Arm: - case COFF_Machine_Arm64: case COFF_Machine_ArmNt: - case COFF_Machine_Ebc: case COFF_Machine_Ia64: - case COFF_Machine_M32R: case COFF_Machine_Mips16: - case COFF_Machine_MipsFpu:case COFF_Machine_MipsFpu16: - case COFF_Machine_PowerPc:case COFF_Machine_PowerPcFp: - case COFF_Machine_R4000: case COFF_Machine_RiscV32: - case COFF_Machine_RiscV64:case COFF_Machine_RiscV128: - case COFF_Machine_Sh3: case COFF_Machine_Sh3Dsp: - case COFF_Machine_Sh4: case COFF_Machine_Sh5: - case COFF_Machine_Thumb: case COFF_Machine_WceMipsV2: + case COFF_MachineType_Unknown: + case COFF_MachineType_X86: case COFF_MachineType_X64: + case COFF_MachineType_Am33: case COFF_MachineType_Arm: + case COFF_MachineType_Arm64: case COFF_MachineType_ArmNt: + case COFF_MachineType_Ebc: case COFF_MachineType_Ia64: + case COFF_MachineType_M32R: case COFF_MachineType_Mips16: + case COFF_MachineType_MipsFpu:case COFF_MachineType_MipsFpu16: + case COFF_MachineType_PowerPc:case COFF_MachineType_PowerPcFp: + case COFF_MachineType_R4000: case COFF_MachineType_RiscV32: + case COFF_MachineType_RiscV64:case COFF_MachineType_RiscV128: + case COFF_MachineType_Sh3: case COFF_MachineType_Sh3Dsp: + case COFF_MachineType_Sh4: case COFF_MachineType_Sh5: + case COFF_MachineType_Thumb: case COFF_MachineType_WceMipsV2: { is_machine_type_valid = 1; }break; @@ -499,7 +499,7 @@ coff_is_import(String8 raw_archive_member) if (raw_archive_member.size >= sizeof(U16)*2) { U16 *sig1 = (U16*)raw_archive_member.str; U16 *sig2 = sig1 + 1; - is_import = *sig1 == COFF_Machine_Unknown && *sig2 == 0xffff; + is_import = *sig1 == COFF_MachineType_Unknown && *sig2 == 0xffff; } return is_import; } diff --git a/src/ctrl/ctrl_core.c b/src/ctrl/ctrl_core.c index 360d5d3e..0c2316bf 100644 --- a/src/ctrl/ctrl_core.c +++ b/src/ctrl/ctrl_core.c @@ -3714,7 +3714,7 @@ ctrl_thread__module_open(CTRL_Handle process, CTRL_Handle module, Rng1U64 vaddr_ switch(file_header.machine) { default:{}break; - case COFF_Machine_X86: + case COFF_MachineType_X86: { PE_TLSHeader32 tls_header32 = {0}; dmn_process_read_struct(process.dmn_handle, vaddr_range.min + tls_voff_range.min, &tls_header32); @@ -3725,7 +3725,7 @@ ctrl_thread__module_open(CTRL_Handle process, CTRL_Handle module, Rng1U64 vaddr_ tls_header.zero_fill_size = (U64)tls_header32.zero_fill_size; tls_header.characteristics = (U64)tls_header32.characteristics; }break; - case COFF_Machine_X64: + case COFF_MachineType_X64: { dmn_process_read_struct(process.dmn_handle, vaddr_range.min + tls_voff_range.min, &tls_header); }break; diff --git a/src/demon/win32/demon_core_win32.c b/src/demon/win32/demon_core_win32.c index b4715f5b..5ed5e044 100644 --- a/src/demon/win32/demon_core_win32.c +++ b/src/demon/win32/demon_core_win32.c @@ -495,12 +495,12 @@ dmn_w32_image_info_from_process_base_vaddr(HANDLE process, U64 base_vaddr) Arch arch = Arch_Null; switch(coff_header.machine) { - case COFF_Machine_X86: + case COFF_MachineType_X86: { arch = Arch_x86; optional_size_off = OffsetOf(PE_OptionalHeader32, sizeof_image); }break; - case COFF_Machine_X64: + case COFF_MachineType_X64: { arch = Arch_x64; optional_size_off = OffsetOf(PE_OptionalHeader32Plus, sizeof_image); diff --git a/src/linker/lnk.c b/src/linker/lnk.c index 9d6b5a28..2283b570 100644 --- a/src/linker/lnk.c +++ b/src/linker/lnk.c @@ -1283,7 +1283,7 @@ lnk_push_linker_symbols(LNK_SymbolTable *symtab, COFF_MachineType machine) LNK_Symbol *image_base = lnk_symbol_table_push_defined_chunk(symtab, str8_lit("__ImageBase"), LNK_DefinedSymbolVisibility_Extern, 0, g_null_chunk_ptr, 0, COFF_ComdatSelect_Any, 0); { // load config symbols - if (machine == COFF_Machine_X86) { + if (machine == COFF_MachineType_X86) { lnk_symbol_table_push_defined_chunk(symtab, str8_lit(LNK_SAFE_SE_HANDLER_TABLE_SYMBOL_NAME), LNK_DefinedSymbolVisibility_Extern, 0, g_null_chunk_ptr, 0, COFF_ComdatSelect_NoDuplicates, 0); lnk_symbol_table_push_defined_chunk(symtab, str8_lit(LNK_SAFE_SE_HANDLER_COUNT_SYMBOL_NAME), LNK_DefinedSymbolVisibility_Extern, 0, g_null_chunk_ptr, 0, COFF_ComdatSelect_NoDuplicates, 0); } @@ -1604,7 +1604,7 @@ lnk_build_guard_tables(TP_Context *tp, } // TODO: emit table for SEH on X86 - if (machine == COFF_Machine_X86) { + if (machine == COFF_MachineType_X86) { lnk_not_implemented("__safe_se_handler_table"); lnk_not_implemented("__safe_se_handler_count"); } @@ -2372,7 +2372,7 @@ lnk_build_win32_image_header(LNK_SymbolTable *symtab, lnk_build_pe_magic(symtab, header_sect, pe_magic_chunk); lnk_build_coff_file_header(symtab, header_sect, coff_file_header_chunk, config->machine, config->time_stamp, config->file_characteristics); switch (config->machine) { - case COFF_Machine_X64: { + case COFF_MachineType_X64: { lnk_build_pe_optional_header_x64(symtab, header_sect, pe_optional_chunk, @@ -3404,8 +3404,8 @@ lnk_run(int argc, char **argv) String8 delay_helper_name = str8_zero(); switch (config->machine) { - case COFF_Machine_X86: delay_helper_name = str8_cstring(LNK_DELAY_LOAD_HELPER2_X86_SYMBOL_NAME); break; - case COFF_Machine_X64: delay_helper_name = str8_cstring(LNK_DELAY_LOAD_HELPER2_SYMBOL_NAME); break; + case COFF_MachineType_X86: delay_helper_name = str8_cstring(LNK_DELAY_LOAD_HELPER2_X86_SYMBOL_NAME); break; + case COFF_MachineType_X64: delay_helper_name = str8_cstring(LNK_DELAY_LOAD_HELPER2_SYMBOL_NAME); break; default: NotImplemented; } @@ -3464,7 +3464,7 @@ lnk_run(int argc, char **argv) if (is_delayed) { if (!imptab_delayed) { - Assert(config->machine != COFF_Machine_Unknown); + Assert(config->machine != COFF_MachineType_Unknown); B32 is_unloadable = !!(config->flags & LNK_ConfigFlag_DelayUnload); B32 is_bindable = !!(config->flags & LNK_ConfigFlag_DelayBind); imptab_delayed = lnk_import_table_alloc_delayed(st, symtab, config->machine, is_unloadable, is_bindable); @@ -3479,7 +3479,7 @@ lnk_run(int argc, char **argv) } } else { if (!imptab_static) { - Assert(config->machine != COFF_Machine_Unknown); + Assert(config->machine != COFF_MachineType_Unknown); imptab_static = lnk_import_table_alloc_static(st, symtab, config->machine); } LNK_ImportDLL *dll = lnk_import_table_search_dll(imptab_static, import_header->dll_name); @@ -3561,14 +3561,14 @@ lnk_run(int argc, char **argv) LNK_Obj *obj = &obj_node_arr.v[obj_idx].data; // derive machine from obj - if (config->machine == COFF_Machine_Unknown) { + if (config->machine == COFF_MachineType_Unknown) { config->machine = obj->machine; - } else if (config->machine != COFF_Machine_X64) { + } else if (config->machine != COFF_MachineType_X64) { lnk_error_with_loc(LNK_Error_UnsupportedMachine, obj->path, obj->lib_path, "%S machine is supported", coff_string_from_machine_type(obj->machine)); } else { // is obj machine compatible? if (config->machine != obj->machine && - obj->machine != COFF_Machine_Unknown) { // obj with unknown machine type is compatible with any other machine type + obj->machine != COFF_MachineType_Unknown) { // obj with unknown machine type is compatible with any other machine type lnk_error_obj(LNK_Error_IncompatibleObj, obj, "conflicting machine types expected %S but got %S", coff_string_from_machine_type(config->machine), @@ -3990,18 +3990,18 @@ lnk_run(int argc, char **argv) if (pdata_symbol) { String8 pdata = lnk_data_from_chunk_ref_no_pad(sect_id_map, image_data, pdata_symbol->u.defined.u.chunk->ref); switch (config->machine) { - case COFF_Machine_X86: - case COFF_Machine_X64: { + case COFF_MachineType_X86: + case COFF_MachineType_X64: { U64 count = pdata.size / sizeof(PE_IntelPdata); radsort((PE_IntelPdata *)pdata.str, count, lnk_pdata_is_before_x8664); } break; - case COFF_Machine_Arm64: - case COFF_Machine_Arm: { + case COFF_MachineType_Arm64: + case COFF_MachineType_Arm: { AssertAlways(!"TOOD: ARM"); } break; - case COFF_Machine_MipsFpu: - case COFF_Machine_Mips16: - case COFF_Machine_MipsFpu16: { + case COFF_MachineType_MipsFpu: + case COFF_MachineType_Mips16: + case COFF_MachineType_MipsFpu16: { AssertAlways(!"TODO: MIPS"); } break; } diff --git a/src/linker/lnk_config.c b/src/linker/lnk_config.c index aaae53c9..72b3dd12 100644 --- a/src/linker/lnk_config.c +++ b/src/linker/lnk_config.c @@ -355,11 +355,11 @@ lnk_get_default_function_pad_min(COFF_MachineType machine) { U64 function_pad_min = 0; switch (machine) { - case COFF_Machine_Unknown: break; - case COFF_Machine_X86: { + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X86: { function_pad_min = 5; } break; - case COFF_Machine_X64: { + case COFF_MachineType_X64: { function_pad_min = 6; } break; default: { @@ -399,12 +399,12 @@ lnk_get_default_subsystem_version(PE_WindowsSubsystem subsystem, COFF_MachineTyp case PE_WindowsSubsystem_WINDOWS_CUI: { switch (machine) { - case COFF_Machine_X64: - case COFF_Machine_X86: ver = make_version(6,0); break; + case COFF_MachineType_X64: + case COFF_MachineType_X86: ver = make_version(6,0); break; - case COFF_Machine_ArmNt: - case COFF_Machine_Arm64: - case COFF_Machine_Arm: ver = make_version(6,2); break; + case COFF_MachineType_ArmNt: + case COFF_MachineType_Arm64: + case COFF_MachineType_Arm: ver = make_version(6,2); break; default: lnk_not_implemented("define subsystem(%S) version for %S", pe_string_from_subsystem(subsystem), coff_string_from_machine_type(machine)); break; } @@ -412,12 +412,12 @@ lnk_get_default_subsystem_version(PE_WindowsSubsystem subsystem, COFF_MachineTyp case PE_WindowsSubsystem_WINDOWS_GUI: { switch (machine) { - case COFF_Machine_X64: - case COFF_Machine_X86: ver = make_version(6,0); break; + case COFF_MachineType_X64: + case COFF_MachineType_X86: ver = make_version(6,0); break; - case COFF_Machine_ArmNt: - case COFF_Machine_Arm64: - case COFF_Machine_Arm: ver = make_version(6,2); break; + case COFF_MachineType_ArmNt: + case COFF_MachineType_Arm64: + case COFF_MachineType_Arm: ver = make_version(6,2); break; default: lnk_not_implemented("define subsystem(%S) version for %S", pe_string_from_subsystem(subsystem), coff_string_from_machine_type(machine)); break; } @@ -447,13 +447,13 @@ lnk_get_min_subsystem_version(PE_WindowsSubsystem subsystem, COFF_MachineType ma case PE_WindowsSubsystem_WINDOWS_CUI: { switch (machine) { - case COFF_Machine_X86: ver = make_version(5,1); break; + case COFF_MachineType_X86: ver = make_version(5,1); break; - case COFF_Machine_X64: ver = make_version(5,2); break; + case COFF_MachineType_X64: ver = make_version(5,2); break; - case COFF_Machine_ArmNt: - case COFF_Machine_Arm64: - case COFF_Machine_Arm: ver = make_version(6,2); break; + case COFF_MachineType_ArmNt: + case COFF_MachineType_Arm64: + case COFF_MachineType_Arm: ver = make_version(6,2); break; default: lnk_not_implemented("define min subsystem(%S) version for %S", pe_string_from_subsystem(subsystem), coff_string_from_machine_type(machine)); break; } @@ -461,13 +461,13 @@ lnk_get_min_subsystem_version(PE_WindowsSubsystem subsystem, COFF_MachineType ma case PE_WindowsSubsystem_WINDOWS_GUI: { switch (machine) { - case COFF_Machine_X86: ver = make_version(5,1); break; + case COFF_MachineType_X86: ver = make_version(5,1); break; - case COFF_Machine_X64: ver = make_version(5,2); break; + case COFF_MachineType_X64: ver = make_version(5,2); break; - case COFF_Machine_ArmNt: - case COFF_Machine_Arm64: - case COFF_Machine_Arm: ver = make_version(6,2); break; + case COFF_MachineType_ArmNt: + case COFF_MachineType_Arm64: + case COFF_MachineType_Arm: ver = make_version(6,2); break; default: lnk_not_implemented("define min subsystem(%S) version for %S", pe_string_from_subsystem(subsystem), coff_string_from_machine_type(machine)); break; } @@ -1213,7 +1213,7 @@ lnk_apply_cmd_option_to_config(Arena *arena, LNK_Config *config, String8 cmd_nam case LNK_CmdSwitch_Machine: { if (value_strings.node_count == 1) { COFF_MachineType machine = coff_machine_from_string(value_strings.first->string); - if (machine != COFF_Machine_Unknown) { + if (machine != COFF_MachineType_Unknown) { config->machine = machine; } else { lnk_error_cmd_switch(LNK_Error_Cmdl, obj_path, lib_path, cmd_switch, "unknown parameter \"%S\"", value_strings.first->string); diff --git a/src/linker/lnk_import_table.c b/src/linker/lnk_import_table.c index 34f44e52..81b7d648 100644 --- a/src/linker/lnk_import_table.c +++ b/src/linker/lnk_import_table.c @@ -345,7 +345,7 @@ lnk_import_table_push_dll_delayed(LNK_ImportTable *imptab, LNK_SymbolTable *symt // emit tail merge LNK_Chunk *tail_merge_chunk = 0; switch (machine) { - case COFF_Machine_X64: { + case COFF_MachineType_X64: { LNK_Symbol *delay_load_helper_symbol = lnk_make_undefined_symbol(symtab->arena->v[0], str8_lit(LNK_DELAY_LOAD_HELPER2_SYMBOL_NAME), LNK_SymbolScopeFlag_Main); tail_merge_chunk = lnk_emit_tail_merge_thunk_x64(code_sect, code_chunk, imp_desc_symbol, delay_load_helper_symbol); } break; @@ -446,7 +446,7 @@ lnk_import_table_push_func_static(LNK_ImportTable *imptab, LNK_SymbolTable *symt LNK_Symbol *jmp_thunk_symbol = g_null_symbol_ptr; if (header->type == COFF_ImportHeader_Code) { switch (dll->machine) { - case COFF_Machine_X64: { + case COFF_MachineType_X64: { // generate jump thunk LNK_Chunk *jmp_thunk_chunk = lnk_emit_indirect_jump_thunk_x64(code_sect, code_table_chunk, iat_symbol); lnk_section_associate_chunks(data_sect, iat_chunk, jmp_thunk_chunk); @@ -507,7 +507,7 @@ lnk_import_table_push_func_delayed(LNK_ImportTable *imptab, LNK_SymbolTable *sym LNK_Chunk *load_thunk_chunk = 0; if (header->type == COFF_ImportHeader_Code) { switch (dll->machine) { - case COFF_Machine_X64: { + case COFF_MachineType_X64: { String8 iat_symbol_name = push_str8f(symtab->arena->v[0], "__imp_%S", header->func_name); LNK_Symbol *iat_symbol = lnk_make_undefined_symbol(symtab->arena->v[0], iat_symbol_name, LNK_SymbolScopeFlag_Main); @@ -624,12 +624,12 @@ lnk_ordinal_data_from_hint(Arena *arena, COFF_MachineType machine, U16 hint) { String8 ordinal_data = str8_zero(); switch (machine) { - case COFF_Machine_X64: { + case COFF_MachineType_X64: { U64 *ordinal = push_array(arena, U64, 1); *ordinal = coff_make_ordinal64(hint); ordinal_data = str8_struct(ordinal); } break; - case COFF_Machine_X86: { + case COFF_MachineType_X86: { U32 *ordinal = push_array(arena, U32, 1); *ordinal = coff_make_ordinal32(hint); ordinal_data = str8_struct(ordinal); diff --git a/src/linker/lnk_lib.c b/src/linker/lnk_lib.c index b200b1db..fc4e54d0 100644 --- a/src/linker/lnk_lib.c +++ b/src/linker/lnk_lib.c @@ -541,7 +541,7 @@ lnk_build_import_entry_obj(Arena *arena, String8 dll_name, COFF_MachineType mach { ProfBeginFunction(); - Assert(machine == COFF_Machine_X64); + Assert(machine == COFF_MachineType_X64); Assert(str8_match_lit("dll", str8_skip_last_dot(dll_name), StringMatchFlag_CaseInsensitive|StringMatchFlag_RightSideSloppy)); String8List list = {0}; diff --git a/src/linker/lnk_reloc.c b/src/linker/lnk_reloc.c index b37120bd..f78df7e6 100644 --- a/src/linker/lnk_reloc.c +++ b/src/linker/lnk_reloc.c @@ -117,8 +117,8 @@ lnk_ext_reloc_type_from_coff(COFF_MachineType machine, U32 type) { LNK_RelocType result = LNK_Reloc_NULL; switch (machine) { - case COFF_Machine_Unknown: break; - case COFF_Machine_X64: { + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: { switch (type) { case COFF_Reloc_X64_Abs: result = LNK_Reloc_NULL; break; case COFF_Reloc_X64_Addr64: result = LNK_Reloc_ADDR_64; break; @@ -150,7 +150,7 @@ lnk_ext_reloc_type_to_coff(COFF_MachineType machine, LNK_RelocType type) { U32 result = 0; switch (machine) { - case COFF_Machine_X64: { + case COFF_MachineType_X64: { switch (type) { case LNK_Reloc_NULL: result = COFF_Reloc_X64_Abs; break; case LNK_Reloc_ADDR_64: result = COFF_Reloc_X64_Addr64; break; diff --git a/src/linker/lnk_section_table.c b/src/linker/lnk_section_table.c index 4ac8cb25..084538db 100644 --- a/src/linker/lnk_section_table.c +++ b/src/linker/lnk_section_table.c @@ -236,8 +236,8 @@ lnk_code_align_byte_from_machine(COFF_MachineType machine) { U8 align_byte = 0; switch (machine) { - case COFF_Machine_X64: - case COFF_Machine_X86: { + case COFF_MachineType_X64: + case COFF_MachineType_X86: { align_byte = 0xCC; } break; default: { diff --git a/src/linker/rdi/rdi_coff.c b/src/linker/rdi/rdi_coff.c index 32b93862..2646860c 100644 --- a/src/linker/rdi/rdi_coff.c +++ b/src/linker/rdi/rdi_coff.c @@ -5,31 +5,31 @@ internal RDI_Arch rdi_arch_from_coff_machine(COFF_MachineType machine) { switch (machine) { - case COFF_Machine_X86: return RDI_Arch_X86; - case COFF_Machine_X64: return RDI_Arch_X64; + case COFF_MachineType_X86: return RDI_Arch_X86; + case COFF_MachineType_X64: return RDI_Arch_X64; - case COFF_Machine_Unknown: - case COFF_Machine_Am33: - case COFF_Machine_Arm: - case COFF_Machine_Arm64: - case COFF_Machine_ArmNt: - case COFF_Machine_Ebc: - case COFF_Machine_Ia64: - case COFF_Machine_M32R: - case COFF_Machine_Mips16: - case COFF_Machine_MipsFpu: - case COFF_Machine_MipsFpu16: - case COFF_Machine_PowerPc: - case COFF_Machine_PowerPcFp: - case COFF_Machine_R4000: - case COFF_Machine_RiscV32: - case COFF_Machine_RiscV64: - case COFF_Machine_Sh3: - case COFF_Machine_Sh3Dsp: - case COFF_Machine_Sh4: - case COFF_Machine_Sh5: - case COFF_Machine_Thumb: - case COFF_Machine_WceMipsV2: + case COFF_MachineType_Unknown: + case COFF_MachineType_Am33: + case COFF_MachineType_Arm: + case COFF_MachineType_Arm64: + case COFF_MachineType_ArmNt: + case COFF_MachineType_Ebc: + case COFF_MachineType_Ia64: + case COFF_MachineType_M32R: + case COFF_MachineType_Mips16: + case COFF_MachineType_MipsFpu: + case COFF_MachineType_MipsFpu16: + case COFF_MachineType_PowerPc: + case COFF_MachineType_PowerPcFp: + case COFF_MachineType_R4000: + case COFF_MachineType_RiscV32: + case COFF_MachineType_RiscV64: + case COFF_MachineType_Sh3: + case COFF_MachineType_Sh3Dsp: + case COFF_MachineType_Sh4: + case COFF_MachineType_Sh5: + case COFF_MachineType_Thumb: + case COFF_MachineType_WceMipsV2: NotImplemented; default: return RDI_Arch_NULL; diff --git a/src/pe/pe.c b/src/pe/pe.c index f6dc53b5..b631386f 100644 --- a/src/pe/pe.c +++ b/src/pe/pe.c @@ -568,8 +568,8 @@ pe_bin_info_from_data(Arena *arena, String8 data) switch(file_header.machine) { default:{ NotImplemented; }break; - case COFF_Machine_Unknown: break; - case COFF_Machine_X86: + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X86: { PE_TLSHeader32 tls_header32 = {0}; if(str8_deserial_read_struct(data, tls_header_frng.min, &tls_header32) == sizeof(tls_header32)) @@ -586,7 +586,7 @@ pe_bin_info_from_data(Arena *arena, String8 data) Assert(!"unable to read TLS Header 32"); } }break; - case COFF_Machine_X64: + case COFF_MachineType_X64: { if(str8_deserial_read_struct(data, tls_header_frng.min, &tls_header) != sizeof(tls_header)) { @@ -981,7 +981,7 @@ pe_get_entry_point_names(COFF_MachineType machine, String8Array entry_point_names = {0}; if (file_characteristics & PE_ImageFileCharacteristic_FILE_DLL) { - if (machine == COFF_Machine_X86) { + if (machine == COFF_MachineType_X86) { read_only static String8 dll_entry_point_arr[] = { str8_lit_comp("__DllMainCRTStartup@12"), }; @@ -1432,8 +1432,8 @@ pe_tls_from_data(Arena *arena, U64 *callback_addrs = 0; switch (machine) { - case COFF_Machine_Unknown: break; - case COFF_Machine_X86: { + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X86: { PE_TLSHeader32 header32 = {0}; str8_deserial_read_struct(raw_tls, 0, &header32); @@ -1458,7 +1458,7 @@ pe_tls_from_data(Arena *arena, callback_addrs[i] = (U64)src[i]; } } break; - case COFF_Machine_X64: { + case COFF_MachineType_X64: { str8_deserial_read_struct(raw_tls, 0, &header64); U64 callbacks_voff = header64.callbacks_address - image_base; diff --git a/src/radcon/radcon_coff.c b/src/radcon/radcon_coff.c index 56306141..35c6a23d 100644 --- a/src/radcon/radcon_coff.c +++ b/src/radcon/radcon_coff.c @@ -5,31 +5,31 @@ internal RDI_Arch c2r_rdi_arch_from_coff_machine(COFF_MachineType machine) { switch (machine) { - case COFF_Machine_X86: return RDI_Arch_X86; - case COFF_Machine_X64: return RDI_Arch_X64; + case COFF_MachineType_X86: return RDI_Arch_X86; + case COFF_MachineType_X64: return RDI_Arch_X64; - case COFF_Machine_Unknown: - case COFF_Machine_Am33: - case COFF_Machine_Arm: - case COFF_Machine_Arm64: - case COFF_Machine_ArmNt: - case COFF_Machine_Ebc: - case COFF_Machine_Ia64: - case COFF_Machine_M32R: - case COFF_Machine_Mips16: - case COFF_Machine_MipsFpu: - case COFF_Machine_MipsFpu16: - case COFF_Machine_PowerPc: - case COFF_Machine_PowerPcFp: - case COFF_Machine_R4000: - case COFF_Machine_RiscV32: - case COFF_Machine_RiscV64: - case COFF_Machine_Sh3: - case COFF_Machine_Sh3Dsp: - case COFF_Machine_Sh4: - case COFF_Machine_Sh5: - case COFF_Machine_Thumb: - case COFF_Machine_WceMipsV2: + case COFF_MachineType_Unknown: + case COFF_MachineType_Am33: + case COFF_MachineType_Arm: + case COFF_MachineType_Arm64: + case COFF_MachineType_ArmNt: + case COFF_MachineType_Ebc: + case COFF_MachineType_Ia64: + case COFF_MachineType_M32R: + case COFF_MachineType_Mips16: + case COFF_MachineType_MipsFpu: + case COFF_MachineType_MipsFpu16: + case COFF_MachineType_PowerPc: + case COFF_MachineType_PowerPcFp: + case COFF_MachineType_R4000: + case COFF_MachineType_RiscV32: + case COFF_MachineType_RiscV64: + case COFF_MachineType_Sh3: + case COFF_MachineType_Sh3Dsp: + case COFF_MachineType_Sh4: + case COFF_MachineType_Sh5: + case COFF_MachineType_Thumb: + case COFF_MachineType_WceMipsV2: NotImplemented; default: return RDI_Arch_NULL; diff --git a/src/raddump/raddump.c b/src/raddump/raddump.c index 5eebeb56..52f76b9c 100644 --- a/src/raddump/raddump.c +++ b/src/raddump/raddump.c @@ -7959,9 +7959,9 @@ pe_print_exceptions(Arena *arena, rd_indent(); rd_printf("%-8s %-8s %-8s %-8s", "Offset", "Begin", "End", "Unwind Info"); switch (machine) { - case COFF_Machine_Unknown: break; - case COFF_Machine_X64: - case COFF_Machine_X86: { + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: + case COFF_MachineType_X86: { pe_print_exceptions_x8664(arena, out, indent, section_count, sections, raw_data, except_frange, rdi); } break; default: NotImplemented; break; @@ -7994,9 +7994,9 @@ pe_print_base_relocs(Arena *arena, U32 addr_size = 0; switch (machine) { - case COFF_Machine_Unknown: break; - case COFF_Machine_X86: addr_size = 4; break; - case COFF_Machine_X64: addr_size = 8; break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X86: addr_size = 4; break; + case COFF_MachineType_X64: addr_size = 8; break; default: NotImplemented; } @@ -8026,9 +8026,9 @@ pe_print_base_relocs(Arena *arena, case PE_BaseRelocKind_DIR64: type_str = "DIR64"; break; default: { switch (machine) { - case COFF_Machine_Arm: - case COFF_Machine_Arm64: - case COFF_Machine_ArmNt: { + case COFF_MachineType_Arm: + case COFF_MachineType_Arm64: + case COFF_MachineType_ArmNt: { switch (type) { case PE_BaseRelocKind_ARM_MOV32: type_str = "ARM_MOV32"; break; case PE_BaseRelocKind_THUMB_MOV32: type_str = "THUMB_MOV32"; break; @@ -8226,8 +8226,8 @@ pe_print(Arena *arena, String8List *out, String8 indent, String8 raw_data, RD_Op String8 raw_lc = str8_substr(raw_data, dirs_file_ranges[PE_DataDirectoryIndex_LOAD_CONFIG]); if (raw_lc.size) { switch (file_header->machine) { - case COFF_Machine_Unknown: break; - case COFF_Machine_X86: { + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X86: { PE_LoadConfig32 *lc = str8_deserial_get_raw_ptr(raw_lc, 0, sizeof(*lc)); if (lc) { pe_print_load_config32(arena, out, indent, lc); @@ -8235,7 +8235,7 @@ pe_print(Arena *arena, String8List *out, String8 indent, String8 raw_data, RD_Op rd_errorf("not enough bytes to parse 32bit load config"); } } break; - case COFF_Machine_X64: { + case COFF_MachineType_X64: { PE_LoadConfig64 *lc = str8_deserial_get_raw_ptr(raw_lc, 0, sizeof(*lc)); if (lc) { pe_print_load_config64(arena, out, indent, lc);