checkpoint on eval2; type graph operations, parsing, etc.

project.4coder

@@ -49,7 +49,7 @@ commands =
   // .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
   // .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg debug telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
   // .f1 = { .win = "raddbg_stable --ipc kill_all && build radbin", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
-  .f1 = { .win = "raddbg_stable --ipc kill_all && build ryan_scratch", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
+  .f1 = { .win = "raddbg_stable --ipc kill_all && build ryan_scratch no_meta", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
   
   //- rjf: [raddbg wsl]
   // .f1 = { .win = "wsl ./build.sh raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },

project.raddbg

@@ -33,6 +33,6 @@ target:
 target:
 {
   executable: "build/ryan_scratch.exe"
-  working_directory: "build/"
+  working_directory: build
   enabled: 1
 }

src/dbg_engine/dbg_engine_ctrl.c

@@ -1804,10 +1804,21 @@ d_unwind_from_thread(Arena *arena, D_Handle thread, U64 endt_us)
   //////////////////////////////
   //- rjf: grab initial memory
   //
+  // NOTE(rjf): we can pre-fill memory that we can expect to load here -
+  // otherwise we will lazily evaluate it via the unwinding backends below
+  //
   MemoryMap memory_map = {0};
+  if(regs_block_good)
   {
-    // NOTE(rjf): we can pre-fill memory that we can expect to load here -
+    U64 sp = arch_sp_from_reg_block(arch_info, regs_block);
-    // otherwise we will lazily evaluate it via the unwinding backends below
+    U64 sp_rounded_down = AlignDownPow2(sp, KB(4));
+    Rng1U64 top_of_stack_vaddr_range = r1u64(sp_rounded_down, sp_rounded_down+KB(4));
+    D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process_entity->handle, top_of_stack_vaddr_range, 1, endt_us);
+    String8 data = slice.data;
+    if(!slice.stale)
+    {
+      memory_map_push(scratch.arena, &memory_map, top_of_stack_vaddr_range, data.str);
+    }
   }
   
   //////////////////////////////
@@ -1834,7 +1845,6 @@ d_unwind_from_thread(Arena *arena, D_Handle thread, U64 endt_us)
     unwind.flags = 0;
     for(;!unwind.flags;)
     {
-      ARCH_Info *arch_info = arch_info_from_arch(arch);
       U64 start_ip = arch_ip_from_reg_block(arch_info, regs_block);
       U64 start_sp = arch_sp_from_reg_block(arch_info, regs_block);
       
@@ -1879,7 +1889,7 @@ d_unwind_from_thread(Arena *arena, D_Handle thread, U64 endt_us)
         // stale. if it can't be read, the unwind fails.
         if(step.status == UWND_StepStatus_FailedMemoryRead)
         {
-          D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process_entity->handle, step.missed_read_vaddr_range, 1, 0);
+          D_ProcessMemorySlice slice = d_process_memory_slice_from_vaddr_range(scratch.arena, process_entity->handle, step.missed_read_vaddr_range, 1, endt_us);
           String8 data = slice.data;
           if(slice.stale)
           {
@@ -6157,7 +6167,7 @@ d_call_stack_artifact_create(String8 key, B32 *cancel_signal, B32 *retry_out, U6
       {
         pre_reg_gen = d_reg_gen();
         pre_mem_gen = d_mem_gen();
-        unwind = d_unwind_from_thread(arena, thread_handle, 0);
+        unwind = d_unwind_from_thread(arena, thread_handle, now_time_us()+100);
         if(!(unwind.flags & D_UnwindFlag_Stale))
         {
           good = 1;

src/eval/eval_types.c

@@ -758,7 +758,7 @@ e_push_type_from_key(Arena *arena, E_TypeKey key)
           RDI_TopLevelInfo *tli = rdi_element_from_name_idx(rdi, TopLevelInfo, 0);
           Arch arch = arch_from_rdi_arch(tli->arch);
           RDI_TypeNode *rdi_type = rdi_element_from_name_idx(rdi, TypeNodes, type_node_idx);
-          if(rdi_type->kind != RDI_TypeKind_NULL)
+          if(rdi_type->kind != RDI_TypeKind_Null)
           {
             E_TypeKind kind = e_type_kind_from_rdi(rdi_type->kind);
             

src/eval2/eval2.h

@@ -61,6 +61,8 @@ typedef enum E2_Status
   E2_Status_UnsupportedOp,
   E2_Status_BadOffset,
   E2_Status_Error,
+  E2_Status_FirstError = E2_Status_BadRegCode,
+  E2_Status_LastError = E2_Status_Error,
 }
 E2_Status;
 
@@ -71,7 +73,7 @@ typedef enum E2_TypeKeyKind
 {
   E2_TypeKeyKind_Null,
   E2_TypeKeyKind_Basic,
-  E2_TypeKeyKind_Ext,
+  E2_TypeKeyKind_DbgInfo,
   E2_TypeKeyKind_Cons,
   E2_TypeKeyKind_Reg,
 }
@@ -82,9 +84,9 @@ struct E2_TypeKey
 {
   E2_TypeKeyKind kind;
   U32 u32[3];
-  // [0] -> E_TypeKind (Basic, Cons, Ext); Arch (Reg, RegAlias)
+  // [0] -> E_TypeKind (Basic, Cons, DbgInfo); Arch (Reg)
-  // [1] -> Type Index In Debug Info (Ext); Code (Reg, RegAlias); Type Index In Constructed (Cons)
+  // [1] -> Debug Info Number (DbgInfo); Code (Reg); Type Index In Constructed (Cons)
-  // [2] -> Debug Info Number (Ext)
+  // [2] -> Type Index In Debug Info (DbgInfo)
 };
 
 typedef struct E2_TypeKeyNode E2_TypeKeyNode;
@@ -319,7 +321,7 @@ typedef struct E2_ParseTask E2_ParseTask;
 struct E2_ParseTask
 {
   E2_ParseTask *next;
-  E2_Expr *parent;
+  Rng1U64 src_range;
   E2_ExprNode *first_child;
   E2_ExprNode *last_child;
   U64 child_count;
@@ -411,6 +413,8 @@ struct E2_Interp
 ////////////////////////////////
 //~ rjf: Globals
 
+thread_static E2_Assets *e2_assets = 0;
+read_only global E2_DbgInfo e2_dbg_info_nil = {{0}, &rdi_parsed_nil};
 read_only global E2_Expr e2_expr_nil = {&e2_expr_nil, &e2_expr_nil, &e2_expr_nil};
 
 ////////////////////////////////
@@ -431,10 +435,100 @@ internal E2_Expr *e2_expr_from_name(E2_ExprMap *map, String8 name);
 internal E2_Msg *e2_msg(Arena *arena, E2_MsgList *msgs, Rng1U64 src_range, String8 string);
 internal E2_Msg *e2_msgf(Arena *arena, E2_MsgList *msgs, Rng1U64 src_range, char *fmt, ...);
 
+////////////////////////////////
+//~ rjf: Assets
+
+internal void e2_select_assets(E2_Assets *assets);
+internal E2_DbgInfo *e2_dbgi_from_num(U32 num);
+
 ////////////////////////////////
 //~ rjf: Type Keys
 
+//- rjf: enums
+internal E2_TypeKind e2_type_kind_from_rdi(RDI_TypeKind k);
+internal RDI_EvalTypeGroup e2_type_group_from_kind(E2_TypeKind k);
+internal B32 e2_type_kind_is_ptr_or_ref(E2_TypeKind k);
+internal B32 e2_type_kind_is_integer(E2_TypeKind k);
+internal B32 e2_type_kind_is_float(E2_TypeKind k);
+internal B32 e2_type_kind_is_signed(E2_TypeKind k);
+internal B32 e2_type_kind_is_unsigned(E2_TypeKind k);
+
+//- rjf: basic key constructors
+internal E2_TypeKey e2_type_key_zero(void);
 internal E2_TypeKey e2_type_key_basic(E2_TypeKind kind);
+internal E2_TypeKey e2_type_key_dbgi(E2_TypeKind kind, U32 dbg_info_num, U32 type_idx);
+internal E2_TypeKey e2_type_key_reg(Arch arch, ARCH_RegCode reg_code);
+
+//- rjf: constructed type constructor
+typedef struct E2_ConsTypeParams E2_ConsTypeParams;
+struct E2_ConsTypeParams
+{
+  Arch arch;
+  E2_TypeKind kind;
+  E2_TypeFlags flags;
+  String8 name;
+  E2_TypeKey direct_type_key;
+  U64 count;
+  U64 depth;
+  E2_Expr **args;
+};
+internal E2_TypeKey e2_type_key_cons_(E2_ConsTypeParams *params);
+#define e2_type_key_cons(k, ...) e2_type_key_cons_(&(E2_ConsTypeParams){.kind = (k), __VA_ARGS__})
+
+//- rjf: constructed type constructor helpers
+#define e2_type_key_cons_array(element_type_key, count_, ...) e2_type_key_cons(E2_TypeKind_Array, .direct_type_key = (element_type_key), .count = (count_), __VA_ARGS__)
+#define e2_type_key_cons_ptr(arch, ptee_type_key, ...) e2_type_key_cons(E2_TypeKind_Ptr, .direct_type_key = (ptee_type_key), __VA_ARGS__)
+
+//- rjf: basic type key type functions
+internal B32 e2_type_key_match(E2_TypeKey a, E2_TypeKey b);
+
+//- rjf: type key -> info
+internal E2_TypeKind e2_type_kind_from_key(E2_TypeKey k);
+internal U64 e2_byte_size_from_type_key(E2_TypeKey k);
+internal U32 e2_dbgi_num_from_type_key(E2_TypeKey k);
+internal E2_DbgInfo *e2_dbgi_from_type_key(E2_TypeKey k);
+internal U32 e2_dbgi_type_idx_from_key(E2_TypeKey k);
+internal U64 e2_shift_from_type_key(E2_TypeKey k);
+internal U64 e2_mask_count_from_type_key(E2_TypeKey k);
+internal Arch e2_arch_from_type_key(E2_TypeKey k);
+
+//- rjf: type graph traversal primitives
+internal E2_TypeKey e2_type_key_direct(E2_TypeKey k);
+internal E2_TypeKey e2_type_key_owner(E2_TypeKey k);
+
+//- rjf: type unwrapping (helpers for advancing past categories of direct type chains)
+typedef U32 E2_TypeUnwrapFlags;
+enum
+{
+  E2_TypeUnwrapFlag_Modifiers     = (1<<0),
+  E2_TypeUnwrapFlag_Pointers      = (1<<1),
+  E2_TypeUnwrapFlag_Lenses        = (1<<2),
+  E2_TypeUnwrapFlag_Meta          = (1<<3),
+  E2_TypeUnwrapFlag_Enums         = (1<<4),
+  E2_TypeUnwrapFlag_Aliases       = (1<<5),
+  E2_TypeUnwrapFlag_Bitfields     = (1<<6),
+  E2_TypeUnwrapFlag_All           = 0xffffffff,
+  E2_TypeUnwrapFlag_AllDecorative = (E2_TypeUnwrapFlag_All & ~(E2_TypeUnwrapFlag_Pointers|E2_TypeUnwrapFlag_Bitfields))
+};
+internal E2_TypeKey e2_type_key_unwrap(E2_TypeKey k, E2_TypeUnwrapFlags flags);
+#define e2_type_key_undecorate(k) e2_type_key_unwrap((k), E2_TypeUnwrapFlag_AllDecorative)
+
+//- rjf: type coercion
+internal E2_TypeKey e2_coerced_type_key_from_operands(E2_TypeKey lhs, E2_TypeKey rhs);
+
+////////////////////////////////
+//~ rjf: Expression Constructors
+
+internal E2_Expr *e2_expr(Arena *arena);
+internal E2_Expr *e2_expr_const_u64_or_smaller(Arena *arena, U64 u);
+internal E2_Expr *e2_expr_const_f32(Arena *arena, F32 f32);
+internal E2_Expr *e2_expr_const_f64(Arena *arena, F64 f64);
+internal E2_Expr *e2_expr_unary_op(Arena *arena, E2_TypeKey type_key, RDI_EvalOp op, E2_Expr *operand);
+internal E2_Expr *e2_expr_binary_op(Arena *arena, E2_TypeKey type_key, RDI_EvalOp op, E2_Expr *lhs, E2_Expr *rhs);
+internal E2_Expr *e2_expr_resolve_to_value(Arena *arena, E2_Expr *expr);
+internal E2_Expr *e2_expr_truncate(Arena *arena, E2_Expr *expr, E2_TypeKey dst_type_key);
+internal E2_Expr *e2_expr_convert_if_possible(Arena *arena, E2_Expr *expr, E2_TypeKey dst_type_key);
+internal void e2_expr_push_child(E2_Expr *parent, E2_Expr *expr);
 
 ////////////////////////////////
 //~ rjf: String -> Expression
@@ -442,7 +536,7 @@ internal E2_TypeKey e2_type_key_basic(E2_TypeKind kind);
 internal E2_Token e2_token_from_string_off(String8 string, U64 start_off);
 internal U64 e2_read_token(String8 string, U64 off, E2_Token *token_out);
 internal B32 e2_try_token(String8 string, E2_TokenKind kind, String8 expected_string, U64 *off_out, E2_Token *token_out);
-internal E2_Parse e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_SpaceMap *space_map, E2_ExprMap *expr_map, String8 string);
+internal E2_Parse e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, String8 string);
 
 ////////////////////////////////
 //~ rjf: Expression -> Bytecode

src/eval2/eval2.mdesk

@@ -128,3 +128,14 @@ E2_TypeKindTable:
   `FirstMeta       = E2_TypeKind_MetaExpr`,
   `LastMeta        = E2_TypeKind_MetaDescription`,
 }
+
+@data(U8) e2_type_kind_basic_byte_size_table:
+{
+  @expand(E2_TypeKindTable a) `$(a.basic_byte_size)`
+}
+
+@data(String8) e2_type_kind_basic_string_table:
+{
+  @expand(E2_TypeKindTable a) `str8_lit_comp("$(a.basic_string)")`
+}
+

src/eval2/generated/eval2.meta.c

@@ -34,5 +34,135 @@ E2_OpInfo e2_op_kind_info_table[26] =
 {E2_OpParseKind_Binary, 13, str8_lit_comp(""), str8_lit_comp("="), str8_lit_comp(""), str8_lit_comp("")},
 };
 
+U8 e2_type_kind_basic_byte_size_table[61] =
+{
+0,
+0,
+0xFF,
+4,
+1,
+2,
+4,
+1,
+2,
+4,
+1,
+2,
+4,
+8,
+16,
+32,
+64,
+1,
+2,
+4,
+8,
+16,
+32,
+64,
+1,
+2,
+4,
+4,
+6,
+8,
+10,
+16,
+8,
+16,
+20,
+32,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+};
+
+String8 e2_type_kind_basic_string_table[61] =
+{
+str8_lit_comp(""),
+str8_lit_comp("void"),
+str8_lit_comp("HANDLE"),
+str8_lit_comp("HRESULT"),
+str8_lit_comp("char8"),
+str8_lit_comp("char16"),
+str8_lit_comp("char32"),
+str8_lit_comp("uchar8"),
+str8_lit_comp("uchar16"),
+str8_lit_comp("uchar32"),
+str8_lit_comp("uint8"),
+str8_lit_comp("uint16"),
+str8_lit_comp("uint32"),
+str8_lit_comp("uint64"),
+str8_lit_comp("uint128"),
+str8_lit_comp("uint256"),
+str8_lit_comp("uint512"),
+str8_lit_comp("int8"),
+str8_lit_comp("int16"),
+str8_lit_comp("int32"),
+str8_lit_comp("int64"),
+str8_lit_comp("int128"),
+str8_lit_comp("int256"),
+str8_lit_comp("int512"),
+str8_lit_comp("bool"),
+str8_lit_comp("float16"),
+str8_lit_comp("float32"),
+str8_lit_comp("float32PP"),
+str8_lit_comp("float48"),
+str8_lit_comp("float64"),
+str8_lit_comp("float80"),
+str8_lit_comp("float128"),
+str8_lit_comp("complex_float32"),
+str8_lit_comp("complex_float64"),
+str8_lit_comp("complex_float80"),
+str8_lit_comp("complex_float128"),
+str8_lit_comp("modifier"),
+str8_lit_comp("ptr"),
+str8_lit_comp("lref"),
+str8_lit_comp("rref"),
+str8_lit_comp("array"),
+str8_lit_comp("function"),
+str8_lit_comp("method"),
+str8_lit_comp("member_ptr"),
+str8_lit_comp("struct"),
+str8_lit_comp("class"),
+str8_lit_comp("union"),
+str8_lit_comp("enum"),
+str8_lit_comp("typedef"),
+str8_lit_comp("struct"),
+str8_lit_comp("union"),
+str8_lit_comp("class"),
+str8_lit_comp("enum"),
+str8_lit_comp("bitfield"),
+str8_lit_comp("variadic"),
+str8_lit_comp("set"),
+str8_lit_comp("lens"),
+str8_lit_comp("lens_spec"),
+str8_lit_comp("meta_expr"),
+str8_lit_comp("meta_display_name"),
+str8_lit_comp("meta_description"),
+};
+
 C_LINKAGE_END
 

src/eval2/generated/eval2.meta.h

@@ -117,6 +117,8 @@ E2_TypeKind_LastMeta        = E2_TypeKind_MetaDescription,
 
 C_LINKAGE_BEGIN
 extern E2_OpInfo e2_op_kind_info_table[26];
+extern U8 e2_type_kind_basic_byte_size_table[61];
+extern String8 e2_type_kind_basic_string_table[61];
 
 C_LINKAGE_END
 

src/lib_rdi/rdi.c

@@ -81,17 +81,17 @@ RDI_EVAL_CTRLBITS(64, 0, 1),
 RDI_EVAL_CTRLBITS(1, 0, 1),
 RDI_EVAL_CTRLBITS(1, 1, 1),
 RDI_EVAL_CTRLBITS(1, 1, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
 RDI_EVAL_CTRLBITS(2, 2, 1),
 RDI_EVAL_CTRLBITS(2, 2, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
-RDI_EVAL_CTRLBITS(1, 2, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
-RDI_EVAL_CTRLBITS(1, 1, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
+RDI_EVAL_CTRLBITS(2, 2, 1),
+RDI_EVAL_CTRLBITS(2, 1, 1),
 RDI_EVAL_CTRLBITS(1, 2, 1),
 RDI_EVAL_CTRLBITS(1, 2, 1),
 RDI_EVAL_CTRLBITS(1, 1, 1),
@@ -162,7 +162,6 @@ RDI_U8 *result = 0;
 switch (kind)
 {
 default:{}break;
-case RDI_TypeKind_NULL: {result = (RDI_U8*)"NULL"; *size_out = sizeof("NULL")-1;}break;
 case RDI_TypeKind_Void: {result = (RDI_U8*)"Void"; *size_out = sizeof("Void")-1;}break;
 case RDI_TypeKind_Handle: {result = (RDI_U8*)"Handle"; *size_out = sizeof("Handle")-1;}break;
 case RDI_TypeKind_HResult: {result = (RDI_U8*)"HResult"; *size_out = sizeof("HResult")-1;}break;
@@ -222,7 +221,6 @@ case RDI_TypeKind_IncompleteUnion: {result = (RDI_U8*)"IncompleteUnion"; *size_o
 case RDI_TypeKind_IncompleteClass: {result = (RDI_U8*)"IncompleteClass"; *size_out = sizeof("IncompleteClass")-1;}break;
 case RDI_TypeKind_IncompleteEnum: {result = (RDI_U8*)"IncompleteEnum"; *size_out = sizeof("IncompleteEnum")-1;}break;
 case RDI_TypeKind_Bitfield: {result = (RDI_U8*)"Bitfield"; *size_out = sizeof("Bitfield")-1;}break;
-case RDI_TypeKind_COUNT: {result = (RDI_U8*)"COUNT"; *size_out = sizeof("COUNT")-1;}break;
 }
 return result;
 }

src/lib_rdi/rdi.h

@@ -274,7 +274,7 @@ RDI_Language_COUNT      = 4,
 typedef RDI_U16 RDI_TypeKind;
 typedef enum RDI_TypeKindEnum
 {
-RDI_TypeKind_NULL                 = 0x0000,
+RDI_TypeKind_Null,
 RDI_TypeKind_Void                 = 0x0001,
 RDI_TypeKind_Handle               = 0x0002,
 RDI_TypeKind_HResult              = 0x0003,
@@ -334,7 +334,6 @@ RDI_TypeKind_IncompleteUnion      = 0x2006,
 RDI_TypeKind_IncompleteClass      = 0x2007,
 RDI_TypeKind_IncompleteEnum       = 0x2008,
 RDI_TypeKind_Bitfield             = 0xF000,
-RDI_TypeKind_COUNT                = 0xF002,
 RDI_TypeKind_FirstBuiltIn         = RDI_TypeKind_Void,
 RDI_TypeKind_LastBuiltIn          = RDI_TypeKind_Variadic,
 RDI_TypeKind_FirstConstructed     = RDI_TypeKind_Modifier,
@@ -345,6 +344,7 @@ RDI_TypeKind_FirstIncomplete      = RDI_TypeKind_IncompleteStruct,
 RDI_TypeKind_LastIncomplete       = RDI_TypeKind_IncompleteEnum,
 RDI_TypeKind_FirstRecord          = RDI_TypeKind_Struct,
 RDI_TypeKind_LastUserDefined      = RDI_TypeKind_IncompleteEnum,
+RDI_TypeKind_COUNT,
 } RDI_TypeKindEnum;
 
 typedef RDI_U16 RDI_TypeModifierFlags;
@@ -471,6 +471,8 @@ RDI_EvalOp_PartialValueBit      = 50,
 RDI_EvalOp_Swap                 = 51,
 RDI_EvalOp_PushCfa              = 52,
 RDI_EvalOp_COUNT                = 53,
+RDI_EvalOp_FirstLogical = RDI_EvalOp_LogAnd,
+RDI_EvalOp_LastLogical = RDI_EvalOp_Grtr,
 } RDI_EvalOpEnum;
 
 typedef RDI_U8 RDI_EvalTypeGroup;
@@ -771,7 +773,6 @@ X(Masm)\
 X(COUNT)\
 
 #define RDI_TypeKind_XList \
-X(NULL)\
 X(Void)\
 X(Handle)\
 X(HResult)\
@@ -831,7 +832,6 @@ X(IncompleteUnion)\
 X(IncompleteClass)\
 X(IncompleteEnum)\
 X(Bitfield)\
-X(COUNT)\
 
 #define RDI_TypeModifierFlags_XList \
 X(Const)\

src/lib_rdi_make/rdi_make.c

@@ -545,7 +545,7 @@ rdim_rng1u64_chunk_list_push(RDIM_Arena *arena, RDIM_Rng1U64ChunkList *list, RDI
 RDI_PROC RDI_TypeKind
 rdim_short_type_kind_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -561,7 +561,7 @@ rdim_short_type_kind_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_unsigned_short_type_kind_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -577,7 +577,7 @@ rdim_unsigned_short_type_kind_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_int_type_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -593,7 +593,7 @@ rdim_int_type_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_unsigned_int_type_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -609,7 +609,7 @@ rdim_unsigned_int_type_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_long_type_kind_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -625,7 +625,7 @@ rdim_long_type_kind_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_unsigned_long_type_kind_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -641,7 +641,7 @@ rdim_unsigned_long_type_kind_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_long_long_type_kind_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -657,7 +657,7 @@ rdim_long_long_type_kind_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_unsigned_long_long_type_kind_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;
@@ -673,7 +673,7 @@ rdim_unsigned_long_long_type_kind_from_data_model(RDIM_DataModel data_model)
 RDI_PROC RDI_TypeKind
 rdim_pointer_size_t_type_kind_from_data_model(RDIM_DataModel data_model)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch((RDIM_DataModelEnum)data_model)
   {
     case RDIM_DataModel_Null:{}break;

src/rdi/rdi.mdesk

@@ -718,8 +718,6 @@ RDI_LanguageTable:
 @table(name value size bookend1 bookend2)
 RDI_TypeKindTable:
 {
-  {NULL                 0x0000     0                                             }
-  //-
   {Void                 0x0001     0              FirstBuiltIn                   }
   {Handle               0x0002     0xFFFFFFFF                                    }
   {HResult              0x0003     4                                             }
@@ -782,7 +780,6 @@ RDI_TypeKindTable:
   {IncompleteEnum       0x2008     0               LastIncomplete LastUserDefined}
   //-
   {Bitfield             0xF000     0                                             }
-  {COUNT                0xF002     0                                             }
 }
 
 @table(name value)
@@ -857,9 +854,11 @@ RDI_EnumMemberTable:
 
 @enum(RDI_U16) RDI_TypeKind:
 {
+  `Null`,
   @expand(RDI_TypeKindTable a) `$(a.name .. =>20) = $(a.value)`;
   @expand(RDI_TypeKindTable a) `$(a.bookend1 != "" -> a.bookend1 .. =>20 .. " = RDI_TypeKind_" .. a.name)`;
   @expand(RDI_TypeKindTable a) `$(a.bookend2 != "" -> a.bookend2 .. =>20 .. " = RDI_TypeKind_" .. a.name)`;
+  `COUNT`;
 }
 
 @enum(RDI_U16) RDI_TypeModifierFlags:
@@ -1193,7 +1192,7 @@ RDI_LocationSetElementMemberTable:
 ////////////////////////////////
 //~ rjf: Evaluation Bytecode Tables
 
-@table(name value num_decodes num_pops num_pushes)
+@table(name value num_decodes num_pops num_pushes bookend)
 RDI_EvalOpTable:
 {
   {Stop            0       0 0 0}
@@ -1217,18 +1216,18 @@ RDI_EvalOpTable:
   {ConstString     18      1 0 1}
   {Abs             19      1 1 1}
   {Neg             20      1 1 1}
-  {Add             21      1 2 1}
+  {Add             21      2 2 1}
-  {Sub             22      1 2 1}
+  {Sub             22      2 2 1}
-  {Mul             23      1 2 1}
+  {Mul             23      2 2 1}
-  {Div             24      1 2 1}
+  {Div             24      2 2 1}
-  {Mod             25      1 2 1}
+  {Mod             25      2 2 1}
   {LShift          26      2 2 1}
   {RShift          27      2 2 1}
-  {BitAnd          28      1 2 1}
+  {BitAnd          28      2 2 1}
-  {BitOr           29      1 2 1}
+  {BitOr           29      2 2 1}
-  {BitXor          30      1 2 1}
+  {BitXor          30      2 2 1}
-  {BitNot          31      1 1 1}
+  {BitNot          31      2 1 1}
-  {LogAnd          32      1 2 1}
+  {LogAnd          32      1 2 1 FirstLogical}
   {LogOr           33      1 2 1}
   {LogNot          34      1 1 1}
   {EqEq            35      1 2 1}
@@ -1236,7 +1235,7 @@ RDI_EvalOpTable:
   {LsEq            37      1 2 1}
   {GrEq            38      1 2 1}
   {Less            39      1 2 1}
-  {Grtr            40      1 2 1}
+  {Grtr            40      1 2 1 LastLogical}
   {Trunc           41      1 1 1}
   {TruncSigned     42      1 1 1}
   {Convert         43      2 1 1}
@@ -1280,7 +1279,8 @@ RDI_EvalConversionKindTable:
 
 @enum(RDI_U8) RDI_EvalOp:
 {
-  @expand(RDI_EvalOpTable a) `$(a.name .. =>20) = $(a.value)`
+  @expand(RDI_EvalOpTable a) `$(a.name .. =>20) = $(a.value)`,
+  @expand(RDI_EvalOpTable a) `$(a.bookend != "" -> a.bookend .. " = RDI_EvalOp_" .. a.name)`,
 }
 
 @enum(RDI_U8) RDI_EvalTypeGroup:

src/rdi_from_dwarf/rdi_from_dwarf.c

@@ -2104,7 +2104,7 @@ d2r_convert(Arena *arena, D2R_ConvertParams *params)
         
         // rjf: convert type
         RDIM_Type *dst_type = 0;
-        RDI_TypeKind rdi_type_kind = RDI_TypeKind_NULL;
+        RDI_TypeKind rdi_type_kind = RDI_TypeKind_Null;
         RDI_TypeModifierFlags rdi_type_modifier_flags = 0;
         switch(tag.kind)
         {
@@ -2254,7 +2254,7 @@ d2r_convert(Arena *arena, D2R_ConvertParams *params)
 #define CaseB(rdi_type_kind_, encoding_, bit_size_)                       else if(encoding == (encoding_) && bitsize == (bit_size_)) { rdi_type_kind = (rdi_type_kind_); }
 #define CaseC(rdi_type_kind_, encoding_, name_) /* assumes x64/arm64 */   else if(encoding == (encoding_) && str8_match(name, str8_lit(name_), 0)) { rdi_type_kind = (rdi_type_kind_); }
 #define CaseD(rdi_type_kind_, encoding_, name_, bit_size_)                else if(encoding == (encoding_) && bitsize == (bit_size_) && str8_match(name, str8_lit(name_), 0)) { rdi_type_kind = (rdi_type_kind_); }
-            CaseA(RDI_TypeKind_NULL,        DW_ATE_Null)
+            CaseA(RDI_TypeKind_Null,        DW_ATE_Null)
               CaseA(RDI_TypeKind_Void,        DW_ATE_Address)
               CaseA(RDI_TypeKind_Bool,        DW_ATE_Boolean)
               CaseB(RDI_TypeKind_ComplexF32,  DW_ATE_ComplexFloat, 64)

src/rdi_from_pdb/rdi_from_pdb.c

@@ -199,7 +199,7 @@ p2r_rdi_language_from_cv_language(CV_Language cv_language)
 internal RDI_TypeKind
 p2r_rdi_type_kind_from_cv_basic_type(CV_BasicType basic_type)
 {
-  RDI_TypeKind result = RDI_TypeKind_NULL;
+  RDI_TypeKind result = RDI_TypeKind_Null;
   switch(basic_type)
   {
     case CV_BasicType_VOID: {result = RDI_TypeKind_Void;}break;

src/scratch/ryan_scratch.c

@@ -38,17 +38,66 @@
 internal void
 entry_point(CmdLine *cmdline)
 {
-  Temp scratch = scratch_begin(0, 0);
+  String8 strings[] =
-  E2_ParseState state = {0};
-  E2_SpaceMap space_map = {0};
-  E2_ExprMap expr_map = {0};
-  for(;;)
   {
-    E2_Parse parse = e2_parse_from_string(scratch.arena, &state, &space_map, &expr_map, s("!123"));
+    s("123"),
-    if(parse.status == E2_Status_Good)
+    s("123 + 456"),
+    s("!1"),
+    s("!0"),
+    s("1 + 1 + 1"),
+    s("40 / 0"),
+    s("3 * 4"),
+    s("3 * 4 + 2"),
+    s("(3 * 4) + 2"),
+    s("2 + (3 * 4)"),
+  };
+  for EachElement(idx, strings)
+  {
+    Temp scratch = scratch_begin(0, 0);
+    
+    // rjf: string -> expr
+    E2_Expr *expr = &e2_expr_nil;
     {
-      break;
+      E2_ParseState state = {0};
+      E2_ExprMap expr_map = {0};
+      for(;;)
+      {
+        E2_Parse parse = e2_parse_from_string(scratch.arena, &state, &expr_map, strings[idx]);
+        if(parse.status == E2_Status_Good)
+        {
+          expr = parse.expr;
+          break;
+        }
+      }
     }
+    
+    // rjf: expr -> bytecode
+    String8 bytecode = e2_bytecode_from_expr(scratch.arena, expr);
+    
+    // rjf: bytecode -> value
+    E2_Val val = {0};
+    {
+      E2_InterpState state = {0};
+      E2_SpaceMap space_map = {0};
+      for(;;)
+      {
+        E2_Interp interp = e2_interp_from_bytecode(scratch.arena, &state, &space_map, bytecode);
+        if(interp.status == E2_Status_Good)
+        {
+          val = interp.val;
+          break;
+        }
+        else if(E2_Status_FirstError <= interp.status <= E2_Status_LastError)
+        {
+          break;
+        }
+      }
+    }
+    
+    // rjf: log
+    printf("%.*s -> %I64u\n", str8_varg(strings[idx]), val.u64);
+    fflush(stdout);
+    
+    scratch_end(scratch);
   }
-  scratch_end(scratch);
 }