konpeito 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e006122255b4a6a62dcd3c3ec066b97b9be8e3b3142e4d7c5fc0dd2ccd6b010
-  data.tar.gz: afb890b5639796f4085af9191493241c9dff65ef9abb67c204884998743bde06
+  metadata.gz: 453b0bb32e4ef66b8b6020d262200e070caf01fb483cff4a0ebd6ceba46495b3
+  data.tar.gz: 7b38fb2807e1649150a0febae5defcb8f964967a715770db1de857d6409f88b3
 SHA512:
-  metadata.gz: e6c22d15f78ad5963d979d7bd528e39e202032e8bf9296c5ee4a2dd2b4627b117b70bafb766b118ea7d2c22e315da7a1db3837b102e2992c81be1fde10114ff6
-  data.tar.gz: db28cfe4761900dd2acadd218dbef736ec4e1b7f8c0debe02827059f3540f4e654438176f3fd9b9dc3d372a3e0e46188f7d5890d2d37a14856a6d3c106eecc68
+  metadata.gz: afa5fd10db773c8e1bb3c399a39cf140b1c7577271420750368551ee80cab864683d9455860ddba185b0d53cc221df42b5beb3a7334fbc67b56747e4a7bd6e0f
+  data.tar.gz: 7fbe956b09d489f9af313c0fa6600f81960cb02cb72d95f912a4d50d9f658b4b7bff35528d43b73c223d011d0aa5c35f6c63bf09ce5f1873c14605cd7274395e

data/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to Konpeito will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.5.0] - 2026-03-10
+
+### Added
+- **Clay UI layout stdlib**: Flexbox-style UI layout library for the mruby backend. `module Clay` auto-detected like raylib — 40+ `%a{cfunc}` bindings covering lifecycle, element construction, text, borders, scrolling, floating elements, and bulk rendering via the official raylib renderer. Vendored Clay v0.14 under `vendor/clay/`.
+- **Clay UI demo**: `examples/mruby_clay_ui/clay_demo.rb` — sidebar + main content layout with TTF fonts
+- **Memory Match game**: `examples/mruby_clay_ui/memory_game.rb` — card matching game using Clay layout system with module NativeArray game state
+- **Module NativeArray**: fixed-size global arrays shared across functions via RBS module instance variables (`@field: NativeArray[T, N]`). Compiles to LLVM global arrays — no C wrapper file needed. Available on LLVM (CRuby) and mruby backends.
+- **Inline RBS module blocks**: `# @rbs module Foo ... # @rbs end` comment blocks are now extracted by the preprocessor and emitted as raw RBS, enabling module NativeArray declarations without separate `.rbs` files or empty `module Foo; end` stubs.
+- **Space Invaders example rewrite**: `examples/mruby_space_invaders/` rewritten to use module NativeArray with inline RBS — single `.rb` file, no C wrapper or separate `.rbs` needed
+- **Third-party license file**: `THIRD_PARTY_LICENSES.md` summarizing vendored library licenses (yyjson, Clay)
+
+### Fixed
+- **NativeArray GEP stride**: fix `gep` → `gep2` for all NativeArray element access (14 call sites). With LLVM opaque pointers, `gep` used array type as stride instead of element type, causing memory corruption and SIGSEGV crashes.
+
+## [0.4.2] - 2026-03-10
+
+### Fixed
+- **Linux symbol collision**: use `internal` linkage for LLVM callback functions to prevent flat namespace collisions on Linux
+- **NativeClass ptr→VALUE**: add missing `ptr2int` conversion for NativeClass objects passed to CRuby APIs
+- **JSON codegen tests**: skip when vendored yyjson source is unavailable (CI environments)
+- **CI stabilization**: run codegen tests per-file in separate processes to prevent `.so` accumulation crashes
+
+### Added
+- **macOS ARM CI job**: unit tests and codegen tests on `macos-latest` (ARM)
+- **mruby CI job**: build and run verification with `konpeito run --target mruby`
+- **Japanese tutorial**: add mruby backend section (5.5) matching English tutorial
+
+### Changed
+- Update `actions/checkout` v4 → v6, `actions/setup-java` v4 → v5
+
 ## [0.4.1] - 2026-03-09
 
 ### Added

data/Rakefile

@@ -5,7 +5,34 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"].exclude("test/codegen/**/*_test.rb")
+end
+
+desc "Run codegen tests (each file in a separate process to avoid .so accumulation crashes)"
+task "test:codegen" do
+  test_files = FileList["test/codegen/**/*_test.rb"].sort
+  failed = []
+  test_files.each do |f|
+    print "#{File.basename(f, '.rb')} "
+    unless system("bundle", "exec", "ruby", "-Ilib:test", f)
+      failed << f
+    end
+  end
+  puts
+  unless failed.empty?
+    abort "#{failed.size}/#{test_files.size} codegen test files failed:\n  #{failed.join("\n  ")}"
+  end
+  puts "All #{test_files.size} codegen test files passed."
+end
+
+desc "Run all tests (non-codegen + codegen in separate processes)"
+task "test:all" => [:test] do
+  # Run codegen tests in a separate process so a crash doesn't kill non-codegen results
+  sh "bundle exec rake test:codegen" do |ok, _status|
+    unless ok
+      warn "Codegen tests failed (possibly due to native extension crash on ruby-head)"
+    end
+  end
 end
 
 desc "Run conformance tests against Ruby/Native/JVM backends"
@@ -23,4 +50,9 @@ task "conformance:jvm" do
   ruby "spec/conformance/runner.rb", "--jvm-only"
 end
 
+desc "Run CI compilation diagnostics"
+task "test:diagnose" do
+  ruby "test/ci_diagnostic.rb"
+end
+
 task default: :test

data/THIRD_PARTY_LICENSES.md

@@ -0,0 +1,26 @@
+# Third-Party Licenses
+
+Konpeito vendors the following third-party libraries. Each library's license
+file is kept alongside its source under `vendor/`.
+
+---
+
+## yyjson
+
+- **Location:** `vendor/yyjson/`
+- **License:** MIT
+- **Copyright:** (c) 2020 YaoYuan
+- **URL:** https://github.com/ibireme/yyjson
+
+See `vendor/yyjson/LICENSE` for the full license text.
+
+---
+
+## Clay
+
+- **Location:** `vendor/clay/`
+- **License:** zlib/libpng
+- **Copyright:** (c) 2024 Nic Barker
+- **URL:** https://github.com/nicbarker/clay
+
+See `vendor/clay/LICENSE` for the full license text.

data/lib/konpeito/cli/run_command.rb

@@ -277,7 +277,7 @@ module Konpeito
 
         # Include extra C files in cache key (they affect the binary)
         source_dir = File.dirname(File.expand_path(source_file))
-        extra_c_files = Dir.glob(File.join(source_dir, "*.c")).sort
+        extra_c_files = Dir.glob(File.join(source_dir, "*.c"))
 
         options_hash = {
           "inline_rbs" => options[:inline_rbs].to_s,

data/lib/konpeito/codegen/cruby_backend.rb

@@ -996,6 +996,13 @@ module Konpeito
           flags.concat(yyjson_objs)
         end
 
+        # Add clay object files if Clay stdlib is used
+        clay_used = @rbs_loader&.cfunc_methods&.any? { |k, _| k.start_with?("Clay.") }
+        if clay_used
+          clay_objs = ensure_clay_compiled
+          flags.concat(clay_objs)
+        end
+
         if @rbs_loader
           stdlib_ui_dir = File.expand_path("../stdlib/ui", __dir__)
 
@@ -1051,6 +1058,25 @@ module Konpeito
         [yyjson_obj, wrapper_obj]
       end
 
+      # Compile vendored clay.h implementation if Clay stdlib is used
+      # Returns array of object file paths
+      def ensure_clay_compiled
+        clay_dir = File.expand_path("../../../vendor/clay", __dir__)
+        clay_impl_c = File.join(clay_dir, "clay_impl.c")
+        clay_impl_obj = File.join(clay_dir, "clay_impl.o")
+
+        return [] unless File.exist?(clay_impl_c)
+
+        cc = find_llvm_tool("clang") || "cc"
+
+        unless File.exist?(clay_impl_obj) && File.mtime(clay_impl_obj) > File.mtime(clay_impl_c)
+          cmd = [cc, "-c", "-O2", "-fPIC", "-o", clay_impl_obj, clay_impl_c]
+          system(*cmd) or return []
+        end
+
+        [clay_impl_obj]
+      end
+
       def ruby_link_flags
         # Get Ruby's linker flags for extensions
         [

data/lib/konpeito/codegen/inliner.rb

@@ -532,6 +532,16 @@ module Konpeito
           new_array = transform_value(inst.array, prefix, param_map)
           HIR::MultiWriteExtract.new(array: new_array, index: inst.index, type: inst.type, result_var: new_result)
 
+        when HIR::ModuleNativeArrayRef
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::ModuleNativeArrayRef.new(
+            module_name: inst.module_name,
+            field_name: inst.field_name,
+            element_type: inst.element_type,
+            size: inst.size,
+            result_var: new_result
+          )
+
         else
           # For other instructions, just return as-is with renamed result
           inst

data/lib/konpeito/codegen/llvm_generator.rb

@@ -100,6 +100,9 @@ module Konpeito
         # Scan HIR to register NativeClassTypes before code generation
         scan_for_native_class_types(hir_program)
 
+        # Declare LLVM globals for module-level NativeArray fields
+        declare_module_native_arrays(hir_program)
+
         # Pre-scan: detect parameters that can receive nil at call sites
         @nil_possible_params = scan_nil_possible_params(hir_program)
 
@@ -2182,6 +2185,8 @@ module Konpeito
           generate_sized_queue_push(inst)
         when HIR::SizedQueuePop
           generate_sized_queue_pop(inst)
+        when HIR::ModuleNativeArrayRef
+          generate_module_native_array_ref(inst)
         when HIR::NativeArrayAlloc
           generate_native_array_alloc(inst)
         when HIR::NativeArrayGet
@@ -2985,6 +2990,9 @@ module Konpeito
           # Convert bool to Ruby true/false
           is_true = @builder.icmp(:ne, value, LLVM::Int8.from_i(0))
           @builder.select(is_true, qtrue, qfalse)
+        when [:native_class, :value]
+          # NativeClass struct pointer to VALUE (i64)
+          @builder.ptr2int(value, LLVM::Int64)
         when [:i64, :double]
           @builder.si2fp(value, LLVM::Double)
         when [:double, :i64]
@@ -4826,6 +4834,7 @@ module Konpeito
         callback_func = @mod.functions.add(callback_name,
           [value_type, value_type, LLVM::Int32, LLVM::Pointer(value_type), value_type],
           value_type)
+        callback_func.linkage = :internal
 
         # Save current builder state
         saved_block = @builder.insert_block
@@ -5221,6 +5230,7 @@ module Konpeito
         # --- Shared lambda_true helper (created once per module) ---
         @lambda_true_func ||= begin
           f = @mod.functions.add("__konpeito_lambda_true", [value_type], value_type)
+          f.linkage = :internal
           bb = f.basic_blocks.append("entry")
           @builder.position_at_end(bb)
           @builder.ret(qtrue)
@@ -5231,6 +5241,7 @@ module Konpeito
         arity_func_name = "__konpeito_proc_arity_#{param_count}"
         arity_func = @mod.functions[arity_func_name] || begin
           f = @mod.functions.add(arity_func_name, [value_type], value_type)
+          f.linkage = :internal
           bb = f.basic_blocks.append("entry")
           @builder.position_at_end(bb)
           arity_ruby = @builder.call(@rb_int2inum, LLVM::Int64.from_i(param_count), "arity_val")
@@ -5560,6 +5571,7 @@ module Konpeito
         callback_func = @mod.functions.add(callback_name,
           [LLVM::Pointer(LLVM::Int8)],
           value_type)
+        callback_func.linkage = :internal
 
         # Save current builder state
         saved_block = @builder.insert_block
@@ -5893,6 +5905,7 @@ module Konpeito
         # VALUE callback(VALUE data) - data is pointer to captures array
         callback_type = LLVM::Type.function([value_type], value_type)
         callback_func = @mod.functions.add(callback_name, [value_type], value_type)
+        callback_func.linkage = :internal
 
         # Save current builder state
         saved_block = @builder.insert_block
@@ -5988,6 +6001,7 @@ module Konpeito
 
         # VALUE callback(VALUE mutex) - mutex is passed as data2
         callback_func = @mod.functions.add(callback_name, [value_type], value_type)
+        callback_func.linkage = :internal
 
         # Save current builder state
         saved_block = @builder.insert_block
@@ -8108,6 +8122,7 @@ module Konpeito
 
         # VALUE func(VALUE data)  — data (params[0]) = self or escape array
         callback_func = @mod.functions.add(callback_name, [value_type], value_type)
+        callback_func.linkage = :internal
 
         # Save current builder state
         saved_block    = @builder.insert_block
@@ -8227,6 +8242,7 @@ module Konpeito
 
         # VALUE func(VALUE data2, VALUE exception)
         callback_func = @mod.functions.add(callback_name, [value_type, value_type], value_type)
+        callback_func.linkage = :internal
 
         # Save current builder state
         saved_block = @builder.insert_block
@@ -8387,6 +8403,7 @@ module Konpeito
         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)
+        callback_func.linkage = :internal
 
         saved_block = @builder.insert_block
         saved_vars = @variables.dup
@@ -8524,6 +8541,7 @@ module Konpeito
       def generate_rescue_handler_with_flag_callback(rescue_clauses, counter)
         callback_name = "rescue_handler_flag_#{counter}"
         callback_func = @mod.functions.add(callback_name, [value_type, value_type], value_type)
+        callback_func.linkage = :internal
 
         saved_block = @builder.insert_block
         saved_vars = @variables.dup
@@ -9828,8 +9846,8 @@ module Konpeito
         # Normalize negative indices
         index_i64 = normalize_native_index(index_i64, inst.receiver)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         # Load element
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
@@ -9859,8 +9877,9 @@ module Konpeito
         target_type = element_type == :Int64 ? :i64 : :double
         converted_value = convert_value(store_value, value_type, target_type)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        llvm_elem_type = native_array_element_llvm_type(element_type)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         # Store element
         @builder.store(converted_value, elem_ptr)
@@ -9880,46 +9899,19 @@ module Konpeito
         len_value = @variables["#{receiver_var}_len"]
         return index_i64 unless len_value
 
-        func = @builder.insert_block.parent
+        # Use branchless select instead of conditional branches to avoid
+        # creating new basic blocks that break surrounding PHI node predecessors.
         is_negative = @builder.icmp(:slt, index_i64, LLVM::Int64.from_i(0))
-
-        neg_bb = func.basic_blocks.append("idx_neg")
-        pos_bb = func.basic_blocks.append("idx_pos")
-        merge_bb = func.basic_blocks.append("idx_merge")
-
-        @builder.cond(is_negative, neg_bb, pos_bb)
-
-        @builder.position_at_end(neg_bb)
         normalized = @builder.add(len_value, index_i64, "neg_idx")
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(pos_bb)
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(merge_bb)
-        @builder.phi(LLVM::Int64, { neg_bb => normalized, pos_bb => index_i64 })
+        @builder.select(is_negative, normalized, index_i64, "norm_idx")
       end
 
       # Normalize negative index for StaticArray (compile-time known size)
       def normalize_static_index(index_i64, size)
-        func = @builder.insert_block.parent
+        # Use branchless select to avoid creating new basic blocks
         is_negative = @builder.icmp(:slt, index_i64, LLVM::Int64.from_i(0))
-
-        neg_bb = func.basic_blocks.append("sidx_neg")
-        pos_bb = func.basic_blocks.append("sidx_pos")
-        merge_bb = func.basic_blocks.append("sidx_merge")
-
-        @builder.cond(is_negative, neg_bb, pos_bb)
-
-        @builder.position_at_end(neg_bb)
         normalized = @builder.add(LLVM::Int64.from_i(size), index_i64, "neg_sidx")
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(pos_bb)
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(merge_bb)
-        @builder.phi(LLVM::Int64, { neg_bb => normalized, pos_bb => index_i64 })
+        @builder.select(is_negative, normalized, index_i64, "norm_sidx")
       end
 
       # Generate NativeArray length access: arr.length
@@ -9977,7 +9969,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Get element via GEP + load (no rb_ary_entry!)
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter (unboxed!)
@@ -10027,7 +10019,7 @@ module Konpeito
           convert_value(val, val_type, type_tag)
         else
           # Use first element as initial, start from index 1
-          elem_ptr = @builder.gep(array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
+          elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
           @builder.load2(llvm_elem_type, elem_ptr, "first_elem")
         end
 
@@ -10059,7 +10051,7 @@ module Konpeito
 
         # Load accumulator and element (both unboxed)
         acc_value = @builder.load2(llvm_elem_type, acc_alloca, "acc")
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameters
@@ -10159,7 +10151,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element (unboxed)
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter
@@ -10242,7 +10234,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element (unboxed)
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter
@@ -10340,7 +10332,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element and store to alloca for later use
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
         @builder.store(elem_value, elem_alloca)
 
@@ -10432,7 +10424,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter
@@ -10540,7 +10532,7 @@ module Konpeito
 
         # Load accumulator and element
         acc_value = @builder.load2(llvm_elem_type, acc_alloca, "acc")
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Add (unboxed)
@@ -10601,7 +10593,7 @@ module Konpeito
         # Non-empty: initialize with first element
         @builder.position_at_end(non_empty_block)
         result_alloca = @builder.alloca(llvm_elem_type, "na_minmax_result")
-        first_ptr = @builder.gep(array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
+        first_ptr = @builder.gep2(llvm_elem_type, array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
         first_elem = @builder.load2(llvm_elem_type, first_ptr, "first")
         @builder.store(first_elem, result_alloca)
 
@@ -10621,7 +10613,7 @@ module Konpeito
 
         # Load current result and element
         current_result = @builder.load2(llvm_elem_type, result_alloca, "current")
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Compare and select
@@ -10691,11 +10683,16 @@ module Konpeito
       # Get the array pointer from a receiver HIR value
       def get_native_array_ptr(receiver)
         case receiver
+        when HIR::LoadLocal
+          # LoadLocal may have result_var=nil (e.g., from inliner transform_value).
+          # Use the variable name to look up the array pointer.
+          @variables[receiver.var.name] || (receiver.result_var && @variables[receiver.result_var]) ||
+            raise("NativeArray LoadLocal var '#{receiver.var.name}' not in @variables")
         when HIR::Instruction
           if receiver.result_var
             @variables[receiver.result_var]
           else
-            raise "NativeArray receiver has no result_var"
+            raise "NativeArray receiver has no result_var: #{receiver.class}"
           end
         when String
           @variables[receiver]
@@ -10707,6 +10704,8 @@ module Konpeito
       # Get the variable name from a receiver for length lookup
       def get_receiver_var_name(receiver)
         case receiver
+        when HIR::LoadLocal
+          receiver.var.name
         when HIR::Instruction
           receiver.result_var
         when String
@@ -10716,6 +10715,62 @@ module Konpeito
         end
       end
 
+      # ========================================
+      # Module-level NativeArray (LLVM global variables)
+      # ========================================
+
+      # Declare LLVM global arrays for all modules with NativeArray fields
+      def declare_module_native_arrays(hir)
+        @module_native_arrays ||= {}
+
+        hir.modules.each do |module_def|
+          next unless module_def.native_array_fields&.any?
+
+          module_def.native_array_fields.each do |field_name, info|
+            elem_type = info[:element_type]
+            size = info[:size]
+            llvm_elem_type = elem_type == :Int64 ? LLVM::Int64 : LLVM::Double
+
+            global_name = "konpeito_#{module_def.name}_#{field_name}"
+            array_type = LLVM::Type.array(llvm_elem_type, size)
+
+            global = @mod.globals.add(array_type, global_name)
+            global.initializer = LLVM::Constant.null(array_type)
+            global.linkage = :internal
+
+            @module_native_arrays["#{module_def.name}_#{field_name}"] = {
+              global: global,
+              element_type: elem_type,
+              size: size,
+              llvm_elem_type: llvm_elem_type,
+              array_type: array_type
+            }
+          end
+        end
+      end
+
+      # Generate a reference to a module-level NativeArray global
+      def generate_module_native_array_ref(inst)
+        key = "#{inst.module_name}_#{inst.field_name}"
+        info = @module_native_arrays[key]
+        raise "Unknown module NativeArray: #{key}" unless info
+
+        # GEP to get pointer to first element of global array
+        array_ptr = @builder.gep2(
+          info[:array_type], info[:global],
+          [LLVM::Int64.from_i(0), LLVM::Int64.from_i(0)],
+          "#{inst.field_name}_ptr"
+        )
+
+        if inst.result_var
+          @variables[inst.result_var] = array_ptr
+          @variable_types[inst.result_var] = :native_array
+          @variables["#{inst.result_var}_len"] = LLVM::Int64.from_i(inst.size)
+        end
+
+        array_ptr
+      end
+
       # Allocate a NativeArray on the stack
       # Returns a pointer to contiguous memory + stores length
       def generate_native_array_alloc(inst)
@@ -10765,8 +10820,8 @@ module Konpeito
         index_value, index_type = get_value_with_type(inst.index)
         index_i64 = index_type == :i64 ? index_value : @builder.call(@rb_num2long, index_value)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         if native_array_has_class_element?(element_type)
           # For NativeClass elements, return pointer to struct (for field access)
@@ -10807,8 +10862,9 @@ module Konpeito
         target_type = element_type == :Int64 ? :i64 : :double
         converted_value = convert_value(store_value, value_type, target_type)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        llvm_elem_type = native_array_element_llvm_type(element_type)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         # Store element
         @builder.store(converted_value, elem_ptr)
@@ -12906,8 +12962,8 @@ module Konpeito
         # Get JSON element at index
         elem_val = @builder.call(@yyjson_arr_get, root, idx, "json_elem")
 
-        # Get pointer to NativeClass struct in the array
-        struct_ptr = @builder.gep(array_ptr, [idx], "elem_struct_ptr")
+        # Get pointer to NativeClass struct in the array (use gep2 for correct stride)
+        struct_ptr = @builder.gep2(llvm_elem_type, array_ptr, [idx], "elem_struct_ptr")
 
         # Parse fields from JSON object into struct
         fields = element_class.fields

data/lib/konpeito/codegen/mruby_backend.rb

@@ -58,6 +58,10 @@ module Konpeito
             extra_obj_files << extra_obj
           end
 
+          # Compile vendored Clay library if used
+          clay_objs = ensure_clay_compiled
+          extra_obj_files.concat(clay_objs)
+
           obj_files = [obj_file, init_obj_file, helpers_obj_file] + extra_obj_files
 
           # Link into standalone executable
@@ -901,6 +905,34 @@ module Konpeito
           )
         end
 
+        # Include Clay if used
+        clay_used = @extra_c_files.any? { |f| File.basename(f).include?("clay") }
+        if clay_used
+          sections << license_section(
+            "Clay",
+            "zlib/libpng",
+            "Copyright (c) 2024 Nic Barker",
+            "https://github.com/nicbarker/clay",
+            <<~ZLIB
+              This software is provided 'as-is', without any express or implied warranty.
+              In no event will the authors be held liable for any damages arising from the
+              use of this software.
+
+              Permission is granted to anyone to use this software for any purpose,
+              including commercial applications, and to alter it and redistribute it freely,
+              subject to the following restrictions:
+
+              1. The origin of this software must not be misrepresented; you must not claim
+                 that you wrote the original software. If you use this software in a product,
+                 an acknowledgment in the product documentation would be appreciated but is
+                 not required.
+              2. Altered source versions must be plainly marked as such, and must not be
+                 misrepresented as being the original software.
+              3. This notice may not be removed or altered from any source distribution.
+            ZLIB
+          )
+        end
+
         # Include raylib if linked
         ffi_libs = @rbs_loader&.all_ffi_libraries || []
         if ffi_libs.any? { |lib| lib.to_s.include?("raylib") }
@@ -1160,8 +1192,41 @@ module Konpeito
         end
       end
 
+      # Compile vendored clay.h implementation if Clay stdlib is used
+      # Returns array of object file paths
+      def ensure_clay_compiled
+        clay_used = @extra_c_files.any? { |f| File.basename(f).include?("clay") }
+        return [] unless clay_used
+
+        clay_dir = File.expand_path("../../../vendor/clay", __dir__)
+        clay_impl_c = File.join(clay_dir, "clay_impl.c")
+        clay_impl_obj = File.join(clay_dir, "clay_impl.o")
+
+        return [] unless File.exist?(clay_impl_c)
+
+        cc, cc_flags = cross_cc_with_flags
+        cflags = cross_compiling? ? Platform.cross_mruby_cflags(@cross_mruby_dir) : (Platform.mruby_cflags rescue "-O2")
+
+        # Compile clay_impl.c (only if stale)
+        unless File.exist?(clay_impl_obj) && File.mtime(clay_impl_obj) > File.mtime(clay_impl_c)
+          cmd = [*cc, "-c", "-O2"]
+          cmd.concat(cc_flags)
+          cmd += ["-o", clay_impl_obj, clay_impl_c]
+          system(*cmd) or return []
+        end
+
+        [clay_impl_obj]
+      end
+
       def ffi_include_flags
         flags = []
+
+        # Always add vendored Clay include path if Clay stdlib is used
+        clay_dir = File.expand_path("../../../vendor/clay", __dir__)
+        if @extra_c_files.any? { |f| File.basename(f).include?("clay") } && Dir.exist?(clay_dir)
+          flags << "-I#{clay_dir}"
+        end
+
         if cross_compiling?
           # When cross-compiling, use cross library include paths
           flags << "-I#{@cross_libs_dir}/../include" if @cross_libs_dir && Dir.exist?("#{@cross_libs_dir}/../include")