1pub fn writeSetSub6(comptime op: enum { set, sub }, code: *[1]u8, addend: anytype) void {
  2    const mask: u8 = 0b11_000000;
  3    const actual: i8 = @truncate(addend);
  4    var value: u8 = mem.readInt(u8, code, .little);
  5    switch (op) {
  6        .set => value = (value & mask) | @as(u8, @bitCast(actual & ~mask)),
  7        .sub => value = (value & mask) | (@as(u8, @bitCast(@as(i8, @bitCast(value)) -| actual)) & ~mask),
  8    }
  9    mem.writeInt(u8, code, value, .little);
 10}
 11
 12pub fn writeSubUleb(code: []u8, addend: i64) void {
 13    var reader: std.Io.Reader = .fixed(code);
 14    const value = reader.takeLeb128(u64) catch unreachable;
 15    overwriteUleb(code, value -% @as(u64, @intCast(addend)));
 16}
 17
 18pub fn writeSetUleb(code: []u8, addend: i64) void {
 19    overwriteUleb(code, @intCast(addend));
 20}
 21
 22fn overwriteUleb(code: []u8, addend: u64) void {
 23    var value: u64 = addend;
 24    var i: usize = 0;
 25
 26    while (true) {
 27        const byte = code[i];
 28        if (byte & 0x80 == 0) break;
 29        code[i] = 0x80 | @as(u8, @truncate(value & 0x7f));
 30        i += 1;
 31        value >>= 7;
 32    }
 33    code[i] = @truncate(value & 0x7f);
 34}
 35
 36pub fn writeAddend(
 37    comptime Int: type,
 38    comptime op: enum { add, sub },
 39    code: *[@typeInfo(Int).int.bits / 8]u8,
 40    value: anytype,
 41) void {
 42    var V: Int = mem.readInt(Int, code, .little);
 43    const addend: Int = @truncate(value);
 44    switch (op) {
 45        .add => V +|= addend, // TODO: I think saturating arithmetic is correct here
 46        .sub => V -|= addend,
 47    }
 48    mem.writeInt(Int, code, V, .little);
 49}
 50
 51pub fn writeInstU(code: *[4]u8, value: u32) void {
 52    var data: Instruction = .{ .U = mem.bytesToValue(@FieldType(Instruction, "U"), code) };
 53    const compensated: u32 = @bitCast(@as(i32, @bitCast(value)) + 0x800);
 54    data.U.imm12_31 = bitSlice(compensated, 31, 12);
 55    mem.writeInt(u32, code, data.toU32(), .little);
 56}
 57
 58pub fn writeInstI(code: *[4]u8, value: u32) void {
 59    var data: Instruction = .{ .I = mem.bytesToValue(@FieldType(Instruction, "I"), code) };
 60    data.I.imm0_11 = bitSlice(value, 11, 0);
 61    mem.writeInt(u32, code, data.toU32(), .little);
 62}
 63
 64pub fn writeInstS(code: *[4]u8, value: u32) void {
 65    var data: Instruction = .{ .S = mem.bytesToValue(@FieldType(Instruction, "S"), code) };
 66    data.S.imm0_4 = bitSlice(value, 4, 0);
 67    data.S.imm5_11 = bitSlice(value, 11, 5);
 68    mem.writeInt(u32, code, data.toU32(), .little);
 69}
 70
 71pub fn writeInstJ(code: *[4]u8, value: u32) void {
 72    var data: Instruction = .{ .J = mem.bytesToValue(@FieldType(Instruction, "J"), code) };
 73    data.J.imm1_10 = bitSlice(value, 10, 1);
 74    data.J.imm11 = bitSlice(value, 11, 11);
 75    data.J.imm12_19 = bitSlice(value, 19, 12);
 76    data.J.imm20 = bitSlice(value, 20, 20);
 77    mem.writeInt(u32, code, data.toU32(), .little);
 78}
 79
 80pub fn writeInstB(code: *[4]u8, value: u32) void {
 81    var data: Instruction = .{ .B = mem.bytesToValue(@FieldType(Instruction, "B"), code) };
 82    data.B.imm1_4 = bitSlice(value, 4, 1);
 83    data.B.imm5_10 = bitSlice(value, 10, 5);
 84    data.B.imm11 = bitSlice(value, 11, 11);
 85    data.B.imm12 = bitSlice(value, 12, 12);
 86    mem.writeInt(u32, code, data.toU32(), .little);
 87}
 88
 89fn bitSlice(
 90    value: anytype,
 91    comptime high: comptime_int,
 92    comptime low: comptime_int,
 93) std.math.IntFittingRange(0, 1 << high - low) {
 94    return @truncate((value >> low) & (1 << (high - low + 1)) - 1);
 95}
 96
 97pub const Eflags = packed struct(u32) {
 98    rvc: bool,
 99    fabi: FloatAbi,
100    rve: bool,
101    tso: bool,
102    _reserved: u19 = 0,
103    _unused: u8 = 0,
104
105    pub const FloatAbi = enum(u2) {
106        soft = 0b00,
107        single = 0b01,
108        double = 0b10,
109        quad = 0b11,
110    };
111};
112
113const mem = std.mem;
114const std = @import("std");
115
116const encoding = @import("../codegen/riscv64/encoding.zig");
117const Instruction = encoding.Instruction;