Merge pull request #503 from savi-lang/fix/trait-bitmap-max

Fix trait bitmap entries to correctly use 64-bit values

Author: jemc

src/savi/compiler/code_gen.cr

@@ -3457,15 +3457,15 @@ class Savi::Compiler::CodeGen
     # This code is shamelessly copied from gen_desc, with a few modifications,
     # because we already know that we are just targeting exactly one gtype
     # (the mutator_gtype which this object is tailor-made to fit).
-    traits_bitmap = trait_bitmap_size.times.map { 0 }.to_a
+    traits_bitmap = trait_bitmap_size.times.map { 0_u64 }.to_a
     mutator_gtype.type_def.tap do |other_def|
       raise "can't be subtype of a concrete" unless other_def.is_abstract?(ctx)
 
       index = other_def.desc_id >> Math.log2(@bitwidth).to_i
       raise "bad index or trait_bitmap_size" unless index < trait_bitmap_size
 
       bit = other_def.desc_id & (@bitwidth - 1)
-      traits_bitmap[index] |= (1 << bit)
+      traits_bitmap[index] |= (1_u64 << bit)
     end
     traits_bitmap_global = gen_global_for_const \
       @isize.const_array(traits_bitmap.map { |bits| @isize.const_int(bits) })

src/savi/compiler/code_gen/debug_info.cr

@@ -176,8 +176,7 @@ class Savi::Compiler::CodeGen
       t : Reach::Ref,
       llvm_struct_type : LLVM::Type,
     )
-      ident = t.single!.defn(ctx).ident
-      name = ident.value
+      name = t.single_def!(ctx).llvm_name
 
       # Create a temporary stand-in for this debug type, which is used to
       # prevent unwanted recursion if it (directly or indirectly) contains
@@ -220,6 +219,17 @@ class Savi::Compiler::CodeGen
       di_create_struct_type(name, llvm_type, di_member_info, pos)
     end
 
+    @di_opaque_object_pointer_type : LibLLVM::MetadataRef?
+    def di_opaque_object_pointer_type
+      @di_opaque_object_pointer_type ||= begin
+        di_create_pointer_type("OPAQUE*",
+          di_create_struct_type("OPAQUE",
+            @runtime.obj, di_runtime_member_info, Source::Pos.none
+          )
+        )
+      end
+    end
+
     def di_create_fields_struct_type(
       t : Reach::Ref,
       llvm_type : LLVM::Type,
@@ -332,8 +342,7 @@ class Savi::Compiler::CodeGen
             ctx.code_gen.gtypes[ctx.reach[t.single!].llvm_name].struct_type,
           )
         elsif t.llvm_use_type(ctx) == :struct_ptr_opaque
-          # TODO: Some more descriptive debug type?
-          di_create_basic_type(t, llvm_type, LLVM::DwarfTypeEncoding::Address)
+          di_opaque_object_pointer_type
         else
           raise NotImplementedError.new(t)
         end

src/savi/compiler/code_gen/ponyrt.cr

@@ -378,17 +378,20 @@ class Savi::Compiler::CodeGen::PonyRT
 
   def di_runtime_member_info(debug : DebugInfo)
     di_type_u32 = debug.di_create_basic_type("uint32_t", @i32, LLVM::DwarfTypeEncoding::Unsigned)
+    di_type_usize = debug.di_create_basic_type("size_t", @isize, LLVM::DwarfTypeEncoding::Unsigned)
     di_type_char = debug.di_create_basic_type("char", @i8, LLVM::DwarfTypeEncoding::Signed)
     di_type_cstring = debug.di_create_pointer_type("char*", di_type_char)
     di_type_typestring_ptr = debug.di_create_pointer_type("TYPESTRING*",
       debug.di_create_struct_type("TYPESTRING", @typestring, {
         3 => {"_ptr", @ptr, di_type_cstring},
       }),
     )
+    di_type_trait_bitmap_ptr = debug.di_create_pointer_type("size_t*", di_type_usize)
     di_type_desc_ptr = debug.di_create_pointer_type("TYPE*",
       debug.di_create_struct_type("TYPE", @desc, {
         DESC_ID => {"id", @i32, di_type_u32},
         DESC_TYPE_NAME => {"name", @ptr, di_type_typestring_ptr},
+        DESC_TRAITS => {"traits", @ptr, di_type_trait_bitmap_ptr},
       }),
     )
     { 0 => {"TYPE", @ptr, di_type_desc_ptr} }
@@ -442,14 +445,14 @@ class Savi::Compiler::CodeGen::PonyRT
     # the corresponding bit set in their version of the bitmap.
     # This is used for runtime type matching against abstract types (traits).
     is_asio_event_actor = false
-    traits_bitmap = g.trait_bitmap_size.times.map { 0 }.to_a
+    traits_bitmap = g.trait_bitmap_size.times.map { 0_u64 }.to_a
     g.ctx.reach.each_type_def.each { |other_def|
       if gtype.type_def.is_subtype_of?(g.ctx, other_def)
         index = other_def.desc_id >> Math.log2(g.bitwidth).to_i
         raise "bad index or trait_bitmap_size" unless index < g.trait_bitmap_size
 
         bit = other_def.desc_id & (g.bitwidth - 1)
-        traits_bitmap[index] |= (1 << bit)
+        traits_bitmap[index] |= (1_u64 << bit)
 
         # Take special note if this type is a subtype of AsioEvent.Actor.
         is_asio_event_actor = true if other_def.llvm_name == "AsioEvent.Actor"

tooling/lldb/savi_commands.py

@@ -12,6 +12,10 @@ def get_command(debugger, command, result, internal_dict):
   # Get the root value by name, then dig into it using the child field names.
   value = frame.FindVariable(names[0])
   for name in names[1:]:
+    # If we're looking for a field in a struct, we need to use the FIELDS field.
+    if name != "TYPE" and name != "FIELDS":
+      value = value.GetChildMemberWithName("FIELDS")
+
     # TODO: If the value has an abstract type, we need to use its TYPE field
     # here to .Cast() it to the corresponding concrete type.
     # However it may be difficult to find the appropriate concrete type by name;