eliminate os_core, move into base; eliminate regs, move into arch abstraction layer, define x64 regs in x64 layer; move win32 backend for os core (now base) functionality to top-level win32 layer

src/arch/arch.c

@@ -0,0 +1,168 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+////////////////////////////////
+//~ rjf: Abstracted Architecture Functions
+
+internal ARCH_Info *
+arch_info_from_arch(Arch arch)
+{
+  ARCH_Info *result = &arch_info_nil;
+  switch(arch)
+  {
+    default:{}break;
+#if defined(X64_H)
+    case Arch_x64:
+    {
+      local_persist read_only ARCH_Info info =
+      {
+        .reg_block_size                  = sizeof(X64_RegBlock),
+        .instruction_pointer_reg_code    = X64_RegCode_rip,
+        .stack_pointer_reg_code          = X64_RegCode_rsp,
+        .reg_code_count                  = X64_RegCode_COUNT,
+        .reg_code_rng_table              = x64_reg_code_rng_table,
+        .reg_code_name_table             = x64_reg_code_name_table,
+        .reg_code_base_table             = x64_reg_code_base_table,
+        .reg_code_is_vector_table        = x64_reg_code_is_vector_table,
+      };
+      result = &info;
+    }break;
+#endif
+  }
+  return result;
+}
+
+internal ARCH_RegCode
+arch_reg_code_from_name(ARCH_Info *arch_info, String8 name)
+{
+  ARCH_RegCode result = 0;
+  for EachIndex(code, arch_info->reg_code_count)
+  {
+    if(str8_match(arch_info->reg_code_name_table[code], name, 0))
+    {
+      result = code;
+      break;
+    }
+  }
+  return result;
+}
+
+internal ARCH_RegCode
+arch_reg_code_from_rdi(Arch arch, RDI_RegCode code)
+{
+  ARCH_RegCode result = 0;
+  {
+    ARCH_Info *arch_info = arch_info_from_arch(arch);
+    U8 *rdi_from_reg_code_table = arch_rdi_from_reg_code_table_from_arch(arch);
+    for EachIndex(c, arch_info->reg_code_count)
+    {
+      if(rdi_from_reg_code_table[c] == code)
+      {
+        result = c;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+internal ARCH_RegCode
+arch_reg_code_from_dw(Arch arch, DW_Reg code)
+{
+  ARCH_RegCode result = 0;
+  {
+    ARCH_Info *arch_info = arch_info_from_arch(arch);
+    U8 *dw_from_reg_code_table = arch_dw_from_reg_code_table_from_arch(arch);
+    for EachIndex(c, arch_info->reg_code_count)
+    {
+      if(dw_from_reg_code_table[c] == code)
+      {
+        result = c;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+internal B32
+arch_reg_block_read_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *dst)
+{
+  B32 result = 0;
+  {
+    Rng1U16 legal_range = r1u16(0, arch_info->reg_block_size);
+    Rng1U16 try_range = range;
+    Rng1U16 read_range = intersect_1u16(legal_range, try_range);
+    U64 read_size = dim_1u16(read_range);
+    if(read_size != 0)
+    {
+      MemoryCopy(dst, (U8 *)block + read_range.min, read_size);
+      result = 1;
+    }
+  }
+  return result;
+}
+
+internal B32
+arch_reg_block_write_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *src)
+{
+  B32 result = 0;
+  Rng1U16 legal_range = r1u16(0, arch_info->reg_block_size);
+  Rng1U16 try_range = range;
+  Rng1U16 write_range = intersect_1u16(legal_range, try_range);
+  U64 write_size = dim_1u16(write_range);
+  if(write_size != 0)
+  {
+    MemoryCopy((U8 *)block + write_range.min, src, write_size);
+    result = 1;
+  }
+  return result;
+}
+
+internal U64
+arch_ip_from_reg_block(ARCH_Info *arch_info, void *block)
+{
+  U64 result = 0;
+  ARCH_RegCode reg_code = arch_info->instruction_pointer_reg_code;
+  if(reg_code < arch_info->reg_code_count)
+  {
+    arch_reg_block_read_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &result);
+  }
+  return result;
+}
+
+internal U64
+arch_sp_from_reg_block(ARCH_Info *arch_info, void *block)
+{
+  U64 result = 0;
+  ARCH_RegCode reg_code = arch_info->stack_pointer_reg_code;
+  if(reg_code < arch_info->reg_code_count)
+  {
+    arch_reg_block_read_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &result);
+  }
+  return result;
+}
+
+internal B32
+arch_reg_block_write_ip(ARCH_Info *arch_info, void *block, U64 ip)
+{
+  B32 result = 0;
+  ARCH_RegCode reg_code = arch_info->instruction_pointer_reg_code;
+  if(reg_code < arch_info->reg_code_count)
+  {
+    result = arch_reg_block_write_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &ip);
+  }
+  return result;
+}
+
+internal B32
+arch_reg_block_write_sp(ARCH_Info *arch_info, void *block, U64 sp)
+{
+  B32 result = 0;
+  ARCH_RegCode reg_code = arch_info->stack_pointer_reg_code;
+  if(reg_code < arch_info->reg_code_count)
+  {
+    result = arch_reg_block_write_range(arch_info, block, arch_info->reg_code_rng_table[reg_code], &sp);
+  }
+  return result;
+}

src/arch/arch.h

@@ -0,0 +1,47 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef ARCH_H
+#define ARCH_H
+
+////////////////////////////////
+//~ rjf: Abstraction Backend Info
+
+typedef U8 ARCH_RegCode;
+
+typedef struct ARCH_Info ARCH_Info;
+struct ARCH_Info
+{
+  U16 reg_block_size;
+  ARCH_RegCode instruction_pointer_reg_code;
+  ARCH_RegCode stack_pointer_reg_code;
+  U16 reg_code_count;
+  Rng1U16 *reg_code_rng_table;
+  String8 *reg_code_name_table;
+  U8 *reg_code_base_table;
+  B8 *reg_code_is_vector_table;
+};
+
+////////////////////////////////
+//~ rjf: Globals
+
+global read_only Rng1U16 arch_reg_code_rng_nil = {0};
+global read_only String8 arch_reg_code_name_nil = {0};
+global read_only U8 arch_reg_code_u8_nil = 0;
+global read_only ARCH_Info arch_info_nil = {0, 0, 0, 0, &arch_reg_code_rng_nil, &arch_reg_code_name_nil, &arch_reg_code_u8_nil, &arch_reg_code_u8_nil};
+
+////////////////////////////////
+//~ rjf: Abstracted Architecture Functions
+
+internal ARCH_Info *arch_info_from_arch(Arch arch);
+internal ARCH_RegCode arch_reg_code_from_name(ARCH_Info *arch_info, String8 name);
+internal ARCH_RegCode arch_reg_code_from_rdi(Arch arch, RDI_RegCode code);
+internal ARCH_RegCode arch_reg_code_from_dw(Arch arch, DW_Reg code);
+internal B32 arch_reg_block_read_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *dst);
+internal B32 arch_reg_block_write_range(ARCH_Info *arch_info, void *block, Rng1U16 range, void *src);
+internal U64 arch_ip_from_reg_block(ARCH_Info *arch_info, void *block);
+internal U64 arch_sp_from_reg_block(ARCH_Info *arch_info, void *block);
+internal B32 arch_reg_block_write_ip(ARCH_Info *arch_info, void *block, U64 ip);
+internal B32 arch_reg_block_write_sp(ARCH_Info *arch_info, void *block, U64 sp);
+
+#endif // REGS_H

src/arch/arch_inc.c

@@ -0,0 +1,10 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#include "arch/arch.c"
+#if defined(DWARF_H)
+# include "arch/dwarf/arch_dwarf.c"
+#endif
+#if defined(RDI_H)
+# include "arch/rdi/arch_rdi.c"
+#endif

src/arch/arch_inc.h

@@ -0,0 +1,15 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef ARCH_INC_H
+#define ARCH_INC_H
+
+#include "arch/arch.h"
+#if defined(DWARF_H)
+# include "arch/dwarf/arch_dwarf.h"
+#endif
+#if defined(RDI_H)
+# include "arch/rdi/arch_rdi.h"
+#endif
+
+#endif // ARCH_INC_H

src/arch/dwarf/arch_dwarf.c

@@ -0,0 +1,19 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+internal U8 *
+arch_dw_from_reg_code_table_from_arch(Arch arch)
+{
+  U8 *result = &arch_reg_code_u8_nil;
+  switch(arch)
+  {
+    default:{}break;
+#if defined(X64_H)
+    case Arch_x64:
+    {
+      result = dw_reg_code_from_x64_table;
+    }break;
+#endif
+  }
+  return result;
+}

src/arch/dwarf/arch_dwarf.h

@@ -0,0 +1,9 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef ARCH_DWARF_H
+#define ARCH_DWARF_H
+
+internal U8 *arch_dw_from_reg_code_table_from_arch(Arch arch);
+
+#endif // ARCH_DWARF_H

src/arch/rdi/arch_rdi.c

@@ -0,0 +1,19 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+internal U8 *
+arch_rdi_from_reg_code_table_from_arch(Arch arch)
+{
+  U8 *result = &arch_reg_code_u8_nil;
+  switch(arch)
+  {
+    default:{}break;
+#if defined(X64_H)
+    case Arch_x64:
+    {
+      result = rdi_reg_code_from_x64_table;
+    }break;
+#endif
+  }
+  return result;
+}

src/arch/rdi/arch_rdi.h

@@ -0,0 +1,9 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef ARCH_RDI_H
+#define ARCH_RDI_H
+
+internal U8 *arch_rdi_from_reg_code_table_from_arch(Arch arch);
+
+#endif // ARCH_RDI_H