diff options
| -rw-r--r-- | sim/ppc/.Sanitize | 5 | ||||
| -rw-r--r-- | sim/ppc/README.psim | 177 | ||||
| -rw-r--r-- | sim/ppc/core.c | 662 | ||||
| -rw-r--r-- | sim/ppc/core.h | 144 | ||||
| -rw-r--r-- | sim/ppc/core_n.h | 91 | ||||
| -rw-r--r-- | sim/ppc/device_tree.c | 926 | ||||
| -rw-r--r-- | sim/ppc/device_tree.h | 293 | ||||
| -rw-r--r-- | sim/ppc/devices.c | 1597 | ||||
| -rw-r--r-- | sim/ppc/devices.h | 308 | ||||
| -rw-r--r-- | sim/ppc/gen.c | 506 | ||||
| -rw-r--r-- | sim/ppc/idecode_insn.h | 67 | ||||
| -rw-r--r-- | sim/ppc/memory_map.c | 355 | ||||
| -rw-r--r-- | sim/ppc/memory_map.h | 126 | ||||
| -rw-r--r-- | sim/ppc/ppc-endian.h | 5 | ||||
| -rw-r--r-- | sim/ppc/system.c | 945 | ||||
| -rw-r--r-- | sim/ppc/system.h | 6 |
16 files changed, 3990 insertions, 2223 deletions
diff --git a/sim/ppc/.Sanitize b/sim/ppc/.Sanitize index e99ca8a..c25d589 100644 --- a/sim/ppc/.Sanitize +++ b/sim/ppc/.Sanitize @@ -36,6 +36,7 @@ configure configure.in core.c core.h +core_n.h cpu.c cpu.h debug.c @@ -52,14 +53,11 @@ gen.c idecode_branch.h idecode_expression.h idecode_fields.h -idecode_insn.h inline.c inline.h interrupts.c interrupts.h main.c -memory_map.c -memory_map.h ppc-endian.c ppc-endian.h ppc-instructions @@ -76,6 +74,7 @@ system.c system.h vm.c vm.h +vm_n.h words.h Things-to-lose: diff --git a/sim/ppc/README.psim b/sim/ppc/README.psim index c76c023..f9a1486 100644 --- a/sim/ppc/README.psim +++ b/sim/ppc/README.psim @@ -4,63 +4,47 @@ Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au> This directory contains the program PSIM that models the PowerPC -architecture. It can either be run stand alone (psim) or linked with -GDB. +architecture. It can either be run stand alone (psim or run) or used +as part of GDB. -CONTENTS: +SOURCE: - psim-*.tar: + PSIM is now part of the Cygnus GDB source tree (hopefully it + will in turn become part of the next FSF release of GDB). - psim-sim-*.tar.gz simulator source code + If you're looking for a more `cutting' edge version of this + program then it can be found in: - psim-test-*.tar.gz test directory for simulator + ftp.ci.com.au:pub/clayton/psim-sim-*.tar.gz - psim-gdb-*.diff.gz patches to integrated psim - into gdb + This contains a replacement for the directory sim/ppc. As + these releases prove stable they are merged back into the GDB + source tree. - gnu-*.tar: + If you find bugs or experience problems, please e-mail them to + the alias: - gnu-gdb-*.diff.gz patches to gdb that may have - already been merged into the - GDB source tree. + powerpc-psim@ci.com.au - gnu-*-*.diff.gz Other noise + It's a majordomo mailing list. BUILDING: - o Install flex, bison, gnu-make, native gcc and probably also byacc. + o At present PSIM can only be built using the compiler GCC + (yes that is bug). This is because, among other things the + code exploits GCC's suport of long ongs. + o I also suggest that you install: flex, bision, gnu-make and + byacc. Doing this just makes builds easier. - o First you will need a fairly current copy of GDB (try the ftp site - ftp.cygnus.com:pub). I've built it with a beta version of gdb-4.15. + o Configure almost as per normal, specifing the special target + eabisim vis: - Unpack gdb vis: - - $ gunzip < gdb-4.15.tar.gz | tar xf - - - - o Apply any patches that haven't yet been merged into the GDB source - tree. - - $ cd gdb-4.15 - $ gunzip < ../psim-gdb-*.diff.gz | patch -p1 - $ gunzip < ../gnu-gdb-*.diff.gz | patch -p1 - - - o Unpack the psim source code (and optionally the test directory) - - $ cd gdb-4.15 - $ gunzip < ../psim-sim-*.tar.gz | tar xvf - - $ gunzip < ../psim-test-*.tar.gz | tar xvf - - - - o Configure gdb as per normal. I use something along the lines of: - - $ cd gdb-4.15 - $ CC=gcc ./configure --target=powerpcle-unknown-eabi + $ CC=gcc ./configure --target=powerpcle-unknown-eabisim + by default (because of its dependency on GCC). o Build your entire gdb tree as per normal. Something along the lines of: @@ -78,15 +62,17 @@ BUILDING: $ cd gdb-4.15 $ make CC=gcc install - The program sim/ppc/psim is not installed. - RUNNING: PSIM can either be run as a stand alone program or as part - of gdb. The psim-test archive contains pre-compiled and - linked programs that can be run on PSIM. The notes below - assume that you have unpacked that tar archive. + of gdb. The psim-test archive (found in: + + ftp.ci.com.au:pub/clayton + + contains pre-compiled and linked programs that can be run on + PSIM. The notes below assume that you have unpacked that tar + archive. To rebuild the archive you will need to obtain a working version of an ELF compiler/linker for the PowerPC. @@ -135,68 +121,105 @@ RUNNING: . -CONFIGURATION: Making it go faster +CONFIGURATION: + + Making it go faster - See the file sim/ppc/config.h (a.k.a. sim/ppc/data/ppc-config) - for notes. + See the file sim/ppc/config.h (which is copied from + sim/ppc/std-config.h) for further information. KNOWN FEATURES - SMP, dual-endian, VEA and OEA models, hardware devices - (console, icu, reset) ... + SMP: A Symetric Multi-Processor configuration is suported. + This includes a model of the PowerPC load word and reserve + et.al. instructions (if intending to use this feature you are + well advised to read the the source code for the reservation + instructions so that you are aware of any potential + limitations in the model). + + DUAL-ENDIAN: Both little and big endian modes are suported. + Switching between the two modes at run time, however, is not. + + UIEA, VEA and OEA: The PowerPC architecture defines three + levels of the PowerPC architecture. This simulator, to a + reasonable degree, is capable of modeling all three of them. + That is the User Instruction Set Architecture, the Virtual + Environment Architecture and finally the Operating Environment + Architecture. + + HARDWARE DEVICES: The OEA model includes facilities that allow + a programmer to (I won't say easily) extend this simulator so + that a program can interact with models of real devices. + Illustrating this is the phony machine clayton that includes + console, interrupt control unit and reset register devices. + + PEDANTIC VEA MEMORY MODEL: User programs can not assume that + they can stray off the end of valid memory areas. This model + defines valid memory addresses in strict accordance to the + executable and does not page allign their values. At first + this was a bug but since then has turned up several bugs in + peoples code so I've renamed it `a feature' :-) + + RUNTIME CONFIG OF HARDWARE: In addition to the three builtin + models of hardware - VEA, OEA/Hardware and (the start of) OpenBoot, + it is possible to load a file containing a specification of a + custom device tree. KNOWN PROBLEMS: - Configuration could be better. + FLOATING POINT: Need to add suport for non IEEE float + machines. Need to more fully handle exceptions (eg things + like divide by zero). - HTAB (page) code for OEA model untested. Some of the vm code - instructions unimplemented. + DEVICE TREE DOC: How to create and use the device tree is not + documented at all. - Doesn't detect/handle changing endian bits. In fact they are - ignored. + INITIALIZATION: When running from gdb, things are not + re-initialzied very well e.g. registers are not rezeroed. - Return from interrupt instruction unimplemented. + HTAB (page) code for OEA model untested. Some of the vm code + instructions unimplemented. Flush instruction cache instructions do nothing. Perhaphs they should (if there is an instruction cache) flush it. - PowerOpen VEA model (a.k.a XCOFF a.k.a AIX) broken. It was - working but that is before I changed the create stack frame - code into an ELF version. + Lacks PowerOpen (a.k.a. XCOFF a.k.a. AIX) and NT startups. + The PowerOpen worked until I added the ELF one. OpenBoot and PR*P interfaces missing. Open boot could be implemented by putting special instructions at the address of the OpenBoot callback functions. Those instructions could than emulate OpenBoot behavour. - VEA memory read/write performance could be improved by merging - the data sections. - - When reading in a VEA executable, the binaries text and data - sections are not made page aligned. + Missing VEA system calls. Missing or commented out instructions. - Lack of floating point support. - [workaround: build everything using -msoft-float] + Only basic (hackish) floating point implemented, I would not + trust it and it is going to change. + + 64bit target untested. - 64bit untested. + 64bit host broken. For instance use of scanf "%x", &long long. - Event code for pending events from signal handlers not + Event code for pending events from within signal handlers not finished/tested. Better and more devices. - Only two device trees VEA and OEA (clayton) and those hard coded. - Should be possible to specify a file containing a device tree - description as the program to run. At present it a device tree - file is detected causing psim to abort. - - I wonder if I've got my ppc.instructions copyright - notice correct. + PORTABILITY (Notes taken from Michael Meissner): Heavy use of + the ## operator - fix using the clasic X/**/Y hack; Use of the + signed keyword. In particular, signed char has no analogue in + classic C (though most implementations of classic C use signed + chars); Use of long long which restricts the target compiler + to be GCC. + OPTIONS/FLAGS: Need a function that can parse command line + options so that both psim and sim_{load,open,command} can all + call it. Options should be extended to allow the setting of + things like floating point support. THANKS: @@ -251,3 +274,7 @@ i486DX2/66 1/270/316 - switch=2/2,expand=0,inline=1,nia=0 1/271/281 - switch=1/1,expand=0,inline=1,nia=1 1/267/274 - switch=2/1,expand=0,inline=1,nia=1 + +---- + +CFLAGS = -g -Wall -Wno-unused -Wmissing-prototypes -Werror diff --git a/sim/ppc/core.c b/sim/ppc/core.c index 9c47a6c..a40128e 100644 --- a/sim/ppc/core.c +++ b/sim/ppc/core.c @@ -26,354 +26,468 @@ #define STATIC_INLINE_CORE STATIC_INLINE #endif + #include "basics.h" #include "device_tree.h" -#include "memory_map.h" #include "core.h" +typedef struct _core_mapping core_mapping; +struct _core_mapping { + /* ram map */ + int free_buffer; + void *buffer; + /* device map */ + const device *device; + device_io_read_buffer_callback *reader; + device_io_write_buffer_callback *writer; + /* common */ + int address_space; + unsigned_word base; + unsigned_word bound; + unsigned nr_bytes; + core_mapping *next; +}; + +struct _core_map { + core_mapping *first; + core_mapping *default_map; +}; + +typedef enum { + core_read_map, + core_write_map, + core_execute_map, + nr_core_map_types, +} core_map_types; + struct _core { - /* attached devices */ - device_node *device_tree; - /* different memory maps */ - memory_map *readable; /* really everything */ - memory_map *writeable; - memory_map *executable; - /* VEA model requires additional memory information */ - unsigned_word data_upper_bound; - unsigned_word data_high_water; - unsigned_word stack_upper_bound; - unsigned_word stack_lower_bound; - unsigned_word stack_low_water; - /* misc */ - int trace; + core_map map[nr_core_map_types]; }; +INLINE_CORE core * +core_create(void) +{ + core *new_core = ZALLOC(core); + return new_core; +} + + STATIC_INLINE_CORE void -create_core_from_addresses(device_node *device, - void *data) +core_init(core *memory) { - core *memory = (core*)data; - device_address *address; - for (address = device->addresses; - address != NULL; - address = address->next_address) { - switch (device->type) { - case memory_device: - { - void *ram = zalloc(address->size); - TRACE(trace_core, - ("create_core_from_addresses() adding memory at 0x%.8x-0x%.8x, size %8d\n", - address->lower_bound, address->lower_bound + address->size - 1, address->size)); - core_add_raw_memory(memory, - ram, - address->lower_bound, - address->size, - address->access); + core_map_types access_type; + for (access_type = 0; + access_type < nr_core_map_types; + access_type++) { + core_map *map = memory->map + access_type; + /* blow away old mappings */ + core_mapping *curr = map->first; + while (curr != NULL) { + core_mapping *tbd = curr; + curr = curr->next; + if (tbd->free_buffer) { + ASSERT(tbd->buffer != NULL); + zfree(tbd->buffer); } - break; - case sequential_device: - case block_device: - case bus_device: - case other_device: - { - TRACE(trace_core, - ("create_core_from_addresses() adding device at 0x%.8x-0x%.8x, size %8d\n", - address->lower_bound, address->lower_bound + address->size - 1, address->size)); - ASSERT(device->callbacks != NULL); - core_add_callback_memory(memory, - device, - device->callbacks->read_callback, - device->callbacks->write_callback, - address->lower_bound, - address->size, - address->access); - } - break; - default: - TRACE(trace_core, - ("create_core_from_addresses() unknown type %d\n", (int)device->type)); - break; - /* nothing happens here */ + zfree(tbd); + } + map->first = NULL; + /* blow away the default */ + if (map->default_map != NULL) { + ASSERT(map->default_map->buffer == NULL); + zfree(map->default_map); } + map->default_map = NULL; } } -INLINE_CORE core * -core_create(device_node *root, - int trace) + +/* the core has three sub mappings that the more efficient + read/write fixed quantity functions use */ + +INLINE_CORE core_map * +core_readable(core *memory) { - core *memory; - - /* Initialize things */ - memory = ZALLOC(core); - memory->trace = trace; - memory->device_tree = root; - - /* allocate space for the separate virtual to physical maps */ - memory->executable = new_memory_map(); - memory->readable = new_memory_map(); - memory->writeable = new_memory_map(); - - /* initial values for the water marks */ - memory->data_high_water = 0; - memory->stack_low_water = memory->data_high_water - sizeof(unsigned_word); - - /* go over the device tree looking for address ranges to add to - memory */ - device_tree_traverse(root, - create_core_from_addresses, - NULL, - memory); - - /* return the created core object */ - return memory; + return memory->map + core_read_map; } +INLINE_CORE core_map * +core_writeable(core *memory) +{ + return memory->map + core_write_map; +} -STATIC_INLINE_CORE void -zero_core_from_addresses(device_node *device, - void *data) +INLINE_CORE core_map * +core_executable(core *memory) { - core *memory = (core*)data; - device_address *address; - - /* for memory nodes, copy or zero any data */ - if (device->type == memory_device) { - for (address = device->addresses; - address != NULL; - address = address->next_address) { - if (memory_map_zero(memory->readable, - address->lower_bound, - address->size) != address->size) - error("init_core_from_addresses() - zero failed\n"); - /* adjust high water mark (sbrk) */ - if (memory->data_upper_bound < address->upper_bound) - memory->data_upper_bound = address->upper_bound; - } - } + return memory->map + core_execute_map; } -STATIC_INLINE_CORE void -load_core_from_addresses(device_node *device, - void *data) + + +STATIC_INLINE_CORE core_mapping * +new_core_mapping(attach_type attach, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + const device *device, + void *buffer, + int free_buffer) { - core *memory = (core*)data; - device_address *address; - - /* initialize the address range with the value attached to the - address. Even works for devices! */ - for (address = device->addresses; - address != NULL; - address = address->next_address) { - /* (re)init the address range. I don't want to think about what - this is doing to callback devices! */ - if (address->init) { - if (memory_map_write_buffer(memory->readable, - address->init, - address->lower_bound, - address->size, - raw_transfer) != address->size) - error("init_core_from_addresses() - write failed\n"); - } + core_mapping *new_mapping = ZALLOC(core_mapping); + switch (attach) { + case attach_default: + case attach_callback: + new_mapping->device = device; + new_mapping->reader = device->callback->io_read_buffer; + new_mapping->writer = device->callback->io_write_buffer; + break; + case attach_raw_memory: + new_mapping->buffer = buffer; + new_mapping->free_buffer = free_buffer; + break; + default: + error("new_core_mapping() - internal error - unknown attach type %d\n", + attach); } + /* common */ + new_mapping->address_space = address_space; + new_mapping->base = addr; + new_mapping->nr_bytes = nr_bytes; + new_mapping->bound = addr + (nr_bytes - 1); + return new_mapping; } -INLINE_CORE void -core_init(core *memory) + +STATIC_INLINE_CORE void +core_map_attach(core_map *access_map, + attach_type attach, + int address_space, + unsigned_word addr, + unsigned nr_bytes, /* host limited */ + const device *device, /*callback/default*/ + void *buffer, /*raw_memory*/ + int free_buffer) /*raw_memory*/ { - unsigned nr_cleared; - unsigned_word clear_base; - unsigned_word clear_bound; - - /* for vea, several memory break points */ - memory->data_upper_bound = 0; - memory->stack_upper_bound = device_tree_find_int(memory->device_tree, - "/options/stack-pointer");; - memory->stack_lower_bound = memory->stack_upper_bound; - - /* (re) clear all of memory that is specified by memory-address - entries. While we're at it determine the upper bound for memory - areas */ - device_tree_traverse(memory->device_tree, - NULL, - zero_core_from_addresses, - memory); - - /* May have grown the data sectioin (vea model), zero that too if - present */ - clear_base = memory->data_upper_bound; - clear_bound = memory->data_high_water; - if (clear_bound > clear_base) { - while ((nr_cleared = memory_map_zero(memory->readable, - clear_base, - clear_bound - clear_base)) > 0) { - clear_base += nr_cleared; - } + if (attach == attach_default) { + if (access_map->default_map != NULL) + error("core_map_attach() default mapping already in place\n"); + ASSERT(buffer == NULL); + access_map->default_map = new_core_mapping(attach, + address_space, addr, nr_bytes, + device, buffer, free_buffer); } - - /* clear any part of the stack that was dynamically allocated */ - clear_base = memory->stack_low_water; - clear_bound = memory->stack_upper_bound; - if (clear_bound > clear_base) { - while ((nr_cleared = memory_map_zero(memory->readable, - clear_base, - clear_bound - clear_base)) > 0) { - clear_base += nr_cleared; + else { + /* find the insertion point for this additional mapping and insert */ + core_mapping *next_mapping; + core_mapping **last_mapping; + + /* actually do occasionally get a zero size map */ + if (nr_bytes == 0) + error("core_map_attach() size == 0\n"); + + /* find the insertion point (between last/next) */ + next_mapping = access_map->first; + last_mapping = &access_map->first; + while(next_mapping != NULL && next_mapping->bound < addr) { + /* assert: next_mapping->base > all bases before next_mapping */ + /* assert: next_mapping->bound >= all bounds before next_mapping */ + last_mapping = &next_mapping->next; + next_mapping = next_mapping->next; } - } - /* with everything zero'ed, now (re) load any data sections */ - device_tree_traverse(memory->device_tree, - NULL, - load_core_from_addresses, - memory); + /* check insertion point correct */ + if (next_mapping != NULL && next_mapping->base < (addr + (nr_bytes - 1))) { + error("core_map_attach() map overlap\n"); + } + /* create/insert the new mapping */ + *last_mapping = new_core_mapping(attach, + address_space, addr, nr_bytes, + device, buffer, free_buffer); + (*last_mapping)->next = next_mapping; + } } - INLINE_CORE void -core_add_raw_memory(core *memory, - void *buffer, - unsigned_word base, - unsigned size, - device_access access) +core_attach(core *memory, + attach_type attach, + int address_space, + access_type access, + unsigned_word addr, + unsigned nr_bytes, /* host limited */ + const device *device) /*callback/default*/ { - if (access & device_is_readable) - memory_map_add_raw_memory(memory->readable, - buffer, base, size); - if (access & device_is_writeable) - memory_map_add_raw_memory(memory->writeable, - buffer, base, size); - if (access & device_is_executable) - memory_map_add_raw_memory(memory->executable, - buffer, base, size); + core_map_types access_map; + int free_buffer = 0; + void *buffer = NULL; + ASSERT(attach == attach_default || nr_bytes > 0); + if (attach == attach_raw_memory) + buffer = zalloc(nr_bytes); + for (access_map = 0; + access_map < nr_core_map_types; + access_map++) { + switch (access_map) { + case core_read_map: + if (access & access_read) + core_map_attach(memory->map + access_map, + attach, + address_space, addr, nr_bytes, + device, buffer, !free_buffer); + free_buffer ++; + break; + case core_write_map: + if (access & access_write) + core_map_attach(memory->map + access_map, + attach, + address_space, addr, nr_bytes, + device, buffer, !free_buffer); + free_buffer ++; + break; + case core_execute_map: + if (access & access_exec) + core_map_attach(memory->map + access_map, + attach, + address_space, addr, nr_bytes, + device, buffer, !free_buffer); + free_buffer ++; + break; + default: + error("core_attach() internal error\n"); + break; + } + } + ASSERT(free_buffer > 0); /* must attach to at least one thing */ } -INLINE_CORE void -core_add_callback_memory(core *memory, - device_node *device, - device_reader_callback *reader, - device_writer_callback *writer, - unsigned_word base, - unsigned size, - device_access access) +STATIC_INLINE_CORE core_mapping * +core_map_find_mapping(core_map *map, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia, + int abort) /*either 0 or 1 - helps inline */ { - if (access & device_is_readable) - memory_map_add_callback_memory(memory->readable, - device, reader, writer, - base, size); - if (access & device_is_writeable) - memory_map_add_callback_memory(memory->writeable, - device, reader, writer, - base, size); - if (access & device_is_executable) - memory_map_add_callback_memory(memory->executable, - device, reader, writer, - base, size); + core_mapping *mapping = map->first; + ASSERT((addr & (nr_bytes - 1)) == 0); /* must be aligned */ + ASSERT((addr + (nr_bytes - 1)) >= addr); /* must not wrap */ + while (mapping != NULL) { + if (addr >= mapping->base + && (addr + (nr_bytes - 1)) <= mapping->bound) + return mapping; + mapping = mapping->next; + } + if (map->default_map != NULL) + return map->default_map; + if (abort) + error("core_find_mapping() - access to unmaped address, attach a default map to handle this - addr=0x%x nr_bytes=0x%x processor=0x%x cia=0x%x\n", + addr, nr_bytes, processor, cia); + return NULL; } -STATIC_INLINE_CORE void -malloc_core_memory(core *memory, - unsigned_word base, - unsigned size, - device_access access) +STATIC_INLINE_CORE void * +core_translate(core_mapping *mapping, + unsigned_word addr) { - void *buffer = (void*)zalloc(size); - core_add_raw_memory(memory, buffer, base, size, access); + return mapping->buffer + addr - mapping->base; } -INLINE_CORE unsigned_word -core_data_upper_bound(core *memory) + +INLINE_CORE unsigned +core_map_read_buffer(core_map *map, + void *buffer, + unsigned_word addr, + unsigned len) { - return memory->data_upper_bound; + unsigned count; + unsigned_1 byte; + for (count = 0; count < len; count++) { + unsigned_word raddr = addr + count; + core_mapping *mapping = + core_map_find_mapping(map, + raddr, 1, + NULL, /*processor*/ + 0, /*cia*/ + 0); /*dont-abort*/ + if (mapping == NULL) + break; + if (mapping->reader != NULL) { + if (mapping->reader(mapping->device, + &byte, + mapping->address_space, + raddr - mapping->base, + 1, /* nr_bytes */ + 0, /*processor*/ + 0 /*cpu*/) != 1) + break; + } + else + byte = *(unsigned_1*)core_translate(mapping, + raddr); + ((unsigned_1*)buffer)[count] = T2H_1(byte); + } + return count; } -INLINE_CORE unsigned_word -core_stack_lower_bound(core *memory) +INLINE_CORE unsigned +core_map_write_buffer(core_map *map, + const void *buffer, + unsigned_word addr, + unsigned len) { - return memory->stack_lower_bound; + unsigned count; + unsigned_1 byte; + for (count = 0; count < len; count++) { + unsigned_word raddr = addr + count; + core_mapping *mapping = core_map_find_mapping(map, + raddr, 1, + NULL, /*processor*/ + 0, /*cia*/ + 0); /*dont-abort*/ + if (mapping == NULL) + break; + byte = H2T_1(((unsigned_1*)buffer)[count]); + if (mapping->writer != NULL) { + if (mapping->writer(mapping->device, + &byte, + mapping->address_space, + raddr - mapping->base, + 1, /*nr_bytes*/ + 0, /*processor*/ + 0 /*cpu*/) != 1) + break; + } + else + *(unsigned_1*)core_translate(mapping, raddr) = byte; + } + return count; } -INLINE_CORE unsigned_word -core_stack_size(core *memory) -{ - return (memory->stack_upper_bound - memory->stack_lower_bound); -} +/* Top level core(root) device: core@garbage + + The core device captures incomming dma requests and changes them to + outgoing io requests. */ -INLINE_CORE void -core_add_data(core *memory, unsigned_word incr) +STATIC_INLINE_CORE void +core_init_callback(const device *me, + psim *system) { - unsigned_word new_upper_bound = memory->data_upper_bound + incr; - if (new_upper_bound > memory->data_high_water) { - if (memory->data_upper_bound >= memory->data_high_water) - /* all the memory is new */ - malloc_core_memory(memory, - memory->data_upper_bound, - incr, - device_is_readable | device_is_writeable); - else - /* some of the memory was already allocated, only need to add - missing bit */ - malloc_core_memory(memory, - memory->data_high_water, - new_upper_bound - memory->data_high_water, - device_is_readable | device_is_writeable); - memory->data_high_water = new_upper_bound; - } - memory->data_upper_bound = new_upper_bound; + core *memory = (core*)me->data; + core_init(memory); } -INLINE_CORE void -core_add_stack(core *memory, unsigned_word incr) +STATIC_INLINE_CORE void +core_attach_address_callback(const device *me, + const char *name, + attach_type attach, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who) /*callback/default*/ { - unsigned_word new_lower_bound = memory->stack_lower_bound - incr; - if (new_lower_bound < memory->stack_low_water) { - if (memory->stack_lower_bound <= memory->stack_low_water) - /* all the memory is new */ - malloc_core_memory(memory, - new_lower_bound, - incr, - device_is_readable | device_is_writeable); - else - /* allocate only the extra bit */ - malloc_core_memory(memory, - new_lower_bound, - memory->stack_low_water - new_lower_bound, - device_is_readable | device_is_writeable); - memory->stack_low_water = new_lower_bound; - } - memory->stack_lower_bound = new_lower_bound; + core *memory = (core*)me->data; + unsigned_word device_address; + if (address_space != 0) + error("core_attach_address_callback() invalid address space\n"); + core_attach(memory, + attach, + address_space, + access, + addr, + nr_bytes, + who); } -INLINE_CORE memory_map * -core_readable(core *core) +STATIC_INLINE_CORE unsigned +core_dma_read_buffer_callback(const device *me, + void *target, + int address_space, + unsigned_word offset, + unsigned nr_bytes) { - return core->readable; + core *memory = (core*)me->data; + return core_map_read_buffer(core_readable(memory), + target, + offset, + nr_bytes); } -INLINE_CORE memory_map * -core_writeable(core *core) +STATIC_INLINE_CORE unsigned +core_dma_write_buffer_callback(const device *me, + const void *source, + int address_space, + unsigned_word offset, + unsigned nr_bytes, + int violate_read_only_section) { - return core->writeable; + core *memory = (core*)me->data; + core_map *map = (violate_read_only_section + ? core_readable(memory) + : core_writeable(memory)); + return core_map_write_buffer(map, + source, + offset, + nr_bytes); } -INLINE_CORE memory_map * -core_executable(core *core) +static device_callbacks const core_callbacks = { + core_init_callback, + core_attach_address_callback, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + core_dma_read_buffer_callback, + core_dma_write_buffer_callback, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, +}; + + +INLINE_CORE const device * +core_device_create(core *memory) { - return core->executable; + return device_create_from("core", memory, &core_callbacks, NULL); } -#endif /* _CORE_ */ + + +/* define the read/write 1/2/4/8/word functions */ + +#undef N +#define N 1 +#include "core_n.h" + +#undef N +#define N 2 +#include "core_n.h" + +#undef N +#define N 4 +#include "core_n.h" + +#undef N +#define N 8 +#include "core_n.h" + +#undef N +#define N word +#include "core_n.h" + +#endif /* _CORE_C_ */ diff --git a/sim/ppc/core.h b/sim/ppc/core.h index 5d7837a..38871e6 100644 --- a/sim/ppc/core.h +++ b/sim/ppc/core.h @@ -26,78 +26,130 @@ #define INLINE_CORE #endif -/* the base type */ +/* basic types */ typedef struct _core core; +typedef struct _core_map core_map; +/* constructor */ -/* create the hardware's core (memory and devices) from the device - tree */ INLINE_CORE core *core_create -(device_node *root, - int trace); +(void); +INLINE_CORE const device *core_device_create +(core *); -/* given a created core object, (re)initialize it from the - information provided in it's associated device tree */ - -INLINE_CORE void core_init -(core *memory); -/* from this core extract out the three different types of memory - - executable, readable, writeable */ +/* the core has three sub mappings that the more efficient + read/write fixed quantity functions use */ -INLINE_CORE memory_map *core_readable +INLINE_CORE core_map *core_readable (core *memory); -INLINE_CORE memory_map *core_writeable +INLINE_CORE core_map *core_writeable (core *memory); -INLINE_CORE memory_map *core_executable +INLINE_CORE core_map *core_executable (core *memory); -/* operators to grow memory on the fly */ -INLINE_CORE void core_add_raw_memory -(core *memory, - void *buffer, - unsigned_word base, - unsigned size, - device_access access); +/* operators to add/remove a mapping in the core -INLINE_CORE void core_add_callback_memory -(core *memory, - device_node *device, - device_reader_callback *reader, - device_writer_callback *writer, - unsigned_word base, - unsigned size, - device_access access); + callback-memory: + All access are passed onto the specified devices callback routines + after being `translated'. DEFAULT indicates that the specified + memory should be called if all other mappings fail. + + For callback-memory, the device must be specified. -/* In the VEA model, memory grow's after it is created. Operators - below grow memory as required. + raw-memory: - FIXME - should this be inside of vm? */ + While RAM could be implemented using the callback interface + core instead treats it as the common case including the code + directly in the read/write operators. -INLINE_CORE unsigned_word core_data_upper_bound -(core *memory); + For raw-memory, the device is ignored and the core alloc's a + block to act as the memory. -INLINE_CORE unsigned_word core_stack_lower_bound -(core *memory); + default-memory: -INLINE_CORE unsigned_word core_stack_size -(core *memory); + Should, for the core, there be no defined mapping for a given + address then the default map (if present) is called. -INLINE_CORE void core_add_data -(core *memory, - unsigned_word incr); + For default-memory, the device must be specified. */ -INLINE_CORE void core_add_stack -(core *memory, - unsigned_word incr); +INLINE_CORE void core_attach +(core *map, + attach_type attach, + int address_space, + access_type access, + unsigned_word addr, + unsigned nr_bytes, /* host limited */ + const device *device); /*callback/default*/ +INLINE_CORE void core_detach +(core *map, + attach_type attach, + int address_space, + unsigned_word addr, + unsigned nr_bytes, /* host limited */ + access_type access, + const device *device); /*callback/default*/ -#endif /* _CORE_ */ + +/* Variable sized read/write: + + Transfer (zero) a variable size block of data between the host and + target (possibly byte swapping it). Should any problems occure, + the number of bytes actually transfered is returned. */ + +INLINE_CORE unsigned core_map_read_buffer +(core_map *map, + void *buffer, + unsigned_word addr, + unsigned nr_bytes); + +INLINE_CORE unsigned core_map_write_buffer +(core_map *map, + const void *buffer, + unsigned_word addr, + unsigned nr_bytes); + + +/* Fixed sized read/write: + + Transfer a fixed amout of memory between the host and target. The + memory always being translated and the operation always aborting + should a problem occure */ + +#define DECLARE_CORE_WRITE_N(N) \ +INLINE_CORE void core_map_write_##N \ +(core_map *map, \ + unsigned_word addr, \ + unsigned_##N val, \ + cpu *processor, \ + unsigned_word cia); + +DECLARE_CORE_WRITE_N(1) +DECLARE_CORE_WRITE_N(2) +DECLARE_CORE_WRITE_N(4) +DECLARE_CORE_WRITE_N(8) +DECLARE_CORE_WRITE_N(word) + +#define DECLARE_CORE_READ_N(N) \ +INLINE_CORE unsigned_##N core_map_read_##N \ +(core_map *map, \ + unsigned_word addr, \ + cpu *processor, \ + unsigned_word cia); + +DECLARE_CORE_READ_N(1) +DECLARE_CORE_READ_N(2) +DECLARE_CORE_READ_N(4) +DECLARE_CORE_READ_N(8) +DECLARE_CORE_READ_N(word) + +#endif diff --git a/sim/ppc/core_n.h b/sim/ppc/core_n.h new file mode 100644 index 0000000..d4c54bc --- /dev/null +++ b/sim/ppc/core_n.h @@ -0,0 +1,91 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + */ + + +#ifndef N +#error "N must be #defined" +#endif + +#undef unsigned_N +#define unsigned_N XCONCAT2(unsigned_,N) +#undef T2H_N +#define T2H_N XCONCAT2(T2H_,N) +#undef H2T_N +#define H2T_N XCONCAT2(H2T_,N) + + +INLINE_CORE unsigned_N +XCONCAT2(core_map_read_,N)(core_map *map, + unsigned_word addr, + cpu *processor, + unsigned_word cia) +{ + core_mapping *mapping = core_map_find_mapping(map, + addr, + sizeof(unsigned_N), + processor, + cia, + 1); /*abort*/ + if (WITH_CALLBACK_MEMORY && mapping->reader != NULL) { + unsigned_N data; + if (mapping->reader(mapping->device, + &data, + mapping->address_space, + addr - mapping->base, + sizeof(unsigned_N), /* nr_bytes */ + processor, + cia) != sizeof(unsigned_N)) + error("core_read_,N() reader should not fail\n"); + return T2H_N(data); + } + else + return T2H_N(*(unsigned_N*)core_translate(mapping, addr)); +} + + + +INLINE_CORE void +XCONCAT2(core_map_write_,N)(core_map *map, + unsigned_word addr, + unsigned_N val, + cpu *processor, + unsigned_word cia) +{ + core_mapping *mapping = core_map_find_mapping(map, + addr, + sizeof(unsigned_N), + processor, + cia, + 1); /*abort*/ + if (WITH_CALLBACK_MEMORY && mapping->writer != NULL) { + unsigned_N data = H2T_N(val); + if (mapping->writer(mapping->device, + &data, + mapping->address_space, + addr - mapping->base, + sizeof(unsigned_N), /* nr_bytes */ + processor, + cia) != sizeof(unsigned_N)) + error("core_read_,N() writer should not fail\n"); + } + else + *(unsigned_N*)core_translate(mapping, addr) = H2T_N(val); +} + diff --git a/sim/ppc/device_tree.c b/sim/ppc/device_tree.c index 3a0f60e..78b6e1b 100644 --- a/sim/ppc/device_tree.c +++ b/sim/ppc/device_tree.c @@ -27,358 +27,310 @@ #endif #include <string.h> +#include <stdio.h> +#include <stdlib.h> #include "basics.h" #include "device_tree.h" -#include "devices.h" -#include "bfd.h" - -/* Any starting address less than this is assumed to be an OEA program - rather than VEA. */ -#ifndef OEA_START_ADDRESS -#define OEA_START_ADDRESS 4096 -#endif - -#ifndef OEA_MEMORY_SIZE -#define OEA_MEMORY_SIZE 0x100000 -#endif - -enum { clayton_memory_size = OEA_MEMORY_SIZE }; - -/* insert the address into the device_nodes sorted list of addresses */ -INLINE_DEVICE_TREE void -device_node_add_address(device_node *node, - unsigned_word lower_bound, - unsigned size, - device_access access, - void *init) -{ - unsigned_word upper_bound = lower_bound + size; - device_address *new_address; - device_address **current_address; - - /* find the insertion point */ - current_address = &node->addresses; - while (*current_address != NULL - && (*current_address)->upper_bound >= upper_bound) { - current_address = &(*current_address)->next_address; - } - - /* insert */ - new_address = ZALLOC(device_address); - new_address->lower_bound = lower_bound; - new_address->upper_bound = lower_bound + size; - new_address->size = size; - new_address->access = access; - new_address->init = init; - new_address->next_address = *current_address; - *current_address = new_address; -} - - -/* create a new device tree optionally making it a child of the parent - node */ - -INLINE_DEVICE_TREE device_node * -device_node_create(device_node *parent, - char *name, - device_type type, - device_callbacks *callbacks, - void *data) +typedef enum { + node_any = 0, + node_device, + node_integer, + node_boolean, + node_string +} node_type; + + +struct _device_tree { + /* where i am */ + device_tree *parent; + device_tree *children; + device_tree *sibling; + /* what i am */ + node_type type; + const char *name; + /* the value */ + const device *device; + int boolean; + const char *string; + signed_word integer; +}; + + +STATIC_INLINE_DEVICE_TREE device_tree * +new_device_tree(device_tree *parent, + const char *name, + node_type type) { - device_node *new_node; - new_node = ZALLOC(device_node); + device_tree *new_node; + new_node = ZALLOC(device_tree); new_node->parent = parent; - new_node->name = name; + new_node->name = strdup(name); new_node->type = type; - new_node->callbacks = callbacks; - new_node->data = data; if (parent != NULL) { - new_node->sibling = parent->children; - parent->children = new_node; + device_tree **sibling = &parent->children; + while ((*sibling) != NULL) + sibling = &(*sibling)->sibling; + *sibling = new_node; } return new_node; } -/* Binary file: +/* find/create a node in the device tree */ - The specified file is a binary, assume VEA is required, construct a - fake device tree based on the addresses of the text / data segments - requested by the binary */ +typedef enum { + device_tree_grow = 1, + device_tree_return_null = 2, + device_tree_abort = 3, +} device_tree_action; - -/* Update the fake device tree so that memory is allocated for this - section */ -STATIC_INLINE_DEVICE_TREE void -update_memory_node_for_section(bfd *abfd, - asection *the_section, - PTR obj) +STATIC_INLINE_DEVICE_TREE device_tree * +device_tree_find_node(device_tree *root, + const char *path, + node_type type, + device_tree_action action) { - unsigned_word section_vma; - unsigned_word section_size; - device_access section_access; - void *section_init; - device_node *memory = (device_node*)obj; - - /* skip the section if no memory to allocate */ - if (! (bfd_get_section_flags(abfd, the_section) & SEC_ALLOC)) - return; - - /* check/ignore any sections of size zero */ - section_size = bfd_get_section_size_before_reloc(the_section); - if (section_size == 0) - return; - - /* find where it is to go */ - section_vma = bfd_get_section_vma(abfd, the_section); - - TRACE(trace_device_tree, - ("name=%-7s, vma=0x%.8x, size=%6d, flags=%3x(%s%s%s%s )\n", - bfd_get_section_name(abfd, the_section), - section_vma, section_size, - bfd_get_section_flags(abfd, the_section), - bfd_get_section_flags(abfd, the_section) & SEC_LOAD ? " LOAD" : "", - bfd_get_section_flags(abfd, the_section) & SEC_CODE ? " CODE" : "", - bfd_get_section_flags(abfd, the_section) & SEC_DATA ? " DATA" : "", - bfd_get_section_flags(abfd, the_section) & SEC_ALLOC ? " ALLOC" : "", - bfd_get_section_flags(abfd, the_section) & SEC_READONLY ? " READONLY" : "" - )); - - if (bfd_get_section_flags(abfd, the_section) & SEC_LOAD) { - section_init = zalloc(section_size); - if (!bfd_get_section_contents(abfd, - the_section, - section_init, 0, - section_size)) { - bfd_perror("core:load_section()"); - error("load of data failed"); - return; + const char *chp; + int name_len; + device_tree *child; + + /* strip off any leading `/', `../' or `./' */ + while (1) { + if (strncmp(path, "/", strlen("/")) == 0) { + while (root != NULL && root->parent != NULL) + root = root->parent; + path += strlen("/"); + } + else if (strncmp(path, "./", strlen("./")) == 0) { + root = root; + path += strlen("./"); + } + else if (strncmp(path, "../", strlen("../")) == 0) { + if (root != NULL && root->parent != NULL) + root = root->parent; + path += strlen("../"); + } + else { + break; } } - else { - section_init = NULL; + + /* find the qualified (with @) and unqualified names in the path, + remembering to skip any "\/" */ + chp = path; + do { + chp = strchr(chp+1, '/'); + } while (chp != NULL && chp[-1] == '\\'); + name_len = (chp == NULL + ? strlen(path) + : chp - path); + + /* leaf? and growing? */ + if (root != NULL) { + for (child = root->children; + child != NULL; + child = child->sibling) { + if (strncmp(path, child->name, name_len) == 0 + && (strlen(child->name) == name_len + || (strchr(child->name, '@') + == child->name + name_len))) { + if (path[name_len] == '\0') { + if (action == device_tree_grow) + error("device_tree_find_node() node %s already present\n", + path); + if (type != node_any && child->type != type) { + if (action == device_tree_return_null) + return NULL; + else + error("device_tree_find_node() node %s does not match type %d\n", + path, type); + } + else + return child; + } + else + return device_tree_find_node(child, + path + name_len + 1, + type, + action); + } + } + } + + /* search failed, take default action */ + switch (action) { + case device_tree_grow: + if (path[name_len] != '\0') + error("device_tree_find_node() not a leaf %s\n", path); + return new_device_tree(root, path, type); + case device_tree_return_null: + return NULL; + default: + error("device_tree_find_node() invalid default action %d\n", action); + return NULL; } +} - /* determine the devices access */ - if (bfd_get_section_flags(abfd, the_section) & SEC_CODE) - section_access = (device_is_readable | device_is_executable); - else if (bfd_get_section_flags(abfd, the_section) & SEC_READONLY) - section_access = device_is_readable; - else - section_access = (device_is_readable | device_is_writeable); - - /* find our memory and add this section to its list of addresses */ - device_node_add_address(memory, - section_vma, - section_size, - section_access, - section_init); + +/* grow the device tree */ + +INLINE_DEVICE_TREE device_tree * +device_tree_add_passthrough(device_tree *root, + const char *path) +{ + device_tree *new_node = device_tree_find_node(root, + path, + node_device, + device_tree_grow); + new_node->device = device_create_from(new_node->name, + NULL, + passthrough_device_callbacks(), + new_node->parent->device); + return new_node; } -/* construct the device tree from the executable */ +INLINE_DEVICE_TREE device_tree * +device_tree_add_device(device_tree *root, + const char *path, + const device *dev) +{ + device_tree *new_node = device_tree_find_node(root, + path, + node_device, + device_tree_grow); + new_node->device = dev; + return new_node; +} -STATIC_INLINE_DEVICE_TREE device_node * -create_option_device_node(device_node *root, - bfd *image) +INLINE_DEVICE_TREE device_tree * +device_tree_add_integer(device_tree *root, + const char *path, + signed_word integer) { - int oea = (bfd_get_start_address(image) < OEA_START_ADDRESS); - int elf = (image->xvec->flavour == bfd_target_elf_flavour); - device_node *option_node; - - /* the option node and than its members */ - option_node = device_node_create(root, "options", options_device, - NULL, NULL); - - /* which endian are we ? */ - device_node_create(option_node, - "little-endian?", - boolean_type_device, - NULL, - (void*)(image->xvec->byteorder_big_p ? 0 : -1)); - - /* what is the initial entry point */ - device_node_create(option_node, - "program-counter", - integer_type_device, - NULL, - (void*)(bfd_get_start_address(image))); - - /* address of top of boot stack */ - TRACE(trace_tbd, ("create_optioin_device_node() - TBD - NT/OpenBoot?\n")); - device_node_create(option_node, - "stack-pointer", - integer_type_device, - NULL, - (void *)((oea) - ? clayton_memory_size /* OEA */ - : ((elf) - ? 0xe0000000 /* elf */ - : 0x20000000 /* xcoff */))); - - /* execution environment */ - device_node_create(option_node, - "vea?", - boolean_type_device, - NULL, - (void *)((oea) ? 0 : -1)); - - /* what type of binary */ - TRACE(trace_tbd, ("create_optioin_device_node() - TBD - NT/OpenBoot?\n")); - device_node_create(option_node, - "elf?", - boolean_type_device, - NULL, - (void *)((elf) ? -1 : 0)); - - /* must all memory transfers be naturally aligned? */ - device_node_create(option_node, - "aligned?", - boolean_type_device, - NULL, - (void*)((WITH_ALIGNMENT == NONSTRICT_ALIGNMENT - || image->xvec->byteorder_big_p - || !oea) - ? 0 - : -1)); - - - return option_node; + device_tree *new_node = device_tree_find_node(root, + path, + node_integer, + device_tree_grow); + new_node->integer = integer; + return new_node; } +INLINE_DEVICE_TREE device_tree * +device_tree_add_string(device_tree *root, + const char *path, + const char *string) +{ + device_tree *new_node = device_tree_find_node(root, + path, + node_string, + device_tree_grow); + new_node->string = string; + return new_node; +} -/* clatyon is a simple machine that does not require interrupts or any - thing else */ +INLINE_DEVICE_TREE device_tree * +device_tree_add_boolean(device_tree *root, + const char *path, + int boolean) +{ + device_tree *new_node = device_tree_find_node(root, + path, + node_boolean, + device_tree_grow); + new_node->boolean = boolean; + return new_node; +} -STATIC_INLINE_DEVICE_TREE device_node * -create_clayton_device_tree(bfd *image) +INLINE_DEVICE_TREE device_tree * +device_tree_add_found_device(device_tree *root, + const char *path) { - device_node *root; - device_node *io_node; - device_node *data_node; - device_node *memory_node; - - /* the root */ - root = ZALLOC(device_node); - - /* memory - clayton has 2mb of RAM at location 0 */ - memory_node = device_node_create(root, - "memory", - memory_device, - NULL, - NULL); - device_node_add_address(memory_node, 0x0, clayton_memory_size, - (device_is_readable - | device_is_writeable - | device_is_executable), - NULL); - - /* io address space */ - io_node = device_node_create(root, "io", bus_device, NULL, NULL); - - /* and IO devices */ - find_device_descriptor("console") - ->creator(io_node, "console@0x400000,0"); - find_device_descriptor("halt") - ->creator(io_node, "halt@0x500000,0"); - find_device_descriptor("icu") - ->creator(io_node, "icu@0x600000,0"); - - /* data to load */ - data_node = device_node_create(root, "image", data_device, NULL, NULL); - bfd_map_over_sections(image, - update_memory_node_for_section, - (PTR)data_node); - - /* options */ - create_option_device_node(root, image); - - return root; + device_tree *new_node = device_tree_add_device(root, path, NULL); + new_node->device = device_create(new_node->name, + new_node->parent->device); + return new_node; } -/* user mode executable build up a device tree that reflects this */ +/* look up the device tree */ -STATIC_INLINE_DEVICE_TREE device_node * -create_vea_device_tree(bfd *image) +INLINE_DEVICE_TREE const device * +device_tree_find_device(device_tree *root, + const char *path) { - device_node *root; - device_node *memory_node; - device_node *option_node; - - /* the root */ - root = ZALLOC(device_node); - - /* memory */ - memory_node = device_node_create(root, "memory", memory_device, - NULL, NULL); - bfd_map_over_sections(image, - update_memory_node_for_section, - (PTR)memory_node); - /* options - only endian so far */ - option_node = create_option_device_node(root, image); - - return root; + device_tree *node = device_tree_find_node(root, + path, + node_device, + device_tree_abort); + return node->device; } +INLINE_DEVICE_TREE signed_word +device_tree_find_integer(device_tree *root, + const char *path) +{ + device_tree *node = device_tree_find_node(root, + path, + node_integer, + device_tree_abort); + return node->integer; +} -/* create a device tree from the specified file */ -INLINE_DEVICE_TREE device_node * -device_tree_create(const char *file_name) +INLINE_DEVICE_TREE const char * +device_tree_find_string(device_tree *root, + const char *path) { - bfd *image; - device_node *tree; + device_tree *node = device_tree_find_node(root, + path, + node_string, + device_tree_abort); + return node->string; +} - bfd_init(); /* could be redundant but ... */ +INLINE_DEVICE_TREE int +device_tree_find_boolean(device_tree *root, + const char *path) +{ + device_tree *node = device_tree_find_node(root, + path, + node_boolean, + device_tree_abort); + return node->boolean; +} - /* open the file */ - image = bfd_openr(file_name, NULL); - if (image == NULL) { - bfd_perror("open failed:"); - error("nothing loaded\n"); - return NULL; - } - /* check it is valid */ - if (!bfd_check_format(image, bfd_object)) { - printf_filtered("create_device_tree() - FIXME - should check more bfd bits\n"); - printf_filtered("create_device_tree() - %s not an executable, assume device file\n", file_name); - bfd_close(image); - image = NULL; - } +/* init all the devices */ - /* depending on what was found about the file, load it */ - if (image != NULL) { - if (bfd_get_start_address(image) == 0) { - TRACE(trace_device_tree, ("create_device_tree() - clayton image\n")); - tree = create_clayton_device_tree(image); - } - else if (bfd_get_start_address(image) > 0) { - TRACE(trace_device_tree, ("create_device_tree() - vea image\n")); - tree = create_vea_device_tree(image); - } - bfd_close(image); - } - else { - error("TBD - create_device_tree() text file defining device tree\n"); - tree = NULL; - } +STATIC_INLINE_DEVICE_TREE void +device_tree_init_device(device_tree *root, + void *data) +{ + psim *system = (psim*)data; + if (root->type == node_device) + root->device->callback->init(root->device, system); +} - return tree; + +INLINE_DEVICE_TREE void +device_tree_init(device_tree *root, + psim *system) +{ + device_tree_traverse(root, device_tree_init_device, NULL, system); } /* traverse a device tree applying prefix/postfix functions to it */ INLINE_DEVICE_TREE void -device_tree_traverse(device_node *root, +device_tree_traverse(device_tree *root, device_tree_traverse_function *prefix, device_tree_traverse_function *postfix, void *data) { - device_node *child; + device_tree *child; if (prefix != NULL) prefix(root, data); for (child = root->children; child != NULL; child = child->sibling) { @@ -389,126 +341,312 @@ device_tree_traverse(device_node *root, } -/* query the device tree */ +/* dump out a device node and addresses */ -INLINE_DEVICE_TREE device_node * -device_tree_find_node(device_node *root, - const char *path) +INLINE_DEVICE_TREE void +device_tree_dump(device_tree *device, + void *ignore_data_argument) { - char *chp; - int name_len; - device_node *child; + printf_filtered("(device_tree@0x%x\n", device); + printf_filtered(" (parent 0x%x)\n", device->parent); + printf_filtered(" (children 0x%x)\n", device->children); + printf_filtered(" (sibling 0x%x)\n", device->sibling); + printf_filtered(" (type %d)\n", device->type); + printf_filtered(" (name %s)\n", device->name); + printf_filtered(" (device 0x%x)\n", device->device); + printf_filtered(" (boolean %d)\n", device->boolean); + printf_filtered(" (string %s)\n", device->string); + printf_filtered(" (integer %d)\n", device->integer); + printf_filtered(")\n"); +} - /* strip off any leading `/', `../' or `./' */ - while (1) { - if (strncmp(path, "/", strlen("/")) == 0) { - while (root->parent != NULL) - root = root->parent; - path += strlen("/"); - } - else if (strncmp(path, "./", strlen("./")) == 0) { - root = root; - path += strlen("./"); - } - else if (strncmp(path, "../", strlen("../")) == 0) { - if (root->parent != NULL) - root = root->parent; - path += strlen("../"); - } - else { - break; - } - } - /* find the qualified (with @) and unqualified names in the path */ - chp = strchr(path, '/'); - name_len = (chp == NULL - ? strlen(path) - : chp - path); +/* Parse a device name, various formats */ - /* search through children for a match */ - for (child = root->children; - child != NULL; - child = child->sibling) { - if (strncmp(path, child->name, name_len) == 0 - && (strlen(child->name) == name_len - || strchr(child->name, '@') == child->name + name_len)) { - if (path[name_len] == '\0') - return child; - else - return device_tree_find_node(child, path + name_len + 1); - } - } - return NULL; +#ifndef __NetBSD__ +#define strtouq strtoul +#endif + +#define SCAN_INIT(START, END, COUNT, NAME) \ + char *START = NULL; \ + char *END = strchr(NAME, '@'); \ + int COUNT = 0; \ + if (END == NULL) \ + return 0; \ + START = END + 1 + +#define SCAN_U(START, END, COUNT, U) \ +do { \ + *U = strtouq(START, &END, 0); \ + if (START == END) \ + return COUNT; \ + COUNT++; \ + if (*END != ',') \ + return COUNT; \ + START = END + 1; \ +} while (0) + +#define SCAN_P(START, END, COUNT, P) \ +do { \ + *P = (void*)(unsigned)strtouq(START, &END, 0); \ + if (START == END) \ + return COUNT; \ + COUNT++; \ + if (*END != ',') \ + return COUNT; \ + START = END + 1; \ +} while (0) + +#define SCAN_C(START, END, COUNT, C) \ +do { \ + char *chp = C; \ + END = START; \ + while (*END != '\0' && *END != ',') { \ + if (*END == '\\') \ + END++; \ + *chp = *END; \ + chp += 1; \ + END += 1; \ + } \ + *chp = '\0'; \ + if (START == END) \ + return COUNT; \ + COUNT++; \ + if (*END != ',') \ + return COUNT; \ + START = END + 1; \ +} while (0) + +INLINE_DEVICE_TREE int +scand_uw(const char *name, + unsigned_word *uw1) +{ + SCAN_INIT(start, end, count, name); + SCAN_U(start, end, count, uw1); + return count; } -INLINE_DEVICE_TREE device_node *device_tree_find_next_node -(device_node *root, - const char *path, - device_node *last); +INLINE_DEVICE_TREE int +scand_uw_u(const char *name, + unsigned_word *uw1, + unsigned *u2) +{ + SCAN_INIT(start, end, count, name); + SCAN_U(start, end, count, uw1); + SCAN_U(start, end, count, u2); + return count; +} -INLINE_DEVICE_TREE signed_word -device_tree_find_int(device_node *root, - const char *path) +INLINE_DEVICE_TREE int +scand_uw_u_u(const char *name, + unsigned_word *uw1, + unsigned *u2, + unsigned *u3) { - device_node *int_node = device_tree_find_node(root, path); - if (int_node == NULL) { - error("device_tree_find_int() - node %s does not exist\n", path); - return 0; - } - else if (int_node->type != integer_type_device) { - error("device_tree_find_int() - node %s is not an int\n", path); - return 0; - } - else { - return (signed_word)(int_node->data); - } + SCAN_INIT(start, end, count, name); + SCAN_U(start, end, count, uw1); + SCAN_U(start, end, count, u2); + SCAN_U(start, end, count, u3); + return count; } +INLINE_DEVICE_TREE int +scand_uw_uw_u(const char *name, + unsigned_word *uw1, + unsigned_word *uw2, + unsigned *u3) +{ + SCAN_INIT(start, end, count, name); + SCAN_U(start, end, count, uw1); + SCAN_U(start, end, count, uw2); + SCAN_U(start, end, count, u3); + return count; +} -INLINE_DEVICE_TREE const char *device_tree_find_string -(device_node *root, - const char *path); +INLINE_DEVICE_TREE int +scand_c(const char *name, + char *c1) +{ + SCAN_INIT(start, end, count, name); + SCAN_C(start, end, count, c1); + return count; +} INLINE_DEVICE_TREE int -device_tree_find_boolean(device_node *root, - const char *path) +scand_c_uw_u(const char *name, + char *c1, + unsigned_word *uw2, + unsigned *u3) { - device_node *int_node = device_tree_find_node(root, path); - if (int_node == NULL) { - error("device_tree_find_boolean() - node %s does not exist\n", path); - return 0; - } - else if (int_node->type != boolean_type_device) { - error("device_tree_find_boolean() - node %s is not a boolean\n", path); - return 0; + SCAN_INIT(start, end, count, name); + SCAN_C(start, end, count, c1); + SCAN_U(start, end, count, uw2); + SCAN_U(start, end, count, u3); + return count; +} + + +STATIC_INLINE_DEVICE_TREE void +u_strcat(char *buf, + unsigned_word uw) +{ + if (MASKED64(uw, 32, 63) == uw + || WITH_HOST_WORD_BITSIZE == 64) { + char *end = strchr(buf, '\0'); + sprintf(end, "0x%x", (unsigned)uw); } else { - return (signed_word)(int_node->data); + char *end = strchr(buf, '\0'); + sprintf(end, "0x%x%08x", + (unsigned)EXTRACTED64(uw, 0, 31), + (unsigned)EXTRACTED64(uw, 32, 63)); + } +} + +STATIC_INLINE_DEVICE_TREE void +c_strcat(char *buf, + const char *c) +{ + char *end = strchr(buf, '\0'); + while (*c) { + if (*c == '/' || *c == ',') + *end++ = '\\'; + *end++ = *c++; + } + *end = '\0'; +} + +STATIC_INLINE_DEVICE_TREE int +c_strlen(const char *c) +{ + int len = 0; + while (*c) { + if (*c == '/' || *c == ',') + len++; + len++; + c++; } + return len; } +enum { + strlen_unsigned = 10, + strlen_unsigned_word = 18, +}; -INLINE_DEVICE_TREE void *device_tree_find_bytes -(device_node *root, - const char *path); +INLINE_DEVICE_TREE char * +printd_uw_u(const char *name, + unsigned_word uw1, + unsigned u2) +{ + int sizeof_buf = (strlen(name) + + strlen("@") + + strlen_unsigned_word + + strlen(",") + + strlen_unsigned + + 1); + char *buf = (char*)zalloc(sizeof_buf); + strcpy(buf, name); + strcat(buf, "@"); + u_strcat(buf, uw1); + strcat(buf, ","); + u_strcat(buf, u2); + ASSERT(strlen(buf) < sizeof_buf); + return buf; +} -/* dump out a device node and addresses */ +INLINE_DEVICE_TREE char * +printd_uw_u_u(const char *name, + unsigned_word uw1, + unsigned u2, + unsigned u3) +{ + int sizeof_buf = (strlen(name) + + strlen("@") + + strlen_unsigned_word + + strlen(",") + + strlen_unsigned + + strlen(",") + + strlen_unsigned + + 1); + char *buf = (char*)zalloc(sizeof_buf); + strcpy(buf, name); + strcat(buf, "@"); + u_strcat(buf, uw1); + strcat(buf, ","); + u_strcat(buf, u2); + strcat(buf, ","); + u_strcat(buf, u3); + ASSERT(strlen(buf) < sizeof_buf); + return buf; +} -INLINE_DEVICE_TREE void -device_tree_dump(device_node *device, - void *ignore_data_argument) +INLINE_DEVICE_TREE char * +printd_uw_u_u_c(const char *name, + unsigned_word uw1, + unsigned u2, + unsigned u3, + const char *c4) { - printf_filtered("(device_node@0x%x\n", device); - printf_filtered(" (parent 0x%x)\n", device->parent); - printf_filtered(" (children 0x%x)\n", device->children); - printf_filtered(" (sibling 0x%x)\n", device->sibling); - printf_filtered(" (name %s)\n", device->name ? device->name : "(null)"); - printf_filtered(" (type %d)\n", device->type); - printf_filtered(" (handlers 0x%x)\n", device->callbacks); - printf_filtered(" (addresses %d)\n", device->addresses); - printf_filtered(" (data %d)\n", device->data); - printf_filtered(")\n"); + int sizeof_buf = (strlen(name) + + strlen("@") + + strlen_unsigned_word + + strlen(",") + + strlen_unsigned + + strlen(",") + + strlen_unsigned + + strlen(",") + + c_strlen(c4) + + 1); + char *buf = (char*)zalloc(sizeof_buf); + strcpy(buf, name); + strcat(buf, "@"); + u_strcat(buf, uw1); + strcat(buf, ","); + u_strcat(buf, u2); + strcat(buf, ","); + u_strcat(buf, u3); + strcat(buf, ","); + c_strcat(buf, c4); + ASSERT(strlen(buf) < sizeof_buf); + return buf; +} + +INLINE_DEVICE_TREE char * +printd_c(const char *name, + const char *c1) +{ + int sizeof_buf = (strlen(name) + + strlen("@") + + c_strlen(c1) + + 1); + char *buf = (char*)zalloc(sizeof_buf); + strcpy(buf, name); + strcat(buf, "@"); + c_strcat(buf, c1); + ASSERT(strlen(buf) < sizeof_buf); + return buf; +} + +INLINE_DEVICE_TREE char * +printd_c_uw(const char *name, + const char *c1, + unsigned_word uw2) +{ + int sizeof_buf = (strlen(name) + + strlen("@") + + c_strlen(c1) + + strlen(",") + + strlen_unsigned_word + + 1); + char *buf = (char*)zalloc(sizeof_buf); + strcpy(buf, name); + strcat(buf, "@"); + c_strcat(buf, c1); + strcat(buf, ","); + u_strcat(buf, uw2); + ASSERT(strlen(buf) < sizeof_buf); + return buf; } #endif /* _DEVICE_TREE_C_ */ diff --git a/sim/ppc/device_tree.h b/sim/ppc/device_tree.h index 59d764e..d8e5481 100644 --- a/sim/ppc/device_tree.h +++ b/sim/ppc/device_tree.h @@ -27,208 +27,147 @@ #endif -/* forward declaration of types */ - -typedef struct _device_node device_node; -typedef struct _device_address device_address; -typedef struct _device_callbacks device_callbacks; - - -/* Device callbacks: */ - - -/* Memory operations: transfer data to/from a processor. - - These callbacks pass/return data in *host* byte order. - - Should a memory read/write operation cause an interrupt (external - exception) then a device would typically pass an interrupt message - to the devices parent. Hopefully that is an interrupt controler - and will know what to do with it. - - Devices normally never either restart a processor or issue an - interrupt directly. The only exception I've thought of could be - machine check type event. */ - -typedef unsigned64 (device_reader_callback) - (device_node *device, - unsigned_word base, - unsigned nr_bytes, - cpu *processor, - unsigned_word cia); - -typedef void (device_writer_callback) - (device_node *device, - unsigned_word base, - unsigned nr_bytes, - unsigned64 val, - cpu *processor, - unsigned_word cia); - -/* Interrupts: - - A child device uses the below to pass on to its parent changes in - the state of a child devices interrupt lines. - - Typically, the parent being an interrupt control device, would, in - responce, schedule an event at the start of the next clock cycle. - On this event, the state of any cpu could be changed. Other - devices could either ignore or pass on the interrupt message */ - -typedef void (device_interrupt_callback) - (device_node *me, - int interrupt_status, - device_node *device, - cpu *processor, - unsigned_word cia); - -/* Create: - - DEVICE_CREATOR is called once, as part of building the device tree. - This function gives the device the chance to attach any additional - data to this particular device instance. - - DEVICE_INIT_CALLBACK is (re)called when ever the system is - (re)initialised. */ - -typedef device_node *(device_creator) - (device_node *parent, - char *name); - -typedef void (device_init_callback) - (device_node *device); - - - -/* constructs to describe the hardware's tree of devices */ - -typedef enum _device_type { - /* default */ - unknown_device, - /* typical devices */ - memory_device, - sequential_device, - block_device, - bus_device, - other_device, - /* atypical devices, these are for data being loaded into ram/rom */ - data_device, - options_device, - /* types of primative nodes containing just data */ - boolean_type_device, - integer_type_device, - string_type_device, - byte_type_device, -} device_type; - -typedef enum _device_access { - device_is_readable = 1, - device_is_writeable = 2, - device_is_read_write = 3, - device_is_executable = 4, - device_is_read_exec = 5, - device_is_write_exec = 6, - device_is_read_write_exec = 7, -} device_access; - -struct _device_address { - unsigned_word lower_bound; - unsigned_word upper_bound; - unsigned size; /* host limited */ - void *init; /* initial data */ - device_access access; - device_address *next_address; -}; - -struct _device_callbacks { - device_reader_callback *read_callback; - device_writer_callback *write_callback; - device_interrupt_callback *interrupt_callback; - /* device_init_callback *init_callback; */ - /* device_init_hander *post_init_handler; */ -}; - -struct _device_node { - /* where i am */ - device_node *parent; - device_node *children; - device_node *sibling; - /* what I am */ - char *name; /* eg rom@0x1234,0x40 */ - device_type type; - device_callbacks *callbacks; - device_address *addresses; - void *data; -}; - - -/* given the image to run, return its device tree */ - -INLINE_DEVICE_TREE device_node *device_tree_create -(const char *hardware_description); +#include "devices.h" +typedef struct _device_tree device_tree; -/* traverse the tree eiter pre or post fix */ -typedef void (device_tree_traverse_function) - (device_node *device, - void *data); +/* extend the device tree, each function returns the address of the + new node */ -INLINE_DEVICE_TREE void device_tree_traverse -(device_node *root, - device_tree_traverse_function *prefix, - device_tree_traverse_function *postfix, - void *data); +INLINE_DEVICE_TREE device_tree *device_tree_add_passthrough +(device_tree *root, + const char *path); +INLINE_DEVICE_TREE device_tree *device_tree_add_device +(device_tree *root, + const char *path, + const device *dev); + +INLINE_DEVICE_TREE device_tree *device_tree_add_integer +(device_tree *root, + const char *path, + signed_word integer); -/* query the device tree */ +INLINE_DEVICE_TREE device_tree *device_tree_add_string +(device_tree *root, + const char *path, + const char *string); + +INLINE_DEVICE_TREE device_tree *device_tree_add_boolean +(device_tree *root, + const char *path, + int bool); -INLINE_DEVICE_TREE device_node *device_tree_find_node -(device_node *root, +INLINE_DEVICE_TREE device_tree *device_tree_add_found_device +(device_tree *root, const char *path); -INLINE_DEVICE_TREE device_node *device_tree_find_next_node -(device_node *root, - const char *path, - device_node *last); +/* query the device tree */ + +INLINE_DEVICE_TREE const device *device_tree_find_device +(device_tree *root, + const char *path); -INLINE_DEVICE_TREE signed_word device_tree_find_int -(device_node *root, +INLINE_DEVICE_TREE signed_word device_tree_find_integer +(device_tree *root, const char *path); INLINE_DEVICE_TREE const char *device_tree_find_string -(device_node *root, +(device_tree *root, const char *path); INLINE_DEVICE_TREE int device_tree_find_boolean -(device_node *root, +(device_tree *root, const char *path); -INLINE_DEVICE_TREE void *device_tree_find_bytes -(device_node *root, - const char *path); -/* add to the device tree */ +/* initialize the entire tree */ + +INLINE_DEVICE_TREE void device_tree_init +(device_tree *root, + psim *system); + + +/* traverse the tree eiter pre or post fix */ -INLINE_DEVICE_TREE device_node *device_node_create -(device_node *parent, - char *name, - device_type type, - device_callbacks *callbacks, +typedef void (device_tree_traverse_function) + (device_tree *device, + void *data); + +INLINE_DEVICE_TREE void device_tree_traverse +(device_tree *root, + device_tree_traverse_function *prefix, + device_tree_traverse_function *postfix, void *data); -INLINE_DEVICE_TREE void device_node_add_address -(device_node *node, - unsigned_word lower_bound, - unsigned size, - device_access access, - void *init); -/* dump a node, pass this to the device_tree_traverse() function to - dump the tree */ +/* dump a node, this can be passed to the device_tree_traverse() + function to dump out the entire device tree */ INLINE_DEVICE_TREE void device_tree_dump -(device_node *device, +(device_tree *device, void *ignore_data_argument); + +/* Parse a device name, various formats */ + +INLINE_DEVICE_TREE int scand_uw +(const char *name, + unsigned_word *uw1); + +INLINE_DEVICE_TREE int scand_uw_u +(const char *name, + unsigned_word *uw1, + unsigned *u2); + +INLINE_DEVICE_TREE int scand_uw_u_u +(const char *name, + unsigned_word *uw1, + unsigned *u2, + unsigned *u3); + +INLINE_DEVICE_TREE int scand_uw_uw_u +(const char *name, + unsigned_word *uw1, + unsigned_word *uw2, + unsigned *u3); + +INLINE_DEVICE_TREE int scand_c +(const char *name, + char *c1); + +INLINE_DEVICE_TREE int scand_c_uw_u +(const char *name, + char *c1, + unsigned_word *uw2, + unsigned *u3); + +INLINE_DEVICE_TREE char *printd_uw_u +(const char *name, + unsigned_word uw1, + unsigned u2); + +INLINE_DEVICE_TREE char *printd_uw_u_u +(const char *name, + unsigned_word uw1, + unsigned u2, + unsigned u3); + +INLINE_DEVICE_TREE char *printd_uw_u_u_c +(const char *name, + unsigned_word uw1, + unsigned u2, + unsigned u3, + const char *c4); + +INLINE_DEVICE_TREE char *printd_c +(const char *name, + const char *c1); + +INLINE_DEVICE_TREE char *printd_c_uw +(const char *name, + const char *c1, + unsigned_word uw2); + #endif /* _DEVICE_TREE_H_ */ diff --git a/sim/ppc/devices.c b/sim/ppc/devices.c index 96b8109..983b693 100644 --- a/sim/ppc/devices.c +++ b/sim/ppc/devices.c @@ -31,51 +31,291 @@ #include <string.h> #include <stdlib.h> #include <fcntl.h> +#include <signal.h> +#include <stdarg.h> #include "basics.h" -#include "device_tree.h" #include "devices.h" #include "events.h" -#include "cpu.h" /* drats */ +#include "cpu.h" + +#include "bfd.h" /* Helper functions */ +/* Generic device init: Attaches the device of size <nr_bytes> (taken + from <name>@<int>,<nr_bytes>) to its parent at address zero and + with read/write access. */ + STATIC_INLINE_DEVICES void -parse_device_address(char *name, - unsigned *base, - unsigned *flags) +generic_init_callback(const device *me, + psim *system) { - /* extract the two arguments */ - name = strchr(name, '@'); - if (name == NULL) - error("missing address for device %s\n", name); - name++; - *base = strtol(name, &name, 0); - *flags = (*name == ',' - ? strtol(name+1, &name, 0) - : 0); + unsigned_word addr; + unsigned nr_bytes; + if (scand_uw_u(me->name, &addr, &nr_bytes) != 2) + error("generic_init_callback() invalid nr_bytes in %s\n", me->name); + me->parent->callback->attach_address(me->parent, + me->name, + attach_callback, + 0 /*address_space*/, + addr, + nr_bytes, + access_read_write, + me); } -/* Simple console device: + +/* inimplemented versions of each function */ - Implements a simple text output device that is attached to stdout - of the process running the simulation. The devices has four - word registers: +INLINE_DEVICES void +unimp_device_init(const device *me, + psim *system) +{ + error("device_init_callback for %s not implemented\n", me->name); +} - 0: read - 4: read-status - 8: write - c: write-status +INLINE_DEVICES void +unimp_device_attach_address(const device *me, + const char *name, + attach_type type, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who) /*callback/default*/ +{ + error("device_attach_address_callback for %s not implemented\n", me->name); +} - Where a nonzero status register indicates that the device is ready - (input fifo contains a character or output fifo has space). +INLINE_DEVICES void +unimp_device_detach_address(const device *me, + const char *name, + attach_type type, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who) /*callback/default*/ +{ + error("device_detach_address_callback for %s not implemented\n", me->name); +} - Illustrates: Mapping read/write to device operations onto actual - registers. +INLINE_DEVICES unsigned +unimp_device_io_read_buffer(const device *me, + void *dest, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) +{ + error("device_io_read_buffer_callback for %s not implemented\n", me->name); + return 0; +} - */ +INLINE_DEVICES unsigned +unimp_device_io_write_buffer(const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) +{ + error("device_io_write_buffer_callback for %s not implemented\n", me->name); + return 0; +} + +INLINE_DEVICES unsigned +unimp_device_dma_read_buffer(const device *me, + void *target, + int address_space, + unsigned_word addr, + unsigned nr_bytes) +{ + error("device_dma_read_buffer_callback for %s not implemented\n", me->name); + return 0; +} + +INLINE_DEVICES unsigned +unimp_device_dma_write_buffer(const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + int violate_read_only_section) +{ + error("device_dma_write_buffer_callback for %s not implemented\n", me->name); + return 0; +} + +INLINE_DEVICES void +unimp_device_attach_interrupt(const device *me, + const device *who, + int interrupt_line, + const char *name) +{ + error("device_attach_interrupt_callback for %s not implemented\n", me->name); +} + +INLINE_DEVICES void +unimp_device_detach_interrupt(const device *me, + const device *who, + int interrupt_line, + const char *name) +{ + error("device_detach_interrupt_callback for %s not implemented\n", me->name); +} + +INLINE_DEVICES void +unimp_device_interrupt(const device *me, + const device *who, + int interrupt_line, + int interrupt_status, + cpu *processor, + unsigned_word cia) +{ + error("device_interrupt_callback for %s not implemented\n", me->name); +} + +INLINE_DEVICES void +unimp_device_interrupt_ack(const device *me, + int interrupt_line, + int interrupt_status) +{ + error("device_interrupt_ack_callback for %s not implemented\n", me->name); +} + +INLINE_DEVICES void +unimp_device_ioctl(const device *me, + psim *system, + cpu *processor, + unsigned_word cia, + ...) +{ + error("device_ioctl_callback for %s not implemented\n", me->name); +} + + + +/* ignore/passthrough versions of each function */ + +INLINE_DEVICES void +ignore_device_init(const device *me, + psim *system) +{ + /*null*/ +} + +INLINE_DEVICES void +pass_device_attach_address(const device *me, + const char *name, + attach_type type, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who) /*callback/default*/ +{ + me->parent->callback->attach_address(me->parent, name, type, + address_space, addr, nr_bytes, + access, + who); +} + +INLINE_DEVICES void +pass_device_detach_address(const device *me, + const char *name, + attach_type type, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who) /*callback/default*/ +{ + me->parent->callback->detach_address(me->parent, name, type, + address_space, addr, nr_bytes, access, + who); +} + +INLINE_DEVICES unsigned +pass_device_dma_read_buffer(const device *me, + void *target, + int address_space, + unsigned_word addr, + unsigned nr_bytes) +{ + return me->parent->callback->dma_read_buffer(me->parent, target, + address_space, addr, nr_bytes); +} + +INLINE_DEVICES unsigned +pass_device_dma_write_buffer(const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + int violate_read_only_section) +{ + return me->parent->callback->dma_write_buffer(me->parent, source, + address_space, addr, + nr_bytes, + violate_read_only_section); +} + +INLINE_DEVICES void +pass_device_attach_interrupt(const device *me, + const device *who, + int interrupt_line, + const char *name) +{ + me->parent->callback->attach_interrupt(me->parent, who, + interrupt_line, name); +} + +INLINE_DEVICES void +pass_device_detach_interrupt(const device *me, + const device *who, + int interrupt_line, + const char *name) +{ + me->parent->callback->detach_interrupt(me->parent, who, + interrupt_line, name); +} + + +INLINE_DEVICES void +pass_device_interrupt(const device *me, + const device *who, + int interrupt_line, + int interrupt_status, + cpu *processor, + unsigned_word cia) +{ + me->parent->callback->interrupt(me->parent, who, + interrupt_line, interrupt_status, + processor, cia); +} + + + +/* Simple console device: console@)x<address>,16 + + Input characters are taken from the keyboard, output characters + sent to the terminal. Echoing of characters is not disabled. + + The device has four registers: + + 0x0: read + 0x4: read-status + 0x8: write + 0xC: write-status + + Where a nonzero status register indicates that the device is ready + (input fifo contains a character or output fifo has space). */ typedef struct _console_buffer { char buffer; @@ -84,8 +324,6 @@ typedef struct _console_buffer { } console_buffer; typedef struct _console_device { - unsigned_word my_base_address; - int interrupt_delay; console_buffer input; console_buffer output; } console_device; @@ -100,24 +338,28 @@ typedef enum { } console_offsets; -STATIC_INLINE_DEVICES unsigned64 -console_read_callback(device_node *device, - unsigned_word base, - unsigned nr_bytes, - cpu *processor, - unsigned_word cia) +STATIC_INLINE_DEVICES unsigned +console_io_read_buffer_callback(const device *me, + void *dest, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) { - console_device *con = (console_device*)device->data; + console_device *console = (console_device*)me->data; + unsigned_1 val; TRACE(trace_console_device, - ("device=0x%x, base=0x%x, nr_bytes=%d\n", - device, base, nr_bytes)); + ("device=0x%x, addr=0x%x, nr_bytes=%d\n", + me, addr, nr_bytes)); - /* handle the request */ + /* determine what was read */ - switch (base & console_offset_mask) { + switch (addr) { case console_read_buffer: - return con->input.buffer; + val = console->input.buffer; + break; case console_read_status: { /* check for input */ @@ -127,124 +369,130 @@ console_read_callback(device_node *device, flags = fcntl(0, F_GETFL, 0); if (flags == -1) { perror("console"); - return 0; + val = 0; + break; } /* temp, disable blocking IO */ status = fcntl(0, F_SETFL, flags | O_NDELAY); if (status == -1) { perror("console"); - return 0; + val = 0; + break; } /* try for input */ - status = read(0, &con->input.buffer, 1); + status = read(0, &console->input.buffer, 1); if (status == 1) { - con->input.status = 1; + console->input.status = 1; } else { - con->input.status = 0; + console->input.status = 0; } /* return to regular vewing */ fcntl(0, F_SETFL, flags); } - return con->input.status; + val = console->input.status; + break; case console_write_buffer: - return con->output.buffer; + val = console->output.buffer; + break; case console_write_status: - return con->output.status; + val = console->output.status; + break; default: error("console_read_callback() internal error\n"); - return 0; + val = 0; + break; } + bzero(dest, nr_bytes); + *(unsigned_1*)dest = val; + return nr_bytes; } -STATIC_INLINE_DEVICES void -console_write_callback(device_node *device, - unsigned_word base, - unsigned nr_bytes, - unsigned64 val, - cpu *processor, - unsigned_word cia) +STATIC_INLINE_DEVICES unsigned +console_io_write_buffer_callback(const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) { - console_device *con = (console_device*)device->data; + console_device *console = (console_device*)me->data; + unsigned_1 val = *(unsigned8*)source; TRACE(trace_console_device, - ("device=0x%x, base=0x%x, nr_bytes=%d, val=0x%x\n", - device, base, nr_bytes, val)); + ("device=0x%x, addr=0x%x, nr_bytes=%d, val=%d\n", + me, addr, nr_bytes, val)); - /* check for bus error */ - if (base & 0x3) { - error("%s - misaligned base address, base=0x%x, nr_bytes=%d\n", - "console_write_callback", base, nr_bytes); - } - - switch (base & console_offset_mask) { - case console_read_buffer: con->input.buffer = val; break; - case console_read_status: con->input.status = val; break; + switch (addr) { + case console_read_buffer: + console->input.buffer = val; + break; + case console_read_status: + console->input.status = val; + break; case console_write_buffer: TRACE(trace_console_device, ("<%c:%d>", val, val)); - printf_filtered("%c", val); - con->output.buffer = val; - con->output.status = 1; + printf_filtered("%c",val) ; + console->output.buffer = val; + console->output.status = 1; break; case console_write_status: - con->output.status = val; + console->output.status = val; break; + default: + error("console_write_callback() internal error\n"); } - + + return nr_bytes; } -static device_callbacks console_callbacks = { - console_read_callback, - console_write_callback, + +static device_callbacks const console_callbacks = { + generic_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + console_io_read_buffer_callback, + console_io_write_buffer_callback, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, }; -STATIC_INLINE_DEVICES device_node * -console_create(device_node *parent, - char *name) -{ - device_node *device; - unsigned address_base; - unsigned address_flags; +STATIC_INLINE_DEVICES const device * +console_create(const char *name, + const device *parent) +{ /* create the descriptor */ console_device *console = ZALLOC(console_device); - /* extract the two arguments */ - parse_device_address(name, &address_base, &address_flags); - /* fill in the details */ - console->my_base_address = address_base; - console->interrupt_delay = address_flags; console->output.status = 1; console->output.buffer = '\0'; console->input.status = 0; console->input.buffer = '\0'; /* insert into the device tree along with its address info */ - device = device_node_create(parent, name, sequential_device, - &console_callbacks, console); - device_node_add_address(device, - address_base, - console_size, - device_is_read_write_exec, - NULL); - - return device; + return device_create_from(name, + console, /* data */ + &console_callbacks, + parent); } -static device_descriptor console_descriptor = { - "console", - console_create, -}; - -/* ICU device: + +/* ICU device: icu@0x<address>,4 Single 4 byte register. Read returns processor number. Write interrupts specified processor. @@ -256,55 +504,513 @@ static device_descriptor console_descriptor = { device doesn't pass interrupt events to its parent. Instead it passes them back to its self. */ -STATIC_INLINE_DEVICES unsigned64 -icu_read_callback(device_node *device, - unsigned_word base, - unsigned nr_bytes, - cpu *processor, - unsigned_word cia) +STATIC_INLINE_DEVICES unsigned +icu_io_read_buffer_callback(const device *me, + void *dest, + int address_space, + unsigned_word base, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) { + unsigned_1 val; TRACE(trace_icu_device, ("device=0x%x, base=0x%x, nr_bytes=%d\n", - device, base, nr_bytes)); - return cpu_nr(processor); + me, base, nr_bytes)); + val = cpu_nr(processor); + bzero(dest, nr_bytes); + *(unsigned_1*)dest = val; + return nr_bytes; } -STATIC_INLINE_DEVICES void -icu_write_callback(device_node *device, - unsigned_word base, - unsigned nr_bytes, - unsigned64 val, - cpu *processor, - unsigned_word cia) + +STATIC_INLINE_DEVICES unsigned +icu_io_write_buffer_callback(const device *me, + const void *source, + int address_space, + unsigned_word base, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) { psim *system = cpu_system(processor); - device_node *parent = device; /* NB: normally would be device->parent */ + unsigned_1 val = H2T_1(*(unsigned_1*)source); TRACE(trace_icu_device, ("device=0x%x, base=0x%x, nr_bytes=%d, val=0x%x\n", - device, base, nr_bytes, val)); + me, base, nr_bytes, val)); /* tell the parent device that the interrupt lines have changed. For this fake ICU. The interrupt lines just indicate the cpu to interrupt next */ - parent->callbacks->interrupt_callback(parent, val, device, processor, cia); + me->parent->callback->interrupt(me->parent, me, + val, val, + processor, cia); + return nr_bytes; } + +static device_callbacks const icu_callbacks = { + generic_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + icu_io_read_buffer_callback, + icu_io_write_buffer_callback, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, +}; + + + +/* HALT device: halt@0x<address>,4 + + With real hardware, the processor operation is normally terminated + through a reset. This device illustrates how a reset device could + be attached to an address */ + + +STATIC_INLINE_DEVICES unsigned +halt_io_read_buffer_callback(const device *me, + void *dest, + int address_space, + unsigned_word base, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) +{ + cpu_halt(processor, cia, was_exited, 0); + return 0; +} + + +STATIC_INLINE_DEVICES unsigned +halt_io_write_buffer_callback(const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) +{ + cpu_halt(processor, cia, was_exited, 0); + return 0; +} + + +static device_callbacks const halt_callbacks = { + generic_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + halt_io_read_buffer_callback, + halt_io_write_buffer_callback, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, +}; + + + +/* Register init device: register@<name>,0x<value>[,<processor>] + + This strange device is used to initialize the processors registers + as part of the initialization. */ + +STATIC_INLINE_DEVICES void +register_init_callback(const device *me, + psim *system) +{ + char name[100]; + unsigned_word value; + unsigned which_cpu; + int status; + status = scand_c_uw_u(me->name, name, &value, &which_cpu); + switch (status) { + case 2: /* register@<name>,<value> */ + psim_write_register(system, -1, &value, name, cooked_transfer); + break; + case 3: /* register@<name>,<value>,<processor> */ + psim_write_register(system, which_cpu, &value, name, cooked_transfer); + break; + default: + error("register_init_callback() invalid register init %s\n", me->name); + break; + } +} + + +static device_callbacks const register_callbacks = { + register_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, +}; + + + +/* VEA VM device: vm@0x<stack-base>,<nr_bytes> + + A VEA mode device. This sets its self up as the default memory + device capturing all accesses (reads/writes) to currently unmapped + addresses. If the unmaped access falls within unallocated stack or + heap address ranges then memory is allocated and the access is + allowed to continue. + + During init phase, this device expects to receive `attach' requests + from its children for the text/data/bss memory areas. Typically, + this would be done by the binary device. + + STACK: The location of the stack in memory is specified as part of + the devices name. Unmaped accesses that fall within the stack + space result in the allocated stack being grown downwards so that + it includes the page of the culprit access. + + HEAP: During initialization, the vm device monitors all `attach' + operations from its children using this to determine the initial + location of the heap. The heap is then extended by system calls + that frob the heap upper bound variable (see system.c). */ + + +typedef struct _vm_device { + /* area of memory valid for stack addresses */ + unsigned_word stack_base; /* min possible stack value */ + unsigned_word stack_bound; + unsigned_word stack_lower_limit; + /* area of memory valid for heap addresses */ + unsigned_word heap_base; + unsigned_word heap_bound; + unsigned_word heap_upper_limit; +} vm_device; + + STATIC_INLINE_DEVICES void -icu_do_interrupt(event_queue *queue, - void *data) +vm_init_callback(const device *me, + psim *system) +{ + vm_device *vm = (vm_device*)me->data; + + /* revert the stack/heap variables to their defaults */ + vm->stack_lower_limit = vm->stack_bound; + vm->heap_base = 0; + vm->heap_bound = 0; + vm->heap_upper_limit = 0; + + /* establish this device as the default memory handler */ + me->parent->callback->attach_address(me->parent, + me->name, + attach_default, + 0 /*address space - ignore*/, + 0 /*addr - ignore*/, + 0 /*nr_bytes - ignore*/, + access_read_write /*access*/, + me); +} + + +STATIC_INLINE_DEVICES void +vm_attach_address(const device *me, + const char *name, + attach_type type, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who) /*callback/default*/ +{ + vm_device *vm = (vm_device*)me->data; + /* update end of bss if necessary */ + if (vm->heap_base < addr + nr_bytes) { + vm->heap_base = addr + nr_bytes; + vm->heap_bound = addr + nr_bytes; + vm->heap_upper_limit = addr + nr_bytes; + } + me->parent->callback->attach_address(me->parent, + "vm@0x0,0", /* stop remap */ + attach_raw_memory, + 0 /*address space*/, + addr, + nr_bytes, + access, + me); +} + + +STATIC_INLINE_DEVICES unsigned +add_vm_space(const device *me, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) +{ + vm_device *vm = (vm_device*)me->data; + unsigned_word block_addr; + unsigned block_nr_bytes; + + /* an address in the stack area, allocate just down to the addressed + page */ + if (addr >= vm->stack_base && addr < vm->stack_lower_limit) { + block_addr = FLOOR_PAGE(addr); + block_nr_bytes = vm->stack_lower_limit - block_addr; + vm->stack_lower_limit = block_addr; + } + /* an address in the heap area, allocate all of the required heap */ + else if (addr >= vm->heap_upper_limit && addr < vm->heap_bound) { + block_addr = vm->heap_upper_limit; + block_nr_bytes = vm->heap_bound - vm->heap_upper_limit; + vm->heap_upper_limit = vm->heap_bound; + } + /* oops - an invalid address - abort the cpu */ + else if (processor != NULL) { + cpu_halt(processor, cia, was_signalled, SIGSEGV); + return 0; + } + /* 2*oops - an invalid address and no processor */ + else { + return 0; + } + + /* got the parameters, allocate the space */ + me->parent->callback->attach_address(me->parent, + "vm@0x0,0", /* stop remap */ + attach_raw_memory, + 0 /*address space*/, + block_addr, + block_nr_bytes, + access_read_write, + me); + return block_nr_bytes; +} + + +STATIC_INLINE_DEVICES unsigned +vm_io_read_buffer_callback(const device *me, + void *dest, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) +{ + if (add_vm_space(me, addr, nr_bytes, processor, cia) >= nr_bytes) { + bzero(dest, nr_bytes); /* always initialized to zero */ + return nr_bytes; + } + else + return 0; +} + + +STATIC_INLINE_DEVICES unsigned +vm_io_write_buffer_callback(const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia) +{ + if (add_vm_space(me, addr, nr_bytes, processor, cia) >= nr_bytes) { + return me->parent->callback->dma_write_buffer(me->parent, source, + address_space, addr, + nr_bytes, + 0/*violate_read_only*/); + } + else + return 0; +} + + +STATIC_INLINE_DEVICES void +vm_ioctl_callback(const device *me, + psim *system, + cpu *processor, + unsigned_word cia, + ...) +{ + /* While the caller is notified that the heap has grown by the + requested amount, the heap is infact extended out to a page + boundary. */ + vm_device *vm = (vm_device*)me->data; + unsigned_word new_break = ALIGN_8(cpu_registers(processor)->gpr[3]); + unsigned_word old_break = vm->heap_bound; + signed_word delta = new_break - old_break; + if (delta > 0) + vm->heap_bound = ALIGN_PAGE(new_break); + cpu_registers(processor)->gpr[0] = 0; + cpu_registers(processor)->gpr[3] = new_break; +} + + +static device_callbacks const vm_callbacks = { + vm_init_callback, + vm_attach_address, + pass_device_detach_address, + vm_io_read_buffer_callback, + vm_io_write_buffer_callback, + unimp_device_dma_read_buffer, + pass_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + vm_ioctl_callback, +}; + + +STATIC_INLINE_DEVICES const device * +vea_vm_create(const char *name, + const device *parent) +{ + vm_device *vm = ZALLOC(vm_device); + unsigned_word addr; + unsigned nr_bytes; + + /* extract out the stack parameters */ + if (scand_uw_u(name, &addr, &nr_bytes) != 2) + error("vm_device_create() invalid vm device %s\n", name); + vm->stack_base = addr; + vm->stack_bound = addr + nr_bytes; + + /* insert in the tree including the buffer */ + return device_create_from(name, + vm, /* data */ + &vm_callbacks, + parent); +} + + + +/* Memory init device: memory@0x<addr>,<size>,<access> + + This strange device is used create sections of memory */ + +STATIC_INLINE_DEVICES void +memory_init_callback(const device *me, + psim *system) +{ + unsigned_word addr; + unsigned nr_bytes; + unsigned access; + + if (scand_uw_u_u(me->name, &addr, &nr_bytes, &access) != 3) + error("memory_init_callback() invalid memory device %s\n", me->name); + + me->parent->callback->attach_address(me->parent, + me->name, + attach_raw_memory, + 0 /*address space*/, + addr, + nr_bytes, + (access_type)access, + me); +} + + +static device_callbacks const memory_callbacks = { + memory_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, +}; + + +STATIC_INLINE_DEVICES const device * +memory_create(const char *name, + const device *parent) +{ + void *buffer; + unsigned_word addr; + unsigned nr_bytes; + if (scand_uw_u(name, &addr, &nr_bytes) != 2) + error("memory_create() invalid memory device %s\n"); + + /* insert in the tree including the buffer */ + return device_create_from(name, + buffer, /* data */ + &memory_callbacks, + parent); +} + + + +/* IOBUS device: iobus@<address> + + Simple bus on which some IO devices live */ + +STATIC_INLINE_DEVICES void +iobus_attach_address_callback(const device *me, + const char *name, + attach_type type, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who) /*callback/default*/ +{ + unsigned_word iobus_addr; + /* sanity check */ + if (type == attach_default) + error("iobus_attach_address_callback() no default for %s/%s\n", + me->name, name); + if (address_space != 0) + error("iobus_attach_address_callback() no address_space for %s/%s\n", + me->name, name); + /* get the bus address */ + if (scand_uw(me->name, &iobus_addr) != 1) + error("iobus_attach_address_callback() invalid address for %s\n", + me->name); + me->parent->callback->attach_address(me->parent, + me->name, + type, + 0 /*address_space*/, + iobus_addr + addr, + nr_bytes, + access, + who); +} + + +STATIC_INLINE_DEVICES void +iobus_do_interrupt(event_queue *queue, + void *data) { cpu *target = (cpu*)data; /* try to interrupt the processor. If the attempt fails, try again on the next tick */ if (!external_interrupt(target)) - event_queue_schedule(queue, 1, icu_do_interrupt, target); + event_queue_schedule(queue, 1, iobus_do_interrupt, target); } + STATIC_INLINE_DEVICES void -icu_interrupt_callback(device_node *me, - int interrupt_status, - device_node *device, - cpu *processor, - unsigned_word cia) +iobus_interrupt_callback(const device *me, + const device *who, + int interrupt_line, + int interrupt_status, + cpu *processor, + unsigned_word cia) { /* the interrupt controler can't interrupt a cpu at any time. Rather it must synchronize with the system clock before @@ -313,130 +1019,605 @@ icu_interrupt_callback(device_node *me, cpu *target = psim_cpu(system, interrupt_status); if (target != NULL) { event_queue *events = cpu_event_queue(target); - event_queue_schedule(events, 1, icu_do_interrupt, target); + event_queue_schedule(events, 1, iobus_do_interrupt, target); } } -static device_callbacks icu_callbacks = { - icu_read_callback, - icu_write_callback, - icu_interrupt_callback, + +static device_callbacks const iobus_callbacks = { + ignore_device_init, + iobus_attach_address_callback, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + iobus_interrupt_callback, + unimp_device_interrupt_ack, + unimp_device_ioctl, }; -STATIC_INLINE_DEVICES device_node * -icu_create(device_node *parent, - char *name) + + +/* FILE device: file@0x<address>,<file-name> + (later - file@0x<address>,<size>,<file-offset>,<file-name>) + + Specifies a file to read directly into memory starting at <address> */ + + +STATIC_INLINE_DEVICES void +file_init_callback(const device *me, + psim *system) { - device_node *device; - unsigned address_base; - unsigned address_flags; + unsigned_word addr; + char *file_name; + char buf; + FILE *image; + + if ((file_name = strchr(me->name, ',')) == NULL + || scand_uw(me->name, &addr) != 1) + error("file_init_callback() invalid file device %s\n", me->name); + + /* open the file to load */ + file_name++; /* skip the `,' */ + image = fopen(file_name, "r"); + if (image == NULL) + error("file_init_callback() file open failed for %s\n", me->name); + + /* read it in slowly */ + while (fread(&buf, 1, 1, image) > 0) { + me->parent->callback->dma_write_buffer(me->parent, + &buf, + 0 /*address-space*/, + addr, + 1 /*nr-bytes*/, + 1 /*violate ro*/); + addr++; + } - /* extract the two arguments */ - parse_device_address(name, &address_base, &address_flags); + /* close down again */ + fclose(image); +} - /* insert into the device tree along with its address info */ - device = device_node_create(parent, name, sequential_device, - &icu_callbacks, 0); - device_node_add_address(device, - address_base, - 4, - device_is_read_write_exec, - NULL); - return device; +static device_callbacks const file_callbacks = { + file_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, +}; + + + +/* HTAB: htab@0x<address>,<nr_bytes> + PTE: pte@0x<effective-address>,0x<real-address>,<nr_bytes> + + HTAB defines the location (in physical memory) of a HASH table. + PTE (as a child of HTAB) defines a mapping that is to be entered + into that table. + + NB: All the work in this device is done during init by the PTE. + The pte, looks up its parent to determine the address of the HTAB + and then uses DMA calls to establish the required mapping. */ + + +STATIC_INLINE_DEVICES void +htab_init_callback(const device *me, + psim *system) +{ + /* only the pte does work */ + if (strncmp(me->name, "pte@", strlen("pte@")) == 0) { + unsigned_word htab_ra; + unsigned htab_nr_bytes; + unsigned_word pte_ea; + unsigned_word pte_ra; + unsigned pte_nr_bytes; + /* determine the location/size of the hash table */ + if (scand_uw_u(me->parent->name, &htab_ra, &htab_nr_bytes) != 2) + error("htab_init_callback() htab entry %s invalid\n", + me->parent->name); + /* determine the location/size of the mapping */ + if (scand_uw_uw_u(me->name, &pte_ea, &pte_ra, &pte_nr_bytes) != 3) + error("htab_init_callback() pte entry %s invalid\n", me->name); + error("Map ea=0x%x, ra=0x%x, nr_bytes=%d using htab=0x%x, nr_bytes=%d\n", + pte_ea, pte_ra, pte_nr_bytes, htab_ra, htab_nr_bytes); + } } -static device_descriptor icu_descriptor = { - "icu", - icu_create, + +static device_callbacks const htab_callbacks = { + htab_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, }; + +/* Simulator device: sim@0x<address>,<nr_bytes> + + Eventually gives access to the hardware configuration. For + instance, it could allow the setting (on the fly) of variables such + as hardware floating-point or strict-alignment. + + It's intended use is as part of testing the simulators + functionality */ + +static device_callbacks const sim_callbacks = { + ignore_device_init, + unimp_device_attach_address, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, +}; + +/* Load device: *binary@<file-name> -/* HALT device: + Assuming that <file-name> is an executable file understood by BFD, + this device loads or maps the relevant text/data segments into + memory using dma. */ - With real hardware, the processor operation is normally terminated - through a reset. This device illustrates how a reset device could - be attached to an address */ +/* create a device tree from the image */ -STATIC_INLINE_DEVICES unsigned64 -halt_read_callback(device_node *device, - unsigned_word base, - unsigned nr_bytes, - cpu *processor, - unsigned_word cia) +STATIC_INLINE_DEVICES void +update_device_tree_for_section(bfd *abfd, + asection *the_section, + PTR obj) { - cpu_halt(processor, cia, was_exited, 0); - return 0; + unsigned_word section_vma; + unsigned_word section_size; + access_type access; + device *me = (device*)obj; + + /* skip the section if no memory to allocate */ + if (! (bfd_get_section_flags(abfd, the_section) & SEC_ALLOC)) + return; + + /* check/ignore any sections of size zero */ + section_size = bfd_get_section_size_before_reloc(the_section); + if (section_size == 0) + return; + + /* find where it is to go */ + section_vma = bfd_get_section_vma(abfd, the_section); + + TRACE(trace_device_tree, + ("name=%-7s, vma=0x%.8x, size=%6d, flags=%3x(%s%s%s%s )\n", + bfd_get_section_name(abfd, the_section), + section_vma, section_size, + bfd_get_section_flags(abfd, the_section), + bfd_get_section_flags(abfd, the_section) & SEC_LOAD ? " LOAD" : "", + bfd_get_section_flags(abfd, the_section) & SEC_CODE ? " CODE" : "", + bfd_get_section_flags(abfd, the_section) & SEC_DATA ? " DATA" : "", + bfd_get_section_flags(abfd, the_section) & SEC_ALLOC ? " ALLOC" : "", + bfd_get_section_flags(abfd, the_section) & SEC_READONLY ? " READONLY" : "" + )); + + /* determine the devices access */ + access = access_read; + if (bfd_get_section_flags(abfd, the_section) & SEC_CODE) + access |= access_exec; + if (!(bfd_get_section_flags(abfd, the_section) & SEC_READONLY)) + access |= access_write; + + /* if a map, pass up a request to create the memory in core */ + if (strncmp(me->name, "map-binary@", strlen("map-binary@")) == 0) + me->parent->callback->attach_address(me->parent, + me->name, + attach_raw_memory, + 0 /*address space*/, + section_vma, + section_size, + access, + me); + + /* if a load dma in the required data */ + if (bfd_get_section_flags(abfd, the_section) & SEC_LOAD) { + void *section_init = zalloc(section_size); + if (!bfd_get_section_contents(abfd, + the_section, + section_init, 0, + section_size)) { + bfd_perror("core:load_section()"); + error("load of data failed"); + return; + } + if (me->parent->callback->dma_write_buffer(me->parent, + section_init, + 0 /*address_space*/, + section_vma, + section_size, + 1 /*violate_read_only*/) + != section_size) + error("data_init_callback() broken transfer for %s\n", me->name); + zfree(section_init); /* only free if load */ + } } + STATIC_INLINE_DEVICES void -halt_write_callback(device_node *device, - unsigned_word base, - unsigned nr_bytes, - unsigned64 val, - cpu *processor, - unsigned_word cia) +binary_init_callback(const device *me, + psim *system) { - cpu_halt(processor, cia, was_exited, 0); + char file_name[100]; + bfd *image; + + /* get a file name */ + if (scand_c(me->name, file_name) != 1) + error("load_binary_init_callback() invalid load-binary device %s\n", + me->name); + + /* open the file */ + image = bfd_openr(file_name, NULL); + if (image == NULL) { + bfd_perror("open failed:"); + error("nothing loaded\n"); + } + + /* check it is valid */ + if (!bfd_check_format(image, bfd_object)) { + printf_filtered("create_device_tree() - FIXME - should check more bfd bits\n"); + printf_filtered("create_device_tree() - %s not an executable, assume device file\n", file_name); + bfd_close(image); + image = NULL; + } + + /* and the data sections */ + bfd_map_over_sections(image, + update_device_tree_for_section, + (PTR)me); + + bfd_close(image); } -static device_callbacks halt_callbacks = { - halt_read_callback, - halt_write_callback, +static device_callbacks const binary_callbacks = { + binary_init_callback, + unimp_device_attach_address, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, }; -STATIC_INLINE_DEVICES device_node * -halt_create(device_node *parent, - char *name) + + +/* Stack device: stack@<type> + + Has a single IOCTL to create a stack frame of the specified type. + If <type> is elf or xcoff then a corresponding stack is created. + Any other value of type is ignored. + + The IOCTL takes the additional arguments: + + unsigned_word stack_end -- where the stack should come down from + char **argv -- ... + char **envp -- ... + + */ + +STATIC_INLINE_DEVICES int +sizeof_argument_strings(char **arg) +{ + int sizeof_strings = 0; + + /* robust */ + if (arg == NULL) + return 0; + + /* add up all the string sizes (padding as we go) */ + for (; *arg != NULL; arg++) { + int len = strlen(*arg) + 1; + sizeof_strings += ALIGN_8(len); + } + + return sizeof_strings; +} + +STATIC_INLINE_DEVICES int +number_of_arguments(char **arg) +{ + int nr; + if (arg == NULL) + return 0; + for (nr = 0; *arg != NULL; arg++, nr++); + return nr; +} + +STATIC_INLINE_DEVICES int +sizeof_arguments(char **arg) +{ + return ALIGN_8((number_of_arguments(arg) + 1) * sizeof(unsigned_word)); +} + +STATIC_INLINE_DEVICES void +write_stack_arguments(psim *system, + char **arg, + unsigned_word start_block, + unsigned_word end_block, + unsigned_word start_arg, + unsigned_word end_arg) +{ + TRACE(trace_create_stack, + ("write_stack_arguments() - %s=0x%x %s=0x%x %s=0x%x %s=0x%x\n", + "system", system, "arg", arg, + "start_block", start_block, "start_arg", start_arg)); + if (arg == NULL) + error("write_arguments: character array NULL\n"); + /* only copy in arguments, memory is already zero */ + for (; *arg != NULL; arg++) { + int len = strlen(*arg)+1; + unsigned_word target_start_block; + TRACE(trace_create_stack, + ("write_stack_arguments - write %s=%s at %s=0x%x %s=0x%x %s=0x%x\n", + "**arg", *arg, "start_block", start_block, + "len", len, "start_arg", start_arg)); + if (psim_write_memory(system, 0, *arg, + start_block, len, + 0/*violate_readonly*/) != len) + error("write_stack_arguments() - write of **arg (%s) at 0x%x failed\n", + *arg, start_block); + target_start_block = H2T_word(start_block); + if (psim_write_memory(system, 0, &target_start_block, + start_arg, sizeof(target_start_block), + 0) != sizeof(target_start_block)) + error("write_stack_arguments() - write of *arg failed\n"); + start_block += ALIGN_8(len); + start_arg += sizeof(start_block); + } + start_arg += sizeof(start_block); /*the null at the end*/ + if (start_block != end_block + || ALIGN_8(start_arg) != end_arg) + error("write_stack_arguments - possible corruption\n"); +} + +STATIC_INLINE_DEVICES void +create_elf_stack_frame(psim *system, + unsigned_word bottom_of_stack, + char **argv, + char **envp) +{ + /* fixme - this is over aligned */ + + /* information block */ + const unsigned sizeof_envp_block = sizeof_argument_strings(envp); + const unsigned_word start_envp_block = bottom_of_stack - sizeof_envp_block; + const unsigned sizeof_argv_block = sizeof_argument_strings(argv); + const unsigned_word start_argv_block = start_envp_block - sizeof_argv_block; + + /* auxiliary vector - contains only one entry */ + const unsigned sizeof_aux_entry = 2*sizeof(unsigned_word); /* magic */ + const unsigned_word start_aux = start_argv_block - ALIGN_8(sizeof_aux_entry); + + /* environment points (including null sentinal) */ + const unsigned sizeof_envp = sizeof_arguments(envp); + const unsigned_word start_envp = start_aux - sizeof_envp; + + /* argument pointers (including null sentinal) */ + const int argc = number_of_arguments(argv); + const unsigned sizeof_argv = sizeof_arguments(argv); + const unsigned_word start_argv = start_envp - sizeof_argv; + + /* link register save address - alligned to a 16byte boundary */ + const unsigned_word top_of_stack = ((start_argv + - 2 * sizeof(unsigned_word)) + & ~0xf); + + /* install arguments on stack */ + write_stack_arguments(system, envp, + start_envp_block, bottom_of_stack, + start_envp, start_aux); + write_stack_arguments(system, argv, + start_argv_block, start_envp_block, + start_argv, start_envp); + + /* set up the registers */ + psim_write_register(system, -1, + &top_of_stack, "sp", cooked_transfer); + psim_write_register(system, -1, + &argc, "r3", cooked_transfer); + psim_write_register(system, -1, + &start_argv, "r4", cooked_transfer); + psim_write_register(system, -1, + &start_envp, "r5", cooked_transfer); + psim_write_register(system, -1, + &start_aux, "r6", cooked_transfer); +} + +STATIC_INLINE_DEVICES void +create_aix_stack_frame(psim *system, + unsigned_word bottom_of_stack, + char **argv, + char **envp) { - device_node *device; - unsigned address_base; - unsigned address_flags; + unsigned_word core_envp; + unsigned_word core_argv; + unsigned_word core_argc; + unsigned_word core_aux; + unsigned_word top_of_stack; + + /* cheat - create an elf stack frame */ + create_elf_stack_frame(system, bottom_of_stack, argv, envp); + + /* extract argument addresses from registers */ + psim_read_register(system, 0, &top_of_stack, "r1", cooked_transfer); + psim_read_register(system, 0, &core_argc, "r3", cooked_transfer); + psim_read_register(system, 0, &core_argv, "r4", cooked_transfer); + psim_read_register(system, 0, &core_envp, "r5", cooked_transfer); + psim_read_register(system, 0, &core_aux, "r6", cooked_transfer); + + /* extract arguments from registers */ + error("create_aix_stack_frame() - what happens next?\n"); +} + + - parse_device_address(name, &address_base, &address_flags); - device = device_node_create(parent, name, other_device, - &halt_callbacks, NULL); - device_node_add_address(device, - address_base, - 4, - device_is_read_write_exec, - NULL); - return device; +STATIC_INLINE_DEVICES void +stack_ioctl_callback(const device *me, + psim *system, + cpu *processor, + unsigned_word cia, + ...) +{ + va_list ap; + unsigned_word stack_pointer; + char **argv; + char **envp; + va_start(ap, cia); + stack_pointer = va_arg(ap, unsigned_word); + argv = va_arg(ap, char **); + envp = va_arg(ap, char **); + if (strcmp(me->name, "stack@elf") == 0) + create_elf_stack_frame(system, stack_pointer, argv, envp); + else if (strcmp(me->name, "stack@xcoff") == 0) + create_aix_stack_frame(system, stack_pointer, argv, envp); } -static device_descriptor halt_descriptor = { - "halt", - halt_create, + +static device_callbacks const stack_callbacks = { + ignore_device_init, + unimp_device_attach_address, + unimp_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + unimp_device_dma_read_buffer, + unimp_device_dma_write_buffer, + unimp_device_attach_interrupt, + unimp_device_detach_interrupt, + unimp_device_interrupt, + unimp_device_interrupt_ack, + stack_ioctl_callback, }; -static device_descriptor *devices[] = { - &console_descriptor, - &halt_descriptor, - &icu_descriptor, - NULL, + +/* Table of all the devices and a function to lookup/create a device + from its name */ + +typedef const device *(device_creator) + (const char *name, + const device *parent); + +typedef struct _device_descriptor device_descriptor; +struct _device_descriptor { + const char *name; + device_creator *creator; + const device_callbacks *callbacks; +}; + +static device_descriptor devices[] = { + { "console", console_create, NULL }, + { "memory", memory_create, NULL }, + { "vm", vea_vm_create, NULL }, + { "halt", NULL, &halt_callbacks }, + { "icu", NULL, &icu_callbacks }, + { "register", NULL, ®ister_callbacks }, + { "iobus", NULL, &iobus_callbacks }, + { "file", NULL, &file_callbacks }, + { "htab", NULL, &htab_callbacks }, + { "pte", NULL, &htab_callbacks }, /* yep - uses htab's table */ + { "stack", NULL, &stack_callbacks }, + { "sim", NULL, &sim_callbacks }, + { "load-binary", NULL, &binary_callbacks }, + { "map-binary", NULL, &binary_callbacks }, + { NULL }, }; -INLINE_DEVICES device_descriptor * -find_device_descriptor(char *name) +INLINE_DEVICES const device * +device_create(const char *name, + const device *parent) { - device_descriptor **device; + device_descriptor *device; int name_len; char *chp; chp = strchr(name, '@'); name_len = (chp == NULL ? strlen(name) : chp - name); - for (device = devices; *device != NULL; device++) { - if (strncmp(name, (*device)->name, name_len) == 0 - && ((*device)->name[name_len] == '\0' - || (*device)->name[name_len] == '@')) - return *device; + for (device = devices; device->name != NULL; device++) { + if (strncmp(name, device->name, name_len) == 0 + && (device->name[name_len] == '\0' + || device->name[name_len] == '@')) + if (device->creator != NULL) + return device->creator(name, parent); + else + return device_create_from(name, + NULL /* data */, + device->callbacks, + parent); } + error("device_create() unknown device %s\n", name); return NULL; } + +INLINE_DEVICES const device * +device_create_from(const char *name, + void *data, + const device_callbacks *callback, + const device *parent) +{ + device *me = ZALLOC(device); + me->name = strdup(name); + me->data = data; + me->callback = callback; + me->parent = parent; + return me; +} + + +INLINE_DEVICES const device_callbacks * +passthrough_device_callbacks(void) +{ + static const device_callbacks callbacks = { + ignore_device_init, + pass_device_attach_address, + pass_device_detach_address, + unimp_device_io_read_buffer, + unimp_device_io_write_buffer, + pass_device_dma_read_buffer, + pass_device_dma_write_buffer, + pass_device_attach_interrupt, + pass_device_detach_interrupt, + pass_device_interrupt, + unimp_device_interrupt_ack, + unimp_device_ioctl, + }; + return &callbacks; +} + + + #endif /* _DEVICES_C_ */ diff --git a/sim/ppc/devices.h b/sim/ppc/devices.h index e115779..681992e 100644 --- a/sim/ppc/devices.h +++ b/sim/ppc/devices.h @@ -26,17 +26,311 @@ #define INLINE_DEVICES #endif -#include "device_tree.h" -/* table of all the configured devices */ +/* forward declaration of types */ +/* typedef struct _device device; -- in devices.h */ -typedef struct _device_descriptor device_descriptor; -struct _device_descriptor { - char *name; - device_creator *creator; + +/* Address access attributes that can be attached to a devices address + range */ +typedef enum _access_type { + access_invalid = 0, + access_read = 1, + access_write = 2, + access_read_write = 3, + access_exec = 4, + access_read_exec = 5, + access_write_exec = 6, + access_read_write_exec = 7, +} access_type; + +/* Address attachement types */ +typedef enum _attach_type { + attach_invalid, + attach_callback, + attach_default, + attach_raw_memory, +} attach_type; + + +/* Operators on devices: */ + + +/* Initialization: + + A device is made fully functional in two stages. + + 1. It is created. A device is created _before_ it is entered into + the device tree. During creation any permenant structures needed + by the device should be created/initialized. + + 2. It is initialized. Before a simulation run, each device in the + device tree is initialized in prefix order. As part of this + initialization, a device should (re)attach its self to its parent + as needed. + + */ + +typedef void (device_init_callback) + (const device *me, + psim *system); + + +/* Data transfers: + + A device may permit the reading/writing (IO) of its registers in + one or more address spaces. For instance, a PCI device may have + config registers in its config space and control registers in both + the io and memory spaces of a PCI bus. + + Similarly, a device may initiate a data transfer (DMA) by passing + such a request up to its parent. + + Init: + + As part of its initialization (not creation) and possibly also as a + consequence of IO a device may attach its self to one or more of + the address spaces of its parent device. + + For instance, a PCI device, during initialization would attach its + config registers (space=0?, base=0, nr_bytes=64) to its parent PCI + bridge. Later, due to a write to this config space, the same + device may in turn find it necessary to also attach its self to + it's parent's `memory' or `io' space. + + To perform these operations, a device will call upon its parent + using either device_attach_address or device_detach_address. + + * Any address specified is according to what the device expects to + see. + + * Any detach operation must exactly match a previous attach. + + * included with the attach or detach is the devices name, the + parent may use this as part of determining how to map map between a + child's address + space and its own. + + * at any time, at most one device can have a default mapping + registered. + + + IO: + + A device receives requests to perform reads/writes to its registers + or memory either A. from a processor or B. from a parent device. + + The device may then in turn either A. resolve the IO request + locally by processing the data or trigering an exception or + B. re-mapping the access onto one of its local address spaces and + then in turn passing that on to one of its children. + + * Any address passed is relative to the local device. Eg for PCI + config registers, the address would (normally) be in the range of 0 + to 63. + + * Any exception situtation triggered by an IO operation (processor + != NULL) is handled in one of the following ways: 1. Machine check + (and similar): issued immediatly by restarting the cpu; 2. External + exception: issue delayed (using events.h) until the current + instruction execution cycle is completed; 3. Slave device (and + similar): the need for the interrupt is passed on to the devices + parent (which being an interrupt control unit will in turn take one + of the actions described here); 4. Forget it. + + * Any exception situtation trigered by a non IO operation + (processor == NULL) is handled buy returning 0. + + * Transfers of size <= 8 and of a power of 2 *must* be correctly + aligned and should be treated as a `single cycle' transfer. + + DMA: + + A device initiates a DMA transfer by calling its parent with the + request. At the top level (if not done earlier) this is reflected + back down the tree as io read/writes to the target device. + + This function is subject to change ... + + */ + +typedef void (device_config_address_callback) + (const device *me, + const char *name, + attach_type type, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + access_type access, + const device *who); /*callback/default*/ + +typedef unsigned (device_io_read_buffer_callback) + (const device *me, + void *dest, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia); + +typedef unsigned (device_io_write_buffer_callback) + (const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + cpu *processor, + unsigned_word cia); + +typedef unsigned (device_dma_read_buffer_callback) + (const device *me, + void *dest, + int address_space, + unsigned_word addr, + unsigned nr_bytes); + +typedef unsigned (device_dma_write_buffer_callback) + (const device *me, + const void *source, + int address_space, + unsigned_word addr, + unsigned nr_bytes, + int violate_read_only_section); + + +/* Interrupts: + + As mentioned above. Instead of handling an interrupt directly, a + device may instead pass the need to interrupt on to its parent. + + Init: + + Before passing interrupts up to is parent, a device must first + attach its interrupt lines to the parent device. To do this, the + device uses the parents attach/detach calls. + + Interrupts: + + A child notifies a parent of a change in an interrupt lines status + using the interrupt call. Similarly, a parent may notify a child + of any `interrupt ack' sequence using the interrupt_ack call. + + */ + +typedef void (device_config_interrupt_callback) + (const device *me, + const device *who, + int interrupt_line, + const char *name); + +typedef void (device_interrupt_ack_callback) + (const device *me, + int interrupt_line, + int interrupt_status); + +typedef void (device_interrupt_callback) + (const device *me, + const device *who, + int interrupt_line, + int interrupt_status, + cpu *processor, + unsigned_word cia); + + +/* IOCTL: + + Very simply, a catch all for any thing that turns up that until now + either hasn't been thought of or doesn't justify an extra function. */ + + +typedef void (device_ioctl_callback) + (const device *me, + psim *system, + cpu *processor, + unsigned_word cia, + ...); + + + +/* the callbacks */ + +typedef struct _device_callbacks { + /* initialization */ + device_init_callback *init; + /* address/data config - from child */ + device_config_address_callback *attach_address; + device_config_address_callback *detach_address; + /* address/data transfer - to child */ + device_io_read_buffer_callback *io_read_buffer; + device_io_write_buffer_callback *io_write_buffer; + /* address/data transfer - from child */ + device_dma_read_buffer_callback *dma_read_buffer; + device_dma_write_buffer_callback *dma_write_buffer; + /* interrupt config - from child */ + device_config_interrupt_callback *attach_interrupt; + device_config_interrupt_callback *detach_interrupt; + /* interrupt transfer - from child */ + device_interrupt_callback *interrupt; + /* interrupt transfer - to child */ + device_interrupt_ack_callback *interrupt_ack; + /* back door to anything we've forgot */ + device_ioctl_callback *ioctl; +} device_callbacks; + +/* A device */ +struct _device { + const char *name; /* eg rom@0x1234, 0x400 */ + void *data; /* device specific data */ + const device_callbacks *callback; + const device *parent; }; -INLINE_DEVICES device_descriptor *find_device_descriptor(char *name); +/* Create a new device, finding it in the builtin device table */ + +INLINE_DEVICES const device *device_create +(const char *name, + const device *parent); + +/* create a new device using the parameterized data */ + +INLINE_DEVICES const device *device_create_from +(const char *name, + void *data, + const device_callbacks *callback, + const device *parent); + + +/* Unimplemented call back functions. These abort the simulation */ + +INLINE_DEVICES device_init_callback unimp_device_init; +INLINE_DEVICES device_config_address_callback unimp_device_attach_address; +INLINE_DEVICES device_config_address_callback unimp_device_detach_address; +INLINE_DEVICES device_io_read_buffer_callback unimp_device_io_read_buffer; +INLINE_DEVICES device_io_write_buffer_callback unimp_device_io_write_buffer; +INLINE_DEVICES device_dma_read_buffer_callback unimp_device_dma_read_buffer; +INLINE_DEVICES device_dma_write_buffer_callback unimp_device_dma_write_buffer; +INLINE_DEVICES device_config_interrupt_callback unimp_device_attach_interrupt; +INLINE_DEVICES device_config_interrupt_callback unimp_device_detach_interrupt; +INLINE_DEVICES device_interrupt_callback unimp_device_interrupt; +INLINE_DEVICES device_interrupt_ack_callback unimp_device_interrupt_ack; +INLINE_DEVICES device_ioctl_callback unimp_device_ioctl; + +/* Pass through and ignore callback functions. A call going towards + the root device are passed on up, local calls are ignored and call + downs abort */ + +INLINE_DEVICES device_init_callback ignore_device_init; +INLINE_DEVICES device_config_address_callback pass_device_attach_address; +INLINE_DEVICES device_config_address_callback pass_device_detach_address; +INLINE_DEVICES device_dma_read_buffer_callback pass_device_dma_read_buffer; +INLINE_DEVICES device_dma_write_buffer_callback pass_device_dma_write_buffer; +INLINE_DEVICES device_config_interrupt_callback pass_device_attach_interrupt; +INLINE_DEVICES device_config_interrupt_callback pass_device_detach_interrupt; +INLINE_DEVICES device_interrupt_callback pass_device_interrupt; + +INLINE_DEVICES const device_callbacks *passthrough_device_callbacks +(void); + + #endif /* _DEVICES_H_ */ diff --git a/sim/ppc/gen.c b/sim/ppc/gen.c index cc46952..b9870ab 100644 --- a/sim/ppc/gen.c +++ b/sim/ppc/gen.c @@ -23,11 +23,7 @@ Instead of using/abusing macro's the semantic code should be parsed and each `cachable' expression replaced with the corresponding - value. - - If not expanding fields, invalid_insn has call to its self this is - a little fatal when semantic_invalid() is being called because an - instruction is invalid */ + value. */ #include <sys/types.h> @@ -52,7 +48,7 @@ /****************************************************************/ -void +static void error (char *msg, ...) { va_list ap; @@ -62,7 +58,7 @@ error (char *msg, ...) exit (1); } -void * +static void * zmalloc(long size) { void *memory = malloc(size); @@ -72,7 +68,7 @@ zmalloc(long size) return memory; } -void +static void dumpf (int indent, char *msg, ...) { va_list ap; @@ -121,10 +117,11 @@ typedef struct _opcode_rules { /* FIXME - this should be loaded from a file */ opcode_rules opcode_table[] = WITH_IDECODE_OPCODE_RULES; +static void dump_opcode_rule(opcode_rules *rule, int indent) { - printf("(opcode_rules*)0x%x\n", rule); + printf("(opcode_rules*)%p\n", rule); dumpf(indent, "(valid %d)\n", rule->valid); ASSERT(rule != NULL); if (rule->valid) { @@ -158,7 +155,7 @@ char insn_local[] = "unsigned_word nia = cia + 4;"; /****************************************************************/ -int +static int bin2i(char *bin, int width) { int i = 0; @@ -171,7 +168,7 @@ bin2i(char *bin, int width) } -int +static int it_is(char *flag, char *flags) { @@ -203,13 +200,16 @@ struct _lf { }; -lf * -lf_open(char *name) +static lf * +lf_open(char *name, + char *real_name) { /* create a file object */ lf *new_lf = zmalloc(sizeof(lf)); ASSERT(new_lf != NULL); - new_lf->file_name = name; + new_lf->file_name = (real_name == NULL + ? name + : real_name); /* attach to stdout if pipe */ if (!strcmp(name, "-")) { @@ -224,7 +224,7 @@ lf_open(char *name) } -void +static void lf_close(lf *file) { if (file->stream != stdout) { @@ -237,7 +237,7 @@ lf_close(lf *file) } -void +static void lf_putchr(lf *file, const char chr) { @@ -254,14 +254,14 @@ lf_putchr(lf *file, putc(chr, file->stream); } -void +static void lf_indent_suppress(lf *file) { file->line_blank = 0; } -void +static void lf_putstr(lf *file, const char *string) { @@ -273,7 +273,7 @@ lf_putstr(lf *file, } } -void +static void do_lf_putunsigned(lf *file, unsigned u) { @@ -284,7 +284,7 @@ do_lf_putunsigned(lf *file, } -void +static void lf_putint(lf *file, int decimal) { @@ -301,7 +301,7 @@ lf_putint(lf *file, ASSERT(0); } -void +static void lf_printf(lf *file, const char *fmt, ...) @@ -318,7 +318,7 @@ lf_printf(lf *file, va_end(ap); } -void +static void lf_print_file_line_nr(lf *file) { #if WITH_LINE_NUMBERS @@ -331,6 +331,7 @@ lf_print_file_line_nr(lf *file) #endif } +static void lf_indent(lf *file, int delta) { file->indent += delta; @@ -363,7 +364,7 @@ struct _file_table_entry { }; -file_table * +static file_table * file_table_open(char *file_name) { int fd; @@ -411,7 +412,7 @@ file_table_open(char *file_name) } -file_table_entry * +static file_table_entry * file_table_read(file_table *file) { int field; @@ -494,11 +495,11 @@ file_table_read(file_table *file) } -void +static void dump_file_table_entry(file_table_entry *entry, int indent) { - printf("(file_table_entry*)0x%x\n", entry); + printf("(file_table_entry*)%p\n", entry); if (entry != NULL) { int field; @@ -548,7 +549,7 @@ struct _insn_fields { unsigned value; }; -insn_field * +static insn_field * insn_field_new() { insn_field *new_field = (insn_field*)zmalloc(sizeof(insn_field)); @@ -556,7 +557,7 @@ insn_field_new() return new_field; } -insn_fields * +static insn_fields * insn_fields_new() { insn_fields *new_fields = (insn_fields*)zmalloc(sizeof(insn_fields)); @@ -565,7 +566,7 @@ insn_fields_new() } -insn_fields * +static insn_fields * parse_insn_format(file_table_entry *entry, char *format) { @@ -600,9 +601,8 @@ parse_insn_format(file_table_entry *entry, /* sanity check */ if (!isdigit(*chp)) { - fprintf(stderr, "%s:%d: missing position field at %s\n", - entry->file_name, entry->line_nr, chp); - break; + error("%s:%d: missing position field at `%s'\n", + entry->file_name, entry->line_nr, chp); } /* break out the bit position */ @@ -613,23 +613,23 @@ parse_insn_format(file_table_entry *entry, if (*chp == '.' && strlen_pos > 0) chp++; else { - fprintf(stderr, "%s:%d: missing field value at %s\n", - entry->file_name, entry->line_nr, chp); + error("%s:%d: missing field value at %s\n", + entry->file_name, entry->line_nr, chp); break; } /* break out the value */ start_val = chp; - while (*start_val == '/' && *chp == '/' - || isdigit(*start_val) && isdigit(*chp) - || isalpha(*start_val) && (isalnum(*chp) || *chp == '_')) + while ((*start_val == '/' && *chp == '/') + || (isdigit(*start_val) && isdigit(*chp)) + || (isalpha(*start_val) && (isalnum(*chp) || *chp == '_'))) chp++; strlen_val = chp - start_val; if (*chp == ',') chp++; else if (*chp != '\0' || strlen_val == 0) { - fprintf(stderr, "%s:%d: missing field terminator at %s\n", - entry->file_name, entry->line_nr, chp); + error("%s:%d: missing field terminator at %s\n", + entry->file_name, entry->line_nr, chp); break; } @@ -706,7 +706,7 @@ typedef enum { } constant_field_types; -int +static int insn_field_is_constant(insn_field *field, opcode_rules *rule) { @@ -738,12 +738,12 @@ insn_field_is_constant(insn_field *field, } -void +static void dump_insn_field(insn_field *field, int indent) { - printf("(insn_field*)0x%x\n", field); + printf("(insn_field*)0x%x\n", (unsigned)field); dumpf(indent, "(first %d)\n", field->first); @@ -767,14 +767,14 @@ dump_insn_field(insn_field *field, } -void +static void dump_insn_fields(insn_fields *fields, int indent) { insn_field *field; int i; - printf("(insn_fields*)0x%x\n", fields); + printf("(insn_fields*)%p\n", fields); dumpf(indent, "(first 0x%x)\n", fields->first); dumpf(indent, "(last 0x%x)\n", fields->last); @@ -800,7 +800,7 @@ struct _opcode_field { opcode_field *parent; }; -opcode_field * +static opcode_field * opcode_field_new() { opcode_field *new_field = (opcode_field*)zmalloc(sizeof(opcode_field)); @@ -810,10 +810,10 @@ opcode_field_new() return new_field; } -void +static void dump_opcode_field(opcode_field *field, int indent, int levels) { - printf("(opcode_field*)0x%x\n", field); + printf("(opcode_field*)%p\n", field); if (levels && field != NULL) { dumpf(indent, "(first %d)\n", field->first); dumpf(indent, "(last %d)\n", field->last); @@ -835,7 +835,7 @@ struct _insn_bits { insn_bits *last; }; -insn_bits * +static insn_bits * insn_bits_new() { insn_bits *new_bits = (insn_bits*)zmalloc(sizeof(insn_bits)); @@ -844,10 +844,10 @@ insn_bits_new() } -void +static void dump_insn_bits(insn_bits *bits, int indent, int levels) { - printf("(insn_bits*)0x%x\n", bits); + printf("(insn_bits*)%p\n", bits); if (levels && bits != NULL) { dumpf(indent, "(value %d)\n", bits->value); @@ -873,12 +873,19 @@ typedef enum { insn_nmemonic, insn_name, insn_comment, - nr_insn_table_fields = file_table_max_fields + nr_insn_table_fields = file_table_max_fields, } insn_table_fields; char *insn_field_name[] = { "format", "form", "flags", "nmemonic", "name", "comments" }; +typedef enum { + function_type = insn_format, + function_name = insn_name, + function_param = insn_comment, +} function_table_fields; + + typedef struct _insn insn; struct _insn { file_table_entry *file_entry; @@ -892,6 +899,7 @@ struct _insn_table { insn_bits *expanded_bits; int nr_insn; insn *insns; + insn *functions; opcode_rules *opcode_rule; opcode_field *opcode; int nr_entries; @@ -902,7 +910,7 @@ struct _insn_table { -insn * +static insn * insn_new() { insn *new_entry = ((insn*) zmalloc(sizeof(insn))); @@ -910,7 +918,7 @@ insn_new() return new_entry; } -insn_table * +static insn_table * insn_table_new() { insn_table *new_table = (insn_table*)zmalloc(sizeof(insn_table)); @@ -919,7 +927,25 @@ insn_table_new() } -void +static void +insn_table_insert_function(insn_table *table, + file_table_entry *file_entry) +{ + insn **ptr_to_cur_function = &table->functions; + + /* create a new function */ + insn *new_function = insn_new(); + new_function->file_entry = file_entry; + + /* append it to the end of the function list */ + while (*ptr_to_cur_function != NULL) { + ptr_to_cur_function = &(*ptr_to_cur_function)->next; + } + *ptr_to_cur_function = new_function; +} + + +static void insn_table_insert_insn(insn_table *table, file_table_entry *file_entry, insn_fields *fields) @@ -946,7 +972,7 @@ insn_table_insert_insn(insn_table *table, } -opcode_field * +static opcode_field * insn_table_find_opcode_field(insn *insns, opcode_rules *rule, int string_only) @@ -1047,7 +1073,7 @@ insn_table_find_opcode_field(insn *insns, } -void +static void insn_table_insert_expanded(insn_table *table, insn *old_insn, int new_opcode_nr, @@ -1081,7 +1107,7 @@ insn_table_insert_expanded(insn_table *table, old_insn->fields); } -void +static void insn_table_expand_opcode(insn_table *table, insn *instruction, int field_nr, @@ -1124,6 +1150,7 @@ insn_table_expand_opcode(insn_table *table, } } +static void insn_table_insert_expanding(insn_table *table, insn *entry) { @@ -1135,7 +1162,7 @@ insn_table_insert_expanding(insn_table *table, } -void +static void insn_table_expand_insns(insn_table *table) { @@ -1196,7 +1223,7 @@ insn_table_expand_insns(insn_table *table) -insn_table * +static insn_table * insn_table_load_insns(char *file_name) { file_table *file = file_table_open(file_name); @@ -1204,25 +1231,33 @@ insn_table_load_insns(char *file_name) file_table_entry *file_entry; table->opcode_rule = opcode_table; - while (file_entry = file_table_read(file)) { - insn_fields *fields; - /* skip instructions that aren't relevant to the mode */ - if (it_is("64", file_entry->fields[insn_flags]) && !WITH_64BIT_TARGET - || it_is("32", file_entry->fields[insn_flags]) && WITH_64BIT_TARGET) - continue; - /* create/insert the new instruction */ - fields = parse_insn_format(file_entry, file_entry->fields[insn_format]); - insn_table_insert_insn(table, file_entry, fields); + while ((file_entry = file_table_read(file)) != NULL) { + if (it_is("function", file_entry->fields[insn_flags])) { + insn_table_insert_function(table, file_entry); + } + else { + insn_fields *fields; + /* skip instructions that aren't relevant to the mode */ + if ((it_is("64", file_entry->fields[insn_flags]) + && WITH_TARGET_WORD_BITSIZE != 64) + || (it_is("32", file_entry->fields[insn_flags]) + && WITH_TARGET_WORD_BITSIZE != 32) + || (it_is("f", file_entry->fields[insn_flags]) + && WITH_FLOATING_POINT == SOFT_FLOATING_POINT)) + continue; + /* create/insert the new instruction */ + fields = parse_insn_format(file_entry, file_entry->fields[insn_format]); + insn_table_insert_insn(table, file_entry, fields); + } } - return table; } -void +static void dump_insn(insn *entry, int indent, int levels) { - printf("(insn*)0x%x\n", entry); + printf("(insn*)%p\n", entry); if (levels && entry != NULL) { @@ -1243,12 +1278,12 @@ dump_insn(insn *entry, int indent, int levels) } -void +static void dump_insn_table(insn_table *table, int indent, int levels) { - printf("(insn_table*)0x%x\n", table); + printf("(insn_table*)%p\n", table); if (levels && table != NULL) { insn *entry; @@ -1293,7 +1328,7 @@ dump_insn_table(insn_table *table, /****************************************************************/ -void +static void lf_print_copyleft(lf *file) { lf_putstr(file, "\ @@ -1326,7 +1361,7 @@ lf_print_copyleft(lf *file) } -void +static void lf_print_c_line_nr(lf *file, file_table_entry *entry) { #if WITH_LINE_NUMBERS @@ -1340,7 +1375,7 @@ lf_print_c_line_nr(lf *file, file_table_entry *entry) } -void +static void lf_print_c_code(lf *file, char *code) { char *chp = code; @@ -1378,7 +1413,7 @@ lf_print_c_code(lf *file, char *code) } -void +static void lf_print_binary(lf *file, int decimal, int width) { int bit; @@ -1394,7 +1429,7 @@ lf_print_binary(lf *file, int decimal, int width) } -void +static void lf_print_insn_bits(lf *file, insn_bits *bits) { if (bits == NULL) @@ -1410,7 +1445,7 @@ lf_print_insn_bits(lf *file, insn_bits *bits) } } -void +static void lf_print_opcodes(lf *file, insn_table *table) { @@ -1426,7 +1461,7 @@ lf_print_opcodes(lf *file, } } -void +static void lf_print_table_name(lf *file, insn_table *table) { @@ -1442,12 +1477,13 @@ typedef enum { function_name_prefix_none } lf_function_name_prefixes; -void +static void lf_print_function_name(lf *file, - insn *instruction, + char *basename, insn_bits *expanded_bits, lf_function_name_prefixes prefix) { + /* the prefix */ switch (prefix) { case function_name_prefix_semantics: @@ -1463,7 +1499,7 @@ lf_print_function_name(lf *file, /* the function name */ { char *pos; - for (pos = instruction->file_entry->fields[insn_name]; + for (pos = basename; *pos != '\0'; pos++) { switch (*pos) { @@ -1486,7 +1522,7 @@ lf_print_function_name(lf *file, } -void +static void lf_print_idecode_table(lf *file, insn_table *entry) { @@ -1574,7 +1610,7 @@ lf_print_idecode_table(lf *file, } -void +static void lf_print_my_prefix(lf *file, file_table_entry *file_entry) { @@ -1586,7 +1622,7 @@ lf_print_my_prefix(lf *file, } -void +static void lf_print_ptrace(lf *file) { lf_printf(file, "\n"); @@ -1607,7 +1643,7 @@ typedef void padding_handler int opcode_nr); -void +static void insn_table_traverse_tree(insn_table *table, void *data, int depth, @@ -1657,12 +1693,31 @@ insn_table_traverse_tree(insn_table *table, } +typedef void function_handler +(insn_table *table, + void *data, + file_table_entry *function); + +static void +insn_table_traverse_function(insn_table *table, + void *data, + function_handler *leaf) +{ + insn *function; + for (function = table->functions; + function != NULL; + function = function->next) { + leaf(table, data, function->file_entry); + } +} + + typedef void insn_handler (insn_table *table, void *data, insn *instruction); -void +static void insn_table_traverse_insn(insn_table *table, void *data, insn_handler *leaf) @@ -1676,7 +1731,7 @@ insn_table_traverse_insn(insn_table *table, } -void +static void update_depth(insn_table *entry, void *data, int depth) @@ -1687,7 +1742,7 @@ update_depth(insn_table *entry, } -int +static int insn_table_depth(insn_table *table) { int depth = 0; @@ -1704,7 +1759,7 @@ insn_table_depth(insn_table *table) /****************************************************************/ -void +static void dump_traverse_start(insn_table *table, void *data, int depth) @@ -1712,7 +1767,7 @@ dump_traverse_start(insn_table *table, dumpf(depth*2, "(%d\n", table->opcode_nr); } -void +static void dump_traverse_leaf(insn_table *entry, void *data, int depth) @@ -1724,7 +1779,7 @@ dump_traverse_leaf(insn_table *entry, entry->insns->file_entry->fields[insn_format]); } -void +static void dump_traverse_end(insn_table *table, void *data, int depth) @@ -1732,7 +1787,7 @@ dump_traverse_end(insn_table *table, dumpf(depth*2, ")\n"); } -void +static void dump_traverse_padding(insn_table *table, void *data, int depth, @@ -1742,7 +1797,7 @@ dump_traverse_padding(insn_table *table, } -void +static void dump_traverse(insn_table *table) { insn_table_traverse_tree(table, NULL, 1, @@ -1756,15 +1811,15 @@ dump_traverse(insn_table *table) /****************************************************************/ -void +static void semantics_h_print_function(lf *file, - insn *instruction, + char *basename, insn_bits *expanded_bits) { lf_printf(file, "\n"); lf_printf(file, "INLINE_SEMANTICS unsigned_word "); lf_print_function_name(file, - instruction, + basename, expanded_bits, function_name_prefix_semantics); lf_printf(file, "\n(%s);\n", @@ -1772,27 +1827,52 @@ semantics_h_print_function(lf *file, } -void +static void semantics_h_leaf(insn_table *entry, void *data, int depth) { lf *file = (lf*)data; ASSERT(entry->nr_insn == 1); - semantics_h_print_function(file, entry->insns, entry->expanded_bits); + semantics_h_print_function(file, + entry->insns->file_entry->fields[insn_name], + entry->expanded_bits); } -void +static void semantics_h_insn(insn_table *entry, void *data, insn *instruction) { lf *file = (lf*)data; - semantics_h_print_function(file, instruction, NULL); + semantics_h_print_function(file, + instruction->file_entry->fields[insn_name], + NULL); +} + +static void +semantics_h_function(insn_table *entry, + void *data, + file_table_entry *function) +{ + lf *file = (lf*)data; + if (function->fields[function_type] == NULL + || function->fields[function_type][0] == '\0') { + semantics_h_print_function(file, + function->fields[function_name], + NULL); + } + else { + lf_printf(file, "\n"); + lf_printf(file, "INLINE_SEMANTICS %s %s\n(%s);\n", + function->fields[function_type], + function->fields[function_name], + function->fields[function_param]); + } } -void +static void gen_semantics_h(insn_table *table, lf *file) { @@ -1807,6 +1887,12 @@ gen_semantics_h(insn_table *table, lf *file) lf_printf(file, "\n"); lf_printf(file, "\n"); + /* output a declaration for all functions */ + insn_table_traverse_function(table, + file, + semantics_h_function); + + /* output a declaration for all instructions */ if (idecode_expand_semantics) insn_table_traverse_tree(table, file, @@ -1834,7 +1920,7 @@ struct _icache_tree { icache_tree *children; }; -icache_tree * +static icache_tree * icache_tree_new() { icache_tree *new_tree = (icache_tree*)zmalloc(sizeof(icache_tree)); @@ -1842,7 +1928,7 @@ icache_tree_new() return new_tree; } -icache_tree * +static icache_tree * icache_tree_insert(icache_tree *tree, char *name) { @@ -1872,7 +1958,7 @@ icache_tree_insert(icache_tree *tree, } -icache_tree * +static icache_tree * insn_table_cache_fields(insn_table *table) { icache_tree *tree = icache_tree_new(); @@ -1896,7 +1982,7 @@ insn_table_cache_fields(insn_table *table) -void +static void gen_icache_h(icache_tree *tree, lf *file) { @@ -1976,7 +2062,7 @@ gen_icache_h(icache_tree *tree, /****************************************************************/ -void +static void lf_print_c_extraction(lf *file, insn *instruction, char *field_name, @@ -2030,7 +2116,7 @@ lf_print_c_extraction(lf *file, } -void +static void lf_print_c_extractions(lf *file, insn *instruction, insn_bits *expanded_bits, @@ -2126,7 +2212,24 @@ lf_print_c_extractions(lf *file, lf_print_file_line_nr(file); } -void + +static void +lf_print_idecode_illegal(lf *file) +{ + switch (idecode_cache) { + case 0: + lf_printf(file, "return semantic_illegal(%s);\n", insn_actual); + break; + case 1: + lf_printf(file, "return semantic_illegal;\n"); + break; + default: + lf_printf(file, "return idecode_illegal(%s);\n", cache_idecode_actual); + } +} + + +static void lf_print_c_validate(lf *file, insn *instruction, opcode_field *opcodes) @@ -2161,30 +2264,21 @@ lf_print_c_validate(lf *file, } /* if any bits not checked by opcode tables, output code to check them */ - if (!it_is("illegal", instruction->file_entry->fields[insn_flags]) - && check_mask) { + if (check_mask) { lf_printf(file, "\n"); lf_printf(file, "/* validate: %s */\n", instruction->file_entry->fields[insn_format]); - lf_printf(file, "if ((instruction & 0x%x) != 0x%x) {\n", + lf_printf(file, "if ((instruction & 0x%x) != 0x%x)\n", check_mask, check_val); - switch (idecode_cache) { - case 0: - lf_printf(file, " return semantic_illegal(%s);\n", insn_actual); - break; - case 1: - lf_printf(file, " return semantic_illegal;\n"); - break; - default: - lf_printf(file, " return idecode_illegal(%s);\n", cache_idecode_actual); - } - lf_printf(file, "}\n"); + lf_indent(file, +2); + lf_print_idecode_illegal(file); + lf_indent(file, -2); } } -void +static void lf_print_c_cracker(lf *file, insn *instruction, insn_bits *expanded_bits, @@ -2219,7 +2313,7 @@ lf_print_c_cracker(lf *file, lf_print_c_line_nr(file, instruction->file_entry); lf_printf(file, "return "); lf_print_function_name(file, - instruction, + instruction->file_entry->fields[insn_name], expanded_bits, function_name_prefix_semantics); lf_printf(file, ";\n"); @@ -2230,7 +2324,7 @@ lf_print_c_cracker(lf *file, } -void +static void lf_print_c_semantic(lf *file, insn *instruction, insn_bits *expanded_bits, @@ -2258,12 +2352,21 @@ lf_print_c_semantic(lf *file, if (idecode_cache < 2) lf_print_c_validate(file, instruction, opcodes); - /* if OEA and a floating point generate a check that fp is enabled */ + /* if floating-point generate checks that a. floating point hardware + exists and b. floating point is enabled */ if (it_is("f", instruction->file_entry->fields[insn_flags])) { lf_printf(file, "\n"); - lf_printf(file, "/* verify FP is enabled */\n"); + lf_printf(file, "/* verify: FP hardware exists */\n"); + lf_printf(file, "if (CURRENT_FLOATING_POINT != HARD_FLOATING_POINT)\n"); + lf_indent(file, +2); + lf_print_idecode_illegal(file); + lf_indent(file, -2); + lf_printf(file, "\n"); + lf_printf(file, "/* verify: FP is enabled */\n"); lf_printf(file, "if (!IS_FP_AVAILABLE(processor))\n"); - lf_printf(file, " floating_point_unavailable_interrupt(processor, cia);\n"); + lf_indent(file, +2); + lf_printf(file, "floating_point_unavailable_interrupt(processor, cia);\n"); + lf_indent(file, -2); } /* generate the code (or at least something */ @@ -2282,8 +2385,9 @@ lf_print_c_semantic(lf *file, lf_print_file_line_nr(file); } else if (it_is("f", instruction->file_entry->fields[insn_flags])) { - /* unimplemented floating point - call for assistance */ + /* unimplemented floating point instruction - call for assistance */ lf_printf(file, "\n"); + lf_printf(file, "/* unimplemented floating point instruction - call for assistance */\n"); lf_print_c_line_nr(file, instruction->file_entry); lf_putstr(file, "floating_point_assist_interrupt(processor, cia);\n"); lf_print_file_line_nr(file); @@ -2302,25 +2406,32 @@ lf_print_c_semantic(lf *file, lf_printf(file, "}\n"); } -void -lf_print_c_semantic_function(lf *file, - insn *instruction, - insn_bits *expanded_bits, - opcode_field *opcodes) +static void +lf_print_c_semantic_function_header(lf *file, + char *basename, + insn_bits *expanded_bits) { - - /* build the semantic routine to execute the instruction */ - - /* function header */ lf_printf(file, "\n"); lf_printf(file, "INLINE_SEMANTICS unsigned_word\n"); lf_print_function_name(file, - instruction, + basename, expanded_bits, function_name_prefix_semantics); lf_printf(file, "\n(%s)\n", idecode_cache > 1 ? cache_insn_formal : insn_formal); +} +static void +lf_print_c_semantic_function(lf *file, + insn *instruction, + insn_bits *expanded_bits, + opcode_field *opcodes) +{ + + /* build the semantic routine to execute the instruction */ + lf_print_c_semantic_function_header(file, + instruction->file_entry->fields[insn_name], + expanded_bits); lf_print_c_semantic(file, instruction, expanded_bits, @@ -2329,7 +2440,7 @@ lf_print_c_semantic_function(lf *file, } -void +static void semantics_c_leaf(insn_table *entry, void *data, int depth) @@ -2345,7 +2456,7 @@ semantics_c_leaf(insn_table *entry, entry->parent->opcode); } -void +static void semantics_c_insn(insn_table *table, void *data, insn *instruction) @@ -2355,9 +2466,37 @@ semantics_c_insn(insn_table *table, NULL, NULL); } +static void +semantics_c_function(insn_table *table, + void *data, + file_table_entry *function) +{ + lf *file = (lf*)data; + if (function->fields[function_type] == NULL + || function->fields[function_type][0] == '\0') { + lf_print_c_semantic_function_header(file, + function->fields[function_name], + NULL); + } + else { + lf_printf(file, "\n"); + lf_printf(file, "INLINE_SEMANTICS %s\n%s(%s)\n", + function->fields[function_type], + function->fields[function_name], + function->fields[function_param]); + } + lf_print_c_line_nr(file, function); + lf_printf(file, "{\n"); + lf_indent(file, +2); + lf_print_c_code(file, function->annex); + lf_indent(file, -2); + lf_printf(file, "}\n"); + lf_print_file_line_nr(file); +} + -void +static void gen_semantics_c(insn_table *table, lf *file) { lf_print_copyleft(file); @@ -2374,6 +2513,12 @@ gen_semantics_c(insn_table *table, lf *file) lf_printf(file, "#include \"semantics.h\"\n"); lf_printf(file, "\n"); + /* output a definition (c-code) for all functions */ + insn_table_traverse_function(table, + file, + semantics_c_function); + + /* output a definition (c-code) for all instructions */ if (idecode_expand_semantics) insn_table_traverse_tree(table, file, @@ -2394,7 +2539,7 @@ gen_semantics_c(insn_table *table, lf *file) /****************************************************************/ -void +static void gen_idecode_h(insn_table *table, lf *file) { lf_print_copyleft(file); @@ -2406,7 +2551,6 @@ gen_idecode_h(insn_table *table, lf *file) lf_printf(file, "#define INLINE_IDECODE\n"); lf_printf(file, "#endif\n"); lf_printf(file, "\n"); - lf_printf(file, "#include \"idecode_insn.h\"\n"); lf_printf(file, "#include \"idecode_expression.h\"\n"); lf_printf(file, "#include \"idecode_fields.h\"\n"); lf_printf(file, "#include \"idecode_branch.h\"\n"); @@ -2430,7 +2574,7 @@ gen_idecode_h(insn_table *table, lf *file) /****************************************************************/ -void +static void idecode_table_start(insn_table *table, void *data, int depth) @@ -2446,7 +2590,7 @@ idecode_table_start(insn_table *table, } } -void +static void idecode_table_leaf(insn_table *entry, void *data, int depth) @@ -2461,7 +2605,7 @@ idecode_table_leaf(insn_table *entry, /* table leaf entry */ lf_printf(file, " /*%d*/ { 0, 0, ", entry->opcode_nr); lf_print_function_name(file, - entry->insns, + entry->insns->file_entry->fields[insn_name], entry->expanded_bits, (idecode_cache < 2 ? function_name_prefix_semantics @@ -2491,7 +2635,7 @@ idecode_table_leaf(insn_table *entry, } } -void +static void idecode_table_end(insn_table *table, void *data, int depth) @@ -2504,7 +2648,7 @@ idecode_table_end(insn_table *table, } } -void +static void idecode_table_padding(insn_table *table, void *data, int depth, @@ -2528,7 +2672,7 @@ void lf_print_idecode_switch insn_table *table); -void +static void idecode_switch_start(insn_table *table, void *data, int depth) @@ -2542,7 +2686,7 @@ idecode_switch_start(insn_table *table, } -void +static void idecode_switch_leaf(insn_table *entry, void *data, int depth) @@ -2559,7 +2703,7 @@ idecode_switch_leaf(insn_table *entry, /* switch calling leaf */ lf_printf(file, "return "); lf_print_function_name(file, - entry->insns, + entry->insns->file_entry->fields[insn_name], entry->expanded_bits, (idecode_cache < 2 ? function_name_prefix_semantics @@ -2585,22 +2729,17 @@ idecode_switch_leaf(insn_table *entry, lf_indent(file, -2); } + +static void lf_print_idecode_switch_illegal(lf *file) { - switch (idecode_cache) { - case 0: - lf_printf(file, " return semantic_illegal(%s);\n", insn_actual); - break; - case 1: - lf_printf(file, " return semantic_illegal;\n"); - break; - default: - lf_printf(file, " return idecode_illegal(%s);\n", cache_idecode_actual); - } - lf_printf(file, " break;\n"); + lf_indent(file, +2); + lf_print_idecode_illegal(file); + lf_printf(file, "break;\n"); + lf_indent(file, -2); } -void +static void idecode_switch_end(insn_table *table, void *data, int depth) @@ -2616,7 +2755,7 @@ idecode_switch_end(insn_table *table, lf_printf(file, "}\n"); } -void +static void idecode_switch_padding(insn_table *table, void *data, int depth, @@ -2648,7 +2787,7 @@ lf_print_idecode_switch(lf *file, } -void +static void idecode_expand_if_switch(insn_table *table, void *data, int depth) @@ -2674,6 +2813,7 @@ idecode_expand_if_switch(insn_table *table, } +static void lf_print_c_cracker_function(lf *file, insn *instruction, insn_bits *expanded_bits, @@ -2683,7 +2823,7 @@ lf_print_c_cracker_function(lf *file, lf_printf(file, "\n"); lf_printf(file, "STATIC_INLINE_IDECODE idecode_semantic *\n"); lf_print_function_name(file, - instruction, + instruction->file_entry->fields[insn_name], expanded_bits, function_name_prefix_idecode); lf_printf(file, "\n(%s)\n", cache_idecode_formal); @@ -2694,7 +2834,7 @@ lf_print_c_cracker_function(lf *file, opcodes); } -void +static void idecode_crack_leaf(insn_table *entry, void *data, int depth) @@ -2710,7 +2850,7 @@ idecode_crack_leaf(insn_table *entry, entry->opcode); } -void +static void idecode_crack_insn(insn_table *entry, void *data, insn *instruction) @@ -2724,6 +2864,7 @@ idecode_crack_insn(insn_table *entry, /****************************************************************/ +static void gen_idecode_c(insn_table *table, lf *file) { int depth; @@ -2841,7 +2982,7 @@ struct _spreg_table { spreg_table_entry *sprs; }; -spreg_table_entry * +static spreg_table_entry * spreg_table_entry_new() { spreg_table_entry *new_entry = @@ -2850,7 +2991,7 @@ spreg_table_entry_new() return new_entry; } -spreg_table * +static spreg_table * spreg_table_new() { spreg_table *new_table = (spreg_table*)zmalloc(sizeof(spreg_table)); @@ -2858,7 +2999,7 @@ spreg_table_new() return new_table; } -void +static void spreg_table_insert(spreg_table *table, file_table_entry *entry) { /* create a new spr entry */ @@ -2898,7 +3039,7 @@ spreg_table_insert(spreg_table *table, file_table_entry *entry) } -spreg_table * +static spreg_table * spreg_table_load(char *file_name) { file_table *file = file_table_open(file_name); @@ -2906,7 +3047,7 @@ spreg_table_load(char *file_name) { file_table_entry *entry; - while (entry = file_table_read(file)) { + while ((entry = file_table_read(file)) != NULL) { spreg_table_insert(table, entry); } } @@ -2926,7 +3067,7 @@ char *spreg_attributes[] = { 0 }; -void +static void gen_spreg_h(spreg_table *table, lf *file) { spreg_table_entry *entry; @@ -2969,7 +3110,7 @@ gen_spreg_h(spreg_table *table, lf *file) } -void +static void gen_spreg_c(spreg_table *table, lf *file) { spreg_table_entry *entry; @@ -3060,9 +3201,10 @@ main(int argc, insn_table *instructions = NULL; spreg_table *sprs = NULL; icache_tree *cache_fields = NULL; + char *real_file_name = NULL; int ch; - while ((ch = getopt(argc, argv, "i:I:r:S:s:D:d:P:p:C:")) != -1) { + while ((ch = getopt(argc, argv, "n:i:I:r:S:s:D:d:P:p:C:")) != -1) { fprintf(stderr, "\t-%c %s\n", ch, optarg); switch(ch) { case 'I': @@ -3080,9 +3222,12 @@ main(int argc, case 'r': sprs = spreg_table_load(optarg); break; + case 'n': + real_file_name = strdup(optarg); + break; default: { - lf *file = lf_open(optarg); + lf *file = lf_open(optarg, real_file_name); switch (ch) { case 'S': gen_semantics_h(instructions, file); @@ -3108,6 +3253,7 @@ main(int argc, } lf_close(file); } + real_file_name = NULL; } } return 0; diff --git a/sim/ppc/idecode_insn.h b/sim/ppc/idecode_insn.h deleted file mode 100644 index 4e56b78..0000000 --- a/sim/ppc/idecode_insn.h +++ /dev/null @@ -1,67 +0,0 @@ -/* This file is part of the program psim. - - Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au> - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - - */ - - -/* - * Interface for the Instruction execution routines - */ - -/* - * Macro's that define the parts of an instruction - */ - -#define FLOATING_POINT_ENABLED_PROGRAM_INTERRUPT \ - program_interrupt(processor, \ - cia, \ - floating_point_enabled_program_interrupt) - -#define ILLEGAL_INSN_PROGRAM_INTERRUPT \ - program_interrupt(processor, \ - cia, \ - illegal_instruction_program_interrupt) -#define PRIVILEGED_INSN_PROGRAM_INTERRUPT \ - program_interrupt(processor, \ - cia, \ - privileged_instruction_program_interrupt) - -#define TRAP_PROGRAM_INTERRUPT \ - program_interrupt(processor, \ - cia, \ - trap_program_interrupt) - -#define FLOATING_POINT_UNAVAILABLE_INTERRUPT \ - floating_point_unavailable_interrupt(processor, \ - cia) - -#define FLOATING_POINT_ASSIST_INTERRUPT \ - floating_point_assist_interrupt(processor, \ - cia) - -#define BREAKPOINT \ - do { \ - ITRACE(trace_breakpoint, \ - ("breakpoint - cia0x%x\n", \ - cia)); \ - cpu_halt(processor, cia, was_trap, 0); \ - } while (0) - -#define SYSTEM_CALL_INTERRUPT \ - system_call_interrupt(processor, \ - cia) diff --git a/sim/ppc/memory_map.c b/sim/ppc/memory_map.c deleted file mode 100644 index af97006..0000000 --- a/sim/ppc/memory_map.c +++ /dev/null @@ -1,355 +0,0 @@ -/* This file is part of the program psim. - - Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au> - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - - */ - - -#ifndef _MEMORY_MAP_C_ -#define _MEMORY_MAP_C_ - -#ifndef STATIC_INLINE_MEMORY_MAP -#define STATIC_INLINE_MEMORY_MAP STATIC_INLINE -#endif - - -#include "basics.h" -#include "device_tree.h" -#include "memory_map.h" -#include "interrupts.h" - - -typedef struct _memory_mapping memory_mapping; -struct _memory_mapping { - /* ram map */ - void *buffer; - /* device map */ - device_node *device; - device_reader_callback *reader; - device_writer_callback *writer; - /* common */ - unsigned_word base; - unsigned_word bound; - unsigned_word size; - struct _memory_mapping *next; -}; - -struct _memory_map { - memory_mapping *first; -}; - -INLINE_MEMORY_MAP memory_map * -new_memory_map(void) -{ - memory_map *new_map; - new_map = ZALLOC(memory_map); - return new_map; -} - -STATIC_INLINE_MEMORY_MAP void -memory_map_add_memory(memory_map *map, - device_node *device, - device_reader_callback *reader, - device_writer_callback *writer, - void *buffer, - unsigned_word base, - unsigned size) -{ - memory_mapping *new_mapping; - memory_mapping *next_mapping; - memory_mapping **last_mapping; - - /* actually do occasionally get a zero size map */ - if (size == 0) - return; - - new_mapping = ZALLOC(memory_mapping); - - /* ram */ - new_mapping->buffer = buffer; - /* devices */ - new_mapping->device = device; - new_mapping->reader = reader; - new_mapping->writer = writer; - /* common */ - new_mapping->base = base; - new_mapping->size = size; - new_mapping->bound = base + size; - - /* find the insertion point (between last/next) */ - next_mapping = map->first; - last_mapping = &map->first; - while(next_mapping != NULL && next_mapping->bound <= new_mapping->base) { - /* assert: new_mapping->base > all bases before next_mapping */ - /* assert: new_mapping->bound >= all bounds before next_mapping */ - last_mapping = &next_mapping->next; - next_mapping = next_mapping->next; - } - - /* check insertion point correct */ - if (next_mapping != NULL && next_mapping->base < new_mapping->bound) { - error("memory_map_add_callback_memory() internal error - map overlap\n"); - } - - /* insert the new mapping */ - *last_mapping = new_mapping; - new_mapping->next = next_mapping; - -} - - -INLINE_MEMORY_MAP void -memory_map_add_callback_memory(memory_map *map, - device_node *device, - device_reader_callback *reader, - device_writer_callback *writer, - unsigned_word base, - unsigned size) -{ - memory_map_add_memory(map, device, reader, writer, NULL, base, size); -} - -INLINE_MEMORY_MAP void -memory_map_add_raw_memory(memory_map *map, - void *buffer, - unsigned_word base, - unsigned size) -{ - memory_map_add_memory(map, NULL, NULL, NULL, buffer, base, size); -} - - - - -STATIC_INLINE_MEMORY_MAP memory_mapping * -memory_map_find_mapping(memory_map *map, - unsigned_word addr, - unsigned nr_bytes, - int abort, - cpu *processor, - unsigned_word cia) -{ - memory_mapping *mapping = map->first; - ASSERT((addr & (nr_bytes-1)) == 0); - while (1) { - if (addr >= mapping->base - && (addr + nr_bytes) <= mapping->bound) - break; - mapping = mapping->next; - if (mapping == NULL) { - if (abort) { - switch (CURRENT_ENVIRONMENT) { - case VIRTUAL_ENVIRONMENT: - data_storage_interrupt(processor, - cia, - addr, - vea_storage_interrupt, - 0/* doesnt matter */); - break; - default: - error("memory_map_find_mapping() - %s%x%s%s%s%s%s", - "access to undefined address 0x", addr, "\n", - "this code should be passing back up the device tree an\n", - "abort event (with processor attached). Somewhere in\n", - "the device tree this would be caught and either halt,\n", - "interrupt, or reset the processor\n"); - } - return NULL; - } - else - return NULL; - } - } - return mapping; -} - - -STATIC_INLINE_MEMORY_MAP void * -memory_map_translate(memory_mapping *mapping, - unsigned_word addr) -{ - return mapping->buffer + addr - mapping->base; -} - - -INLINE_MEMORY_MAP unsigned -memory_map_read_buffer(memory_map *map, - void *buffer, - unsigned_word addr, - unsigned len, - transfer_mode mode) -{ - unsigned count; - unsigned_1 byte; - for (count = 0; count < len; count++) { - unsigned pos = 0; - unsigned_word raddr = addr + count; - memory_mapping *mapping = - memory_map_find_mapping(map, raddr, 1, - 0/*abort*/, - 0, 0/*processor, cia*/); - if (mapping == NULL) - break; - if (mode == raw_transfer || - CURRENT_TARGET_BYTE_ORDER == CURRENT_HOST_BYTE_ORDER) - pos = count; - else if (mode == cooked_transfer) - pos = len-count-1; - else - error("memory_map_read_buffer() - transfer mode unknown\n"); - if (mapping->reader != NULL) - /* hope it doesn't barf */ - byte = mapping->reader(mapping->device, - raddr - mapping->base, - 1, - 0, 0/*processor, cia*/); - else - byte = *(unsigned_1*)memory_map_translate(mapping, - raddr); - ((unsigned_1*)buffer)[pos] = T2H_1(byte); - } - return count; -} - - -INLINE_MEMORY_MAP unsigned -memory_map_write_buffer(memory_map *map, - const void *buffer, - unsigned_word addr, - unsigned len, - transfer_mode mode) -{ - unsigned count; - unsigned_1 byte; - for (count = 0; count < len; count++) { - unsigned pos = 0; - unsigned_word raddr = addr + count; - memory_mapping *mapping = - memory_map_find_mapping(map, raddr, 1, - 0/*abort*/, - 0, 0/*processor, cia*/); - if (mapping == NULL) - break; - if (mode == raw_transfer || - CURRENT_TARGET_BYTE_ORDER == CURRENT_HOST_BYTE_ORDER) - pos = count; - else if (mode == cooked_transfer) - pos = len-count-1; - else - error("memory_map_write_buffer() - transfer mode unknown\n"); - byte = H2T_1(((unsigned_1*)buffer)[pos]); - if (mapping->writer != NULL) - /* hope it doesn't barf */ - mapping->writer(mapping->device, - raddr - mapping->base, - 1, - byte, - 0, 0/*processor, cia*/); - else - *(unsigned_1*)memory_map_translate(mapping, raddr) = byte; - } - return count; -} - - -INLINE_MEMORY_MAP unsigned -memory_map_zero(memory_map *map, - unsigned_word addr, - unsigned len) -{ - unsigned pos; - for (pos = 0; pos < len; pos++) { - unsigned_word raddr = addr + pos; - memory_mapping *mapping = - memory_map_find_mapping(map, raddr, 1, - 0/*abort*/, - 0, 0/*processor, cia*/); - if (mapping == NULL) - break; - if (mapping->writer != NULL) - mapping->writer(mapping->device, - raddr - mapping->base, - 1, - 0, - 0, 0/*processor, cia*/); - else - *(unsigned_1*)memory_map_translate(mapping, raddr) = 0; - } - return pos; -} - - -#define DEFINE_MEMORY_MAP_READ_N(N) \ -INLINE_MEMORY_MAP unsigned_##N \ -memory_map_read_##N(memory_map *map, \ - unsigned_word addr, \ - cpu *processor, \ - unsigned_word cia) \ -{ \ - memory_mapping *mapping = memory_map_find_mapping(map, addr, \ - sizeof(unsigned_##N), \ - 1, \ - processor, \ - cia); \ - if (WITH_CALLBACK_MEMORY && mapping->reader != NULL) \ - return ((unsigned_##N) \ - mapping->reader(mapping->device, \ - addr - mapping->base, \ - sizeof(unsigned_##N), \ - processor, \ - cia)); \ - else \ - return T2H_##N(*(unsigned_##N*)memory_map_translate(mapping, addr)); \ -} - -DEFINE_MEMORY_MAP_READ_N(1) -DEFINE_MEMORY_MAP_READ_N(2) -DEFINE_MEMORY_MAP_READ_N(4) -DEFINE_MEMORY_MAP_READ_N(8) -DEFINE_MEMORY_MAP_READ_N(word) - -#define DEFINE_MEMORY_MAP_WRITE_N(N) \ -INLINE_MEMORY_MAP void \ -memory_map_write_##N(memory_map *map, \ - unsigned_word addr, \ - unsigned_##N val, \ - cpu *processor, \ - unsigned_word cia) \ -{ \ - memory_mapping *mapping = memory_map_find_mapping(map, addr, \ - sizeof(unsigned_##N), \ - 1, \ - processor, \ - cia); \ - if (WITH_CALLBACK_MEMORY && mapping->writer != NULL) \ - mapping->writer(mapping->device, \ - addr - mapping->base, \ - sizeof(unsigned_##N), \ - val, \ - processor, \ - cia); \ - else \ - *(unsigned_##N*)memory_map_translate(mapping, addr) = H2T_##N(val); \ -} - -DEFINE_MEMORY_MAP_WRITE_N(1) -DEFINE_MEMORY_MAP_WRITE_N(2) -DEFINE_MEMORY_MAP_WRITE_N(4) -DEFINE_MEMORY_MAP_WRITE_N(8) -DEFINE_MEMORY_MAP_WRITE_N(word) - -#endif /* _MEMORY_MAP_C_ */ diff --git a/sim/ppc/memory_map.h b/sim/ppc/memory_map.h deleted file mode 100644 index c197f43..0000000 --- a/sim/ppc/memory_map.h +++ /dev/null @@ -1,126 +0,0 @@ -/* This file is part of the program psim. - - Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au> - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - - */ - - -#ifndef _MEMORY_MAP_H_ -#define _MEMORY_MAP_H_ - -#ifndef INLINE_MEMORY_MAP -#define INLINE_MEMORY_MAP -#endif - -/* basic types */ - -typedef struct _memory_map memory_map; - - -/* constructor */ - -INLINE_MEMORY_MAP memory_map *new_memory_map -(void); - - -/* operators to add memory to a memory map - - callback-memory: - - includes a callback routine that is called upon for the data. - Useful when modeling memory mapped devices. - - raw-memory: - - normal base and bound memory map used to model ram or mapped memory - pages */ - -INLINE_MEMORY_MAP void memory_map_add_callback_memory -(memory_map *map, - device_node *device, - device_reader_callback *reader, - device_writer_callback *writer, - unsigned_word base, - unsigned size); /* host limited */ - -INLINE_MEMORY_MAP void memory_map_add_raw_memory -(memory_map *map, - void *buffer, - unsigned_word base, - unsigned size/*host limited*/); - - -/* Variable sized read/write/zero: - - Transfer (zero) a variable size block of data between the host and - target (possibly byte swapping it). Should any problems occure, - the number of bytes actually transfered is returned. */ - -INLINE_MEMORY_MAP unsigned memory_map_read_buffer -(memory_map *map, - void *buffer, - unsigned_word addr, - unsigned len, - transfer_mode mode); - -INLINE_MEMORY_MAP unsigned memory_map_write_buffer -(memory_map *map, - const void *buffer, - unsigned_word addr, - unsigned len, - transfer_mode mode); - -INLINE_MEMORY_MAP unsigned memory_map_zero -(memory_map *map, - unsigned_word addr, - unsigned len); - - -/* Fixed sized read/write: - - Transfer a fixed amout of memory between the host and target. The - memory always being translated and the operation always aborting - should a problem occure */ - -#define DECLARE_MEMORY_MAP_WRITE_N(N) \ -INLINE_MEMORY_MAP void memory_map_write_##N \ -(memory_map *map, \ - unsigned_word addr, \ - unsigned_##N val, \ - cpu *processor, \ - unsigned_word cia); - -DECLARE_MEMORY_MAP_WRITE_N(1) -DECLARE_MEMORY_MAP_WRITE_N(2) -DECLARE_MEMORY_MAP_WRITE_N(4) -DECLARE_MEMORY_MAP_WRITE_N(8) -DECLARE_MEMORY_MAP_WRITE_N(word) - -#define DECLARE_MEMORY_MAP_READ_N(N) \ -INLINE_MEMORY_MAP unsigned_##N memory_map_read_##N \ -(memory_map *map, \ - unsigned_word addr, \ - cpu *processor, \ - unsigned_word cia); - -DECLARE_MEMORY_MAP_READ_N(1) -DECLARE_MEMORY_MAP_READ_N(2) -DECLARE_MEMORY_MAP_READ_N(4) -DECLARE_MEMORY_MAP_READ_N(8) -DECLARE_MEMORY_MAP_READ_N(word) - -#endif diff --git a/sim/ppc/ppc-endian.h b/sim/ppc/ppc-endian.h index 6ac0601..496d36a 100644 --- a/sim/ppc/ppc-endian.h +++ b/sim/ppc/ppc-endian.h @@ -184,10 +184,11 @@ do { \ Byte swap a quantity the size of the targets word */ -#if WITH_64BIT_TARGET +#if (WITH_TARGET_WORD_BITSIZE == 64) #define H2T_word(X) H2T_8(X) #define T2H_word(X) T2H_8(X) -#else +#endif +#if (WITH_TARGET_WORD_BITSIZE == 32) #define H2T_word(X) H2T_4(X) #define T2H_word(X) T2H_4(X) #endif diff --git a/sim/ppc/system.c b/sim/ppc/system.c index c032688..25ea8eb 100644 --- a/sim/ppc/system.c +++ b/sim/ppc/system.c @@ -30,6 +30,7 @@ #include <signal.h> #include <sys/errno.h> #include <sys/param.h> +#include <fcntl.h> #if (NetBSD >= 199306) /* here NetBSD as that is what we're emulating */ #include <sys/syscall.h> /* FIXME - should not be including this one */ @@ -45,347 +46,675 @@ extern int errno; #include "system.h" -void -system_call(cpu *processor, - unsigned_word cia) -{ - switch (cpu_registers(processor)->gpr[0]) { - - - case 1/*SYS_exit*/: -#if (NetBSD >= 199306) && (SYS_exit != 1) -# error "SYS_exit" +#ifndef STATIC_INLINE_SYSTEM +#define STATIC_INLINE_SYSTEM STATIC_INLINE #endif - { - int status = (int)cpu_registers(processor)->gpr[3]; - cpu_halt(processor, cia, was_exited, status); - break; - } - - case 3/*SYS_read*/: -#if (NetBSD >= 199306) && (SYS_read != 3) -# error "SYS_read" -#endif - { - void *scratch_buffer; - int d = (int)cpu_registers(processor)->gpr[3]; - unsigned_word buf = cpu_registers(processor)->gpr[4]; - int nbytes = cpu_registers(processor)->gpr[5]; - int status; - int nr_moved; - - /* get a tempoary bufer */ - scratch_buffer = zalloc(cpu_registers(processor)->gpr[5]); - - /* check if buffer exists by reading it */ - nr_moved = vm_data_map_read_buffer(cpu_data_map(processor), - scratch_buffer, - buf, - nbytes, - raw_transfer); - if (nr_moved != nbytes) - error("system_call()read - check on buffer failed\n"); - - /* read */ - if (d == 0) { - status = fread (scratch_buffer, 1, nbytes, stdin); - if (status == 0 && ferror (stdin)) - status = -1; - } else { - status = read (d, scratch_buffer, nbytes); - } - - if (status == -1) { - cpu_registers(processor)->gpr[0] = errno; - break; - } else { - cpu_registers(processor)->gpr[0] = 0; - cpu_registers(processor)->gpr[3] = status; - - if (status > 0) { - nr_moved = vm_data_map_write_buffer(cpu_data_map(processor), - scratch_buffer, - buf, - status, - raw_transfer, - 0/*violate_ro*/); - - if (nr_moved != nbytes) - error("system_call()read - write to buffer failed\n"); - } - } - - zfree(scratch_buffer); - - break; - } - - case 4/*SYS_write*/: -#if (NetBSD >= 199306) && (SYS_write != 4) -# error "SYS_write" +#if (NetBSD >= 199306) +#define SYS(X) ASSERT(call == (SYS_##X)) +#else +#define SYS(X) #endif - { - void *scratch_buffer; - int nr_moved; - int d = (int)cpu_registers(processor)->gpr[3]; - unsigned_word buf = cpu_registers(processor)->gpr[4]; - int nbytes = cpu_registers(processor)->gpr[5]; - int status; - - /* get a tempoary bufer */ - scratch_buffer = zalloc(cpu_registers(processor)->gpr[5]); - - /* copy in */ - nr_moved = vm_data_map_read_buffer(cpu_data_map(processor), - scratch_buffer, - buf, - nbytes, - raw_transfer); - if (nr_moved != nbytes) { - /* FIXME - should handle better */ - error("system_call()write copy failed (nr_moved=%d != nbytes=%d)\n", - nr_moved, nbytes); - } - - /* write */ - status = write(d, scratch_buffer, nbytes); - if (status == -1) { - cpu_registers(processor)->gpr[0] = errno; - break; - } - cpu_registers(processor)->gpr[0] = 0; - cpu_registers(processor)->gpr[3] = status; - - zfree(scratch_buffer); - - break; - } - - case 17/*SYS_break*/: -#if (NetBSD >= 199306) && (SYS_break != 17) -# error "SYS_break" +#if (NetBSD >= 199306 && PATH_MAX != 1024) +#error "PATH_MAX not 1024" +#elif !defined(PATH_MAX) +#define PATH_MAX 1024 #endif - { - /* pretend to extend the heap so that it reaches addresss - new_break while in truth, if growth is needed grow it by a - page aligned amount */ - unsigned_word new_break = ALIGN_8(cpu_registers(processor)->gpr[3]); - unsigned_word old_break = core_data_upper_bound(cpu_core(processor)); - signed_word delta = new_break - old_break; - if (delta > 0) - core_add_data(cpu_core(processor), - ALIGN_PAGE(new_break) - old_break); - cpu_registers(processor)->gpr[0] = 0; - cpu_registers(processor)->gpr[3] = new_break; - break; - } - case 20/*SYS_getpid*/: -#if (NetBSD >= 199306) && (SYS_getpid != 20) -# error "SYS_getpid" -#endif - { - cpu_registers(processor)->gpr[3] = (int)getpid(); +STATIC_INLINE_SYSTEM char * +read_string(cpu *processor, + char *dest, + unsigned_word addr, + unsigned nr_bytes) +{ + unsigned nr_moved = 0; + if (addr == 0) + return NULL; + while (1) { + if (vm_data_map_read_buffer(cpu_data_map(processor), + &dest[nr_moved], + addr + nr_moved, + sizeof(dest[nr_moved])) + != sizeof(dest[nr_moved])) + return NULL; + if (dest[nr_moved] == '\0' || nr_moved >= nr_bytes) break; - } - + nr_moved++; + } + dest[nr_moved] = '\0'; + return dest; +} - case 37/*SYS_kill*/: -#if (NetBSD >= 199306) && (SYS_kill != 37) -# error "SYS_kill" -#endif - { - pid_t pid = cpu_registers(processor)->gpr[3]; - int sig = cpu_registers(processor)->gpr[4]; - TRACE(trace_tbd, ("SYS_kill - more to this than just a kill\n")); - cpu_halt(processor, cia, was_signalled, sig); - break; - } - - case 48/*SYS_sigprocmask*/: -#if (NetBSD >= 199306) && (SYS_sigprocmask != 48) -# error "SYS_sigprocmask" -#endif - { - natural_word how = cpu_registers(processor)->gpr[3]; - unsigned_word set = cpu_registers(processor)->gpr[4]; - unsigned_word oset = cpu_registers(processor)->gpr[5]; - TRACE(trace_system, ("SYS_sigprocmask: how=%d, set=0x%x, oset=0x%x\n", - how, set, oset)); - cpu_registers(processor)->gpr[0] = 0; - cpu_registers(processor)->gpr[3] = 0; - cpu_registers(processor)->gpr[4] = set; - break; - } +STATIC_INLINE_SYSTEM void +write_status(cpu *processor, + int status) +{ + cpu_registers(processor)->gpr[3] = status; + if (status < 0) + cpu_registers(processor)->gpr[0] = errno; + else + cpu_registers(processor)->gpr[0] = 0; +} - case 54/*SYS_ioctl*/: -#if (NetBSD >= 199306) && (SYS_ioctl != 54) -# error "SYS_ioctl" +STATIC_INLINE_SYSTEM void +write_stat(cpu *processor, + unsigned_word addr, + struct stat buf) +{ + int nr_moved; + H2T(buf.st_dev); + H2T(buf.st_ino); + H2T(buf.st_mode); + H2T(buf.st_nlink); + H2T(buf.st_uid); + H2T(buf.st_gid); + H2T(buf.st_rdev); + H2T(buf.st_size); + H2T(buf.st_atime); + /* H2T(buf.st_spare1); */ + H2T(buf.st_mtime); + /* H2T(buf.st_spare2); */ + H2T(buf.st_ctime); + /* H2T(buf.st_spare3); */ + H2T(buf.st_blksize); + H2T(buf.st_blocks); +#if (NetBSD >= 199306) + H2T(buf.st_flags); + H2T(buf.st_gen); #endif - { - TRACE(trace_system, ("SYS_ioctl: d=%d, request=0x%x, argp=0x%x\n", - cpu_registers(processor)->gpr[3], cpu_registers(processor)->gpr[4], cpu_registers(processor)->gpr[5])); - cpu_registers(processor)->gpr[0] = 0; - cpu_registers(processor)->gpr[3] = 0; - break; - } + nr_moved = vm_data_map_write_buffer(cpu_data_map(processor), + &buf, + addr, + sizeof(buf), + 0/*violate_ro*/); + if (nr_moved != sizeof(buf)) + error("write_stat() write failed\n"); +} + + +STATIC_INLINE_SYSTEM void +do_exit(unsigned call, + cpu *processor, + unsigned_word cia) +{ + int status = (int)cpu_registers(processor)->gpr[3]; + SYS(exit); + cpu_halt(processor, cia, was_exited, status); +} - case 189/*SYS_fstat*/: -#if (NetBSD >= 199306) && (SYS_fstat != 189) -# error "SYS_fstat" -#endif - { - int fd = cpu_registers(processor)->gpr[3]; - unsigned_word stat_buf_addr = cpu_registers(processor)->gpr[4]; - struct stat buf; - int nr_moved; - int status; - - /* check buffer all there, by reading it */ - nr_moved = vm_data_map_read_buffer(cpu_data_map(processor), - &buf, - stat_buf_addr, - sizeof(buf), - raw_transfer); - if (nr_moved != sizeof(buf)) - error("system_call()fstat - check on buffer failed\n"); - - /* do the fstat call */ - status = fstat(fd, &buf); - if (status == -1) { - cpu_registers(processor)->gpr[0] = errno; - break; - } - cpu_registers(processor)->gpr[0] = 0; - cpu_registers(processor)->gpr[3] = 0; - - H2T(buf.st_dev); - H2T(buf.st_ino); - H2T(buf.st_mode); - H2T(buf.st_nlink); - H2T(buf.st_uid); - H2T(buf.st_gid); - H2T(buf.st_rdev); - H2T(buf.st_size); - H2T(buf.st_atime); - /* H2T(buf.st_spare1); */ - H2T(buf.st_mtime); - /* H2T(buf.st_spare2); */ - H2T(buf.st_ctime); - /* H2T(buf.st_spare3); */ - H2T(buf.st_blksize); - H2T(buf.st_blocks); -#if (NetBSD >= 199306) - H2T(buf.st_flags); - H2T(buf.st_gen); +STATIC_INLINE_SYSTEM void +do_read(unsigned call, + cpu *processor, + unsigned_word cia) +{ + void *scratch_buffer; + int d = (int)cpu_registers(processor)->gpr[3]; + unsigned_word buf = cpu_registers(processor)->gpr[4]; + int nbytes = cpu_registers(processor)->gpr[5]; + int status; + int nr_moved; + SYS(read); + + /* get a tempoary bufer */ + scratch_buffer = zalloc(nbytes); + + /* check if buffer exists by reading it */ + nr_moved = vm_data_map_read_buffer(cpu_data_map(processor), + scratch_buffer, + buf, + nbytes); + if (nr_moved != nbytes) + error("system_call()read - check on buffer failed\n"); + + /* read */ +#if 0 + if (d == 0) { + status = fread (scratch_buffer, 1, nbytes, stdin); + if (status == 0 && ferror (stdin)) + status = -1; + } #endif - + status = read (d, scratch_buffer, nbytes); + + if (status == -1) { + cpu_registers(processor)->gpr[0] = errno; + } else { + cpu_registers(processor)->gpr[3] = status; + + if (status > 0) { nr_moved = vm_data_map_write_buffer(cpu_data_map(processor), - &buf, - stat_buf_addr, - sizeof(buf), - raw_transfer, + scratch_buffer, + buf, + status, 0/*violate_ro*/); - break; + if (nr_moved != status) + error("system_call()read - write to buffer failed\n"); } + } + + zfree(scratch_buffer); +} - case 202/*SYS___sysctl*/: -#if (NetBSD >= 199306) && (SYS___sysctl != 202) -# error "SYS__sysctl" -#endif - { - /* call the arguments by their real name */ - unsigned_word name = cpu_registers(processor)->gpr[3]; - natural_word namelen = cpu_registers(processor)->gpr[4]; - unsigned_word oldp = cpu_registers(processor)->gpr[5]; - unsigned_word oldlenp = cpu_registers(processor)->gpr[6]; - natural_word oldlen; - natural_word mib; - natural_word int_val; - - /* pluck out the management information base id */ - if (namelen < 1 - || sizeof(mib) != vm_data_map_read_buffer(cpu_data_map(processor), - &mib, - name, - sizeof(mib), - cooked_transfer)) - error("system_call()SYS___sysctl bad name[0]\n"); - name += sizeof(mib); - - /* see what to do with it ... */ - switch (mib) { - case 6/*CTL_HW*/: +STATIC_INLINE_SYSTEM void +do_write(unsigned call, + cpu *processor, + unsigned_word cia) +{ + void *scratch_buffer = NULL; + int nr_moved; + int d = (int)cpu_registers(processor)->gpr[3]; + unsigned_word buf = cpu_registers(processor)->gpr[4]; + int nbytes = cpu_registers(processor)->gpr[5]; + int status; + SYS(write); + + /* get a tempoary bufer */ + scratch_buffer = zalloc(nbytes); /* FIXME - nbytes == 0 */ + + /* copy in */ + nr_moved = vm_data_map_read_buffer(cpu_data_map(processor), + scratch_buffer, + buf, + nbytes); + if (nr_moved != nbytes) { + /* FIXME - should handle better */ + error("system_call()write copy failed (nr_moved=%d != nbytes=%d)\n", + nr_moved, nbytes); + } + + /* write */ + status = write(d, scratch_buffer, nbytes); + if (status == -1) { + cpu_registers(processor)->gpr[0] = errno; + } + cpu_registers(processor)->gpr[3] = status; + + zfree(scratch_buffer); +} + + +STATIC_INLINE_SYSTEM void +do_open(unsigned call, + cpu *processor, + unsigned_word cia) +{ + unsigned_word path_addr = cpu_registers(processor)->gpr[3]; + char path_buf[PATH_MAX]; + char *path = read_string(processor, path_buf, path_addr, PATH_MAX); + int flags = (int)cpu_registers(processor)->gpr[4]; + int mode = (int)cpu_registers(processor)->gpr[4]; + SYS(open); + write_status(processor, open(path, flags, mode)); +} + + +STATIC_INLINE_SYSTEM void +do_close(unsigned call, + cpu *processor, + unsigned_word cia) +{ + int d = (int)cpu_registers(processor)->gpr[3]; + SYS(close); + write_status(processor, close(d)); +} + + +STATIC_INLINE_SYSTEM void +do_break(unsigned call, + cpu *processor, + unsigned_word cia) + /* just pass this onto the `vm' device */ +{ + psim *system = cpu_system(processor); + const device *vm = psim_device(system, "/vm"); + SYS(break); + vm->callback->ioctl(vm, + system, + processor, + cia, + 0, /*ioctl*/ + NULL); /*ioctl-data*/ +} + + +STATIC_INLINE_SYSTEM void +do_getpid(unsigned call, + cpu *processor, + unsigned_word cia) +{ + SYS(getpid); + cpu_registers(processor)->gpr[3] = (int)getpid(); +} + + +STATIC_INLINE_SYSTEM void +do_getuid(unsigned call, + cpu *processor, + unsigned_word cia) +{ + SYS(getuid); + cpu_registers(processor)->gpr[3] = (int)getuid(); +} + + +STATIC_INLINE_SYSTEM void +do_geteuid(unsigned call, + cpu *processor, + unsigned_word cia) +{ + SYS(geteuid); + cpu_registers(processor)->gpr[3] = (int)geteuid(); +} + + +STATIC_INLINE_SYSTEM void +do_kill(unsigned call, + cpu *processor, + unsigned_word cia) +{ + pid_t pid = cpu_registers(processor)->gpr[3]; + int sig = cpu_registers(processor)->gpr[4]; + SYS(kill); + error("SYS_kill - more to this than just a kill\n"); + cpu_halt(processor, cia, was_signalled, sig); +} + + +STATIC_INLINE_SYSTEM void +do_sigprocmask(unsigned call, + cpu *processor, + unsigned_word cia) +{ + natural_word how = cpu_registers(processor)->gpr[3]; + unsigned_word set = cpu_registers(processor)->gpr[4]; + unsigned_word oset = cpu_registers(processor)->gpr[5]; + SYS(sigprocmask); + TRACE(trace_system, ("SYS_sigprocmask: how=%d, set=0x%x, oset=0x%x\n", + how, set, oset)); + cpu_registers(processor)->gpr[3] = 0; + cpu_registers(processor)->gpr[4] = set; +} + + +STATIC_INLINE_SYSTEM void +do_ioctl(unsigned call, + cpu *processor, + unsigned_word cia) +{ + SYS(ioctl); + TRACE(trace_system, ("SYS_ioctl: d=%d, request=0x%x, argp=0x%x\n", + cpu_registers(processor)->gpr[3], cpu_registers(processor)->gpr[4], cpu_registers(processor)->gpr[5])); + cpu_registers(processor)->gpr[3] = 0; +} + + +STATIC_INLINE_SYSTEM void +do_umask(unsigned call, + cpu *processor, + unsigned_word cia) +{ + SYS(umask); + cpu_registers(processor)->gpr[3] = umask(cpu_registers(processor)->gpr[3]); +} + + +STATIC_INLINE_SYSTEM void +do_stat(unsigned call, + cpu *processor, + unsigned_word cia) +{ + char path_buf[PATH_MAX]; + unsigned_word path_addr = cpu_registers(processor)->gpr[3]; + unsigned_word stat_buf_addr = cpu_registers(processor)->gpr[4]; + char *path = read_string(processor, path_buf, path_addr, PATH_MAX); + struct stat buf; + SYS(stat); + write_status(processor, stat(path, &buf)); + write_stat(processor, stat_buf_addr, buf); +} + + +STATIC_INLINE_SYSTEM void +do_fstat(unsigned call, + cpu *processor, + unsigned_word cia) +{ + int fd = cpu_registers(processor)->gpr[3]; + unsigned_word stat_buf_addr = cpu_registers(processor)->gpr[4]; + struct stat buf; + SYS(fstat); + write_status(processor, fstat(fd, &buf)); + write_stat(processor, stat_buf_addr, buf); +} + + +STATIC_INLINE_SYSTEM void +do_lstat(unsigned call, + cpu *processor, + unsigned_word cia) +{ + char path_buf[PATH_MAX]; + unsigned_word path_addr = cpu_registers(processor)->gpr[3]; + char *path = read_string(processor, path_buf, path_addr, PATH_MAX); + unsigned_word stat_buf_addr = cpu_registers(processor)->gpr[4]; + struct stat buf; + SYS(lstat); + write_status(processor, stat(path, &buf)); + write_stat(processor, stat_buf_addr, buf); +} + + +STATIC_INLINE_SYSTEM void +do___sysctl(unsigned call, + cpu *processor, + unsigned_word cia) +{ + /* call the arguments by their real name */ + unsigned_word name = cpu_registers(processor)->gpr[3]; + natural_word namelen = cpu_registers(processor)->gpr[4]; + unsigned_word oldp = cpu_registers(processor)->gpr[5]; + unsigned_word oldlenp = cpu_registers(processor)->gpr[6]; + natural_word oldlen; + natural_word mib; + natural_word int_val; + SYS(__sysctl); + + /* pluck out the management information base id */ + if (namelen < 1) + error("system_call()SYS___sysctl bad name[0]\n"); + mib = vm_data_map_read_word(cpu_data_map(processor), + name, + processor, + cia); + name += sizeof(mib); + + /* see what to do with it ... */ + switch (mib) { + case 6/*CTL_HW*/: #if (NetBSD >= 199306) && (CTL_HW != 6) # error "CTL_HW" #endif - if (namelen < 2 - || sizeof(mib) != vm_data_map_read_buffer(cpu_data_map(processor), - &mib, - name, - sizeof(mib), - cooked_transfer)) - error("system_call()SYS___sysctl - CTL_HW - bad name[1]\n"); - name += sizeof(mib); - switch (mib) { - case 7/*HW_PAGESIZE*/: + if (namelen < 2) + error("system_call()SYS___sysctl - CTL_HW - bad name[1]\n"); + mib = vm_data_map_read_word(cpu_data_map(processor), + name, + processor, + cia); + name += sizeof(mib); + switch (mib) { + case 7/*HW_PAGESIZE*/: #if (NetBSD >= 199306) && (HW_PAGESIZE != 7) # error "HW_PAGESIZE" #endif - if (sizeof(oldlen) != vm_data_map_read_buffer(cpu_data_map(processor), - &oldlen, - oldlenp, - sizeof(oldlen), - cooked_transfer)) - error("system_call()sysctl - CTL_HW.HW_PAGESIZE - oldlen read\n"); - if (sizeof(natural_word) > oldlen) - error("system_call()sysctl - CTL_HW.HW_PAGESIZE - to small\n"); - int_val = 8192; - oldlen = sizeof(int_val); - if (sizeof(int_val) != vm_data_map_write_buffer(cpu_data_map(processor), - &int_val, - oldp, - sizeof(int_val), - cooked_transfer, - 0/*violate_ro*/)) - error("system_call()sysctl - CTL_HW.HW_PAGESIZE - int_val\n"); - if (sizeof(oldlen) != vm_data_map_write_buffer(cpu_data_map(processor), - &oldlen, - oldlenp, - sizeof(oldlen), - cooked_transfer, - 0/*violate_ro*/)) - error("system_call()sysctl - CTL_HW.HW_PAGESIZE - oldlen write\n"); - break; - default: - error("sysctl() CTL_HW.%d unknown\n", mib); - break; - } - break; - default: - error("sysctl() name[0]=%s unknown\n", (int)mib); - break; - } - cpu_registers(processor)->gpr[0] = 0; - cpu_registers(processor)->gpr[3] = 0; + oldlen = vm_data_map_read_word(cpu_data_map(processor), + oldlenp, + processor, + cia); + if (sizeof(natural_word) > oldlen) + error("system_call()sysctl - CTL_HW.HW_PAGESIZE - to small\n"); + int_val = 8192; + oldlen = sizeof(int_val); + vm_data_map_write_word(cpu_data_map(processor), + oldp, + int_val, + processor, + cia); + vm_data_map_write_word(cpu_data_map(processor), + oldlenp, + oldlen, + processor, + cia); + break; + default: + error("sysctl() CTL_HW.%d unknown\n", mib); break; } - - + break; default: - error("system_call() unimplemented system call %d, cia=0x%x, arg[0]=0x%x, lr=0x%x\n", - cpu_registers(processor)->gpr[0], cia, cpu_registers(processor)->gpr[3], LR); + error("sysctl() name[0]=%s unknown\n", (int)mib); break; - } + cpu_registers(processor)->gpr[3] = 0; +} + +STATIC_INLINE_SYSTEM void +unimp(unsigned call, + cpu *processor, + unsigned_word cia) +{ + error("unimplemented system call %d, cia=0x%x\n", call, cia); +} + + +typedef void (sys_handler) + (unsigned call, + cpu *processor, + unsigned_word cia); + +static sys_handler *(handlers[]) = { + unimp, /* SYS_syscall 0 */ + do_exit, /* 1*/ + unimp, /* SYS_fork 2 */ + do_read, /* 3 */ + do_write, /* 4 */ + do_open, /* 5 */ + do_close, /* 6 */ + unimp, /* SYS_wait4 7 */ + unimp, /* 8 is old creat */ + unimp, /* SYS_link 9 */ + unimp, /* SYS_unlink 10 */ + unimp, /* 11 is obsolete execv */ + unimp, /* SYS_chdir 12 */ + unimp, /* SYS_fchdir 13 */ + unimp, /* SYS_mknod 14 */ + unimp, /* SYS_chmod 15 */ + unimp, /* SYS_chown 16 */ + do_break, /* 17 */ + unimp, /* SYS_getfsstat 18 */ + unimp, /* 19 is old lseek */ + do_getpid, /* 20 */ + unimp, /* SYS_mount 21 */ + unimp, /* SYS_unmount 22 */ + unimp, /* SYS_setuid 23 */ + do_getuid, /* 24 */ + do_geteuid, /* 25 */ + unimp, /* SYS_ptrace 26 */ + unimp, /* SYS_recvmsg 27 */ + unimp, /* SYS_sendmsg 28 */ + unimp, /* SYS_recvfrom 29 */ + unimp, /* SYS_accept 30 */ + unimp, /* SYS_getpeername 31 */ + unimp, /* SYS_getsockname 32 */ + unimp, /* SYS_access 33 */ + unimp, /* SYS_chflags 34 */ + unimp, /* SYS_fchflags 35 */ + unimp, /* SYS_sync 36 */ + do_kill, /* 37 */ + unimp, /* 38 is old stat */ + unimp, /* SYS_getppid 39 */ + unimp, /* 40 is old lstat */ + unimp, /* SYS_dup 41 */ + unimp, /* SYS_pipe 42 */ + unimp, /* SYS_getegid 43 */ + unimp, /* SYS_profil 44 */ + unimp, /* SYS_ktrace 45 */ + unimp, /* SYS_sigaction 46 */ + unimp, /* SYS_getgid 47 */ + do_sigprocmask, /* 48 */ + unimp, /* SYS_getlogin 49 */ + unimp, /* SYS_setlogin 50 */ + unimp, /* SYS_acct 51 */ + unimp, /* SYS_sigpending 52 */ + unimp, /* SYS_sigaltstack 53 */ + do_ioctl, /* 54 */ + unimp, /* SYS_reboot 55 */ + unimp, /* SYS_revoke 56 */ + unimp, /* SYS_symlink 57 */ + unimp, /* SYS_readlink 58 */ + unimp, /* SYS_execve 59 */ + do_umask, /* 60 */ + unimp, /* SYS_chroot 61 */ + unimp, /* 62 is old fstat */ + unimp, /* 63 is old getkerninfo */ + unimp, /* 64 is old getpagesize */ + unimp, /* SYS_msync 65 */ + unimp, /* SYS_vfork 66 */ + unimp, /* 67 is obsolete vread */ + unimp, /* 68 is obsolete vwrite */ + unimp, /* SYS_sbrk 69 */ + unimp, /* SYS_sstk 70 */ + unimp, /* 71 is old mmap */ + unimp, /* SYS_vadvise 72 */ + unimp, /* SYS_munmap 73 */ + unimp, /* SYS_mprotect 74 */ + unimp, /* SYS_madvise 75 */ + unimp, /* 76 is obsolete vhangup */ + unimp, /* 77 is obsolete vlimit */ + unimp, /* SYS_mincore 78 */ + unimp, /* SYS_getgroups 79 */ + unimp, /* SYS_setgroups 80 */ + unimp, /* SYS_getpgrp 81 */ + unimp, /* SYS_setpgid 82 */ + unimp, /* SYS_setitimer 83 */ + unimp, /* 84 is old wait */ + unimp, /* SYS_swapon 85 */ + unimp, /* SYS_getitimer 86 */ + unimp, /* 87 is old gethostname */ + unimp, /* 88 is old sethostname */ + unimp, /* 89 is old getdtablesize */ + unimp, /* SYS_dup2 90 */ + unimp, /* 91 */ + unimp, /* SYS_fcntl 92 */ + unimp, /* SYS_select 93 */ + unimp, /* 94 */ + unimp, /* SYS_fsync 95 */ + unimp, /* SYS_setpriority 96 */ + unimp, /* SYS_socket 97 */ + unimp, /* SYS_connect 98 */ + unimp, /* 99 is old accept */ + unimp, /* SYS_getpriority 100 */ + unimp, /* 101 is old send */ + unimp, /* 102 is old recv */ + unimp, /* SYS_sigreturn 103 */ + unimp, /* SYS_bind 104 */ + unimp, /* SYS_setsockopt 105 */ + unimp, /* SYS_listen 106 */ + unimp, /* 107 is obsolete vtimes */ + unimp, /* 108 is old sigvec */ + unimp, /* 109 is old sigblock */ + unimp, /* 110 is old sigsetmask */ + unimp, /* SYS_sigsuspend 111 */ + unimp, /* 112 is old sigstack */ + unimp, /* 113 is old recvmsg */ + unimp, /* 114 is old sendmsg */ + unimp, /* SYS_vtrace 115 - is obsolete vtrace */ + unimp, /* SYS_gettimeofday 116 */ + unimp, /* SYS_getrusage 117 */ + unimp, /* SYS_getsockopt 118 */ + unimp, /* SYS_resuba 119 */ + unimp, /* SYS_readv 120 */ + unimp, /* SYS_writev 121 */ + unimp, /* SYS_settimeofday 122 */ + unimp, /* SYS_fchown 123 */ + unimp, /* SYS_fchmod 124 */ + unimp, /* 125 is old recvfrom */ + unimp, /* 126 is old setreuid */ + unimp, /* 127 is old setregid */ + unimp, /* SYS_rename 128 */ + unimp, /* 129 is old truncate */ + unimp, /* 130 is old ftruncate */ + unimp, /* SYS_flock 131 */ + unimp, /* SYS_mkfifo 132 */ + unimp, /* SYS_sendto 133 */ + unimp, /* SYS_shutdown 134 */ + unimp, /* SYS_socketpair 135 */ + unimp, /* SYS_mkdir 136 */ + unimp, /* SYS_rmdir 137 */ + unimp, /* SYS_utimes 138 */ + unimp, /* 139 is obsolete 4.2 sigreturn */ + unimp, /* SYS_adjtime 140 */ + unimp, /* 141 is old getpeername */ + unimp, /* 142 is old gethostid */ + unimp, /* 143 is old sethostid */ + unimp, /* 144 is old getrlimit */ + unimp, /* 145 is old setrlimit */ + unimp, /* 146 is old killpg */ + unimp, /* SYS_setsid 147 */ + unimp, /* SYS_quotactl 148 */ + unimp, /* 149 is old quota */ + unimp, /* 150 is old getsockname */ + unimp, /* 151 */ + unimp, /* 152 */ + unimp, /* 153 */ + unimp, /* 154 */ + unimp, /* SYS_nfssvc 155 */ + unimp, /* 156 is old getdirentries */ + unimp, /* SYS_statfs 157 */ + unimp, /* SYS_fstatfs 158 */ + unimp, /* 159 */ + unimp, /* 160 */ + unimp, /* SYS_getfh 161 */ + unimp, /* 162 is old getdomainname */ + unimp, /* 163 is old setdomainname */ + unimp, /* 164 is old uname */ + unimp, /* SYS_sysarch 165 */ + unimp, /* 166 */ + unimp, /* 167 */ + unimp, /* 168 */ + unimp, /* SYS_semsys 169 */ + unimp, /* SYS_msgsys 170 */ + unimp, /* SYS_shmsys 171 */ + unimp, /* 172 */ + unimp, /* 173 */ + unimp, /* 174 */ + unimp, /* 175 */ + unimp, /* 176 */ + unimp, /* 177 */ + unimp, /* 178 */ + unimp, /* 179 */ + unimp, /* 180 */ + unimp, /* SYS_setgid 181 */ + unimp, /* SYS_setegid 182 */ + unimp, /* SYS_seteuid 183 */ + unimp, /* SYS_lfs_bmapv 184 */ + unimp, /* SYS_lfs_markv 185 */ + unimp, /* SYS_lfs_segclean 186 */ + unimp, /* SYS_lfs_segwait 187 */ + do_stat, /* 188 */ + do_fstat, /* 189 */ + do_lstat, /* 190 */ + unimp, /* SYS_pathconf 191 */ + unimp, /* SYS_fpathconf 192 */ + unimp, /* 193 */ + unimp, /* SYS_getrlimit 194 */ + unimp, /* SYS_setrlimit 195 */ + unimp, /* SYS_getdirentries 196 */ + unimp, /* SYS_mmap 197 */ + unimp, /* SYS___syscall 198 */ + unimp, /* SYS_lseek 199 */ + unimp, /* SYS_truncate 200 */ + unimp, /* SYS_ftruncate 201 */ + do___sysctl, /* 202 */ + unimp, /* SYS_mlock 203 */ + unimp, /* SYS_munlock 204 */ +}; + +INLINE_SYSTEM void +system_call(cpu *processor, + unsigned_word cia) +{ + unsigned call = cpu_registers(processor)->gpr[0]; + if (call >= sizeof(handlers)/sizeof(handlers[0])) + error("system call %d out-of-range\n", call); + cpu_registers(processor)->gpr[0] = 0; /* default success */ + handlers[call](call, processor, cia); } #endif /* _SYSTEM_C_ */ diff --git a/sim/ppc/system.h b/sim/ppc/system.h index 4a0df87..709d5c5 100644 --- a/sim/ppc/system.h +++ b/sim/ppc/system.h @@ -22,7 +22,11 @@ #ifndef _SYSTEM_H_ #define _SYSTEM_H_ -void system_call +#ifndef INLINE_SYSTEM +#define INLINE_SYSTEM +#endif + +INLINE_SYSTEM void system_call (cpu *processor, unsigned_word cia); |