Merge pull request #10414 from joachimschmidt557/stage2-arm

stage2 ARM: Implement airLoad for slices

src/arch/arm/CodeGen.zig

@@ -1317,8 +1317,37 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
                 .stack_offset => |off| {
                     if (elem_ty.abiSize(self.target.*) <= 4) {
                         const tmp_reg = try self.register_manager.allocReg(null, &.{});
-                        try self.load(.{ .register = tmp_reg }, ptr, elem_ty);
-                        return self.genSetStack(elem_ty, off, MCValue{ .register = tmp_reg });
+                        try self.load(.{ .register = tmp_reg }, ptr, ptr_ty);
+                        try self.genSetStack(elem_ty, off, MCValue{ .register = tmp_reg });
+                    } else if (elem_ty.abiSize(self.target.*) == 8) {
+                        // TODO generalize this: maybe add a
+                        // genArmMemcpy function which manually copies
+                        // data if the size is below a certain
+                        // threshold and calls "memcpy" if the size is
+                        // larger
+
+                        const usize_ty = Type.initTag(.usize);
+                        const tmp_regs = try self.register_manager.allocRegs(2, .{ null, null }, &.{});
+                        _ = try self.addInst(.{
+                            .tag = .ldr,
+                            .cond = .al,
+                            .data = .{ .rr_offset = .{
+                                .rt = tmp_regs[0],
+                                .rn = reg,
+                                .offset = .{ .offset = Instruction.Offset.none },
+                            } },
+                        });
+                        _ = try self.addInst(.{
+                            .tag = .ldr,
+                            .cond = .al,
+                            .data = .{ .rr_offset = .{
+                                .rt = tmp_regs[1],
+                                .rn = reg,
+                                .offset = .{ .offset = Instruction.Offset.imm(4) },
+                            } },
+                        });
+                        try self.genSetStack(usize_ty, off, MCValue{ .register = tmp_regs[0] });
+                        try self.genSetStack(usize_ty, off + 4, MCValue{ .register = tmp_regs[1] });
                     } else {
                         return self.fail("TODO implement memcpy", .{});
                     }

src/codegen.zig

@@ -150,6 +150,13 @@ pub fn generateSymbol(
     const tracy = trace(@src());
     defer tracy.end();
 
+    if (typed_value.val.isUndefDeep()) {
+        const target = bin_file.options.target;
+        const abi_size = try math.cast(usize, typed_value.ty.abiSize(target));
+        try code.appendNTimes(0xaa, abi_size);
+        return Result{ .appended = {} };
+    }
+
     switch (typed_value.ty.zigTypeTag()) {
         .Fn => {
             return Result{
@@ -193,6 +200,38 @@ pub fn generateSymbol(
         },
         .Pointer => switch (typed_value.ty.ptrSize()) {
             .Slice => {
+                // TODO populate .debug_info for the slice
+
+                // generate ptr
+                var buf: Type.SlicePtrFieldTypeBuffer = undefined;
+                const slice_ptr_field_type = typed_value.ty.slicePtrFieldType(&buf);
+                switch (try generateSymbol(bin_file, src_loc, .{
+                    .ty = slice_ptr_field_type,
+                    .val = typed_value.val.slicePtr(),
+                }, code, debug_output)) {
+                    .appended => {},
+                    .externally_managed => |slice| {
+                        code.appendSliceAssumeCapacity(slice);
+                    },
+                    .fail => |em| return Result{ .fail = em },
+                }
+
+                // generate length
+                var int_buffer: Value.Payload.U64 = .{
+                    .base = .{ .tag = .int_u64 },
+                    .data = typed_value.val.sliceLen(),
+                };
+                switch (try generateSymbol(bin_file, src_loc, .{
+                    .ty = Type.initTag(.usize),
+                    .val = Value.initPayload(&int_buffer.base),
+                }, code, debug_output)) {
+                    .appended => {},
+                    .externally_managed => |slice| {
+                        code.appendSliceAssumeCapacity(slice);
+                    },
+                    .fail => |em| return Result{ .fail = em },
+                }
+
                 return Result{
                     .fail = try ErrorMsg.create(
                         bin_file.allocator,