| ... | ... | @@ -1308,6 +1308,15 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo |
| 1308 | 1308 | } }, |
| 1309 | 1309 | }); |
| 1310 | 1310 | }, |
| 1311 | .stack_offset => |off| { |
| 1312 | if (elem_ty.abiSize(self.target.*) <= 4) { |
| 1313 | const tmp_reg = try self.register_manager.allocReg(null, &.{}); |
| 1314 | try self.load(.{ .register = tmp_reg }, ptr, elem_ty); |
| 1315 | return self.genSetStack(elem_ty, off, MCValue{ .register = tmp_reg }); |
| 1316 | } else { |
| 1317 | return self.fail("TODO implement memcpy", .{}); |
| 1318 | } |
| 1319 | }, |
| 1311 | 1320 | else => return self.fail("TODO load from register into {}", .{dst_mcv}), |
| 1312 | 1321 | } |
| 1313 | 1322 | }, |
| ... | ... | @@ -1351,11 +1360,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void { |
| 1351 | 1360 | return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); |
| 1352 | 1361 | } |
| 1353 | 1362 | |
| 1354 | | fn airStore(self: *Self, inst: Air.Inst.Index) !void { |
| 1355 | | const bin_op = self.air.instructions.items(.data)[inst].bin_op; |
| 1356 | | const ptr = try self.resolveInst(bin_op.lhs); |
| 1357 | | const value = try self.resolveInst(bin_op.rhs); |
| 1358 | | const elem_ty = self.air.typeOf(bin_op.rhs); |
| 1363 | fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) InnerError!void { |
| 1359 | 1364 | switch (ptr) { |
| 1360 | 1365 | .none => unreachable, |
| 1361 | 1366 | .undef => unreachable, |
| ... | ... | @@ -1365,27 +1370,62 @@ fn airStore(self: *Self, inst: Air.Inst.Index) !void { |
| 1365 | 1370 | .compare_flags_signed => unreachable, |
| 1366 | 1371 | .stack_argument_offset => unreachable, |
| 1367 | 1372 | .immediate => |imm| { |
| 1368 | | try self.setRegOrMem(elem_ty, .{ .memory = imm }, value); |
| 1373 | try self.setRegOrMem(value_ty, .{ .memory = imm }, value); |
| 1369 | 1374 | }, |
| 1370 | 1375 | .ptr_stack_offset => |off| { |
| 1371 | | try self.genSetStack(elem_ty, off, value); |
| 1376 | try self.genSetStack(value_ty, off, value); |
| 1372 | 1377 | }, |
| 1373 | 1378 | .ptr_embedded_in_code => |off| { |
| 1374 | | try self.setRegOrMem(elem_ty, .{ .embedded_in_code = off }, value); |
| 1379 | try self.setRegOrMem(value_ty, .{ .embedded_in_code = off }, value); |
| 1375 | 1380 | }, |
| 1376 | 1381 | .embedded_in_code => { |
| 1377 | 1382 | return self.fail("TODO implement storing to MCValue.embedded_in_code", .{}); |
| 1378 | 1383 | }, |
| 1379 | | .register => { |
| 1380 | | return self.fail("TODO implement storing to MCValue.register", .{}); |
| 1384 | .register => |addr_reg| { |
| 1385 | switch (value) { |
| 1386 | .register => |value_reg| { |
| 1387 | _ = try self.addInst(.{ |
| 1388 | .tag = .str, |
| 1389 | .cond = .al, |
| 1390 | .data = .{ .rr_offset = .{ |
| 1391 | .rt = value_reg, |
| 1392 | .rn = addr_reg, |
| 1393 | .offset = .{ .offset = Instruction.Offset.none }, |
| 1394 | } }, |
| 1395 | }); |
| 1396 | }, |
| 1397 | else => { |
| 1398 | if (value_ty.abiSize(self.target.*) <= 4) { |
| 1399 | const tmp_reg = try self.register_manager.allocReg(null, &.{addr_reg}); |
| 1400 | try self.genSetReg(value_ty, tmp_reg, value); |
| 1401 | |
| 1402 | try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty); |
| 1403 | } else { |
| 1404 | return self.fail("TODO implement memcpy", .{}); |
| 1405 | } |
| 1406 | }, |
| 1407 | } |
| 1381 | 1408 | }, |
| 1382 | 1409 | .memory => { |
| 1410 | // const addr_reg = try self.copyToTmpRegister(ptr_ty, ptr); |
| 1411 | // try self.store(.{ .register = addr_reg }, value, ptr_ty, value_ty); |
| 1383 | 1412 | return self.fail("TODO implement storing to MCValue.memory", .{}); |
| 1384 | 1413 | }, |
| 1385 | 1414 | .stack_offset => { |
| 1386 | 1415 | return self.fail("TODO implement storing to MCValue.stack_offset", .{}); |
| 1387 | 1416 | }, |
| 1388 | 1417 | } |
| 1418 | } |
| 1419 | |
| 1420 | fn airStore(self: *Self, inst: Air.Inst.Index) !void { |
| 1421 | const bin_op = self.air.instructions.items(.data)[inst].bin_op; |
| 1422 | const ptr = try self.resolveInst(bin_op.lhs); |
| 1423 | const value = try self.resolveInst(bin_op.rhs); |
| 1424 | const ptr_ty = self.air.typeOf(bin_op.lhs); |
| 1425 | const value_ty = self.air.typeOf(bin_op.rhs); |
| 1426 | |
| 1427 | try self.store(ptr, value, ptr_ty, value_ty); |
| 1428 | |
| 1389 | 1429 | return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none }); |
| 1390 | 1430 | } |
| 1391 | 1431 | |
Joachim Schmidt <joachim.schmidt557@outlook.com> 2021-12-21 15:57:03+01:00
Andrew Kelley <andrew@ziglang.org> 2021-12-21 11:30:56-08:00
src