Extended-ARM-Emulator/sparse_array_2.h at master · janpavlis/Extended-ARM-Emulator · 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
#ifndef SPARSE_ARRAY_2_H
#define SPARSE_ARRAY_2_H

using namespace std;

#include "sparse_array_1.h"

extern const uint64_t CHUNKSIZE;

class A2 {
public:
    A1 **arrs;
    A2() {
        arrs = new A1*[CHUNKSIZE];
    }

    ~A2() {
        delete[] arrs;
    }

    inline uint8_t get(uint64_t address) {
        if ( arrs[address >> 22] != NULL ) {
            return arrs[address >> 22]->get(extract(address, 21, 0));
        }
        return 0;
    }

    inline uint32_t get_32(uint64_t address) {
        if ( arrs[address >> 22] != NULL ) {
            return arrs[address >> 22]->get_32(extract(address, 21, 0));
        }
        return 0;
    }

    inline uint64_t get_64(uint64_t address) {
        if ( arrs[address >> 22] != NULL ) {
            return arrs[address >> 22]->get_64(extract(address, 21, 0));
        }
        return 0;
    }

    inline atomic32data* get_32_atomic(uint64_t address) {
        if ( arrs[address >> 22] != NULL ) {
            return arrs[address >> 22]->get_32_atomic(extract(address, 21, 0));
        }
        return new atomic32data;
    }

    inline atomic64data* get_64_atomic(uint64_t address) {
        if ( arrs[address >> 22] != NULL ) {
            return arrs[address >> 22]->get_64_atomic(extract(address, 21, 0));
        }
        return new atomic64data;
    }

    inline void set(uint64_t address, uint8_t data) {
        // cout << address << " " << address >> 22 << " " << address % CHUNKSIZE << endl;
        if ( arrs[address >> 22] != NULL ) {
            arrs[address >> 22]->set(extract(address, 21, 0), data);
        } else {
            arrs[address >> 22] = new A1;
            arrs[address >> 22]->set(extract(address, 21, 0), data);
        }
    }

    inline void set_32(uint64_t address, uint32_t data) {
        if ( arrs[address >> 22] != NULL ) {
            arrs[address >> 22]->set_32(extract(address, 21, 0), data);
        } else {
            arrs[address >> 22] = new A1;
            arrs[address >> 22]->set_32(extract(address, 21, 0), data);
        }
    }

    inline void set_64(uint64_t address, uint64_t data) {
        if ( arrs[address >> 22] != NULL ) {
            arrs[address >> 22]->set_64(extract(address, 21, 0), data);
        } else {
            arrs[address >> 22] = new A1;
            arrs[address >> 22]->set_64(extract(address, 21, 0), data);
        }
    }

    inline void set_32_atomic(uint64_t address, uint32_t data) {
        if ( arrs[address >> 22] != NULL ) {
            arrs[address >> 22]->set_32_atomic(extract(address, 21, 0), data);
        } else {
            arrs[address >> 22] = new A1;
            arrs[address >> 22]->set_32_atomic(extract(address, 21, 0), data);
        }
    }

    inline void set_64_atomic(uint64_t address, uint64_t data) {
        if ( arrs[address >> 22] != NULL ) {
            arrs[address >> 22]->set_64_atomic(extract(address, 21, 0), data);
        } else {
            arrs[address >> 22] = new A1;
            arrs[address >> 22]->set_64_atomic(extract(address, 21, 0), data);
        }
    }

    inline void set_128(uint64_t address, unsigned __int128 data) {
        if ( arrs[address >> 22] != NULL ) {
            arrs[address >> 22]->set_128(extract(address, 21, 0), data);
        } else {
            arrs[address >> 22] = new A1;
            arrs[address >> 22]->set_128(extract(address, 21, 0), data);
        }
    }
};

#endif // SPARSE_ARRAY_2_H