linear code size for fixed size arrays (except when flattened)

Author: cpetig

crates/core/src/abi.rs

@@ -325,12 +325,23 @@ def_instruction! {
         } : [1] => [*size as usize],
 
         /// Pops an array and an address off the stack, passes each element to a block storing it
-        FixedSizeListLowerMemory {
+        FixedSizeListLowerToMemory {
             element: &'a Type,
             size: u32,
             id: TypeId,
         } : [2] => [0],
 
+        /// Pops base address, pushes an array
+        ///
+        /// This will also pop a block from the block stack which is how to
+        /// read each individual element from the list.
+        FixedSizeListLiftFromMemory {
+            element: &'a Type,
+            size: u32,
+            id: TypeId,
+        } : [1] => [1],
+
+
         /// Pushes an operand onto the stack representing the list item from
         /// each iteration of the list.
         ///
@@ -1993,7 +2004,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                     self.write_to_memory(element, elem_addr, offset);
                     self.finish_block(0);
                     self.stack.push(addr);
-                    self.emit(&FixedSizeListLowerMemory {
+                    self.emit(&FixedSizeListLowerToMemory {
                         element,
                         size: *size,
                         id,
@@ -2187,13 +2198,13 @@ impl<'a, B: Bindgen> Generator<'a, B> {
 
                 TypeDefKind::Unknown => unreachable!(),
                 TypeDefKind::FixedSizeList(ty, size) => {
-                    let increment = self.bindgen.sizes().size(ty);
-                    let mut position = offset;
-                    for _ in 0..*size {
-                        self.read_from_memory(ty, addr.clone(), position);
-                        position = position + increment;
-                    }
-                    self.emit(&FixedSizeListLift {
+                    self.push_block();
+                    self.emit(&IterBasePointer);
+                    let elemaddr = self.stack.pop().unwrap();
+                    self.read_from_memory(ty, elemaddr, Default::default());
+                    self.finish_block(1);
+                    self.stack.push(addr.clone());
+                    self.emit(&FixedSizeListLiftFromMemory {
                         element: ty,
                         size: *size,
                         id,

crates/cpp/src/lib.rs

@@ -2676,8 +2676,37 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                 self.push_str("};\n");
                 results.push(result);
             }
+            abi::Instruction::FixedSizeListLiftFromMemory {
+                element,
+                size: elemsize,
+                id: _,
+            } => {
+                let body = self.blocks.pop().unwrap();
+                let tmp = self.tmp();
+                let vec = format!("array{tmp}");
+                let source = operands[0].clone();
+                let size = self.r#gen.sizes.size(element);
+                let size_str = size.format(POINTER_SIZE_EXPRESSION);
+                let typename = self
+                    .r#gen
+                    .type_name(element, &self.namespace, Flavor::InStruct);
+                let ptr_type = self.r#gen.r#gen.opts.ptr_type();
+                self.push_str(&format!("std::array<{typename}, {elemsize}> {vec};\n"));
+                self.push_str(&format!(
+                    "{{
+                    {ptr_type} outer_base = {source};\n"
+                ));
+                let source: String = "outer_base".into();
+                // let vec: String = "outer_vec".into();
+                self.push_str(&format!("for (unsigned i = 0; i<{elemsize}; ++i) {{\n",));
+                self.push_str(&format!("{ptr_type} base = {source} + i * {size_str};\n"));
+                self.push_str(&body.0);
+                self.push_str(&format!("{vec}[i] = {};", body.1[0]));
+                self.push_str("\n}\n}\n");
+                results.push(vec);
+            }
             abi::Instruction::FixedSizeListLower { .. } => todo!(),
-            abi::Instruction::FixedSizeListLowerMemory {
+            abi::Instruction::FixedSizeListLowerToMemory {
                 element,
                 size: elemsize,
                 id: _,

crates/csharp/src/function.rs

@@ -1447,7 +1447,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::DropHandle { .. }
             | Instruction::FixedSizeListLift { .. }
             | Instruction::FixedSizeListLower { .. }
-            | Instruction::FixedSizeListLowerMemory { .. }
+            | Instruction::FixedSizeListLowerToMemory { .. }
+            | Instruction::FixedSizeListLiftFromMemory { .. }
             => {
                 dbg!(inst);
                 todo!()

crates/moonbit/src/lib.rs

@@ -2698,7 +2698,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::DropHandle { .. } => todo!(),
             Instruction::FixedSizeListLift { .. } => todo!(),
             Instruction::FixedSizeListLower { .. } => todo!(),
-            Instruction::FixedSizeListLowerMemory { .. } => todo!(),
+            Instruction::FixedSizeListLowerToMemory { .. } => todo!(),
+            Instruction::FixedSizeListLiftFromMemory { .. } => todo!(),
         }
     }
 

crates/rust/src/bindgen.rs

@@ -783,7 +783,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 results.push(len);
             }
 
-            Instruction::FixedSizeListLowerMemory {
+            Instruction::FixedSizeListLowerToMemory {
                 element,
                 size: _,
                 id: _,
@@ -1252,6 +1252,29 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     results.push(format!("{}[{i}]", operands[0]));
                 }
             }
+            Instruction::FixedSizeListLiftFromMemory {
+                element,
+                size,
+                id: _,
+            } => {
+                let body = self.blocks.pop().unwrap();
+                let elemsize = self
+                    .r#gen
+                    .sizes
+                    .size(element)
+                    .format(POINTER_SIZE_EXPRESSION);
+                let base = operands[0].clone();
+                let tmp = self.tmp();
+                let index_var = format!("idx{tmp}");
+                self.push_str(&format!(
+                    " let array{tmp}: [_; {size}] = core::array::from_fn(|{index_var}| {{
+                            let base = {base}.add({index_var} * {elemsize});
+                            {body} 
+                        }});"
+                ));
+                let result = format!("array{tmp}");
+                results.push(result);
+            }
         }
     }
 }