SandboXP

1
"use strict";
2

3

4
CPU.prototype.mmap_read8 = function(addr)
5
{
6
    const value = this.memory_map_read8[addr >>> MMAP_BLOCK_BITS](addr);
7
    dbg_assert(value >= 0 && value <= 0xFF);
8
    return value;
9
};
10

11
CPU.prototype.mmap_write8 = function(addr, value)
12
{
13
    dbg_assert(value >= 0 && value <= 0xFF);
14
    this.memory_map_write8[addr >>> MMAP_BLOCK_BITS](addr, value);
15
};
16

17
CPU.prototype.mmap_read16 = function(addr)
18
{
19
    var fn = this.memory_map_read8[addr >>> MMAP_BLOCK_BITS];
20
    const value = fn(addr) | fn(addr + 1 | 0) << 8;
21
    dbg_assert(value >= 0 && value <= 0xFFFF);
22
    return value;
23
};
24

25
CPU.prototype.mmap_write16 = function(addr, value)
26
{
27
    var fn = this.memory_map_write8[addr >>> MMAP_BLOCK_BITS];
28

29
    dbg_assert(value >= 0 && value <= 0xFFFF);
30
    fn(addr, value & 0xFF);
31
    fn(addr + 1 | 0, value >> 8);
32
};
33

34
CPU.prototype.mmap_read32 = function(addr)
35
{
36
    var aligned_addr = addr >>> MMAP_BLOCK_BITS;
37

38
    return this.memory_map_read32[aligned_addr](addr);
39
};
40

41
CPU.prototype.mmap_write32 = function(addr, value)
42
{
43
    var aligned_addr = addr >>> MMAP_BLOCK_BITS;
44

45
    this.memory_map_write32[aligned_addr](addr, value);
46
};
47

48
CPU.prototype.mmap_write64 = function(addr, value0, value1)
49
{
50
    var aligned_addr = addr >>> MMAP_BLOCK_BITS;
51
    // This should hold since writes across pages are split up
52
    dbg_assert(aligned_addr === (addr + 7) >>> MMAP_BLOCK_BITS);
53

54
    var write_func32 = this.memory_map_write32[aligned_addr];
55
    write_func32(addr, value0);
56
    write_func32(addr + 4, value1);
57
};
58

59
CPU.prototype.mmap_write128 = function(addr, value0, value1, value2, value3)
60
{
61
    var aligned_addr = addr >>> MMAP_BLOCK_BITS;
62
    // This should hold since writes across pages are split up
63
    dbg_assert(aligned_addr === (addr + 12) >>> MMAP_BLOCK_BITS);
64

65
    var write_func32 = this.memory_map_write32[aligned_addr];
66
    write_func32(addr, value0);
67
    write_func32(addr + 4, value1);
68
    write_func32(addr + 8, value2);
69
    write_func32(addr + 12, value3);
70
};
71

72
/**
73
 * @param {Array.<number>|Uint8Array} blob
74
 * @param {number} offset
75
 */
76
CPU.prototype.write_blob = function(blob, offset)
77
{
78
    dbg_assert(blob && blob.length >= 0);
79

80
    if(blob.length)
81
    {
82
        dbg_assert(!this.in_mapped_range(offset));
83
        dbg_assert(!this.in_mapped_range(offset + blob.length - 1));
84

85
        this.jit_dirty_cache(offset, offset + blob.length);
86
        this.mem8.set(blob, offset);
87
    }
88
};
89

90
CPU.prototype.read_blob = function(offset, length)
91
{
92
    if(length)
93
    {
94
        dbg_assert(!this.in_mapped_range(offset));
95
        dbg_assert(!this.in_mapped_range(offset + length - 1));
96
    }
97
    return this.mem8.subarray(offset, offset + length);
98
};
99