konpeito 0.2.4 → 0.3.0

data/lib/konpeito/codegen/llvm_generator.rb

@@ -7,6 +7,9 @@ module Konpeito
   module Codegen
     # Generates LLVM IR from HIR
     class LLVMGenerator
+      # Special capture name used to pass outer `self` into block callbacks.
+      # Allows @ivar access inside blocks to use the enclosing method's self.
+      BLOCK_SELF_CAPTURE = "__blk_self__"
       attr_reader :mod, :builder, :hir_program
 
       def initialize(module_name: "konpeito", monomorphizer: nil, rbs_loader: nil, debug: false, profile: false, source_file: nil)
@@ -30,6 +33,9 @@ module Konpeito
         @variables = {}           # For SSA values (temps, etc.)
         @variable_allocas = {}    # For local variables (alloca-based for loop safety)
         @variable_types = {}      # Track unboxed types: :i64, :double, or :value
+        @block_exit_overrides = {} # When safe navigation expands a HIR block into multiple LLVM blocks,
+                                   # maps HIR block label → actual LLVM exit block (for phi predecessors)
+        @generating_block_label = nil # Label of the HIR block currently being generated
         @hir_program = nil
         @monomorphizer = monomorphizer
         @rbs_loader = rbs_loader
@@ -42,6 +48,8 @@ module Konpeito
         @variadic_functions = {}  # Track functions with **kwargs or *args
         @keyword_param_functions = {}  # Track functions with keyword params (for direct call kwargs passing)
         @comparison_result_vars = Set.new  # Track variables holding comparison results (0/1 boolean)
+        @polymorphic_methods = Set.new  # Method names defined in multiple classes (must not use direct call)
+        @hir_functions = {}  # name -> HIR::Function; used to detect &blk params (proc-storing methods)
 
         # Register all NativeClass types from RBS upfront
         register_native_classes_from_rbs
@@ -126,7 +134,11 @@ module Konpeito
         @alias_renamed_methods = {}  # "ClassName#old_name" -> renamed_func_name
 
         functions.each_with_index do |func, i|
-          key = [func.owner_class, func.owner_module, func.name.to_s, func.class_method?]
+          # Use the mangled LLVM name as the dedup key.
+          # Two HIR functions with the same owner_class but different owner_module
+          # still produce the same LLVM symbol (e.g. rn_Style_align), so they must
+          # be deduplicated even if their [owner_class, owner_module, name] triples differ.
+          key = mangle_name(func)
           if seen.key?(key) && alias_targets["#{func.owner_class}##{func.name}"]
             # This method was aliased and is now being redefined.
             # Rename the earlier definition so the alias can point to it.
@@ -139,12 +151,20 @@ module Konpeito
           end
           seen[key] = i
         end
-        # Keep all functions (including renamed originals)
-        functions
+        # Keep only the last occurrence of each function key.
+        # Also keep alias-renamed originals (needed for alias resolution).
+        keep_indices = seen.values.to_set
+        functions.each_with_index do |func, i|
+          keep_indices << i if func.name.to_s.end_with?("$alias_orig")
+        end
+        functions.select.with_index { |_, i| keep_indices.include?(i) }
       end
 
       # Declare a function (create LLVM function without body)
       def declare_function(hir_func)
+        # Record HIR function for later inspection (e.g. detecting &blk params)
+        @hir_functions[hir_func.name.to_s] = hir_func
+
         native_class_type = detect_native_class_for_function(hir_func)
 
         if native_class_type
@@ -159,8 +179,8 @@ module Konpeito
       # e.g. for monomorphized functions like dot_Vec2 whose name has no matching method entry).
       def native_param_type_sym_from_hir(param)
         t = param.type
-        return :Float64 if t == TypeChecker::Types::FLOAT || t&.name == :Float
-        return :Int64   if t == TypeChecker::Types::INTEGER || t&.name == :Integer
+        return :Float64 if t == TypeChecker::Types::FLOAT || (t.is_a?(TypeChecker::Types::ClassInstance) && t.name == :Float)
+        return :Int64   if t == TypeChecker::Types::INTEGER || (t.is_a?(TypeChecker::Types::ClassInstance) && t.name == :Integer)
         # Everything else (NativeClass, unknown) → use pointer (else branch in caller)
         :OtherNativeClass
       end
@@ -202,6 +222,10 @@ module Konpeito
 
         mangled = mangle_name(hir_func)
         func = @mod.functions.add(mangled, param_types, return_type)
+        # Track methods that are defined in multiple classes — these require virtual dispatch
+        if (existing = @functions[hir_func.name]) && existing.name != mangled
+          @polymorphic_methods << hir_func.name
+        end
         @functions[hir_func.name] = func
         @functions[mangled] = func
         @native_method_funcs ||= {}
@@ -257,6 +281,10 @@ module Konpeito
 
         return_type = value_type
         func = @mod.functions.add(mangled, param_types, return_type)
+        # Track methods that are defined in multiple classes — these require virtual dispatch
+        if (existing = @functions[hir_func.name]) && existing.name != mangled
+          @polymorphic_methods << hir_func.name
+        end
         @functions[hir_func.name] = func
         @functions[mangled] = func
       end
@@ -504,6 +532,11 @@ module Konpeito
         # We'll use rb_funcallv for variadic args: VALUE rb_funcallv(VALUE recv, ID mid, int argc, VALUE *argv)
         @rb_funcallv = @mod.functions.add("rb_funcallv", [value_type, id_type, LLVM::Int32, LLVM::Pointer(value_type)], value_type)
 
+        # rb_funcallv_kw - call a method with keyword argument flag
+        # VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
+        # kw_splat: RB_PASS_KEYWORDS (1) means last element of argv is a keyword Hash
+        @rb_funcallv_kw = @mod.functions.add("rb_funcallv_kw", [value_type, id_type, LLVM::Int32, LLVM::Pointer(value_type), LLVM::Int32], value_type)
+
         # rb_int2inum - convert C int to Ruby Integer
         @rb_int2inum = @mod.functions.add("rb_int2inum", [int_type], value_type) do |fn|
           fn.linkage = :external
@@ -699,6 +732,14 @@ module Konpeito
            LLVM::Pointer(block_callback_type), value_type],
           value_type)
 
+        # rb_block_call_kw - call method with block callback and keyword argument flag
+        # VALUE rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE *argv,
+        #                        rb_block_call_func_t proc, VALUE data2, int kw_splat)
+        @rb_block_call_kw = @mod.functions.add("rb_block_call_kw",
+          [value_type, id_type, LLVM::Int32, LLVM::Pointer(value_type),
+           LLVM::Pointer(block_callback_type), value_type, LLVM::Int32],
+          value_type)
+
         # Proc functions
         # VALUE rb_proc_new(rb_block_call_func_t func, VALUE val)
         # Creates a Proc object from a C callback function
@@ -1045,6 +1086,7 @@ module Konpeito
         @variables = {}
         @variable_allocas = {}
         @variable_types = {}
+        @block_exit_overrides = {}
         @current_function = func
         @current_hir_func = hir_func
         @current_native_class = native_class_type  # Track for self field access
@@ -1119,6 +1161,7 @@ module Konpeito
         @variables = {}
         @variable_allocas = {}
         @variable_types = {}
+        @block_exit_overrides = {}
         @current_function = func
         @current_hir_func = hir_func
 
@@ -1155,6 +1198,34 @@ module Konpeito
           @variable_types[var_name] = type_tag
         end
 
+        # Pre-scan for thread-captured variables.
+        # Replace their stack allocas with heap cells at function entry so that
+        # all code (loop conditions, loop bodies, after-loop) uses the same
+        # shared heap location consistently. This avoids the mid-loop alloca
+        # replacement issue where loop conditions read from stale stack allocas.
+        thread_captured_vars = collect_thread_captured_vars(hir_func)
+        @thread_boxed_vars = {}  # Reset per-function (each function has its own heap cells)
+        unless thread_captured_vars.empty?
+          declare_malloc
+          thread_captured_vars.each do |cap_name|
+            next if @thread_boxed_vars[cap_name]
+            next unless @variable_allocas[cap_name]
+
+            # Allocate a heap cell (8 bytes = sizeof(VALUE)) and replace the alloca
+            cell = @builder.call(@malloc, LLVM::Int64.from_i(8), "tbox_#{cap_name}")
+            cell_int = @builder.ptr2int(cell, LLVM::Int64, "tbox_#{cap_name}_int")
+            cell_typed = @builder.int2ptr(cell_int, LLVM::Pointer(value_type), "tbox_#{cap_name}_ptr")
+
+            # Initialize with Qnil (variables haven't been assigned yet at entry)
+            @builder.store(@qnil, cell_typed)
+
+            # Replace stack alloca with heap cell — all subsequent reads/writes
+            # in the function go through this shared heap location
+            @variable_allocas[cap_name] = cell_typed
+            @thread_boxed_vars[cap_name] = cell_typed
+          end
+        end
+
         # Separate regular, keyword, keyword_rest, and block parameters
         regular_params = hir_func.params.reject { |p| p.keyword || p.keyword_rest || p.rest || p.block }
         keyword_params = hir_func.params.select(&:keyword)
@@ -1507,67 +1578,93 @@ module Konpeito
       # Topologically sort blocks based on phi dependencies
       # Ensures blocks are generated after the blocks their phi nodes reference
       def sort_blocks_by_phi_dependencies(blocks)
-        # Build a map of block label -> block
+        return blocks if blocks.size <= 1
+
         block_map = blocks.each_with_object({}) { |b, h| h[b.label] = b }
 
-        # Build dependency graph: block -> blocks it depends on (via phi incoming values)
-        dependencies = {}
+        # Build CFG successor edges from terminators.
+        # A block's successors are the blocks it branches/jumps to.
+        successors = {}
+        blocks.each do |block|
+          succs = []
+          term = block.terminator
+          case term
+          when HIR::Branch
+            succs << term.then_block if block_map[term.then_block]
+            succs << term.else_block if block_map[term.else_block]
+          when HIR::Jump
+            succs << term.target if block_map[term.target]
+          end
+          successors[block.label] = succs
+        end
+
+        # Also add phi-based dependencies: if a block has a phi that references a
+        # result_var defined in another block, that other block should come first.
+        phi_deps = Hash.new { |h, k| h[k] = Set.new }
         blocks.each do |block|
-          deps = Set.new
           block.instructions.each do |inst|
             next unless inst.is_a?(HIR::Phi)
 
-            inst.incoming.each do |label, value|
-              # If the incoming value is from a result_var in another block,
-              # we depend on that block being generated first
+            inst.incoming.each do |_label, value|
               if value.respond_to?(:result_var) && value.result_var
-                # Find which block defines this result_var
                 blocks.each do |other_block|
                   next if other_block.label == block.label
 
                   other_block.instructions.each do |other_inst|
                     if other_inst.respond_to?(:result_var) && other_inst.result_var == value.result_var
-                      deps << other_block.label
+                      phi_deps[block.label] << other_block.label
                     end
                   end
                 end
               end
             end
           end
-          dependencies[block.label] = deps
         end
 
-        # Topological sort using Kahn's algorithm
-        in_degree = Hash.new(0)
-        dependencies.each do |block_label, deps|
-          deps.each do |dep_label|
-            in_degree[block_label] += 1 if block_map[dep_label]
+        # Reverse Post-Order (RPO) traversal of the CFG.
+        # This ensures a block is processed after all its predecessors (except back-edges).
+        visited = Set.new
+        post_order = []
+
+        dfs = lambda do |label|
+          return if visited.include?(label)
+
+          visited << label
+          successors[label]&.each do |succ|
+            dfs.call(succ)
           end
+          post_order << label
         end
 
-        # Start with blocks that have no dependencies
-        queue = blocks.select { |b| in_degree[b.label] == 0 }
-        sorted = []
+        dfs.call(blocks.first.label)
 
-        while queue.any?
-          # Take the first available block (preserves original order when possible)
-          current = queue.shift
-          sorted << current
+        # Any unreachable blocks (not visited) are appended at the end
+        rpo = post_order.reverse.filter_map { |label| block_map[label] }
+        remaining = blocks.select { |b| !visited.include?(b.label) }
 
-          # For each block that depends on current, decrease its in-degree
-          blocks.each do |block|
-            if dependencies[block.label]&.include?(current.label)
-              in_degree[block.label] -= 1
-              if in_degree[block.label] == 0 && !sorted.include?(block) && !queue.include?(block)
-                queue << block
-              end
+        sorted = rpo + remaining
+
+        # Final pass: respect phi dependencies by moving blocks forward if needed.
+        # If block B depends on block A (via phi), ensure A comes before B.
+        changed = true
+        while changed
+          changed = false
+          sorted.each_with_index do |block, idx|
+            phi_deps[block.label].each do |dep_label|
+              dep_idx = sorted.index { |b| b.label == dep_label }
+              next unless dep_idx && dep_idx > idx
+
+              # Move dep_block before current block
+              dep_block = sorted.delete_at(dep_idx)
+              sorted.insert(idx, dep_block)
+              changed = true
+              break
             end
+            break if changed
           end
         end
 
-        # If some blocks weren't added (cycle), add them in original order
-        remaining = blocks - sorted
-        sorted + remaining
+        sorted
       end
 
       def collect_local_variables_with_types(hir_func)
@@ -1627,6 +1724,22 @@ module Konpeito
         vars
       end
 
+      # Collect all variable names that are captured by any Thread.new block
+      # in the function. Used for pre-boxing at function entry.
+      def collect_thread_captured_vars(hir_func)
+        captured = Set.new
+        hir_func.body.each do |block|
+          block.instructions.each do |inst|
+            if inst.is_a?(HIR::ThreadNew) && inst.block_def
+              inst.block_def.captures.each do |cap|
+                captured << cap.name
+              end
+            end
+          end
+        end
+        captured
+      end
+
       # Collect local variables used in a block definition
       # Similar to collect_local_variables_with_types but for block bodies
       def collect_local_variables_in_block(block_def)
@@ -1722,7 +1835,12 @@ module Konpeito
 
       # Get the self VALUE for the current function.
       # For variadic functions (arity -1), self is at params[2] instead of params[0].
+      # Inside block/rescue callbacks, returns the captured self (set by callback generators).
+      # Inside thread callbacks, params[0] is ptr (void*) not VALUE, so returns Qnil.
       def get_self_value
+        return @block_callback_self if @block_callback_self
+        return @qnil if @in_thread_callback
+
         func = @builder.insert_block.parent
         mangled = func.name
         if @variadic_functions[mangled]
@@ -1736,10 +1854,15 @@ module Konpeito
         llvm_block = @blocks[hir_block.label]
         @builder.position_at_end(llvm_block)
 
+        # Track the current HIR block label so safe navigation can record exit overrides
+        saved_generating_block_label = @generating_block_label
+        @generating_block_label = hir_block.label
+
         # Collect instructions that are owned by BeginRescue nodes
         # These will be generated inside callbacks, not in the main function
         rescue_owned = collect_rescue_owned_instructions(hir_block.instructions)
 
+
         # Generate instructions
         hir_block.instructions.each do |inst|
           next if rescue_owned.include?(inst.object_id)
@@ -1748,29 +1871,42 @@ module Konpeito
 
         # Generate terminator
         generate_terminator(hir_block.terminator) if hir_block.terminator
+
+        @generating_block_label = saved_generating_block_label
       end
 
-      # Collect all instructions that are owned by BeginRescue nodes
-      # These instructions will be generated inside try/rescue callbacks,
-      # not in the main function body
+      # Collect all instructions that are owned by BeginRescue or CaseStatement nodes.
+      # These instructions will be generated inside their proper blocks (callbacks or
+      # when_body blocks), not in the main function body's linear pass.
       def collect_rescue_owned_instructions(instructions)
         owned = Set.new
         instructions.each do |inst|
-          next unless inst.is_a?(HIR::BeginRescue)
+          if inst.is_a?(HIR::BeginRescue)
+            # All sub-expression instructions emitted during rescue/else/ensure visitation
+            # are tracked in non_try_instruction_ids (same approach as JVM generator)
+            owned.merge(inst.non_try_instruction_ids) if inst.non_try_instruction_ids
+
+            # Try block instructions (skip Phi nodes — they must stay at the top of their
+            # natural HIR block; generate_phi will return a cached value when called inline)
+            inst.try_blocks&.each { |i| owned << i.object_id unless i.is_a?(HIR::Phi) }
+
+            # Rescue clause body instructions
+            inst.rescue_clauses&.each do |clause|
+              clause.body_blocks&.each { |i| owned << i.object_id }
+            end
 
-          # Try block instructions
-          inst.try_blocks&.each { |i| owned << i.object_id }
+            # Else block instructions
+            inst.else_blocks&.each { |i| owned << i.object_id }
 
-          # Rescue clause body instructions
-          inst.rescue_clauses&.each do |clause|
-            clause.body_blocks&.each { |i| owned << i.object_id }
+            # Ensure block instructions
+            inst.ensure_blocks&.each { |i| owned << i.object_id }
+          elsif inst.is_a?(HIR::CaseStatement)
+            # When/else body instructions (and their condition expressions) are emitted
+            # into the current block by build_when_clause, but they must only be generated
+            # inside their proper when_body/else LLVM blocks by generate_case_statement.
+            # Skip them here so they are not executed unconditionally before the dispatch.
+            owned.merge(inst.sub_instruction_ids) if inst.sub_instruction_ids
           end
-
-          # Else block instructions
-          inst.else_blocks&.each { |i| owned << i.object_id }
-
-          # Ensure block instructions
-          inst.ensure_blocks&.each { |i| owned << i.object_id }
         end
         owned
       end
@@ -1813,6 +1949,8 @@ module Konpeito
           generate_store_constant(inst)
         when HIR::Call
           generate_call(inst)
+        when HIR::CaseEqualityCheck
+          generate_case_equality_check(inst)
         when HIR::SelfRef
           generate_self_ref(inst)
         when HIR::Phi
@@ -2103,9 +2241,12 @@ module Konpeito
         end
 
         # Generate dynamic parts first (they may need to_s conversion)
-        # and collect their lengths
         dynamic_values = []
-        dynamic_lengths = []
+
+        # Declare rb_obj_as_string (returns String as-is, calls to_s only for non-String)
+        rb_obj_as_string = @mod.functions["rb_obj_as_string"] || @mod.functions.add(
+          "rb_obj_as_string", [value_type], value_type
+        )
 
         part_info.each do |info|
           next if info[:type] == :static
@@ -2116,19 +2257,13 @@ module Konpeito
           val = get_value_as_ruby(info[:hir])
 
           # Convert to string if needed (for non-string interpolated values)
+          # rb_obj_as_string returns String as-is, avoids rb_funcallv method lookup
           val_type = info[:hir].respond_to?(:type) ? info[:hir].type : nil
           unless val_type == TypeChecker::Types::STRING
-            to_s_ptr = @builder.global_string_pointer("to_s")
-            to_s_id = @builder.call(@rb_intern, to_s_ptr)
-            val = @builder.call(@rb_funcallv, val, to_s_id, LLVM::Int32.from_i(0), LLVM::Pointer(value_type).null)
+            val = @builder.call(rb_obj_as_string, val)
           end
 
           dynamic_values << val
-          # Get string length (returns Fixnum, need to unbox)
-          len_val = @builder.call(@rb_str_length, val)
-          # Unbox Fixnum: (value >> 1)
-          len_i64 = @builder.ashr(len_val, LLVM::Int64.from_i(1))
-          dynamic_lengths << len_i64
         end
 
         # If only one part, just return it
@@ -2143,14 +2278,9 @@ module Konpeito
           return result
         end
 
-        # Calculate total length: static_length + sum of dynamic lengths
-        total_length = LLVM::Int64.from_i(static_length)
-        dynamic_lengths.each do |len|
-          total_length = @builder.add(total_length, len)
-        end
-
-        # Pre-allocate buffer with total capacity
-        result = @builder.call(@rb_str_buf_new, total_length)
+        # Pre-allocate buffer: static length + padding for dynamic parts (avoid runtime length scan)
+        total_capacity = LLVM::Int64.from_i(static_length + 128)
+        result = @builder.call(@rb_str_buf_new, total_capacity)
 
         # Append each part using efficient methods
         dynamic_idx = 0
@@ -2571,6 +2701,15 @@ module Konpeito
         @variables[var_name] = value_to_store
         @variable_types[var_name] = target_type
 
+        # Write-back to escape array when inside a rescue/try callback.
+        # This ensures variable mutations inside callbacks are visible to the
+        # outer function after rb_rescue2 returns.
+        if @rescue_escape_array && @rescue_escape_indices&.key?(var_name)
+          idx = @rescue_escape_indices[var_name]
+          boxed = convert_value(value_to_store, target_type, :value)
+          @builder.call(@rb_ary_store, @rescue_escape_array, LLVM::Int64.from_i(idx), boxed)
+        end
+
         # Propagate comparison result flag through variable assignments
         src_var = inst.value.respond_to?(:result_var) ? inst.value.result_var : nil
         if src_var && @comparison_result_vars.include?(src_var)
@@ -2600,9 +2739,17 @@ module Konpeito
             value = @variables[hir_value.result_var]
             type_tag = @variable_types[hir_value.result_var] || :value
             [value, type_tag]
-          else
+          elsif @variables.key?(hir_value.var.name)
             # Fall back to var.name (for pattern-bound variables or inliner-created refs)
             var_name = hir_value.var.name
+            value = @variables[var_name]
+            type_tag = @variable_types[var_name] || :value
+            [value, type_tag]
+          else
+            # Variable not yet loaded (e.g. sub-expression in rescue handler body).
+            # Generate the LoadLocal instruction to load from @variable_allocas.
+            generate_instruction(hir_value)
+            var_name = hir_value.result_var || hir_value.var.name
             value = @variables[var_name] || @qnil
             type_tag = @variable_types[var_name] || :value
             [value, type_tag]
@@ -3008,6 +3155,11 @@ module Konpeito
           return generate_unboxed_unary(inst)
         end
 
+        # Try inline String methods (empty?)
+        if can_inline_string_method?(inst)
+          return generate_inline_string_method(inst)
+        end
+
         # Try unboxed arithmetic optimization
         if can_use_unboxed_arithmetic?(inst)
           # generate_unboxed_arithmetic sets @variables and @variable_types internally
@@ -3036,9 +3188,11 @@ module Konpeito
             return result
           end
 
-          # Check if we can call a local function directly
+          # Check if we can call a local function directly.
+          # Skip if the method is defined in multiple classes (polymorphic) — such
+          # calls must use rb_funcallv so the correct subclass override is invoked.
           local_func = @functions[inst.method_name]
-          if local_func && self_receiver?(inst.receiver)
+          if local_func && self_receiver?(inst.receiver) && !@polymorphic_methods.include?(inst.method_name)
             result = generate_direct_call(inst, inst.method_name)
             @variables[inst.result_var] = result if inst.result_var
             return result
@@ -3091,6 +3245,12 @@ module Konpeito
           return result
         end
 
+        # Try optimized String method calls before rb_funcallv fallback
+        if (result = try_optimized_string_call(inst, receiver_type))
+          @variables[inst.result_var] = result if inst.result_var
+          return result
+        end
+
         # Get receiver as Ruby VALUE (box if needed)
         receiver = get_value_as_ruby(inst.receiver)
 
@@ -3101,7 +3261,7 @@ module Konpeito
         # Build keyword arguments hash if present
         kwargs_hash = nil
         if inst.has_keyword_args?
-          kwargs_hash = build_keyword_args_hash(inst.keyword_args)
+          kwargs_hash = build_keyword_args_hash(inst.keyword_args, keyword_splat: inst.keyword_splat)
         end
 
         # Check if any argument is a splat
@@ -3136,7 +3296,14 @@ module Konpeito
             argv = @builder.bit_cast(argv, LLVM::Pointer(value_type))
           end
 
-          result = @builder.call(@rb_funcallv, receiver, method_id, argc, argv)
+          # Use rb_funcallv_kw when keyword arguments are present so Ruby
+          # correctly separates them from positional arguments (Ruby 3.0+)
+          if kwargs_hash
+            rb_pass_keywords = LLVM::Int32.from_i(1) # RB_PASS_KEYWORDS
+            result = @builder.call(@rb_funcallv_kw, receiver, method_id, argc, argv, rb_pass_keywords)
+          else
+            result = @builder.call(@rb_funcallv, receiver, method_id, argc, argv)
+          end
         end
 
         @variables[inst.result_var] = result if inst.result_var
@@ -3229,6 +3396,14 @@ module Konpeito
             end
           end
         end
+
+        # Record that the enclosing HIR block now exits through safe_merge_bb.
+        # Any HIR::Phi that references the enclosing HIR block as a predecessor
+        # must use safe_merge_bb instead of the original LLVM block.
+        if @generating_block_label
+          @block_exit_overrides[@generating_block_label] = safe_merge_bb
+        end
+
         phi
       end
 
@@ -3439,13 +3614,30 @@ module Konpeito
         end
       end
 
-      # Build a Ruby Hash from keyword arguments
+      # Build a Ruby Hash from keyword arguments (and optional **hash splat)
       # Returns an LLVM VALUE representing the Hash
-      def build_keyword_args_hash(keyword_args)
+      def build_keyword_args_hash(keyword_args, keyword_splat: nil)
+        # If only a keyword splat with no explicit keyword args, use the hash directly
+        if keyword_splat && keyword_args.empty?
+          return get_value_as_ruby(keyword_splat)
+        end
+
         # Create new hash
         hash = @builder.call(@rb_hash_new)
 
-        # Add each keyword argument
+        # Merge splatted hash if present (mixed case: **hash + explicit key: val)
+        if keyword_splat
+          splat_value = get_value_as_ruby(keyword_splat)
+          update_id_ptr = @builder.global_string_pointer("update")
+          update_id = @builder.call(@rb_intern, update_id_ptr)
+          argv = @builder.alloca(LLVM::Array(value_type, 1))
+          ptr = @builder.gep(argv, [LLVM::Int32.from_i(0), LLVM::Int32.from_i(0)])
+          @builder.store(splat_value, ptr)
+          argv_ptr = @builder.bit_cast(argv, LLVM::Pointer(value_type))
+          @builder.call(@rb_funcallv, hash, update_id, LLVM::Int32.from_i(1), argv_ptr)
+        end
+
+        # Add each explicit keyword argument
         keyword_args.each do |key_name, value_inst|
           # Convert key name to Ruby Symbol
           key_str_ptr = @builder.global_string_pointer(key_name.to_s)
@@ -4309,37 +4501,108 @@ module Konpeito
         method_ptr = @builder.global_string_pointer(inst.method_name)
         method_id = @builder.call(@rb_intern, method_ptr)
 
-        # Prepare arguments array (for methods like upto/downto that take args)
-        argc = LLVM::Int32.from_i(inst.args.size)
+        # Build keyword arguments hash if present
+        kwargs_hash = nil
+        if inst.has_keyword_args?
+          kwargs_hash = build_keyword_args_hash(inst.keyword_args, keyword_splat: inst.keyword_splat)
+        end
 
-        if inst.args.empty?
+        # Prepare arguments array (regular args + optional kwargs hash)
+        total_args = inst.args.dup
+        total_args << kwargs_hash if kwargs_hash
+
+        argc = LLVM::Int32.from_i(total_args.size)
+
+        if total_args.empty?
           argv = LLVM::Pointer(value_type).null
         else
-          argv = @builder.alloca(LLVM::Array(value_type, inst.args.size))
-          inst.args.each_with_index do |arg, i|
-            arg_value = get_value_as_ruby(arg)
+          argv = @builder.alloca(LLVM::Array(value_type, total_args.size))
+          total_args.each_with_index do |arg, i|
+            arg_value = arg.is_a?(LLVM::Value) ? arg : get_value_as_ruby(arg)
             ptr = @builder.gep(argv, [LLVM::Int32.from_i(0), LLVM::Int32.from_i(i)])
             @builder.store(arg_value, ptr)
           end
           argv = @builder.bit_cast(argv, LLVM::Pointer(value_type))
         end
 
-        # Create capture struct for closure variables
+        # Create capture struct for closure variables.
+        # Also capture outer self so @ivar access inside blocks works correctly.
         captures = inst.block.captures.select { |c| @variable_allocas[c.name] }
-        capture_data = create_capture_struct(captures)
+
+        outer_self_val = get_self_value
+        self_slot = @builder.alloca(value_type, "blk_self_slot")
+        @builder.store(outer_self_val, self_slot)
+        @variable_allocas[BLOCK_SELF_CAPTURE] = self_slot
+        self_capture = HIR::Capture.new(name: BLOCK_SELF_CAPTURE, type: nil)
+        all_captures = [self_capture] + captures
 
         # Collect type info for captured variables
-        capture_types = {}
+        capture_types = { BLOCK_SELF_CAPTURE => :value }
         captures.each do |capture|
           capture_types[capture.name] = @variable_types[capture.name] || :value
         end
 
-        # Generate block callback function
-        block_func = generate_block_callback(inst.block, inst.method_name, captures, capture_types)
+        # Determine capture strategy.
+        #
+        # - Builtin block iterators (each, times, map, etc.) call the block inline
+        #   before returning, so the stack remains alive and pointer-to-alloca is safe.
+        #   These arrive via generate_block_iterator_call with a non-nil `builtin`.
+        #
+        # - Compiled user functions that use `yield` call blocks inline → pointer-to-alloca safe,
+        #   and write-back through captured variable allocas works correctly.
+        #
+        # - Compiled user functions with a `&blk` parameter (block: true in HIR::Param) STORE the
+        #   block as a Proc (e.g. Button#on_click stores the block in @click_handler). The stack
+        #   frame of the caller will be gone when the proc is eventually called. These MUST use
+        #   escape-cells to avoid dangling-pointer segfaults.
+        #
+        # - External / unknown methods (not in the builtin table and not compiled by Konpeito)
+        #   may also store the block. Use escape-cells for safety.
+        #
+        # Additionally, when we are already inside a block callback (@in_block_callback),
+        # the outer callback's stack will also be freed before any nested proc runs, so
+        # escape-cells is required there too.
+        hir_target = @hir_functions[inst.method_name.to_s]
+        target_stores_block = hir_target&.params&.any? { |p| p.block }
+        is_external_method = builtin.nil? && @functions[inst.method_name].nil?
+        use_escape_cells = target_stores_block || is_external_method || @in_block_callback
+
+        if use_escape_cells
+          esc_ary = @builder.call(@rb_ary_new_capa, LLVM::Int64.from_i(all_captures.size), "blk_esc_ary")
+          all_captures.each do |cap|
+            val = if @variable_allocas[cap.name]
+                    @builder.load2(value_type, @variable_allocas[cap.name], "blk_esc_#{cap.name}")
+                  else
+                    @qnil
+                  end
+            @builder.call(@rb_ary_push, esc_ary, val)
+          end
 
-        # Call rb_block_call with capture data
-        result = @builder.call(@rb_block_call,
-          receiver, method_id, argc, argv, block_func, capture_data)
+          block_func = generate_block_callback(inst.block, inst.method_name, all_captures, capture_types,
+                                               escape_cells_mode: true)
+          if kwargs_hash
+            rb_pass_keywords = LLVM::Int32.from_i(1)
+            result = @builder.call(@rb_block_call_kw,
+              receiver, method_id, argc, argv, block_func, esc_ary, rb_pass_keywords)
+          else
+            result = @builder.call(@rb_block_call,
+              receiver, method_id, argc, argv, block_func, esc_ary)
+          end
+        else
+          # Pointer-to-alloca mode: captures are stored as VALUE* pointers in a struct.
+          # The callback reads/writes through those pointers, so mutations propagate back.
+          capture_data = create_capture_struct(all_captures)
+          block_func = generate_block_callback(inst.block, inst.method_name, all_captures, capture_types,
+                                               escape_cells_mode: false)
+          if kwargs_hash
+            rb_pass_keywords = LLVM::Int32.from_i(1)
+            result = @builder.call(@rb_block_call_kw,
+              receiver, method_id, argc, argv, block_func, capture_data, rb_pass_keywords)
+          else
+            result = @builder.call(@rb_block_call,
+              receiver, method_id, argc, argv, block_func, capture_data)
+          end
+        end
 
         result
       end
@@ -4395,6 +4658,7 @@ module Konpeito
         saved_types = @variable_types.dup
         saved_allocas = @variable_allocas.dup
         saved_in_block_callback = @in_block_callback
+        saved_block_callback_self = @block_callback_self
 
         # Create entry block for callback
         entry = callback_func.basic_blocks.append("entry")
@@ -4450,6 +4714,14 @@ module Konpeito
           end
         end
 
+        # Extract the captured outer self for @ivar access inside blocks.
+        # BLOCK_SELF_CAPTURE is always included by generate_rb_block_call.
+        @block_callback_self = nil
+        if @variable_allocas[BLOCK_SELF_CAPTURE]
+          @block_callback_self = @builder.load2(value_type,
+            @variable_allocas[BLOCK_SELF_CAPTURE], "blk_self")
+        end
+
         # Bind block parameters to yielded values
         # For single-parameter blocks, use yielded_arg directly
         # For multi-parameter blocks, check argc at runtime:
@@ -4551,6 +4823,12 @@ module Konpeito
             val = @builder.load2(value_type, param_allocas[i], param.name)
             @variables[param.name] = val
             @variable_types[param.name] = :value
+            # Register the alloca so that generate_store_local uses the correct
+            # pointer when the block body assigns to a parameter variable
+            # (e.g. `completely = true` inside an |painter, completely| block).
+            # Without this, generate_store_local creates a new alloca with the
+            # same name as the already-loaded i64 value, causing an LLVM type error.
+            @variable_allocas[param.name] = param_allocas[i]
           end
         end
 
@@ -4597,8 +4875,10 @@ module Konpeito
           # Jump from entry to first HIR block
           @builder.br(@blocks[block_def.body.first.label])
 
-          # Generate each block (instructions + terminators)
-          block_def.body.each do |hir_block|
+          # Generate each block in phi-dependency order (same as setup_function)
+          # Without sorting, nested if/else phi nodes may be placed in the wrong block
+          sorted_callback_blocks = sort_blocks_by_phi_dependencies(block_def.body)
+          sorted_callback_blocks.each do |hir_block|
             generate_block(callback_func, hir_block)
           end
 
@@ -4635,7 +4915,9 @@ module Konpeito
           result_type = :value
           last_inst = nil
           block_def.body.each do |basic_block|
+            rescue_owned = collect_rescue_owned_instructions(basic_block.instructions)
             basic_block.instructions.each do |hir_inst|
+              next if rescue_owned.include?(hir_inst.object_id)
               result = generate_instruction(hir_inst)
               last_inst = hir_inst
             end
@@ -4665,6 +4947,7 @@ module Konpeito
         @variable_types = saved_types
         @variable_allocas = saved_allocas
         @in_block_callback = saved_in_block_callback
+        @block_callback_self = saved_block_callback_self
 
         callback_func
       end
@@ -5025,33 +5308,58 @@ module Konpeito
           capture_types[cap.name] = @variable_types[cap.name]
         end
 
+        # Determine if all captures have been pre-boxed to heap cells.
+        # When ThreadNew is at function top-level, collect_thread_captured_vars finds it
+        # and pre-boxes the captures. When ThreadNew is inside a rescue callback or
+        # other nested scope, pre-boxing doesn't happen — we must use the safe value-copy
+        # protocol instead (snapshot values, no bidirectional mutation).
+        all_preboxed = !captures.empty? && captures.all? { |c| @thread_boxed_vars[c.name] }
+
         # Create thread-specific callback (different signature from fiber/proc)
-        callback_func = generate_thread_callback(block_def, captures, capture_types)
+        callback_func = generate_thread_callback(block_def, captures, capture_types, cell_protocol: all_preboxed)
 
-        # Setup captures data (pass as intptr_t, cast back in callback)
         if captures.empty?
-          captures_data = LLVM::Int64.from_i(0)
+          captures_ptr = LLVM::Pointer(LLVM::Int8).null
         else
-          ptr_type = LLVM::Pointer(value_type)
-          array_type = LLVM::Array(ptr_type, captures.size)
-          captures_array = @builder.alloca(array_type, "thread_captures")
+          declare_malloc
+          n = captures.size
 
-          captures.each_with_index do |capture, i|
-            alloca = @variable_allocas[capture.name]
-            if alloca
-              ptr = @builder.gep(captures_array, [LLVM::Int32.from_i(0), LLVM::Int32.from_i(i)])
-              @builder.store(alloca, ptr)
-            else
-              ptr = @builder.gep(captures_array, [LLVM::Int32.from_i(0), LLVM::Int32.from_i(i)])
-              @builder.store(LLVM::Pointer(value_type).null, ptr)
+          if all_preboxed
+            # Cell-pointer protocol: pass pointers to shared heap cells.
+            # Enables bidirectional mutation visibility between threads.
+            buf = @builder.call(@malloc, LLVM::Int64.from_i(n * 8), "thread_ptrbuf")
+            buf_int = @builder.ptr2int(buf, LLVM::Int64, "thread_ptrbuf_int")
+            buf_typed = @builder.int2ptr(buf_int, LLVM::Pointer(LLVM::Pointer(value_type)), "thread_ptrbuf_typed")
+
+            captures.each_with_index do |capture, i|
+              cell_ptr = @thread_boxed_vars[capture.name]
+              elem_ptr = @builder.gep2(LLVM::Pointer(value_type), buf_typed, [LLVM::Int64.from_i(i)], "tpb_elem_#{i}")
+              @builder.store(cell_ptr, elem_ptr)
             end
-          end
 
-          captures_data = @builder.ptr2int(captures_array, LLVM::Int64, "captures_int")
-        end
+            captures_ptr = buf
+          else
+            # Value-copy protocol: snapshot current VALUES into the buffer.
+            # Safe for async threads (no pointer dependency on caller's stack).
+            # No bidirectional mutation — thread gets independent copies.
+            buf_size = LLVM::Int64.from_i(n * 8)
+            raw_ptr = @builder.call(@malloc, buf_size, "thread_cap_buf")
+            raw_int = @builder.ptr2int(raw_ptr, LLVM::Int64, "thread_cap_int")
+            val_arr_ptr = @builder.int2ptr(raw_int, LLVM::Pointer(value_type), "thread_cap_vals")
+
+            captures.each_with_index do |capture, i|
+              val = if @variable_allocas[capture.name]
+                      @builder.load2(value_type, @variable_allocas[capture.name], "tc_#{capture.name}")
+                    else
+                      @qnil
+                    end
+              elem_ptr = @builder.gep2(value_type, val_arr_ptr, [LLVM::Int64.from_i(i)], "tc_elem_#{i}")
+              @builder.store(val, elem_ptr)
+            end
 
-        # Call rb_thread_create - pass captures as intptr_t (void* compatible)
-        captures_ptr = @builder.int2ptr(captures_data, LLVM::Pointer(LLVM::Int8), "captures_ptr")
+            captures_ptr = raw_ptr
+          end
+        end
         result = @builder.call(@rb_thread_create, callback_func, captures_ptr)
 
         if inst.result_var
@@ -5063,7 +5371,9 @@ module Konpeito
       end
 
       # Generate thread callback function with correct signature: VALUE func(void*)
-      def generate_thread_callback(block_def, captures = [], capture_types = {})
+      # cell_protocol: true = buffer contains cell POINTERS (shared heap cells, bidirectional)
+      #                false = buffer contains VALUE copies (snapshot, safe for async)
+      def generate_thread_callback(block_def, captures = [], capture_types = {}, cell_protocol: false)
         return nil unless block_def
 
         # Create a unique name for the callback
@@ -5082,38 +5392,63 @@ module Konpeito
         saved_types = @variable_types.dup
         saved_allocas = @variable_allocas.dup
         saved_current_function = @current_function
+        saved_in_block_callback = @in_block_callback
+        saved_block_callback_self = @block_callback_self
+        saved_in_thread_callback = @in_thread_callback
+        saved_thread_boxed_vars = @thread_boxed_vars
 
         # Create entry block for callback
         entry = callback_func.basic_blocks.append("entry")
         @builder.position_at_end(entry)
         @current_function = callback_func
 
-        # Reset variable tracking for callback scope
+        # Reset variable tracking for callback scope.
+        # Thread callbacks are independent execution contexts — reset block callback state.
         @variables = {}
         @variable_types = {}
         @variable_allocas = {}
+        @in_block_callback = false
+        @block_callback_self = nil
+        @in_thread_callback = true
 
-        # Setup captured variable access through void* arg
         unless captures.empty?
-          # The void* arg contains captures array pointer (cast from intptr_t)
-          ptr_type = LLVM::Pointer(value_type)
-          array_type = LLVM::Array(ptr_type, captures.size)
+          declare_free
 
-          # Convert void* (i8*) to intptr_t, then to the array pointer type
-          arg_int = @builder.ptr2int(callback_func.params[0], LLVM::Int64, "arg_int")
-          captures_ptr = @builder.int2ptr(arg_int, LLVM::Pointer(array_type), "captures_ptr")
+          if cell_protocol
+            # Cell-pointer protocol: buffer contains pointers to shared heap cells.
+            # Reads/writes through cell pointers are visible to both sides.
+            arg_int = @builder.ptr2int(callback_func.params[0], LLVM::Int64, "tc_arg_int")
+            buf_typed = @builder.int2ptr(arg_int, LLVM::Pointer(LLVM::Pointer(value_type)), "tc_buf_typed")
 
-          captures.each_with_index do |capture, i|
-            # Get pointer to the pointer (VALUE**)
-            elem_ptr_ptr = @builder.gep2(array_type, captures_ptr,
-              [LLVM::Int32.from_i(0), LLVM::Int32.from_i(i)], "cap_#{capture.name}_ptr_ptr")
-            # Load the pointer to the variable (VALUE*)
-            elem_ptr = @builder.load2(ptr_type, elem_ptr_ptr, "cap_#{capture.name}_ptr")
+            captures.each_with_index do |capture, i|
+              elem_ptr = @builder.gep2(LLVM::Pointer(value_type), buf_typed, [LLVM::Int64.from_i(i)], "tc_bp_#{i}")
+              cell_ptr = @builder.load2(LLVM::Pointer(value_type), elem_ptr, "tc_cell_#{capture.name}")
+              @variable_allocas[capture.name] = cell_ptr
+              @variable_types[capture.name] = capture_types[capture.name] || :value
+              val = @builder.load2(value_type, cell_ptr, "tc_#{capture.name}_val")
+              @variables[capture.name] = val
+            end
 
-            # Store in variable_allocas so LoadLocal/StoreLocal can use it
-            @variable_allocas[capture.name] = elem_ptr
-            # Preserve the original type from outer scope
-            @variable_types[capture.name] = capture_types[capture.name] || :value
+            # Free the pointer buffer (NOT the cells — they're shared)
+            @builder.call(@free, callback_func.params[0])
+          else
+            # Value-copy protocol: buffer contains snapshot VALUE copies.
+            # Load each VALUE into a local alloca, then free the buffer.
+            arg_int = @builder.ptr2int(callback_func.params[0], LLVM::Int64, "tc_arg_int")
+            val_arr_ptr = @builder.int2ptr(arg_int, LLVM::Pointer(value_type), "tc_vals")
+
+            captures.each_with_index do |capture, i|
+              elem_ptr = @builder.gep2(value_type, val_arr_ptr, [LLVM::Int64.from_i(i)], "tc_elem_#{i}")
+              val = @builder.load2(value_type, elem_ptr, "tc_#{capture.name}_val")
+              alloca = @builder.alloca(value_type, "tc_#{capture.name}")
+              @builder.store(val, alloca)
+              @variable_allocas[capture.name] = alloca
+              @variable_types[capture.name] = capture_types[capture.name] || :value
+              @variables[capture.name] = val
+            end
+
+            # Free the malloc'd buffer
+            @builder.call(@free, callback_func.params[0])
           end
         end
 
@@ -5151,8 +5486,9 @@ module Konpeito
           # Jump from entry to first HIR block
           @builder.br(@blocks[block_def.body.first.label])
 
-          # Generate each block (instructions + terminators)
-          block_def.body.each do |hir_block|
+          # Generate each block in phi-dependency order (same as setup_function)
+          sorted_callback_blocks = sort_blocks_by_phi_dependencies(block_def.body)
+          sorted_callback_blocks.each do |hir_block|
             generate_block(callback_func, hir_block)
           end
 
@@ -5177,7 +5513,9 @@ module Konpeito
           result_type = :value
           last_inst = nil
           block_def.body.each do |basic_block|
+            rescue_owned = collect_rescue_owned_instructions(basic_block.instructions)
             basic_block.instructions.each do |hir_inst|
+              next if rescue_owned.include?(hir_inst.object_id)
               result = generate_instruction(hir_inst)
               last_inst = hir_inst
             end
@@ -5203,6 +5541,10 @@ module Konpeito
         @variable_types = saved_types
         @variable_allocas = saved_allocas
         @current_function = saved_current_function
+        @in_block_callback = saved_in_block_callback
+        @block_callback_self = saved_block_callback_self
+        @in_thread_callback = saved_in_thread_callback
+        @thread_boxed_vars = saved_thread_boxed_vars
 
         callback_func
       end
@@ -5428,7 +5770,9 @@ module Konpeito
         last_inst = nil
 
         block_def.body.each do |basic_block|
+          rescue_owned = collect_rescue_owned_instructions(basic_block.instructions)
           basic_block.instructions.each do |hir_inst|
+            next if rescue_owned.include?(hir_inst.object_id)
             result = generate_instruction(hir_inst) || result
             last_inst = hir_inst
           end
@@ -6043,6 +6387,8 @@ module Konpeito
           @builder.fmul(left, right)
         when "/"
           @builder.fdiv(left, right)
+        when "%"
+          @builder.frem(left, right)
         else
           raise "Unknown float operation: #{inst.method_name}"
         end
@@ -6212,6 +6558,88 @@ module Konpeito
         end
       end
 
+      # Try optimized String method calls (String#[] 2-arg, String#split with literal)
+      def try_optimized_string_call(inst, receiver_type)
+        resolved_type = receiver_type.is_a?(TypeChecker::TypeVar) ? resolve_type_var(receiver_type) : receiver_type
+        is_string = resolved_type == TypeChecker::Types::STRING ||
+          (resolved_type.is_a?(TypeChecker::Types::ClassInstance) && resolved_type.name == :String)
+        return nil unless is_string
+
+        case inst.method_name
+        when "[]"
+          # String#[start, length] → rb_str_substr(str, start, length)
+          return nil unless inst.args.size == 2
+
+          receiver = get_value_as_ruby(inst.receiver)
+          start_val = get_value_as_ruby(inst.args[0])
+          start_long = @builder.call(@rb_num2long, start_val)
+          len_val = get_value_as_ruby(inst.args[1])
+          len_long = @builder.call(@rb_num2long, len_val)
+
+          rb_str_substr = @mod.functions["rb_str_substr"] || @mod.functions.add(
+            "rb_str_substr", [value_type, LLVM::Int64, LLVM::Int64], value_type
+          )
+          @builder.call(rb_str_substr, receiver, start_long, len_long)
+        when "split"
+          # String#split(separator) → rb_str_split(str, separator_cstr)
+          return nil unless inst.args.size == 1
+
+          receiver = get_value_as_ruby(inst.receiver)
+
+          # rb_str_split takes (VALUE str, const char *sep)
+          rb_str_split = @mod.functions["rb_str_split"] || @mod.functions.add(
+            "rb_str_split", [value_type, LLVM::Pointer(LLVM::Int8)], value_type
+          )
+
+          if inst.args[0].is_a?(HIR::StringLit)
+            # Literal separator: use compile-time C string directly
+            sep_ptr = @builder.global_string_pointer(inst.args[0].value)
+          else
+            # Dynamic separator: convert to C string
+            sep_value = get_value_as_ruby(inst.args[0])
+            sep_value_ptr = @builder.alloca(LLVM::Int64, "split_sep_ptr")
+            @builder.store(sep_value, sep_value_ptr)
+            sep_ptr = @builder.call(@rb_string_value_cstr, sep_value_ptr, "split_sep_cstr")
+          end
+          @builder.call(rb_str_split, receiver, sep_ptr)
+        end
+      end
+
+      # Inline String method constants
+      INLINE_STRING_METHODS = %w[empty?].freeze
+
+      # Check if a method call can use inline String optimization
+      def can_inline_string_method?(inst)
+        return false unless inst.args.empty?
+        return false unless INLINE_STRING_METHODS.include?(inst.method_name)
+
+        receiver_type = get_type(inst.receiver)
+        receiver_type = resolve_type_var(receiver_type) if receiver_type.is_a?(TypeChecker::TypeVar)
+        receiver_type == TypeChecker::Types::STRING ||
+          (receiver_type.is_a?(TypeChecker::Types::ClassInstance) && receiver_type.name == :String)
+      end
+
+      # Generate inline String method
+      def generate_inline_string_method(inst)
+        receiver = get_value_as_ruby(inst.receiver)
+
+        case inst.method_name
+        when "empty?"
+          # rb_str_strlen returns long (byte count), avoids rb_funcallv method lookup
+          rb_str_strlen = @mod.functions["rb_str_strlen"] || @mod.functions.add(
+            "rb_str_strlen", [value_type], LLVM::Int64
+          )
+          str_len = @builder.call(rb_str_strlen, receiver, "str_len")
+          is_empty = @builder.icmp(:eq, str_len, LLVM::Int64.from_i(0), "is_empty")
+          result = @builder.select(is_empty, @qtrue, @qfalse)
+          if inst.result_var
+            @variables[inst.result_var] = result
+            @variable_types[inst.result_var] = :value
+          end
+          result
+        end
+      end
+
       # Generate Array#[] using rb_ary_entry
       def generate_array_index_get(inst)
         receiver = get_value_as_ruby(inst.receiver)
@@ -6743,7 +7171,7 @@ module Konpeito
         kw_info = @keyword_param_functions[func_name.to_s] || @keyword_param_functions[func_name.to_sym]
         if kw_info
           if inst.has_keyword_args?
-            kwargs_hash = build_keyword_args_hash(inst.keyword_args)
+            kwargs_hash = build_keyword_args_hash(inst.keyword_args, keyword_splat: inst.keyword_splat)
             call_args << kwargs_hash
           else
             # No keyword args provided - pass an empty hash
@@ -6783,7 +7211,7 @@ module Konpeito
         # Collect all arguments (regular + keyword hash if present)
         all_args = inst.args.map { |arg| get_value_as_ruby(arg) }
         if inst.has_keyword_args?
-          kwargs_hash = build_keyword_args_hash(inst.keyword_args)
+          kwargs_hash = build_keyword_args_hash(inst.keyword_args, keyword_splat: inst.keyword_splat)
           all_args << kwargs_hash
         end
 
@@ -6941,23 +7369,60 @@ module Konpeito
           end
           result = scope
         else
-          # Unqualified constant - search current class/module first, then Object
+          # Unqualified constant — follow Ruby's nesting lookup:
+          # 1. owner_class (e.g. RanmaFrame) — check with rb_const_defined_at
+          # 2. owner_module (e.g. Kumiki) if constant not directly in class
+          # 3. rb_cObject as final fallback
+          #
+          # Uses `select` to pick the lookup scope without creating new basic blocks
+          # (creating blocks mid-HIR-block corrupts phi node predecessor relationships).
           const_name = parts.first
-          owner_class = @current_hir_func&.owner_class || @current_hir_func&.owner_module
+          const_name_ptr = @builder.global_string_pointer(const_name)
+          const_id = @builder.call(@rb_intern, const_name_ptr)
+          rb_cobject_val = @builder.load2(value_type, @rb_cObject, "rb_cObject")
+
+          owner_class  = @current_hir_func&.owner_class
+          owner_module = @current_hir_func&.owner_module
+
           if owner_class
-            # Look up constant in the owning class/module
-            owner_ptr = @builder.global_string_pointer(owner_class)
-            owner_id = @builder.call(@rb_intern, owner_ptr)
-            rb_cobject_val = @builder.load2(value_type, @rb_cObject, "rb_cObject")
-            owner_value = @builder.call(@rb_const_get, rb_cobject_val, owner_id)
-            const_name_ptr = @builder.global_string_pointer(const_name)
-            const_id = @builder.call(@rb_intern, const_name_ptr)
-            result = @builder.call(@rb_const_get, owner_value, const_id)
+            # Resolve the owner class value (qualified by module if present)
+            if owner_module
+              owner_mod_ptr = @builder.global_string_pointer(owner_module)
+              owner_mod_id  = @builder.call(@rb_intern, owner_mod_ptr)
+              owner_mod_val = @builder.call(@rb_const_get, rb_cobject_val, owner_mod_id)
+              owner_cls_ptr = @builder.global_string_pointer(owner_class)
+              owner_cls_id  = @builder.call(@rb_intern, owner_cls_ptr)
+              owner_cls_val = @builder.call(@rb_const_get, owner_mod_val, owner_cls_id)
+            else
+              owner_cls_ptr = @builder.global_string_pointer(owner_class)
+              owner_cls_id  = @builder.call(@rb_intern, owner_cls_ptr)
+              owner_cls_val = @builder.call(@rb_const_get, rb_cobject_val, owner_cls_id)
+              owner_mod_val = rb_cobject_val
+            end
+
+            if owner_module
+              # Use rb_const_defined_at to select the scope without branching:
+              # if constant is defined directly in owner_class → look in owner_class
+              # otherwise                                       → look in owner_module
+              @rb_const_defined_at ||= @mod.functions.add("rb_const_defined_at",
+                [value_type, id_type], LLVM::Int32)
+              defined_in_cls = @builder.call(@rb_const_defined_at, owner_cls_val, const_id, "def_in_cls")
+              is_in_cls = @builder.icmp(:ne, defined_in_cls, LLVM::Int32.from_i(0))
+              # Select lookup scope: class if defined there, module otherwise
+              lookup_scope = @builder.select(is_in_cls, owner_cls_val, owner_mod_val, "const_scope")
+              result = @builder.call(@rb_const_get, lookup_scope, const_id, "const_val")
+            else
+              result = @builder.call(@rb_const_get, owner_cls_val, const_id)
+            end
+
+          elsif owner_module
+            # Only a module context (no class), look in module
+            owner_mod_ptr = @builder.global_string_pointer(owner_module)
+            owner_mod_id  = @builder.call(@rb_intern, owner_mod_ptr)
+            owner_mod_val = @builder.call(@rb_const_get, rb_cobject_val, owner_mod_id)
+            result = @builder.call(@rb_const_get, owner_mod_val, const_id)
           else
             # Top-level constant
-            const_name_ptr = @builder.global_string_pointer(const_name)
-            const_id = @builder.call(@rb_intern, const_name_ptr)
-            rb_cobject_val = @builder.load2(value_type, @rb_cObject, "rb_cObject")
             result = @builder.call(@rb_const_get, rb_cobject_val, const_id)
           end
         end
@@ -7285,7 +7750,57 @@ module Konpeito
         # Generate try callback function
         @rescue_counter ||= 0
         @rescue_counter += 1
-        try_func = generate_rescue_try_callback(inst.try_blocks, @rescue_counter)
+
+        # Rescue callbacks run as separate C functions that only receive a single VALUE
+        # as data.  Any local variables (method params, locals) in @variable_allocas are
+        # NOT accessible inside those callbacks unless we pack them into an escape array.
+        # This applies to ALL contexts — not just thread/block callbacks — because the
+        # rescue callback is always a separate LLVM function.
+        #
+        # Native pointer types (NativeArray, NativeClass, ByteBuffer, etc.) cannot be
+        # stored in a Ruby Array, so we skip them.  Unboxed types (:i64, :double) are
+        # boxed before pushing and unboxed after unpacking.
+        native_pointer_types = %i[native_array native_class byte_buffer byte_slice
+                                  native_string slice_int64 slice_float64
+                                  static_array native_hash]
+        escapable_vars = @variable_allocas.keys.select do |vname|
+          !native_pointer_types.include?(@variable_types[vname])
+        end
+
+        needs_escape = !escapable_vars.empty?
+        escape_var_names = nil
+        rescue_data = nil
+
+        if needs_escape
+          escape_var_names = escapable_vars
+          n = 1 + escape_var_names.size  # index-0 = self
+          rescue_esc_ary = @builder.call(@rb_ary_new_capa, LLVM::Int64.from_i(n), "rescue_esc_ary")
+          # Push self (index 0)
+          actual_self = @block_callback_self || get_self_value
+          @builder.call(@rb_ary_push, rescue_esc_ary, actual_self)
+          # Push captured variables (index 1..n), boxing unboxed types
+          escape_var_names.each do |vname|
+            var_type = @variable_types[vname] || :value
+            case var_type
+            when :double
+              raw = @builder.load2(LLVM::Double, @variable_allocas[vname], "esc_load_#{vname}")
+              val = @builder.call(@rb_float_new, raw, "esc_box_#{vname}")
+            when :i64, :i8
+              raw = @builder.load2(LLVM::Int64, @variable_allocas[vname], "esc_load_#{vname}")
+              val = @builder.call(@rb_int2inum, raw, "esc_box_#{vname}")
+            else
+              val = @builder.load2(value_type, @variable_allocas[vname], "esc_load_#{vname}")
+            end
+            @builder.call(@rb_ary_push, rescue_esc_ary, val)
+          end
+          rescue_data = rescue_esc_ary
+        else
+          rescue_data = get_self_value
+        end
+
+        try_func = generate_rescue_try_callback(inst.try_blocks, @rescue_counter,
+                                                try_hir_blocks: inst.try_hir_blocks,
+                                                escape_var_names: escape_var_names)
 
         # Collect exception classes
         exception_classes = []
@@ -7299,18 +7814,18 @@ module Konpeito
 
         has_else = inst.else_blocks && !inst.else_blocks.empty?
 
-        # If else blocks present, use a global flag to detect if rescue ran
-        # A module-level global i32 is set to 1 by the rescue callback
         if has_else
           flag_global = @mod.globals.add(LLVM::Int32, "rescue_else_flag_#{@rescue_counter}")
           flag_global.initializer = LLVM::Int32.from_i(0)
           @builder.store(LLVM::Int32.from_i(0), flag_global)
 
-          rescue_func = generate_rescue_handler_with_global_flag_callback(inst.rescue_clauses, @rescue_counter, flag_global)
-          args = [try_func, @qnil, rescue_func, @qnil]
+          rescue_func = generate_rescue_handler_with_global_flag_callback(inst.rescue_clauses, @rescue_counter, flag_global,
+                                                                          escape_var_names: escape_var_names)
+          args = [try_func, rescue_data, rescue_func, rescue_data]
         else
-          rescue_func = generate_rescue_handler_callback(inst.rescue_clauses, @rescue_counter)
-          args = [try_func, @qnil, rescue_func, @qnil]
+          rescue_func = generate_rescue_handler_callback(inst.rescue_clauses, @rescue_counter,
+                                                         escape_var_names: escape_var_names)
+          args = [try_func, rescue_data, rescue_func, rescue_data]
         end
 
         args.concat(exception_classes)
@@ -7320,6 +7835,19 @@ module Konpeito
         rescue2_func = declare_rb_rescue2_variadic(exception_classes.size)
         result = @builder.call(rescue2_func, *args)
 
+        # Write-back: after rb_rescue2 returns, the escape array contains updated values
+        # from try/rescue callbacks (written via rb_ary_store in generate_store_local).
+        # Copy them back to the outer function's allocas.
+        if needs_escape && escape_var_names
+          escape_var_names.each_with_index do |vname, idx|
+            next unless @variable_allocas[vname]
+            val = @builder.call(@rb_ary_entry, rescue_data, LLVM::Int64.from_i(idx + 1), "wb_#{vname}")
+            @builder.store(val, @variable_allocas[vname])
+            @variables[vname] = val
+            @variable_types[vname] = :value
+          end
+        end
+
         # Execute else blocks if no exception was raised
         if has_else
           flag_val = @builder.load2(LLVM::Int32, flag_global, "flag_val")
@@ -7396,53 +7924,127 @@ module Konpeito
       end
 
       # Generate try callback function: VALUE func(VALUE data)
-      def generate_rescue_try_callback(try_instructions, counter)
+      # When escape_var_names is given, params[0] is a Ruby Array [self, var0, var1, ...].
+      def generate_rescue_try_callback(try_instructions, counter, try_hir_blocks: nil, escape_var_names: nil)
         callback_name = "rescue_try_#{counter}"
 
-        # VALUE func(VALUE data)
+        # VALUE func(VALUE data)  — data (params[0]) = self or escape array
         callback_func = @mod.functions.add(callback_name, [value_type], value_type)
 
         # Save current builder state
-        saved_block = @builder.insert_block
-        saved_vars = @variables.dup
-        saved_types = @variable_types.dup
-        saved_allocas = @variable_allocas.dup
-
-        # Create entry block for callback
-        entry = callback_func.basic_blocks.append("entry")
-        @builder.position_at_end(entry)
+        saved_block    = @builder.insert_block
+        saved_vars     = @variables.dup
+        saved_types    = @variable_types.dup
+        saved_allocas  = @variable_allocas.dup
+        saved_cur_func = @current_function
+        saved_return_blocks = @return_blocks
+        saved_block_callback_self = @block_callback_self
+        saved_rescue_escape_array = @rescue_escape_array
+        saved_rescue_escape_indices = @rescue_escape_indices
 
         # Reset variable tracking for callback scope
         @variables = {}
         @variable_types = {}
         @variable_allocas = {}
 
-        result = @qnil
+        if try_hir_blocks && !try_hir_blocks.empty?
+          # Structured try body: process HIR BasicBlock list (handles control flow inside try).
+          if escape_var_names
+            # In escape mode, create a dedicated entry block FIRST (LLVM entry = first BB).
+            # It unpacks self + local vars from the escape array, then branches to the first HIR block.
+            escape_entry_bb = callback_func.basic_blocks.append("rescue_escape_entry")
+          else
+            # Normal mode: params[0] is self.
+            @block_callback_self = callback_func.params[0]
+          end
 
-        # Generate try instructions
-        if try_instructions && !try_instructions.empty?
-          try_instructions.each do |inst|
-            result = generate_instruction(inst)
+          # Pre-create all LLVM basic blocks so forward references resolve.
+          try_hir_blocks.each do |hb|
+            llvm_bb = callback_func.basic_blocks.append(hb.label)
+            @blocks[hb.label] = llvm_bb
+          end
+          # Set @current_function so generate_store_local creates allocas in the callback.
+          @current_function = callback_func
+          # Populate @return_blocks so generate_phi skips Return-predecessor entries.
+          @return_blocks = Set.new
+          try_hir_blocks.each do |hb|
+            @return_blocks << hb.label if hb.terminator.is_a?(HIR::Return)
+          end
+
+          if escape_var_names
+            # Fill the escape-entry block: unpack array → allocas, then branch to first HIR block.
+            @builder.position_at_end(escape_entry_bb)
+            escape_ary = callback_func.params[0]
+            self_val = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(0), "rescue_esc_self")
+            @block_callback_self = self_val
+            escape_var_names.each_with_index do |vname, i|
+              val   = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(i + 1), "rescue_esc_#{vname}")
+              alloca = @builder.alloca(value_type, "rescue_esc_alloca_#{vname}")
+              @builder.store(val, alloca)
+              @variable_allocas[vname] = alloca
+              @variable_types[vname]   = :value
+            end
+            # Set escape write-back info so StoreLocal writes to escape array
+            @rescue_escape_array = escape_ary
+            @rescue_escape_indices = {}
+            escape_var_names.each_with_index { |vname, i| @rescue_escape_indices[vname] = i + 1 }
+            @builder.br(@blocks[try_hir_blocks.first.label])
+          end
+
+          sorted = sort_blocks_by_phi_dependencies(try_hir_blocks)
+          sorted.each { |hb| generate_block(callback_func, hb) }
+        else
+          # Flat try body: original behaviour (no control flow in try body).
+          entry = callback_func.basic_blocks.append("entry")
+          @builder.position_at_end(entry)
+
+          if escape_var_names
+            escape_ary = callback_func.params[0]
+            self_val = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(0), "rescue_esc_self")
+            @block_callback_self = self_val
+            escape_var_names.each_with_index do |vname, i|
+              val   = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(i + 1), "rescue_esc_#{vname}")
+              alloca = @builder.alloca(value_type, "rescue_esc_alloca_#{vname}")
+              @builder.store(val, alloca)
+              @variable_allocas[vname] = alloca
+              @variable_types[vname]   = :value
+            end
+            # Set escape write-back info so StoreLocal writes to escape array
+            @rescue_escape_array = escape_ary
+            @rescue_escape_indices = {}
+            escape_var_names.each_with_index { |vname, i| @rescue_escape_indices[vname] = i + 1 }
+          else
+            @block_callback_self = callback_func.params[0]
+          end
+
+          result = @qnil
+          if try_instructions && !try_instructions.empty?
+            try_instructions.each { |inst| result = generate_instruction(inst) }
           end
-        end
 
-        # Return the result (or Qnil)
-        @builder.ret(result || @qnil)
+          @builder.ret(result || @qnil)
+        end
 
         # Restore builder state
         @builder.position_at_end(saved_block) if saved_block
-        @variables = saved_vars
-        @variable_types = saved_types
+        @variables       = saved_vars
+        @variable_types  = saved_types
         @variable_allocas = saved_allocas
+        @current_function = saved_cur_func
+        @return_blocks    = saved_return_blocks
+        @block_callback_self = saved_block_callback_self
+        @rescue_escape_array = saved_rescue_escape_array
+        @rescue_escape_indices = saved_rescue_escape_indices
 
         callback_func
       end
 
-      # Generate rescue handler callback: VALUE func(VALUE exception, VALUE data)
-      def generate_rescue_handler_callback(rescue_clauses, counter)
+      # Generate rescue handler callback: VALUE func(VALUE data2, VALUE exception)
+      # data2 (params[0]) = self or escape array (when escape_var_names is given)
+      def generate_rescue_handler_callback(rescue_clauses, counter, escape_var_names: nil)
         callback_name = "rescue_handler_#{counter}"
 
-        # VALUE func(VALUE exception, VALUE data)
+        # VALUE func(VALUE data2, VALUE exception)
         callback_func = @mod.functions.add(callback_name, [value_type, value_type], value_type)
 
         # Save current builder state
@@ -7450,6 +8052,12 @@ module Konpeito
         saved_vars = @variables.dup
         saved_types = @variable_types.dup
         saved_allocas = @variable_allocas.dup
+        saved_block_callback_self = @block_callback_self
+        saved_rescue_escape_array = @rescue_escape_array
+        saved_rescue_escape_indices = @rescue_escape_indices
+
+        # In normal mode: params[0] = self. In escape mode, set @block_callback_self after unpacking.
+        @block_callback_self = callback_func.params[0] unless escape_var_names
 
         # Create entry block for callback
         entry = callback_func.basic_blocks.append("entry")
@@ -7460,10 +8068,30 @@ module Konpeito
         @variable_types = {}
         @variable_allocas = {}
 
-        # Get exception parameter
         # CRuby rescue callback: (VALUE data2, VALUE exception)
         exception_val = callback_func.params[1]
 
+        # In escape mode: unpack self and local variables from the escape array (params[0]).
+        # escape_allocas_map holds the allocas so we can restore them after each body-block reset.
+        escape_allocas_map = {}
+        if escape_var_names
+          escape_ary = callback_func.params[0]
+          self_val = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(0), "rescue_esc_self")
+          @block_callback_self = self_val
+          escape_var_names.each_with_index do |vname, i|
+            val   = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(i + 1), "rescue_esc_#{vname}")
+            alloca = @builder.alloca(value_type, "rescue_esc_alloca_#{vname}")
+            @builder.store(val, alloca)
+            @variable_allocas[vname] = alloca
+            @variable_types[vname]   = :value
+            escape_allocas_map[vname] = alloca
+          end
+          # Set escape write-back info so StoreLocal writes to escape array
+          @rescue_escape_array = escape_ary
+          @rescue_escape_indices = {}
+          escape_var_names.each_with_index { |vname, i| @rescue_escape_indices[vname] = i + 1 }
+        end
+
         # Match exception class to find correct handler
         if rescue_clauses && !rescue_clauses.empty?
           # Create blocks for each rescue clause and a fallback
@@ -7523,6 +8151,12 @@ module Konpeito
             @variable_types = {}
             @variable_allocas = {}
 
+            # In escape mode, restore captured variable allocas (created in entry block).
+            escape_allocas_map.each do |vname, alloca|
+              @variable_allocas[vname] = alloca
+              @variable_types[vname]   = :value
+            end
+
             # Bind exception variable if specified
             if clause.exception_var
               @variables[clause.exception_var] = exception_val
@@ -7559,20 +8193,30 @@ module Konpeito
         @variables = saved_vars
         @variable_types = saved_types
         @variable_allocas = saved_allocas
+        @block_callback_self = saved_block_callback_self
+        @rescue_escape_array = saved_rescue_escape_array
+        @rescue_escape_indices = saved_rescue_escape_indices
 
         callback_func
       end
 
       # Generate rescue handler callback that sets a global flag when called
       # The flag_global is an LLVM global variable that is set to 1 when rescue is invoked
-      def generate_rescue_handler_with_global_flag_callback(rescue_clauses, counter, flag_global)
+      def generate_rescue_handler_with_global_flag_callback(rescue_clauses, counter, flag_global, escape_var_names: nil)
         callback_name = "rescue_handler_gflag_#{counter}"
+        # VALUE func(VALUE data2, VALUE exception) — data2 (params[0]) = self or escape array
         callback_func = @mod.functions.add(callback_name, [value_type, value_type], value_type)
 
         saved_block = @builder.insert_block
         saved_vars = @variables.dup
         saved_types = @variable_types.dup
         saved_allocas = @variable_allocas.dup
+        saved_block_callback_self = @block_callback_self
+        saved_rescue_escape_array = @rescue_escape_array
+        saved_rescue_escape_indices = @rescue_escape_indices
+
+        # In normal mode: params[0] = self. In escape mode, set @block_callback_self after unpacking.
+        @block_callback_self = callback_func.params[0] unless escape_var_names
 
         entry = callback_func.basic_blocks.append("entry")
         @builder.position_at_end(entry)
@@ -7587,6 +8231,26 @@ module Konpeito
         # Set the global flag to 1 (rescue was invoked)
         @builder.store(LLVM::Int32.from_i(1), flag_global)
 
+        # In escape mode: unpack self and local variables from the escape array.
+        escape_allocas_map = {}
+        if escape_var_names
+          escape_ary = callback_func.params[0]
+          self_val = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(0), "rescue_esc_self")
+          @block_callback_self = self_val
+          escape_var_names.each_with_index do |vname, i|
+            val   = @builder.call(@rb_ary_entry, escape_ary, LLVM::Int64.from_i(i + 1), "rescue_esc_#{vname}")
+            alloca = @builder.alloca(value_type, "rescue_esc_alloca_#{vname}")
+            @builder.store(val, alloca)
+            @variable_allocas[vname] = alloca
+            @variable_types[vname]   = :value
+            escape_allocas_map[vname] = alloca
+          end
+          # Set escape write-back info so StoreLocal writes to escape array
+          @rescue_escape_array = escape_ary
+          @rescue_escape_indices = {}
+          escape_var_names.each_with_index { |vname, i| @rescue_escape_indices[vname] = i + 1 }
+        end
+
         # Same rescue matching logic as generate_rescue_handler_callback
         if rescue_clauses && !rescue_clauses.empty?
           clause_blocks = rescue_clauses.map.with_index do |_, i|
@@ -7632,6 +8296,12 @@ module Konpeito
             @variable_types = {}
             @variable_allocas = {}
 
+            # In escape mode, restore captured variable allocas after the reset.
+            escape_allocas_map.each do |vname, alloca|
+              @variable_allocas[vname] = alloca
+              @variable_types[vname]   = :value
+            end
+
             if clause.exception_var
               @variables[clause.exception_var] = exception_val
               @variable_types[clause.exception_var] = :value
@@ -7661,6 +8331,9 @@ module Konpeito
         @variables = saved_vars
         @variable_types = saved_types
         @variable_allocas = saved_allocas
+        @block_callback_self = saved_block_callback_self
+        @rescue_escape_array = saved_rescue_escape_array
+        @rescue_escape_indices = saved_rescue_escape_indices
 
         callback_func
       end
@@ -7892,6 +8565,27 @@ module Konpeito
         result
       end
 
+      # Generate a CaseEqualityCheck: condition === predicate (returns VALUE Qtrue/Qfalse)
+      # Used by the new HIR-block-based case/when dispatch
+      def generate_case_equality_check(inst)
+        cond_val = get_value_as_ruby(inst.condition)
+
+        result = if inst.predicate.nil?
+          # No predicate: treat condition itself as Ruby truthy value
+          cond_val
+        else
+          pred_val = get_value_as_ruby(inst.predicate)
+          # call_case_equality returns VALUE (Qtrue or Qfalse)
+          call_case_equality(cond_val, pred_val, receiver_hir: inst.condition)
+        end
+
+        if inst.result_var
+          @variables[inst.result_var] = result
+          @variable_types[inst.result_var] = :value
+        end
+        result
+      end
+
       # Call === (case equality) on receiver with argument
       # Call case equality with optimized inline comparison for basic types
       def call_case_equality(receiver, arg, receiver_hir: nil)
@@ -7950,8 +8644,8 @@ module Konpeito
       def inline_class_case_eq(klass, arg)
         # Use rb_obj_is_kind_of(arg, klass) which returns int (0 or non-zero)
         result_int = @builder.call(@rb_obj_is_kind_of, arg, klass)
-        # Convert int to VALUE
-        is_true = @builder.icmp(:ne, result_int, LLVM::Int32.from_i(0))
+        # rb_obj_is_kind_of returns VALUE (i64); compare with i64 0 (Qfalse)
+        is_true = @builder.icmp(:ne, result_int, LLVM::Int64.from_i(0))
         @builder.select(is_true, @qtrue, @qfalse)
       end
 
@@ -8638,11 +9332,19 @@ module Konpeito
       end
 
       def generate_phi(inst)
+        # If this phi was already generated (e.g., it lives in an earlier HIR block but
+        # also appears in a when_body or inline-rescue try_blocks), return the cached value.
+        if inst.result_var && @variables.key?(inst.result_var)
+          return @variables[inst.result_var]
+        end
+
         # Collect incoming values with their type tags for optimization
         incoming_data = []
 
         inst.incoming.each do |label, hir_value|
-          llvm_block = @blocks[label]
+          # If safe navigation inside this HIR block created additional LLVM blocks,
+          # use the actual exit block instead of the original HIR block's LLVM block.
+          llvm_block = @block_exit_overrides[label] || @blocks[label]
           next unless llvm_block
           # Skip blocks with Return terminators — they don't branch to the
           # merge block, so they cannot be predecessors in the phi node.
@@ -10118,6 +10820,14 @@ module Konpeito
       end
 
       # Declare memchr if not already declared
+      def declare_strlen
+        @strlen ||= @mod.functions["strlen"] || @mod.functions.add(
+          "strlen",
+          [LLVM::Pointer(LLVM::Int8)],
+          LLVM::Int64
+        )
+      end
+
       def declare_memchr
         @memchr ||= @mod.functions["memchr"] || @mod.functions.add(
           "memchr",
@@ -11131,22 +11841,24 @@ module Konpeito
         # Get C string pointer
         data_ptr = @builder.call(@rb_string_value_cstr, value_ptr, "data_ptr")
 
-        # Get byte length using rb_str_length (returns Fixnum)
-        len_value = @builder.call(@rb_str_length, string_value, "str_len")
-        byte_len = @builder.call(@rb_num2long, len_value, "byte_len")
+        # Get byte length using strlen on the C string
+        # (rb_str_length returns character count, not byte count)
+        declare_strlen
+        byte_len = @builder.call(@strlen, data_ptr, "byte_len")
 
-        # Check ASCII-only using Ruby's ascii_only? method
-        ascii_only_id = @builder.call(@rb_intern, @builder.global_string_pointer("ascii_only?"))
-        ascii_result = @builder.call(@rb_funcallv, string_value, ascii_only_id,
-          LLVM::Int32.from_i(0), LLVM::Pointer(LLVM::Int64).null_pointer, "ascii_result")
+        # Check ASCII-only using rb_enc_str_asciionly_p (avoids rb_funcallv method lookup)
+        rb_enc_str_asciionly_p = @mod.functions["rb_enc_str_asciionly_p"] || @mod.functions.add(
+          "rb_enc_str_asciionly_p", [value_type], LLVM::Int32
+        )
+        ascii_int = @builder.call(rb_enc_str_asciionly_p, string_value, "ascii_int")
+        # rb_enc_str_asciionly_p returns non-zero for ASCII-only
+        ascii_result = @builder.icmp(:ne, ascii_int, LLVM::Int32.from_i(0), "is_ascii_raw")
 
-        # Convert Ruby boolean to flags (Qtrue = 20, Qfalse = 0)
         # flags bit 0 = ASCII_ONLY
-        is_ascii_true = @builder.icmp(:eq, ascii_result, @qtrue, "is_ascii_true")
-        flags_val = @builder.select(is_ascii_true, LLVM::Int64.from_i(1), LLVM::Int64.from_i(0), "flags_val")
+        flags_val = @builder.select(ascii_result, LLVM::Int64.from_i(1), LLVM::Int64.from_i(0), "flags_val")
 
         # For ASCII strings, char_len = byte_len; otherwise -1 (not computed)
-        char_len = @builder.select(is_ascii_true, byte_len, LLVM::Int64.from_i(-1), "char_len")
+        char_len = @builder.select(ascii_result, byte_len, LLVM::Int64.from_i(-1), "char_len")
 
         # Allocate struct on stack
         ns_ptr = @builder.alloca(struct_type, "native_string")