ngrc version works?

src/backend/into_crane.rs

@@ -406,12 +406,53 @@ impl<M: Module> Backend<M> {
                 }
             }
 
-            Expression::Construct(_, ty, name, fields) => {
-                let Type::Structure(fields) = ty else {
+            Expression::Construct(_, ty, _, fields) => {
+                let Type::Structure(type_fields) = ty else {
                     panic!("Got to backend with non-structure type in structure construction?!");
                 };
 
-                unimplemented!()
+                let global_allocator = ArcIntern::new("__global_allocation_pointer__".to_string());
+                let Some(ReferenceBuilder::Global(_, allocator_variable)) =
+                    variables.get(&global_allocator)
+                else {
+                    panic!("Couldn't find global allocation pointer");
+                };
+
+                let pointer_to = self.module.target_config().pointer_type();
+                let allocator_pointer = builder.ins().symbol_value(pointer_to, *allocator_variable);
+                let structure =
+                    builder
+                        .ins()
+                        .load(pointer_to, MemFlags::new(), allocator_pointer, 0);
+                let structure_size = builder
+                    .ins()
+                    .iconst(pointer_to, type_fields.object_size() as i64);
+                let updated_allocator_value = builder.ins().iadd(structure, structure_size);
+                builder.ins().store(
+                    MemFlags::new(),
+                    updated_allocator_value,
+                    allocator_pointer,
+                    0,
+                );
+
+                for (field_name, field_value) in fields.into_iter() {
+                    let (field_value, field_cranelift_type) =
+                        self.compile_value_or_ref(field_value, variables, builder)?;
+                    let Some((field_internal_type, offset)) =
+                        type_fields.field_type_and_offset(&field_name)
+                    else {
+                        panic!("Got to backend with mismatched construction and type definition");
+                    };
+                    assert_eq!(
+                        field_cranelift_type,
+                        self.translate_type(field_internal_type).value_type
+                    );
+                    builder
+                        .ins()
+                        .store(MemFlags::new(), field_value, structure, offset);
+                }
+
+                Ok((structure, self.module.target_config().pointer_type()))
             }
 
             Expression::FieldRef(_, _, struct_type, val, field) => {
@@ -427,7 +468,10 @@ impl<M: Module> Backend<M> {
 
                 let field_cranelift_type = self.translate_type(field_type).value_type;
 
-                let value = builder.ins().load(field_cranelift_type, MemFlags::new(), structure, offset);
+                let value =
+                    builder
+                        .ins()
+                        .load(field_cranelift_type, MemFlags::new(), structure, offset);
                 Ok((value, field_cranelift_type))
             }
 

src/backend/runtime.rs

@@ -91,7 +91,14 @@ impl RuntimeFunctions {
     /// one; both to reduce the chance that they deviate, and to reduce overall
     /// maintenance burden.
     pub fn register_jit_implementations(builder: &mut JITBuilder) {
+        let allocation_pointer = unsafe {
+            std::alloc::alloc_zeroed(
+                std::alloc::Layout::from_size_align(1024 * 1024, 1024 * 1024)
+                    .expect("reasonable layout is reasonable"),
+            )
+        };
         builder.symbol("print", runtime_print as *const u8);
+        builder.symbol("__global_allocation_pointer__", allocation_pointer);
     }
 }