// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)

////////////////////////////////
//~ rjf: Context Selection Functions (Selection Required For All Subsequent APIs)

internal void
e_select_interpret_ctx(E_InterpretCtx *ctx, RDI_Parsed *primary_rdi, U64 ip_voff)
{
  e_interpret_ctx = ctx;
  
  // compute and apply frame base
  if(primary_rdi != 0)
  {
    Temp scratch = scratch_begin(0, 0);
    RDI_Symbol *proc = rdi_procedure_from_voff(primary_rdi, ip_voff);
    RDI_Location location = rdi_location_from_location_voff(primary_rdi, proc->location, ip_voff);
    E_OpList oplist = e_oplist_from_location(scratch.arena, primary_rdi, location);
    String8 bytecode = e_bytecode_from_oplist(scratch.arena, &oplist);
    E_Interpretation frame_base_interpretation = e_interpret(bytecode);
    U64 frame_base = frame_base_interpretation.value.u64;
    if(frame_base_interpretation.code == E_InterpretationCode_Good)
    {
      *ctx->frame_base = frame_base;
    }
    else
    {
      ctx->frame_base = 0;
    }
    scratch_end(scratch);
  }
}

////////////////////////////////
//~ rjf: Space Reading Helpers

internal U64
e_space_gen(E_Space space)
{
  U64 result = 0;
  if(e_base_ctx->space_gen != 0)
  {
    result = e_base_ctx->space_gen(space);
  }
  return result;
}

internal B32
e_space_read(E_Space space, void *out, Rng1U64 range)
{
  ProfBeginFunction();
  B32 result = 0;
  {
    switch(space.kind)
    {
      //- rjf: reads from hash store key
      case E_SpaceKind_HashStoreKey:
      {
        C_Root root = {space.u64_0};
        C_ID id = {space.u128};
        C_Key key = c_key_make(root, id);
        U128 hash = c_hash_from_key(key, 0);
        Access *access = access_open();
        {
          String8 data = c_data_from_hash(access, hash);
          Rng1U64 legal_range = r1u64(0, data.size);
          Rng1U64 read_range = intersect_1u64(range, legal_range);
          if(read_range.min < read_range.max)
          {
            result = 1;
            MemoryCopy(out, data.str + read_range.min, dim_1u64(read_range));
          }
        }
        access_close(access);
      }break;
      
      //- rjf: file reads
      case E_SpaceKind_File:
      {
        // rjf: unpack space/path
        U64 file_path_string_id = space.u64_0;
        String8 file_path = e_string_from_id(file_path_string_id);
        
        // rjf: find containing chunk range
        U64 chunk_size = KB(4);
        Rng1U64 containing_range = range;
        containing_range.min -= containing_range.min%chunk_size;
        containing_range.max += chunk_size-1;
        containing_range.max -= containing_range.max%chunk_size;
        
        // rjf: map to hash
        C_Key key = fs_key_from_path_range(file_path, containing_range, 0);
        U128 hash = c_hash_from_key(key, 0);
        
        // rjf: look up from hash store
        Access *access = access_open();
        {
          String8 data = c_data_from_hash(access, hash);
          Rng1U64 legal_range = r1u64(containing_range.min, containing_range.min + data.size);
          Rng1U64 read_range = intersect_1u64(range, legal_range);
          if(read_range.min < read_range.max)
          {
            result = 1;
            MemoryCopy(out, data.str + read_range.min - containing_range.min, dim_1u64(read_range));
          }
        }
        access_close(access);
      }break;
      
      //- rjf: debug info constant data
      case E_SpaceKind_DebugConstantData:
      {
        U32 dbg_info_num = space.u64s[0];
        if(1 <= dbg_info_num && dbg_info_num <= e_base_ctx->dbg_infos_count)
        {
          E_DbgInfo *dbg_info = &e_base_ctx->dbg_infos[dbg_info_num-1];
          RDI_Parsed *rdi = dbg_info->rdi;
          U64 all_constant_data_size = 0;
          U8 *all_constant_data_ptr = rdi_table_from_name(rdi, LocationsConstantData, &all_constant_data_size);
          String8 all_constant_data = str8(all_constant_data_ptr, all_constant_data_size);
          String8 read_memory = str8_substr(all_constant_data, range);
          result = (dim_1u64(range) == read_memory.size);
          MemoryCopy(out, read_memory.str, read_memory.size);
        }
      }break;
      
      //- rjf: default -> use hooks
      default:
      if(e_base_ctx->space_read != 0)
      {
        result = e_base_ctx->space_read(space, out, range);
      }break;
    }
  }
  ProfEnd();
  return result;
}

internal B32
e_space_write(E_Space space, void *in, Rng1U64 range)
{
  ProfBeginFunction();
  B32 result = 0;
  if(e_base_ctx->space_write != 0)
  {
    switch(space.kind)
    {
      default:
      {
        result = e_base_ctx->space_write(space, in, range);
      }break;
    }
  }
  ProfEnd();
  return result;
}

////////////////////////////////
//~ rjf: Interpretation Functions

internal E_Interpretation
e_interpret(String8 bytecode)
{
  E_Interpretation result = {0};
  Temp scratch = scratch_begin(0, 0);
  
  //- rjf: allocate stack & "registers"
  U64 stack_cap = 128; // TODO(rjf): scan bytecode; determine maximum stack depth
  E_Value *stack = push_array_no_zero(scratch.arena, E_Value, stack_cap);
  U64 stack_count = 0;
  E_Space selected_space = {0};
  if(bytecode.size != 0)
  {
    selected_space = e_interpret_ctx->primary_space;
  }
  
  //- rjf: iterate bytecode & perform ops
  U8 *ptr = bytecode.str;
  U8 *opl = bytecode.str + bytecode.size;
  for(;ptr < opl;)
  {
    // rjf: consume next opcode
    RDI_EvalOp op = (RDI_EvalOp)*ptr;
    U16 ctrlbits = 0;
    if(op < RDI_EvalOp_COUNT)
    {
      ctrlbits = rdi_eval_op_ctrlbits_table[op];
    }
    else switch(op)
    {
      case E_IRExtKind_SetSpace:{ctrlbits = RDI_EVAL_CTRLBITS(32, 0, 0);}break;
      default:
      {
        result.code = E_InterpretationCode_BadOp;
        goto done;
      }break;
    }
    ptr += 1;
    
    // rjf: decode
    E_Value imm = {0};
    {
      U32 decode_size = RDI_DECODEN_FROM_CTRLBITS(ctrlbits);
      U8 *next_ptr = ptr + decode_size;
      if(next_ptr > opl)
      {
        result.code = E_InterpretationCode_BadOp;
        goto done;
      }
      // TODO(rjf): guarantee 8 bytes padding after the end of serialized
      // bytecode; read 8 bytes and mask
      MemoryCopy(&imm, ptr, decode_size);
      ptr = next_ptr;
    }
    
    // rjf: unpack imm -> type group & arithmetic width
    RDI_EvalTypeGroup type_group = (RDI_EvalTypeGroup)imm.u512.u8[0];
    U64 op_arithmetic_size = (U64)imm.u512.u8[1];
    
    // rjf: pop
    E_Value *svals = 0;
    {
      U32 pop_count = RDI_POPN_FROM_CTRLBITS(ctrlbits);
      if(pop_count > stack_count)
      {
        result.code = E_InterpretationCode_BadOp;
        goto done;
      }
      if(pop_count <= stack_count)
      {
        stack_count -= pop_count;
        svals = stack + stack_count;
      }
    }
    
    // rjf: interpret op, given decodes/pops
    E_Value nval = {0};
    switch(op)
    {
      case E_IRExtKind_SetSpace:
      {
        MemoryCopy(&selected_space, &imm, sizeof(selected_space));
      }break;
      
      case RDI_EvalOp_Stop:
      {
        goto done;
      }break;
      
      case RDI_EvalOp_Noop:
      {
        // do nothing
      }break;
      
      case RDI_EvalOp_Cond:
      if(svals[0].u64)
      {
        ptr += imm.u64;
      }break;
      
      case RDI_EvalOp_Skip:
      {
        ptr += imm.u64;
      }break;
      
      case RDI_EvalOp_MemRead:
      {
        U64 addr = svals[0].u64;
        U64 size = imm.u64;
        B32 good_read = e_space_read(selected_space, &nval, r1u64(addr, addr+size));
        if(!good_read)
        {
          result.code = E_InterpretationCode_BadMemRead;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_RegRead:
      {
        U8 rdi_reg_code     = (imm.u64&0x0000FF)>>0;
        U8 byte_size        = (imm.u64&0x00FF00)>>8;
        U8 byte_off         = (imm.u64&0xFF0000)>>16;
        REGS_RegCode base_reg_code = regs_reg_code_from_arch_rdi_code(e_interpret_ctx->reg_arch, rdi_reg_code);
        REGS_Rng *rng_table = regs_reg_code_rng_table_from_arch(e_interpret_ctx->reg_arch);
        B32 good_read = 0;
        if(0 <= rdi_reg_code && rdi_reg_code < regs_reg_code_count_from_arch(e_interpret_ctx->reg_arch))
        {
          REGS_Rng rng = rng_table[base_reg_code];
          U64 off = (U64)rng.byte_off + byte_off;
          U64 size = (U64)byte_size;
          good_read = e_space_read(e_interpret_ctx->reg_space, &nval, r1u64(off, off+size));
        }
        if(!good_read)
        {
          result.code = E_InterpretationCode_BadRegRead;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_RegReadDyn:
      {
        U64 off  = svals[0].u64;
        U64 size = bit_size_from_arch(e_interpret_ctx->reg_arch)/8;
        B32 good_read = e_space_read(e_interpret_ctx->reg_space, &nval, r1u64(off, off+size));
        if(!good_read)
        {
          result.code = E_InterpretationCode_BadRegRead;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_FrameOff:
      {
        if(e_interpret_ctx->frame_base != 0)
        {
          nval.u64 = *e_interpret_ctx->frame_base + imm.u64;
        }
        else
        {
          result.code = E_InterpretationCode_BadFrameBase;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_ModuleOff:
      {
        if(e_interpret_ctx->module_base != 0)
        {
          nval.u64 = *e_interpret_ctx->module_base + imm.u64;
        }
        else
        {
          result.code = E_InterpretationCode_BadModuleBase;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_TLSOff:
      {
        if(e_interpret_ctx->tls_base != 0)
        {
          nval.u64 = *e_interpret_ctx->tls_base + imm.u64;
        }
        else
        {
          result.code = E_InterpretationCode_BadTLSBase;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_ConstU8:
      case RDI_EvalOp_ConstU16:
      case RDI_EvalOp_ConstU32:
      case RDI_EvalOp_ConstU64:
      case RDI_EvalOp_ConstU128:
      {
        nval = imm;
      }break;
      
      case RDI_EvalOp_ConstString:
      {
        MemoryCopy(&nval, ptr, imm.u64);
        ptr += imm.u64;
      }break;
      
      case RDI_EvalOp_Abs:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.f32 = svals[0].f32;
          if(svals[0].f32 < 0)
          {
            nval.f32 = -svals[0].f32;
          }
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.f64 = svals[0].f64;
          if(svals[0].f64 < 0)
          {
            nval.f64 = -svals[0].f64;
          }
        }
        else
        {
          nval.s64 = svals[0].s64;
          if(svals[0].s64 < 0)
          {
            nval.s64 = -svals[0].s64;
          }
        }
      }break;
      
      case RDI_EvalOp_Neg:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.f32 = -svals[0].f32;
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.f64 = -svals[0].f64;
        }
        else
        {
          nval.u64 = (~svals[0].u64) + 1;
        }
      }break;
      
      case RDI_EvalOp_Add:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.f32 = svals[0].f32 + svals[1].f32;
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.f64 = svals[0].f64 + svals[1].f64;
        }
        else
        {
          nval.u64 = svals[0].u64 + svals[1].u64;
        }
      }break;
      
      case RDI_EvalOp_Sub:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.f32 = svals[0].f32 - svals[1].f32;
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.f64 = svals[0].f64 - svals[1].f64;
        }
        else
        {
          nval.u64 = svals[0].u64 - svals[1].u64;
        }
      }break;
      
      case RDI_EvalOp_Mul:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.f32 = svals[0].f32*svals[1].f32;
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.f64 = svals[0].f64*svals[1].f64;
        }
        else
        {
          nval.u64 = svals[0].u64*svals[1].u64;
        }
      }break;
      
      case RDI_EvalOp_Div:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          if(svals[1].f32 != 0.f)
          {
            nval.f32 = svals[0].f32/svals[1].f32;
          }
          else
          {
            result.code = E_InterpretationCode_DivideByZero;
            goto done;
          }
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          if(svals[1].f64 != 0.)
          {
            nval.f64 = svals[0].f64/svals[1].f64;
          }
          else
          {
            result.code = E_InterpretationCode_DivideByZero;
            goto done;
          }
        }
        else if(type_group == RDI_EvalTypeGroup_U ||
                type_group == RDI_EvalTypeGroup_S)
        {
          if(svals[1].u64 != 0)
          {
            nval.u64 = svals[0].u64/svals[1].u64;
          }
          else
          {
            result.code = E_InterpretationCode_DivideByZero;
            goto done;
          }
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_Mod:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          if(svals[1].u64 != 0)
          {
            nval.u64 = svals[0].u64%svals[1].u64;
          }
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_LShift:
      {
        if(type_group == RDI_EvalTypeGroup_U)
        {
          switch(op_arithmetic_size)
          {
            default:{}break;
            case 1:{nval.u8  = svals[0].u8 << svals[1].u8;}break;
            case 2:{nval.u16 = svals[0].u16 << svals[1].u16;}break;
            case 4:{nval.u32 = svals[0].u32 << svals[1].u32;}break;
            case 8:{nval.u64 = svals[0].u64 << svals[1].u64;}break;
          }
        }
        else if(type_group == RDI_EvalTypeGroup_S)
        {
          switch(op_arithmetic_size)
          {
            default:{}break;
            case 1:{nval.s8  = svals[0].s8 << svals[1].s8;}break;
            case 2:{nval.s16 = svals[0].s16 << svals[1].s16;}break;
            case 4:{nval.s32 = svals[0].s32 << svals[1].s32;}break;
            case 8:{nval.s64 = svals[0].s64 << svals[1].s64;}break;
          }
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_RShift:
      {
        if(type_group == RDI_EvalTypeGroup_U)
        {
          switch(op_arithmetic_size)
          {
            default:{}break;
            case 1:{nval.u8  = svals[0].u8 >> svals[1].u8;}break;
            case 2:{nval.u16 = svals[0].u16 >> svals[1].u16;}break;
            case 4:{nval.u32 = svals[0].u32 >> svals[1].u32;}break;
            case 8:{nval.u64 = svals[0].u64 >> svals[1].u64;}break;
          }
        }
        else if(type_group == RDI_EvalTypeGroup_S)
        {
          switch(op_arithmetic_size)
          {
            default:{}break;
            case 1:{nval.s8  = svals[0].s8 >> svals[1].s8;}break;
            case 2:{nval.s16 = svals[0].s16 >> svals[1].s16;}break;
            case 4:{nval.s32 = svals[0].s32 >> svals[1].s32;}break;
            case 8:{nval.s64 = svals[0].s64 >> svals[1].s64;}break;
          }
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_BitAnd:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = svals[0].u64&svals[1].u64;
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_BitOr:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = svals[0].u64|svals[1].u64;
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_BitXor:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = svals[0].u64^svals[1].u64;
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_BitNot:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = ~svals[0].u64;
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_LogAnd:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = (svals[0].u64 && svals[1].u64);
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_LogOr:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = (svals[0].u64 || svals[1].u64);
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_LogNot:
      {
        if(type_group == RDI_EvalTypeGroup_U ||
           type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = (!svals[0].u64);
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_EqEq:
      {
        B32 result = MemoryMatchArray(svals[0].u512.u64, svals[1].u512.u64);
        nval.u64 = !!result;
      }break;
      
      case RDI_EvalOp_NtEq:
      {
        B32 result = MemoryMatchArray(svals[0].u512.u64, svals[1].u512.u64);
        nval.u64 = !result;
      }break;
      
      case RDI_EvalOp_LsEq:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.u64 = (svals[0].f32 <= svals[1].f32);
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.u64 = (svals[0].f64 <= svals[1].f64);
        }
        else if(type_group == RDI_EvalTypeGroup_U)
        {
          nval.u64 = (svals[0].u64 <= svals[1].u64);
        }
        else if(type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = (svals[0].s64 <= svals[1].s64);
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_GrEq:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.u64 = (svals[0].f32 >= svals[1].f32);
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.u64 = (svals[0].f64 >= svals[1].f64);
        }
        else if(type_group == RDI_EvalTypeGroup_U)
        {
          nval.u64 = (svals[0].u64 >= svals[1].u64);
        }
        else if(type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = (svals[0].s64 >= svals[1].s64);
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_Less:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.u64 = (svals[0].f32 < svals[1].f32);
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.u64 = (svals[0].f64 < svals[1].f64);
        }
        else if(type_group == RDI_EvalTypeGroup_U)
        {
          nval.u64 = (svals[0].u64 < svals[1].u64);
        }
        else if(type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = (svals[0].s64 < svals[1].s64);
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_Grtr:
      {
        if(type_group == RDI_EvalTypeGroup_F32)
        {
          nval.u64 = (svals[0].f32 > svals[1].f32);
        }
        else if(type_group == RDI_EvalTypeGroup_F64)
        {
          nval.u64 = (svals[0].f64 > svals[1].f64);
        }
        else if(type_group == RDI_EvalTypeGroup_U)
        {
          nval.u64 = (svals[0].u64 > svals[1].u64);
        }
        else if(type_group == RDI_EvalTypeGroup_S)
        {
          nval.u64 = (svals[0].s64 > svals[1].s64);
        }
        else
        {
          result.code = E_InterpretationCode_BadOpTypes;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_Trunc:
      {
        if(0 < imm.u64)
        {
          U64 mask = 0;
          if(imm.u64 < 64)
          {
            mask = max_U64 >> (64 - imm.u64);
          }
          nval.u64 = svals[0].u64&mask;
        }
      }break;
      
      case RDI_EvalOp_TruncSigned:
      {
        if(0 < imm.u64)
        {
          U64 mask = 0;
          if(imm.u64 < 64)
          {
            mask = max_U64 >> (64 - imm.u64);
          }
          U64 high = 0;
          if(svals[0].u64 & (1 << (imm.u64 - 1)))
          {
            high = ~mask;
          }
          nval.u64 = high|(svals[0].u64&mask);
        }
      }break;
      
      case RDI_EvalOp_Convert:
      {
        U32 in = imm.u64&0xFF;
        U32 out = (imm.u64 >> 8)&0xFF;
        if(in != out)
        {
          switch(in + out*RDI_EvalTypeGroup_COUNT)
          {
            case RDI_EvalTypeGroup_F32 + RDI_EvalTypeGroup_U*RDI_EvalTypeGroup_COUNT:
            {
              nval.u64 = (U64)svals[0].f32;
            }break;
            case RDI_EvalTypeGroup_F64 + RDI_EvalTypeGroup_U*RDI_EvalTypeGroup_COUNT:
            {
              nval.u64 = (U64)svals[0].f64;
            }break;
            
            case RDI_EvalTypeGroup_F32 + RDI_EvalTypeGroup_S*RDI_EvalTypeGroup_COUNT:
            {
              nval.s64 = (S64)svals[0].f32;
            }break;
            case RDI_EvalTypeGroup_F64 + RDI_EvalTypeGroup_S*RDI_EvalTypeGroup_COUNT:
            {
              nval.s64 = (S64)svals[0].f64;
            }break;
            
            case RDI_EvalTypeGroup_U + RDI_EvalTypeGroup_F32*RDI_EvalTypeGroup_COUNT:
            {
              nval.f32 = (F32)svals[0].u64;
            }break;
            case RDI_EvalTypeGroup_S + RDI_EvalTypeGroup_F32*RDI_EvalTypeGroup_COUNT:
            {
              nval.f32 = (F32)svals[0].s64;
            }break;
            case RDI_EvalTypeGroup_F64 + RDI_EvalTypeGroup_F32*RDI_EvalTypeGroup_COUNT:
            {
              nval.f32 = (F32)svals[0].f64;
            }break;
            
            case RDI_EvalTypeGroup_U + RDI_EvalTypeGroup_F64*RDI_EvalTypeGroup_COUNT:
            {
              nval.f64 = (F64)svals[0].u64;
            }break;
            case RDI_EvalTypeGroup_S + RDI_EvalTypeGroup_F64*RDI_EvalTypeGroup_COUNT:
            {
              nval.f64 = (F64)svals[0].s64;
            }break;
            case RDI_EvalTypeGroup_F32 + RDI_EvalTypeGroup_F64*RDI_EvalTypeGroup_COUNT:
            {
              nval.f64 = (F64)svals[0].f32;
            }break;
          }
        }
      }break;
      
      case RDI_EvalOp_Pick:
      {
        if(stack_count > imm.u64)
        {
          nval = stack[stack_count - imm.u64 - 1];
        }
        else
        {
          result.code = E_InterpretationCode_BadOp;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_Pop:
      {
        // do nothing - the pop is handled by the control bits
      }break;
      
      case RDI_EvalOp_Insert:
      {
        if(stack_count > imm.u64)
        {
          if(imm.u64 > 0)
          {
            E_Value tval = stack[stack_count - 1];
            E_Value *dst = stack + stack_count - 1 - imm.u64;
            E_Value *shift = dst + 1;
            MemoryCopy(shift, dst, imm.u64*sizeof(E_Value));
            *dst = tval;
          }
        }
        else
        {
          result.code = E_InterpretationCode_BadOp;
          goto done;
        }
      }break;
      
      case RDI_EvalOp_ValueRead:
      {
        U64 bytes_to_read = imm.u64;
        U64 offset = svals[0].u64;
        if(offset + bytes_to_read <= sizeof(E_Value))
        {
          E_Value src_val = svals[1];
          MemoryCopy(&nval.u512.u64[0], (U8 *)(&src_val.u512.u64[0]) + offset, bytes_to_read);
        }
      }break;
      
      case RDI_EvalOp_ByteSwap:
      {
        U64 byte_size = imm.u64;
        switch(byte_size)
        {
          default:
          {
            result.code = E_InterpretationCode_BadOp;
            goto done;
          }break;
          case 2:{nval.u16 = bswap_u16(svals[0].u16);}break;
          case 4:{nval.u32 = bswap_u32(svals[0].u32);}break;
          case 8:{nval.u64 = bswap_u64(svals[0].u64);}break;
        }
      }break;
      
      case RDI_EvalOp_PushCfa:
      {
        nval.u64 = e_interpret_ctx->cfa;
      }break;
      
      case RDI_EvalOp_CallSiteValue:
      case RDI_EvalOp_PartialValue:
      case RDI_EvalOp_PartialValueBit:
      case RDI_EvalOp_Swap:
      {
        // TODO(rjf)
        result.code = E_InterpretationCode_BadOp;
        goto done;
      }break;
    }
    
    // rjf: push
    {
      U64 push_count = RDI_PUSHN_FROM_CTRLBITS(ctrlbits);
      if(push_count == 1)
      {
        if(stack_count < stack_cap)
        {
          stack[stack_count] = nval;
          stack_count += 1;
        }
        else
        {
          result.code = E_InterpretationCode_InsufficientStackSpace;
          goto done;
        }
      }
    }
  }
  done:;
  
  if(stack_count >= 1)
  {
    result.value = stack[0];
  }
  result.space = selected_space;
  scratch_end(scratch);
  return result;
}