LowerNamedToMemory for MoonBit

Author: vigoo

crates/c/src/lib.rs

@@ -3999,6 +3999,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 "LiftNamedFromMemory is only emitted by generators that implement \
                  Bindgen::lift_helper_name, which this generator does not"
             ),
+            Instruction::LowerNamedToMemory { .. } => unreachable!(
+                "LowerNamedToMemory is only emitted by generators that implement \
+                 Bindgen::lower_helper_name, which this generator does not"
+            ),
             Instruction::I32Store { offset } => self.store("int32_t", *offset, operands),
             Instruction::I64Store { offset } => self.store("int64_t", *offset, operands),
             Instruction::F32Store { offset } => self.store("float", *offset, operands),

crates/core/src/abi.rs

@@ -134,6 +134,18 @@ def_instruction! {
         /// of a single huge function.
         LiftNamedFromMemory { ty: TypeId, offset: ArchitectureSize } : [1] => [1],
 
+        /// Pops a value to lower and then a base pointer from the stack, calls a
+        /// pre-generated, shared per-type lower helper function to write the
+        /// named aggregate type `ty` at the constant `offset` from that
+        /// pointer, producing no result.
+        ///
+        /// This is the lower-side counterpart of `LiftNamedFromMemory`: it
+        /// outlines the canonical-ABI "write to memory" of large named
+        /// record/variant types into shared helper functions instead of
+        /// inlining the full recursive lower at every use site. The value
+        /// operand is `operands[0]` and the base pointer is `operands[1]`.
+        LowerNamedToMemory { ty: TypeId, offset: ArchitectureSize } : [2] => [0],
+
         /// Pops a pointer from the stack and then an `i32` value.
         /// Stores the value in little-endian at the pointer specified plus the
         /// constant `offset`.
@@ -816,6 +828,19 @@ pub trait Bindgen {
         let _ = (resolve, id);
         None
     }
+
+    /// Returns the name of a pre-generated, shared lower helper function for
+    /// the named aggregate type `id`, if one exists.
+    ///
+    /// When this returns `Some`, the canonical-ABI lower of that type (in
+    /// `write_to_memory`) is "outlined" into a call to the named helper
+    /// (emitted as `Instruction::LowerNamedToMemory`) instead of being inlined
+    /// recursively. Generators that do not implement helper outlining should
+    /// return `None` (the default).
+    fn lower_helper_name(&self, resolve: &Resolve, id: TypeId) -> Option<String> {
+        let _ = (resolve, id);
+        None
+    }
 }
 
 /// Generates an abstract sequence of instructions which represents this
@@ -914,6 +939,38 @@ pub fn lift_from_memory_root<B: Bindgen>(
     generator.stack.pop().unwrap()
 }
 
+/// Like [`lower_to_memory`], but used to generate the *body* of an outlined
+/// lower helper for the named type `skip_outline_root`.
+///
+/// The root type itself is lowered inline (one level deep) while nested named
+/// aggregate types are outlined into calls to their own shared helpers (see
+/// [`Bindgen::lower_helper_name`] and [`Instruction::LowerNamedToMemory`]).
+///
+/// `skip_outline_root` must be the id of the named aggregate (record/variant)
+/// being lowered, and `ty` must be exactly `Type::Id(skip_outline_root)` (not
+/// an alias to it) so that the single-shot inline of the root in
+/// `write_to_memory` lands on the intended type.
+pub fn lower_to_memory_root<B: Bindgen>(
+    resolve: &Resolve,
+    bindgen: &mut B,
+    address: B::Operand,
+    value: B::Operand,
+    ty: &Type,
+    skip_outline_root: TypeId,
+) {
+    assert!(
+        matches!(ty, Type::Id(id) if *id == skip_outline_root),
+        "lower_to_memory_root requires `ty` to be `Type::Id(skip_outline_root)`, \
+         not an alias or other type"
+    );
+    let mut generator = Generator::new(resolve, bindgen);
+    generator.realloc = Some(Realloc::Export("cabi_realloc"));
+    generator.lower_outline_root = Some(skip_outline_root);
+    generator.stack.push(value);
+    generator.write_to_memory(ty, address, Default::default());
+    debug_assert!(generator.stack.is_empty());
+}
+
 /// Used in a similar manner as the `Interface::call` function except is
 /// used to generate the `post-return` callback for `func`.
 ///
@@ -1060,6 +1117,11 @@ struct Generator<'a, B: Bindgen> {
     /// level) while nested named aggregates are still outlined into their own
     /// helpers. `None` everywhere else (so all eligible named types outline).
     lift_outline_root: Option<TypeId>,
+    /// Like `lift_outline_root`, but for the lower side: when generating the
+    /// body of an outlined lower helper for a named type, this holds that
+    /// type's id so its own top-level lower is inlined (one level) while
+    /// nested named aggregates are still outlined. `None` everywhere else.
+    lower_outline_root: Option<TypeId>,
 }
 
 const MAX_FLAT_PARAMS: usize = 16;
@@ -1076,6 +1138,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
             return_pointer: None,
             realloc: None,
             lift_outline_root: None,
+            lower_outline_root: None,
         }
     }
 
@@ -2029,7 +2092,21 @@ impl<'a, B: Bindgen> Generator<'a, B> {
             Type::String => self.write_list_to_memory(ty, addr, offset),
             Type::ErrorContext => self.lower_and_emit(ty, addr, &I32Store { offset }),
 
-            Type::Id(id) => match &self.resolve.types[id].kind {
+            Type::Id(id) => {
+                // Outline the lower of large named aggregate types into shared
+                // helper functions instead of inlining the full recursive
+                // lower here. `lower_outline_root` is `Some(id)` only while
+                // generating that type's own helper body, in which case its
+                // top level is inlined (one level) and nested types still
+                // outline.
+                let is_outline_root = self.lower_outline_root == Some(id);
+                self.lower_outline_root = None;
+                if !is_outline_root && self.bindgen.lower_helper_name(self.resolve, id).is_some() {
+                    self.stack.push(addr);
+                    self.emit(&Instruction::LowerNamedToMemory { ty: id, offset });
+                    return;
+                }
+                match &self.resolve.types[id].kind {
                 TypeDefKind::Type(t) => self.write_to_memory(t, addr, offset),
                 TypeDefKind::List(_) => self.write_list_to_memory(ty, addr, offset),
                 // Maps have the same linear memory layout as list<tuple<K, V>>.
@@ -2143,6 +2220,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                         id,
                     });
                 }
+                }
             },
         }
     }

crates/cpp/src/lib.rs

@@ -3524,6 +3524,10 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                 "LiftNamedFromMemory is only emitted by generators that implement \
                  Bindgen::lift_helper_name, which this generator does not"
             ),
+            abi::Instruction::LowerNamedToMemory { .. } => unreachable!(
+                "LowerNamedToMemory is only emitted by generators that implement \
+                 Bindgen::lower_helper_name, which this generator does not"
+            ),
             abi::Instruction::PointerStore { offset } => {
                 let ptr_type = self.r#gen.r#gen.opts.ptr_type();
                 self.store(ptr_type, *offset, operands)

crates/csharp/src/function.rs

@@ -468,6 +468,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 "LiftNamedFromMemory is only emitted by generators that implement \
                  Bindgen::lift_helper_name, which this generator does not"
             ),
+            Instruction::LowerNamedToMemory { .. } => unreachable!(
+                "LowerNamedToMemory is only emitted by generators that implement \
+                 Bindgen::lower_helper_name, which this generator does not"
+            ),
             Instruction::PointerLoad { offset } => results.push(format!(
                 "new global::System.Span<nint>((void*)((byte*){} + {offset}), 1)[0]",
                 operands[0],

crates/go/src/lib.rs

@@ -1996,6 +1996,10 @@ return {results}"
                 "LiftNamedFromMemory is only emitted by generators that implement \
                  Bindgen::lift_helper_name, which this generator does not"
             ),
+            Instruction::LowerNamedToMemory { .. } => unreachable!(
+                "LowerNamedToMemory is only emitted by generators that implement \
+                 Bindgen::lower_helper_name, which this generator does not"
+            ),
             Instruction::PointerLoad { offset } => {
                 load(self, results, &operands[0], offset, "uint32", &|v| {
                     format!("uintptr({v})")