OpenSaturn/debug.zig at master · Linuxperoxo/OpenSaturn · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
// ┌──────────────────────────────────────────────┐
// │  (c) 2025 Linuxperoxo  •  FILE: debug.zig    │
// │            Author: Linuxperoxo               │
// └──────────────────────────────────────────────┘

comptime {
    @compileError("File Not Working");
}

pub const saturnArchInfos: type = @import("root").arch;

pub const RegDebug_x86_64: type = enum(u2) {
    rax,
    rcx,
    rdx,
    rbx,
    r8,
    r9,
    r10,
    r11,
    r12,
    r13,
    r14,
    r15,
};

const ArchBreakPoint: type = struct {
    pub const Archs: type = enum {
        x86,
        x86_64,
        arm,
    };

    const ArchsTypes: type = struct {
        pub const x86: type = struct {
            pub const Regs: type = enum {
                eax,
                ecx,
                edx,
                ebx,
            };

            const DebugAsm = "jmp .";

            pub inline fn breakpoint(A: anytype, comptime R: Regs) void {
                switch(@typeInfo(@TypeOf(A))) {
                    .@"struct" => |S| {
                        if(S.fields.len == 0) {
                            asm volatile(DebugAsm :::);
                        }
                    },
                    else => {},
                }
                switch(R) {
                    .eax => asm volatile(DebugAsm ::[_] "{eax}" (A):),
                    .ebx => asm volatile(DebugAsm ::[_] "{ebx}" (A):),
                    .ecx => asm volatile(DebugAsm ::[_] "{ecx}" (A):),
                    .edx => asm volatile(DebugAsm ::[_] "{edx}" (A):),
                }
            }
        };

        pub const x86_64: type = struct {
            pub const Regs: type = enum {
                rax,
                rcx,
                rdx,
                rbx,
                r8,
                r9,
                r10,
                r11,
                r12,
                r13,
                r14,
                r15,
            };

            pub inline fn breakpoint(_: anytype, comptime _: Regs) void {
                @compileError("breakpoint for x86_64 not implemented yet");
            }
        };

        pub const arm: type = struct {
            pub const Regs: type = enum {

            };

            pub inline fn breakpoint(_: anytype, comptime _: Regs) void {
                @compileError("breakpoint for arm not implemented yet");
            }
        };
    };

    pub fn Spawn(comptime A: Archs) type {
        return switch(A) {
            .x86 => ArchBreakPoint.ArchsTypes.x86,
            .x86_64 => ArchBreakPoint.ArchsTypes.x86_64,
            .arm => ArchBreakPoint.ArchsTypes.arm,
        };
    }
};

pub const breakpoint = init: {
    if(saturnArchInfos.__SaturnCodeModel__ != .Debug)
        break :init notbreakpoint;
    const archType = switch(saturnArchInfos.__SaturnTarget__) {
        .x86 => ArchBreakPoint.Spawn(.x86),
        .x86_64 => ArchBreakPoint.Spawn(.x86_64),
        .arm => ArchBreakPoint.Spawn(.arm),
        else => @compileError("Attempt to use debug mode in an architecture that does not support debug"),
    };
    if(!@hasDecl(archType, "breakpoint"))
        @compileError("Attempt to use debug mode in an architecture that does not support debug");
    break :init archType.breakpoint;
};

fn notbreakpoint(_: anytype, _: anytype) void {
    return;
}