trunk/src/memory.c

/*
 *  Copyright (C) 2003-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: memory.c,v 1.202 2007/04/28 09:19:51 debug Exp $
 *
 *  Functions for handling the memory of an emulated machine.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/mman.h>

#include "cpu.h"
#include "machine.h"
#include "memory.h"
#include "misc.h"


extern int verbose;
extern int quiet_mode;


/*
 *  memory_readmax64():
 *
 *  Read at most 64 bits of data from a buffer.  Length is given by
 *  len, and the byte order by cpu->byte_order.
 *
 *  This function should not be called with cpu == NULL.
 */
uint64_t memory_readmax64(struct cpu *cpu, unsigned char *buf, int len)
{
        int i, byte_order = cpu->byte_order;
        uint64_t x = 0;

        if (len & MEM_PCI_LITTLE_ENDIAN) {
                len &= ~MEM_PCI_LITTLE_ENDIAN;
                byte_order = EMUL_LITTLE_ENDIAN;
        }

        /*  Switch byte order for incoming data, if necessary:  */
        if (byte_order == EMUL_BIG_ENDIAN)
                for (i=0; i<len; i++) {
                        x <<= 8;
                        x |= buf[i];
                }
        else
                for (i=len-1; i>=0; i--) {
                        x <<= 8;
                        x |= buf[i];
                }

        return x;
}


/*
 *  memory_writemax64():
 *
 *  Write at most 64 bits of data to a buffer.  Length is given by
 *  len, and the byte order by cpu->byte_order.
 *
 *  This function should not be called with cpu == NULL.
 */
void memory_writemax64(struct cpu *cpu, unsigned char *buf, int len,
        uint64_t data)
{
        int i, byte_order = cpu->byte_order;

        if (len & MEM_PCI_LITTLE_ENDIAN) {
                len &= ~MEM_PCI_LITTLE_ENDIAN;
                byte_order = EMUL_LITTLE_ENDIAN;
        }

        if (byte_order == EMUL_LITTLE_ENDIAN)
                for (i=0; i<len; i++) {
                        buf[i] = data & 255;
                        data >>= 8;
                }
        else
                for (i=0; i<len; i++) {
                        buf[len - 1 - i] = data & 255;
                        data >>= 8;
                }
}


/*
 *  zeroed_alloc():
 *
 *  Allocates a block of memory using mmap(), and if that fails, try
 *  malloc() + memset(). The returned memory block contains only zeroes.
 */
void *zeroed_alloc(size_t s)
{
        void *p = mmap(NULL, s, PROT_READ | PROT_WRITE,
            MAP_ANON | MAP_PRIVATE, -1, 0);

        if (p == NULL) {
#if 1
                fprintf(stderr, "zeroed_alloc(): mmap() failed. This should"
                    " not usually happen. If you can reproduce this, then"
                    " please contact me with details about your run-time"
                    " environment.\n");
                exit(1);
#else
                p = malloc(s);
                if (p == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
                memset(p, 0, s);
#endif
        }

        return p;
}


/*
 *  memory_new():
 *
 *  This function creates a new memory object. An emulated machine needs one
 *  of these.
 */
struct memory *memory_new(uint64_t physical_max, int arch)
{
        struct memory *mem;
        int bits_per_pagetable = BITS_PER_PAGETABLE;
        int bits_per_memblock = BITS_PER_MEMBLOCK;
        int entries_per_pagetable = 1 << BITS_PER_PAGETABLE;
        int max_bits = MAX_BITS;
        size_t s;

        mem = malloc(sizeof(struct memory));
        if (mem == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(mem, 0, sizeof(struct memory));

        /*  Check bits_per_pagetable and bits_per_memblock for sanity:  */
        if (bits_per_pagetable + bits_per_memblock != max_bits) {
                fprintf(stderr, "memory_new(): bits_per_pagetable and "
                    "bits_per_memblock mismatch\n");
                exit(1);
        }

        mem->physical_max = physical_max;
        mem->dev_dyntrans_alignment = 4095;
        if (arch == ARCH_ALPHA)
                mem->dev_dyntrans_alignment = 8191;

        s = entries_per_pagetable * sizeof(void *);

        mem->pagetable = (unsigned char *) mmap(NULL, s,
            PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
        if (mem->pagetable == NULL) {
                mem->pagetable = malloc(s);
                if (mem->pagetable == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
                memset(mem->pagetable, 0, s);
        }

        mem->mmap_dev_minaddr = 0xffffffffffffffffULL;
        mem->mmap_dev_maxaddr = 0;

        return mem;
}


/*
 *  memory_points_to_string():
 *
 *  Returns 1 if there's something string-like in emulated memory at address
 *  addr, otherwise 0.
 */
int memory_points_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,
        int min_string_length)
{
        int cur_length = 0;
        unsigned char c;

        for (;;) {
                c = '\0';
                cpu->memory_rw(cpu, mem, addr+cur_length,
                    &c, sizeof(c), MEM_READ, CACHE_NONE | NO_EXCEPTIONS);
                if (c=='\n' || c=='\t' || c=='\r' || (c>=' ' && c<127)) {
                        cur_length ++;
                        if (cur_length >= min_string_length)
                                return 1;
                } else {
                        if (cur_length >= min_string_length)
                                return 1;
                        else
                                return 0;
                }
        }
}


/*
 *  memory_conv_to_string():
 *
 *  Convert emulated memory contents to a string, placing it in a buffer
 *  provided by the caller.
 */
char *memory_conv_to_string(struct cpu *cpu, struct memory *mem, uint64_t addr,
        char *buf, int bufsize)
{
        int len = 0;
        int output_index = 0;
        unsigned char c, p='\0';

        while (output_index < bufsize-1) {
                c = '\0';
                cpu->memory_rw(cpu, mem, addr+len, &c, sizeof(c), MEM_READ,
                    CACHE_NONE | NO_EXCEPTIONS);
                buf[output_index] = c;
                if (c>=' ' && c<127) {
                        len ++;
                        output_index ++;
                } else if (c=='\n' || c=='\r' || c=='\t') {
                        len ++;
                        buf[output_index] = '\\';
                        output_index ++;
                        switch (c) {
                        case '\n':      p = 'n'; break;
                        case '\r':      p = 'r'; break;
                        case '\t':      p = 't'; break;
                        }
                        if (output_index < bufsize-1) {
                                buf[output_index] = p;
                                output_index ++;
                        }
                } else {
                        buf[output_index] = '\0';
                        return buf;
                }
        }

        buf[bufsize-1] = '\0';
        return buf;
}


/*
 *  memory_device_dyntrans_access():
 *
 *  Get the lowest and highest dyntrans access since last time.
 */
void memory_device_dyntrans_access(struct cpu *cpu, struct memory *mem,
        void *extra, uint64_t *low, uint64_t *high)
{
        size_t s;
        int i, need_inval = 0;

        /*  TODO: This is O(n), so it might be good to rewrite it some day.
            For now, it will be enough, as long as this function is not
            called too often.  */

        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (mem->devices[i].extra == extra &&
                    mem->devices[i].flags & DM_DYNTRANS_WRITE_OK &&
                    mem->devices[i].dyntrans_data != NULL) {
                        if (mem->devices[i].dyntrans_write_low != (uint64_t) -1)
                                need_inval = 1;
                        if (low != NULL)
                                *low = mem->devices[i].dyntrans_write_low;
                        mem->devices[i].dyntrans_write_low = (uint64_t) -1;

                        if (high != NULL)
                                *high = mem->devices[i].dyntrans_write_high;
                        mem->devices[i].dyntrans_write_high = 0;

                        if (!need_inval)
                                return;

                        /*  Invalidate any pages of this device that might
                            be in the dyntrans load/store cache, by marking
                            the pages read-only.  */
                        if (cpu->invalidate_translation_caches != NULL) {
                                for (s = *low; s <= *high;
                                    s += cpu->machine->arch_pagesize)
                                        cpu->invalidate_translation_caches
                                            (cpu, mem->devices[i].baseaddr + s,
                                            JUST_MARK_AS_NON_WRITABLE
                                            | INVALIDATE_PADDR);
                        }

                        return;
                }
        }
}


/*
 *  memory_device_update_data():
 *
 *  Update a device' dyntrans data pointer.
 *
 *  SUPER-IMPORTANT NOTE: Anyone who changes a dyntrans data pointer while
 *  things are running also needs to invalidate all CPUs' address translation
 *  caches!  Otherwise, these may contain old pointers to the old data.
 */
void memory_device_update_data(struct memory *mem, void *extra,
        unsigned char *data)
{
        int i;

        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (mem->devices[i].extra != extra)
                        continue;

                mem->devices[i].dyntrans_data = data;
                mem->devices[i].dyntrans_write_low = (uint64_t)-1;
                mem->devices[i].dyntrans_write_high = 0;
        }
}


/*
 *  memory_device_register():
 *
 *  Register a memory mapped device.
 */
void memory_device_register(struct memory *mem, const char *device_name,
        uint64_t baseaddr, uint64_t len,
        int (*f)(struct cpu *,struct memory *,uint64_t,unsigned char *,
                size_t,int,void *),
        void *extra, int flags, unsigned char *dyntrans_data)
{
        int i, newi = 0;

        /*
         *  Figure out at which index to insert this device, and simultaneously
         *  check for collisions:
         */
        newi = -1;
        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (i == 0 && baseaddr + len <= mem->devices[i].baseaddr)
                        newi = i;
                if (i > 0 && baseaddr + len <= mem->devices[i].baseaddr &&
                    baseaddr >= mem->devices[i-1].endaddr)
                        newi = i;
                if (i == mem->n_mmapped_devices - 1 &&
                    baseaddr >= mem->devices[i].endaddr)
                        newi = i + 1;

                /*  If this is not colliding with device i, then continue:  */
                if (baseaddr + len <= mem->devices[i].baseaddr)
                        continue;
                if (baseaddr >= mem->devices[i].endaddr)
                        continue;

                fatal("\nERROR! \"%s\" collides with device %i (\"%s\")!\n",
                    device_name, i, mem->devices[i].name);
                exit(1);
        }
        if (mem->n_mmapped_devices == 0)
                newi = 0;
        if (newi == -1) {
                fatal("INTERNAL ERROR\n");
                exit(1);
        }

        if (verbose >= 2) {
                /*  (40 bits of physical address is displayed)  */
                debug("device at 0x%010"PRIx64": %s", (uint64_t) baseaddr,
                    device_name);

                if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)
                    && (baseaddr & mem->dev_dyntrans_alignment) != 0) {
                        fatal("\nWARNING: Device dyntrans access, but unaligned"
                            " baseaddr 0x%"PRIx64".\n", (uint64_t) baseaddr);
                }

                if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)) {
                        debug(" (dyntrans %s)",
                            (flags & DM_DYNTRANS_WRITE_OK)? "R/W" : "R");
                }
                debug("\n");
        }

        for (i=0; i<mem->n_mmapped_devices; i++) {
                if (dyntrans_data == mem->devices[i].dyntrans_data &&
                    mem->devices[i].flags&(DM_DYNTRANS_OK|DM_DYNTRANS_WRITE_OK)
                    && flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)) {
                        fatal("ERROR: the data pointer used for dyntrans "
                            "accesses must only be used once!\n");
                        fatal("(%p cannot be used by '%s'; already in use by '"
                            "%s')\n", dyntrans_data, device_name,
                            mem->devices[i].name);
                        exit(1);
                }
        }

        mem->n_mmapped_devices++;

        mem->devices = realloc(mem->devices, sizeof(struct memory_device)
            * mem->n_mmapped_devices);
        if (mem->devices == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        /*  Make space for the new entry:  */
        if (newi + 1 != mem->n_mmapped_devices)
                memmove(&mem->devices[newi+1], &mem->devices[newi],
                    sizeof(struct memory_device)
                    * (mem->n_mmapped_devices - newi - 1));

        mem->devices[newi].name = strdup(device_name);
        mem->devices[newi].baseaddr = baseaddr;
        mem->devices[newi].endaddr = baseaddr + len;
        mem->devices[newi].length = len;
        mem->devices[newi].flags = flags;
        mem->devices[newi].dyntrans_data = dyntrans_data;

        if (mem->devices[newi].name == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        if (flags & (DM_DYNTRANS_OK | DM_DYNTRANS_WRITE_OK)
            && !(flags & DM_EMULATED_RAM) && dyntrans_data == NULL) {
                fatal("\nERROR: Device dyntrans access, but dyntrans_data"
                    " = NULL!\n");
                exit(1);
        }

        if ((size_t)dyntrans_data & (sizeof(void *) - 1)) {
                fprintf(stderr, "memory_device_register():"
                    " dyntrans_data not aligned correctly (%p)\n",
                    dyntrans_data);
                exit(1);
        }

        mem->devices[newi].dyntrans_write_low = (uint64_t)-1;
        mem->devices[newi].dyntrans_write_high = 0;
        mem->devices[newi].f = f;
        mem->devices[newi].extra = extra;

        if (baseaddr < mem->mmap_dev_minaddr)
                mem->mmap_dev_minaddr = baseaddr & ~mem->dev_dyntrans_alignment;
        if (baseaddr + len > mem->mmap_dev_maxaddr)
                mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) |
                    mem->dev_dyntrans_alignment) + 1;

        if (newi < mem->last_accessed_device)
                mem->last_accessed_device ++;
}


/*
 *  memory_device_remove():
 *
 *  Unregister a memory mapped device from a memory object.
 */
void memory_device_remove(struct memory *mem, int i)
{
        if (i < 0 || i >= mem->n_mmapped_devices) {
                fatal("memory_device_remove(): invalid device number %i\n", i);
                exit(1);
        }

        mem->n_mmapped_devices --;

        if (i == mem->n_mmapped_devices)
                return;

        memmove(&mem->devices[i], &mem->devices[i+1],
            sizeof(struct memory_device) * (mem->n_mmapped_devices - i));

        if (i <= mem->last_accessed_device)
                mem->last_accessed_device --;
        if (mem->last_accessed_device < 0)
                mem->last_accessed_device = 0;
}


#define MEMORY_RW       userland_memory_rw
#define MEM_USERLAND
#include "memory_rw.c"
#undef MEM_USERLAND
#undef MEMORY_RW


/*
 *  memory_paddr_to_hostaddr():
 *
 *  Translate a physical address into a host address. The usual way to call
 *  this function is to make sure that paddr is page aligned, which will result
 *  in the host _page_ corresponding to that address.
 *
 *  Return value is a pointer to the address in the host, or NULL on failure.
 *  On reads, a NULL return value should be interpreted as reading all zeroes.
 */
unsigned char *memory_paddr_to_hostaddr(struct memory *mem,
        uint64_t paddr, int writeflag)
{
        void **table;
        int entry;
        const int mask = (1 << BITS_PER_PAGETABLE) - 1;
        const int shrcount = MAX_BITS - BITS_PER_PAGETABLE;
        unsigned char *hostptr;

        table = mem->pagetable;
        entry = (paddr >> shrcount) & mask;

        /*  printf("memory_paddr_to_hostaddr(): p=%16"PRIx64
            " w=%i => entry=0x%x\n", (uint64_t) paddr, writeflag, entry);  */

        if (table[entry] == NULL) {
                size_t alloclen;

                /*
                 *  Special case:  reading from a nonexistant memblock
                 *  returns all zeroes, and doesn't allocate anything.
                 *  (If any intermediate pagetable is nonexistant, then
                 *  the same thing happens):
                 */
                if (writeflag == MEM_READ)
                        return NULL;

                /*  Allocate a memblock:  */
                alloclen = 1 << BITS_PER_MEMBLOCK;

                /*  printf("  allocating for entry %i, len=%i\n",
                    entry, alloclen);  */

                /*  Anonymous mmap() should return zero-filled memory,
                    try malloc + memset if mmap failed.  */
                table[entry] = (void *) mmap(NULL, alloclen,
                    PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
                if (table[entry] == NULL) {
                        table[entry] = malloc(alloclen);
                        if (table[entry] == NULL) {
                                fatal("out of memory\n");
                                exit(1);
                        }
                        memset(table[entry], 0, alloclen);
                }
        }

        hostptr = (unsigned char *) table[entry];

        if (hostptr != NULL)
                hostptr += (paddr & ((1 << BITS_PER_MEMBLOCK) - 1));

        return hostptr;
}


#define UPDATE_CHECKSUM(value) {                                        \
                internal_state -= 0x118c7771c0c0a77fULL;                \
                internal_state = ((internal_state + (value)) << 7) ^    \
                    (checksum >> 11) ^ ((checksum - (value)) << 3) ^    \
                    (internal_state - checksum) ^ ((value) - internal_state); \
                checksum ^= internal_state;                             \
        }


/*
 *  memory_checksum():
 *
 *  Calculate a 64-bit checksum of everything in a struct memory. This is
 *  useful for tracking down bugs; an old (presumably working) version of
 *  the emulator can be compared to a newer (buggy) version.
 */
uint64_t memory_checksum(struct memory *mem)
{
        uint64_t internal_state = 0x80624185376feff2ULL;
        uint64_t checksum = 0xcb9a87d5c010072cULL;
        const size_t n_entries = (1 << BITS_PER_PAGETABLE) - 1;
        const size_t len = (1 << BITS_PER_MEMBLOCK) / sizeof(uint64_t);
        size_t entry, i;

        for (entry=0; entry<=n_entries; entry++) {
                uint64_t **table = mem->pagetable;
                uint64_t *memblock = table[entry];

                if (memblock == NULL) {
                        UPDATE_CHECKSUM(0x1198ab7c8174a76fULL);
                        continue;
                }

                for (i=0; i<len; i++)
                        UPDATE_CHECKSUM(memblock[i]);
        }

        return checksum;
}


/*
 *  memory_warn_about_unimplemented_addr():
 *
 *  Called from memory_rw whenever memory outside of the physical address space
 *  is accessed (and quiet_mode isn't set).
 */
void memory_warn_about_unimplemented_addr(struct cpu *cpu, struct memory *mem,
        int writeflag, uint64_t paddr, uint8_t *data, size_t len)
{
        uint64_t offset, old_pc = cpu->pc;
        char *symbol;

        /*
         *  This allows guest OS kernels to probe memory a few KBs past the
         *  end of memory, without giving too many warnings.
         */
        if (paddr < mem->physical_max + 0x40000)
                return;

        if (!cpu->machine->halt_on_nonexistant_memaccess && quiet_mode)
                return;

        fatal("[ memory_rw(): %s ", writeflag? "write":"read");

        if (writeflag) {
                unsigned int i;
                debug("data={", writeflag);
                if (len > 16) {
                        int start2 = len-16;
                        for (i=0; i<16; i++)
                                debug("%s%02x", i?",":"", data[i]);
                        debug(" .. ");
                        if (start2 < 16)
                                start2 = 16;
                        for (i=start2; i<len; i++)
                                debug("%s%02x", i?",":"", data[i]);
                } else
                        for (i=0; i<len; i++)
                                debug("%s%02x", i?",":"", data[i]);
                debug("} ");
        }

        fatal("paddr=0x%llx >= physical_max; pc=", (long long)paddr);
        if (cpu->is_32bit)
                fatal("0x%08"PRIx32, (uint32_t) old_pc);
        else
                fatal("0x%016"PRIx64, (uint64_t) old_pc);
        symbol = get_symbol_name(&cpu->machine->symbol_context,
            old_pc, &offset);
        fatal(" <%s> ]\n", symbol? symbol : " no symbol ");

        if (cpu->machine->halt_on_nonexistant_memaccess) {
                /*  TODO: Halt in a nicer way. Not possible with the
                    current dyntrans system...  */
                exit(1);
        }
}

1	dpavlin	2	/*
2	dpavlin	34	* Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3	dpavlin	2	*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	40	* $Id: memory.c,v 1.202 2007/04/28 09:19:51 debug Exp $
29	dpavlin	2	*
30			* Functions for handling the memory of an emulated machine.
31			*/
32
33			#include <stdio.h>
34			#include <stdlib.h>
35			#include <string.h>
36			#include <sys/types.h>
37			#include <sys/mman.h>
38
39			#include "cpu.h"
40			#include "machine.h"
41			#include "memory.h"
42			#include "misc.h"
43
44
45	dpavlin	22	extern int verbose;
46	dpavlin	34	extern int quiet_mode;
47	dpavlin	2
48
49			/*
50			* memory_readmax64():
51			*
52			* Read at most 64 bits of data from a buffer. Length is given by
53			* len, and the byte order by cpu->byte_order.
54			*
55			* This function should not be called with cpu == NULL.
56			*/
57			uint64_t memory_readmax64(struct cpu cpu, unsigned char buf, int len)
58			{
59	dpavlin	20	int i, byte_order = cpu->byte_order;
60	dpavlin	2	uint64_t x = 0;
61
62	dpavlin	20	if (len & MEM_PCI_LITTLE_ENDIAN) {
63			len &= ~MEM_PCI_LITTLE_ENDIAN;
64			byte_order = EMUL_LITTLE_ENDIAN;
65			}
66
67	dpavlin	2	/* Switch byte order for incoming data, if necessary: */
68	dpavlin	20	if (byte_order == EMUL_BIG_ENDIAN)
69	dpavlin	2	for (i=0; i<len; i++) {
70			x <<= 8;
71			x \|= buf[i];
72			}
73			else
74			for (i=len-1; i>=0; i--) {
75			x <<= 8;
76			x \|= buf[i];
77			}
78
79			return x;
80			}
81
82
83			/*
84			* memory_writemax64():
85			*
86			* Write at most 64 bits of data to a buffer. Length is given by
87			* len, and the byte order by cpu->byte_order.
88			*
89			* This function should not be called with cpu == NULL.
90			*/
91			void memory_writemax64(struct cpu cpu, unsigned char buf, int len,
92			uint64_t data)
93			{
94	dpavlin	20	int i, byte_order = cpu->byte_order;
95	dpavlin	2
96	dpavlin	20	if (len & MEM_PCI_LITTLE_ENDIAN) {
97			len &= ~MEM_PCI_LITTLE_ENDIAN;
98			byte_order = EMUL_LITTLE_ENDIAN;
99			}
100
101			if (byte_order == EMUL_LITTLE_ENDIAN)
102	dpavlin	2	for (i=0; i<len; i++) {
103			buf[i] = data & 255;
104			data >>= 8;
105			}
106			else
107			for (i=0; i<len; i++) {
108			buf[len - 1 - i] = data & 255;
109			data >>= 8;
110			}
111			}
112
113
114			/*
115			* zeroed_alloc():
116			*
117			* Allocates a block of memory using mmap(), and if that fails, try
118	dpavlin	12	* malloc() + memset(). The returned memory block contains only zeroes.
119	dpavlin	2	*/
120			void *zeroed_alloc(size_t s)
121			{
122			void *p = mmap(NULL, s, PROT_READ \| PROT_WRITE,
123			MAP_ANON \| MAP_PRIVATE, -1, 0);
124	dpavlin	32
125	dpavlin	2	if (p == NULL) {
126	dpavlin	32	#if 1
127			fprintf(stderr, "zeroed_alloc(): mmap() failed. This should"
128			" not usually happen. If you can reproduce this, then"
129			" please contact me with details about your run-time"
130			" environment.\n");
131			exit(1);
132			#else
133	dpavlin	2	p = malloc(s);
134			if (p == NULL) {
135			fprintf(stderr, "out of memory\n");
136			exit(1);
137			}
138			memset(p, 0, s);
139	dpavlin	32	#endif
140	dpavlin	2	}
141	dpavlin	32
142	dpavlin	2	return p;
143			}
144
145
146			/*
147			* memory_new():
148			*
149			* This function creates a new memory object. An emulated machine needs one
150			* of these.
151			*/
152	dpavlin	12	struct memory *memory_new(uint64_t physical_max, int arch)
153	dpavlin	2	{
154			struct memory *mem;
155			int bits_per_pagetable = BITS_PER_PAGETABLE;
156			int bits_per_memblock = BITS_PER_MEMBLOCK;
157			int entries_per_pagetable = 1 << BITS_PER_PAGETABLE;
158			int max_bits = MAX_BITS;
159			size_t s;
160
161			mem = malloc(sizeof(struct memory));
162			if (mem == NULL) {
163			fprintf(stderr, "out of memory\n");
164			exit(1);
165			}
166
167			memset(mem, 0, sizeof(struct memory));
168
169			/* Check bits_per_pagetable and bits_per_memblock for sanity: */
170			if (bits_per_pagetable + bits_per_memblock != max_bits) {
171			fprintf(stderr, "memory_new(): bits_per_pagetable and "
172			"bits_per_memblock mismatch\n");
173			exit(1);
174			}
175
176			mem->physical_max = physical_max;
177	dpavlin	12	mem->dev_dyntrans_alignment = 4095;
178			if (arch == ARCH_ALPHA)
179			mem->dev_dyntrans_alignment = 8191;
180	dpavlin	2
181			s = entries_per_pagetable * sizeof(void *);
182
183			mem->pagetable = (unsigned char *) mmap(NULL, s,
184			PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE, -1, 0);
185			if (mem->pagetable == NULL) {
186			mem->pagetable = malloc(s);
187			if (mem->pagetable == NULL) {
188			fprintf(stderr, "out of memory\n");
189			exit(1);
190			}
191			memset(mem->pagetable, 0, s);
192			}
193
194			mem->mmap_dev_minaddr = 0xffffffffffffffffULL;
195			mem->mmap_dev_maxaddr = 0;
196
197			return mem;
198			}
199
200
201			/*
202			* memory_points_to_string():
203			*
204	dpavlin	22	* Returns 1 if there's something string-like in emulated memory at address
205			* addr, otherwise 0.
206	dpavlin	2	*/
207			int memory_points_to_string(struct cpu cpu, struct memory mem, uint64_t addr,
208			int min_string_length)
209			{
210			int cur_length = 0;
211			unsigned char c;
212
213			for (;;) {
214			c = '\0';
215			cpu->memory_rw(cpu, mem, addr+cur_length,
216			&c, sizeof(c), MEM_READ, CACHE_NONE \| NO_EXCEPTIONS);
217			if (c=='\n' \|\| c=='\t' \|\| c=='\r' \|\| (c>=' ' && c<127)) {
218			cur_length ++;
219			if (cur_length >= min_string_length)
220			return 1;
221			} else {
222			if (cur_length >= min_string_length)
223			return 1;
224			else
225			return 0;
226			}
227			}
228			}
229
230
231			/*
232			* memory_conv_to_string():
233			*
234	dpavlin	22	* Convert emulated memory contents to a string, placing it in a buffer
235			* provided by the caller.
236	dpavlin	2	*/
237			char memory_conv_to_string(struct cpu cpu, struct memory *mem, uint64_t addr,
238			char *buf, int bufsize)
239			{
240			int len = 0;
241			int output_index = 0;
242			unsigned char c, p='\0';
243
244			while (output_index < bufsize-1) {
245			c = '\0';
246			cpu->memory_rw(cpu, mem, addr+len, &c, sizeof(c), MEM_READ,
247			CACHE_NONE \| NO_EXCEPTIONS);
248			buf[output_index] = c;
249			if (c>=' ' && c<127) {
250			len ++;
251			output_index ++;
252			} else if (c=='\n' \|\| c=='\r' \|\| c=='\t') {
253			len ++;
254			buf[output_index] = '\\';
255			output_index ++;
256			switch (c) {
257			case '\n': p = 'n'; break;
258			case '\r': p = 'r'; break;
259			case '\t': p = 't'; break;
260			}
261			if (output_index < bufsize-1) {
262			buf[output_index] = p;
263			output_index ++;
264			}
265			} else {
266			buf[output_index] = '\0';
267			return buf;
268			}
269			}
270
271			buf[bufsize-1] = '\0';
272			return buf;
273			}
274
275
276			/*
277	dpavlin	12	* memory_device_dyntrans_access():
278	dpavlin	2	*
279	dpavlin	22	* Get the lowest and highest dyntrans access since last time.
280	dpavlin	2	*/
281	dpavlin	12	void memory_device_dyntrans_access(struct cpu cpu, struct memory mem,
282	dpavlin	2	void extra, uint64_t low, uint64_t *high)
283			{
284			size_t s;
285	dpavlin	24	int i, need_inval = 0;
286	dpavlin	2
287			/* TODO: This is O(n), so it might be good to rewrite it some day.
288			For now, it will be enough, as long as this function is not
289			called too often. */
290
291			for (i=0; i<mem->n_mmapped_devices; i++) {
292	dpavlin	32	if (mem->devices[i].extra == extra &&
293			mem->devices[i].flags & DM_DYNTRANS_WRITE_OK &&
294			mem->devices[i].dyntrans_data != NULL) {
295			if (mem->devices[i].dyntrans_write_low != (uint64_t) -1)
296	dpavlin	2	need_inval = 1;
297			if (low != NULL)
298	dpavlin	32	*low = mem->devices[i].dyntrans_write_low;
299			mem->devices[i].dyntrans_write_low = (uint64_t) -1;
300	dpavlin	2
301			if (high != NULL)
302	dpavlin	32	*high = mem->devices[i].dyntrans_write_high;
303			mem->devices[i].dyntrans_write_high = 0;
304	dpavlin	2
305			if (!need_inval)
306			return;
307
308			/* Invalidate any pages of this device that might
309	dpavlin	12	be in the dyntrans load/store cache, by marking
310	dpavlin	2	the pages read-only. */
311	dpavlin	18	if (cpu->invalidate_translation_caches != NULL) {
312	dpavlin	32	for (s = low; s <= high;
313			s += cpu->machine->arch_pagesize)
314	dpavlin	18	cpu->invalidate_translation_caches
315	dpavlin	32	(cpu, mem->devices[i].baseaddr + s,
316	dpavlin	18	JUST_MARK_AS_NON_WRITABLE
317			\| INVALIDATE_PADDR);
318	dpavlin	2	}
319
320			return;
321			}
322			}
323			}
324
325
326			/*
327	dpavlin	28	* memory_device_update_data():
328			*
329			* Update a device' dyntrans data pointer.
330			*
331			* SUPER-IMPORTANT NOTE: Anyone who changes a dyntrans data pointer while
332			* things are running also needs to invalidate all CPUs' address translation
333			* caches! Otherwise, these may contain old pointers to the old data.
334			*/
335			void memory_device_update_data(struct memory mem, void extra,
336			unsigned char *data)
337			{
338			int i;
339
340			for (i=0; i<mem->n_mmapped_devices; i++) {
341	dpavlin	32	if (mem->devices[i].extra != extra)
342	dpavlin	28	continue;
343
344	dpavlin	32	mem->devices[i].dyntrans_data = data;
345			mem->devices[i].dyntrans_write_low = (uint64_t)-1;
346			mem->devices[i].dyntrans_write_high = 0;
347	dpavlin	28	}
348			}
349
350
351			/*
352	dpavlin	2	* memory_device_register():
353			*
354	dpavlin	32	* Register a memory mapped device.
355	dpavlin	2	*/
356			void memory_device_register(struct memory mem, const char device_name,
357			uint64_t baseaddr, uint64_t len,
358			int (f)(struct cpu ,struct memory ,uint64_t,unsigned char ,
359			size_t,int,void *),
360	dpavlin	12	void extra, int flags, unsigned char dyntrans_data)
361	dpavlin	2	{
362	dpavlin	22	int i, newi = 0;
363	dpavlin	2
364	dpavlin	22	/*
365			* Figure out at which index to insert this device, and simultaneously
366			* check for collisions:
367			*/
368			newi = -1;
369	dpavlin	2	for (i=0; i<mem->n_mmapped_devices; i++) {
370	dpavlin	32	if (i == 0 && baseaddr + len <= mem->devices[i].baseaddr)
371	dpavlin	22	newi = i;
372	dpavlin	32	if (i > 0 && baseaddr + len <= mem->devices[i].baseaddr &&
373			baseaddr >= mem->devices[i-1].endaddr)
374	dpavlin	22	newi = i;
375			if (i == mem->n_mmapped_devices - 1 &&
376	dpavlin	32	baseaddr >= mem->devices[i].endaddr)
377	dpavlin	22	newi = i + 1;
378
379	dpavlin	32	/* If this is not colliding with device i, then continue: */
380			if (baseaddr + len <= mem->devices[i].baseaddr)
381	dpavlin	2	continue;
382	dpavlin	32	if (baseaddr >= mem->devices[i].endaddr)
383	dpavlin	2	continue;
384
385	dpavlin	22	fatal("\nERROR! \"%s\" collides with device %i (\"%s\")!\n",
386	dpavlin	32	device_name, i, mem->devices[i].name);
387	dpavlin	22	exit(1);
388	dpavlin	2	}
389	dpavlin	22	if (mem->n_mmapped_devices == 0)
390			newi = 0;
391			if (newi == -1) {
392			fatal("INTERNAL ERROR\n");
393			exit(1);
394			}
395	dpavlin	2
396	dpavlin	22	if (verbose >= 2) {
397			/* (40 bits of physical address is displayed) */
398	dpavlin	24	debug("device at 0x%010"PRIx64": %s", (uint64_t) baseaddr,
399	dpavlin	22	device_name);
400	dpavlin	2
401	dpavlin	22	if (flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)
402			&& (baseaddr & mem->dev_dyntrans_alignment) != 0) {
403			fatal("\nWARNING: Device dyntrans access, but unaligned"
404	dpavlin	24	" baseaddr 0x%"PRIx64".\n", (uint64_t) baseaddr);
405	dpavlin	22	}
406
407			if (flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)) {
408			debug(" (dyntrans %s)",
409			(flags & DM_DYNTRANS_WRITE_OK)? "R/W" : "R");
410			}
411			debug("\n");
412	dpavlin	2	}
413
414	dpavlin	22	for (i=0; i<mem->n_mmapped_devices; i++) {
415	dpavlin	32	if (dyntrans_data == mem->devices[i].dyntrans_data &&
416			mem->devices[i].flags&(DM_DYNTRANS_OK\|DM_DYNTRANS_WRITE_OK)
417	dpavlin	22	&& flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)) {
418			fatal("ERROR: the data pointer used for dyntrans "
419			"accesses must only be used once!\n");
420			fatal("(%p cannot be used by '%s'; already in use by '"
421			"%s')\n", dyntrans_data, device_name,
422	dpavlin	32	mem->devices[i].name);
423	dpavlin	22	exit(1);
424			}
425	dpavlin	2	}
426
427	dpavlin	22	mem->n_mmapped_devices++;
428	dpavlin	2
429	dpavlin	32	mem->devices = realloc(mem->devices, sizeof(struct memory_device)
430			* mem->n_mmapped_devices);
431			if (mem->devices == NULL) {
432			fprintf(stderr, "out of memory\n");
433			exit(1);
434			}
435
436	dpavlin	22	/* Make space for the new entry: */
437	dpavlin	32	if (newi + 1 != mem->n_mmapped_devices)
438			memmove(&mem->devices[newi+1], &mem->devices[newi],
439			sizeof(struct memory_device)
440			* (mem->n_mmapped_devices - newi - 1));
441	dpavlin	22
442	dpavlin	32	mem->devices[newi].name = strdup(device_name);
443			mem->devices[newi].baseaddr = baseaddr;
444			mem->devices[newi].endaddr = baseaddr + len;
445			mem->devices[newi].length = len;
446			mem->devices[newi].flags = flags;
447			mem->devices[newi].dyntrans_data = dyntrans_data;
448	dpavlin	22
449	dpavlin	32	if (mem->devices[newi].name == NULL) {
450	dpavlin	2	fprintf(stderr, "out of memory\n");
451			exit(1);
452			}
453
454	dpavlin	20	if (flags & (DM_DYNTRANS_OK \| DM_DYNTRANS_WRITE_OK)
455			&& !(flags & DM_EMULATED_RAM) && dyntrans_data == NULL) {
456	dpavlin	12	fatal("\nERROR: Device dyntrans access, but dyntrans_data"
457			" = NULL!\n");
458			exit(1);
459			}
460
461	dpavlin	18	if ((size_t)dyntrans_data & (sizeof(void *) - 1)) {
462	dpavlin	2	fprintf(stderr, "memory_device_register():"
463	dpavlin	12	" dyntrans_data not aligned correctly (%p)\n",
464			dyntrans_data);
465	dpavlin	2	exit(1);
466			}
467
468	dpavlin	32	mem->devices[newi].dyntrans_write_low = (uint64_t)-1;
469			mem->devices[newi].dyntrans_write_high = 0;
470			mem->devices[newi].f = f;
471			mem->devices[newi].extra = extra;
472	dpavlin	2
473			if (baseaddr < mem->mmap_dev_minaddr)
474	dpavlin	12	mem->mmap_dev_minaddr = baseaddr & ~mem->dev_dyntrans_alignment;
475	dpavlin	2	if (baseaddr + len > mem->mmap_dev_maxaddr)
476	dpavlin	12	mem->mmap_dev_maxaddr = (((baseaddr + len) - 1) \|
477			mem->dev_dyntrans_alignment) + 1;
478	dpavlin	32
479			if (newi < mem->last_accessed_device)
480			mem->last_accessed_device ++;
481	dpavlin	2	}
482
483
484			/*
485			* memory_device_remove():
486			*
487	dpavlin	32	* Unregister a memory mapped device from a memory object.
488	dpavlin	2	*/
489			void memory_device_remove(struct memory *mem, int i)
490			{
491			if (i < 0 \|\| i >= mem->n_mmapped_devices) {
492			fatal("memory_device_remove(): invalid device number %i\n", i);
493	dpavlin	32	exit(1);
494	dpavlin	2	}
495
496			mem->n_mmapped_devices --;
497
498			if (i == mem->n_mmapped_devices)
499			return;
500
501	dpavlin	32	memmove(&mem->devices[i], &mem->devices[i+1],
502			sizeof(struct memory_device) * (mem->n_mmapped_devices - i));
503	dpavlin	2
504	dpavlin	32	if (i <= mem->last_accessed_device)
505			mem->last_accessed_device --;
506			if (mem->last_accessed_device < 0)
507			mem->last_accessed_device = 0;
508	dpavlin	2	}
509
510
511			#define MEMORY_RW userland_memory_rw
512			#define MEM_USERLAND
513			#include "memory_rw.c"
514			#undef MEM_USERLAND
515			#undef MEMORY_RW
516
517
518			/*
519			* memory_paddr_to_hostaddr():
520			*
521	dpavlin	28	* Translate a physical address into a host address. The usual way to call
522			* this function is to make sure that paddr is page aligned, which will result
523			* in the host _page_ corresponding to that address.
524	dpavlin	2	*
525	dpavlin	28	* Return value is a pointer to the address in the host, or NULL on failure.
526	dpavlin	2	* On reads, a NULL return value should be interpreted as reading all zeroes.
527			*/
528			unsigned char memory_paddr_to_hostaddr(struct memory mem,
529			uint64_t paddr, int writeflag)
530			{
531			void **table;
532			int entry;
533			const int mask = (1 << BITS_PER_PAGETABLE) - 1;
534			const int shrcount = MAX_BITS - BITS_PER_PAGETABLE;
535	dpavlin	28	unsigned char *hostptr;
536	dpavlin	2
537			table = mem->pagetable;
538			entry = (paddr >> shrcount) & mask;
539
540	dpavlin	24	/* printf("memory_paddr_to_hostaddr(): p=%16"PRIx64
541			" w=%i => entry=0x%x\n", (uint64_t) paddr, writeflag, entry); */
542	dpavlin	2
543			if (table[entry] == NULL) {
544			size_t alloclen;
545
546			/*
547			* Special case: reading from a nonexistant memblock
548			* returns all zeroes, and doesn't allocate anything.
549			* (If any intermediate pagetable is nonexistant, then
550			* the same thing happens):
551			*/
552			if (writeflag == MEM_READ)
553			return NULL;
554
555			/* Allocate a memblock: */
556			alloclen = 1 << BITS_PER_MEMBLOCK;
557
558			/* printf(" allocating for entry %i, len=%i\n",
559			entry, alloclen); */
560
561			/* Anonymous mmap() should return zero-filled memory,
562			try malloc + memset if mmap failed. */
563			table[entry] = (void *) mmap(NULL, alloclen,
564	dpavlin	22	PROT_READ \| PROT_WRITE, MAP_ANON \| MAP_PRIVATE, -1, 0);
565	dpavlin	2	if (table[entry] == NULL) {
566			table[entry] = malloc(alloclen);
567			if (table[entry] == NULL) {
568			fatal("out of memory\n");
569			exit(1);
570			}
571			memset(table[entry], 0, alloclen);
572			}
573			}
574
575	dpavlin	28	hostptr = (unsigned char *) table[entry];
576
577			if (hostptr != NULL)
578			hostptr += (paddr & ((1 << BITS_PER_MEMBLOCK) - 1));
579
580			return hostptr;
581	dpavlin	2	}
582
583	dpavlin	24
584			#define UPDATE_CHECKSUM(value) { \
585			internal_state -= 0x118c7771c0c0a77fULL; \
586			internal_state = ((internal_state + (value)) << 7) ^ \
587			(checksum >> 11) ^ ((checksum - (value)) << 3) ^ \
588			(internal_state - checksum) ^ ((value) - internal_state); \
589			checksum ^= internal_state; \
590			}
591
592
593			/*
594			* memory_checksum():
595			*
596			* Calculate a 64-bit checksum of everything in a struct memory. This is
597			* useful for tracking down bugs; an old (presumably working) version of
598			* the emulator can be compared to a newer (buggy) version.
599			*/
600			uint64_t memory_checksum(struct memory *mem)
601			{
602			uint64_t internal_state = 0x80624185376feff2ULL;
603			uint64_t checksum = 0xcb9a87d5c010072cULL;
604	dpavlin	40	const size_t n_entries = (1 << BITS_PER_PAGETABLE) - 1;
605	dpavlin	24	const size_t len = (1 << BITS_PER_MEMBLOCK) / sizeof(uint64_t);
606			size_t entry, i;
607
608			for (entry=0; entry<=n_entries; entry++) {
609			uint64_t **table = mem->pagetable;
610			uint64_t *memblock = table[entry];
611
612			if (memblock == NULL) {
613			UPDATE_CHECKSUM(0x1198ab7c8174a76fULL);
614			continue;
615			}
616
617			for (i=0; i<len; i++)
618			UPDATE_CHECKSUM(memblock[i]);
619			}
620
621			return checksum;
622			}
623
624	dpavlin	34
625			/*
626			* memory_warn_about_unimplemented_addr():
627			*
628			* Called from memory_rw whenever memory outside of the physical address space
629			* is accessed (and quiet_mode isn't set).
630			*/
631			void memory_warn_about_unimplemented_addr(struct cpu cpu, struct memory mem,
632			int writeflag, uint64_t paddr, uint8_t *data, size_t len)
633			{
634			uint64_t offset, old_pc = cpu->pc;
635			char *symbol;
636
637			/*
638			* This allows guest OS kernels to probe memory a few KBs past the
639			* end of memory, without giving too many warnings.
640			*/
641			if (paddr < mem->physical_max + 0x40000)
642			return;
643
644			if (!cpu->machine->halt_on_nonexistant_memaccess && quiet_mode)
645			return;
646
647			fatal("[ memory_rw(): %s ", writeflag? "write":"read");
648
649			if (writeflag) {
650			unsigned int i;
651			debug("data={", writeflag);
652			if (len > 16) {
653			int start2 = len-16;
654			for (i=0; i<16; i++)
655			debug("%s%02x", i?",":"", data[i]);
656			debug(" .. ");
657			if (start2 < 16)
658			start2 = 16;
659			for (i=start2; i<len; i++)
660			debug("%s%02x", i?",":"", data[i]);
661			} else
662			for (i=0; i<len; i++)
663			debug("%s%02x", i?",":"", data[i]);
664			debug("} ");
665			}
666
667			fatal("paddr=0x%llx >= physical_max; pc=", (long long)paddr);
668			if (cpu->is_32bit)
669			fatal("0x%08"PRIx32, (uint32_t) old_pc);
670			else
671			fatal("0x%016"PRIx64, (uint64_t) old_pc);
672			symbol = get_symbol_name(&cpu->machine->symbol_context,
673			old_pc, &offset);
674			fatal(" <%s> ]\n", symbol? symbol : " no symbol ");
675
676			if (cpu->machine->halt_on_nonexistant_memaccess) {
677			/* TODO: Halt in a nicer way. Not possible with the
678			current dyntrans system... */
679			exit(1);
680			}
681			}
682