udt member/enum-val layout & nested baking; use rio to pre-fault all commits

project.4coder

@@ -47,7 +47,7 @@ commands =
 {
   //- rjf: [raddbg]
   // .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
-  .f1 = { .win = "raddbg_stable --ipc kill_all && build radbin 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 release telemetry", .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, },

src/os/core/win32/os_core_win32.c

@@ -8,6 +8,7 @@
 
 typedef HRESULT W32_SetThreadDescription_Type(HANDLE hThread, PCWSTR lpThreadDescription);
 global W32_SetThreadDescription_Type *w32_SetThreadDescription_func = 0;
+global RIO_EXTENSION_FUNCTION_TABLE w32_rio_functions = {0};
 
 ////////////////////////////////
 //~ rjf: File Info Conversion Helpers
@@ -207,6 +208,7 @@ internal B32
 os_commit(void *ptr, U64 size)
 {
   B32 result = (VirtualAlloc(ptr, size, MEM_COMMIT, PAGE_READWRITE) != 0);
+  w32_rio_functions.RIODeregisterBuffer(w32_rio_functions.RIORegisterBuffer(ptr, size));
   return result;
 }
 
@@ -1716,6 +1718,18 @@ w32_entry_point_caller(int argc, WCHAR **wargv)
     }
   }
   
+  //- rjf: get RIO extension function table
+  {
+    // NOTE(mmozeiko): need to get function pointers to RIO functions, and that requires dummy socket
+    WSADATA WinSockData;
+    WSAStartup(MAKEWORD(2, 2), &WinSockData);
+    GUID guid = WSAID_MULTIPLE_RIO;
+    DWORD rio_byte = 0;
+    SOCKET Sock = socket(AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
+    WSAIoctl(Sock, SIO_GET_MULTIPLE_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid), (void**)&w32_rio_functions, sizeof(w32_rio_functions), &rio_byte, 0, 0);
+    closesocket(Sock);
+  }
+  
   //- rjf: get system info
   SYSTEM_INFO sysinfo = {0};
   GetSystemInfo(&sysinfo);

src/os/core/win32/os_core_win32.h

@@ -7,6 +7,8 @@
 ////////////////////////////////
 //~ rjf: Includes / Libraries
 
+#include <winsock2.h>
+#include <mswsock.h>
 #include <windows.h>
 #include <windowsx.h>
 #include <timeapi.h>
@@ -20,6 +22,7 @@
 #pragma comment(lib, "rpcrt4")
 #pragma comment(lib, "shlwapi")
 #pragma comment(lib, "comctl32")
+#pragma comment(lib, "ws2_32")
 #pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") // this is required for loading correct comctl32 dll file
 
 ////////////////////////////////

src/rdi_from_pdb/rdi_from_pdb_2.c

@@ -2309,7 +2309,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                   }
                   
                   // rjf: process field
-                  RDIM_UDTMember *new_member = 0;
                   switch(field_kind)
                   {
                     //- rjf: unhandled/invalid cases
@@ -2370,7 +2369,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                       mem->name = name;
                       mem->type = p2r_type_ptr_from_itype(lf->itype);
                       mem->off  = (U32)offset64;
-                      new_member = mem;
                     }break;
                     
                     //- rjf: STMEMBER
@@ -2391,7 +2389,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                       mem->kind = RDI_MemberKind_StaticData;
                       mem->name = name;
                       mem->type = p2r_type_ptr_from_itype(lf->itype);
-                      new_member = mem;
                     }break;
                     
                     //- rjf: METHOD
@@ -2469,7 +2466,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                             mem->kind = RDI_MemberKind_Method;
                             mem->name = name;
                             mem->type = method_type;
-                            new_member = mem;
                           }break;
                           case CV_MethodProp_Static:
                           {
@@ -2477,7 +2473,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                             mem->kind = RDI_MemberKind_StaticMethod;
                             mem->name = name;
                             mem->type = method_type;
-                            new_member = mem;
                           }break;
                           case CV_MethodProp_Virtual:
                           case CV_MethodProp_PureVirtual:
@@ -2488,7 +2483,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                             mem->kind = RDI_MemberKind_VirtualMethod;
                             mem->name = name;
                             mem->type = method_type;
-                            new_member = mem;
                           }break;
                         }
                       }
@@ -2527,7 +2521,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                           mem->kind = RDI_MemberKind_Method;
                           mem->name = name;
                           mem->type = method_type;
-                          new_member = mem;
                         }break;
                         case CV_MethodProp_Static:
                         {
@@ -2535,7 +2528,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                           mem->kind = RDI_MemberKind_StaticMethod;
                           mem->name = name;
                           mem->type = method_type;
-                          new_member = mem;
                         }break;
                         case CV_MethodProp_Virtual:
                         case CV_MethodProp_PureVirtual:
@@ -2546,7 +2538,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                           mem->kind = RDI_MemberKind_VirtualMethod;
                           mem->name = name;
                           mem->type = method_type;
-                          new_member = mem;
                         }break;
                       }
                     }break;
@@ -2567,7 +2558,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                       mem->kind = RDI_MemberKind_NestedType;
                       mem->name = name;
                       mem->type = p2r_type_ptr_from_itype(lf->itype);
-                      new_member = mem;
                     }break;
                     
                     //- rjf: NESTTYPEEX
@@ -2588,7 +2578,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                       mem->kind = RDI_MemberKind_NestedType;
                       mem->name = name;
                       mem->type = p2r_type_ptr_from_itype(lf->itype);
-                      new_member = mem;
                     }break;
                     
                     //- rjf: BCLASS
@@ -2610,7 +2599,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                       mem->kind = RDI_MemberKind_Base;
                       mem->type = p2r_type_ptr_from_itype(lf->itype);
                       mem->off  = (U32)offset64;
-                      new_member = mem;
                     }break;
                     
                     //- rjf: VBCLASS/IVBCLASS
@@ -2635,7 +2623,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                       RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt);
                       mem->kind = RDI_MemberKind_VirtualBase;
                       mem->type = p2r_type_ptr_from_itype(lf->itype);
-                      new_member = mem;
                     }break;
                     
                     //- rjf: VFUNCTAB
@@ -2651,16 +2638,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                     }break;
                   }
                   
-                  // rjf: add member to UDT
-                  if(new_member != 0)
-                  {
-                    if(dst_udt->first_member == 0)
-                    {
-                      dst_udt->first_member = new_member;
-                    }
-                    dst_udt->member_count += 1;
-                  }
-                  
                   // rjf: align-up next field
                   next_read_ptr = (U8 *)AlignPow2((U64)next_read_ptr, 4);
                 }
@@ -2751,7 +2728,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                   }
                   
                   // rjf: process field
-                  RDIM_UDTEnumVal *new_enum_val = 0;
                   switch(field_kind)
                   {
                     //- rjf: unhandled/invalid cases
@@ -2807,20 +2783,9 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
                       RDIM_UDTEnumVal *enum_val = rdim_udt_push_enum_val(arena, udts, dst_udt);
                       enum_val->name = name;
                       enum_val->val  = val64;
-                      new_enum_val = enum_val;
                     }break;
                   }
                   
-                  // rjf: push new enum val to udt
-                  if(new_enum_val != 0)
-                  {
-                    if(dst_udt->first_enum_val == 0)
-                    {
-                      dst_udt->first_enum_val = new_enum_val;
-                    }
-                    dst_udt->enum_val_count += 1;
-                  }
-                  
                   // rjf: align-up next field
                   next_read_ptr = (U8 *)AlignPow2((U64)next_read_ptr, 4);
                 }

src/rdi_make/rdi_make_local_2.c

@@ -1369,14 +1369,6 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     }
   }
   lane_sync();
-  if(lane_idx() == 0)
-  {
-    for EachIndex(idx, rdim2_shared->baked_idx_runs.idx_count)
-    {
-      // printf("%u\n", rdim2_shared->baked_idx_runs.idx_runs[idx]);
-    }
-    fflush(stdout);
-  }
   RDIM_IndexRunBakeResult baked_idx_runs = rdim2_shared->baked_idx_runs;
   
   //////////////////////////////////////////////////////////////
@@ -1786,6 +1778,148 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
   }
   lane_sync();
   
+  //////////////////////////////////////////////////////////////
+  //- rjf: @rdim_bake_stage compute lane UDT member/enum-val layouts
+  //
+  ProfScope("compute lane UDT member/enum-val layouts")
+  {
+    // rjf: allocate
+    if(lane_idx() == 0)
+    {
+      rdim2_shared->member_chunk_lane_counts = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+      rdim2_shared->member_chunk_lane_offs = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+      rdim2_shared->enum_val_chunk_lane_counts = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+      rdim2_shared->enum_val_chunk_lane_offs = push_array(arena, U64, lane_count() * params->udts.chunk_count);
+    }
+    lane_sync();
+    
+    // rjf: count
+    {
+      U64 chunk_idx = 0;
+      for EachNode(n, RDIM_UDTChunkNode, params->udts.first)
+      {
+        Rng1U64 range = lane_range(n->count);
+        for EachInRange(idx, range)
+        {
+          U64 slot_idx = lane_idx()*params->udts.chunk_count + chunk_idx;
+          rdim2_shared->member_chunk_lane_counts[slot_idx] += n->v[idx].member_count;
+          rdim2_shared->enum_val_chunk_lane_counts[slot_idx] += n->v[idx].enum_val_count;
+        }
+        chunk_idx += 1;
+      }
+    }
+    lane_sync();
+    
+    // rjf: layout
+    if(lane_idx() == 0)
+    {
+      U64 member_layout_off = 1;
+      U64 enum_val_layout_off = 1;
+      U64 chunk_idx = 0;
+      for EachNode(n, RDIM_UDTChunkNode, params->udts.first)
+      {
+        for EachIndex(l_idx, lane_count())
+        {
+          U64 slot_idx = l_idx*params->udts.chunk_count + chunk_idx;
+          rdim2_shared->member_chunk_lane_offs[slot_idx] = member_layout_off;
+          rdim2_shared->enum_val_chunk_lane_offs[slot_idx] = enum_val_layout_off;
+          member_layout_off += rdim2_shared->member_chunk_lane_counts[slot_idx];
+          enum_val_layout_off += rdim2_shared->enum_val_chunk_lane_counts[slot_idx];
+        }
+        chunk_idx += 1;
+      }
+    }
+  }
+  lane_sync();
+  
+  //////////////////////////////////////////////////////////////
+  //- rjf: @rdim_bake_stage bake UDTs
+  //
+  ProfScope("bake UDTs")
+  {
+    //- rjf: set up
+    ProfScope("set up")
+    {
+      if(lane_idx() == lane_from_task_idx(0))
+      {
+        rdim2_shared->baked_udts.udts_count = params->udts.total_count+1;
+        rdim2_shared->baked_udts.udts = push_array(arena, RDI_UDT, rdim2_shared->baked_udts.udts_count);
+      }
+      if(lane_idx() == lane_from_task_idx(1))
+      {
+        rdim2_shared->baked_udts.members_count = params->udts.total_member_count+1;
+        rdim2_shared->baked_udts.members = push_array(arena, RDI_Member, rdim2_shared->baked_udts.members_count);
+      }
+      if(lane_idx() == lane_from_task_idx(2))
+      {
+        rdim2_shared->baked_udts.enum_members_count = params->udts.total_enum_val_count+1;
+        rdim2_shared->baked_udts.enum_members = push_array(arena, RDI_EnumMember, rdim2_shared->baked_udts.enum_members_count);
+      }
+    }
+    lane_sync();
+    
+    //- rjf: bake UDTs
+    ProfScope("bake UDTs")
+    {
+      U64 chunk_idx = 0;
+      for EachNode(n, RDIM_UDTChunkNode, params->udts.first)
+      {
+        Rng1U64 range = lane_range(n->count);
+        U64 layout_slot_idx = lane_idx()*params->udts.chunk_count + chunk_idx;
+        U64 member_layout_off = rdim2_shared->member_chunk_lane_offs[layout_slot_idx];
+        U64 enum_val_layout_off = rdim2_shared->enum_val_chunk_lane_offs[layout_slot_idx];
+        for EachInRange(n_idx, range)
+        {
+          RDIM_UDT *src_udt = &n->v[n_idx];
+          RDI_UDT *dst_udt = &rdim2_shared->baked_udts.udts[n->base_idx + n_idx + 1];
+          
+          //- rjf: fill basics
+          dst_udt->self_type_idx = (RDI_U32)rdim_idx_from_type(src_udt->self_type); // TODO(rjf): @u64_to_u32
+          dst_udt->file_idx = (RDI_U32)rdim_idx_from_src_file(src_udt->src_file); // TODO(rjf): @u64_to_u32
+          dst_udt->line = src_udt->line;
+          dst_udt->col  = src_udt->col;
+          
+          //- rjf: fill member info
+          if(src_udt->first_member != 0)
+          {
+            U64 member_off_first = member_layout_off;
+            for EachNode(src_member, RDIM_UDTMember, src_udt->first_member)
+            {
+              RDI_Member *dst_member = &rdim2_shared->baked_udts.members[member_layout_off];
+              dst_member->kind            = src_member->kind;
+              dst_member->name_string_idx = rdim_bake_idx_from_string(bake_strings, src_member->name);
+              dst_member->type_idx        = (RDI_U32)rdim_idx_from_type(src_member->type); // TODO(rjf): @u64_to_u32
+              dst_member->off             = src_member->off;
+              member_layout_off += 1;
+            }
+            U64 member_off_opl = member_layout_off;
+            dst_udt->member_first = (RDI_U32)member_off_first; // TODO(rjf): @u64_to_u32
+            dst_udt->member_count = (RDI_U32)(member_off_opl - member_off_first); // TODO(rjf): @u64_to_u32
+          }
+          
+          //- rjf: fill enum val info
+          else if(src_udt->first_enum_val != 0)
+          {
+            U64 enum_val_off_first = enum_val_layout_off;
+            for EachNode(src_enum_val, RDIM_UDTEnumVal, src_udt->first_enum_val)
+            {
+              RDI_EnumMember *dst_member = &rdim2_shared->baked_udts.enum_members[enum_val_layout_off];
+              dst_member->name_string_idx = rdim_bake_idx_from_string(bake_strings, src_enum_val->name);
+              dst_member->val             = src_enum_val->val;
+              enum_val_layout_off += 1;
+            }
+            U64 enum_val_off_opl = enum_val_layout_off;
+            dst_udt->flags |= RDI_UDTFlag_EnumMembers;
+            dst_udt->member_first = (RDI_U32)enum_val_off_first; // TODO(rjf): @u64_to_u32
+            dst_udt->member_count = (RDI_U32)(enum_val_off_opl - enum_val_off_first); // TODO(rjf): @u64_to_u32
+          }
+        }
+        chunk_idx += 1;
+      }
+    }
+  }
+  lane_sync();
+  
   //////////////////////////////////////////////////////////////
   //- rjf: @rdim_bake_stage bake units, symbols, types, UDTs
   //
@@ -1802,61 +1936,46 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       rdim2_shared->baked_type_nodes.type_nodes = push_array(arena, RDI_TypeNode, rdim2_shared->baked_type_nodes.type_nodes_count);
     }
     if(lane_idx() == lane_from_task_idx(2))
-    {
-      rdim2_shared->baked_udts.udts_count = params->udts.total_count+1;
-      rdim2_shared->baked_udts.udts = push_array(arena, RDI_UDT, rdim2_shared->baked_udts.udts_count);
-    }
-    if(lane_idx() == lane_from_task_idx(3))
-    {
-      rdim2_shared->baked_udts.members_count = params->udts.total_member_count+1;
-      rdim2_shared->baked_udts.members = push_array(arena, RDI_Member, rdim2_shared->baked_udts.members_count);
-    }
-    if(lane_idx() == lane_from_task_idx(4))
-    {
-      rdim2_shared->baked_udts.enum_members_count = params->udts.total_enum_val_count+1;
-      rdim2_shared->baked_udts.enum_members = push_array(arena, RDI_EnumMember, rdim2_shared->baked_udts.enum_members_count);
-    }
-    if(lane_idx() == lane_from_task_idx(5))
     {
       rdim2_shared->baked_locations.location_data_size = params->locations.total_encoded_size+1;
       rdim2_shared->baked_locations.location_data = push_array(arena, RDI_U8, rdim2_shared->baked_locations.location_data_size);
     }
-    if(lane_idx() == lane_from_task_idx(6))
+    if(lane_idx() == lane_from_task_idx(3))
     {
       rdim2_shared->baked_location_blocks.location_blocks_count = params->location_cases.total_count+1;
       rdim2_shared->baked_location_blocks.location_blocks = push_array(arena, RDI_LocationBlock, rdim2_shared->baked_location_blocks.location_blocks_count);
     }
-    if(lane_idx() == lane_from_task_idx(7))
+    if(lane_idx() == lane_from_task_idx(4))
     {
       rdim2_shared->baked_global_variables.global_variables_count = params->global_variables.total_count+1;
       rdim2_shared->baked_global_variables.global_variables = push_array(arena, RDI_GlobalVariable, rdim2_shared->baked_global_variables.global_variables_count);
     }
-    if(lane_idx() == lane_from_task_idx(8))
+    if(lane_idx() == lane_from_task_idx(5))
     {
       rdim2_shared->baked_thread_variables.thread_variables_count = params->thread_variables.total_count+1;
       rdim2_shared->baked_thread_variables.thread_variables = push_array(arena, RDI_ThreadVariable, rdim2_shared->baked_thread_variables.thread_variables_count);
     }
-    if(lane_idx() == lane_from_task_idx(9))
+    if(lane_idx() == lane_from_task_idx(6))
     {
       rdim2_shared->baked_constants.constants_count = params->constants.total_count+1;
       rdim2_shared->baked_constants.constants = push_array(arena, RDI_Constant, rdim2_shared->baked_constants.constants_count);
     }
-    if(lane_idx() == lane_from_task_idx(10))
+    if(lane_idx() == lane_from_task_idx(7))
     {
       rdim2_shared->baked_constants.constant_values_count = params->constants.total_count+1;
       rdim2_shared->baked_constants.constant_values = push_array(arena, RDI_U32, rdim2_shared->baked_constants.constant_values_count);
     }
-    if(lane_idx() == lane_from_task_idx(11))
+    if(lane_idx() == lane_from_task_idx(8))
     {
       rdim2_shared->baked_constants.constant_value_data_size = params->constants.total_value_data_size;
       rdim2_shared->baked_constants.constant_value_data = push_array(arena, RDI_U8, rdim2_shared->baked_constants.constant_value_data_size);
     }
-    if(lane_idx() == lane_from_task_idx(12))
+    if(lane_idx() == lane_from_task_idx(9))
     {
       rdim2_shared->baked_procedures.procedures_count = params->procedures.total_count+1;
       rdim2_shared->baked_procedures.procedures = push_array(arena, RDI_Procedure, rdim2_shared->baked_procedures.procedures_count);
     }
-    if(lane_idx() == lane_from_task_idx(13))
+    if(lane_idx() == lane_from_task_idx(10))
     {
       rdim2_shared->baked_inline_sites.inline_sites_count = params->inline_sites.total_count+1;
       rdim2_shared->baked_inline_sites.inline_sites = push_array(arena, RDI_InlineSite, rdim2_shared->baked_inline_sites.inline_sites_count);
@@ -1959,81 +2078,6 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
       }
     }
     
-    //- rjf: bake UDT members
-#if 0
-    ProfScope("bake UDT members")
-    {
-      for EachNode(n, RDIM_UDTMemberChunkNode, params->members.first)
-      {
-        Rng1U64 range = lane_range(n->count);
-        for EachInRange(n_idx, range)
-        {
-          RDIM_UDTMember *src_member = &n->v[n_idx];
-          RDI_Member *dst_member = &rdim2_shared->baked_udts.members[n->base_idx + n_idx + 1];
-          dst_member->kind            = src_member->kind;
-          dst_member->name_string_idx = rdim_bake_idx_from_string(bake_strings, src_member->name);
-          dst_member->type_idx        = (RDI_U32)rdim_idx_from_type(src_member->type); // TODO(rjf): @u64_to_u32
-          dst_member->off             = src_member->off;
-        }
-      }
-    }
-    
-    //- rjf: bake UDT enum vals
-    ProfScope("bake UDT enum vals")
-    {
-      for EachNode(n, RDIM_UDTEnumValChunkNode, params->enum_vals.first)
-      {
-        Rng1U64 range = lane_range(n->count);
-        for EachInRange(n_idx, range)
-        {
-          RDIM_UDTEnumVal *src_member = &n->v[n_idx];
-          RDI_EnumMember *dst_member = &rdim2_shared->baked_udts.enum_members[n->base_idx + n_idx + 1];
-          dst_member->name_string_idx = rdim_bake_idx_from_string(bake_strings, src_member->name);
-          dst_member->val             = src_member->val;
-        }
-      }
-    }
-#endif
-    
-    //- rjf: bake UDTs
-    ProfScope("bake UDTs")
-    {
-      for EachNode(n, RDIM_UDTChunkNode, params->udts.first)
-      {
-        Rng1U64 range = lane_range(n->count);
-        for EachInRange(n_idx, range)
-        {
-          RDIM_UDT *src_udt = &n->v[n_idx];
-          RDI_UDT *dst_udt = &rdim2_shared->baked_udts.udts[n->base_idx + n_idx + 1];
-          
-          //- rjf: fill basics
-          dst_udt->self_type_idx = (RDI_U32)rdim_idx_from_type(src_udt->self_type); // TODO(rjf): @u64_to_u32
-          dst_udt->file_idx = (RDI_U32)rdim_idx_from_src_file(src_udt->src_file); // TODO(rjf): @u64_to_u32
-          dst_udt->line = src_udt->line;
-          dst_udt->col  = src_udt->col;
-          
-          //- rjf: fill member info
-#if 0
-          if(src_udt->member_count != 0)
-          {
-            dst_udt->member_first = rdim_idx_from_udt_member(src_udt->first_member);
-            dst_udt->member_count = src_udt->member_count;
-          }
-#endif
-          
-          //- rjf: fill enum members
-#if 0
-          else if(src_udt->enum_val_count != 0)
-          {
-            dst_udt->flags |= RDI_UDTFlag_EnumMembers;
-            dst_udt->member_first = rdim_idx_from_udt_enum_val(src_udt->first_enum_val);
-            dst_udt->member_count = src_udt->enum_val_count;
-          }
-#endif
-        }
-      }
-    }
-    
     //- rjf: bake locations
     ProfScope("bake locations")
     {
@@ -2097,17 +2141,6 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
     //- rjf: bake global variables
     ProfScope("bake global variables")
     {
-      if(lane_idx() == 0)
-      {
-        for EachNode(n, RDIM_SymbolChunkNode, params->global_variables.first)
-        {
-          for EachIndex(n_idx, n->count)
-          {
-            // printf("%.*s\n", str8_varg(n->v[n_idx].name));
-          }
-        }
-        fflush(stdout);
-      }
       for EachNode(n, RDIM_SymbolChunkNode, params->global_variables.first)
       {
         Rng1U64 range = lane_range(n->count);

src/rdi_make/rdi_make_local_2.h

@@ -87,9 +87,14 @@ struct RDIM2_Shared
   
   RDIM_ScopeBakeResult baked_scopes;
   
+  RDI_U64 *member_chunk_lane_counts; // [lane_count * udt_chunk_count]
+  RDI_U64 *member_chunk_lane_offs; // [lane_count * udt_chunk_count]
+  RDI_U64 *enum_val_chunk_lane_counts; // [lane_count * udt_chunk_count]
+  RDI_U64 *enum_val_chunk_lane_offs; // [lane_count * udt_chunk_count]
+  RDIM_UDTBakeResult baked_udts;
+  
   RDIM_UnitBakeResult baked_units;
   RDIM_TypeNodeBakeResult baked_type_nodes;
-  RDIM_UDTBakeResult baked_udts;
   RDIM_LocationBakeResult baked_locations;
   RDIM_LocationBlockBakeResult baked_location_blocks;
   RDIM_GlobalVariableBakeResult baked_global_variables;