switch eval memory reads -> more generalized space reads; apply to register reads as well

src/ctrl/ctrl_core.c

@@ -3796,12 +3796,21 @@ ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg,
 //- rjf: eval helpers
 
 internal B32
-ctrl_eval_memory_read(void *u, E_Space space, void *out, Rng1U64 vaddr_range)
+ctrl_eval_space_read(void *u, E_Space space, void *out, Rng1U64 range)
 {
-  // TODO(rjf): @spaces pick the correct process from space
+  B32 result = 0;
-  DMN_Handle process = *(DMN_Handle *)u;
+  CTRL_Entity *entity = (CTRL_Entity *)space;
-  U64 read_size = dmn_process_read(process, vaddr_range, out);
+  {
-  B32 result = (read_size == dim_1u64(vaddr_range));
+    switch(entity->kind)
+    {
+      default:{}break;
+      case CTRL_EntityKind_Process:
+      {
+        U64 read_size = dmn_process_read(entity->handle, range, out);
+        result = (read_size == dim_1u64(range));
+      }break;
+    }
+  }
   return result;
 }
 
@@ -4720,8 +4729,8 @@ ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg)
             {
               E_InterpretCtx *ctx = &interpret_ctx;
               ctx->arch          = arch;
-              ctx->memory_read_user_data = &event->process;
+              ctx->space_read_user_data = ctrl_state->ctrl_thread_entity_store;
-              ctx->memory_read   = ctrl_eval_memory_read;
+              ctx->space_read    = ctrl_eval_space_read;
               ctx->primary_space = eval_modules_primary->space;
               ctx->reg_size      = regs_block_size_from_architecture(ctx->arch);
               ctx->reg_data      = push_array(temp.arena, U8, ctx->reg_size);

src/ctrl/ctrl_core.h

@@ -818,7 +818,7 @@ internal void ctrl_thread__module_close(CTRL_MachineID machine_id, DMN_Handle mo
 internal DMN_Event *ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg, DMN_RunCtrls *run_ctrls, CTRL_Spoof *spoof);
 
 //- rjf: eval helpers
-internal B32 ctrl_eval_memory_read(void *u, E_Space space, void *out, Rng1U64 vaddr_range);
+internal B32 ctrl_eval_space_read(void *u, E_Space space, void *out, Rng1U64 vaddr_range);
 
 //- rjf: log flusher
 internal void ctrl_thread__flush_info_log(String8 string);

src/df/core/df_core.c

@@ -3689,22 +3689,25 @@ df_ctrl_last_stop_event(void)
 //~ rjf: Evaluation Context
 
 internal B32
-df_eval_memory_read(void *u, E_Space space, void *out, Rng1U64 vaddr_range)
+df_eval_space_read(void *u, E_Space space, void *out, Rng1U64 range)
 {
-  // TODO(rjf): @spaces pick the correct process from space
   B32 result = 0;
-  DF_Entity *process = (DF_Entity *)u;
+  DF_Entity *entity = (DF_Entity *)space;
-  if(process->kind == DF_EntityKind_Process)
+  switch(entity->kind)
   {
-    Temp scratch = scratch_begin(0, 0);
+    default:{}break;
-    CTRL_ProcessMemorySlice slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, vaddr_range, df_state->frame_eval_memread_endt_us);
+    case DF_EntityKind_Process:
-    String8 data = slice.data;
-    if(data.size == dim_1u64(vaddr_range))
     {
-      result = 1;
+      Temp scratch = scratch_begin(0, 0);
-      MemoryCopy(out, data.str, data.size);
+      CTRL_ProcessMemorySlice slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, entity->ctrl_machine_id, entity->ctrl_handle, range, df_state->frame_eval_memread_endt_us);
-    }
+      String8 data = slice.data;
-    scratch_end(scratch);
+      if(data.size == dim_1u64(range))
+      {
+        result = 1;
+        MemoryCopy(out, data.str, data.size);
+      }
+      scratch_end(scratch);
+    }break;
   }
   return result;
 }
@@ -8330,8 +8333,8 @@ df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt)
   {
     E_InterpretCtx *ctx = interpret_ctx;
     ctx->arch          = arch;
-    ctx->memory_read_user_data = process;
+    ctx->space_read_user_data = process;
-    ctx->memory_read   = df_eval_memory_read;
+    ctx->space_read    = df_eval_space_read;
     ctx->primary_space = eval_modules_primary->space;
     ctx->reg_size      = regs_block_size_from_architecture(ctx->arch);
     ctx->reg_data      = push_array(arena, U8, ctx->reg_size);

src/df/core/df_core.h

@@ -1563,7 +1563,7 @@ internal CTRL_Event df_ctrl_last_stop_event(void);
 ////////////////////////////////
 //~ rjf: Evaluation Context
 
-internal B32 df_eval_memory_read(void *u, E_Space space, void *out, Rng1U64 vaddr_range);
+internal B32 df_eval_space_read(void *u, E_Space space, void *out, Rng1U64 vaddr_range);
 internal E_Eval df_eval_from_eval_cfg_table(Arena *arena, E_Eval eval, DF_CfgTable *cfg);
 
 ////////////////////////////////

src/df/gfx/df_gfx.c

@@ -8421,6 +8421,7 @@ df_single_line_eval_value_strings_from_eval(Arena *arena, DF_EvalVizStringFlags
            direct_type_is_string &&
            (flags & DF_EvalVizStringFlag_ReadOnlyDisplayRules))
         {
+          // TODO(rjf): @spaces pick correct space
           U64 string_memory_addr = value_eval.value.u64;
           U64 element_size = e_type_byte_size_from_key(direct_type_key);
           CTRL_ProcessMemorySlice text_slice = ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(arena, process->ctrl_machine_id, process->ctrl_handle, string_memory_addr, 256, element_size, 0);

src/eval/eval_bundles.c

@@ -68,7 +68,7 @@ e_dynamically_typed_eval_from_eval(E_Eval eval)
   E_TypeKind type_kind = e_type_kind_from_key(type_key);
   if(e_type_state != 0 &&
      e_interpret_ctx != 0 &&
-     e_interpret_ctx->memory_read != 0 &&
+     e_interpret_ctx->space_read != 0 &&
      e_interpret_ctx->module_base != 0 &&
      type_kind == E_TypeKind_Ptr)
   {
@@ -93,8 +93,8 @@ e_dynamically_typed_eval_from_eval(E_Eval eval)
         U64 addr_size = bit_size_from_arch(e_interpret_ctx->arch)/8;
         U64 class_base_vaddr = 0;
         U64 vtable_vaddr = 0;
-        if(e_interpret_ctx->memory_read(e_interpret_ctx->memory_read_user_data, eval.space, &class_base_vaddr, r1u64(ptr_vaddr, ptr_vaddr+addr_size)) &&
+        if(e_space_read(eval.space, &class_base_vaddr, r1u64(ptr_vaddr, ptr_vaddr+addr_size)) &&
-           e_interpret_ctx->memory_read(e_interpret_ctx->memory_read_user_data, eval.space, &vtable_vaddr, r1u64(class_base_vaddr, class_base_vaddr+addr_size)))
+           e_space_read(eval.space, &vtable_vaddr, r1u64(class_base_vaddr, class_base_vaddr+addr_size)))
         {
           U32 rdi_idx = 0;
           RDI_Parsed *rdi = 0;
@@ -142,14 +142,14 @@ e_value_eval_from_eval(E_Eval eval)
     {
       eval.mode = E_Mode_Value;
     }
-    else if(e_interpret_ctx->memory_read != 0)
+    else if(e_interpret_ctx->space_read != 0)
     {
       U64 type_byte_size = e_type_byte_size_from_key(type_key);
       Rng1U64 value_vaddr_range = r1u64(eval.value.u64, eval.value.u64 + type_byte_size);
       MemoryZeroStruct(&eval.value);
       if(!e_type_key_match(type_key, e_type_key_zero()) &&
          type_byte_size <= sizeof(E_Value) &&
-         e_interpret_ctx->memory_read(e_interpret_ctx->memory_read_user_data, eval.space, &eval.value, value_vaddr_range))
+         e_space_read(eval.space, &eval.value, value_vaddr_range))
       {
         eval.mode = E_Mode_Value;
         

src/eval/eval_core.h

@@ -58,6 +58,7 @@ enum
 {
   E_Space_Null,
   E_Space_Regs,
+  E_Space_FIXED_COUNT
 };
 
 ////////////////////////////////

src/eval/eval_interpret.c

@@ -16,6 +16,34 @@ e_select_interpret_ctx(E_InterpretCtx *ctx)
   e_interpret_ctx = ctx;
 }
 
+////////////////////////////////
+//~ rjf: Space Reading Helpers
+
+internal B32
+e_space_read(E_Space space, void *out, Rng1U64 range)
+{
+  B32 result = 0;
+  switch(space)
+  {
+    case E_Space_FIXED_COUNT:
+    case E_Space_Null:{}break;
+    case E_Space_Regs:
+    {
+      Rng1U64 legal_range = r1u64(0, e_interpret_ctx->reg_size);
+      Rng1U64 read_range = intersect_1u64(legal_range, range);
+      U64 read_size = dim_1u64(read_range);
+      MemoryCopy(out, (U8 *)e_interpret_ctx->reg_data + read_range.min, read_size);
+      result = (read_size == dim_1u64(range));
+    }break;
+    default:
+    if(e_interpret_ctx->space_read != 0)
+    {
+      result = e_interpret_ctx->space_read(e_interpret_ctx->space_read_user_data, space, out, range);
+    }break;
+  }
+  return result;
+}
+
 ////////////////////////////////
 //~ rjf: Interpretation Functions
 
@@ -126,11 +154,7 @@ e_interpret(String8 bytecode)
       {
         U64 addr = svals[0].u64;
         U64 size = imm;
-        B32 good_read = 0;
+        B32 good_read = e_space_read(selected_space, &nval, r1u64(addr, addr+size));
-        if(e_interpret_ctx->memory_read != 0 && e_interpret_ctx->memory_read(e_interpret_ctx->memory_read_user_data, selected_space, &nval, r1u64(addr, addr+size)))
-        {
-          good_read = 1;
-        }
         if(!good_read)
         {
           result.code = E_InterpretationCode_BadMemRead;

src/eval/eval_interpret.h

@@ -29,14 +29,14 @@ struct E_Interpretation
 ////////////////////////////////
 //~ rjf: Interpretation Context
 
-typedef B32 E_MemoryReadFunction(void *user_data, E_Space space, void *out, Rng1U64 vaddr_range);
+typedef B32 E_SpaceReadFunction(void *user_data, E_Space space, void *out, Rng1U64 offset_range);
 
 typedef struct E_InterpretCtx E_InterpretCtx;
 struct E_InterpretCtx
 {
   Architecture arch;
-  void *memory_read_user_data;
+  void *space_read_user_data;
-  E_MemoryReadFunction *memory_read;
+  E_SpaceReadFunction *space_read;
   E_Space primary_space;
   void *reg_data;
   U64 reg_size;
@@ -56,6 +56,11 @@ thread_static E_InterpretCtx *e_interpret_ctx = 0;
 internal E_InterpretCtx *e_selected_interpret_ctx(void);
 internal void e_select_interpret_ctx(E_InterpretCtx *ctx);
 
+////////////////////////////////
+//~ rjf: Space Reading Helpers
+
+internal B32 e_space_read(E_Space space, void *out, Rng1U64 range);
+
 ////////////////////////////////
 //~ rjf: Interpretation Functions
 

src/eval/eval_ir.c

@@ -1194,7 +1194,7 @@ e_irtree_and_type_from_expr(Arena *arena, E_Expr *expr)
       result = e_irtree_and_type_from_expr(arena, rhs);
       if(lhs->kind != E_ExprKind_LeafIdent)
       {
-        e_msgf(arena, &result.msgs, E_MsgKind_MalformedInput, expr->location, "Left side of assignment must be an identifier.");
+        e_msgf(arena, &result.msgs, E_MsgKind_MalformedInput, expr->location, "Left side of assignment must be an unused identifier.");
       }
     }break;