tiny.stabilizer.Runtime

1pub const Runtime = struct {2    allocator: Allocator,3    config: config.Config,4    heap: ShuffleAllocator,5    stack: stack.StackPads,6    code: CodeRandomizer,7    rng: Marsaglia,8    stack_pad_slots: std.ArrayListUnmanaged(*u8) = .empty,9    constructors: std.ArrayListUnmanaged(ConstructorFn) = .empty,1011    pub fn init(allocator: Allocator, runtime_config: config.Config) !Runtime {12        var rng = Marsaglia.init(runtime_config.seed);13        var stack_pads = try stack.StackPads.init(allocator, runtime_config.stack, &rng);14        errdefer stack_pads.deinit();15        return .{16            .allocator = allocator,17            .config = runtime_config,18            .heap = ShuffleAllocator.init(allocator, runtime_config.heap, runtime_config.seed ^ 0x4845_4150),19            .stack = stack_pads,20            .code = CodeRandomizer.init(allocator, runtime_config.code, runtime_config.seed ^ 0x434f_4445),21            .rng = rng,22        };23    }2425    pub fn deinit(self: *Runtime) void {26        self.constructors.deinit(self.allocator);27        self.stack_pad_slots.deinit(self.allocator);28        self.code.deinit();29        self.stack.deinit();30        self.heap.deinit();31        self.* = undefined;32    }3334    pub fn randomizedAllocator(self: *Runtime) Allocator {35        return self.heap.allocator();36    }3738    pub fn malloc(self: *Runtime, len: usize) ![*]u8 {39        return self.heap.malloc(len);40    }4142    pub fn calloc(self: *Runtime, count: usize, len: usize) ![*]u8 {43        return self.heap.calloc(count, len);44    }4546    pub fn realloc(self: *Runtime, ptr: ?[*]u8, new_len: usize) !?[*]u8 {47        return self.heap.realloc(ptr, new_len);48    }4950    pub fn free(self: *Runtime, ptr: ?[*]u8) void {51        self.heap.freePointer(ptr);52    }5354    pub fn freeIfOwned(self: *Runtime, ptr: ?[*]u8) bool {55        return self.heap.freePointerIfOwned(ptr);56    }5758    pub fn ownsPointer(self: *const Runtime, ptr: ?[*]u8) bool {59        return self.heap.ownsPointer(ptr);60    }6162    pub fn registerStackPad(self: *Runtime, slot: *u8) !void {63        for (self.stack_pad_slots.items) |existing| {64            if (existing == slot) return;65        }66        try self.stack_pad_slots.append(self.allocator, slot);67    }6869    pub fn registeredStackPadCount(self: *const Runtime) usize {70        return self.stack_pad_slots.items.len;71    }7273    pub fn registerConstructor(self: *Runtime, constructor: ConstructorFn) !void {74        try self.constructors.append(self.allocator, constructor);75    }7677    pub fn constructorCount(self: *const Runtime) usize {78        return self.constructors.items.len;79    }8081    pub fn runConstructors(self: *Runtime) void {82        for (self.constructors.items) |constructor| constructor();83    }8485    pub fn registerFunctionRange(self: *Runtime, options: code_mod.FunctionRangeOptions) !code_mod.FunctionId {86        return self.code.registerFunctionRange(options);87    }8889    pub fn enterFunction(self: *Runtime, id: code_mod.FunctionId, roots: []const usize) !?usize {90        const location = try self.code.enterFunction(id, roots);91        return if (location) |active| active.base else null;92    }9394    pub fn trapFunction(self: *Runtime, id: code_mod.FunctionId, roots: []const usize) !usize {95        const location = try self.code.trap(id, roots);96        return location.base;97    }9899    pub fn adjustAddress(self: *const Runtime, address: usize) usize {100        return self.code.adjustAddress(address);101    }102103    pub fn adjustBacktrace(self: *const Runtime, adjusted: []usize, real: []const usize) []usize {104        const count = @min(adjusted.len, real.len);105        for (real[0..count], adjusted[0..count]) |address, *out| {106            out.* = self.adjustAddress(address);107        }108        return adjusted[0..count];109    }110111    pub fn runProgram(self: *Runtime, main: anytype, args: anytype) @TypeOf(@call(.auto, main, args)) {112        self.code.trapRegisteredFunctions();113        self.runConstructors();114        return @call(.auto, main, args);115    }116117    pub fn nextStackPad(self: *Runtime) stack.StackPad {118        return self.stack.next(&self.rng);119    }120121    pub fn rerandomize(self: *Runtime) void {122        _ = self.rerandomizeAt(0);123    }124125    pub fn rerandomizeAt(self: *Runtime, instruction_pointer: usize) usize {126        if (self.config.code.enabled) {127            if (self.code.functionCount() == 0) self.rerandomizeStackPads();128            return self.code.beginRerandomizationAt(instruction_pointer);129        } else {130            self.rerandomizeStackPads();131            return instruction_pointer;132        }133    }134135    fn rerandomizeStackPads(self: *Runtime) void {136        if (!self.config.stack.enabled) return;137        self.stack.refill(&self.rng);138        for (self.stack_pad_slots.items) |slot| {139            slot.* = self.rng.nextByte();140        }141    }142};

1pub const Runtime = runtime_mod.Runtime;