tiny.deadalloc.RepairTable

1pub const RepairTable = struct {2    overflow_count: usize = 0,3    dangle_count: usize = 0,4    overflow_entries: [max_repair_entries]OverflowRepair = @as([max_repair_entries]OverflowRepair, @splat(.{})),5    dangle_entries: [max_repair_entries]DangleRepair = @as([max_repair_entries]DangleRepair, @splat(.{})),67    pub fn fromReport(report: report_mod.Report, current: RepairTable) RepairTable {8        var next = current;9        for (report.issueSlice()) |issue| next.recordIssue(issue);10        return next;11    }1213    pub fn overflowPadding(self: RepairTable, allocation_return_address: usize) usize {14        var index: usize = 0;15        while (index < self.overflow_count) : (index += 1) {16            const entry = self.overflow_entries[index];17            if (entry.allocation_return_address == allocation_return_address) return entry.padding_bytes;18        }19        return 0;20    }2122    pub fn lifeExtension(self: RepairTable, allocation_return_address: usize, free_return_address: usize) u64 {23        var index: usize = 0;24        while (index < self.dangle_count) : (index += 1) {25            const entry = self.dangle_entries[index];26            if (entry.allocation_return_address == allocation_return_address and entry.free_return_address == free_return_address) {27                return entry.quarantine_epochs;28            }29        }30        return 0;31    }3233    fn recordIssue(self: *RepairTable, issue: report_mod.Issue) void {34        switch (issue.kind) {35            .buffer_overflow => self.recordOverflow(issue),36            .use_after_free, .double_free => self.recordDangle(issue),37            .invalid_free, .leak, .size_mismatch => {},38        }39    }4041    fn recordOverflow(self: *RepairTable, issue: report_mod.Issue) void {42        if (issue.allocation_return_address == 0) return;43        const needed = if (issue.offset >= issue.requested_len)44            issue.offset - issue.requested_len + 145        else46            1;47        if (needed == 0) return;4849        var index: usize = 0;50        while (index < self.overflow_count) : (index += 1) {51            if (self.overflow_entries[index].allocation_return_address == issue.allocation_return_address) {52                self.overflow_entries[index].padding_bytes = @max(self.overflow_entries[index].padding_bytes, needed);53                return;54            }55        }56        if (self.overflow_count == self.overflow_entries.len) return;57        self.overflow_entries[self.overflow_count] = .{58            .allocation_return_address = issue.allocation_return_address,59            .padding_bytes = needed,60        };61        self.overflow_count += 1;62    }6364    fn recordDangle(self: *RepairTable, issue: report_mod.Issue) void {65        if (issue.allocation_return_address == 0) return;66        const free_return_address = if (issue.free_return_address != 0) issue.free_return_address else issue.return_address;67        if (free_return_address == 0) return;6869        var index: usize = 0;70        while (index < self.dangle_count) : (index += 1) {71            if (self.dangle_entries[index].allocation_return_address == issue.allocation_return_address and self.dangle_entries[index].free_return_address == free_return_address) {72                self.dangle_entries[index].quarantine_epochs = growU64(self.dangle_entries[index].quarantine_epochs, 1, 4096);73                return;74            }75        }76        if (self.dangle_count == self.dangle_entries.len) return;77        self.dangle_entries[self.dangle_count] = .{78            .allocation_return_address = issue.allocation_return_address,79            .free_return_address = free_return_address,80            .quarantine_epochs = 1,81        };82        self.dangle_count += 1;83    }84};

1pub const RepairTable = exterminator_mod.RepairTable;