Merge branch 'dev'

.github/workflows/builds.yml

@@ -20,9 +20,9 @@ jobs:
         shell: cmd
         run: |
           call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
-          call build raddbg msvc debug
+          call build raddbg msvc debug             || exit /b 1
-          call build raddbg_from_pdb msvc debug
+          call build raddbg_from_pdb msvc debug    || exit /b 1
-          call build raddbg_from_dwarf msvc debug
+          call build raddbg_from_dwarf msvc debug  || exit /b 1
-          call build raddbg clang debug
+          call build raddbg clang debug            || exit /b 1
-          call build raddbg_from_pdb clang debug
+          call build raddbg_from_pdb clang debug   || exit /b 1
-          call build raddbg_from_dwarf clang debug
+          call build raddbg_from_dwarf clang debug || exit /b 1

build.bat

@@ -60,6 +60,8 @@ if "%msvc%"=="1"  set only_compile=/c
 if "%clang%"=="1" set only_compile=-c
 if "%msvc%"=="1"  set EHsc=/EHsc
 if "%clang%"=="1" set EHsc=
+if "%msvc%"=="1"  set rc=rc.exe
+if "%clang%"=="1" set rc=llvm-rc.exe
 
 :: --- Choose Compile/Link Lines ----------------------------------------------
 if "%msvc%"=="1"      set compile_debug=%cl_debug%
@@ -79,7 +81,7 @@ if not exist local mkdir local
 
 :: --- Produce Logo Icon File -------------------------------------------------
 pushd build
-rc /nologo /fo logo.res ..\data\logo.rc
+%rc% /nologo /fo logo.res ..\data\logo.rc || exit /b 1
 popd
 
 :: --- Build & Run Metaprogram ------------------------------------------------

project.4coder

@@ -65,7 +65,7 @@ commands =
   },
   .rjf_f3 =
   {
-    .win = "pushd build && raddbg.exe && popd",
+    .win = "pushd build && raddbg.exe --user:local_dev.raddbg_user --profile:local_dev.raddbg_profile && popd",
     .linux = "",
     .out = "*compilation*",
     .footer_panel = true,

src/ctrl/ctrl_core.c

@@ -754,189 +754,12 @@ ctrl_process_read(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range,
   return actual_bytes_read;
 }
 
-internal String8
-ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range)
-{
-  String8 result = {0};
-  if(range.max > range.min &&
-     dim_1u64(range) <= MB(256) &&
-     range.min <= 0x000FFFFFFFFFFFFFull &&
-     range.max <= 0x000FFFFFFFFFFFFFull)
-  {
-    HS_Scope *scope = hs_scope_open();
-    CTRL_ProcessMemoryCache *cache = &ctrl_state->process_memory_cache;
-    
-    //- rjf: unpack address range
-    Rng1U64 page_range = r1u64(AlignDownPow2(range.min, KB(4)), AlignPow2(range.max, KB(4)));
-    
-    //- rjf: setup output memory for read
-    void *read_out = push_array(arena, U8, dim_1u64(page_range));
-    
-    //- rjf: unpack process/machine params
-    U64 hash = ctrl_hash_from_string(str8_struct(&process));
-    U64 slot_idx = hash%cache->slots_count;
-    U64 stripe_idx = slot_idx%cache->stripes_count;
-    CTRL_ProcessMemoryCacheSlot *slot = &cache->slots[slot_idx];
-    CTRL_ProcessMemoryCacheStripe *stripe = &cache->stripes[stripe_idx];
-    
-    //- rjf: cache lookup & fill loop
-    for(U64 page_vaddr = page_range.min; page_vaddr < page_range.max; page_vaddr += KB(4))
-    {
-      // rjf: unpack page base address
-      U64 lvl5_idx         = (page_vaddr&0x00000000000FF000ull) >> 12;
-      U64 lvl4_idx         = (page_vaddr&0x000000000FF00000ull) >> 20;
-      U64 lvl3_idx         = (page_vaddr&0x0000000FF0000000ull) >> 28;
-      U64 lvl2_idx         = (page_vaddr&0x00000FF000000000ull) >> 36;
-      U64 lvl1_idx         = (page_vaddr&0x000FF00000000000ull) >> 44;
-      
-      // rjf: try to find node & read from it
-      B32 node_found = 0;
-      B32 page_found = 0;
-      B32 page_stale = 0;
-      OS_MutexScopeR(stripe->rw_mutex)
-      {
-        CTRL_ProcessMemoryCacheNode *node = 0;
-        for(CTRL_ProcessMemoryCacheNode *n = slot->first; n != 0; n = n->next)
-        {
-          if(ctrl_handle_match(process, n->process) && n->machine_id == machine_id)
-          {
-            node = n;
-            break;
-          }
-        }
-        if(node != 0)
-        {
-          node_found = 1;
-          CTRL_ProcessMemoryCacheNode1 *node1 =  node->children[lvl1_idx];
-          CTRL_ProcessMemoryCacheNode2 *node2 = node1 ? node1->children[lvl2_idx] : 0;
-          CTRL_ProcessMemoryCacheNode3 *node3 = node2 ? node2->children[lvl3_idx] : 0;
-          CTRL_ProcessMemoryCacheNode4 *node4 = node3 ? node3->children[lvl4_idx] : 0;
-          U128 page_hash = node4 ? node4->page_hashes[lvl5_idx] : u128_zero();
-          B32 stale = (node4 && node4->page_memgen_idxs[lvl5_idx] < ctrl_memgen_idx());
-          if(!u128_match(page_hash, u128_zero()))
-          {
-            page_stale = stale;
-            String8 page_data = hs_data_from_hash(scope, page_hash);
-            if(page_data.size >= KB(4))
-            {
-              page_found = 1;
-              MemoryCopy((U8*)read_out + (page_vaddr-page_range.min), page_data.str, KB(4));
-            }
-            else
-            {
-              page_stale = 1;
-            }
-          }
-        }
-      }
-      
-      // rjf: either node or page not found? -> need a hard-lock & fill
-      if(!node_found || !page_found || page_stale) OS_MutexScopeW(stripe->rw_mutex)
-      {
-        CTRL_ProcessMemoryCacheNode *node = 0;
-        for(CTRL_ProcessMemoryCacheNode *n = slot->first; n != 0; n = n->next)
-        {
-          if(ctrl_handle_match(process, n->process) && n->machine_id == machine_id)
-          {
-            node = n;
-            break;
-          }
-        }
-        if(node == 0)
-        {
-          Arena *node_arena = arena_alloc();
-          node = push_array(node_arena, CTRL_ProcessMemoryCacheNode, 1);
-          node->arena = node_arena;
-          node->machine_id = machine_id;
-          node->process = process;
-          node->range_hash_slots_count = 1024;
-          node->range_hash_slots = push_array(node_arena, CTRL_ProcessMemoryRangeHashSlot, node->range_hash_slots_count);
-          DLLPushBack(slot->first, slot->last, node);
-        }
-        if(!page_found || page_stale)
-        {
-          CTRL_ProcessMemoryCacheNode1 *node1 = node->children[lvl1_idx];
-          if(node1 == 0)
-          {
-            node1 = push_array(node->arena, CTRL_ProcessMemoryCacheNode1, 1);
-            node->children[lvl1_idx] = node1;
-          }
-          CTRL_ProcessMemoryCacheNode2 *node2 = node1->children[lvl2_idx];
-          if(node2 == 0)
-          {
-            node2 = push_array(node->arena, CTRL_ProcessMemoryCacheNode2, 1);
-            node1->children[lvl2_idx] = node2;
-          }
-          CTRL_ProcessMemoryCacheNode3 *node3 = node2->children[lvl3_idx];
-          if(node3 == 0)
-          {
-            node3 = push_array(node->arena, CTRL_ProcessMemoryCacheNode3, 1);
-            node2->children[lvl3_idx] = node3;
-          }
-          CTRL_ProcessMemoryCacheNode4 *node4 = node3->children[lvl4_idx];
-          if(node4 == 0)
-          {
-            node4 = push_array(node->arena, CTRL_ProcessMemoryCacheNode4, 1);
-            node3->children[lvl4_idx] = node4;
-          }
-          Arena *page_arena = arena_alloc__sized(KB(8), KB(8));
-          void *page_base = push_array_no_zero(page_arena, U8, KB(4));
-          U64 actual_read_size = ctrl_process_read(machine_id, process, r1u64(page_vaddr, page_vaddr+KB(4)), page_base);
-          if(actual_read_size >= KB(4))
-          {
-            node4->page_memgen_idxs[lvl5_idx] = ctrl_memgen_idx();
-            if(page_stale)
-            {
-              MemoryCopy((U8*)read_out + (page_vaddr-page_range.min), page_base, KB(4));
-            }
-            U64 page_key_data[] =
-            {
-              (U64)machine_id,
-              (U64)process.u64[0],
-              page_vaddr,
-              page_vaddr+KB(4),
-            };
-            U128 page_key = hs_hash_from_data(str8((U8 *)page_key_data, sizeof(page_key_data)));
-            U128 page_hash = hs_submit_data(page_key,  &page_arena, str8((U8 *)page_base, KB(4)));
-            node4->page_hashes[lvl5_idx] = page_hash;
-          }
-          else
-          {
-            arena_release(page_arena);
-          }
-        }
-      }
-    }
-    
-    //- rjf: fill result by skipping/chopping read memory
-    U64 byte_in_page_idx = (range.min&0x0000000000000FFFull) >> 0;
-    result.str = (U8*)read_out + byte_in_page_idx;
-    result.size = dim_1u64(range);
-    hs_scope_close(scope);
-  }
-  return result;
-}
-
-internal String8
-ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit, U64 endt_us)
-{
-  String8 result = ctrl_query_cached_data_from_process_vaddr_range(arena, machine_id, process, r1u64(vaddr, vaddr+limit));
-  for(U64 idx = 0; idx < result.size; idx += 1)
-  {
-    if(result.str[idx] == 0)
-    {
-      result.size = idx;
-      break;
-    }
-  }
-  return result;
-}
-
 internal B32
-ctrl_process_write_data(CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, String8 data)
+ctrl_process_write(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *src)
 {
   ProfBeginFunction();
-  B32 result = demon_write_memory(ctrl_demon_handle_from_ctrl(process), vaddr, data.str, data.size);
+  U64 size = dim_1u64(range);
+  B32 result = demon_write_memory(ctrl_demon_handle_from_ctrl(process), range.min, src, size);
   if(result)
   {
     ins_atomic_u64_inc_eval(&ctrl_state->memgen_idx);
@@ -945,6 +768,23 @@ ctrl_process_write_data(CTRL_MachineID machine_id, CTRL_Handle process, U64 vadd
   return result;
 }
 
+//- rjf: process memory cache interaction
+
+internal U128
+ctrl_hash_store_key_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated)
+{
+  U64 key_hash_data[] =
+  {
+    (U64)machine_id,
+    (U64)process.u64[0],
+    range.min,
+    range.max,
+    (U64)zero_terminated,
+  };
+  U128 key = hs_hash_from_data(str8((U8*)key_hash_data, sizeof(key_hash_data)));
+  return key;
+}
+
 internal U128
 ctrl_stored_hash_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated)
 {
@@ -1056,6 +896,130 @@ ctrl_stored_hash_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle
   return result;
 }
 
+//- rjf: process memory cache reading helpers
+
+internal CTRL_ProcessMemorySlice
+ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range)
+{
+  CTRL_ProcessMemorySlice result = {0};
+  if(range.max > range.min &&
+     dim_1u64(range) <= MB(256) &&
+     range.min <= 0x000FFFFFFFFFFFFFull &&
+     range.max <= 0x000FFFFFFFFFFFFFull)
+  {
+    Temp scratch = scratch_begin(&arena, 1);
+    HS_Scope *scope = hs_scope_open();
+    CTRL_ProcessMemoryCache *cache = &ctrl_state->process_memory_cache;
+    
+    //- rjf: unpack address range, prepare per-touched-page info
+    U64 page_size = KB(4);
+    Rng1U64 page_range = r1u64(AlignDownPow2(range.min, page_size), AlignPow2(range.max, page_size));
+    U64 page_count = dim_1u64(page_range)/page_size;
+    U128 *page_hashes = push_array(scratch.arena, U128, page_count);
+    U128 *page_last_hashes = push_array(scratch.arena, U128, page_count);
+    
+    //- rjf: gather hashes & last-hashes for each page
+    for(U64 page_idx = 0; page_idx < page_count; page_idx += 1)
+    {
+      U64 page_base_vaddr = page_range.min + page_idx*page_size;
+      U128 page_key = ctrl_hash_store_key_from_process_vaddr_range(machine_id, process, r1u64(page_base_vaddr, page_base_vaddr+page_size), 0);
+      U128 page_hash = ctrl_stored_hash_from_process_vaddr_range(machine_id, process, r1u64(page_base_vaddr, page_base_vaddr+page_size), 0);
+      U128 page_last_hash = hs_hash_from_key(page_key, 1);
+      page_hashes[page_idx] = page_hash;
+      page_last_hashes[page_idx] = page_last_hash;
+    }
+    
+    //- rjf: setup output buffers
+    void *read_out = push_array(arena, U8, dim_1u64(range));
+    U64 *byte_bad_flags = push_array(arena, U64, (dim_1u64(range)+63)/64);
+    U64 *byte_changed_flags = push_array(arena, U64, (dim_1u64(range)+63)/64);
+    
+    //- rjf: iterate pages, fill output
+    {
+      U64 write_off = 0;
+      for(U64 page_idx = 0; page_idx < page_count; page_idx += 1)
+      {
+        // rjf: read data for this page
+        String8 data = hs_data_from_hash(scope, page_hashes[page_idx]);
+        Rng1U64 data_vaddr_range = r1u64(page_range.min + page_idx*page_size, page_range.min + page_idx*page_size+data.size);
+        
+        // rjf: skip/chop bytes which are irrelevant for the actual requested read
+        String8 in_range_data = data;
+        if(page_idx == page_count-1 && data_vaddr_range.max > range.max)
+        {
+          in_range_data = str8_chop(in_range_data, data_vaddr_range.max-range.max);
+        }
+        if(page_idx == 0 && range.min > data_vaddr_range.min)
+        {
+          in_range_data = str8_skip(in_range_data, range.min-data_vaddr_range.min);
+        }
+        
+        // rjf: write this chunk
+        MemoryCopy((U8*)read_out+write_off, in_range_data.str, in_range_data.size);
+        
+        // rjf: if this page's hash & last_hash don't match, diff each byte &
+        // fill out changed flags
+        if(!u128_match(page_hashes[page_idx], page_last_hashes[page_idx]))
+        {
+          String8 last_data = hs_data_from_hash(scope, page_last_hashes[page_idx]);
+          String8 in_range_last_data = last_data;
+          if(page_idx == page_count-1 && data_vaddr_range.max > range.max)
+          {
+            in_range_last_data = str8_chop(in_range_last_data, data_vaddr_range.max-range.max);
+          }
+          if(page_idx == 0 && range.min > data_vaddr_range.min)
+          {
+            in_range_last_data = str8_skip(in_range_last_data, range.min-data_vaddr_range.min);
+          }
+          for(U64 idx = 0; idx < in_range_data.size; idx += 1)
+          {
+            U8 last_byte = idx < in_range_last_data.size ? in_range_last_data.str[idx] : 0;
+            U8 now_byte  = idx < in_range_data.size ? in_range_data.str[idx] : 0;
+            if(last_byte != now_byte)
+            {
+              U64 idx_in_read_out = write_off+idx;
+              byte_changed_flags[idx_in_read_out/64] |= (1ull<<(idx_in_read_out%64));
+            }
+          }
+        }
+        
+        // rjf: increment past this chunk
+        write_off += in_range_data.size;
+        if(data.size < page_size)
+        {
+          U64 missed_byte_count = page_size-data.size;
+          write_off += missed_byte_count;
+        }
+      }
+    }
+    
+    //- rjf: fill result
+    result.data.str = (U8*)read_out;
+    result.data.size = dim_1u64(range);
+    result.byte_bad_flags = byte_bad_flags;
+    result.byte_changed_flags = byte_changed_flags;
+    
+    hs_scope_close(scope);
+    scratch_end(scratch);
+  }
+  return result;
+}
+
+internal CTRL_ProcessMemorySlice
+ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit, U64 endt_us)
+{
+  CTRL_ProcessMemorySlice result = ctrl_query_cached_data_from_process_vaddr_range(arena, machine_id, process, r1u64(vaddr, vaddr+limit));
+  for(U64 idx = 0; idx < result.data.size; idx += 1)
+  {
+    if(result.data.str[idx] == 0)
+    {
+      result.data.size = idx;
+      break;
+    }
+  }
+  return result;
+}
+
 //- rjf: register reading/writing
 
 internal void *
@@ -2207,6 +2171,7 @@ ctrl_thread__launch_and_init(CTRL_Msg *msg)
     CTRL_EventList evts = {0};
     CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts);
     event->kind    = CTRL_EventKind_Stopped;
+    event->msg_id  = msg->msg_id;
     if(stop_event != 0)
     {
       event->cause          = ctrl_event_cause_from_demon_event_kind(stop_event->kind);
@@ -3174,6 +3139,7 @@ ctrl_mem_stream_thread__entry_point(void *p)
     Rng1U64 vaddr_range = {0};
     B32 zero_terminated = 0;
     ctrl_u2ms_dequeue_req(&machine_id, &process, &vaddr_range, &zero_terminated);
+    U128 key = ctrl_hash_store_key_from_process_vaddr_range(machine_id, process, vaddr_range, zero_terminated);
     
     //- rjf: unpack process memory cache key
     U64 process_hash = ctrl_hash_from_string(str8_struct(&process));
@@ -3187,7 +3153,9 @@ ctrl_mem_stream_thread__entry_point(void *p)
     
     //- rjf: take task
     B32 got_task = 0;
-    OS_MutexScopeR(process_stripe->rw_mutex)
+    U64 preexisting_memgen_idx = 0;
+    U128 preexisting_hash = {0};
+    OS_MutexScopeW(process_stripe->rw_mutex)
     {
       for(CTRL_ProcessMemoryCacheNode *n = process_slot->first; n != 0; n = n->next)
       {
@@ -3200,6 +3168,8 @@ ctrl_mem_stream_thread__entry_point(void *p)
             if(MemoryMatchStruct(&range_n->vaddr_range, &vaddr_range) && range_n->zero_terminated == zero_terminated)
             {
               got_task = !ins_atomic_u32_eval_cond_assign(&range_n->is_taken, 1, 0);
+              preexisting_memgen_idx = range_n->memgen_idx;
+              preexisting_hash = range_n->hash;
               goto take_task__break_all;
             }
           }
@@ -3214,7 +3184,7 @@ ctrl_mem_stream_thread__entry_point(void *p)
     void *range_base = 0;
     U64 zero_terminated_size = 0;
     U64 memgen_idx = ctrl_memgen_idx();
-    if(got_task)
+    if(got_task && memgen_idx != preexisting_memgen_idx)
     {
       range_size = dim_1u64(vaddr_range);
       U64 arena_size = AlignPow2(range_size + ARENA_HEADER_SIZE, KB(64));
@@ -3246,16 +3216,6 @@ ctrl_mem_stream_thread__entry_point(void *p)
       }
     }
     
-    //- rjf: determine key for this region
-    U64 key_hash_data[] =
-    {
-      (U64)machine_id,
-      (U64)process.u64[0],
-      vaddr_range.min,
-      vaddr_range.min + zero_terminated_size,
-    };
-    U128 key = hs_hash_from_data(str8((U8 *)key_hash_data, sizeof(key_hash_data)));
-    
     //- rjf: read successful -> submit to hash store
     U128 hash = {0};
     if(got_task && range_base != 0)

src/ctrl/ctrl_core.h

@@ -311,48 +311,6 @@ struct CTRL_EventList
 ////////////////////////////////
 //~ rjf: Process Memory Cache Types
 
-// NOTE(rjf):
-//
-// Process memory is cached with a 5-level page table. Each level has 256
-// slots, and is indexed into with 8 bits. Each index is extracted from a
-// virtual address in the following manner:
-//
-//              |1------||2------||3------||4------||5------||byte-n-page|
-// xxxxxxxx xxxx0000 00000000 00000000 00000000 00000000 0000xxxx xxxxxxxx
-//
-// The top 12 bits are not used (a 52-bit address space is supported at most).
-// The next 8 most-significant-bits are used to index into the level 1 table.
-// The next 8 are used to index into the level 2. Then the level 3. Then the
-// level 4. At the level 4 table, instead of pointing to other tables, each
-// slot points at the base address of a cached 4KB page. The next 8 bits are
-// used to index into that table. The final 12 bits in the address are used
-// to refer to unique bytes within each page.
-
-typedef struct CTRL_ProcessMemoryCacheNode4 CTRL_ProcessMemoryCacheNode4;
-struct CTRL_ProcessMemoryCacheNode4
-{
-  U64 page_memgen_idxs[256];
-  U128 page_hashes[256];
-};
-
-typedef struct CTRL_ProcessMemoryCacheNode3 CTRL_ProcessMemoryCacheNode3;
-struct CTRL_ProcessMemoryCacheNode3
-{
-  CTRL_ProcessMemoryCacheNode4 *children[256];
-};
-
-typedef struct CTRL_ProcessMemoryCacheNode2 CTRL_ProcessMemoryCacheNode2;
-struct CTRL_ProcessMemoryCacheNode2
-{
-  CTRL_ProcessMemoryCacheNode3 *children[256];
-};
-
-typedef struct CTRL_ProcessMemoryCacheNode1 CTRL_ProcessMemoryCacheNode1;
-struct CTRL_ProcessMemoryCacheNode1
-{
-  CTRL_ProcessMemoryCacheNode2 *children[256];
-};
-
 typedef struct CTRL_ProcessMemoryRangeHashNode CTRL_ProcessMemoryRangeHashNode;
 struct CTRL_ProcessMemoryRangeHashNode
 {
@@ -379,7 +337,6 @@ struct CTRL_ProcessMemoryCacheNode
   Arena *arena;
   CTRL_MachineID machine_id;
   CTRL_Handle process;
-  CTRL_ProcessMemoryCacheNode1 *children[256];
   U64 range_hash_slots_count;
   CTRL_ProcessMemoryRangeHashSlot *range_hash_slots;
 };
@@ -406,6 +363,14 @@ struct CTRL_ProcessMemoryCache
   CTRL_ProcessMemoryCacheStripe *stripes;
 };
 
+typedef struct CTRL_ProcessMemorySlice CTRL_ProcessMemorySlice;
+struct CTRL_ProcessMemorySlice
+{
+  String8 data;
+  U64 *byte_bad_flags;
+  U64 *byte_changed_flags;
+};
+
 ////////////////////////////////
 //~ rjf: Wakeup Hook Function Types
 
@@ -560,11 +525,16 @@ internal Architecture ctrl_arch_from_handle(CTRL_MachineID machine, CTRL_Handle
 
 //- rjf: process memory reading/writing
 internal U64 ctrl_process_read(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *dst);
-internal String8 ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range);
+internal B32 ctrl_process_write(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *src);
-internal String8 ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit, U64 endt_us);
+
-internal B32 ctrl_process_write_data(CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, String8 data);
+//- rjf: process memory cache interaction
+internal U128 ctrl_hash_store_key_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated);
 internal U128 ctrl_stored_hash_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated);
 
+//- rjf: process memory cache reading helpers
+internal CTRL_ProcessMemorySlice ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range);
+internal CTRL_ProcessMemorySlice ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit, U64 endt_us);
+
 //- rjf: register reading/writing
 internal void *ctrl_reg_block_from_thread(CTRL_MachineID machine_id, CTRL_Handle thread);
 internal B32 ctrl_thread_write_reg_block(CTRL_MachineID machine_id, CTRL_Handle thread, void *block);

src/df/core/df_core.c

@@ -1621,7 +1621,7 @@ df_entity_notify_mutation(DF_Entity *entity)
       DF_CmdParams p = {0};
       df_push_cmd__root(&p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_WriteProfileData));
     }
-    if(e == entity && flags & DF_EntityKindFlag_LeafMutationSoftHalt)
+    if(e == entity && flags & DF_EntityKindFlag_LeafMutationSoftHalt && df_ctrl_targets_running())
     {
       df_state->entities_mut_soft_halt = 1;
     }
@@ -1629,7 +1629,7 @@ df_entity_notify_mutation(DF_Entity *entity)
     {
       df_state->entities_mut_dbg_info_map = 1;
     }
-    if(flags & DF_EntityKindFlag_TreeMutationSoftHalt)
+    if(flags & DF_EntityKindFlag_TreeMutationSoftHalt && df_ctrl_targets_running())
     {
       df_state->entities_mut_soft_halt = 1;
     }
@@ -3486,12 +3486,14 @@ df_tls_base_vaddr_from_thread(DF_Entity *thread)
     U64 thread_info_addr = ctrl_tls_root_vaddr_from_thread(thread->ctrl_machine_id, thread->ctrl_handle);
     U64 tls_addr_off = tls_index*addr_size;
     U64 tls_addr_array = 0;
-    String8 tls_addr_array_data = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, r1u64(thread_info_addr, thread_info_addr+addr_size));
+    CTRL_ProcessMemorySlice tls_addr_array_slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, r1u64(thread_info_addr, thread_info_addr+addr_size));
+    String8 tls_addr_array_data = tls_addr_array_slice.data;
     if(tls_addr_array_data.size >= 8)
     {
       MemoryCopy(&tls_addr_array, tls_addr_array_data.str, sizeof(U64));
     }
-    String8 result_data = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, r1u64(tls_addr_array + tls_addr_off, tls_addr_array + tls_addr_off + addr_size));
+    CTRL_ProcessMemorySlice result_slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, r1u64(tls_addr_array + tls_addr_off, tls_addr_array + tls_addr_off + addr_size));
+    String8 result_data = result_slice.data;
     if(result_data.size >= 8)
     {
       MemoryCopy(&base_vaddr, result_data.str, sizeof(U64));
@@ -3953,7 +3955,8 @@ df_eval_memory_read(void *u, void *out, U64 addr, U64 size)
   Assert(process->kind == DF_EntityKind_Process);
   Temp scratch = scratch_begin(0, 0);
   B32 result = 0;
-  String8 data = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, r1u64(addr, addr+size));
+  CTRL_ProcessMemorySlice slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, r1u64(addr, addr+size));
+  String8 data = slice.data;
   if(data.size == size)
   {
     result = 1;
@@ -4251,7 +4254,8 @@ df_value_mode_eval_from_eval(TG_Graph *graph, RADDBG_Parsed *rdbg, DF_CtrlCtx *c
         Rng1U64 vaddr_range = r1u64(eval.offset, eval.offset + type_byte_size);
         if(dim_1u64(vaddr_range) == type_byte_size)
         {
-          String8 data = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, vaddr_range);
+          CTRL_ProcessMemorySlice slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, vaddr_range);
+          String8 data = slice.data;
           MemoryZeroArray(eval.imm_u128);
           MemoryCopy(eval.imm_u128, data.str, Min(data.size, sizeof(U64)*2));
           eval.mode = EVAL_EvalMode_Value;
@@ -4328,14 +4332,16 @@ df_dynamically_typed_eval_from_eval(TG_Graph *graph, RADDBG_Parsed *rdbg, DF_Ctr
       {
         U64 ptr_vaddr = eval.offset;
         U64 addr_size = bit_size_from_arch(arch)/8;
-        String8 ptr_value_memory = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle,
+        CTRL_ProcessMemorySlice ptr_value_slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle,
                                                                                                   r1u64(ptr_vaddr, ptr_vaddr+addr_size));
+        String8 ptr_value_memory = ptr_value_slice.data;
         if(ptr_value_memory.size >= addr_size)
         {
           U64 class_base_vaddr = 0;
           MemoryCopy(&class_base_vaddr, ptr_value_memory.str, addr_size);
-          String8 vtable_base_ptr_memory = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle,
+          CTRL_ProcessMemorySlice vtable_base_ptr_slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle,
                                                                                                           r1u64(class_base_vaddr, class_base_vaddr+addr_size));
+          String8 vtable_base_ptr_memory = vtable_base_ptr_slice.data;
           if(vtable_base_ptr_memory.size >= addr_size)
           {
             U64 vtable_vaddr = 0;
@@ -4872,7 +4878,7 @@ df_commit_eval_value(TG_Graph *graph, RADDBG_Parsed *rdbg, DF_CtrlCtx *ctrl_ctx,
       default:{}break;
       case EVAL_EvalMode_Addr:
       {
-        ctrl_process_write_data(process->ctrl_machine_id, process->ctrl_handle, dst_eval.offset, commit_data);
+        ctrl_process_write(process->ctrl_machine_id, process->ctrl_handle, r1u64(dst_eval.offset, dst_eval.offset+commit_data.size), commit_data.str);
       }break;
       case EVAL_EvalMode_Reg:
       {
@@ -6440,6 +6446,23 @@ df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt)
             DF_CmdParams params = df_cmd_params_zero();
             df_cmd_list_push(arena, cmds, &params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_Error));
           }
+          
+          // rjf: kill all entities which are marked to die on stop
+          {
+            DF_Entity *request = df_entity_from_id(event->msg_id);
+            if(df_entity_is_nil(request))
+            {
+              for(DF_Entity *entity = df_entity_root();
+                  !df_entity_is_nil(entity);
+                  entity = df_entity_rec_df_pre(entity, df_entity_root()).next)
+              {
+                if(entity->flags & DF_EntityFlag_DiesOnRunStop)
+                {
+                  df_entity_mark_for_deletion(entity);
+                }
+              }
+            }
+          }
         }break;
         
         //- rjf: entity creation/deletion
@@ -7036,7 +7059,6 @@ df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt)
         case DF_CoreCmdKind_StepIntoLine:
         case DF_CoreCmdKind_StepOverLine:
         case DF_CoreCmdKind_StepOut:
-        case DF_CoreCmdKind_RunToAddress:
         {
           DF_Entity *thread = df_entity_from_handle(params.entity);
           if(df_ctrl_targets_running())
@@ -7088,11 +7110,6 @@ df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt)
                   good = 0;
                 }
               }break;
-              case DF_CoreCmdKind_RunToAddress:
-              {
-                CTRL_Trap trap = {CTRL_TrapFlag_EndStepping|CTRL_TrapFlag_IgnoreStackPointerCheck, params.vaddr};
-                ctrl_trap_list_push(scratch.arena, &traps, &trap);
-              }break;
             }
             if(good && traps.count != 0)
             {
@@ -7127,6 +7144,30 @@ df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt)
         }break;
         
         //- rjf: high-level composite target control operations
+        case DF_CoreCmdKind_RunToLine:
+        {
+          DF_Entity *file = df_entity_from_handle(params.entity);
+          TxtPt point = params.text_point;
+          if(file->kind == DF_EntityKind_File)
+          {
+            DF_Entity *bp = df_entity_alloc(0, file, DF_EntityKind_Breakpoint);
+            bp->flags |= DF_EntityFlag_DiesOnRunStop;
+            df_entity_equip_b32(bp, 1);
+            df_entity_equip_txt_pt(bp, point);
+            df_entity_equip_cfg_src(bp, DF_CfgSrc_Transient);
+            DF_CmdParams p = df_cmd_params_zero();
+            df_cmd_list_push(arena, cmds, &p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_Run));
+          }
+        }break;
+        case DF_CoreCmdKind_RunToAddress:
+        {
+          DF_Entity *bp = df_entity_alloc(0, df_entity_root(), DF_EntityKind_Breakpoint);
+          bp->flags |= DF_EntityFlag_DiesOnRunStop;
+          df_entity_equip_vaddr(bp, params.vaddr);
+          df_entity_equip_cfg_src(bp, DF_CfgSrc_Transient);
+          DF_CmdParams p = df_cmd_params_zero();
+          df_cmd_list_push(arena, cmds, &p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_Run));
+        }break;
         case DF_CoreCmdKind_Run:
         {
           DF_CmdParams params = df_cmd_params_zero();

src/df/core/df_core.h

@@ -463,21 +463,22 @@ enum
   DF_EntityFlag_HasRng1U64        = (1<<5),
   DF_EntityFlag_HasColor          = (1<<6),
   DF_EntityFlag_DiesWithTime      = (1<<7),
+  DF_EntityFlag_DiesOnRunStop     = (1<<8),
   
   //- rjf: ctrl entity equipment
-  DF_EntityFlag_HasCtrlMachineID  = (1<<8),
+  DF_EntityFlag_HasCtrlMachineID  = (1<<9),
-  DF_EntityFlag_HasCtrlHandle     = (1<<9),
+  DF_EntityFlag_HasCtrlHandle     = (1<<10),
-  DF_EntityFlag_HasArch           = (1<<10),
+  DF_EntityFlag_HasArch           = (1<<11),
-  DF_EntityFlag_HasCtrlID         = (1<<11),
+  DF_EntityFlag_HasCtrlID         = (1<<12),
-  DF_EntityFlag_HasStackBase      = (1<<12),
+  DF_EntityFlag_HasStackBase      = (1<<13),
-  DF_EntityFlag_HasTLSRoot        = (1<<13),
+  DF_EntityFlag_HasTLSRoot        = (1<<14),
-  DF_EntityFlag_HasVAddrRng       = (1<<14),
+  DF_EntityFlag_HasVAddrRng       = (1<<15),
-  DF_EntityFlag_HasVAddr          = (1<<15),
+  DF_EntityFlag_HasVAddr          = (1<<16),
   
   //- rjf: file properties
-  DF_EntityFlag_IsFolder          = (1<<16),
+  DF_EntityFlag_IsFolder          = (1<<17),
-  DF_EntityFlag_IsMissing         = (1<<17),
+  DF_EntityFlag_IsMissing         = (1<<18),
-  DF_EntityFlag_Output            = (1<<18), // NOTE(rjf): might be missing, but written by us
+  DF_EntityFlag_Output            = (1<<19), // NOTE(rjf): might be missing, but written by us
   
   //- rjf: deletion
   DF_EntityFlag_MarkedForDeletion = (1<<31),

src/df/core/df_core.mdesk

@@ -10,6 +10,7 @@ DF_CfgSrcTable:
   {"user"            User             LoadUser       WriteUserData       ApplyUserData    }
   {"profile"         Profile          LoadProfile    WriteProfileData    ApplyProfileData }
   {"command_line"    CommandLine      Null           Null                Null             }
+  {"transient"       Transient        Null           Null                Null             }
 }
 
 ////////////////////////////////
@@ -128,12 +129,13 @@ DF_CoreCmdTable://               |            |                  |
   {StepIntoLine                   0            Null               Nil                0  0  0  0  0  0                                                           StepInto              "step_into_line"              "Step Into (Line)"                            "Performs a step that goes into calls, at the source code line level."                                             "step,thread"                    }
   {StepOverLine                   0            Null               Nil                0  0  0  0  0  0                                                           StepOver              "step_over_line"              "Step Over (Line)"                            "Performs a step that skips calls, at the source code line level."                                                 "step,thread"                    }
   {StepOut                        0            Null               Nil                0  0  0  0  0  0                                                           StepOut               "step_out"                    "Step Out"                                    "Runs to the end of the current function and exits it."                                                            ""                               }
-  {RunToAddress                   0            VirtualAddr        Nil                0  0  0  0  1  1                                   PlayStepForward       "run_to_address"              "Run To Address"                              "Runs the selected thread to the specified address."                                                               ""                               }
   {Halt                           0            Null               Nil                0  0  0  0  0  0                                                           Pause                 "halt"                        "Halt"                                        "Halts all running processes."                                                                                     "pause"                          }
   {SoftHaltRefresh                0            Null               Nil                0  0  0  0  0  0                                                           Refresh               "soft_halt_refresh"           "Soft Halt Refresh"                           "Interrupts all running processes to collect data, and then resumes them."                                         ""                               }
   {SetThreadIP                    1            VirtualAddr        Nil                0  0  0  0  1  1                                                           Null                  "set_thread_ip"               "Set Thread IP"                               "Sets the passed thread's instruction pointer at the passed address."                                              ""                               }
   
   //- rjf: high-level composite target control operations
+  {RunToLine                      1            Null               Nil                0  0  0  0  0  0                                                           Play                  "run_to_line"                 "Run To Line"                                 "Runs until a particular source line is hit."                                                                      ""                               }
+  {RunToAddress                   0            VirtualAddr        Nil                0  0  0  0  1  1                                                           PlayStepForward       "run_to_address"              "Run To Address"                              "Runs until a particular address is hit."                                                                          ""                               }
   {Run                            0            Null               Nil                0  0  0  0  0  0                                                           Play                  "run"                         "Run"                                         "Runs all targets after starting them if they have not been started yet."                                          "play"                           }
   {Restart                        0            Null               Nil                0  0  0  0  0  0                                                           Redo                  "restart"                     "Restart"                                     "Kills all running processes, then restarts the targets which were used to launch all current processes (if any)." "restart,retry"                  }
   {StepInto                       0            Null               Nil                0  0  0  0  0  0                                                           StepInto              "step_into"                   "Step Into"                                   "Steps once, possibly into function calls, for either line or instructions."                                       ""                               }

src/df/core/generated/df_core.meta.c

@@ -20,10 +20,11 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
 { str8_lit_comp("step_into_line"), str8_lit_comp("Performs a step that goes into calls, at the source code line level."), str8_lit_comp("step,thread"), str8_lit_comp("Step Into (Line)"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_StepInto},
 { str8_lit_comp("step_over_line"), str8_lit_comp("Performs a step that skips calls, at the source code line level."), str8_lit_comp("step,thread"), str8_lit_comp("Step Over (Line)"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_StepOver},
 { str8_lit_comp("step_out"), str8_lit_comp("Runs to the end of the current function and exits it."), str8_lit_comp(""), str8_lit_comp("Step Out"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_StepOut},
-{ str8_lit_comp("run_to_address"), str8_lit_comp("Runs the selected thread to the specified address."), str8_lit_comp(""), str8_lit_comp("Run To Address"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_VirtualAddr, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*1)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_PlayStepForward},
 { str8_lit_comp("halt"), str8_lit_comp("Halts all running processes."), str8_lit_comp("pause"), str8_lit_comp("Halt"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Pause},
 { str8_lit_comp("soft_halt_refresh"), str8_lit_comp("Interrupts all running processes to collect data, and then resumes them."), str8_lit_comp(""), str8_lit_comp("Soft Halt Refresh"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Refresh},
 { str8_lit_comp("set_thread_ip"), str8_lit_comp("Sets the passed thread's instruction pointer at the passed address."), str8_lit_comp(""), str8_lit_comp("Set Thread IP"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_VirtualAddr, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*1)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Null},
+{ str8_lit_comp("run_to_line"), str8_lit_comp("Runs until a particular source line is hit."), str8_lit_comp(""), str8_lit_comp("Run To Line"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Play},
+{ str8_lit_comp("run_to_address"), str8_lit_comp("Runs until a particular address is hit."), str8_lit_comp(""), str8_lit_comp("Run To Address"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_VirtualAddr, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*1)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_PlayStepForward},
 { str8_lit_comp("run"), str8_lit_comp("Runs all targets after starting them if they have not been started yet."), str8_lit_comp("play"), str8_lit_comp("Run"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Play},
 { str8_lit_comp("restart"), str8_lit_comp("Kills all running processes, then restarts the targets which were used to launch all current processes (if any)."), str8_lit_comp("restart,retry"), str8_lit_comp("Restart"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Redo},
 { str8_lit_comp("step_into"), str8_lit_comp("Steps once, possibly into function calls, for either line or instructions."), str8_lit_comp(""), str8_lit_comp("Step Into"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_StepInto},

src/df/core/generated/df_core.meta.h

@@ -11,6 +11,7 @@ typedef enum DF_CfgSrc
 DF_CfgSrc_User,
 DF_CfgSrc_Profile,
 DF_CfgSrc_CommandLine,
+DF_CfgSrc_Transient,
 DF_CfgSrc_COUNT
 } DF_CfgSrc;
 
@@ -70,10 +71,11 @@ DF_CoreCmdKind_StepOverInst,
 DF_CoreCmdKind_StepIntoLine,
 DF_CoreCmdKind_StepOverLine,
 DF_CoreCmdKind_StepOut,
-DF_CoreCmdKind_RunToAddress,
 DF_CoreCmdKind_Halt,
 DF_CoreCmdKind_SoftHaltRefresh,
 DF_CoreCmdKind_SetThreadIP,
+DF_CoreCmdKind_RunToLine,
+DF_CoreCmdKind_RunToAddress,
 DF_CoreCmdKind_Run,
 DF_CoreCmdKind_Restart,
 DF_CoreCmdKind_StepInto,
@@ -1680,6 +1682,7 @@ String8 df_g_cfg_src_string_table[] =
 str8_lit_comp("user"),
 str8_lit_comp("profile"),
 str8_lit_comp("command_line"),
+str8_lit_comp("transient"),
 };
 
 DF_CoreCmdKind df_g_cfg_src_load_cmd_kind_table[] =
@@ -1687,6 +1690,7 @@ DF_CoreCmdKind df_g_cfg_src_load_cmd_kind_table[] =
 DF_CoreCmdKind_LoadUser,
 DF_CoreCmdKind_LoadProfile,
 DF_CoreCmdKind_Null,
+DF_CoreCmdKind_Null,
 };
 
 DF_CoreCmdKind df_g_cfg_src_write_cmd_kind_table[] =
@@ -1694,6 +1698,7 @@ DF_CoreCmdKind df_g_cfg_src_write_cmd_kind_table[] =
 DF_CoreCmdKind_WriteUserData,
 DF_CoreCmdKind_WriteProfileData,
 DF_CoreCmdKind_Null,
+DF_CoreCmdKind_Null,
 };
 
 DF_CoreCmdKind df_g_cfg_src_apply_cmd_kind_table[] =
@@ -1701,6 +1706,7 @@ DF_CoreCmdKind df_g_cfg_src_apply_cmd_kind_table[] =
 DF_CoreCmdKind_ApplyUserData,
 DF_CoreCmdKind_ApplyProfileData,
 DF_CoreCmdKind_Null,
+DF_CoreCmdKind_Null,
 };
 
 String8 df_g_icon_kind_text_table[] =

src/df/gfx/df_gfx.c

@@ -3045,6 +3045,7 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
           }
           ui_labelf("Target Hz: %.2f", 1.f/df_dt());
           ui_labelf("Ctrl Run Index: %I64u", ctrl_run_idx());
+          ui_labelf("Ctrl Mem Gen Index: %I64u", ctrl_memgen_idx());
           ui_labelf("Window %p", window);
           ui_set_next_pref_width(ui_children_sum(1));
           ui_set_next_pref_height(ui_children_sum(1));
@@ -6786,7 +6787,8 @@ df_single_line_eval_value_strings_from_eval(Arena *arena, DF_EvalVizStringFlags
         if(!has_array && direct_type_is_string && (flags & DF_EvalVizStringFlag_ReadOnlyDisplayRules) && eval.mode == EVAL_EvalMode_Addr)
         {
           U64 string_memory_addr = value_eval.imm_u64;
-          String8 text = ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(arena, process->ctrl_machine_id, process->ctrl_handle, string_memory_addr, 256, max_U64);
+          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, max_U64);
+          String8 text = text_slice.data;
           space_taken += f_dim_from_tag_size_string(font, font_size, text).x;
           space_taken += 2*f_dim_from_tag_size_string(font, font_size, str8_lit("\"")).x;
           str8_list_push(arena, &list, str8_lit("\""));
@@ -6858,7 +6860,8 @@ df_single_line_eval_value_strings_from_eval(Arena *arena, DF_EvalVizStringFlags
           special_case = 1;
           DF_Entity *thread = df_entity_from_handle(ctrl_ctx->thread);
           DF_Entity *process = df_entity_ancestor_from_kind(thread, DF_EntityKind_Process);
-          String8 text = ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(arena, process->ctrl_machine_id, process->ctrl_handle, eval.offset, 256, max_U64);
+          CTRL_ProcessMemorySlice text_slice = ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(arena, process->ctrl_machine_id, process->ctrl_handle, eval.offset, 256, max_U64);
+          String8 text = text_slice.data;
           space_taken += f_dim_from_tag_size_string(font, font_size, text).x;
           space_taken += 2*f_dim_from_tag_size_string(font, font_size, str8_lit("\"")).x;
           str8_list_push(arena, &list, str8_lit("\""));
@@ -9009,6 +9012,9 @@ df_code_slice(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_
   ProfBeginFunction();
   Temp scratch = scratch_begin(0, 0);
   DF_Entity *selected_thread = df_entity_from_handle(ctrl_ctx->thread);
+  DF_Entity *selected_thread_process = df_entity_ancestor_from_kind(selected_thread, DF_EntityKind_Process);
+  U64 selected_thread_rip_unwind_vaddr = df_query_cached_rip_from_thread_unwind(selected_thread, ctrl_ctx->unwind_count);
+  DF_Entity *selected_thread_module = df_module_from_process_vaddr(selected_thread_process, selected_thread_rip_unwind_vaddr);
   CTRL_Event stop_event = df_ctrl_last_stop_event();
   DF_Entity *stopper_thread = df_entity_from_ctrl_handle(stop_event.machine_id, stop_event.entity);
   B32 is_focused = ui_is_focus_active();
@@ -9847,7 +9853,7 @@ df_code_slice(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_
           {
             has_line_info = (src2dasm_list->first->v.remap_line == line_num);
             line_info_line_num = line_num;
-            line_info_t = src2dasm_list->first->v.binary->alive_t;
+            line_info_t = selected_thread_module->alive_t;
           }
           if(dasm2src_list->first != 0)
           {
@@ -9866,7 +9872,7 @@ df_code_slice(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_
               DF_Entity *binary = dasm2src_info->binary;
               has_line_info = 1;
               line_info_line_num = dasm2src_info->pt.line;
-              line_info_t = binary->alive_t;
+              line_info_t = selected_thread_module->alive_t;
             }
           }
           if(has_line_info)
@@ -9969,7 +9975,7 @@ df_code_slice(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_
                       {
                         mapped_special = 1;
                         new_color_kind = DF_ThemeColor_CodeFunction;
-                        mix_t = binary->alive_t;
+                        mix_t = selected_thread_module->alive_t;
                       }
                     }
                     if(!mapped_special)
@@ -9979,7 +9985,7 @@ df_code_slice(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_
                       {
                         mapped_special = 1;
                         new_color_kind = DF_ThemeColor_CodeType;
-                        mix_t = binary->alive_t;
+                        mix_t = selected_thread_module->alive_t;
                       }
                     }
                     if(!mapped_special)
@@ -9989,7 +9995,7 @@ df_code_slice(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_
                       {
                         mapped_special = 1;
                         new_color_kind = DF_ThemeColor_CodeLocal;
-                        mix_t = binary->alive_t;
+                        mix_t = selected_thread_module->alive_t;
                       }
                     }
                     break;

src/df/gfx/df_view_rule_hooks.c

@@ -30,7 +30,8 @@ df_view_rule_hooks__rgba_from_eval(DF_Eval eval, TG_Graph *graph, RADDBG_Parsed
       U64 array_total_size = tg_byte_size_from_graph_raddbg_key(graph, raddbg, type_key);
       U64 array_total_size_capped = ClampTop(array_total_size, 64);
       Rng1U64 array_memory_vaddr_rng = r1u64(eval.offset, eval.offset + array_total_size_capped);
-      String8 array_memory = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, array_memory_vaddr_rng);
+      CTRL_ProcessMemorySlice array_slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, array_memory_vaddr_rng);
+      String8 array_memory = array_slice.data;
       TG_Key element_type_key = tg_unwrapped_direct_from_graph_raddbg_key(graph, raddbg, type_key);
       TG_Kind element_type_kind = tg_kind_from_key(element_type_key);
       U64 element_type_size = tg_byte_size_from_graph_raddbg_key(graph, raddbg, element_type_key);
@@ -66,7 +67,8 @@ df_view_rule_hooks__rgba_from_eval(DF_Eval eval, TG_Graph *graph, RADDBG_Parsed
       U64 struct_total_size = tg_byte_size_from_graph_raddbg_key(graph, raddbg, type_key);
       U64 struct_total_size_capped = ClampTop(struct_total_size, 64);
       Rng1U64 struct_memory_vaddr_rng = r1u64(eval.offset, eval.offset + struct_total_size_capped);
-      String8 struct_memory = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, struct_memory_vaddr_rng);
+      CTRL_ProcessMemorySlice struct_slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, struct_memory_vaddr_rng);
+      String8 struct_memory = struct_slice.data;
       TG_Type *type = tg_type_from_graph_raddbg_key(scratch.arena, graph, raddbg, type_key);
       for(U64 element_idx = 0, member_idx = 0;
           element_idx < 4 && member_idx < type->count;

src/df/gfx/df_views.c

@@ -976,6 +976,27 @@ df_eval_watch_view_build(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_EvalW
         B32 row_expanded = df_expand_key_is_set(&eval_view->expand_tree_table, row->key);
         DF_EvalHistoryCacheNode *history_cache_node = df_eval_history_cache_node_from_key(eval_view, row->key);
         
+        //- rjf: determine if row's data is fresh
+        B32 row_is_fresh = 0;
+        switch(row->eval.mode)
+        {
+          default:{}break;
+          case EVAL_EvalMode_Addr:
+          {
+            U64 size = tg_byte_size_from_graph_raddbg_key(parse_ctx.type_graph, parse_ctx.rdbg, row->eval.type_key);
+            Rng1U64 vaddr_rng = r1u64(row->eval.offset, row->eval.offset+size);
+            CTRL_ProcessMemorySlice slice = ctrl_query_cached_data_from_process_vaddr_range(scratch.arena, process->ctrl_machine_id, process->ctrl_handle, vaddr_rng);
+            for(U64 idx = 0; idx < (size+63)/64; idx += 1)
+            {
+              if(slice.byte_changed_flags[idx] != 0)
+              {
+                row_is_fresh = 1;
+                break;
+              }
+            }
+          }break;
+        }
+        
         //- rjf: store root edit commit info
         if(row_selected)
         {
@@ -1032,7 +1053,11 @@ df_eval_watch_view_build(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_EvalW
         //- rjf: build normal row
         if(!(row->flags & DF_EvalVizRowFlag_Canvas))
         {
-          ui_set_next_flags(disabled_flags);
+          ui_set_next_flags(disabled_flags|(row_is_fresh*UI_BoxFlag_DrawOverlay));
+          if(row_is_fresh)
+          {
+            ui_set_next_overlay_color(mul_4f32(df_rgba_from_theme_color(DF_ThemeColor_Highlight0), v4f32(1, 1, 1, 0.2f)));
+          }
           UI_NamedTableVectorF("row_%I64x", row_hash)
           {
             //- rjf: expression
@@ -4621,30 +4646,10 @@ DF_VIEW_CMD_FUNCTION_DEF(Code)
       }break;
       case DF_CoreCmdKind_RunToCursor:
       {
-        Temp scratch = scratch_begin(0, 0);
+        DF_CmdParams params = df_cmd_params_from_view(ws, panel, view);
-        DF_Entity *thread = df_entity_from_handle(cmd->params.entity);
+        params.entity = view->entity;
-        S64 line_num = tv->cursor.line;
+        params.text_point = tv->cursor;
-        DF_TextLineSrc2DasmInfoListArray src2dasm = df_text_line_src2dasm_info_list_array_from_src_line_range(scratch.arena, entity, r1s64(line_num, line_num));
+        df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_RunToLine));
-        if(!df_entity_is_nil(thread) && src2dasm.count != 0)
-        {
-          DF_TextLineSrc2DasmInfoList *src2dasm_list = &src2dasm.v[0];
-          if(src2dasm_list->first != 0)
-          {
-            Rng1U64 voff_rng = src2dasm_list->first->v.voff_range;
-            DF_Entity *binary = src2dasm_list->first->v.binary;
-            DF_EntityList possible_modules = df_modules_from_binary_file(scratch.arena, binary);
-            DF_Entity *thread_dst_module = df_module_from_thread_candidates(thread, &possible_modules);
-            U64 thread_dst_voff = voff_rng.min;
-            if(!df_entity_is_nil(thread_dst_module) && thread_dst_voff != 0)
-            {
-              DF_CmdParams params = df_cmd_params_from_window(ws);
-              params.vaddr = df_vaddr_from_voff(thread_dst_module, thread_dst_voff);
-              df_cmd_params_mark_slot(&params, DF_CmdParamSlot_VirtualAddr);
-              df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_RunToAddress));
-            }
-          }
-        }
-        scratch_end(scratch);
       }break;
       case DF_CoreCmdKind_SetNextStatement:
       {
@@ -5310,29 +5315,10 @@ DF_VIEW_UI_FUNCTION_DEF(Code)
     //- rjf: run-to-line
     if(sig.run_to_line_num != 0 && contains_1s64(visible_line_num_range, sig.run_to_line_num))
     {
-      U64 line_idx = (sig.run_to_line_num-visible_line_num_range.min);
+      DF_CmdParams params = df_cmd_params_from_view(ws, panel, view);
-      DF_TextLineSrc2DasmInfoList *src2dasm_list = &code_slice_params.line_src2dasm[line_idx];
+      params.entity = df_handle_from_entity(entity);
-      if(src2dasm_list->first != 0)
+      params.text_point = txt_pt(sig.run_to_line_num, 1);
-      {
+      df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_RunToLine));
-        Rng1U64 voff_rng = src2dasm_list->first->v.voff_range;
-        DF_Entity *binary = src2dasm_list->first->v.binary;
-        DF_EntityList possible_modules = df_modules_from_binary_file(scratch.arena, binary);
-        DF_Entity *thread = df_entity_from_handle(ctrl_ctx.thread);
-        DF_Entity *thread_dst_module = df_module_from_thread_candidates(thread, &possible_modules);
-        DF_Entity *module = thread_dst_module;
-        if(df_entity_is_nil(module))
-        {
-          module = df_first_entity_from_list(&possible_modules);
-        }
-        U64 voff = voff_rng.min;
-        if(!df_entity_is_nil(module) && voff != 0)
-        {
-          DF_CmdParams params = df_cmd_params_from_window(ws);
-          params.vaddr = df_vaddr_from_voff(module, voff);
-          df_cmd_params_mark_slot(&params, DF_CmdParamSlot_VirtualAddr);
-          df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_RunToAddress));
-        }
-      }
     }
     
     //- rjf: go to disasm

src/eval/eval_parser.c

@@ -834,8 +834,8 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8
           TG_Key                         type_key = zero_struct;
           String8                        local_lookup_string = token_string;
           
-          //- rjf: form namespaceify fallback
+          //- rjf: form namespaceified fallback versions of this lookup string
-          String8 namespaceified_token_string = token_string;
+          String8List namespaceified_token_strings = {0};
           if(ctx->rdbg->procedures != 0 && ctx->rdbg->scopes != 0 && ctx->rdbg->scope_vmap != 0)
           {
             U64 scope_idx = raddbg_vmap_idx_from_voff(ctx->rdbg->scope_vmap, ctx->rdbg->scope_vmap_count, ctx->ip_voff);
@@ -844,23 +844,22 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8
             RADDBG_Procedure *procedure = &ctx->rdbg->procedures[proc_idx];
             U64 name_size = 0;
             U8 *name_ptr = raddbg_string_from_idx(ctx->rdbg, procedure->name_string_idx, &name_size);
-            String8 name = str8(name_ptr, name_size);
+            String8 containing_procedure_name = str8(name_ptr, name_size);
-            U64 past_scope_resolution_pos = 0;
+            U64 last_past_scope_resolution_pos = 0;
             for(;;)
             {
-              U64 past_next_dbl_colon_pos = str8_find_needle(name, past_scope_resolution_pos, str8_lit("::"), 0)+2;
+              U64 past_next_dbl_colon_pos = str8_find_needle(containing_procedure_name, last_past_scope_resolution_pos, str8_lit("::"), 0)+2;
-              U64 past_next_dot_pos = str8_find_needle(name, past_scope_resolution_pos, str8_lit("."), 0)+1;
+              U64 past_next_dot_pos = str8_find_needle(containing_procedure_name, last_past_scope_resolution_pos, str8_lit("."), 0)+1;
               U64 past_next_scope_resolution_pos = Min(past_next_dbl_colon_pos, past_next_dot_pos);
-              if(past_next_scope_resolution_pos < name.size)
+              if(past_next_scope_resolution_pos >= containing_procedure_name.size)
-              {
-                past_scope_resolution_pos = past_next_scope_resolution_pos;
-              }
-              else
               {
                 break;
               }
+              String8 new_namespace_prefix_possibility = str8_prefix(containing_procedure_name, past_next_scope_resolution_pos);
+              String8 namespaceified_token_string = push_str8f(scratch.arena, "%S%S", new_namespace_prefix_possibility, token_string);
+              str8_list_push_front(scratch.arena, &namespaceified_token_strings, namespaceified_token_string);
+              last_past_scope_resolution_pos = past_next_scope_resolution_pos;
             }
-            namespaceified_token_string = push_str8f(scratch.arena, "%S%S", str8_prefix(name, past_scope_resolution_pos), token_string);
           }
           
           //- rjf: try members
@@ -974,9 +973,11 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8
               RADDBG_NameMapNode *node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, token_string.str, token_string.size);
               U32 matches_count = 0;
               U32 *matches = raddbg_matches_from_map_node(ctx->rdbg, node, &matches_count);
-              if(matches_count == 0)
+              for(String8Node *n = namespaceified_token_strings.first;
+                  n != 0 && matches_count == 0;
+                  n = n->next)
               {
-                node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, namespaceified_token_string.str, namespaceified_token_string.size);
+                node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, n->string.str, n->string.size);
                 matches_count = 0;
                 matches = raddbg_matches_from_map_node(ctx->rdbg, node, &matches_count);
               }
@@ -1014,9 +1015,11 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8
               RADDBG_NameMapNode *node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, token_string.str, token_string.size);
               U32 matches_count = 0;
               U32 *matches = raddbg_matches_from_map_node(ctx->rdbg, node, &matches_count);
-              if(matches_count == 0)
+              for(String8Node *n = namespaceified_token_strings.first;
+                  n != 0 && matches_count == 0;
+                  n = n->next)
               {
-                node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, namespaceified_token_string.str, namespaceified_token_string.size);
+                node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, n->string.str, n->string.size);
                 matches_count = 0;
                 matches = raddbg_matches_from_map_node(ctx->rdbg, node, &matches_count);
               }
@@ -1050,9 +1053,11 @@ eval_parse_expr_from_text_tokens__prec(Arena *arena, EVAL_ParseCtx *ctx, String8
               RADDBG_NameMapNode *node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, token_string.str, token_string.size);
               U32 matches_count = 0;
               U32 *matches = raddbg_matches_from_map_node(ctx->rdbg, node, &matches_count);
-              if(matches_count == 0)
+              for(String8Node *n = namespaceified_token_strings.first;
+                  n != 0 && matches_count == 0;
+                  n = n->next)
               {
-                node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, namespaceified_token_string.str, namespaceified_token_string.size);
+                node = raddbg_name_map_lookup(ctx->rdbg, &parsed_name_map, n->string.str, n->string.size);
                 matches_count = 0;
                 matches = raddbg_matches_from_map_node(ctx->rdbg, node, &matches_count);
               }

src/hash_store/hash_store.c

@@ -122,7 +122,7 @@ hs_submit_data(U128 key, Arena **data_arena, String8 data)
   }
   
   //- rjf: commit this hash to key cache
-  U128 key_old_hash = {0};
+  U128 key_expired_hash = {0};
   OS_MutexScopeW(key_stripe->rw_mutex)
   {
     HS_KeyNode *key_node = 0;
@@ -142,15 +142,19 @@ hs_submit_data(U128 key, Arena **data_arena, String8 data)
     }
     if(key_node)
     {
-      key_old_hash = key_node->hash;
+      if(key_node->hash_history_gen >= ArrayCount(key_node->hash_history))
-      key_node->hash = hash;
+      {
+        key_expired_hash = key_node->hash_history[key_node->hash_history_gen%ArrayCount(key_node->hash_history)];
+      }
+      key_node->hash_history[key_node->hash_history_gen%ArrayCount(key_node->hash_history)] = hash;
+      key_node->hash_history_gen += 1;
     }
   }
   
-  //- rjf: if this key was correllated with an old hash, dec key ref count of old hash
+  //- rjf: if this key's history cache was full, dec key ref count of oldest hash
-  if(!u128_match(key_old_hash, u128_zero()))
+  if(!u128_match(key_expired_hash, u128_zero()))
   {
-    U64 old_hash_slot_idx = key_old_hash.u64[1]%hs_shared->slots_count;
+    U64 old_hash_slot_idx = key_expired_hash.u64[1]%hs_shared->slots_count;
     U64 old_hash_stripe_idx = old_hash_slot_idx%hs_shared->stripes_count;
     HS_Slot *old_hash_slot = &hs_shared->slots[old_hash_slot_idx];
     HS_Stripe *old_hash_stripe = &hs_shared->stripes[old_hash_stripe_idx];
@@ -158,7 +162,7 @@ hs_submit_data(U128 key, Arena **data_arena, String8 data)
     {
       for(HS_Node *n = old_hash_slot->first; n != 0; n = n->next)
       {
-        if(u128_match(n->hash, key_old_hash))
+        if(u128_match(n->hash, key_expired_hash))
         {
           ins_atomic_u64_dec_eval(&n->key_ref_count);
           break;
@@ -239,7 +243,7 @@ hs_scope_touch_node__stripe_r_guarded(HS_Scope *scope, HS_Node *node)
 //~ rjf: Cache Lookup
 
 internal U128
-hs_hash_from_key(U128 key)
+hs_hash_from_key(U128 key, U64 rewind_count)
 {
   U128 result = {0};
   U64 key_slot_idx = key.u64[1]%hs_shared->key_slots_count;
@@ -250,9 +254,9 @@ hs_hash_from_key(U128 key)
   {
     for(HS_KeyNode *n = key_slot->first; n != 0; n = n->next)
     {
-      if(u128_match(n->key, key))
+      if(u128_match(n->key, key) && n->hash_history_gen > 0 && n->hash_history_gen-1 >= rewind_count)
       {
-        result = n->hash;
+        result = n->hash_history[(n->hash_history_gen-1-rewind_count)%ArrayCount(n->hash_history)];
         break;
       }
     }

src/hash_store/hash_store.h

@@ -12,7 +12,8 @@ struct HS_KeyNode
 {
   HS_KeyNode *next;
   U128 key;
-  U128 hash;
+  U128 hash_history[2];
+  U64 hash_history_gen;
 };
 
 typedef struct HS_KeySlot HS_KeySlot;
@@ -138,7 +139,7 @@ internal void hs_scope_touch_node__stripe_r_guarded(HS_Scope *scope, HS_Node *no
 ////////////////////////////////
 //~ rjf: Cache Lookups
 
-internal U128 hs_hash_from_key(U128 key);
+internal U128 hs_hash_from_key(U128 key, U64 rewind_count);
 internal String8 hs_data_from_hash(HS_Scope *scope, U128 hash);
 
 ////////////////////////////////

src/os/gfx/win32/os_gfx_win32.c

@@ -493,6 +493,10 @@ w32_wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
         if(character >= 32 && character != 127)
         {
           OS_Event *event = w32_push_event(OS_EventKind_Text, window);
+          if(lParam & bit29)
+          {
+            event->flags |= OS_EventFlag_Alt;
+          }
           event->character = character;
         }
       }break;

src/raddbg/raddbg.c

@@ -167,6 +167,10 @@ update_and_render(OS_Handle repaint_window_handle, void *user_data)
         df_push_cmd__root(&params, spec);
         df_gfx_request_frame();
         os_eat_event(&events, event);
+        if(event->flags & OS_EventFlag_Alt)
+        {
+          window->menu_bar_focus_press_started = 0;
+        }
       }
     }
   }
@@ -182,7 +186,7 @@ update_and_render(OS_Handle repaint_window_handle, void *user_data)
         continue;
       }
       B32 take = 0;
-      if(event->kind == OS_EventKind_Press && event->key == OS_Key_Alt && event->is_repeat == 0)
+      if(event->kind == OS_EventKind_Press && event->key == OS_Key_Alt && event->flags == 0 && event->is_repeat == 0)
       {
         take = 1;
         df_gfx_request_frame();
@@ -190,19 +194,19 @@ update_and_render(OS_Handle repaint_window_handle, void *user_data)
         ws->menu_bar_key_held = 1;
         ws->menu_bar_focus_press_started = 1;
       }
-      if(event->kind == OS_EventKind_Release && event->key == OS_Key_Alt && event->is_repeat == 0)
+      if(event->kind == OS_EventKind_Release && event->key == OS_Key_Alt && event->flags == 0 && event->is_repeat == 0)
       {
         take = 1;
         df_gfx_request_frame();
         ws->menu_bar_key_held = 0;
       }
-      if(ws->menu_bar_focused && event->kind == OS_EventKind_Press && event->key == OS_Key_Alt && event->is_repeat == 0)
+      if(ws->menu_bar_focused && event->kind == OS_EventKind_Press && event->key == OS_Key_Alt && event->flags == 0 && event->is_repeat == 0)
       {
         take = 1;
         df_gfx_request_frame();
         ws->menu_bar_focused = 0;
       }
-      else if(ws->menu_bar_focus_press_started && !ws->menu_bar_focused && event->kind == OS_EventKind_Release && event->key == OS_Key_Alt && event->is_repeat == 0)
+      else if(ws->menu_bar_focus_press_started && !ws->menu_bar_focused && event->kind == OS_EventKind_Release && event->flags == 0 && event->key == OS_Key_Alt && event->is_repeat == 0)
       {
         take = 1;
         df_gfx_request_frame();

src/raddbg/raddbg.h

@@ -7,6 +7,9 @@
 // [ ] source view -> floating margin/line-nums
 // [ ] theme colors -> more explicit about e.g. opaque backgrounds vs. floating
 //     & scrollbars etc.
+// [ ] need bilinear interpolation on color picker - fine for most UI to not do
+//     do it but it needs to be correct for the color picker, so maybe that
+//     should be a heavier path
 // [ ] drag/drop tab cleanup
 // [ ] target/breakpoint/watch-pin reordering
 // [ ] watch window reordering
@@ -82,8 +85,6 @@
 // [ ] escaping in config files - breakpoint labels etc.
 // [ ] focus changing between query bar & panel content via mouse
 //
-// [ ] ** while typing, "Alt" Windows menu things should not happen
-//
 // [ ] visualize conversion failures
 //
 //  [ ] I was a little confused about what a profile file was. I understood

src/render/d3d11/render_d3d11.cpp

@@ -1300,8 +1300,8 @@ r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes)
 
           U32 uniform_offset[Axis2_COUNT][2] =
           {
-              { 0 * sizeof(R_D3D11_Uniforms_BlurPass) / 16, OffsetOf(R_D3D11_Uniforms_Blur, kernel) / 16 },
+              { 0 * sizeof(R_D3D11_Uniforms_BlurPass) / 16, (U32)OffsetOf(R_D3D11_Uniforms_Blur, kernel) / 16 },
-              { 1 * sizeof(R_D3D11_Uniforms_BlurPass) / 16, OffsetOf(R_D3D11_Uniforms_Blur, kernel) / 16 },
+              { 1 * sizeof(R_D3D11_Uniforms_BlurPass) / 16, (U32)OffsetOf(R_D3D11_Uniforms_Blur, kernel) / 16 },
           };
 
           U32 uniform_count[Axis2_COUNT][2] =

src/scratch/i_hate_c_plus_plus.cpp

@@ -1,20 +1,21 @@
-#include <fstream>
+namespace NS
-
-namespace SomeWeirdNamespace
 {
-  int X = 0;
+  static int X = 123;
-  int Y = 0;
+  static int Y = 456;
-  void Foo(void)
+  namespace SubNS
   {
-    X = 123;
+    static int X = 111;
-    Y = 456;
+    static int Y = 222;
-    int x = 0;
+    int Foo(int x, int y)
+    {
+      int z = x + y + X + Y + NS::X + NS::Y;
+      return z;
+    }
   }
 }
 
-int main()
+int main(void)
 {
-  std::fstream temp;
+  int result = NS::SubNS::Foo(5, 6);
-  SomeWeirdNamespace::Foo();
   return 0;
 }

src/scratch/ryan_scratch.c

@@ -1,17 +1,16 @@
 // Copyright (c) 2024 Epic Games Tools
 // Licensed under the MIT license (https://opensource.org/license/mit/)
 
-int Foo(int x, int y)
-{
-  return x + y;
-}
-
 int main(void)
 {
+  int x = 0;
+  int y = 0;
+  int z = 0;
+  for(;;)
   {
-    int x = 23;
+    x += 1;
-    int y = 45;
+    y += 1;
-    Foo(x, y);
+    z += 1;
   }
   return 0;
 }

src/txti/txti.c

@@ -821,13 +821,15 @@ txti_expr_range_from_line_off_range_string_tokens(U64 off, Rng1U64 line_range, S
           default:{}break;
           case TXTI_TokenKind_Symbol:
           {
+            B32 is_scope_resolution = str8_match(wb_token_string, str8_lit("::"), 0);
             B32 is_dot = str8_match(wb_token_string, str8_lit("."), 0);
             B32 is_arrow = str8_match(wb_token_string, str8_lit("->"), 0);
             B32 is_open_bracket = str8_match(wb_token_string, str8_lit("["), 0);
             B32 is_close_bracket = str8_match(wb_token_string, str8_lit("]"), 0);
             nest -= !!(is_open_bracket);
             nest += !!(is_close_bracket);
-            if(is_dot ||
+            if(is_scope_resolution ||
+               is_dot ||
                is_arrow ||
                is_open_bracket||
                is_close_bracket)

src/ui/ui_core.c

@@ -2443,8 +2443,10 @@ ui_signal_from_box(UI_Box *box)
   B32 keyboard_click = 0;
   if(!disabled && is_focused && box->flags & UI_BoxFlag_KeyboardClickable)
   {
-    if(os_key_press(ui_events(), ui_window(), 0, OS_Key_Return) != 0 ||
+    if(os_key_press(ui_events(), ui_window(), 0, OS_Key_Return) != 0)
-       os_key_press(ui_events(), ui_window(), 0, OS_Key_Space) != 0)
+      // TODO(rjf): need to handle case where this would conflict with typing.
+      // if(os_key_press(ui_events(), ui_window(), 0, OS_Key_Return) != 0 ||
+      // os_key_press(ui_events(), ui_window(), 0, OS_Key_Space) != 0)
     {
       keyboard_click = 1;
       result.clicked = 1;