Improve debugging support

etc/lldb/crystal_formatters.py

@@ -0,0 +1,62 @@
+import lldb
+
+class CrystalArraySyntheticProvider:
+    def __init__(self, valobj, internal_dict):
+        self.valobj = valobj
+        self.buffer = None
+        self.size = 0
+
+    def update(self):
+        if self.valobj.type.is_pointer:
+            self.valobj = self.valobj.Dereference()
+        self.size = int(self.valobj.child[0].value)
+        self.type = self.valobj.type
+        self.buffer = self.valobj.child[2]
+
+    def num_children(self):
+        size = 0 if self.size is None else self.size
+        return size
+
+    def get_child_index(self, name):
+        try:
+            return int(name.lstrip('[').rstrip(']'))
+        except:
+            return -1
+
+    def get_child_at_index(self,index):
+        if index >= self.size:
+            return None        
+        try:
+            elementType = self.buffer.type.GetPointeeType()
+            offset = elementType.size * index
+            return self.buffer.CreateChildAtOffset('[' + str(index) + ']', offset, elementType)
+        except Exception as e:
+            print('Got exception %s' % (str(e)))
+            return None
+
+def findType(name, module):
+    cachedTypes = module.GetTypes()
+    for idx in range(cachedTypes.GetSize()):
+        type = cachedTypes.GetTypeAtIndex(idx)
+        if type.name == name:
+            return type
+    return None
+
+
+def CrystalString_SummaryProvider(value, dict):
+    error = lldb.SBError()
+    if value.TypeIsPointerType():
+        value = value.Dereference()
+    process = value.GetTarget().GetProcess()
+    byteSize = int(value.child[0].value)
+    len = int(value.child[1].value)
+    len = byteSize or len
+    strAddr = value.child[2].load_addr
+    val = process.ReadCStringFromMemory(strAddr, len + 1, error)
+    return '"%s"' % val
+
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand('type synthetic add -l crystal_formatters.CrystalArraySyntheticProvider -x "^Array\(.+\)(\s*\**)?" -w Crystal')
+    debugger.HandleCommand('type summary add -F crystal_formatters.CrystalString_SummaryProvider -x "^(String|\(String \| Nil\))(\s*\**)?$" -w Crystal')
+    debugger.HandleCommand('type category enable Crystal')

spec/spec_helper.cr

@@ -156,9 +156,13 @@ def assert_macro_internal(program, sub_node, macro_args, macro_body, expected, e
   result_pragmas.should eq(expected_pragmas) if expected_pragmas
 end
 
-def codegen(code, inject_primitives = true, debug = Crystal::Debug::None)
+def codegen(code, inject_primitives = true, debug = Crystal::Debug::None, filename = __FILE__)
   code = inject_primitives(code) if inject_primitives
-  node = parse code
+  parser = Parser.new(code)
+  parser.filename = filename
+  parser.wants_doc = false
+  node = parser.parse
+
   result = semantic node
   result.program.codegen(result.node, single_module: false, debug: debug)[""].mod
 end

src/compiler/crystal/codegen/codegen.cr

@@ -135,8 +135,9 @@ module Crystal
       # llvm value, so in a way it's "already loaded".
       # This field is true if that's the case.
       getter already_loaded : Bool
+      getter debug_variable_created : Bool
 
-      def initialize(@pointer, @type, @already_loaded = false)
+      def initialize(@pointer, @type, @already_loaded = false, @debug_variable_created = false)
       end
     end
 
@@ -361,6 +362,13 @@ module Crystal
         mod = info.mod
         push_debug_info_metadata(mod) unless @debug.none?
 
+        if ENV["CRYSTAL_DEBUG_LL_DUMP"]?
+          puts "Module #{name}:"
+          mod.functions.each do |func|
+            puts func.body_to_ll_string
+          end
+        end
+
         mod.dump if dump_all_llvm || name =~ dump_llvm_regex
 
         # Always run verifications so we can catch bugs earlier and more often.
@@ -1345,7 +1353,12 @@ module Crystal
     end
 
     def declare_var(var)
-      context.vars[var.name] ||= LLVMVar.new(var.no_returns? ? llvm_nil : alloca(llvm_type(var.type), var.name), var.type)
+      context.vars[var.name] ||= begin
+        pointer = var.no_returns? ? llvm_nil : alloca(llvm_type(var.type), var.name)
+        debug_variable_created = false
+        debug_variable_created = declare_variable(var.name, var.type, pointer, var.location) unless context.fun.naked?
+        LLVMVar.new(pointer, var.type, debug_variable_created: debug_variable_created)
+      end
     end
 
     def declare_lib_var(name, type, thread_local)
@@ -1712,8 +1725,18 @@ module Crystal
             is_arg = args.try &.any? { |arg| arg.name == var.name }
             next if is_arg
 
-            ptr = builder.alloca llvm_type(var_type), name
-            context.vars[name] = LLVMVar.new(ptr, var_type)
+            ptr = alloca llvm_type(var_type), name
+
+            location = var.location
+            if location.nil? && obj.is_a?(ASTNode)
+              location = obj.location
+            end
+
+            debug_variable_created = false
+            if location && !context.fun.naked?
+              debug_variable_created = declare_variable name, var_type, ptr, location, alloca_block
+            end
+            context.vars[name] = LLVMVar.new(ptr, var_type, debug_variable_created: debug_variable_created)
 
             # Assign default nil for variables that are bound to the nil variable
             if bound_to_mod_nil?(var)

src/compiler/crystal/codegen/crystal_llvm_builder.cr

@@ -61,6 +61,10 @@ module Crystal
       @builder.build_operand_bundle_def(name, values)
     end
 
+    def current_debug_location_metadata
+      @builder.current_debug_location_metadata
+    end
+
     def to_unsafe
       @builder.to_unsafe
     end