pain64/mmu.c at main · EscapeCharacter-dev/pain64 · 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
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "pain64.h"

static uint8_t *_mem_space;

#define MEM_SPACE   sizeof(uint64_t) * 1024 * 1000 * 64

void pain64_open_mem(void) {
    _mem_space = malloc(MEM_SPACE);
    return;
}

static inline int _check_addr(uint64_t address) {
    return address >= MEM_SPACE || address == 0;
}

float64_t *pain64_resolve_addr_F64(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(F64): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (float64_t *)(_mem_space + address);
}

float32_t *pain64_resolve_addr_F32(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(F32): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (float32_t *)(_mem_space + address);
}

uint64_t *pain64_resolve_addr_U64(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(U64): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (uint64_t *)(_mem_space + address);
}

int64_t *pain64_resolve_addr_I64(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(I64): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (int64_t *)(_mem_space + address);
}

uint32_t *pain64_resolve_addr_U32(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(U32): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (uint32_t *)(_mem_space + address);
}

int32_t *pain64_resolve_addr_I32(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(I32): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (int32_t *)(_mem_space + address);
}

uint16_t *pain64_resolve_addr_U16(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(U16): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (uint16_t *)(_mem_space + address);
}

int16_t *pain64_resolve_addr_I16(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(I16): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (int16_t *)(_mem_space + address);
}

uint8_t *pain64_resolve_addr_U8(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(U8): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (uint8_t *)(_mem_space + address);
}

int8_t *pain64_resolve_addr_I8(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(I8): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (int8_t *)(_mem_space + address);
}

struct pain64_device *pain64_resolve_addr_DEVICE(uint64_t address) {
    if (_check_addr(address)) {
        fprintf(stderr, "pain64.mmu(D): Invalid addresss 0x%x\n", address);
        return 0;
    }
    return (struct pain64_device *)(_mem_space + address);
}

void pain64_close_mem(void) {
    free(_mem_space);
    return;
}

void pain64_load_program(uint64_t offset, uint8_t *code, size_t code_size) {
    memcpy((char *)(_mem_space + offset), code, code_size);
    return;
}