From 5b4d72dd7362598e6f9c5483b990d0dee05fce1d Mon Sep 17 00:00:00 2001 From: Michael Meissner Date: Tue, 31 Oct 1995 18:29:37 +0000 Subject: [PATCH] New changes from Andrew --- sim/ppc/.Sanitize | 26 +- sim/ppc/ChangeLog | 218 +- sim/ppc/Makefile.in | 103 +- sim/ppc/README.psim | 329 +-- sim/ppc/bits.c | 27 + sim/ppc/build-psim | 155 ++ sim/ppc/core.c | 78 +- sim/ppc/core_n.h | 4 +- sim/ppc/device_tree.c | 195 +- sim/ppc/device_tree.h | 10 +- sim/ppc/devices.c | 233 +- sim/ppc/devices.h | 50 +- sim/ppc/{system.h => emul_netbsd.h} | 12 +- sim/ppc/gen.c | 3323 --------------------------- sim/ppc/os_emul.c | 49 + sim/ppc/os_emul.h | 41 + sim/ppc/ppc-cache-rules | 85 + sim/ppc/ppc-endian.c | 4 +- sim/ppc/ppc-opcode-complex | 95 + sim/ppc/ppc-opcode-simple | 92 + sim/ppc/spa-reporter.c | 758 ++++++ sim/ppc/spa-system-calls.c | 499 ++++ sim/ppc/spa-system-calls.h | 119 + sim/ppc/std-config.h | 534 +---- sim/ppc/system.c | 720 ------ sim/ppc/table.h | 49 + 26 files changed, 2897 insertions(+), 4911 deletions(-) create mode 100644 sim/ppc/bits.c create mode 100755 sim/ppc/build-psim rename sim/ppc/{system.h => emul_netbsd.h} (84%) delete mode 100644 sim/ppc/gen.c create mode 100644 sim/ppc/os_emul.c create mode 100644 sim/ppc/os_emul.h create mode 100644 sim/ppc/ppc-cache-rules create mode 100644 sim/ppc/ppc-opcode-complex create mode 100644 sim/ppc/ppc-opcode-simple create mode 100644 sim/ppc/spa-reporter.c create mode 100644 sim/ppc/spa-system-calls.c create mode 100644 sim/ppc/spa-system-calls.h delete mode 100644 sim/ppc/system.c create mode 100644 sim/ppc/table.h diff --git a/sim/ppc/.Sanitize b/sim/ppc/.Sanitize index c25d589d4c..efa34bda1d 100644 --- a/sim/ppc/.Sanitize +++ b/sim/ppc/.Sanitize @@ -31,6 +31,7 @@ README.psim basics.h bits.c bits.h +build-psim config.in configure configure.in @@ -45,22 +46,38 @@ device_tree.c device_tree.h devices.c devices.h +dgen.c double.c dp-bit.c +emul_generic.c +emul_generic.h +emul_netbsd.c +emul_netbsd.h events.c events.h -gen.c idecode_branch.h idecode_expression.h idecode_fields.h +igen.c inline.c inline.h interrupts.c interrupts.h +lf.c +lf.h main.c +misc.c +misc.h +mon.c +mon.h +os_emul.c +os_emul.h +ppc-cache-rules ppc-endian.c ppc-endian.h ppc-instructions +ppc-opcode-complex +ppc-opcode-simple ppc-spr-table ppc.mt psim.c @@ -69,9 +86,12 @@ registers.c registers.h sim_callbacks.h sim_calls.c +spa-reporter.c +spa-system-calls.c +spa-system-calls.h std-config.h -system.c -system.h +table.c +table.h vm.c vm.h vm_n.h diff --git a/sim/ppc/ChangeLog b/sim/ppc/ChangeLog index 538ef48e9b..14625b1f00 100644 --- a/sim/ppc/ChangeLog +++ b/sim/ppc/ChangeLog @@ -1,3 +1,197 @@ +Fri Oct 27 19:26:27 1995 Andrew Cagney + + * bits.h (ROTL32, ROTL64): Were functions, made them macros, now + make them functions again. Appears 2.6.3 is confused by just a + macro. + +Thu Oct 26 18:31:58 1995 Andrew Cagney + + * ppc-endian.c (SWAP_8): Fix 8 byte swap! + + * psim.c (psim_create): Not correctly checking that runtime + configuration of things like ENDIAN, ENVIRONMENT and ALIGNMENT + matched the compiled in ones. + + * debug.h (ITRACE), igen.c: Tidy up more tracing flags - + trace_semantics is now different to trace_idecode, the former + checks the cache. + +Tue Oct 24 21:54:13 1995 Andrew Cagney + + * ppc-instructions (mtsrin): Missing instruction + * ppc-instructions (mfsrin): Missing instruction + * ppc-instructions (eieio): Missing instruction + +Tue Oct 24 20:55:29 1995 Andrew Cagney + + * build-psim: New shell script - see internals for usage, + simplifies the process of building custom simulators. + +Mon Oct 23 23:48:59 1995 Andrew Cagney + + * std-config.h (SEMANTICS_INLINE): Tidy up notes on each of the + INLINE macros. Make SEMANTICS_INLINE == 1 if DEFAULT_INLINE == 2. + Don't use DEFAULT_INLINE to define REGISTERS_INLINE DEVICES_INLINE + DEVICE_TREE_INLINE or INTERRUPTS_INLINE as none of these are on + the instruction or data critical paths. + + * FIXME: need to set up OS_EMUL_INLINE/EMUL_GENERIC_INLINE but + not on critical path. + + * FIXME: devices.c/emul_netbsd.c would benefit (slightly) from + the inclusion of device_tree.c/emul_generic.c. + +Mon Oct 23 00:31:50 1995 Andrew Cagney + + * os_emul.[hc], emul_generic.[hc], emul_netbsd.[hc]: replace + system.[hc]. Start of suport for multiple emulations and + emulation state (os_emul object). + + * emul_generic.[hc]: Start of code to implement proper system call + tracing (from spy). + +Sun Oct 22 21:33:51 1995 Andrew Cagney + + * cpu.h, cpu.c (cpu_init): New function, zero the registers before + the processor is started. Fixes problem of registers being + undefined when restarting from within gdb. + + * cpu.h, cpu.c (cpu_flush_icache): New function, flushes the + instruction cache (if present). Fixes problem of cpu caching gdb + breakpoint instructions. + + FIXME: PSIM sometimes aborts calling error(), it should instead + call sim_error() say which takes care of housekeeping such as + saving the CIA before calling error. + + * NOTE: cpu_flush_cache() instead of cpu_synchronize_context() is + used when restarting a simulation because the latter has the + unwanted side effect (well I as a kernel hacker think it is) of + performing an isync when the instruction stream doesn't contain + one. + +Sun Oct 22 19:27:48 1995 Andrew Cagney + + * mon.h (new), mon.c (new), std-config.h (WITH_MON): Performance + monitoring module. Counts both instructions issued and + load/stores. + + * NOTE: mon does not contain to count instruction loads as this + information is already available from the mon_issue() hook. + + * FIXME: mon doesn't have access to register usage information. + This is needed if the user wants to monitor things like register + stalls. + + * igen.c (lf_print_c_semantic), vm_n.h: Add counting code. + + * psim.h, psim.c (psim_create), cpu.h, cpu.c (cpu_create): Attach + a common monitor to each of the cpus. Delete + cpu_increment_number_of_insns() and cpu_get_number_of_insns() + replaced by copied code in mon.[hc]. + +Sun Oct 22 18:42:45 1995 Andrew Cagney + + * sim_calls.c, main.c, psim.c (psim_create): always create + `WITH_SMP' cpus. The actual number of CPU's active in a + simulation run is taken from the device node: /init/smp (an + integer). WITH_SMP changed to 2 (remember to put it back to 0). + +Fri Oct 20 17:26:54 1995 Andrew Cagney + + * system.c: More system call emulation. If code appears NetBSD + specific, make conditional to being compiled on a NetBSD system + (sigh). + +Wed Oct 18 23:02:20 1995 Andrew Cagney + + * Makefile.in, gen.c(delete), igen.c(new), dgen.c(new), + lf.[ch](new), table.[ch](new): Split into two generators - igen + that outputs the instruction tables and dgen that outputs the spr + tables. Add -f (filter out) flag to igen to filter out certain + instructions (ex 64 bit ones) from the created tables. Include + $(LIBIBERTY_LIB) in link options in case host lacks some libc + functions. + + * NOTE: igen, since it was originally written for the + PowerPC/RS6000, things the MSB is 0 and the LSB is 63{31}. + + * Makefile.in, std-config.h, ppc-cache-rules(new), + ppc-opcode-complex(new), ppc-opcode-simple(new): (for igen) Create + cache-rule and opcode-rule tables from macros found std-config.h. + Delete corresponding macro's from std-config.h. + + * FIXME: under this new igen scheme, when playing around with igen + options, you'll find that depenencies don't work very well. + + * igen.c (gen_itable_c, gen_itable_h), Makefile.in: code to output + an table of all the instructions. Code to output a type + enumerating all the instructin names. + + * igen.c(lf_print_c_semantic): Move call to increment instruction + counter so that it occures _after_ the instruction has been fully + validated, was double counting illegal/invalid instructions. Add + conditional so only compiled in when WITH_PROFILE enabled (enabled + by default). + + * igen.c, cpu.h, cpu.c(cpu_increment_number_of_insns): Include + itable.h, count individual instruction types not just total, + adjust reporting functions to output this. + + * ppc-instructions (64 bit Load Doubleword with Update Indexed): + Had 32./ instead of 31./ + + * ppc-instructions (64 bit Store Double Word Conditional Indexed): + bitrot - updated to use newer CR register operators. + + * ppc-instructions (64bit Floating Convert from Integer + Doubleword): Correct call to Round_Float(). + +Mon Oct 16 00:31:20 1995 Andrew Cagney + + * basics.h: #include "sim_callbacks.h" earlier so that its + prototypes are declared in all other header files. + + * bits.h, bits.c, idecode_expression.h (ROTL32, ROTL64): Update + doc in bits.h, remove dead code in bits.c, move ROTL32/ROTL64 into + bits.h. + + * FIXME: the bits.h/bits.c macro's should be replaced with + (inline) c functions. + + * cpu.c(cpu_add_commas), device_tree.h, device_tree.c(scand_*): + Add size of buffer argument to functions writing a string into a + buffer. Check for buffer overflow. + +Sun Oct 15 22:16:11 1995 Andrew Cagney + + * devices.h, devices.c, debug.h, debug.c: add macro's for tracing + of each device. Make parameter names consistent so macros work. + Use macro's in device functions. + + * device_tree.c, devices.h, devices.c: include path to device in a + devices node when creating it. + + * device_tree.c, debug.h, debug.c: Add tracing of `device-tree'. + + * core.c: add tracing of core-device, adjust parameter names in + core functions to be consistent with those in devices*. + +Sun Oct 15 20:33:20 1995 Andrew Cagney + + * debug.h, debug.c (trace_option): New function. Parses the trace + option, updating the trace array. + + * debug.h, debug.c (trace_usage): New function. Outputs the list + of all possible trace options. + + * sim_calls.c (sim_open), main.c (main): Use new trace_option() to + parse trace options specified with the simpler -t flag. Adjust + usage. + + * FIXME: basic parsing of command line options is still duplicated + by main.c and sim_calls.c + Thu Oct 26 10:42:28 1995 Michael Meissner * Makefile.in (clean): Delete *.i and *.out files. @@ -93,7 +287,7 @@ Thu Oct 12 11:35:53 1995 Michael Meissner ({CORE,VM,CPU,EVENTS,REGISTERS,INTERRUPTS}_INLINE): Ditto. ({SPREG,IDECODE}_INLINE): Ditto. -Wed Oct 11 17:13:15 1995 Andrew Cagney +Wed Oct 11 17:13:15 1995 Andrew Cagney * ppc-instructions: Initial cut of floating point suport added. Of note include - use of host IEEE floating point instructions, @@ -110,7 +304,7 @@ Wed Oct 11 17:13:15 1995 Andrew Cagney * Makefile.in et.al (sorry): tweek to use new core, core_map and core.h. -Wed Oct 11 12:10:26 1995 Andrew Cagney +Wed Oct 11 12:10:26 1995 Andrew Cagney * sim_calls.c, main.c: Add -g (trace_gdb) option, add tracing to most of the other functions in sim_calls.c. @@ -121,7 +315,7 @@ Wed Oct 11 12:10:26 1995 Andrew Cagney * vm.c, vm_n.h, Makefile.in: ditto -Tue Oct 10 15:42:59 1995 Andrew Cagney +Tue Oct 10 15:42:59 1995 Andrew Cagney * devices.h, devices.c, memory_map.h, memory_map.c: Changed callback interface so that there is a read/write buffer but no @@ -133,12 +327,12 @@ Tue Oct 10 15:42:59 1995 Andrew Cagney eliminate transfer_mode (raw or cooked) parameter from read/write buffer. -Fri Oct 6 20:23:56 1995 Andrew Cagney +Fri Oct 6 20:23:56 1995 Andrew Cagney * ppc-instructions (fmul, fmuls): correct instruction format - had FRB instead of FRC. -Wed Oct 4 17:31:12 1995 Andrew Cagney +Wed Oct 4 17:31:12 1995 Andrew Cagney * psim.c, device_tree.h, device_tree.c, devices.c (printd_*, scand_*): new functions to parse/print fields in device names @@ -152,7 +346,7 @@ Wed Oct 4 17:31:12 1995 Andrew Cagney variable number of arguments. This gives greater flexability and greater chance of bugs. -Tue Oct 3 22:01:56 1995 Andrew Cagney - aka Noid +Tue Oct 3 22:01:56 1995 Andrew Cagney * main.c (printf_filtered, error): Missing va_end() to close off variable argument use. @@ -275,7 +469,7 @@ Fri Sep 8 09:51:03 1995 Michael Meissner * basics.h (sysdep.h): Don't include it. * Makefile.in (BASICS_H): Remove sysdep.h. -Wed Sep 6 13:25:42 1995 Andrew Cagney - aka Noid +Wed Sep 6 13:25:42 1995 Andrew Cagney * core.c (core_add_data): First growth of bss was being put at wrong address (0) instead of &end. @@ -283,7 +477,7 @@ Wed Sep 6 13:25:42 1995 Andrew Cagney - aka Noid * core.c (core_add_stack, core_add_data): Was not handling case where bss/stack is grown across the current end-of-{bss,stack}. -Wed Sep 6 00:46:10 1995 Andrew Cagney - aka Noid +Wed Sep 6 00:46:10 1995 Andrew Cagney * system.c (system_call): Fix SYS_break - was aligning bss to a page boundary instead of just an 8 byte one; On first call sbrk(0) @@ -329,7 +523,7 @@ Tue Aug 22 09:31:18 1995 Michael Meissner * configure.in: Clone from other simulator targets. * configure: Generate via autoconf from configure.in. -Sat Aug 19 09:05:32 1995 Andrew Cagney - aka Noid +Sat Aug 19 09:05:32 1995 Andrew Cagney * ppc-instructions: fix srawi (was geting XER[CA] real wrong). @@ -340,14 +534,14 @@ Sat Aug 19 09:05:32 1995 Andrew Cagney - aka Noid * main.c (main): really stupid. Wasn't exiting with correct status -Fri Aug 18 00:38:01 1995 Andrew Cagney - aka Noid +Fri Aug 18 00:38:01 1995 Andrew Cagney * system.c (system_call): add system calls kill(2) and getpid(2). * main.c (main): Check/return exit status when simulation finishes. -Thu Aug 17 14:29:18 1995 Andrew Cagney +Thu Aug 17 14:29:18 1995 Andrew Cagney * device_tree.c (create_option_device_node): Alignment rules (at least for the moment) now are for strict alignment only for LE OEA @@ -355,7 +549,7 @@ Thu Aug 17 14:29:18 1995 Andrew Cagney * system.c (system_call) SYS_exit: Wasn't exiting with correct status. -Thu Aug 17 01:16:38 1995 Andrew Cagney - aka Noid +Thu Aug 17 01:16:38 1995 Andrew Cagney * vm.c (DEFINE_VM_DATA_MAP_WRITE_N): For miss aligned transfer forgot to return. diff --git a/sim/ppc/Makefile.in b/sim/ppc/Makefile.in index c5e9ff4ea2..d92ca568de 100644 --- a/sim/ppc/Makefile.in +++ b/sim/ppc/Makefile.in @@ -80,7 +80,11 @@ INCLUDES = -I. -I$(srcdir) $(LIB_INCLUDES) $(BFD_INCLUDES) $(GDB_INCLUDES) CONFIG_FILE = std-config.h # See inline.h for appropriate flags to set -INLINE_CFLAGS = -DDEFAULT_INLINE=2 +INLINE_CFLAGS = # -g0 -DDEFAULT_INLINE=2 +IGEN_FLAGS = -f 64 # -f 64 -e +IGEN_OPCODE_RULES = ppc-opcode-simple # ppc-opcode-complex +DGEN_FLAGS = # # -s + LIBIBERTY_LIB = ../../libiberty/libiberty.a BFD_LIB = ../../bfd/libbfd.a @@ -128,7 +132,15 @@ CPU_H = \ events.h \ interrupts.h \ psim.h \ - icache.h + icache.h \ + itable.h \ + mon.h + +EMUL_GENERIC_H = \ + $(CPU_H) \ + $(IDECODE_H) \ + emul_generic.h \ + os_emul.h INLINE = \ @@ -139,35 +151,43 @@ BUILT_SRC = \ icache.h \ idecode.h idecode.c \ semantics.h semantics.c \ + itable.h itable.c \ spreg.h spreg.c \ config.h \ - ppc-config.h + ppc-config.h LIB_SRC = \ psim.c \ bits.c \ - ppc-endian.c \ debug.c \ + ppc-endian.c \ vm.c \ core.c \ events.c \ - system.c \ + os_emul.c \ + emul_generic.c \ + emul_netbsd.c \ registers.c \ cpu.c \ interrupts.c \ devices.c \ - device_tree.c + device_tree.c \ + mon.c MAIN_SRC = \ main.c \ sim_calls.c +# NOTE: semantics, idecode and psim put last so smaller files are compiled +# first LIB_OBJ = \ debug.o \ bits.o \ ppc-endian.o \ - system.o \ + os_emul.o \ + emul_generic.o \ + emul_netbsd.o \ registers.o \ vm.o \ core.o \ @@ -177,6 +197,8 @@ LIB_OBJ = \ events.o \ devices.o \ device_tree.o \ + itable.o \ + mon.o \ semantics.o \ idecode.o \ psim.o @@ -192,7 +214,7 @@ run: psim rm -f run ln psim run -$(TARGETLIB): tmp-gencode $(LIB_OBJ) $(GDB_OBJ) +$(TARGETLIB): tmp-igen tmp-dgen $(LIB_OBJ) $(GDB_OBJ) rm -f $(TARGETLIB) $(AR) $(AR_FLAGS) $(TARGETLIB) $(LIB_OBJ) $(GDB_OBJ) $(RANLIB) $(TARGETLIB) @@ -201,27 +223,29 @@ $(TARGETLIB): tmp-gencode $(LIB_OBJ) $(GDB_OBJ) # anything changes. psim.o: psim.c psim.h $(CPU_H) $(IDECODE_H) $(INLINE) $(LIB_SRC) -bits.o: bits.c bits.h +bits.o: bits.c $(BASICS_H) debug.o: debug.c $(BASICS_H) ppc-endian.o: ppc-endian.c ppc-endian.h \ config.h ppc-config.h words.h sim_callbacks.h -system.o: system.c system.h $(CPU_H) $(IDECODE_H) +os_emul.o: os_emul.c $(EMUL_GENERIC_H) +emul_generic.o: emul_generic.c $(EMUL_GENERIC_H) +emul_netbsd.o: emul_netbsd.c emul_netbsd.h $(EMUL_GENERIC_H) registers.o: registers.c $(REGISTERS_H) $(BASICS_H) cpu.o: cpu.c $(CPU_H) $(IDECODE_H) -interrupts.o: interrupts.c $(CPU_H) $(IDECODE_H) system.h +interrupts.o: interrupts.c $(CPU_H) $(IDECODE_H) os_emul.h idecode.o: idecode.c $(CPU_H) $(IDECODE_H) semantics.h # double.o: double.c dp-bit.c vm.o: vm.c vm.h vm_n.h $(BASICS_H) $(REGISTERS_H) \ - device_tree.h core.h interrupts.h + device_tree.h core.h interrupts.h itable.h mon.h core.o: core.c core.h $(BASICS_H) device_tree.h @@ -240,6 +264,9 @@ device_tree.o: device_tree.c device_tree.h devices.h $(BASICS_H) semantics.o: semantics.c semantics.h $(CPU_H) $(IDECODE_H) +itable.o: itable.c itable.h + +mon.o: $(CPU_H) # # Rules to create the built c source code files @@ -249,47 +276,63 @@ ppc-config.h: $(CONFIG_FILE) cp $(srcdir)/$(CONFIG_FILE) ppc-config.h -tmp-gencode: gen ppc-instructions ppc-spr-table $(srcdir)/../../move-if-change - ./gen -r $(srcdir)/ppc-spr-table \ - -i $(srcdir)/ppc-instructions \ +tmp-dgen: dgen ppc-spr-table $(srcdir)/../../move-if-change + ./dgen $(DGEN_FLAGS) \ + -r $(srcdir)/ppc-spr-table \ -n spreg.h -P tmp-spreg.h \ - -n spreg.c -p tmp-spreg.c \ + -n spreg.c -p tmp-spreg.c + $(srcdir)/../../move-if-change tmp-spreg.h spreg.h + $(srcdir)/../../move-if-change tmp-spreg.c spreg.c + touch tmp-dgen + + +tmp-igen: igen ppc-instructions $(IGEN_OPCODE_RULES) ppc-cache-rules $(srcdir)/../../move-if-change + ./igen $(IGEN_FLAGS) \ + -o $(srcdir)/$(IGEN_OPCODE_RULES) \ + -k $(srcdir)/ppc-cache-rules \ + -i $(srcdir)/ppc-instructions \ -n icache.h -C tmp-icache.h \ -n semantics.h -S tmp-semantics.h \ -n semantics.c -s tmp-semantics.c \ -n idecode.h -D tmp-idecode.h \ - -n idecode.c -d tmp-idecode.c + -n idecode.c -d tmp-idecode.c \ + -n itable.h -T tmp-itable.h \ + -n itable.c -t tmp-itable.c $(srcdir)/../../move-if-change tmp-icache.h icache.h $(srcdir)/../../move-if-change tmp-idecode.h idecode.h $(srcdir)/../../move-if-change tmp-idecode.c idecode.c $(srcdir)/../../move-if-change tmp-semantics.h semantics.h $(srcdir)/../../move-if-change tmp-semantics.c semantics.c - $(srcdir)/../../move-if-change tmp-spreg.h spreg.h - $(srcdir)/../../move-if-change tmp-spreg.c spreg.c - touch tmp-gencode + $(srcdir)/../../move-if-change tmp-itable.h itable.h + $(srcdir)/../../move-if-change tmp-itable.c itable.c + touch tmp-igen # NOTE: Some versions of make don't handle files created as side-effects # uncomment the below if that is the case. # -# $(TARGETLIB): tmp-gencode -# icache.h idecode.h idecode.c semantics.h semantics.c spreg.h spreg.c: tmp-gencode +# $(TARGETLIB): tmp-igen tmp-dgen +# itable.h itable.c icache.h idecode.h idecode.c semantics.h semantics.c: tmp-igen +# spreg.h spreg.c: tmp-dgen -gen.o: gen.c config.h ppc-config.h - $(CC_FOR_BUILD) -c $(CFLAGS) $(INLINE_CFLAGS) $(HDEFINES) $(TDEFINES) $(INCLUDES) $(srcdir)/gen.c +dgen: dgen.o table.o lf.o misc.o + $(CC_FOR_BUILD) $(CFLAGS) $(LDFLAGS) -o dgen dgen.o table.o lf.o misc.o $(LIBIBERTY_LIB) $(LIBS) -gen: gen.o config.h ppc-config.h $(LIBIBERTY_LIB) $(LIBS) - $(CC_FOR_BUILD) $(CFLAGS) $(LDFLAGS) -o gen gen.o $(LIBIBERTY_LIB) $(LIBS) +igen: igen.o table.o lf.o misc.o + $(CC_FOR_BUILD) $(CFLAGS) $(LDFLAGS) -o igen igen.o table.o lf.o misc.o $(LIBIBERTY_LIB) $(LIBS) -# +table.o: misc.h lf.h table.h +lf.o: misc.h lf.h +dgen.o igen.o: misc.h lf.h table.h +misc.o: misc.h +# With out this #, make thinks that misc.o doesn't have a rule tags etags: TAGS -TAGS: tmp-gencode config.h ppc-config.h +TAGS: tmp-igen tmp-dgen config.h ppc-config.h etags $(srcdir)/*.h $(srcdir)/*.c $(BUILT_SRC) clean mostlyclean: - rm -f tmp-* *.[ioas] *.out core psim run gen config.log - rm -f icache.h idecode.h idecode.c semantics.h semantics.c spreg.h spreg.c ppc-config.h + rm -f tmp-* *.[oas] core psim run igen dgen config.log distclean maintainer-clean realclean: clean rm -f TAGS $(BUILT_SRC) Makefile config.cache config.status config.h stamp-h diff --git a/sim/ppc/README.psim b/sim/ppc/README.psim index f9a14866a2..89bf36965a 100644 --- a/sim/ppc/README.psim +++ b/sim/ppc/README.psim @@ -3,231 +3,250 @@ Copyright (C) 1994-1995, Andrew Cagney -This directory contains the program PSIM that models the PowerPC -architecture. It can either be run stand alone (psim or run) or used -as part of GDB. +This directory contains the program PSIM that models the PowerPC(tm - +IBM) architecture. It can either be run stand alone (psim or run) or +used as part of GDB. -SOURCE: +KNOWN FEATURES - PSIM is now part of the Cygnus GDB source tree (hopefully it - will in turn become part of the next FSF release of GDB). - If you're looking for a more `cutting' edge version of this - program then it can be found in: +SMP: A Symetric Multi-Processor configuration is suported. This +includes modeling of the PowerPC load word and reserve 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). The number of processors is +selected during startup. - ftp.ci.com.au:pub/clayton/psim-sim-*.tar.gz +DUAL-ENDIAN: Both little and big endian models are suported. The +execution of instruction sequences that switch between the two modes, +however, is not. The endianess is selected during startup. - This contains a replacement for the directory sim/ppc. As - these releases prove stable they are merged back into the GDB - source tree. +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. That is the User Instruction Set +Architecture, the Virtual Environment Architecture and finally the +Operating Environment Architecture. The environment is selected +during startup. The OEA model is still under development. - If you find bugs or experience problems, please e-mail them to - the alias: +HARDWARE DEVICE TREE: In the OEA, the model of the target machines +hardware is built from a tree of devices (bit like Open Boot). +Included in this is the ability to model bus hierachies and +runtime-configurable devices (eg PCI). The device tree used to create +the hardware model is created during startup. This device tree is +still under development. - powerpc-psim@ci.com.au +VEA SYSTEM CALLS: In user mode, basic system calls (read, write, open, +close ...) are emulated. Under NetBSD (simply because that is what my +machine at home runs) the list is more extensive. - It's a majordomo mailing list. +PEDANTIC VEA MEMORY MODEL: This model implements the break (brk, sbrk) +system calls. Further, the user model has very strict memory access +controls. 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 +problems in user code so it is now described as a feature. +PROFILING: The simulation is able to count the number and type of +instructions issued and the number of loads and stores. This feature +is still under development. -BUILDING: +PERFORMANCE: In its default configuration PSIM is constructed so that +it will compile fast and run slow. Through the enabling of more +agressive compile options (and the disabling of unwanted features) the +build can be changed to compile slow and run fast. - 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. +FLOATING POINT: Preliminary suport for floating point is included. +Real kernels don't need floating point. - o I also suggest that you install: flex, bision, gnu-make and - byacc. Doing this just makes builds easier. - o Configure almost as per normal, specifing the special target - eabisim vis: +BUILDING PSIM: - $ CC=gcc ./configure --target=powerpcle-unknown-eabisim +To build PSIM you will need the following: - by default (because of its dependency on GCC). + gdb-4.15.tar.gz From your favorite GNU ftp site - o Build your entire gdb tree as per normal. Something along the - lines of: + ftp://ftp.ci.com.au/pub/clayton/gdb-4.15+psim-951016.diff.gz + + This contains a few minor patches to + gdb-4.15 so that will include psim + when it is built. + + ftp://ftp.ci.com.au/pub/clayton/gdb-4.15+psim-951016.tar.gz + + This contains the psim files propper. + + ftp://ftp.ci.com.au/pub/clayton/psim-test-951016.tar.gz + + (Optional) A scattering of pre-compiled + programs that run under the simulator. + + gcc Again available from your favorite + GNU ftp site. + + patch Sun's patch behaves a little wierd + and doesn't appear to like creating + empty files. + + +In the directory ftp.ci.com.au:pub/clayton you will also notice files +named psim-NNNNNN.tar.gz. Those, more recent snapshots, may or may +not work with gdb. + + +0. A starting point + + $ ls -1 + gdb-4.15+psim-951016.diff.gz + gdb-4.15+psim-951016.tar.gz + gdb-4.15.tar.gz + psim-test-951016.tar.gz - $ cd gdb-4.15 - $ make CC=gcc - . - . - . +1. Unpack gdb + $ gunzip < gdb-4.15.tar.gz | tar xf - - o Install it it all as per normal. Something along the lines of: + +2. Change to the gdb directory, apply the psim patches and unpack + the psim files. $ cd gdb-4.15 - $ make CC=gcc install + $ gunzip < ../gdb-4.15+psim-951016.diff.gz | more + $ gunzip < ../gdb-4.15+psim-951016.diff.gz | patch -p1 -RUNNING: + $ gunzip < ../gdb-4.15+psim-951016.tar.gz | tar tvf - + $ gunzip < ../gdb-4.15+psim-951016.tar.gz | tar xvf - - PSIM can either be run as a stand alone program or as part - of gdb. The psim-test archive (found in: - ftp.ci.com.au:pub/clayton +3. Configure gdb - contains pre-compiled and linked programs that can be run on - PSIM. The notes below assume that you have unpacked that tar - archive. + $ more gdb/README - To rebuild the archive you will need to obtain a working - version of an ELF compiler/linker for the PowerPC. - - Example of running PSIM: + then something like (I assume SH): - Print out the users environment: + $ CC=gcc ./configure --target=powerpc-unknown-eabisim - $ sim/ppc/psim sim/ppc/test/envp + eabisim is needed as by default (because PSIM needs GCC) the + simulator is not built. - Print out the arguments: - $ sim/ppc/psim sim/ppc/test/argv a b c +4. Build - Check the OEA model: + $ make CC=gcc - $ sim/ppc/psim sim/ppc/test/interrupt + alternativly, if you are short on disk space or just want the + simulator built: - Check that sbrk works + $ ( cd libiberty && make CC=gcc ) + $ ( cd bfd && make CC=gcc ) + $ ( cd sim/ppc && make CC=gcc ) - $ sim/ppc/psim sim/ppc/test/break - Try for speed. The program count contains a loop - of two instructions which is looped times. - See later for how to make PSIM run 10-100 times - faster. +5. Install - $ time sim/ppc/sim sim/ppc/test/count 5000000 - $ expr 10 \* 1000 \* 1000 / + $ make CC=gcc install + or just + $ cp gdb/gdb ~/bin/powerpc-unknown-eabisim-gdb + $ cp sim/ppc/run ~/bin/powerpc-unknown-eabisim-run - Example of running GDB: +USING THE SIMULATOR: - The most important thing to be aware of is the fact - that before the simulator is used, the user must attach - to it (target sim) and than load the executable (load count). +(I assume that you've unpacked the psim-test archive). - $ cd sim/ppc/test - $ powerpc-unknown-eabi-gdb count - (gdb) target sim - (gdb) load count - (gdb) break main - (gdb) run - . - . - . +1. As a standalone program + Print out the users environment: -CONFIGURATION: + $ powerpc-unknown-eabisim-run envp - Making it go faster + Print out the arguments: - See the file sim/ppc/config.h (which is copied from - sim/ppc/std-config.h) for further information. + $ powerpc-unknown-eabisim-run argv a b c + Check that sbrk works: -KNOWN FEATURES + $ powerpc-unknown-eabisim-run break - 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. +2. Example of running GDB: -KNOWN PROBLEMS: + The main thing to note is that before you can run the simulator + you must enable it. The example below illustrates this: + + $ powerpc-unknown-eabisim-gdb envp + (gdb) target sim + (gdb) load + (gdb) break main + (gdb) run + . + . + . + + +BUGS AND PROBLEMS: - FLOATING POINT: Need to add suport for non IEEE float - machines. Need to more fully handle exceptions (eg things - like divide by zero). +There is a mailing list (subscribe through majordomo@ci.com.au) (that +is almost never used) at: - DEVICE TREE DOC: How to create and use the device tree is not - documented at all. + powerpc-psim@ci.com.au - INITIALIZATION: When running from gdb, things are not - re-initialzied very well e.g. registers are not rezeroed. +If I get the ftp archive updated I post a note to that news group. In +addition your welcome to send bugs or problems either to me or to that +e-mail list. - 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. +KNOWN PROBLEMS: + +See the ChangeLog file looking for lines taged with the word FIXME. - Lacks PowerOpen (a.k.a. XCOFF a.k.a. AIX) and NT startups. - The PowerOpen worked until I added the ELF one. +CORE.C: The implementation of core.c (defined by core.h) isn't the +best. It is intended to be functionaly correct rather than fast. - 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. +HTAB (page) code for OEA model untested. Some of the vm code +instructions unimplemented. - Missing VEA system calls. +Flush instruction cache instructions do nothing. Perhaphs they should +(if there is an instruction cache) flush it. - Missing or commented out instructions. +Lacks PowerOpen (a.k.a. XCOFF a.k.a. AIX) and NT startups. The +PowerOpen worked until I added the ELF one. - Only basic (hackish) floating point implemented, I would not - trust it and it is going to change. +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. - 64bit target untested. +Missing VEA system calls. - 64bit host broken. For instance use of scanf "%x", &long long. +Missing or commented out instructions. - Event code for pending events from within signal handlers not - finished/tested. +64bit target untested. - Better and more devices. +64bit host broken. For instance use of scanf "%x", &long long. - 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. +Event code for pending events from within signal handlers not +finished/tested. + +Better and more devices. + +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: - Thanks go to the following who each helped in some way. +Thanks go to the following who each helped in some way. - Allen Briggs, Bett Koch, David Edelsohn, - Michael Meissner, Bob Mercier, Richard Perini, - Richard Stallman, Mitchele Walker + Allen Briggs, Bett Koch, David Edelsohn, Gordon Irlam, + Michael Meissner, Bob Mercier, Richard Perini, + Richard Stallman, Mitchele Walker ---------------------------------------------------------------- @@ -274,7 +293,3 @@ 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/bits.c b/sim/ppc/bits.c new file mode 100644 index 0000000000..2424e859f5 --- /dev/null +++ b/sim/ppc/bits.c @@ -0,0 +1,27 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1995, Andrew Cagney + + 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 _BITS_C_ +#define _BITS_C_ + +#include "basics.h" + +#endif /* _BITS_C_ */ diff --git a/sim/ppc/build-psim b/sim/ppc/build-psim new file mode 100755 index 0000000000..ea7318a9fd --- /dev/null +++ b/sim/ppc/build-psim @@ -0,0 +1,155 @@ +#!/bin/sh + +case "`uname -s`-`uname -r`" in + NetBSD* ) + cflags="-Wall -Wno-unused -Wmissing-prototypes -Werror" + ;; + SunOS-5* ) + cflags="-gstabs+" + ;; + SunOS-4* ) + cflags="-Werror" + ;; +esac + +for target in "$@" +do + + echo "" + echo "$target" + echo "" + + if [ $# -gt 1 ] + then + make clean + fi + + case $target in + *unsafe* ) + with_trace="-DWITH_TRACE=0" + with_assert="-DWITH_ASSERT=0" + unsafe_flags="-g0 -fomit-frame-pointer -fno-strength-reduce" + ;; + *safe* ) + with_trace= + with_assert= + unsafe_flags="-g0" + ;; + * ) + with_trace= + with_assert= + unsafe_flags= + ;; + esac + + case $target in + *little* ) + with_target_byte_order="-DWITH_TARGET_BYTE_ORDER=LITTLE_ENDIAN" + ;; + *big* ) + with_target_byte_order="-DWITH_TARGET_BYTE_ORDER=BIG_ENDIAN" + ;; + * ) + with_target_byte_order= + ;; + esac + + case $target in + *vea* ) + with_environment="-DWITH_ENVIRONMENT=VIRTUAL_ENVIRONMENT" + with_smp="-DWITH_SMP=0" + ;; + *oea* ) + with_environment="-DWITH_ENVIRONMENT=OPERATING_ENVIRONMENT" + with_smp="-DWITH_SMP=2" + ;; + * ) + with_environment= + with_smp= + ;; + esac + + case $target in + *complex* ) + igen_opcode_rules="IGEN_OPCODE_RULES=ppc-opcode-complex" + igen_flags="-e -r 1024" + opt_flags="-O2" + ;; + *simple* ) + igen_opcode_rules="IGEN_OPCODE_RULES=ppc-opcode-simple" + igen_flags="-e" + opt_flags="-O2" + ;; + * ) + igen_opcode_rules= + igen_flags= + opt_flags= + ;; + esac + + case $target in + *64* ) + with_target_word_bitsize="-DWITH_TARGET_WORD_BITSIZE=64" + igen_flags="$igen_flags -f 32" + ;; + *32* ) + with_target_word_bitsize="-DWITH_TARGET_WORD_BITSIZE=32" + igen_flags="$igen_flags -f 64" + ;; + * ) + with_target_word_bitsize= + igen_flags="$igen_flags -f 64" + ;; + esac + + case $target in + *inline* ) + default_inline="-DDEFAULT_INLINE=2" + ;; + * ) + default_inline= + ;; + esac + + case $target in + *nomon* ) + with_mon="-DWITH_MON=0" + ;; + * ) + with_mon= + ;; + esac + + case $target in + *bswap* ) + with_bswap="-DWITH_BSWAP=1" + ;; + * ) + with_bswap= + ;; + esac + + if ( set -x ; make \ + $igen_opcode_rules \ + IGEN_FLAGS="$igen_flags" \ + INLINE_CFLAGS=" \ + $cflags \ + $unsafe_flags \ + $opt_flags \ + $with_bswap \ + $with_target_byte_order \ + $with_environment \ + $with_smp \ + $default_inline \ + $with_target_word_bitsize \ + $with_trace \ + $with_assert \ + $with_mon \ + " ) + then + rm -f psim-${target}-failed + ( set -x ; cp psim psim-$target ) + else + ( set -x ; touch psim-${target}-failed ) + fi +done diff --git a/sim/ppc/core.c b/sim/ppc/core.c index a40128e981..4acf0a3a25 100644 --- a/sim/ppc/core.c +++ b/sim/ppc/core.c @@ -42,7 +42,7 @@ struct _core_mapping { device_io_read_buffer_callback *reader; device_io_write_buffer_callback *writer; /* common */ - int address_space; + int space; unsigned_word base; unsigned_word bound; unsigned nr_bytes; @@ -130,12 +130,12 @@ core_executable(core *memory) 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) + int space, + unsigned_word addr, + unsigned nr_bytes, + const device *device, + void *buffer, + int free_buffer) { core_mapping *new_mapping = ZALLOC(core_mapping); switch (attach) { @@ -154,7 +154,7 @@ new_core_mapping(attach_type attach, attach); } /* common */ - new_mapping->address_space = address_space; + new_mapping->space = space; new_mapping->base = addr; new_mapping->nr_bytes = nr_bytes; new_mapping->bound = addr + (nr_bytes - 1); @@ -164,21 +164,21 @@ new_core_mapping(attach_type attach, 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*/ + attach_type attach, + int space, + unsigned_word addr, + unsigned nr_bytes, /* host limited */ + const device *device, /*callback/default*/ + void *buffer, /*raw_memory*/ + int free_buffer) /*raw_memory*/ { 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); + space, addr, nr_bytes, + device, buffer, free_buffer); } else { /* find the insertion point for this additional mapping and insert */ @@ -206,8 +206,8 @@ core_map_attach(core_map *access_map, /* create/insert the new mapping */ *last_mapping = new_core_mapping(attach, - address_space, addr, nr_bytes, - device, buffer, free_buffer); + space, addr, nr_bytes, + device, buffer, free_buffer); (*last_mapping)->next = next_mapping; } } @@ -216,7 +216,7 @@ core_map_attach(core_map *access_map, INLINE_CORE void core_attach(core *memory, attach_type attach, - int address_space, + int space, access_type access, unsigned_word addr, unsigned nr_bytes, /* host limited */ @@ -236,7 +236,7 @@ core_attach(core *memory, if (access & access_read) core_map_attach(memory->map + access_map, attach, - address_space, addr, nr_bytes, + space, addr, nr_bytes, device, buffer, !free_buffer); free_buffer ++; break; @@ -244,7 +244,7 @@ core_attach(core *memory, if (access & access_write) core_map_attach(memory->map + access_map, attach, - address_space, addr, nr_bytes, + space, addr, nr_bytes, device, buffer, !free_buffer); free_buffer ++; break; @@ -252,7 +252,7 @@ core_attach(core *memory, if (access & access_exec) core_map_attach(memory->map + access_map, attach, - address_space, addr, nr_bytes, + space, addr, nr_bytes, device, buffer, !free_buffer); free_buffer ++; break; @@ -320,7 +320,7 @@ core_map_read_buffer(core_map *map, if (mapping->reader != NULL) { if (mapping->reader(mapping->device, &byte, - mapping->address_space, + mapping->space, raddr - mapping->base, 1, /* nr_bytes */ 0, /*processor*/ @@ -357,7 +357,7 @@ core_map_write_buffer(core_map *map, if (mapping->writer != NULL) { if (mapping->writer(mapping->device, &byte, - mapping->address_space, + mapping->space, raddr - mapping->base, 1, /*nr_bytes*/ 0, /*processor*/ @@ -382,6 +382,7 @@ core_init_callback(const device *me, psim *system) { core *memory = (core*)me->data; + DTRACE_INIT(core); core_init(memory); } @@ -390,7 +391,7 @@ STATIC_INLINE_CORE void core_attach_address_callback(const device *me, const char *name, attach_type attach, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, access_type access, @@ -398,11 +399,12 @@ core_attach_address_callback(const device *me, { core *memory = (core*)me->data; unsigned_word device_address; - if (address_space != 0) + DTRACE_ATTACH_ADDRESS(core); + if (space != 0) error("core_attach_address_callback() invalid address space\n"); core_attach(memory, attach, - address_space, + space, access, addr, nr_bytes, @@ -412,15 +414,16 @@ core_attach_address_callback(const device *me, STATIC_INLINE_CORE unsigned core_dma_read_buffer_callback(const device *me, - void *target, - int address_space, - unsigned_word offset, + void *dest, + int space, + unsigned_word addr, unsigned nr_bytes) { core *memory = (core*)me->data; + DTRACE_DMA_READ_BUFFER(core); return core_map_read_buffer(core_readable(memory), - target, - offset, + dest, + addr, nr_bytes); } @@ -428,8 +431,8 @@ core_dma_read_buffer_callback(const device *me, STATIC_INLINE_CORE unsigned core_dma_write_buffer_callback(const device *me, const void *source, - int address_space, - unsigned_word offset, + int space, + unsigned_word addr, unsigned nr_bytes, int violate_read_only_section) { @@ -437,9 +440,10 @@ core_dma_write_buffer_callback(const device *me, core_map *map = (violate_read_only_section ? core_readable(memory) : core_writeable(memory)); + DTRACE_DMA_WRITE_BUFFER(core); return core_map_write_buffer(map, source, - offset, + addr, nr_bytes); } @@ -463,7 +467,7 @@ static device_callbacks const core_callbacks = { INLINE_CORE const device * core_device_create(core *memory) { - return device_create_from("core", memory, &core_callbacks, NULL); + return device_create_from("core", "/", memory, &core_callbacks, NULL); } diff --git a/sim/ppc/core_n.h b/sim/ppc/core_n.h index d4c54bc55c..8a80ac8964 100644 --- a/sim/ppc/core_n.h +++ b/sim/ppc/core_n.h @@ -47,7 +47,7 @@ XCONCAT2(core_map_read_,N)(core_map *map, unsigned_N data; if (mapping->reader(mapping->device, &data, - mapping->address_space, + mapping->space, addr - mapping->base, sizeof(unsigned_N), /* nr_bytes */ processor, @@ -78,7 +78,7 @@ XCONCAT2(core_map_write_,N)(core_map *map, unsigned_N data = H2T_N(val); if (mapping->writer(mapping->device, &data, - mapping->address_space, + mapping->space, addr - mapping->base, sizeof(unsigned_N), /* nr_bytes */ processor, diff --git a/sim/ppc/device_tree.c b/sim/ppc/device_tree.c index 78b6e1b624..0d9f7687ff 100644 --- a/sim/ppc/device_tree.c +++ b/sim/ppc/device_tree.c @@ -41,6 +41,14 @@ typedef enum { node_string } node_type; +static char *node_type_names[] = { + "any", + "device", + "integer", + "boolean", + "string", + NULL, +}; struct _device_tree { /* where i am */ @@ -89,6 +97,7 @@ typedef enum { STATIC_INLINE_DEVICE_TREE device_tree * device_tree_find_node(device_tree *root, const char *path, + const char *full_path, node_type type, device_tree_action action) { @@ -139,13 +148,13 @@ device_tree_find_node(device_tree *root, if (path[name_len] == '\0') { if (action == device_tree_grow) error("device_tree_find_node() node %s already present\n", - path); + full_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); + error("device_tree_find_node() node %s is not of type %s\n", + full_path, node_type_names[type]); } else return child; @@ -153,6 +162,7 @@ device_tree_find_node(device_tree *root, else return device_tree_find_node(child, path + name_len + 1, + full_path, type, action); } @@ -163,10 +173,15 @@ device_tree_find_node(device_tree *root, switch (action) { case device_tree_grow: if (path[name_len] != '\0') - error("device_tree_find_node() not a leaf %s\n", path); + error("device_tree_find_node() a parent of %s missing\n", + full_path); return new_device_tree(root, path, type); case device_tree_return_null: return NULL; + case device_tree_abort: + error("device_tree_find_node() could not find %s in tree\n", + full_path); + return NULL; default: error("device_tree_find_node() invalid default action %d\n", action); return NULL; @@ -180,14 +195,22 @@ 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); + device_tree *new_node; + TRACE(trace_device_tree, + ("device_tree_add_passthrough(root=0x%x, path=%s)\n", root, path)); + new_node = device_tree_find_node(root, + path, + path, /*full_path*/ + node_device, + device_tree_grow); new_node->device = device_create_from(new_node->name, + path, NULL, passthrough_device_callbacks(), new_node->parent->device); + + TRACE(trace_device_tree, + ("device_tree_add_passthrough() = 0x%x\n", new_node)); return new_node; } @@ -197,11 +220,18 @@ 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); + device_tree *new_node; + TRACE(trace_device_tree, + ("device_tree_add_device(root=0x%x, path=%s, dev=0x%x)\n", + root, path, dev)); + new_node = device_tree_find_node(root, + path, + path, /* full-path */ + node_device, + device_tree_grow); new_node->device = dev; + TRACE(trace_device_tree, + ("device_tree_add_device() = 0x%x\n", new_node)); return new_node; } @@ -210,11 +240,18 @@ device_tree_add_integer(device_tree *root, const char *path, signed_word integer) { - device_tree *new_node = device_tree_find_node(root, - path, - node_integer, - device_tree_grow); + device_tree *new_node; + TRACE(trace_device_tree, + ("device_tree_add_integer(root=0x%x, path=%s, integer=%d)\n", + root, path, integer)); + new_node = device_tree_find_node(root, + path, + path, /* full-name */ + node_integer, + device_tree_grow); new_node->integer = integer; + TRACE(trace_device_tree, + ("device_tree_add_integer() = 0x%x\n", new_node)); return new_node; } @@ -223,11 +260,18 @@ 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); + device_tree *new_node; + TRACE(trace_device_tree, + ("device_tree_add_device(root=0x%x, path=%s, string=%s)\n", + root, path, string)); + new_node = device_tree_find_node(root, + path, + path, /* full-name */ + node_string, + device_tree_grow); new_node->string = string; + TRACE(trace_device_tree, + ("device_tree_add_string() = 0x%x\n", new_node)); return new_node; } @@ -236,11 +280,18 @@ 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); + device_tree *new_node; + TRACE(trace_device_tree, + ("device_tree_add_boolean(root=0x%x, path=%s, boolean=%d)\n", + root, path, boolean)); + new_node = device_tree_find_node(root, + path, + path, /* full-name */ + node_boolean, + device_tree_grow); new_node->boolean = boolean; + TRACE(trace_device_tree, + ("device_tree_add_boolean() = 0x%x\n", new_node)); return new_node; } @@ -248,9 +299,16 @@ INLINE_DEVICE_TREE device_tree * device_tree_add_found_device(device_tree *root, const char *path) { - device_tree *new_node = device_tree_add_device(root, path, NULL); + device_tree *new_node; + TRACE(trace_device_tree, + ("device_tree_add_found_device(root=0x%x, path=%s)\n", + root, path)); + new_node = device_tree_add_device(root, path, NULL); new_node->device = device_create(new_node->name, + path, new_node->parent->device); + TRACE(trace_device_tree, + ("device_tree_add_found_device() = 0x%x\n", new_node)); return new_node; } @@ -261,10 +319,16 @@ INLINE_DEVICE_TREE const device * device_tree_find_device(device_tree *root, const char *path) { - device_tree *node = device_tree_find_node(root, - path, - node_device, - device_tree_abort); + device_tree *node; + TRACE(trace_device_tree, + ("device_tree_find_device(root=0x%x, path=%s)\n", root, path)); + node = device_tree_find_node(root, + path, + path, /* full-name */ + node_device, + device_tree_abort); + TRACE(trace_device_tree, + ("device_tree_find_device() = 0x%x\n", node->device)); return node->device; } @@ -272,10 +336,16 @@ 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); + device_tree *node; + TRACE(trace_device_tree, + ("device_tree_find_integer(root=0x%x, path=%s)\n", root, path)); + node = device_tree_find_node(root, + path, + path, /* full-name */ + node_integer, + device_tree_abort); + TRACE(trace_device_tree, + ("device_tree_find_integer() = %d\n", node->integer)); return node->integer; } @@ -283,10 +353,16 @@ INLINE_DEVICE_TREE const char * device_tree_find_string(device_tree *root, const char *path) { - device_tree *node = device_tree_find_node(root, - path, - node_string, - device_tree_abort); + device_tree *node; + TRACE(trace_device_tree, + ("device_tree_find_string(root=0x%x, path=%s)\n", root, path)); + node = device_tree_find_node(root, + path, + path, /* full-name */ + node_string, + device_tree_abort); + TRACE(trace_device_tree, + ("device_tree_find_string() = 0x%x\n", node->string)); return node->string; } @@ -294,10 +370,16 @@ 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); + device_tree *node; + TRACE(trace_device_tree, + ("device_tree_find_boolean(root=0x%x, path=%s)\n", root, path)); + node = device_tree_find_node(root, + path, + path, /* full-name */ + node_boolean, + device_tree_abort); + TRACE(trace_device_tree, + ("device_tree_find_boolean() = %d\n", node->boolean)); return node->boolean; } @@ -308,9 +390,14 @@ STATIC_INLINE_DEVICE_TREE void device_tree_init_device(device_tree *root, void *data) { - psim *system = (psim*)data; - if (root->type == node_device) + psim *system; + system = (psim*)data; + if (root->type == node_device) { + TRACE(trace_device_tree, + ("device_tree_init() initializing device=0x%x:%s\n", + root->device, root->device->full_name)); root->device->callback->init(root->device, system); + } } @@ -318,7 +405,11 @@ INLINE_DEVICE_TREE void device_tree_init(device_tree *root, psim *system) { + TRACE(trace_device_tree, + ("device_tree_init(root=0x%x, system=0x%x)\n", root, system)); device_tree_traverse(root, device_tree_init_device, NULL, system); + TRACE(trace_device_tree, + ("device_tree_init() = void\n")); } @@ -363,10 +454,6 @@ device_tree_dump(device_tree *device, /* Parse a device name, various formats */ -#ifndef __NetBSD__ -#define strtouq strtoul -#endif - #define SCAN_INIT(START, END, COUNT, NAME) \ char *START = NULL; \ char *END = strchr(NAME, '@'); \ @@ -377,7 +464,7 @@ device_tree_dump(device_tree *device, #define SCAN_U(START, END, COUNT, U) \ do { \ - *U = strtouq(START, &END, 0); \ + *U = strtoul(START, &END, 0); \ if (START == END) \ return COUNT; \ COUNT++; \ @@ -397,7 +484,7 @@ do { \ START = END + 1; \ } while (0) -#define SCAN_C(START, END, COUNT, C) \ +#define SCAN_C(START, END, COUNT, C, SIZE) \ do { \ char *chp = C; \ END = START; \ @@ -407,6 +494,8 @@ do { \ *chp = *END; \ chp += 1; \ END += 1; \ + if ((SIZE) <= ((END) - (START))) \ + return COUNT; /* overflow */ \ } \ *chp = '\0'; \ if (START == END) \ @@ -465,21 +554,21 @@ scand_uw_uw_u(const char *name, INLINE_DEVICE_TREE int scand_c(const char *name, - char *c1) + char *c1, int c1size) { SCAN_INIT(start, end, count, name); - SCAN_C(start, end, count, c1); + SCAN_C(start, end, count, c1, c1size); return count; } INLINE_DEVICE_TREE int scand_c_uw_u(const char *name, - char *c1, + char *c1, int c1size, unsigned_word *uw2, unsigned *u3) { SCAN_INIT(start, end, count, name); - SCAN_C(start, end, count, c1); + SCAN_C(start, end, count, c1, c1size); SCAN_U(start, end, count, uw2); SCAN_U(start, end, count, u3); return count; diff --git a/sim/ppc/device_tree.h b/sim/ppc/device_tree.h index d8e54819d3..bcd9bea433 100644 --- a/sim/ppc/device_tree.h +++ b/sim/ppc/device_tree.h @@ -110,7 +110,11 @@ INLINE_DEVICE_TREE void device_tree_dump void *ignore_data_argument); -/* Parse a device name, various formats */ +/* Parse a device name, various formats: + + uw: unsigned_word + u: unsigned + c: string */ INLINE_DEVICE_TREE int scand_uw (const char *name, @@ -135,11 +139,11 @@ INLINE_DEVICE_TREE int scand_uw_uw_u INLINE_DEVICE_TREE int scand_c (const char *name, - char *c1); + char *c1, int c1size); INLINE_DEVICE_TREE int scand_c_uw_u (const char *name, - char *c1, + char *c1, int c1size, unsigned_word *uw2, unsigned *u3); diff --git a/sim/ppc/devices.c b/sim/ppc/devices.c index 6b4d940496..c0813d6395 100644 --- a/sim/ppc/devices.c +++ b/sim/ppc/devices.c @@ -59,7 +59,7 @@ generic_init_callback(const device *me, me->parent->callback->attach_address(me->parent, me->name, attach_callback, - 0 /*address_space*/, + 0 /*space*/, addr, nr_bytes, access_read_write, @@ -81,7 +81,7 @@ INLINE_DEVICES void unimp_device_attach_address(const device *me, const char *name, attach_type type, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, access_type access, @@ -94,7 +94,7 @@ INLINE_DEVICES void unimp_device_detach_address(const device *me, const char *name, attach_type type, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, access_type access, @@ -106,7 +106,7 @@ unimp_device_detach_address(const device *me, INLINE_DEVICES unsigned unimp_device_io_read_buffer(const device *me, void *dest, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, @@ -119,7 +119,7 @@ unimp_device_io_read_buffer(const device *me, INLINE_DEVICES unsigned unimp_device_io_write_buffer(const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, @@ -132,7 +132,7 @@ unimp_device_io_write_buffer(const device *me, INLINE_DEVICES unsigned unimp_device_dma_read_buffer(const device *me, void *target, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes) { @@ -143,7 +143,7 @@ unimp_device_dma_read_buffer(const device *me, INLINE_DEVICES unsigned unimp_device_dma_write_buffer(const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, int violate_read_only_section) @@ -213,15 +213,16 @@ ignore_device_init(const device *me, INLINE_DEVICES void pass_device_attach_address(const device *me, const char *name, - attach_type type, - int address_space, + attach_type attach, + int 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, + DTRACE_ATTACH_ADDRESS(pass); + me->parent->callback->attach_address(me->parent, name, attach, + space, addr, nr_bytes, access, who); } @@ -229,39 +230,42 @@ pass_device_attach_address(const device *me, INLINE_DEVICES void pass_device_detach_address(const device *me, const char *name, - attach_type type, - int address_space, + attach_type attach, + int 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, + DTRACE_DETACH_ADDRESS(pass); + me->parent->callback->detach_address(me->parent, name, attach, + space, addr, nr_bytes, access, who); } INLINE_DEVICES unsigned pass_device_dma_read_buffer(const device *me, - void *target, - int address_space, + void *dest, + int space, unsigned_word addr, unsigned nr_bytes) { - return me->parent->callback->dma_read_buffer(me->parent, target, - address_space, addr, nr_bytes); + DTRACE_DMA_READ_BUFFER(pass); + return me->parent->callback->dma_read_buffer(me->parent, dest, + space, addr, nr_bytes); } INLINE_DEVICES unsigned pass_device_dma_write_buffer(const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, int violate_read_only_section) { + DTRACE_DMA_WRITE_BUFFER(pass); return me->parent->callback->dma_write_buffer(me->parent, source, - address_space, addr, + space, addr, nr_bytes, violate_read_only_section); } @@ -341,7 +345,7 @@ typedef enum { STATIC_INLINE_DEVICES unsigned console_io_read_buffer_callback(const device *me, void *dest, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, @@ -349,9 +353,7 @@ console_io_read_buffer_callback(const device *me, { console_device *console = (console_device*)me->data; unsigned_1 val; - TRACE(trace_console_device, - ("device=0x%x, addr=0x%x, nr_bytes=%d\n", - me, addr, nr_bytes)); + DTRACE_IO_READ_BUFFER(console); /* determine what was read */ @@ -416,7 +418,7 @@ console_io_read_buffer_callback(const device *me, STATIC_INLINE_DEVICES unsigned console_io_write_buffer_callback(const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, @@ -424,10 +426,7 @@ console_io_write_buffer_callback(const device *me, { console_device *console = (console_device*)me->data; unsigned_1 val = *(unsigned8*)source; - - TRACE(trace_console_device, - ("device=0x%x, addr=0x%x, nr_bytes=%d, val=%d\n", - me, addr, nr_bytes, val)); + DTRACE_IO_WRITE_BUFFER(console); switch (addr) { case console_read_buffer: @@ -437,8 +436,7 @@ console_io_write_buffer_callback(const device *me, console->input.status = val; break; case console_write_buffer: - TRACE(trace_console_device, - ("<%c:%d>", val, val)); + DTRACE(console, ("<%c:%d>", val, val)); printf_filtered("%c",val) ; console->output.buffer = val; console->output.status = 1; @@ -472,6 +470,7 @@ static device_callbacks const console_callbacks = { STATIC_INLINE_DEVICES const device * console_create(const char *name, + const char *full_name, const device *parent) { /* create the descriptor */ @@ -485,6 +484,7 @@ console_create(const char *name, /* insert into the device tree along with its address info */ return device_create_from(name, + full_name, console, /* data */ &console_callbacks, parent); @@ -507,16 +507,14 @@ console_create(const char *name, STATIC_INLINE_DEVICES unsigned icu_io_read_buffer_callback(const device *me, void *dest, - int address_space, - unsigned_word base, + int space, + unsigned_word addr, 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", - me, base, nr_bytes)); + DTRACE_IO_READ_BUFFER(icu); val = cpu_nr(processor); bzero(dest, nr_bytes); *(unsigned_1*)dest = val; @@ -527,17 +525,15 @@ icu_io_read_buffer_callback(const device *me, STATIC_INLINE_DEVICES unsigned icu_io_write_buffer_callback(const device *me, const void *source, - int address_space, - unsigned_word base, + int space, + unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { psim *system = cpu_system(processor); 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", - me, base, nr_bytes, val)); + DTRACE_IO_WRITE_BUFFER(icu); /* tell the parent device that the interrupt lines have changed. For this fake ICU. The interrupt lines just indicate the cpu to interrupt next */ @@ -575,12 +571,13 @@ static device_callbacks const icu_callbacks = { STATIC_INLINE_DEVICES unsigned halt_io_read_buffer_callback(const device *me, void *dest, - int address_space, - unsigned_word base, + int space, + unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { + DTRACE_IO_READ_BUFFER(halt); cpu_halt(processor, cia, was_exited, 0); return 0; } @@ -589,12 +586,13 @@ halt_io_read_buffer_callback(const device *me, STATIC_INLINE_DEVICES unsigned halt_io_write_buffer_callback(const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { + DTRACE_IO_WRITE_BUFFER(halt); cpu_halt(processor, cia, was_exited, 0); return 0; } @@ -630,7 +628,8 @@ register_init_callback(const device *me, unsigned_word value; unsigned which_cpu; int status; - status = scand_c_uw_u(me->name, name, &value, &which_cpu); + DTRACE_INIT(register); + status = scand_c_uw_u(me->name, name, sizeof(name), &value, &which_cpu); switch (status) { case 2: /* register@, */ psim_write_register(system, -1, &value, name, cooked_transfer); @@ -702,6 +701,7 @@ vm_init_callback(const device *me, psim *system) { vm_device *vm = (vm_device*)me->data; + DTRACE_INIT(vm); /* revert the stack/heap variables to their defaults */ vm->stack_lower_limit = vm->stack_bound; @@ -724,14 +724,15 @@ vm_init_callback(const device *me, STATIC_INLINE_DEVICES void vm_attach_address(const device *me, const char *name, - attach_type type, - int address_space, + attach_type attach, + int space, unsigned_word addr, unsigned nr_bytes, access_type access, const device *who) /*callback/default*/ { vm_device *vm = (vm_device*)me->data; + DTRACE_ATTACH_ADDRESS(vm); /* update end of bss if necessary */ if (vm->heap_base < addr + nr_bytes) { vm->heap_base = addr + nr_bytes; @@ -799,12 +800,13 @@ add_vm_space(const device *me, STATIC_INLINE_DEVICES unsigned vm_io_read_buffer_callback(const device *me, void *dest, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { + DTRACE_IO_READ_BUFFER(vm); if (add_vm_space(me, addr, nr_bytes, processor, cia) >= nr_bytes) { bzero(dest, nr_bytes); /* always initialized to zero */ return nr_bytes; @@ -817,15 +819,16 @@ vm_io_read_buffer_callback(const device *me, STATIC_INLINE_DEVICES unsigned vm_io_write_buffer_callback(const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { + DTRACE_IO_WRITE_BUFFER(vm); 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, + space, addr, nr_bytes, 0/*violate_read_only*/); } @@ -873,7 +876,8 @@ static device_callbacks const vm_callbacks = { STATIC_INLINE_DEVICES const device * vea_vm_create(const char *name, - const device *parent) + const char *full_name, + const device *parent) { vm_device *vm = ZALLOC(vm_device); unsigned_word addr; @@ -887,6 +891,7 @@ vea_vm_create(const char *name, /* insert in the tree including the buffer */ return device_create_from(name, + full_name, vm, /* data */ &vm_callbacks, parent); @@ -905,9 +910,20 @@ memory_init_callback(const device *me, unsigned_word addr; unsigned nr_bytes; unsigned access; + int nr_args; + DTRACE_INIT(memory); - if (scand_uw_u_u(me->name, &addr, &nr_bytes, &access) != 3) + nr_args = scand_uw_u_u(me->name, &addr, &nr_bytes, &access); + switch (nr_args) { + case 2: + access = access_read_write_exec; + break; + case 3: + break; + default: error("memory_init_callback() invalid memory device %s\n", me->name); + break; + } me->parent->callback->attach_address(me->parent, me->name, @@ -936,24 +952,6 @@ static device_callbacks const memory_callbacks = { }; -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@
@@ -963,7 +961,7 @@ STATIC_INLINE_DEVICES void iobus_attach_address_callback(const device *me, const char *name, attach_type type, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, access_type access, @@ -974,8 +972,8 @@ iobus_attach_address_callback(const device *me, 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", + if (space != 0) + error("iobus_attach_address_callback() no space for %s/%s\n", me->name, name); /* get the bus address */ if (scand_uw(me->name, &iobus_addr) != 1) @@ -984,7 +982,7 @@ iobus_attach_address_callback(const device *me, me->parent->callback->attach_address(me->parent, me->name, type, - 0 /*address_space*/, + 0 /*space*/, iobus_addr + addr, nr_bytes, access, @@ -1052,9 +1050,11 @@ file_init_callback(const device *me, psim *system) { unsigned_word addr; + unsigned count; char *file_name; char buf; FILE *image; + DTRACE_INIT(file); if ((file_name = strchr(me->name, ',')) == NULL || scand_uw(me->name, &addr) != 1) @@ -1067,14 +1067,17 @@ file_init_callback(const device *me, error("file_init_callback() file open failed for %s\n", me->name); /* read it in slowly */ + count = 0; 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++; + if (me->parent->callback->dma_write_buffer(me->parent, + &buf, + 0 /*address-space*/, + addr+count, + 1 /*nr-bytes*/, + 1 /*violate ro*/) != 1) + error("file_init_callback() failed to write to address 0x%x, offset %d\n", + addr+count, count); + count++; } /* close down again */ @@ -1115,6 +1118,7 @@ STATIC_INLINE_DEVICES void htab_init_callback(const device *me, psim *system) { + DTRACE_INIT(htab); /* only the pte does work */ if (strncmp(me->name, "pte@", strlen("pte@")) == 0) { unsigned_word htab_ra; @@ -1184,12 +1188,10 @@ static device_callbacks const sim_callbacks = { this device loads or maps the relevant text/data segments into memory using dma. */ -/* create a device tree from the image */ - STATIC_INLINE_DEVICES void -update_device_tree_for_section(bfd *abfd, - asection *the_section, - PTR obj) +update_for_binary_section(bfd *abfd, + asection *the_section, + PTR obj) { unsigned_word section_vma; unsigned_word section_size; @@ -1208,17 +1210,17 @@ update_device_tree_for_section(bfd *abfd, /* 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" : "" - )); + DTRACE(binary, + ("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; @@ -1251,7 +1253,7 @@ update_device_tree_for_section(bfd *abfd, } if (me->parent->callback->dma_write_buffer(me->parent, section_init, - 0 /*address_space*/, + 0 /*space*/, section_vma, section_size, 1 /*violate_read_only*/) @@ -1268,9 +1270,10 @@ binary_init_callback(const device *me, { char file_name[100]; bfd *image; + DTRACE_INIT(binary); /* get a file name */ - if (scand_c(me->name, file_name) != 1) + if (scand_c(me->name, file_name, sizeof(file_name)) != 1) error("load_binary_init_callback() invalid load-binary device %s\n", me->name); @@ -1291,7 +1294,7 @@ binary_init_callback(const device *me, /* and the data sections */ bfd_map_over_sections(image, - update_device_tree_for_section, + update_for_binary_section, (PTR)me); bfd_close(image); @@ -1371,18 +1374,17 @@ write_stack_arguments(psim *system, 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)); + DTRACE(stack, + ("write_stack_arguments(system=0x%x, arg=0x%x, start_block=0x%x, end_block=0x%x, start_arg=0x%x, end_arg=0x%x)\n", + system, arg, start_block, end_block, start_arg, end_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", + DTRACE(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, @@ -1402,6 +1404,8 @@ write_stack_arguments(psim *system, if (start_block != end_block || ALIGN_8(start_arg) != end_arg) error("write_stack_arguments - possible corruption\n"); + DTRACE(stack, + ("write_stack_arguments() = void\n")); } STATIC_INLINE_DEVICES void @@ -1500,10 +1504,16 @@ stack_ioctl_callback(const device *me, stack_pointer = va_arg(ap, unsigned_word); argv = va_arg(ap, char **); envp = va_arg(ap, char **); + va_end(ap); + DTRACE(stack, + ("stack_ioctl_callback(me=0x%x:%s, system=0x%x, processor=0x%x, cia=0x%x, argv=0x%x, envp=0x%x)\n", + me, me->full_name, system, processor, cia, argv, envp)); 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); + DTRACE(stack, + ("stack_ioctl_callback() = void\n")); } @@ -1529,6 +1539,7 @@ static device_callbacks const stack_callbacks = { typedef const device *(device_creator) (const char *name, + const char *full_name, const device *parent); typedef struct _device_descriptor device_descriptor; @@ -1540,7 +1551,7 @@ struct _device_descriptor { static device_descriptor devices[] = { { "console", console_create, NULL }, - { "memory", memory_create, NULL }, + { "memory", NULL, &memory_callbacks }, { "vm", vea_vm_create, NULL }, { "halt", NULL, &halt_callbacks }, { "icu", NULL, &icu_callbacks }, @@ -1559,6 +1570,7 @@ static device_descriptor devices[] = { INLINE_DEVICES const device * device_create(const char *name, + const char *full_name, const device *parent) { device_descriptor *device; @@ -1571,9 +1583,10 @@ device_create(const char *name, && (device->name[name_len] == '\0' || device->name[name_len] == '@')) if (device->creator != NULL) - return device->creator(name, parent); + return device->creator(name, full_name, parent); else return device_create_from(name, + full_name, NULL /* data */, device->callbacks, parent); @@ -1585,12 +1598,14 @@ device_create(const char *name, INLINE_DEVICES const device * device_create_from(const char *name, + const char *full_name, void *data, const device_callbacks *callback, const device *parent) { device *me = ZALLOC(device); me->name = strdup(name); + me->full_name = strdup(full_name); me->data = data; me->callback = callback; me->parent = parent; diff --git a/sim/ppc/devices.h b/sim/ppc/devices.h index df02288d51..fd22a549b8 100644 --- a/sim/ppc/devices.h +++ b/sim/ppc/devices.h @@ -79,6 +79,10 @@ typedef void (device_init_callback) (const device *me, psim *system); +#define DTRACE_INIT(OBJECT) \ + DTRACE(OBJECT, \ + (#OBJECT "_init(me=0x%x:%s system=0x%x)\n", \ + me, me->full_name, system)) /* Data transfers: @@ -160,17 +164,27 @@ typedef void (device_init_callback) typedef void (device_config_address_callback) (const device *me, const char *name, - attach_type type, - int address_space, + attach_type attach, + int space, unsigned_word addr, unsigned nr_bytes, access_type access, const device *who); /*callback/default*/ +#define DTRACE_ATTACH_ADDRESS(OBJECT) \ + DTRACE(OBJECT, \ + (#OBJECT "_attach_address(me=0x%x:%s, name=%s, attach=%d, space=%d, addr=0x%x, nr_bytes=%d, access=%d, who=0x%x)\n", \ + me, me->full_name, name, attach, space, addr, nr_bytes, access, who)) +#define DTRACE_DETACH_ADDRESS(OBJECT) \ + DTRACE(OBJECT, \ + (#OBJECT "_detach_address(me=0x%x:%s, name=%s, attach=%d, space=%d, addr=0x%x, nr_bytes=%d, access=%d, who=0x%x)\n", \ + me, me->full_name, name, attach, space, addr, nr_bytes, access, who)) + + typedef unsigned (device_io_read_buffer_callback) (const device *me, void *dest, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, @@ -179,27 +193,46 @@ typedef unsigned (device_io_read_buffer_callback) typedef unsigned (device_io_write_buffer_callback) (const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia); +#define DTRACE_IO_READ_BUFFER(OBJECT) \ + DTRACE(OBJECT, \ + (#OBJECT "_io_read_buffer(me=0x%x:%s dest=0x%x space=%d addr=0x%x nr_bytes=%d processor=0x%x cia=0x%x)\n", \ + me, me->full_name, dest, space, addr, nr_bytes, processor, cia)) +#define DTRACE_IO_WRITE_BUFFER(OBJECT) \ + DTRACE(OBJECT, \ + (#OBJECT "_io_write_buffer(me=0x%x:%s source=0x%x space=%d addr=0x%x nr_bytes=%d processor=0x%x cia=0x%x)\n", \ + me, me->full_name, source, space, addr, nr_bytes, processor, cia)) + + typedef unsigned (device_dma_read_buffer_callback) (const device *me, void *dest, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes); typedef unsigned (device_dma_write_buffer_callback) (const device *me, const void *source, - int address_space, + int space, unsigned_word addr, unsigned nr_bytes, int violate_read_only_section); +#define DTRACE_DMA_READ_BUFFER(OBJECT) \ + DTRACE(OBJECT, \ + (#OBJECT "_dma_read_buffer(me=0x%x:%s dest=0x%x space=%d addr=0x%x nr_bytes=%d)\n", \ + me, me->full_name, dest, space, addr, nr_bytes)) +#define DTRACE_DMA_WRITE_BUFFER(OBJECT) \ + DTRACE(OBJECT, \ + (#OBJECT "_dma_write_buffer(me=0x%x:%s source=0x%x space=%d addr=0x%x nr_bytes=%d)\n", \ + me, me->full_name, source, space, addr, nr_bytes)) + /* Interrupts: @@ -282,7 +315,8 @@ typedef struct _device_callbacks { /* A device */ struct _device { - const char *name; /* eg rom@0x1234, 0x400 */ + const char *name; /* eg rom@0x1234,0x400 */ + const char *full_name; /* eg /isa/rom@0x1234,0x400 */ void *data; /* device specific data */ const device_callbacks *callback; const device *parent; @@ -293,12 +327,14 @@ struct _device { INLINE_DEVICES const device *device_create (const char *name, + const char *full_name, const device *parent); /* create a new device using the parameterized data */ INLINE_DEVICES const device *device_create_from (const char *name, + const char *full_name, void *data, const device_callbacks *callback, const device *parent); diff --git a/sim/ppc/system.h b/sim/ppc/emul_netbsd.h similarity index 84% rename from sim/ppc/system.h rename to sim/ppc/emul_netbsd.h index 709d5c5c17..3bdb590627 100644 --- a/sim/ppc/system.h +++ b/sim/ppc/emul_netbsd.h @@ -19,15 +19,9 @@ */ -#ifndef _SYSTEM_H_ -#define _SYSTEM_H_ +#ifndef _EMUL_NETBSD_H_ +#define _EMUL_NETBSD_H_ -#ifndef INLINE_SYSTEM -#define INLINE_SYSTEM -#endif - -INLINE_SYSTEM void system_call -(cpu *processor, - unsigned_word cia); +extern emulation emul_netbsd; #endif diff --git a/sim/ppc/gen.c b/sim/ppc/gen.c deleted file mode 100644 index 76f1bcbf1b..0000000000 --- a/sim/ppc/gen.c +++ /dev/null @@ -1,3323 +0,0 @@ -/* This file is part of the program psim. - - Copyright (C) 1994-1995, Andrew Cagney - - 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. - - */ - - -/* BUGS: - - Instead of using/abusing macro's the semantic code should be parsed - and each `cachable' expression replaced with the corresponding - value. */ - - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "config.h" -#include "ppc-config.h" - -#undef WITH_ASSERT -#define WITH_ASSERT 1 - -#include "debug.h" - - -/****************************************************************/ - -static void -error (char *msg, ...) -{ - va_list ap; - va_start(ap, msg); - vprintf(msg, ap); - va_end(ap); - exit (1); -} - -static void * -zmalloc(long size) -{ - void *memory = malloc(size); - if (memory == NULL) - error("zmalloc failed\n"); - bzero(memory, size); - return memory; -} - -static void -dumpf (int indent, char *msg, ...) -{ - va_list ap; - for (; indent > 0; indent--) - printf(" "); - va_start(ap, msg); - vprintf(msg, ap); - va_end(ap); -} - - -/****************************************************************/ - -int idecode_expand_semantics = WITH_IDECODE_EXPAND_SEMANTICS; -int idecode_cache = WITH_IDECODE_CACHE; -int spreg_lookup_table = WITH_SPREG_LOOKUP_TABLE; - -/****************************************************************/ - -typedef struct { - int valid; - char *old_name; - char *new_name; - char *type; - char *expression; -} extraction_rules; - -extraction_rules cachable_values[] = WITH_IDECODE_CACHE_RULES; - -/****************************************************************/ - -typedef struct _opcode_rules { - int valid; - int first; - int last; - int force_first; - int force_last; - int force_slash; - char *force_expansion; - int use_switch; - unsigned special_mask; - unsigned special_value; - unsigned special_rule; -} 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*)%p\n", rule); - dumpf(indent, "(valid %d)\n", rule->valid); - ASSERT(rule != NULL); - if (rule->valid) { - dumpf(indent, "(first %d)\n", rule->first); - dumpf(indent, "(last %d)\n", rule->last); - dumpf(indent, "(force_first %d)\n", rule->force_first); - dumpf(indent, "(force_last %d)\n", rule->force_last); - dumpf(indent, "(force_slash %d)\n", rule->force_slash); - dumpf(indent, "(force_expansion %s)\n", rule->force_expansion); - } -} - - -/****************************************************************/ - -enum gen_constants { - insn_size = 32, - nr_of_sprs = 1024 -}; - -char cache_idecode_formal[] = "cpu *processor,\n instruction_word instruction,\n unsigned_word cia,\n idecode_cache *cache_entry"; -char cache_idecode_actual[] = "processor, instruction, cia, cache_entry"; -char cache_insn_formal[] = "cpu *processor,\n idecode_cache *cache_entry,\n unsigned_word cia"; -char cache_insn_actual[] = "processor, entry, cia"; - -char insn_formal[] = "cpu *processor,\n instruction_word instruction,\n unsigned_word cia"; -char insn_actual[] = "processor, instruction, cia"; - -char insn_local[] = "unsigned_word nia = cia + 4;"; - - -/****************************************************************/ - -static int -bin2i(char *bin, int width) -{ - int i = 0; - while (*bin != '\0' && width != 0) { - i = (i << 1) + (*bin - '0'); - width--; - bin++; - } - return i; -} - - -static int -it_is(char *flag, - char *flags) -{ - int flag_len = strlen(flag); - while (*flags != '\0') { - if (!strncmp(flags, flag, flag_len) - && (flags[flag_len] == ',' || flags[flag_len] == '\0')) - return 1; - while (*flags != ',') { - if (*flags == '\0') - return 0; - flags++; - } - flags++; - } - return 0; -} - - -/****************************************************************/ - -typedef struct _lf lf; -struct _lf { - FILE *stream; - int line_nr; /* nr complete lines written, curr line is line_nr+1 */ - int indent; - int line_blank; - char *file_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 = (real_name == NULL - ? name - : real_name); - - /* attach to stdout if pipe */ - if (!strcmp(name, "-")) { - new_lf->stream = stdout; - } - else { - /* create a new file */ - new_lf->stream = fopen(name, "w"); - ASSERT(new_lf->stream != NULL); - } - return new_lf; -} - - -static void -lf_close(lf *file) -{ - if (file->stream != stdout) { - if (fclose(file->stream)) { - perror("lf_close.fclose"); - exit(1); - } - free(file); - } -} - - -static void -lf_putchr(lf *file, - const char chr) -{ - if (chr == '\n') { - file->line_nr += 1; - file->line_blank = 1; - } - else if (file->line_blank) { - int pad; - for (pad = file->indent; pad > 0; pad--) - putc(' ', file->stream); - file->line_blank = 0; - } - putc(chr, file->stream); -} - -static void -lf_indent_suppress(lf *file) -{ - file->line_blank = 0; -} - - -static void -lf_putstr(lf *file, - const char *string) -{ - const char *chp; - if (string != NULL) { - for (chp = string; *chp != '\0'; chp++) { - lf_putchr(file, *chp); - } - } -} - -static void -do_lf_putunsigned(lf *file, - unsigned u) -{ - if (u > 0) { - do_lf_putunsigned(file, u / 10); - lf_putchr(file, (u % 10) + '0'); - } -} - - -static void -lf_putint(lf *file, - int decimal) -{ - if (decimal == 0) - lf_putchr(file, '0'); - else if (decimal < 0) { - lf_putchr(file, '-'); - do_lf_putunsigned(file, -decimal); - } - else if (decimal > 0) { - do_lf_putunsigned(file, decimal); - } - else - ASSERT(0); -} - -static void -lf_printf(lf *file, - const char *fmt, - ...) -{ - char buf[1024]; - va_list ap; - int nr_chars; - - va_start(ap, fmt); - vsprintf(buf, fmt, ap); - /* FIXME - this is really stuffed but so is vsprintf() on a sun! */ - ASSERT(strlen(buf) > 0 && strlen(buf) < sizeof(buf)); - lf_putstr(file, buf); - va_end(ap); -} - -static void -lf_print_file_line_nr(lf *file) -{ -#if WITH_LINE_NUMBERS - lf_indent_suppress(file); - lf_putstr(file, "#line "); - lf_putint(file, file->line_nr+2); /*line_nr == last_line, want next */ - lf_putstr(file, " \""); - lf_putstr(file, file->file_name); - lf_putstr(file, "\"\n"); -#endif -} - -static void -lf_indent(lf *file, int delta) -{ - file->indent += delta; -} - - -/****************************************************************/ - -/* read entries from ppc.instructions */ - -enum { - file_table_max_fields = 6, -}; - -typedef struct _file_table file_table; -struct _file_table { - size_t size; - char *buffer; - char *pos; - int line_nr; - char *file_name; -}; - -typedef struct _file_table_entry file_table_entry; -struct _file_table_entry { - char *fields[file_table_max_fields]; - int line_nr; - char *file_name; - char *annex; -}; - - -static file_table * -file_table_open(char *file_name) -{ - int fd; - struct stat stat_buf; - file_table *file; - - /* create a file descriptor */ - file = (file_table*)zmalloc(sizeof(file_table)); - ASSERT(file != NULL); - - /* save the file name */ - file->file_name = (char*)zmalloc(strlen(file_name) + 1); - ASSERT(file->file_name != NULL); - strcpy(file->file_name, file_name); - - /* open the file */ - fd = open(file->file_name, O_RDONLY, 0); - ASSERT(fd >= 0); - - /* determine the size */ - if (fstat(fd, &stat_buf) < 0) { - perror("file_table_open.fstat"); - exit(1); - } - file->size = stat_buf.st_size; - - /* allocate this much memory */ - file->buffer = (char*)zmalloc(file->size+1); - if(file->buffer == NULL) { - perror("file_table_open.calloc.file->size+1"); - exit(1); - } - file->pos = file->buffer; - - /* read it in */ - if (read(fd, file->buffer, file->size) < file->size) { - perror("file_table_open.read"); - exit(1); - } - file->buffer[file->size] = '\0'; - - /* done */ - close(fd); - return file; -} - - -static file_table_entry * -file_table_read(file_table *file) -{ - int field; - file_table_entry *entry; - - /* skip comments/blanks */ - while(1) { - /* leading white space */ - while (*file->pos != '\0' - && *file->pos != '\n' - && isspace(*file->pos)) - file->pos++; - /* comment */ - if (*file->pos == '#') { - do { - file->pos++; - } while (*file->pos != '\0' && *file->pos != '\n'); - } - /* end of line? */ - if (*file->pos == '\n') { - file->pos++; - file->line_nr++; - } - else - break; - } - if (*file->pos == '\0') - return NULL; - - /* create this new entry */ - entry = (file_table_entry*)zmalloc(sizeof(file_table_entry)); - ASSERT(entry != NULL); - entry->file_name = file->file_name; - - /* break the line into its colon delimitered fields */ - for (field = 0; field < file_table_max_fields-1; field++) { - entry->fields[field] = file->pos; - while(*file->pos && *file->pos != ':' && *file->pos != '\n') - file->pos++; - if (*file->pos == ':') { - *file->pos = '\0'; - file->pos++; - } - } - - /* any trailing stuff not the last field */ - ASSERT(field == file_table_max_fields-1); - entry->fields[field] = file->pos; - while (*file->pos && *file->pos != '\n') { - file->pos++; - } - if (*file->pos == '\n') { - *file->pos = '\0'; - file->pos++; - } - file->line_nr++; - entry->line_nr = file->line_nr; - - /* if following lines tab indented, put in the annex */ - if (*file->pos == '\t') { - entry->annex = file->pos; - do { - do { - file->pos++; - } while (*file->pos != '\0' && *file->pos != '\n'); - if (*file->pos == '\n') { - file->pos++; - file->line_nr++; - } - } while (*file->pos != '\0' && *file->pos == '\t'); - if (file->pos[-1] == '\n') - file->pos[-1] = '\0'; - } - else - entry->annex = NULL; - - /* return it */ - return entry; - -} - - -static void -dump_file_table_entry(file_table_entry *entry, - int indent) -{ - printf("(file_table_entry*)%p\n", entry); - - if (entry != NULL) { - int field; - char sep; - - sep = ' '; - dumpf(indent, "(fields"); - for (field = 0; field < file_table_max_fields; field++) { - printf("%c%s", sep, entry->fields[field]); - sep = ':'; - } - printf(")\n"); - - dumpf(indent, "(line_nr %d)\n", entry->line_nr); - - dumpf(indent, "(file_name %s)\n", entry->file_name); - - dumpf(indent, "(annex\n%s\n", entry->annex); - dumpf(indent, " )\n"); - - } -} - - -/****************************************************************/ - -typedef struct _insn_field insn_field; -struct _insn_field { - int first; - int last; - int width; - int is_int; - int is_slash; - int is_string; - int val_int; - char *pos_string; - char *val_string; - insn_field *next; - insn_field *prev; -}; - -typedef struct _insn_fields insn_fields; -struct _insn_fields { - insn_field *bits[insn_size]; - insn_field *first; - insn_field *last; - unsigned value; -}; - -static insn_field * -insn_field_new() -{ - insn_field *new_field = (insn_field*)zmalloc(sizeof(insn_field)); - ASSERT(new_field != NULL); - return new_field; -} - -static insn_fields * -insn_fields_new() -{ - insn_fields *new_fields = (insn_fields*)zmalloc(sizeof(insn_fields)); - ASSERT(new_fields != NULL); - return new_fields; -} - - -static insn_fields * -parse_insn_format(file_table_entry *entry, - char *format) -{ - char *chp; - insn_fields *fields = insn_fields_new(); - - /* create a leading sentinal */ - fields->first = insn_field_new(); - fields->first->first = -1; - fields->first->last = -1; - fields->first->width = 0; - - /* and a trailing sentinal */ - fields->last = insn_field_new(); - fields->last->first = insn_size; - fields->last->last = insn_size; - fields->last->width = 0; - - /* link them together */ - fields->first->next = fields->last; - fields->last->prev = fields->first; - - /* now work through the formats */ - chp = format; - - while (*chp != '\0') { - char *start_pos; - char *start_val; - int strlen_val; - int strlen_pos; - insn_field *new_field; - - /* sanity check */ - if (!isdigit(*chp)) { - error("%s:%d: missing position field at `%s'\n", - entry->file_name, entry->line_nr, chp); - } - - /* break out the bit position */ - start_pos = chp; - while (isdigit(*chp)) - chp++; - strlen_pos = chp - start_pos; - if (*chp == '.' && strlen_pos > 0) - chp++; - else { - 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 == '_'))) - chp++; - strlen_val = chp - start_val; - if (*chp == ',') - chp++; - else if (*chp != '\0' || strlen_val == 0) { - error("%s:%d: missing field terminator at %s\n", - entry->file_name, entry->line_nr, chp); - break; - } - - /* create a new field and insert it */ - new_field = insn_field_new(); - new_field->next = fields->last; - new_field->prev = fields->last->prev; - new_field->next->prev = new_field; - new_field->prev->next = new_field; - - /* the value */ - new_field->val_string = (char*)zmalloc(strlen_val+1); - strncpy(new_field->val_string, start_val, strlen_val); - if (isdigit(*new_field->val_string)) { - new_field->val_int = atoi(new_field->val_string); - new_field->is_int = 1; - } - else if (new_field->val_string[0] == '/') { - new_field->is_slash = 1; - } - else { - new_field->is_string = 1; - } - - /* the pos */ - new_field->pos_string = (char*)zmalloc(strlen_pos+1); - strncpy(new_field->pos_string, start_pos, strlen_pos); - new_field->first = atoi(new_field->pos_string); - new_field->last = new_field->next->first - 1; /* guess */ - new_field->width = new_field->last - new_field->first + 1; /* guess */ - new_field->prev->last = new_field->first-1; /*fix*/ - new_field->prev->width = new_field->first - new_field->prev->first; /*fix*/ - } - - /* fiddle first/last so that the sentinals `disapear' */ - ASSERT(fields->first->last < 0); - ASSERT(fields->last->first >= insn_size); - fields->first = fields->first->next; - fields->last = fields->last->prev; - - /* now go over this again, pointing each bit position at a field - record */ - { - int i; - insn_field *field; - field = fields->first; - for (i = 0; i < insn_size; i++) { - while (field->last < i) - field = field->next; - fields->bits[i] = field; - } - } - - /* go over each of the fields, and compute a `value' for the insn */ - { - insn_field *field; - fields->value = 0; - for (field = fields->first; - field->last < insn_size; - field = field->next) { - fields->value <<= field->width; - if (field->is_int) - fields->value |= field->val_int; - } - } - return fields; -} - - -typedef enum { - field_constant_int = 1, - field_constant_slash = 2, - field_constant_string = 3 -} constant_field_types; - - -static int -insn_field_is_constant(insn_field *field, - opcode_rules *rule) -{ - /* field is an integer */ - if (field->is_int) - return field_constant_int; - /* field is `/' and treating that as a constant */ - if (field->is_slash && rule->force_slash) - return field_constant_slash; - /* field, though variable is on the list */ - if (field->is_string && rule->force_expansion != NULL) { - char *forced_fields = rule->force_expansion; - while (*forced_fields != '\0') { - int field_len; - char *end = strchr(forced_fields, ','); - if (end == NULL) - field_len = strlen(forced_fields); - else - field_len = end-forced_fields; - if (strncmp(forced_fields, field->val_string, field_len) == 0 - && field->val_string[field_len] == '\0') - return field_constant_string; - forced_fields += field_len; - if (*forced_fields == ',') - forced_fields++; - } - } - return 0; -} - - -static void -dump_insn_field(insn_field *field, - int indent) -{ - - printf("(insn_field*)0x%x\n", (unsigned)field); - - dumpf(indent, "(first %d)\n", field->first); - - dumpf(indent, "(last %d)\n", field->last); - - dumpf(indent, "(width %d)\n", field->width); - - if (field->is_int) - dumpf(indent, "(is_int %d)\n", field->val_int); - - if (field->is_slash) - dumpf(indent, "(is_slash)\n"); - - if (field->is_string) - dumpf(indent, "(is_string `%s')\n", field->val_string); - - dumpf(indent, "(next 0x%x)\n", field->next); - - dumpf(indent, "(prev 0x%x)\n", field->prev); - - -} - -static void -dump_insn_fields(insn_fields *fields, - int indent) -{ - insn_field *field; - int i; - - printf("(insn_fields*)%p\n", fields); - - dumpf(indent, "(first 0x%x)\n", fields->first); - dumpf(indent, "(last 0x%x)\n", fields->last); - - dumpf(indent, "(value 0x%x)\n", fields->value); - - for (i = 0; i < insn_size; i++) { - dumpf(indent, "(bits[%d] ", i, fields->bits[i]); - dump_insn_field(fields->bits[i], indent+1); - dumpf(indent, " )\n"); - } - -} - - -/****************************************************************/ - -typedef struct _opcode_field opcode_field; -struct _opcode_field { - int first; - int last; - int is_boolean; - opcode_field *parent; -}; - -static opcode_field * -opcode_field_new() -{ - opcode_field *new_field = (opcode_field*)zmalloc(sizeof(opcode_field)); - ASSERT(new_field != NULL); - new_field->first = insn_size; - new_field->last = -1; - return new_field; -} - -static void -dump_opcode_field(opcode_field *field, int indent, int levels) -{ - printf("(opcode_field*)%p\n", field); - if (levels && field != NULL) { - dumpf(indent, "(first %d)\n", field->first); - dumpf(indent, "(last %d)\n", field->last); - dumpf(indent, "(is_boolean %d)\n", field->is_boolean); - dumpf(indent, "(parent "); - dump_opcode_field(field->parent, indent, levels-1); - } -} - - -/****************************************************************/ - -typedef struct _insn_bits insn_bits; -struct _insn_bits { - int is_expanded; - int value; - insn_field *field; - opcode_field *opcode; - insn_bits *last; -}; - -static insn_bits * -insn_bits_new() -{ - insn_bits *new_bits = (insn_bits*)zmalloc(sizeof(insn_bits)); - ASSERT(new_bits); - return new_bits; -} - - -static void -dump_insn_bits(insn_bits *bits, int indent, int levels) -{ - printf("(insn_bits*)%p\n", bits); - - if (levels && bits != NULL) { - dumpf(indent, "(value %d)\n", bits->value); - dumpf(indent, "(opcode "); - dump_opcode_field(bits->opcode, indent+1, 0); - dumpf(indent, " )\n"); - dumpf(indent, "(field "); - dump_insn_field(bits->field, indent+1); - dumpf(indent, " )\n"); - dumpf(indent, "(last "); - dump_insn_bits(bits->last, indent+1, levels-1); - } -} - - -/****************************************************************/ - - -typedef enum { - insn_format, - insn_form, - insn_flags, - insn_nmemonic, - insn_name, - insn_comment, - 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; - insn_fields *fields; - insn *next; -}; - -typedef struct _insn_table insn_table; -struct _insn_table { - int opcode_nr; - insn_bits *expanded_bits; - int nr_insn; - insn *insns; - insn *functions; - opcode_rules *opcode_rule; - opcode_field *opcode; - int nr_entries; - insn_table *entries; - insn_table *sibling; - insn_table *parent; -}; - - - -static insn * -insn_new() -{ - insn *new_entry = ((insn*) zmalloc(sizeof(insn))); - ASSERT(new_entry != NULL); - return new_entry; -} - -static insn_table * -insn_table_new() -{ - insn_table *new_table = (insn_table*)zmalloc(sizeof(insn_table)); - ASSERT(new_table != NULL); - return new_table; -} - - -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) -{ - insn **ptr_to_cur_insn = &table->insns; - insn *cur_insn = *ptr_to_cur_insn; - - /* create a new instruction */ - insn *new_insn = insn_new(); - new_insn->file_entry = file_entry; - new_insn->fields = fields; - - /* insert it according to the order of the fields */ - while (cur_insn != NULL - && new_insn->fields->value >= cur_insn->fields->value) { - ptr_to_cur_insn = &cur_insn->next; - cur_insn = *ptr_to_cur_insn; - } - - new_insn->next = cur_insn; - *ptr_to_cur_insn = new_insn; - - table->nr_insn++; -} - - -static opcode_field * -insn_table_find_opcode_field(insn *insns, - opcode_rules *rule, - int string_only) -{ - opcode_field *curr_opcode = opcode_field_new(); - insn *entry; - - ASSERT(rule->valid); - - for (entry = insns; entry != NULL; entry = entry->next) { - insn_fields *fields = entry->fields; - opcode_field new_opcode; - - /* find a start point for the opcode field */ - new_opcode.first = rule->first; - while (new_opcode.first <= rule->last - && (!string_only - || insn_field_is_constant(fields->bits[new_opcode.first], - rule) != field_constant_string) - && (string_only - || !insn_field_is_constant(fields->bits[new_opcode.first], - rule))) - new_opcode.first = fields->bits[new_opcode.first]->last + 1; - ASSERT(new_opcode.first > rule->last - || (string_only - && insn_field_is_constant(fields->bits[new_opcode.first], - rule) == field_constant_string) - || (!string_only - && insn_field_is_constant(fields->bits[new_opcode.first], - rule))); - - /* find the end point for the opcode field */ - new_opcode.last = rule->last; - while (new_opcode.last >= rule->first - && (!string_only - || insn_field_is_constant(fields->bits[new_opcode.last], - rule) != field_constant_string) - && (string_only - || !insn_field_is_constant(fields->bits[new_opcode.last], - rule))) - new_opcode.last = fields->bits[new_opcode.last]->first - 1; - ASSERT(new_opcode.last < rule->first - || (string_only - && insn_field_is_constant(fields->bits[new_opcode.last], - rule) == field_constant_string) - || (!string_only - && insn_field_is_constant(fields->bits[new_opcode.last], - rule))); - - /* now see if our current opcode needs expanding */ - if (new_opcode.first <= rule->last - && curr_opcode->first > new_opcode.first) - curr_opcode->first = new_opcode.first; - if (new_opcode.last >= rule->first - && curr_opcode->last < new_opcode.last) - curr_opcode->last = new_opcode.last; - - } - - /* was any thing interesting found? */ - if (curr_opcode->first > rule->last) { - ASSERT(curr_opcode->last < rule->first); - free(curr_opcode); - return NULL; - } - ASSERT(curr_opcode->last >= rule->first); - ASSERT(curr_opcode->first <= rule->last); - - /* if something was found, check it includes the forced field range */ - if (!string_only - && curr_opcode->first > rule->force_first) { - curr_opcode->first = rule->force_first; - } - if (!string_only - && curr_opcode->last < rule->force_last) { - curr_opcode->last = rule->force_last; - } - /* handle special case elminating any need to do shift after mask */ - if (string_only - && rule->force_last == insn_size-1) { - curr_opcode->last = insn_size-1; - } - - /* handle any special cases */ - switch (rule->special_rule) { - case 0: /* let the above apply */ - break; - case 1: /* expand a limited nr of bits, ignoring the rest */ - curr_opcode->first = rule->force_first; - curr_opcode->last = rule->force_last; - break; - case 2: /* boolean field */ - curr_opcode->is_boolean = 1; - break; - } - - return curr_opcode; -} - - -static void -insn_table_insert_expanded(insn_table *table, - insn *old_insn, - int new_opcode_nr, - insn_bits *new_bits) -{ - insn_table **ptr_to_cur_entry = &table->entries; - insn_table *cur_entry = *ptr_to_cur_entry; - - /* find the new table for this entry */ - while (cur_entry != NULL - && cur_entry->opcode_nr < new_opcode_nr) { - ptr_to_cur_entry = &cur_entry->sibling; - cur_entry = *ptr_to_cur_entry; - } - - if (cur_entry == NULL || cur_entry->opcode_nr != new_opcode_nr) { - insn_table *new_entry = insn_table_new(); - new_entry->opcode_nr = new_opcode_nr; - new_entry->expanded_bits = new_bits; - new_entry->opcode_rule = table->opcode_rule+1; - new_entry->sibling = cur_entry; - new_entry->parent = table; - *ptr_to_cur_entry = new_entry; - cur_entry = new_entry; - table->nr_entries++; - } - /* ASSERT new_bits == cur_entry bits */ - ASSERT(cur_entry != NULL && cur_entry->opcode_nr == new_opcode_nr); - insn_table_insert_insn(cur_entry, - old_insn->file_entry, - old_insn->fields); -} - -static void -insn_table_expand_opcode(insn_table *table, - insn *instruction, - int field_nr, - int opcode_nr, - insn_bits *bits) -{ - - if (field_nr > table->opcode->last) { - insn_table_insert_expanded(table, instruction, opcode_nr, bits); - } - else { - insn_field *field = instruction->fields->bits[field_nr]; - if (field->is_int || field->is_slash) { - ASSERT(field->first >= table->opcode->first - && field->last <= table->opcode->last); - insn_table_expand_opcode(table, instruction, field->last+1, - ((opcode_nr << field->width) + field->val_int), - bits); - } - else { - int val; - int last_pos = ((field->last < table->opcode->last) - ? field->last : table->opcode->last); - int first_pos = ((field->first > table->opcode->first) - ? field->first : table->opcode->first); - int width = last_pos - first_pos + 1; - int last_val = (table->opcode->is_boolean - ? 2 : (1 << width)); - for (val = 0; val < last_val; val++) { - insn_bits *new_bits = insn_bits_new(); - new_bits->field = field; - new_bits->value = val; - new_bits->last = bits; - new_bits->opcode = table->opcode; - insn_table_expand_opcode(table, instruction, last_pos+1, - ((opcode_nr << width) | val), - new_bits); - } - } - } -} - -static void -insn_table_insert_expanding(insn_table *table, - insn *entry) -{ - insn_table_expand_opcode(table, - entry, - table->opcode->first, - 0, - table->expanded_bits); -} - - -static void -insn_table_expand_insns(insn_table *table) -{ - - ASSERT(table->nr_insn >= 1); - - /* determine a valid opcode */ - while (table->opcode_rule->valid) { - /* specials only for single instructions */ - if ((table->nr_insn > 1 - && table->opcode_rule->special_mask == 0 - && table->opcode_rule->special_rule == 0) - || (table->nr_insn == 1 - && table->opcode_rule->special_mask != 0 - && ((table->insns->fields->value - & table->opcode_rule->special_mask) - == table->opcode_rule->special_value)) - || (idecode_expand_semantics - && table->opcode_rule->special_mask == 0 - && table->opcode_rule->special_rule == 0)) - table->opcode = - insn_table_find_opcode_field(table->insns, - table->opcode_rule, - table->nr_insn == 1/*string*/ - ); - if (table->opcode != NULL) - break; - table->opcode_rule++; - } - - /* did we find anything */ - if (table->opcode == NULL) { - return; - } - ASSERT(table->opcode != NULL); - - /* back link what we found to its parent */ - if (table->parent != NULL) { - ASSERT(table->parent->opcode != NULL); - table->opcode->parent = table->parent->opcode; - } - - /* expand the raw instructions according to the opcode */ - { - insn *entry; - for (entry = table->insns; entry != NULL; entry = entry->next) { - insn_table_insert_expanding(table, entry); - } - } - - /* and do the same for the sub entries */ - { - insn_table *entry; - for (entry = table->entries; entry != NULL; entry = entry->sibling) { - insn_table_expand_insns(entry); - } - } -} - - - -static insn_table * -insn_table_load_insns(char *file_name) -{ - file_table *file = file_table_open(file_name); - insn_table *table = insn_table_new(); - file_table_entry *file_entry; - table->opcode_rule = opcode_table; - - while ((file_entry = file_table_read(file)) != NULL) { - if (it_is("function", file_entry->fields[insn_flags]) - || it_is("internal", 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; -} - - -static void -dump_insn(insn *entry, int indent, int levels) -{ - printf("(insn*)%p\n", entry); - - if (levels && entry != NULL) { - - dumpf(indent, "(file_entry "); - dump_file_table_entry(entry->file_entry, indent+1); - dumpf(indent, " )\n"); - - dumpf(indent, "(fields "); - dump_insn_fields(entry->fields, indent+1); - dumpf(indent, " )\n"); - - dumpf(indent, "(next "); - dump_insn(entry->next, indent+1, levels-1); - dumpf(indent, " )\n"); - - } - -} - - -static void -dump_insn_table(insn_table *table, - int indent, int levels) -{ - - printf("(insn_table*)%p\n", table); - - if (levels && table != NULL) { - insn *entry; - - dumpf(indent, "(opcode_nr %d)\n", table->opcode_nr); - - dumpf(indent, "(expanded_bits "); - dump_insn_bits(table->expanded_bits, indent+1, -1); - dumpf(indent, " )\n"); - - dumpf(indent, "(int nr_insn %d)\n", table->nr_insn); - - dumpf(indent, "(insns "); - dump_insn(table->insns, indent+1, table->nr_insn); - dumpf(indent, " )\n"); - - dumpf(indent, "(opcode_rule "); - dump_opcode_rule(table->opcode_rule, indent+1); - dumpf(indent, " )\n"); - - dumpf(indent, "(opcode "); - dump_opcode_field(table->opcode, indent+1, 1); - dumpf(indent, " )\n"); - - dumpf(indent, "(nr_entries %d)\n", table->entries); - dumpf(indent, "(entries "); - dump_insn_table(table->entries, indent+1, table->nr_entries); - dumpf(indent, " )\n"); - - dumpf(indent, "(sibling ", table->sibling); - dump_insn_table(table->sibling, indent+1, levels-1); - dumpf(indent, " )\n"); - - dumpf(indent, "(parent ", table->parent); - dump_insn_table(table->parent, indent+1, 0); - dumpf(indent, " )\n"); - - } -} - - -/****************************************************************/ - - -static void -lf_print_copyleft(lf *file) -{ - lf_putstr(file, "\ -/* This file is part of psim (model of the PowerPC(tm) architecture) - - Copyright (C) 1994-1995, Andrew Cagney - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public License - as published by the Free Software Foundation; either version 2 of - the License, or (at your option) any later version. - - This library 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 - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - - -- - - PowerPC is a trademark of International Business Machines Corporation. - - -- - - This file was generated by the program gen */ -"); -} - - -static void -lf_print_c_line_nr(lf *file, file_table_entry *entry) -{ -#if WITH_LINE_NUMBERS - lf_indent_suppress(file); - lf_putstr(file, "#line "); - lf_putint(file, entry->line_nr); - lf_putstr(file, " \""); - lf_putstr(file, entry->file_name); - lf_putstr(file, "\"\n"); -#endif -} - - -static void -lf_print_c_code(lf *file, char *code) -{ - char *chp = code; - int in_bit_field = 0; - while (*chp != '\0') { - if (*chp == '\t') - chp++; - if (*chp == '#') - lf_indent_suppress(file); - while (*chp != '\0' && *chp != '\n') { - if (chp[0] == '{' && !isspace(chp[1])) { - in_bit_field = 1; - lf_putchr(file, '_'); - } - else if (in_bit_field && chp[0] == ':') { - lf_putchr(file, '_'); - } - else if (in_bit_field && *chp == '}') { - lf_putchr(file, '_'); - in_bit_field = 0; - } - else { - lf_putchr(file, *chp); - } - chp++; - } - if (in_bit_field) - error("bit field paren miss match some where\n"); - if (*chp == '\n') { - lf_putchr(file, '\n'); - chp++; - } - } - lf_putchr(file, '\n'); -} - - -static void -lf_print_binary(lf *file, int decimal, int width) -{ - int bit; - ASSERT(width > 0); - - for (bit = 1 << (width-1); bit != 0; bit >>= 1) { - if (decimal & bit) - lf_putchr(file, '1'); - else - lf_putchr(file, '0'); - } - -} - - -static void -lf_print_insn_bits(lf *file, insn_bits *bits) -{ - if (bits == NULL) - return; - lf_print_insn_bits(file, bits->last); - lf_putchr(file, '_'); - lf_putstr(file, bits->field->val_string); - if (!bits->opcode->is_boolean || bits->value == 0) { - if (bits->opcode->last < bits->field->last) - lf_putint(file, bits->value << (bits->field->last - bits->opcode->last)); - else - lf_putint(file, bits->value); - } -} - -static void -lf_print_opcodes(lf *file, - insn_table *table) -{ - if (table != NULL) { - while (1) { - lf_printf(file, "_%d_%d", - table->opcode->first, - table->opcode->last); - if (table->parent == NULL) break; - lf_printf(file, "__%d", table->opcode_nr); - table = table->parent; - } - } -} - -static void -lf_print_table_name(lf *file, - insn_table *table) -{ - lf_printf(file, "idecode_table"); - lf_print_opcodes(file, table); -} - - - -typedef enum { - function_name_prefix_semantics, - function_name_prefix_idecode, - function_name_prefix_none -} lf_function_name_prefixes; - -static void -lf_print_function_name(lf *file, - char *basename, - insn_bits *expanded_bits, - lf_function_name_prefixes prefix) -{ - - /* the prefix */ - switch (prefix) { - case function_name_prefix_semantics: - lf_putstr(file, "semantic_"); - break; - case function_name_prefix_idecode: - lf_printf(file, "idecode_"); - break; - default: - break; - } - - /* the function name */ - { - char *pos; - for (pos = basename; - *pos != '\0'; - pos++) { - switch (*pos) { - case '/': - case '-': - break; - case ' ': - lf_putchr(file, '_'); - break; - default: - lf_putchr(file, *pos); - break; - } - } - } - - /* the suffix */ - if (idecode_expand_semantics) - lf_print_insn_bits(file, expanded_bits); -} - - -static void -lf_print_idecode_table(lf *file, - insn_table *entry) -{ - int can_assume_leaf; - int rule; - - /* have a look at the rule table, if all table rules follow all - switch rules, I can assume that all end points are leaves */ - rule = 0; - while (opcode_table[rule].valid - && opcode_table[rule].use_switch) - rule++; - while (opcode_table[rule].valid - && !opcode_table[rule].use_switch - && !opcode_table[rule].special_rule) - rule++; - can_assume_leaf = !opcode_table[rule].valid; - - lf_printf(file, "{\n"); - lf_indent(file, +2); - { - lf_printf(file, "idecode_table_entry *table = "); - lf_print_table_name(file, entry); - lf_printf(file, ";\n"); - lf_printf(file, "int opcode = EXTRACTED32(instruction, %d, %d);\n", - entry->opcode->first, entry->opcode->last); - lf_printf(file, "idecode_table_entry *table_entry = table + opcode;\n"); - lf_printf(file, "while (1) {\n"); - lf_indent(file, +2); - { - lf_printf(file, "while (table_entry->mask != 0) {\n"); - lf_indent(file, +2); - { - lf_printf(file, "table = ((idecode_table_entry*)\n"); - lf_printf(file, " table_entry->function_or_table);\n"); - lf_printf(file, "opcode = ((instruction & table_entry->mask)\n"); - lf_printf(file, " >> table_entry->shift);\n"); - lf_printf(file, "table_entry = table + opcode;\n"); - } - lf_indent(file, -2); - lf_printf(file, "}\n"); - if (!idecode_cache && can_assume_leaf) { - lf_printf(file, "return (((idecode_semantic*)\n"); - lf_printf(file, " table_entry->function_or_table)\n"); - lf_printf(file, " (%s));\n", insn_actual); - } - else if (!idecode_cache && !can_assume_leaf) { - lf_printf(file, "if (table_entry->shift == 0)"); - lf_printf(file, " return (((idecode_semantic*)\n"); - lf_printf(file, " table_entry->function_or_table)\n"); - lf_printf(file, " (%s));\n", insn_actual); - } - else { - lf_printf(file, "if (table_entry->shift == 0)\n"); - lf_printf(file, " return (((idecode_crack*)\n"); - lf_printf(file, " table_entry->function_or_table)\n"); - lf_printf(file, " (%s));\n", cache_idecode_actual); - } - if (!can_assume_leaf) { - lf_printf(file, "opcode = (instruction & table_entry->shift) != 0;\n"); - lf_printf(file, "table = ((idecode_table_entry*)\n"); - lf_printf(file, " table_entry->function_or_table);\n"); - lf_printf(file, "table_entry = table + opcode;\n"); - } - } - lf_indent(file, -2); - lf_printf(file, "}\n"); - } - lf_indent(file, -2); - lf_printf(file, "}\n"); -} - - -static void -lf_print_my_prefix(lf *file, - file_table_entry *file_entry) -{ - lf_printf(file, "const char *const my_prefix = \n"); - lf_printf(file, " \"%s:%s:%d:cache\";\n", - file_entry->file_name, - file_entry->fields[insn_name], - file_entry->line_nr); -} - - -static void -lf_print_ptrace(lf *file) -{ - lf_printf(file, "\n"); - lf_putstr(file, "ITRACE(trace_semantics, (\"cia=0x%x\\n\", cia));\n"); -} - - -/****************************************************************/ - -typedef void leaf_handler -(insn_table *entry, - void *data, - int depth); -typedef void padding_handler -(insn_table *table, - void *data, - int depth, - int opcode_nr); - - -static void -insn_table_traverse_tree(insn_table *table, - void *data, - int depth, - leaf_handler *start, - leaf_handler *leaf, - leaf_handler *end, - padding_handler *padding) -{ - insn_table *entry; - int entry_nr; - - ASSERT(table != NULL - && table->opcode != NULL - && table->nr_entries > 0 - && table->entries != 0); - - if (start != NULL && depth >= 0) - start(table, data, depth); - - for (entry_nr = 0, entry = table->entries; - entry_nr < (table->opcode->is_boolean - ? 2 - : (1 << (table->opcode->last - table->opcode->first + 1))); - entry_nr ++) { - if (entry == NULL - || (!table->opcode->is_boolean - && entry_nr < entry->opcode_nr)) { - if (padding != NULL && depth >= 0) - padding(table, data, depth, entry_nr); - } - else { - ASSERT(entry != NULL && (entry->opcode_nr == entry_nr - || table->opcode->is_boolean)); - if (entry->opcode != NULL && depth != 0) { - insn_table_traverse_tree(entry, data, depth+1, - start, leaf, end, padding); - } - else if (depth >= 0) { - if (leaf != NULL) - leaf(entry, data, depth); - } - entry = entry->sibling; - } - } - if (end != NULL && depth >= 0) - end(table, data, depth); -} - - -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); - -static void -insn_table_traverse_insn(insn_table *table, - void *data, - insn_handler *leaf) -{ - insn *instruction; - for (instruction = table->insns; - instruction != NULL; - instruction = instruction->next) { - leaf(table, data, instruction); - } -} - - -static void -update_depth(insn_table *entry, - void *data, - int depth) -{ - int *max_depth = (int*)data; - if (*max_depth < depth) - *max_depth = depth; -} - - -static int -insn_table_depth(insn_table *table) -{ - int depth = 0; - insn_table_traverse_tree(table, - &depth, - 1, - NULL, /*start*/ - update_depth, - NULL, /*end*/ - NULL); /*padding*/ - return depth; -} - - -/****************************************************************/ - -static void -dump_traverse_start(insn_table *table, - void *data, - int depth) -{ - dumpf(depth*2, "(%d\n", table->opcode_nr); -} - -static void -dump_traverse_leaf(insn_table *entry, - void *data, - int depth) -{ - ASSERT(entry->nr_entries == 0 - && entry->nr_insn == 1 - && entry->opcode == NULL); - dumpf(depth*2, ".%d %s\n", entry->opcode_nr, - entry->insns->file_entry->fields[insn_format]); -} - -static void -dump_traverse_end(insn_table *table, - void *data, - int depth) -{ - dumpf(depth*2, ")\n"); -} - -static void -dump_traverse_padding(insn_table *table, - void *data, - int depth, - int opcode_nr) -{ - dumpf(depth*2, ".<%d>\n", opcode_nr); -} - - -static void -dump_traverse(insn_table *table) -{ - insn_table_traverse_tree(table, NULL, 1, - dump_traverse_start, - dump_traverse_leaf, - dump_traverse_end, - dump_traverse_padding); -} - - -/****************************************************************/ - - -static void -semantics_h_print_function(lf *file, - char *basename, - insn_bits *expanded_bits) -{ - lf_printf(file, "\n"); - lf_printf(file, "INLINE_SEMANTICS unsigned_word "); - lf_print_function_name(file, - basename, - expanded_bits, - function_name_prefix_semantics); - lf_printf(file, "\n(%s);\n", - (idecode_cache ? cache_insn_formal : insn_formal)); -} - - -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->file_entry->fields[insn_name], - entry->expanded_bits); -} - -static void -semantics_h_insn(insn_table *entry, - void *data, - insn *instruction) -{ - lf *file = (lf*)data; - 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]); - } -} - - -static void -gen_semantics_h(insn_table *table, lf *file) -{ - - lf_print_copyleft(file); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef _SEMANTICS_H_\n"); - lf_printf(file, "#define _SEMANTICS_H_\n"); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef INLINE_SEMANTICS\n"); - lf_printf(file, "#define INLINE_SEMANTICS\n"); - lf_printf(file, "#endif\n"); - 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, - 1, - NULL, /* start */ - semantics_h_leaf, /* leaf */ - NULL, /* end */ - NULL); /* padding */ - else - insn_table_traverse_insn(table, - file, - semantics_h_insn); - - lf_printf(file, "\n"); - lf_printf(file, "#endif /* _SEMANTICS_H_ */\n"); - -} - -/****************************************************************/ - -typedef struct _icache_tree icache_tree; -struct _icache_tree { - char *name; - icache_tree *next; - icache_tree *children; -}; - -static icache_tree * -icache_tree_new() -{ - icache_tree *new_tree = (icache_tree*)zmalloc(sizeof(icache_tree)); - ASSERT(new_tree != NULL); - return new_tree; -} - -static icache_tree * -icache_tree_insert(icache_tree *tree, - char *name) -{ - icache_tree *new_tree; - /* find it */ - icache_tree **ptr_to_cur_tree = &tree->children; - icache_tree *cur_tree = *ptr_to_cur_tree; - while (cur_tree != NULL - && strcmp(cur_tree->name, name) < 0) { - ptr_to_cur_tree = &cur_tree->next; - cur_tree = *ptr_to_cur_tree; - } - ASSERT(cur_tree == NULL - || strcmp(cur_tree->name, name) >= 0); - /* already in the tree */ - if (cur_tree != NULL - && strcmp(cur_tree->name, name) == 0) - return cur_tree; - /* missing, insert it */ - ASSERT(cur_tree == NULL - || strcmp(cur_tree->name, name) > 0); - new_tree = icache_tree_new(); - new_tree->name = name; - new_tree->next = cur_tree; - *ptr_to_cur_tree = new_tree; - return new_tree; -} - - -static icache_tree * -insn_table_cache_fields(insn_table *table) -{ - icache_tree *tree = icache_tree_new(); - insn *instruction; - for (instruction = table->insns; - instruction != NULL; - instruction = instruction->next) { - insn_field *field; - icache_tree *form = - icache_tree_insert(tree, - instruction->file_entry->fields[insn_form]); - for (field = instruction->fields->first; - field != NULL; - field = field->next) { - if (field->is_string) - icache_tree_insert(form, field->val_string); - } - } - return tree; -} - - - -static void -gen_icache_h(icache_tree *tree, - lf *file) -{ - lf_print_copyleft(file); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef _ICACHE_H_\n"); - lf_printf(file, "#define _ICACHE_H_\n"); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef INLINE_ICACHE\n"); - lf_printf(file, "#define INLINE_ICACHE\n"); - lf_printf(file, "#endif\n"); - lf_printf(file, "\n"); - lf_printf(file, "\n"); - - /* create an instruction cache if being used */ - if (idecode_cache) { - icache_tree *form; - lf_printf(file, "typedef struct _idecode_cache {\n"); - lf_printf(file, " unsigned_word address;\n"); - lf_printf(file, " void *semantic;\n"); - lf_printf(file, " union {\n"); - for (form = tree->children; - form != NULL; - form = form->next) { - icache_tree *field; - lf_printf(file, " struct {\n"); - for (field = form->children; - field != NULL; - field = field->next) { - extraction_rules *rule; - int found_rule = 0; - for (rule = cachable_values; - rule->valid; - rule++) { - if (strcmp(field->name, rule->old_name) == 0) { - found_rule = 1; - if (rule->new_name != NULL) - lf_printf(file, " %s %s; /* %s */\n", - rule->type == NULL ? "unsigned" : rule->type, - rule->new_name, rule->old_name); - } - } - if (!found_rule) - lf_printf(file, " unsigned %s;\n", field->name); - } - lf_printf(file, " } %s;\n", form->name); - } - lf_printf(file, " } crack;\n"); - lf_printf(file, "} idecode_cache;\n"); - } - else { - /* alernativly, since no cache, #define the fields to be - extractions from the instruction variable */ - extraction_rules *rule; - lf_printf(file, "\n"); - for (rule = cachable_values; - rule->valid; - rule++) { - if (rule->expression != NULL) - lf_printf(file, "#define %s %s\n", - rule->new_name, rule->expression); - } - } - - lf_printf(file, "\n"); - lf_printf(file, "#endif /* _ICACHE_H_ */\n"); -} - - - - -/****************************************************************/ - - -static void -lf_print_c_extraction(lf *file, - insn *instruction, - char *field_name, - char *field_type, - char *field_expression, - insn_field *cur_field, - insn_bits *bits, - int get_value_from_cache, - int put_value_in_cache) -{ - ASSERT(field_name != NULL); - if (bits != NULL - && (!bits->opcode->is_boolean || bits->value == 0) - && strcmp(field_name, cur_field->val_string) == 0) { - ASSERT(bits->field == cur_field); - ASSERT(field_type == NULL); - lf_print_c_line_nr(file, instruction->file_entry); - lf_printf(file, "const unsigned %s = ", - field_name); - if (bits->opcode->last < bits->field->last) - lf_printf(file, "%d;\n", - bits->value << (bits->field->last - bits->opcode->last)); - else - lf_printf(file, "%d;\n", bits->value); - } - else { - /* put the field in the local variable */ - lf_print_c_line_nr(file, instruction->file_entry); - lf_printf(file, "%s const %s = ", - field_type == NULL ? "unsigned" : field_type, - field_name); - /* getting it from the cache */ - if (get_value_from_cache || put_value_in_cache) { - lf_printf(file, "cache_entry->crack.%s.%s", - instruction->file_entry->fields[insn_form], - field_name); - if (put_value_in_cache) /* also put it in the cache? */ - lf_printf(file, " = "); - } - if (!get_value_from_cache) { - if (strcmp(field_name, cur_field->val_string) == 0) - lf_printf(file, "EXTRACTED32(instruction, %d, %d)", - cur_field->first, cur_field->last); - else if (field_expression != NULL) - lf_printf(file, "%s", field_expression); - else - lf_printf(file, "eval_%s", field_name); - } - lf_printf(file, ";\n"); - } -} - - -static void -lf_print_c_extractions(lf *file, - insn *instruction, - insn_bits *expanded_bits, - int get_value_from_cache, - int put_value_in_cache) -{ - insn_field *cur_field; - - /* extract instruction fields */ - lf_printf(file, "/* extraction: %s */\n", - instruction->file_entry->fields[insn_format]); - - for (cur_field = instruction->fields->first; - cur_field->first < insn_size; - cur_field = cur_field->next) { - if (cur_field->is_string) { - insn_bits *bits; - int found_rule = 0; - /* find any corresponding value */ - for (bits = expanded_bits; - bits != NULL; - bits = bits->last) { - if (bits->field == cur_field) - break; - } - /* try the cache rule table for what to do */ - if (get_value_from_cache || put_value_in_cache) { - extraction_rules *field_rule; - for (field_rule = cachable_values; - field_rule->valid; - field_rule++) { - if (strcmp(cur_field->val_string, field_rule->old_name) == 0) { - found_rule = 1; - if (field_rule->valid > 1 && put_value_in_cache) - lf_print_c_extraction(file, - instruction, - field_rule->new_name, - field_rule->type, - field_rule->expression, - cur_field, - bits, - 0, - 0); - else if (field_rule->valid == 1) - lf_print_c_extraction(file, - instruction, - field_rule->new_name, - field_rule->type, - field_rule->expression, - cur_field, - bits, - get_value_from_cache, - put_value_in_cache); - } - } - } - if (found_rule == 0) - lf_print_c_extraction(file, - instruction, - cur_field->val_string, - 0, - 0, - cur_field, - bits, - get_value_from_cache, - put_value_in_cache); - /* if any (XXX == 0), output a corresponding test */ - if (instruction->file_entry->annex != NULL) { - char *field_name = cur_field->val_string; - char *is_0_ptr = instruction->file_entry->annex; - int field_len = strlen(field_name); - if (strlen(is_0_ptr) >= (strlen("_is_0") + field_len)) { - is_0_ptr += field_len; - while ((is_0_ptr = strstr(is_0_ptr, "_is_0")) != NULL) { - if (strncmp(is_0_ptr - field_len, field_name, field_len) == 0 - && !isalpha(is_0_ptr[ - field_len - 1])) { - lf_print_c_line_nr(file, instruction->file_entry); - lf_printf(file, "const unsigned %s_is_0 = (", field_name); - if (bits != NULL) - lf_printf(file, "%d", bits->value); - else - lf_printf(file, "%s", field_name); - lf_printf(file, " == 0);\n"); - break; - } - is_0_ptr += strlen("_is_0"); - } - } - } - /* any thing else ... */ - } - } - lf_print_file_line_nr(file); -} - - -static void -lf_print_idecode_illegal(lf *file) -{ - if (idecode_cache) - lf_printf(file, "return idecode_illegal(%s);\n", cache_idecode_actual); - else - lf_printf(file, "return semantic_illegal(%s);\n", insn_actual); -} - - -static void -lf_print_idecode_floating_point_unavailable(lf *file) -{ - if (idecode_cache) - lf_printf(file, "return idecode_floating_point_unavailable(%s);\n", - cache_idecode_actual); - else - lf_printf(file, "return semantic_floating_point_unavailable(%s);\n", - insn_actual); -} - - -/* Output code to do any final checks on the decoded instruction. - This includes things like verifying any on decoded fields have the - correct value and checking that (for floating point) floating point - hardware isn't disabled */ - -static void -lf_print_c_validate(lf *file, - insn *instruction, - opcode_field *opcodes) -{ - /* Validate: unchecked instruction fields - - If any constant fields in the instruction were not checked by the - idecode tables, output code to check that they have the correct - value here */ - { - unsigned check_mask = 0; - unsigned check_val = 0; - insn_field *field; - opcode_field *opcode; - - /* form check_mask/check_val containing what needs to be checked - in the instruction */ - for (field = instruction->fields->first; - field->first < insn_size; - field = field->next) { - - check_mask <<= field->width; - check_val <<= field->width; - - /* is it a constant that could need validating? */ - if (!field->is_int && !field->is_slash) - continue; - - /* has it been checked by a table? */ - for (opcode = opcodes; opcode != NULL; opcode = opcode->parent) { - if (field->first >= opcode->first - && field->last <= opcode->last) - break; - } - if (opcode != NULL) - continue; - - check_mask |= (1 << field->width)-1; - check_val |= field->val_int; - } - - /* if any bits not checked by opcode tables, output code to check them */ - 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", - check_mask, check_val); - lf_indent(file, +2); - lf_print_idecode_illegal(file); - lf_indent(file, -2); - } - } - - /* Validate floating point hardware - - If the simulator is being built with out floating point hardware - (different to it being disabled in the MSR) then floating point - instructions are invalid */ - { - if (it_is("f", instruction->file_entry->fields[insn_flags])) { - lf_printf(file, "\n"); - lf_printf(file, "/* Validate: 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); - } - } - - /* Validate: Floating Point available - - If floating point is not available, we enter a floating point - unavailable interrupt into the cache instead of the instruction - proper. - - The PowerPC spec requires a CSI after MSR[FP] is changed and when - ever a CSI occures we flush the instruction cache. */ - - { - if (it_is("f", instruction->file_entry->fields[insn_flags])) { - lf_printf(file, "\n"); - lf_printf(file, "/* Validate: FP available according to MSR[FP] */\n"); - lf_printf(file, "if (!IS_FP_AVAILABLE(processor))\n"); - lf_indent(file, +2); - lf_print_idecode_floating_point_unavailable(file); - lf_indent(file, -2); - } - } -} - - -static void -lf_print_c_cracker(lf *file, - insn *instruction, - insn_bits *expanded_bits, - opcode_field *opcodes) -{ - - /* function header */ - lf_printf(file, "{\n"); - lf_indent(file, +2); - - lf_print_my_prefix(file, - instruction->file_entry); - - lf_print_ptrace(file); - - lf_print_c_validate(file, instruction, opcodes); - - lf_printf(file, "\n"); - lf_printf(file, "{\n"); - lf_indent(file, +2); - lf_print_c_extractions(file, - instruction, - expanded_bits, - 0/*get_value_from_cache*/, - 1/*put_value_in_cache*/); - lf_indent(file, -2); - lf_printf(file, "}\n"); - - /* return the function propper (main sorts this one out) */ - lf_printf(file, "\n"); - lf_printf(file, "/* semantic routine */\n"); - lf_print_c_line_nr(file, instruction->file_entry); - lf_printf(file, "return "); - lf_print_function_name(file, - instruction->file_entry->fields[insn_name], - expanded_bits, - function_name_prefix_semantics); - lf_printf(file, ";\n"); - - lf_print_file_line_nr(file); - lf_indent(file, -2); - lf_printf(file, "}\n"); -} - - -static void -lf_print_c_semantic(lf *file, - insn *instruction, - insn_bits *expanded_bits, - opcode_field *opcodes) -{ - - lf_printf(file, "{\n"); - lf_indent(file, +2); - - lf_print_my_prefix(file, - instruction->file_entry); - lf_putstr(file, insn_local); - lf_printf(file, "\n"); - - lf_printf(file, "\n"); - lf_print_c_extractions(file, - instruction, - expanded_bits, - idecode_cache/*get_value_from_cache*/, - 0/*put_value_in_cache*/); - - lf_print_ptrace(file); - - /* validate the instruction, if a cache this has already been done */ - if (!idecode_cache) - lf_print_c_validate(file, instruction, opcodes); - - /* generate the code (or at least something */ - if (instruction->file_entry->annex != NULL) { - /* true code */ - lf_printf(file, "\n"); - lf_print_c_line_nr(file, instruction->file_entry); - lf_printf(file, "{\n"); - lf_indent(file, +2); - lf_print_c_code(file, instruction->file_entry->annex); - lf_indent(file, -2); - lf_printf(file, "}\n"); - lf_print_file_line_nr(file); - } - else if (it_is("nop", instruction->file_entry->fields[insn_flags])) { - lf_print_file_line_nr(file); - } - else if (it_is("f", instruction->file_entry->fields[insn_flags])) { - /* 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); - } - else { - /* abort so it is implemented now */ - lf_print_c_line_nr(file, instruction->file_entry); - lf_putstr(file, "error(\"%s: unimplemented, cia=0x%x\\n\", my_prefix, cia);\n"); - lf_print_file_line_nr(file); - lf_printf(file, "\n"); - } - - /* the function footer */ - lf_printf(file, "return nia;\n"); - lf_indent(file, -2); - lf_printf(file, "}\n"); -} - -static void -lf_print_c_semantic_function_header(lf *file, - char *basename, - insn_bits *expanded_bits) -{ - lf_printf(file, "\n"); - lf_printf(file, "INLINE_SEMANTICS unsigned_word\n"); - lf_print_function_name(file, - basename, - expanded_bits, - function_name_prefix_semantics); - lf_printf(file, "\n(%s)\n", - (idecode_cache ? 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_printf(file, "{\n"); - lf_indent(file, +2); - lf_printf(file, "cpu_increment_number_of_insns (processor);\n"); - - lf_print_c_semantic(file, - instruction, - expanded_bits, - opcodes); - - lf_indent(file, -2); - lf_printf(file, "}\n"); -} - - -static void -semantics_c_leaf(insn_table *entry, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(entry->nr_insn == 1 - && entry->opcode == NULL - && entry->parent != NULL - && entry->parent->opcode != NULL); - lf_print_c_semantic_function(file, - entry->insns, - entry->expanded_bits, - entry->parent->opcode); -} - -static void -semantics_c_insn(insn_table *table, - void *data, - insn *instruction) -{ - lf *file = (lf*)data; - lf_print_c_semantic_function(file, instruction, - 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); -} - - - -static void -gen_semantics_c(insn_table *table, lf *file) -{ - lf_print_copyleft(file); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef _SEMANTICS_C_\n"); - lf_printf(file, "#define _SEMANTICS_C_\n"); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef STATIC_INLINE_SEMANTICS\n"); - lf_printf(file, "#define STATIC_INLINE_SEMANTICS STATIC_INLINE\n"); - lf_printf(file, "#endif\n"); - lf_printf(file, "\n"); - lf_printf(file, "#include \"cpu.h\"\n"); - lf_printf(file, "#include \"idecode.h\"\n"); - 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, - 1, - NULL, /* start */ - semantics_c_leaf, - NULL, /* end */ - NULL); /* padding */ - else - insn_table_traverse_insn(table, - file, - semantics_c_insn); - - lf_printf(file, "\n"); - lf_printf(file, "#endif /* _SEMANTICS_C_ */\n"); -} - - -/****************************************************************/ - -static void -gen_idecode_h(insn_table *table, lf *file) -{ - lf_print_copyleft(file); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef _IDECODE_H_\n"); - lf_printf(file, "#define _IDECODE_H_\n"); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef INLINE_IDECODE\n"); - lf_printf(file, "#define INLINE_IDECODE\n"); - lf_printf(file, "#endif\n"); - lf_printf(file, "\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"); - lf_printf(file, "\n"); - lf_printf(file, "#include \"icache.h\"\n"); - lf_printf(file, "\n"); - lf_printf(file, "typedef unsigned_word idecode_semantic\n(%s);\n", - (idecode_cache ? cache_insn_formal : insn_formal)); - lf_printf(file, "\n"); - if (idecode_cache) - lf_printf(file, "INLINE_IDECODE idecode_semantic *idecode\n(%s);\n", - cache_idecode_formal); - else - lf_printf(file, "INLINE_IDECODE unsigned_word idecode_issue\n(%s);\n", - insn_formal); - lf_printf(file, "\n"); - lf_printf(file, "#endif /* _IDECODE_H_ */\n"); -} - - -/****************************************************************/ - - -static void -idecode_table_start(insn_table *table, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(depth == 0); - /* start of the table */ - if (!table->opcode_rule->use_switch) { - lf_printf(file, "\n"); - lf_printf(file, "static idecode_table_entry "); - lf_print_table_name(file, table); - lf_printf(file, "[] = {\n"); - } -} - -static void -idecode_table_leaf(insn_table *entry, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(entry->parent != NULL); - ASSERT(depth == 0); - - /* add an entry to the table */ - if (!entry->parent->opcode_rule->use_switch) { - if (entry->opcode == NULL) { - /* table leaf entry */ - lf_printf(file, " /*%d*/ { 0, 0, ", entry->opcode_nr); - lf_print_function_name(file, - entry->insns->file_entry->fields[insn_name], - entry->expanded_bits, - (idecode_cache - ? function_name_prefix_idecode - : function_name_prefix_semantics)); - lf_printf(file, " },\n"); - } - else if (entry->opcode_rule->use_switch) { - /* table calling switch statement */ - lf_printf(file, " /*%d*/ { -1, 0, ", - entry->opcode_nr); - lf_print_table_name(file, entry); - lf_printf(file, " },\n"); - } - else { - /* table `calling' another table */ - lf_printf(file, " /*%d*/ { ", entry->opcode_nr); - if (entry->opcode->is_boolean) - lf_printf(file, "MASK32(%d,%d), 0, ", - entry->opcode->first, entry->opcode->last); - else - lf_printf(file, "%d, MASK32(%d,%d), ", - insn_size - entry->opcode->last - 1, - entry->opcode->first, entry->opcode->last); - lf_print_table_name(file, entry); - lf_printf(file, " },\n"); - } - } -} - -static void -idecode_table_end(insn_table *table, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(depth == 0); - - if (!table->opcode_rule->use_switch) { - lf_printf(file, "};\n"); - } -} - -static void -idecode_table_padding(insn_table *table, - void *data, - int depth, - int opcode_nr) -{ - lf *file = (lf*)data; - ASSERT(depth == 0); - - if (!table->opcode_rule->use_switch) { - lf_printf(file, " /*%d*/ { 0, 0, %s_illegal },\n", - opcode_nr, (idecode_cache ? "idecode" : "semantic")); - } -} - - -/****************************************************************/ - - -void lf_print_idecode_switch -(lf *file, - insn_table *table); - - -static void -idecode_switch_start(insn_table *table, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(depth == 0); - ASSERT(table->opcode_rule->use_switch); - - lf_printf(file, "switch (EXTRACTED32(instruction, %d, %d)) {\n", - table->opcode->first, table->opcode->last); -} - - -static void -idecode_switch_leaf(insn_table *entry, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(entry->parent != NULL); - ASSERT(depth == 0); - ASSERT(entry->parent->opcode_rule->use_switch); - - lf_printf(file, "case %d:\n", entry->opcode_nr); - lf_indent(file, +2); - { - if (entry->opcode == NULL) { - /* switch calling leaf */ - lf_printf(file, "return "); - lf_print_function_name(file, - entry->insns->file_entry->fields[insn_name], - entry->expanded_bits, - (idecode_cache - ? function_name_prefix_idecode - : function_name_prefix_semantics)); - if (idecode_cache) - lf_printf(file, "(%s);\n", cache_idecode_actual); - else - lf_printf(file, "(%s);\n", insn_actual); - } - else if (entry->opcode_rule->use_switch) { - /* switch calling switch */ - lf_print_idecode_switch(file, entry); - } - else { - /* switch calling table */ - lf_printf(file, "return "); - lf_print_idecode_table(file, entry); - } - lf_printf(file, "break;\n"); - } - lf_indent(file, -2); -} - - -static void -lf_print_idecode_switch_illegal(lf *file) -{ - lf_indent(file, +2); - lf_print_idecode_illegal(file); - lf_printf(file, "break;\n"); - lf_indent(file, -2); -} - -static void -idecode_switch_end(insn_table *table, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(depth == 0); - ASSERT(table->opcode_rule->use_switch); - - if (table->opcode_rule->use_switch == 1) { - lf_printf(file, "default:\n"); - lf_print_idecode_switch_illegal(file); - } - lf_printf(file, "}\n"); -} - -static void -idecode_switch_padding(insn_table *table, - void *data, - int depth, - int opcode_nr) -{ - lf *file = (lf*)data; - - ASSERT(depth == 0); - ASSERT(table->opcode_rule->use_switch); - - if (table->opcode_rule->use_switch > 1) { - lf_printf(file, "case %d:\n", opcode_nr); - lf_print_idecode_switch_illegal(file); - } -} - - -void -lf_print_idecode_switch(lf *file, - insn_table *table) -{ - insn_table_traverse_tree(table, - file, - 0, - idecode_switch_start, - idecode_switch_leaf, - idecode_switch_end, - idecode_switch_padding); -} - - -static void -idecode_expand_if_switch(insn_table *table, - void *data, - int depth) -{ - lf *file = (lf*)data; - - if (table->opcode_rule->use_switch - && table->parent != NULL /* don't expand the top one yet */ - && !table->parent->opcode_rule->use_switch) { - lf_printf(file, "\n"); - lf_printf(file, "STATIC_INLINE_IDECODE void\n"); - lf_print_table_name(file, table); - lf_printf(file, "\n(%s)\n", - (idecode_cache ? cache_idecode_formal : insn_formal)); - lf_printf(file, "{\n"); - { - lf_indent(file, +2); - lf_print_idecode_switch(file, table); - lf_indent(file, -2); - } - lf_printf(file, "}\n"); - } -} - - -static void -lf_print_c_cracker_function(lf *file, - insn *instruction, - insn_bits *expanded_bits, - opcode_field *opcodes) -{ - /* if needed, generate code to enter this routine into a cache */ - lf_printf(file, "\n"); - lf_printf(file, "STATIC_INLINE_IDECODE idecode_semantic *\n"); - lf_print_function_name(file, - instruction->file_entry->fields[insn_name], - expanded_bits, - function_name_prefix_idecode); - lf_printf(file, "\n(%s)\n", cache_idecode_formal); - - lf_print_c_cracker(file, - instruction, - expanded_bits, - opcodes); -} - -static void -idecode_crack_leaf(insn_table *entry, - void *data, - int depth) -{ - lf *file = (lf*)data; - ASSERT(entry->nr_insn == 1 - && entry->opcode == NULL - && entry->parent != NULL - && entry->parent->opcode != NULL); - lf_print_c_cracker_function(file, - entry->insns, - entry->expanded_bits, - entry->opcode); -} - -static void -idecode_crack_insn(insn_table *entry, - void *data, - insn *instruction) -{ - lf *file = (lf*)data; - lf_print_c_cracker_function(file, - instruction, - NULL, - NULL); -} - -static void -idecode_c_internal_function(insn_table *table, - void *data, - file_table_entry *function) -{ - lf *file = (lf*)data; - ASSERT(idecode_cache != 0); - if (it_is("internal", function->fields[insn_flags])) { - lf_printf(file, "\n"); - lf_printf(file, "STATIC_INLINE_IDECODE idecode_semantic *\n"); - lf_print_function_name(file, - function->fields[insn_name], - NULL, - function_name_prefix_idecode); - lf_printf(file, "\n(%s)\n", cache_idecode_formal); - lf_printf(file, "{\n"); - lf_indent(file, +2); - lf_printf(file, "/* semantic routine */\n"); - lf_print_c_line_nr(file, function); - lf_printf(file, "return "); - lf_print_function_name(file, - function->fields[insn_name], - NULL, - function_name_prefix_semantics); - lf_printf(file, ";\n"); - - lf_print_file_line_nr(file); - lf_indent(file, -2); - lf_printf(file, "}\n"); - } -} - - -/****************************************************************/ - -static void -gen_idecode_c(insn_table *table, lf *file) -{ - int depth; - - /* the intro */ - lf_print_copyleft(file); - lf_printf(file, "\n"); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef _IDECODE_C_\n"); - lf_printf(file, "#define _IDECODE_C_\n"); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef STATIC_INLINE_IDECODE\n"); - lf_printf(file, "#define STATIC_INLINE_IDECODE STATIC_INLINE\n"); - lf_printf(file, "#endif\n"); - lf_printf(file, "\n"); - lf_printf(file, "#include \"cpu.h\"\n"); - lf_printf(file, "#include \"idecode.h\"\n"); - lf_printf(file, "#include \"semantics.h\"\n"); - lf_printf(file, "\n"); - lf_printf(file, "\n"); - lf_printf(file, "typedef idecode_semantic *idecode_crack\n(%s);\n", - (idecode_cache ? cache_idecode_formal : insn_formal)); - lf_printf(file, "\n"); - lf_printf(file, "typedef struct _idecode_table_entry {\n"); - lf_printf(file, " unsigned shift;\n"); - lf_printf(file, " unsigned mask;\n"); - lf_printf(file, " void *function_or_table;\n"); - lf_printf(file, "} idecode_table_entry;\n"); - lf_printf(file, "\n"); - lf_printf(file, "\n"); - - /* output `internal' invalid/floating-point unavailable functions - where needed */ - if (idecode_cache) { - insn_table_traverse_function(table, - file, - idecode_c_internal_function); - } - - /* output cracking functions where needed */ - if (idecode_cache) { - if (idecode_expand_semantics) - insn_table_traverse_tree(table, - file, - 1, - NULL, - idecode_crack_leaf, - NULL, - NULL); - else - insn_table_traverse_insn(table, - file, - idecode_crack_insn); - } - - - /* output tables where needed */ - for (depth = insn_table_depth(table); - depth > 0; - depth--) { - insn_table_traverse_tree(table, - file, - 1-depth, - idecode_table_start, - idecode_table_leaf, - idecode_table_end, - idecode_table_padding); - } - - /* output switch functions where needed */ - insn_table_traverse_tree(table, - file, - 1, - idecode_expand_if_switch, /* START */ - NULL, NULL, NULL); - - /* output the main idecode routine */ - lf_printf(file, "\n"); - if (idecode_cache) - lf_printf(file, "INLINE_IDECODE idecode_semantic *\nidecode\n(%s)\n", - cache_idecode_formal); - else - lf_printf(file, "INLINE_IDECODE unsigned_word\nidecode_issue\n(%s)\n", - insn_formal); - lf_printf(file, "{\n"); - lf_indent(file, +2); - if (table->opcode_rule->use_switch) - lf_print_idecode_switch(file, table); - else - lf_print_idecode_table(file, table); - lf_indent(file, -2); - lf_printf(file, "}\n"); - lf_printf(file, "\n"); - lf_printf(file, "#endif\n"); -} - - -/****************************************************************/ - - -typedef enum { - spreg_name, - spreg_reg_nr, - spreg_readonly, - spreg_length, - nr_spreg_registers = file_table_max_fields -} spreg_fields; - -typedef struct _spreg_table_entry spreg_table_entry; -struct _spreg_table_entry { - char *name; - int spreg_nr; - int is_readonly; - int length; - file_table_entry *entry; - spreg_table_entry *next; -}; - -typedef struct _spreg_table spreg_table; -struct _spreg_table { - spreg_table_entry *sprs; -}; - -static spreg_table_entry * -spreg_table_entry_new() -{ - spreg_table_entry *new_entry = - (spreg_table_entry*)zmalloc(sizeof(spreg_table_entry)); - ASSERT(new_entry != NULL); - return new_entry; -} - -static spreg_table * -spreg_table_new() -{ - spreg_table *new_table = (spreg_table*)zmalloc(sizeof(spreg_table)); - ASSERT(new_table != NULL); - return new_table; -} - -static void -spreg_table_insert(spreg_table *table, file_table_entry *entry) -{ - /* create a new spr entry */ - spreg_table_entry *new_spr = spreg_table_entry_new(); - new_spr->next = NULL; - new_spr->entry = entry; - new_spr->spreg_nr = atoi(entry->fields[spreg_reg_nr]); - new_spr->is_readonly = (entry->fields[spreg_readonly] - ? atoi(entry->fields[spreg_readonly]) - : 0); - new_spr->length = atoi(entry->fields[spreg_length]); - new_spr->name = (char*)zmalloc(strlen(entry->fields[spreg_name]) + 1); - ASSERT(new_spr->name != NULL); - { - int i; - for (i = 0; entry->fields[spreg_name][i] != '\0'; i++) { - if (isupper(entry->fields[spreg_name][i])) - new_spr->name[i] = tolower(entry->fields[spreg_name][i]); - else - new_spr->name[i] = entry->fields[spreg_name][i]; - } - } - - /* insert, by spreg_nr order */ - { - spreg_table_entry **ptr_to_spreg_entry = &table->sprs; - spreg_table_entry *spreg_entry = *ptr_to_spreg_entry; - while (spreg_entry != NULL && spreg_entry->spreg_nr < new_spr->spreg_nr) { - ptr_to_spreg_entry = &spreg_entry->next; - spreg_entry = *ptr_to_spreg_entry; - } - ASSERT(spreg_entry == NULL || spreg_entry->spreg_nr != new_spr->spreg_nr); - *ptr_to_spreg_entry = new_spr; - new_spr->next = spreg_entry; - } - -} - - -static spreg_table * -spreg_table_load(char *file_name) -{ - file_table *file = file_table_open(file_name); - spreg_table *table = spreg_table_new(); - - { - file_table_entry *entry; - while ((entry = file_table_read(file)) != NULL) { - spreg_table_insert(table, entry); - } - } - - return table; -} - - -/****************************************************************/ - -char *spreg_attributes[] = { - "is_valid", - "is_readonly", - "name", - "index", - "length", - 0 -}; - -static void -gen_spreg_h(spreg_table *table, lf *file) -{ - spreg_table_entry *entry; - char **attribute; - - lf_print_copyleft(file); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef _SPREG_H_\n"); - lf_printf(file, "#define _SPREG_H_\n"); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef INLINE_SPREG\n"); - lf_printf(file, "#define INLINE_SPREG\n"); - lf_printf(file, "#endif\n"); - lf_printf(file, "\n"); - lf_printf(file, "typedef unsigned_word spreg;\n"); - lf_printf(file, "\n"); - lf_printf(file, "typedef enum {\n"); - - for (entry = table->sprs; - entry != NULL ; - entry = entry->next) { - lf_printf(file, " spr_%s = %d,\n", entry->name, entry->spreg_nr); - } - - lf_printf(file, " nr_of_sprs = %d\n", nr_of_sprs); - lf_printf(file, "} sprs;\n"); - lf_printf(file, "\n"); - for (attribute = spreg_attributes; - *attribute != NULL; - attribute++) { - if (strcmp(*attribute, "name") == 0) - lf_printf(file, "INLINE_SPREG char *spr_%s(sprs spr);\n", - *attribute); - else - lf_printf(file, "INLINE_SPREG int spr_%s(sprs spr);\n", - *attribute); - } - lf_printf(file, "\n"); - lf_printf(file, "#endif /* _SPREG_H_ */\n"); -} - - -static void -gen_spreg_c(spreg_table *table, lf *file) -{ - spreg_table_entry *entry; - char **attribute; - int spreg_nr; - - lf_print_copyleft(file); - lf_printf(file, "\n"); - lf_printf(file, "#ifndef _SPREG_C_\n"); - lf_printf(file, "#define _SPREG_C_\n"); - lf_printf(file, "\n"); - lf_printf(file, "#include \"words.h\"\n"); - lf_printf(file, "#include \"spreg.h\"\n"); - - lf_printf(file, "\n"); - lf_printf(file, "typedef struct _spreg_info {\n"); - lf_printf(file, " char *name;\n"); - lf_printf(file, " int is_valid;\n"); - lf_printf(file, " int length;\n"); - lf_printf(file, " int is_readonly;\n"); - lf_printf(file, " int index;\n"); - lf_printf(file, "} spreg_info;\n"); - lf_printf(file, "\n"); - lf_printf(file, "static spreg_info spr_info[nr_of_sprs+1] = {\n"); - entry = table->sprs; - for (spreg_nr = 0; spreg_nr < nr_of_sprs+1; spreg_nr++) { - if (entry == NULL || spreg_nr < entry->spreg_nr) - lf_printf(file, " { 0, 0, 0, 0, %d},\n", spreg_nr); - else { - lf_printf(file, " { \"%s\", %d, %d, %d, spr_%s /*%d*/ },\n", - entry->name, 1, entry->length, entry->is_readonly, - entry->name, entry->spreg_nr); - entry = entry->next; - } - } - lf_printf(file, "};\n"); - - for (attribute = spreg_attributes; - *attribute != NULL; - attribute++) { - lf_printf(file, "\n"); - if (strcmp(*attribute, "name") == 0) - lf_printf(file, "INLINE_SPREG char *\n"); - else - lf_printf(file, "INLINE_SPREG int\n"); - lf_printf(file, "spr_%s(sprs spr)\n", *attribute); - lf_printf(file, "{\n"); - if (spreg_lookup_table - || strcmp(*attribute, "name") == 0 - || strcmp(*attribute, "index") == 0) - lf_printf(file, " return spr_info[spr].%s;\n", - *attribute); - else { - spreg_table_entry *entry; - lf_printf(file, " switch (spr) {\n"); - for (entry = table->sprs; entry != NULL; entry = entry->next) { - lf_printf(file, " case %d:\n", entry->spreg_nr); - if (strcmp(*attribute, "is_valid") == 0) - lf_printf(file, " return 1;\n"); - else if (strcmp(*attribute, "is_readonly") == 0) - lf_printf(file, " return %d;\n", entry->is_readonly); - else if (strcmp(*attribute, "length") == 0) - lf_printf(file, " return %d;\n", entry->length); - else - ASSERT(0); - } - lf_printf(file, " default:\n"); - lf_printf(file, " return 0;\n"); - lf_printf(file, " }\n"); - } - lf_printf(file, "}\n"); - } - - lf_printf(file, "\n"); - lf_printf(file, "#endif /* _SPREG_C_ */\n"); -} - - - -/****************************************************************/ - - -int -main(int argc, - char **argv, - char **envp) -{ - 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, "n:i:I:r:S:s:D:d:P:p:C:")) != -1) { - fprintf(stderr, "\t-%c %s\n", ch, optarg); - switch(ch) { - case 'I': - case 'i': - instructions = insn_table_load_insns(optarg); - fprintf(stderr, "\texpanding ...\n"); - insn_table_expand_insns(instructions); - fprintf(stderr, "\tcache fields ...\n"); - cache_fields = insn_table_cache_fields(instructions); - if (ch == 'I') { - dump_traverse(instructions); - dump_insn_table(instructions, 0, 1); - } - break; - case 'r': - sprs = spreg_table_load(optarg); - break; - case 'n': - real_file_name = strdup(optarg); - break; - default: - { - lf *file = lf_open(optarg, real_file_name); - switch (ch) { - case 'S': - gen_semantics_h(instructions, file); - break; - case 's': - gen_semantics_c(instructions, file); - break; - case 'P': - gen_spreg_h(sprs, file); - break; - case 'p': - gen_spreg_c(sprs, file); - break; - case 'D': - gen_idecode_h(instructions, file); - break; - case 'd': - gen_idecode_c(instructions, file); - break; - case 'C': - gen_icache_h(cache_fields, file); - break; - } - lf_close(file); - } - real_file_name = NULL; - } - } - return 0; -} diff --git a/sim/ppc/os_emul.c b/sim/ppc/os_emul.c new file mode 100644 index 0000000000..844b77fecc --- /dev/null +++ b/sim/ppc/os_emul.c @@ -0,0 +1,49 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1995, Andrew Cagney + + 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 _OS_EMUL_C_ +#define _OS_EMUL_C_ + +#include "cpu.h" +#include "idecode.h" +#include "os_emul.h" + +#include "emul_generic.h" +#include "emul_netbsd.h" + +#ifndef STATIC_INLINE_OS_EMUL +#define STATIC_INLINE_OS_EMUL STATIC_INLINE +#endif + + +INLINE_OS_EMUL void +os_emul_call(cpu *processor, + unsigned_word cia) +{ + emulation *emul = &emul_netbsd; + emul_do_call(emul, + cpu_registers(processor)->gpr[0], + 3, /*r3 contains arg0*/ + processor, + cia); +} + +#endif /* _OS_EMUL_C_ */ diff --git a/sim/ppc/os_emul.h b/sim/ppc/os_emul.h new file mode 100644 index 0000000000..1febef8e9f --- /dev/null +++ b/sim/ppc/os_emul.h @@ -0,0 +1,41 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1995, Andrew Cagney + + 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 _OS_EMUL_H_ +#define _OS_EMUL_H_ + +#ifndef INLINE_OS_EMUL +#define INLINE_OS_EMUL +#endif + +typedef struct _os_emul *os_emul; + +INLINE_OS_EMUL os_emul *os_emul_create +(char *emulation_name); + +INLINE_OS_EMUL void os_emul_init +(os_emul *emulation); + +INLINE_OS_EMUL void os_emul_call +(cpu *processor, + unsigned_word cia); + +#endif diff --git a/sim/ppc/ppc-cache-rules b/sim/ppc/ppc-cache-rules new file mode 100644 index 0000000000..9dad017619 --- /dev/null +++ b/sim/ppc/ppc-cache-rules @@ -0,0 +1,85 @@ +# +# This file is part of the program psim. +# +# Copyright (C) 1994-1995, Andrew Cagney +# +# 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. +# +# +# Instruction unpacking: +# +# Once the instruction has been decoded, the register (and other) +# fields within the instruction need to be extracted. +# +# The table that follows determines how each field should be treated. +# Importantly it considers the case where the extracted field is to +# be used immediatly or stored in an instruction cache. +# +# +# +# Zero marks the end of the table. More importantly 1. indicates +# that the entry is valid and can be cached. 2. indicates that that +# the entry is valid but can not be cached. +# +# +# +# The field name as given in the instruction spec. +# +# +# +# A name for once it has been extracted from the +# instructioin (and possibly stored in the instruction cache). +# +# +# +# String specifying the storage type for (the extracted +# field>. +# +# +# +# Specifies how to get from . If null, old and +# new name had better be the same. */ +# +# +1:RA:RA:: +1:RA:rA:signed_word *:(cpu_registers(processor)->gpr + RA) +1:RT:RT:: +1:RT:rT:signed_word *:(cpu_registers(processor)->gpr + RT) +2:RS:RS:: +1:RS:rS:signed_word *:(cpu_registers(processor)->gpr + RS) +2:RB:RB:: +1:RB:rB:signed_word *:(cpu_registers(processor)->gpr + RB) +2:FRA:FRA:: +1:FRA:frA:unsigned64 *:(cpu_registers(processor)->fpr + FRA) +2:FRB:FRB:: +1:FRB:frB:unsigned64 *:(cpu_registers(processor)->fpr + FRB) +2:FRC:FRC:: +1:FRC:frC:unsigned64 *:(cpu_registers(processor)->fpr + FRC) +2:FRS:FRS:: +1:FRS:frS:unsigned64 *:(cpu_registers(processor)->fpr + FRS) +2:FRT:FRT:: +1:FRT:frT:unsigned64 *:(cpu_registers(processor)->fpr + FRT) +1:SI:EXTS_SI:unsigned_word:((signed_word)(signed16)instruction) +2:BI:BI:: +1:BI:BIT32_BI::BIT32(BI) +2:BA:BA:: +1:BA:BIT32_BA::BIT32(BA) +2:BB:BB:: +1:BB:BIT32_BB::BIT32(BB) +1:BD:EXTS_BD_0b00:unsigned_word:(((signed_word)(signed16)instruction) & ~3) +#1:BD:CIA_plus_EXTS_BD_0b00:unsigned_word:CIA + EXTS(BD_0b00) +1:LI:EXTS_LI_0b00:unsigned_word:((((signed_word)(signed32)(instruction << 6)) >> 6) & ~0x3) +1:D:EXTS_D:unsigned_word:((signed_word)(signed16)(instruction)) +1:DS:EXTS_DS_0b00:unsigned_word:(((signed_word)(signed16)instruction) & ~0x3) diff --git a/sim/ppc/ppc-endian.c b/sim/ppc/ppc-endian.c index 1e51bdfb94..ec90bb7659 100644 --- a/sim/ppc/ppc-endian.c +++ b/sim/ppc/ppc-endian.c @@ -33,7 +33,7 @@ #include "ppc-endian.h" #include "sim_callbacks.h" -#if (WITH_HOST_BYTE_ORDER == LITTLE_ENDIAN) && WITH_NTOH +#if !defined(SWAP_2) && (WITH_HOST_BYTE_ORDER == LITTLE_ENDIAN) && WITH_NTOH #define SWAP_2(SET,RAW) SET htons (RAW) #endif @@ -67,7 +67,7 @@ endian_##NAME##_##BYTE_SIZE(unsigned_##BYTE_SIZE raw_in) \ return raw_in; \ } \ else { \ - SWAP_##BYTE_SIZE(return, raw_in); \ + SWAP_##BYTE_SIZE(return,raw_in); \ } \ } #endif diff --git a/sim/ppc/ppc-opcode-complex b/sim/ppc/ppc-opcode-complex new file mode 100644 index 0000000000..0435846005 --- /dev/null +++ b/sim/ppc/ppc-opcode-complex @@ -0,0 +1,95 @@ +# +# This file is part of the program psim. +# +# Copyright (C) 1994-1995, Andrew Cagney +# +# 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. +# +# Instruction decode: +# +# The table that follows is used by gen to construct a decision tree +# that can identify each possible instruction. Gen then outputs this +# decision tree as (according to config) a table or switch statement +# as the function idecode. +# +# In parallel to this, as mentioned above, WITH_EXPANDED_SEMANTICS +# determines of the semantic functions themselves should be expanded +# in a similar way. +# +# The table contains the following entries: +# +# +# +# Must be 1 for the entry to be considered. The last entry must be +# zero. +# +# +# +# +# Range of bits (within the instruction) that should be searched for +# an instruction field. Within such ranges, gen looks for opcodes +# (constants), registers (strings) and reserved bits (slash) and +# according to the rules that follows includes or excludes them from +# a possible instruction field. +# +# +# +# +# If an instructioin field was found, enlarge the field size so that +# it is forced to at least include bits starting from +# (). To stop this occuring, use = +# + 1 and = - 1. +# +# +# +# Treat `/' fields as a constant instead of variable when looking for +# an instruction field. +# +# +# +# Treat any contained register (string) fields as constant when +# determining the instruction field. For the instruction decode (and +# controled by IDECODE_EXPAND_SEMANTICS) this forces the expansion of +# what would otherwize be non constant bits of an instruction. +# +# +# +# Should this table be expanded using a switch statement (val 1) and +# if so, should it be padded with entries so as to force the compiler +# to generate a jump table (val 2). +# +# +# +# +# +# Special rule to fine tune how specific (or groups) of instructions +# are expanded. The applicability of the rule is determined by +# +# != 0 && (instruction> & ) == +# +# Where is obtained by looking only at constant fields +# with in an instructions spec. When determining an expansion, the +# rule is only considered when a node contains a single instruction. +# can be any of: +# +# 0: for this instruction, expand by earlier rules +# 1: expand bits .. only +# 2: boolean expansion of only zero/non-zero cases +# + 0: 5: 0: 5:0:: 0:0x00000000:0x00000000:0 +21:31:32:-1:0:OE,LR,AA,Rc,LK:0:0x00000000:0x00000000:0 + 6: 9: 6: 9:0:BO: 0:0xfc000000:0x40000000:1 +11:15:11:15:0:RA: 0:0xfc000000:0x38000000:2 +11:15:11:15:0:RA: 0:0xfc000000:0x3c000000:2 diff --git a/sim/ppc/ppc-opcode-simple b/sim/ppc/ppc-opcode-simple new file mode 100644 index 0000000000..b3a1316711 --- /dev/null +++ b/sim/ppc/ppc-opcode-simple @@ -0,0 +1,92 @@ +# +# This file is part of the program psim. +# +# Copyright (C) 1994-1995, Andrew Cagney +# +# 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. +# +# Instruction decode: +# +# The table that follows is used by gen to construct a decision tree +# that can identify each possible instruction. Gen then outputs this +# decision tree as (according to config) a table or switch statement +# as the function idecode. +# +# In parallel to this, as mentioned above, WITH_EXPANDED_SEMANTICS +# determines of the semantic functions themselves should be expanded +# in a similar way. +# +# The table contains the following entries: +# +# +# +# Must be 1 for the entry to be considered. The last entry must be +# zero. +# +# +# +# +# Range of bits (within the instruction) that should be searched for +# an instruction field. Within such ranges, gen looks for opcodes +# (constants), registers (strings) and reserved bits (slash) and +# according to the rules that follows includes or excludes them from +# a possible instruction field. +# +# +# +# +# If an instructioin field was found, enlarge the field size so that +# it is forced to at least include bits starting from +# (). To stop this occuring, use = +# + 1 and = - 1. +# +# +# +# Treat `/' fields as a constant instead of variable when looking for +# an instruction field. +# +# +# +# Treat any contained register (string) fields as constant when +# determining the instruction field. For the instruction decode (and +# controled by IDECODE_EXPAND_SEMANTICS) this forces the expansion of +# what would otherwize be non constant bits of an instruction. +# +# +# +# Should this table be expanded using a switch statement (val 1) and +# if so, should it be padded with entries so as to force the compiler +# to generate a jump table (val 2). +# +# +# +# +# +# Special rule to fine tune how specific (or groups) of instructions +# are expanded. The applicability of the rule is determined by +# +# != 0 && (instruction> & ) == +# +# Where is obtained by looking only at constant fields +# with in an instructions spec. When determining an expansion, the +# rule is only considered when a node contains a single instruction. +# can be any of: +# +# 0: for this instruction, expand by earlier rules +# 1: expand bits .. only +# 2: boolean expansion of only zero/non-zero cases +# + 0: 5: 0: 5:0:: 1:0x00000000:0x00000000:0 +21:31:32:-1:0:: 1:0x00000000:0x00000000:0 diff --git a/sim/ppc/spa-reporter.c b/sim/ppc/spa-reporter.c new file mode 100644 index 0000000000..9a7dd29bc6 --- /dev/null +++ b/sim/ppc/spa-reporter.c @@ -0,0 +1,758 @@ +/* + * Copyright (C) 1991 Gordon Irlam. All rights reserved. + */ + +/* + * Sparc trace generator. + * + * Generate a Sparc address trace. + * + * Report system calls. + * + * We want to display the system call and the return value at the same time + * (so that other output does not appear between the two) but also want to + * identify system calls that block without having to wait for them to + * return. Whenever a system call is performed we store the name of the + * call and the parameters. If we don't see a return within a certain time + * period we display the call regardless, and assume it has blocked. + */ + + +/* + * Imported declarations. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * sigcleanup is not defined in a system header file. + */ +#define SYS_sigcleanup 139 + +#include "prototype.h" +#include "error.h" +#include "spy.h" +#include "system_calls.h" + + +/* + * Forward declarations. + */ + +PROTOTYPE(void report_trap, + (int pid, void *addr, int trap, int g1, syscall_params *params)); +PROTOTYPE(void report_trap_result, (int pid, int error, int o0, int o1)); +PROTOTYPE(void display_trap_msg, (void)); +PROTOTYPE(void delayed_trap_msg, (void)); +PROTOTYPE(void discard_trap_msg, (void)); +PROTOTYPE(int copy_memory, (int pid, void *addr, int size, char *data)); +PROTOTYPE(char *snarf_string, (int pid, void *addr)); +PROTOTYPE(char *snarf_data, (int pid, void *addr, int size)); +PROTOTYPE(char *format_value, + (int pid, fmt_type format, unsigned long value, int opt)); +PROTOTYPE(int printable_data, (char *data, int size)); +PROTOTYPE(char *print_string, (char *data, int size)); + + +/* + * Global definitions. + */ + +static char *trap_msg = NULL; +static fmt_type result_format; +static int no_return; +static fmt_type post_fmt; +static unsigned long post_value; +static int post_size; + + +/* + * Report the occurence of the specified trap. + */ + +void report_trap(pid, addr, trap, g1, params_addr) + int pid; + void *addr; + int trap; + int g1; + syscall_params *params_addr; +{ + syscall_params params; + call_desc *call; + int i; + fmt_type arg_format; + char *arg_str; + + /* + * Display any previous trap message that is still pending (it might have + * been a trap that did not return a value, and so has not yet been + * displayed). + */ + + display_trap_msg(); + + /* + * Read the parameters, and construct a string describing the system call. + */ + + ensure(ptrace(PTRACE_READDATA, pid, + (char *) params_addr, sizeof(syscall_params), + (char *) params) != -1); + + no_return = 0; + + if (trap != T_SOFTWARE_TRAP) { + + /* + * Not a system call trap. + */ + + no_return = 1; + + ensure((trap_msg = malloc(17 + 20 + 1)) != NULL); + sprintf(trap_msg, "0x%08lx: trap %d", (unsigned long) addr, trap); + + result_format = fmt_unknown; + } if ((g1 < 0) || (g1 >= no_system_calls)) { + + /* + * An unknown system call. + */ + + ensure((trap_msg = malloc(21 + 20 + 1)) != NULL); + sprintf(trap_msg, "0x%08lx: _unknown_%d(", + (unsigned long) addr, g1); + + arg_str = format_value(pid, fmt_unknown, params[0], 0); + ensure((trap_msg = realloc(trap_msg, strlen(trap_msg) + + strlen(arg_str) + 1 + 1)) + != NULL); + sprintf(trap_msg + sizeof(trap_msg), "%s)", arg_str); + free(arg_str); + + result_format = fmt_unknown; + } else { + + /* + * A known system call. + */ + + call = &system_calls[g1]; + switch (g1) { + case SYS_open : + if (!(params[1] & O_CREAT)) { + call = &system_call_open_simple; + } + break; + case SYS_exit : + case SYS_execve : + case SYS_sigcleanup : + no_return = 1; + break; + default : + break; + } + + ensure((trap_msg = malloc(13 + strlen(call->name) + 1 + 1)) + != NULL); + sprintf(trap_msg, "0x%08lx: %s(", + (unsigned long) addr, call->name); + + /* + * Display each of the arguments. + */ + + for (i = 0; i < NO_PARAMS; i++) { + if ((arg_format = call->arg[i]) == fmt_none) { + break; + } + if (i > 0) { + strcat(trap_msg, ", "); + } + if (arg_format == fmt_data) { + assert(((i + 1) < NO_PARAMS) && + (call->arg[i + 1] == fmt_data_size)); + arg_str = format_value(pid, arg_format, + params[i], (int) params[i + 1]); + } else { + arg_str = format_value(pid, arg_format, params[i], 0); + } + ensure((trap_msg = realloc(trap_msg, strlen(trap_msg) + + strlen(arg_str) + 2 + 1)) + != NULL); + strcat(trap_msg, arg_str); + free(arg_str); + } + + strcat(trap_msg, ")"); + + result_format = call->result; + } + + /* + * Set alarm so that name of call will be displayed even if it blocks. + */ + + alarm((unsigned int) 1); +} + + +/* + * Report the value returned as a result of the most recent trap. + */ + +void report_trap_result(pid, error, o0, o1) + int pid; + int error; + int o0; + int o1; +{ + char *result, *eno, *emsg, *addr; + + /* + * Turn off alarm used to ensure we print the call promptly - we are about + * to print it now. + */ + + alarm((unsigned int) 0); + + /* + * See if previous call blocked. + */ + + if (trap_msg == NULL) { + ensure((trap_msg = strdup(" [previous call]")) != NULL); + } + + /* + * Work out error message (if any) to be printed following return value. + */ + + if (error) { + eno = format_value(pid, fmt_error, o0, 0); + ensure((emsg = malloc(9 + strlen(eno) + 1)) != NULL); + sprintf(emsg, " [error %s]", eno); + free(eno); + o0 = -1; + post_fmt = fmt_none; + } else { + ensure((emsg = strdup("")) != NULL); + } + + /* + * Print out all the details of the system call. + */ + + if (result_format == fmt_none) { + ensure(fprintf(msgfile, "%s: %s%s\n", trace_progname, trap_msg, emsg) + != EOF); + } else { + result = format_value(pid, result_format, o0, 0); + ensure(fprintf(msgfile, "%s: %s -> %s%s\n", + trace_progname, trap_msg, result, emsg) != EOF); + free(result); + } + + free(emsg); + + /* + * Display any string or buffer modified by the system call if required. + * And providing it can be displayed as a (non-null) string. + */ + + if (post_fmt != fmt_none) { + result = format_value(pid, post_fmt, post_value, post_size); + if ((result[0] == '"') && (strlen(result) > 2)) { + addr = format_value(pid, fmt_ptr, post_value, 0); + ensure(fprintf(msgfile, "%s: %s: %s\n", + trace_progname, addr, result) != EOF); + free(addr); + } + free(result); + post_fmt = fmt_none; + } + + free(trap_msg); + trap_msg = NULL; +} + + +/* + * Report any trap messages that haven't been reported yet. + */ + +void display_trap_msg() { + + /* + * Clear the alarm - we are about to print the message. + */ + + alarm((unsigned int) 0); + + if (trap_msg != NULL) { + ensure(fprintf(msgfile, "%s: %s\n", trace_progname, trap_msg) != EOF); + free(trap_msg); + trap_msg = NULL; + } +} + + +/* + * Report the completion of a trap message as being delayed. + * + * This routine is invoked when a SIGALRM is received. + */ + +void delayed_trap_msg() { + + assert(trap_msg != NULL); + + /* + * If the call was not expected to return a value, think nothing of it, + * otherwise assume the call has blocked. + */ + + ensure(fprintf(msgfile, "%s: %s%s\n", + trace_progname, trap_msg, (no_return ? "" : " [pending]")) + != EOF); + free(trap_msg); + trap_msg = NULL; +} + + +/* + * Discard any pending trap messages. + * + * This routine is used by the child of a fork to discard the fork system call + * record. + */ + +void discard_trap_msg() { + + trap_msg = NULL; +} + + +/* + * Attempt to copy size bytes from the target process to data. The number of + * bytes successfully copied is returned. + */ + +int copy_memory(pid, addr, size, data) + int pid; + void *addr; + int size; + char *data; +{ + int lo, hi, try; + + assert(size >= 0); + + /* + * Common cases first. + */ + + if (ptrace(PTRACE_READDATA, pid, (char *) addr, size, data) != -1) { + return size; + } else if (ptrace(PTRACE_READDATA, pid, (char *) addr, 1, data) == -1) { + return 0; + } + + /* + * Binary search. + */ + + lo = 1; + hi = size - 1; + + while (lo < hi) { + try = (lo + hi + 1) / 2; + if (ptrace(PTRACE_READDATA, pid, (char *) addr, try, data) != -1) { + lo = try; + } else { + hi = try - 1; + } + } + + ensure(ptrace(PTRACE_READDATA, pid, (char *) addr, lo, data) != -1); + + return lo; +} + + +/* + * Create a string representing the contents of the indicated null termintated + * region of memory. + */ + +char *snarf_string(pid, addr) + int pid; + void *addr; +{ + char data[STRING_SIZE_LIMIT + 1]; + int size, len; + char *result = NULL; + int too_long = 0; + + size = copy_memory(pid, addr, STRING_SIZE_LIMIT, data); + data[size] = '\0'; + len = strlen(data); + too_long = (len == STRING_SIZE_LIMIT); + if ((len < size) || too_long) { + if (printable_data(data, len)) { + result = print_string(data, len); + if (too_long) { + ensure((result = realloc(result, strlen(result) + 2 + 1)) + != NULL); + strcat(result, ".."); + } + } + } + + return result; +} + + +/* + * Create a string representing the contents of the indicated length delimited + * region of memory. + */ + +char *snarf_data(pid, addr, size) + int pid; + void *addr; + int size; +{ + char data[DATA_SIZE_LIMIT]; + char *result = NULL; + int too_long = 0; + + if (size > DATA_SIZE_LIMIT) { + size = DATA_SIZE_LIMIT; + too_long = 1; + } + if ((size >= 0) && (copy_memory(pid, addr, size, data) == size)) { + if (printable_data(data, size)) { + result = print_string(data, size); + if (too_long) { + ensure((result = realloc(result, strlen(result) + 2 + 1)) + != NULL); + strcat(result, ".."); + } + } + } + + return result; +} + + +/* + * Create a string representing the contents of the indicated null termintated + * array of pointers to null terminated regions of memory. + */ + +char *snarf_string_array(pid, addr) + int pid; + void *addr; +{ + char *data[ARRAY_SIZE_LIMIT + 1]; + int size, len, i; + char *result = NULL; + char *s; + int too_long = 0; + + size = copy_memory(pid, addr, ARRAY_SIZE_LIMIT * sizeof(char *), + (char *) data) / sizeof(char *); + data[size] = NULL; + for (len = 0; data[len] != NULL; len++) { + } + too_long = (len == ARRAY_SIZE_LIMIT); + if ((len < size) || too_long) { + ensure((result = strdup("{")) != NULL); + for (i = 0; i < len; i++) { + if (i > 0) { + strcat(result, ", "); + } + s = format_value(pid, fmt_string, (unsigned long) data[i], 0); + ensure((result = realloc(result, + strlen(result) + strlen(s) + 2 + 5 + 1)) + != NULL); + strcat(result, s); + } + if (too_long) { + strcat(result, ", .."); + } + strcat(result, "}"); + } + + return result; +} + + +/* + * Return a string containing a value printed in a specific format. Opt is a + * second optional parameter currently only used to contain the size to be used + * with fmt_data. + */ + +char *format_value(pid, format, value, opt) + int pid; + fmt_type format; + unsigned long value; + int opt; +{ + char *str; + int sig, error; + + /* + * See if we are meant to hang on to the value for later use. + */ + + switch (format) { + + case fmt_post_string : + post_fmt = fmt_string ; + post_value = value; + format = fmt_ptr; + break; + + case fmt_post_data : + post_fmt = fmt_data; + post_value = value; + format = fmt_ptr; + break; + + case fmt_data_size : + format = FMT_SIZE; + break; + + case fmt_post_data_size : + post_size = (int) value; + format = FMT_SIZE; + break; + + default : + break; + } + + /* + * Display the value. + */ + + switch (format) { + + case fmt_dec : + + ensure((str = malloc(20 + 1)) != NULL); + sprintf(str, "%d", (int) value); + break; + + case fmt_hex : + + ensure((str = malloc(2 + 20 + 1)) != NULL); + sprintf(str, "0x%lx", value); + break; + + case fmt_ptr : + + if (value == 0) { + ensure((str = strdup("NULL")) != NULL); + } else { + ensure((str = malloc(10 + 1)) != NULL); + sprintf(str, "0x%08lx", value); + } + break; + + case fmt_fd : + + ensure((str = malloc(2 + 20 + 1)) != NULL); + sprintf(str, "fd%d", (int) value); + break; + + case fmt_signal : + + sig = (int) value; + if ((sig < 0) || (sig >= no_signal_names)) { + ensure((str = malloc(20 + 1)) != NULL); + sprintf(str, "%d", sig); + } else { + ensure((str = strdup(signal_names[sig])) != NULL); + } + break; + + case fmt_error : + + error = (int) value; + if ((error < 0) || (error >= no_error_names)) { + ensure((str = malloc(20 + 1)) != NULL); + sprintf(str, "%d", error); + } else { + ensure((str = strdup(error_names[error])) != NULL); + } + break; + + case fmt_open_flags : + + ensure((str = malloc(8 + 3 + 20 + 1)) != NULL); + switch (value & 3) { + case O_RDONLY : + sprintf(str, "O_RDONLY"); + value -= O_RDONLY; + break; + case O_WRONLY : + sprintf(str, "O_WRONLY"); + value -= O_WRONLY; + break; + case O_RDWR : + sprintf(str, "O_RDWR"); + value -= O_RDWR; + break; + default : + sprintf(str, "0x%lx", value); + value = 0; + break; + } + if (value != 0) { + sprintf(str + strlen(str), "|0x%lx", value); + } + break; + + case fmt_unknown : + + ensure((str = strdup("..")) != NULL); + break; + + case fmt_string : + + if ((str = snarf_string(pid, (void *) value)) == NULL) { + str = format_value(pid, fmt_ptr, value, 0); + } + break; + + case fmt_data : + + if ((str = snarf_data(pid, (void *) value, opt)) == NULL) { + str = format_value(pid, fmt_ptr, value, 0); + } + break; + + case fmt_string_array : + + if ((str = snarf_string_array(pid, (void *) value)) == NULL) { + str = format_value(pid, fmt_ptr, value, 0); + } + break; + + default : + + diagnose("Unexpected display format"); + break; + } + + return str; +} + + +/* + * Determine whether size bytes of data are printable. + */ + +int printable_data(data, size) + char *data; + int size; +{ + int i; + + for (i = 0; i < size; i++) { + + if (!(isprint(data[i]))) { + + switch (data[i]) { + + case '\0' : + case '\t' : + case '\n' : + case '\f' : + case '\r' : + break; + + default : + return 0; + break; + } + } + } + + return 1; +} + + +/* + * Create a string representing size bytes of data. + */ + +char *print_string(data, size) + char *data; + int size; +{ + char *str, *s; + int i; + + assert(size >= 0); + + ensure((str = malloc(1 + size * 2 + 1 + 1)) != NULL); + s = str; + + *(s++) = '"'; + + for (i = 0; i < size; i++) { + + if ((!(isprint(data[i]))) || (data[i] == '"') || (data[i] == '\\')) { + + *(s++) = '\\'; + + switch (data[i]) { + case '\0' : + *(s++) = '0'; + break; + case '\t' : + *(s++) = 't'; + break; + case '\n' : + *(s++) = 'n'; + break; + case '\f' : + *(s++) = 'f'; + break; + case '\r' : + *(s++) = 'r'; + break; + case '"' : + case '\\' : + *(s++) = data[i]; + break; + default : + diagnose("Attempted to display illegal character"); + } + } else { + + *(s++) = data[i]; + } + } + + *(s++) = '"'; + *s = '\0'; + + return str; +} diff --git a/sim/ppc/spa-system-calls.c b/sim/ppc/spa-system-calls.c new file mode 100644 index 0000000000..a344595185 --- /dev/null +++ b/sim/ppc/spa-system-calls.c @@ -0,0 +1,499 @@ +/* + * Copyright (C) 1991 Gordon Irlam. All rights reserved. + */ + +/* + * Definition of system calls for sparc trace generator. + */ + + +/* + * Imported declarations. + */ + +#include "system_calls.h" + + +/* + * Table containing system calls, and their parameter profile. + */ + +call_desc system_calls[] = { + /* 0 */ {"syscall", {fmt_dec, fmt_unknown}, fmt_dec}, + /* 1 */ {"_exit", {fmt_dec}, fmt_none}, + /* 2 */ {"fork", {fmt_none}, fmt_dec}, + /* 3 */ {"read", {fmt_fd, fmt_post_data, FMT_SIZE}, fmt_post_data_size}, + /* 4 */ {"write", {fmt_fd, fmt_data, fmt_data_size}, FMT_SIZE}, + /* 5 */ {"open", {fmt_string, fmt_open_flags, FMT_FLAGS}, fmt_fd}, + /* 6 */ {"close", {fmt_fd}, FMT_STATUS}, + /* 7 */ {"wait4", {fmt_dec, fmt_ptr, FMT_FLAGS, fmt_ptr}, fmt_dec}, + /* 8 */ {"creat", {fmt_string, FMT_FLAGS}, fmt_fd}, + /* 9 */ {"link", {fmt_string, fmt_string}, FMT_STATUS}, + /* 10 */ {"unlink", {fmt_string}, FMT_STATUS}, + /* 11 */ {"_unknown_11[\"old execv\"]", {fmt_unknown}, fmt_unknown}, + /* + * execv is now a library routine which calls execve, although + * Sun have not officially declared execv obsolete. + */ + /* 12 */ {"chdir", {fmt_string}, FMT_STATUS}, + /* 13 */ {"_unknown_13[\"old time\"]", {fmt_unknown}, fmt_unknown}, + /* 14 */ {"mknod", {fmt_string, FMT_FLAGS, FMT_FLAGS}, FMT_STATUS}, + /* 15 */ {"chmod", {fmt_string, FMT_FLAGS}, FMT_STATUS}, + /* 16 */ {"chown", {fmt_string, fmt_dec, fmt_dec}, FMT_STATUS}, + /* 17 */ {"_brk", {fmt_ptr}, FMT_STATUS}, + /* 18 */ {"_unknown_18[\"old stat\"]", {fmt_unknown}, fmt_unknown}, + /* 19 */ {"lseek", {fmt_fd, FMT_SIZE, fmt_dec}, FMT_SIZE}, + /* 20 */ {"getpid", {fmt_none}, fmt_dec}, + /* 21 */ {"_unknown_21", {fmt_unknown}, fmt_unknown}, + /* 22 */ {"umount[\"System V\"]", {fmt_string}, FMT_STATUS}, + /* 23 */ {"_unknown_23[\"old setuid\"]", {fmt_unknown}, fmt_unknown}, + /* 24 */ {"getuid", {fmt_none}, fmt_dec}, + /* 25 */ {"_unknown_25[\"old System V stime\"]", + {fmt_unknown}, + fmt_unknown}, + /* 26 */ {"ptrace", + {fmt_dec, fmt_dec, fmt_ptr, fmt_dec, fmt_ptr}, + fmt_dec}, + /* 27 */ {"_unknown_27[\"old alarm\"]", {fmt_unknown}, fmt_unknown}, + /* 28 */ {"_unknown_28[\"old fstat\"]", {fmt_unknown}, fmt_unknown}, + /* 29 */ {"_unknown_29[\"old pause\"]", {fmt_unknown}, fmt_unknown}, + /* 30 */ {"_unknown_30[\"old utime\"]", {fmt_unknown}, fmt_unknown}, + /* 31 */ {"_unknown_31", {fmt_unknown}, fmt_unknown}, + /* 32 */ {"_unknown_32", {fmt_unknown}, fmt_unknown}, + /* 33 */ {"access", {fmt_string, FMT_FLAGS}, FMT_STATUS}, + /* 34 */ {"_unknown_34[\"old nice\"]", {fmt_unknown}, fmt_unknown}, + /* 35 */ {"_unknown_35[\"old ftime\"]", {fmt_unknown}, fmt_unknown}, + /* 36 */ {"sync", {fmt_none}, fmt_none}, + /* 37 */ {"kill", {fmt_dec, fmt_signal}, FMT_STATUS}, + /* 38 */ {"stat", {fmt_string, fmt_ptr}, FMT_STATUS}, + /* 39 */ {"_unknown_39[\"old setpgrp\"]", {fmt_unknown}, fmt_unknown}, + /* 40 */ {"lstat", {fmt_string, fmt_ptr}, FMT_STATUS}, + /* 41 */ {"dup", {fmt_fd}, fmt_fd}, + /* + * Sun sometimes claim dup has 2 parameters. + */ + /* 42 */ {"pipe", {fmt_ptr}, FMT_STATUS}, + /* 43 */ {"_unknown_43[\"old times\"]", {fmt_unknown}, fmt_unknown}, + /* 44 */ {"profil", {fmt_ptr, FMT_SIZE, fmt_ptr, fmt_dec}, FMT_STATUS}, + /* 45 */ {"_unknown_45", {fmt_unknown}, fmt_unknown}, + /* 46 */ {"_unknown_46[\"old setgid\"]", {fmt_unknown}, fmt_unknown}, + /* 47 */ {"getgid", {fmt_none}, fmt_dec}, + /* 48 */ {"_unknown_48[\"old signal\"]", {fmt_unknown}, fmt_unknown}, + /* 49 */ {"_unknown_49", {fmt_unknown}, fmt_unknown}, + /* 50 */ {"_unknown_50", {fmt_unknown}, fmt_unknown}, + /* 51 */ {"acct", {fmt_string}, FMT_STATUS}, + /* 52 */ {"_unknown_52", {fmt_unknown}, fmt_unknown}, + /* 53 */ {"mctl", {fmt_ptr, FMT_SIZE, fmt_dec, FMT_FLAGS}, FMT_STATUS}, + /* 54 */ {"ioctl", {fmt_fd, FMT_FLAGS, fmt_ptr}, fmt_dec}, + /* 55 */ {"reboot", {FMT_FLAGS, fmt_string}, FMT_STATUS}, + /* 56 */ {"_unknown_56[\"old wait3\"]", {fmt_unknown}, fmt_unknown}, + /* 57 */ {"symlink", {fmt_string, fmt_string}, FMT_STATUS}, + /* 58 */ {"readlink", + {fmt_string, fmt_post_data, FMT_SIZE}, + fmt_post_data_size}, + /* 59 */ {"execve", + {fmt_string, fmt_string_array, fmt_string_array}, + FMT_STATUS}, + /* 60 */ {"umask", {FMT_FLAGS}, FMT_FLAGS}, + /* 61 */ {"chroot", {fmt_string}, FMT_STATUS}, + /* 62 */ {"fstat", {fmt_fd, fmt_ptr}, FMT_STATUS}, + /* 63 */ {"_unknown_63", {fmt_unknown}, fmt_unknown}, + /* 64 */ {"getpagesize", {fmt_none}, FMT_SIZE}, + /* 65 */ {"_unknown_65[\"old msync\"]", {fmt_unknown}, fmt_unknown}, + /* + * msync is now a library routine which calls mctl, although + * Sun have not officially declared msync obsolete. + */ + /* 66 */ {"vfork", {fmt_none}, fmt_dec}, + /* 67 */ {"_unknown_67[\"old vread\"]", {fmt_unknown}, fmt_unknown}, + /* + * I don't think vread can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 68 */ {"_unknown_68[\"old vwrite\"]", {fmt_unknown}, fmt_unknown}, + /* + * I don't think vwrite can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 69 */ {"_unknown_69[\"old brk\"]", {fmt_unknown}, fmt_unknown}, + /* + * Also referred to as sbrk. I don't think it can be generated + * by the standard libararies, although Sun have not officially + * declared it obsolete. + */ + /* 70 */ {"_unknown_70[\"old sstk\"]", {fmt_unknown}, fmt_unknown}, + /* + * I don't think sstk can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 71 */ {"mmap", + {fmt_ptr, fmt_post_data_size, FMT_FLAGS, FMT_FLAGS, fmt_fd, + FMT_SIZE}, + fmt_post_data}, + /* 72 */ {"vadvise", {fmt_dec}, FMT_STATUS}, + /* + * vadvise is currently still a valid system call, although Sun + * have said it is likely to disappear in the future. + */ + /* 73 */ {"munmap", {fmt_ptr, FMT_SIZE}, FMT_STATUS}, + /* 74 */ {"mprotect", {fmt_ptr, FMT_SIZE, FMT_FLAGS}, FMT_STATUS}, + /* 75 */ {"_unknown_75[\"old madvise\"]", {fmt_unknown}, fmt_unknown}, + /* + * madvise is now a library routine which calls mctl, although + * Sun have not officially declared madvise obsolete. + */ + /* 76 */ {"vhangup", {fmt_none}, FMT_STATUS}, + /* + * Sun sometimes claim vhangup has 1 parameter. + */ + /* 77 */ {"_unknown_77[\"old vlimit\"]", {fmt_unknown}, fmt_unknown}, + /* 78 */ {"mincore", {fmt_ptr, FMT_SIZE, fmt_ptr}, FMT_STATUS}, + /* 79 */ {"getgroups", {fmt_dec, fmt_ptr}, fmt_dec}, + /* 80 */ {"setgroups", {fmt_dec, fmt_ptr}, FMT_STATUS}, + /* 81 */ {"getpgrp", {fmt_dec}, fmt_dec}, + /* 82 */ {"setpgrp", {fmt_dec, fmt_dec}, FMT_STATUS}, + /* 83 */ {"setitimer", {fmt_dec, fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 84 */ {"_unknown_84[\"old wait\"]", {fmt_unknown}, fmt_unknown}, + /* + * wait is now a library routine which calls wait4, although Sun + * have not officially declared wait obsolete. + */ + /* 85 */ {"swapon", {fmt_string}, FMT_STATUS}, + /* 86 */ {"getitimer", {fmt_dec, fmt_ptr}, FMT_STATUS}, + /* 87 */ {"gethostname", {fmt_post_string, FMT_SIZE}, FMT_STATUS}, + /* 88 */ {"sethostname", {fmt_data, fmt_data_size}, FMT_STATUS}, + /* 89 */ {"getdtablesize", {fmt_none}, fmt_dec}, + /* 90 */ {"dup2", {fmt_fd, fmt_dec}, fmt_fd}, + /* 91 */ {"_unknown_91[\"old getdopt\"]", {fmt_unknown}, fmt_unknown}, + /* + * I don't think getdopt can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 92 */ {"fcntl", {fmt_fd, fmt_dec, fmt_dec}, fmt_dec}, + /* 93 */ {"select", + {fmt_dec, fmt_ptr, fmt_ptr, fmt_ptr, fmt_ptr}, + fmt_dec}, + /* 94 */ {"_unknown_94[\"old setdopt\"]", {fmt_unknown}, fmt_unknown}, + /* + * I don't think setdopt can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 95 */ {"fsync", {fmt_fd}, FMT_STATUS}, + /* 96 */ {"setpriority", {fmt_dec, fmt_dec, fmt_dec}, FMT_STATUS}, + /* 97 */ {"socket", {fmt_dec, fmt_dec, fmt_dec}, fmt_fd}, + /* 98 */ {"connect", {fmt_fd, fmt_ptr, FMT_SIZE}, FMT_STATUS}, + /* 99 */ {"accept", {fmt_fd, fmt_ptr, fmt_ptr}, fmt_fd}, + /* 100 */ {"getpriority", {fmt_dec, fmt_dec}, fmt_dec}, + /* 101 */ {"send", {fmt_fd, fmt_data, fmt_data_size, FMT_FLAGS}, FMT_SIZE}, + /* 102 */ {"recv", + {fmt_fd, fmt_post_data, FMT_SIZE, FMT_FLAGS}, + fmt_post_data_size}, + /* 103 */ {"_unknown_103", {fmt_unknown}, fmt_unknown}, + /* 104 */ {"bind", {fmt_fd, fmt_ptr, FMT_SIZE}, FMT_STATUS}, + /* 105 */ {"setsockopt", + {fmt_fd, fmt_dec, fmt_dec, fmt_ptr, FMT_SIZE}, + FMT_STATUS}, + /* 106 */ {"listen", {fmt_fd, fmt_dec}, FMT_STATUS}, + /* 107 */ {"_unknown_107[\"old vtimes\"]", {fmt_unknown}, fmt_unknown}, + /* 108 */ {"_sigvec", {fmt_signal, fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 109 */ {"sigblock", {fmt_hex}, fmt_hex}, + /* 110 */ {"sigsetmask", {fmt_hex}, fmt_hex}, + /* 111 */ {"sigpause", {fmt_hex}, FMT_STATUS}, + /* 112 */ {"sigstack", {fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 113 */ {"recvmsg", {fmt_fd, fmt_ptr, FMT_FLAGS}, FMT_SIZE}, + /* 114 */ {"sendmsg", {fmt_fd, fmt_ptr, FMT_FLAGS}, FMT_SIZE}, + /* 115 */ {"_unknown_115[\"vtrace\"]", + {fmt_dec, fmt_hex, fmt_hex}, + fmt_unknown}, + /* + * I am unsure of the parameters for vtrace. + */ + /* 116 */ {"gettimeofday", {fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 117 */ {"getrusage", {fmt_dec, fmt_ptr}, FMT_STATUS}, + /* 118 */ {"getsockopt", + {fmt_fd, fmt_dec, fmt_dec, fmt_ptr, fmt_ptr}, + FMT_STATUS}, + /* 119 */ {"_unknown_119", {fmt_unknown}, fmt_unknown}, + /* 120 */ {"readv", {fmt_fd, fmt_ptr, fmt_dec}, FMT_SIZE}, + /* 121 */ {"writev", {fmt_fd, fmt_ptr, fmt_dec}, FMT_SIZE}, + /* 122 */ {"settimeofday", {fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 123 */ {"fchown", {fmt_fd, fmt_dec, fmt_dec}, FMT_STATUS}, + /* 124 */ {"fchmod", {fmt_fd, FMT_FLAGS}, FMT_STATUS}, + /* 125 */ {"recvfrom", + {fmt_fd, fmt_post_data, FMT_SIZE, FMT_FLAGS, fmt_ptr, fmt_ptr}, + fmt_post_data_size}, + /* 126 */ {"setreuid", {fmt_dec, fmt_dec}, FMT_STATUS}, + /* 127 */ {"setregid", {fmt_dec, fmt_dec}, FMT_STATUS}, + /* 128 */ {"rename", {fmt_string, fmt_string}, FMT_STATUS}, + /* 129 */ {"truncate", {fmt_string, FMT_SIZE}, FMT_STATUS}, + /* 130 */ {"ftruncate", {fmt_fd, FMT_SIZE}, FMT_STATUS}, + /* 131 */ {"flock", {fmt_fd, FMT_FLAGS}, FMT_STATUS}, + /* 132 */ {"_unknown_132", {fmt_unknown}, fmt_unknown}, + /* 133 */ {"sendto", + {fmt_fd, fmt_data, fmt_data_size, FMT_FLAGS, fmt_ptr, FMT_SIZE}, + FMT_SIZE}, + /* 134 */ {"shutdown", {fmt_fd, fmt_dec}, FMT_STATUS}, + /* 135 */ {"socketpair", {fmt_dec, fmt_dec, fmt_dec, fmt_ptr}, FMT_STATUS}, + /* + * Sun sometimes claim socketpair has 5 parameters. + */ + /* 136 */ {"mkdir", {fmt_string, FMT_FLAGS}, FMT_STATUS}, + /* 137 */ {"rmdir", {fmt_string}, FMT_STATUS}, + /* 138 */ {"utimes", {fmt_string, fmt_ptr}, FMT_STATUS}, + /* 139 */ {"_sigcleanup", {fmt_ptr}, FMT_STATUS}, + /* 140 */ {"adjtime", {fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 141 */ {"getpeername", {fmt_fd, fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 142 */ {"gethostid", {fmt_none}, fmt_hex}, + /* + * Sun sometimes claim gethostid has 2 parameters. + */ + /* 143 */ {"_unknown_143", {fmt_unknown}, fmt_unknown}, + /* 144 */ {"getrlimit", {fmt_dec, fmt_ptr}, FMT_STATUS}, + /* 145 */ {"setrlimit", {fmt_dec, fmt_ptr}, FMT_STATUS}, + /* 146 */ {"killpg", {fmt_dec, fmt_signal}, FMT_STATUS}, + /* 147 */ {"_unknown_147", {fmt_unknown}, fmt_unknown}, + /* 148 */ {"_unknown_148[\"old quota\"]", {fmt_unknown}, fmt_unknown}, + /* + * I don't think quota can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 149 */ {"_unknown_149[\"old qquota\"]", {fmt_unknown}, fmt_unknown}, + /* + * I don't think qquota can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 150 */ {"getsockname", {fmt_fd, fmt_ptr, fmt_ptr}, FMT_STATUS}, + /* 151 */ {"getmsg", {fmt_fd, fmt_ptr, fmt_ptr, fmt_ptr}, fmt_dec}, + /* 152 */ {"putmsg", {fmt_fd, fmt_ptr, fmt_ptr, FMT_FLAGS}, FMT_STATUS}, + /* 153 */ {"poll", {fmt_ptr, fmt_dec, fmt_dec}, fmt_dec}, + /* 154 */ {"_unknown_154", {fmt_unknown}, fmt_unknown}, + /* 155 */ {"nfssvc", {fmt_fd}, FMT_STATUS}, + /* 156 */ {"_unknown_156[\"old getdirentries\"]", + {fmt_unknown}, + fmt_unknown}, + /* + * I don't think getdirentries can be generated by the standard + * libararies, although Sun have not officially declared it + * obsolete. + */ + /* 157 */ {"statfs", {fmt_string, fmt_ptr}, FMT_STATUS}, + /* 158 */ {"fstatfs", {fmt_fd, fmt_ptr}, FMT_STATUS}, + /* 159 */ {"unmount", {fmt_string}, FMT_STATUS}, + /* 160 */ {"async_daemon", {fmt_none}, fmt_none}, + /* 161 */ {"nfs_getfh", {fmt_hex, fmt_hex}, fmt_unknown}, + /* + * I am unsure of the parameters for nfs_getfh. + */ + /* 162 */ {"getdomainname", {fmt_post_string, FMT_SIZE}, FMT_STATUS}, + /* 163 */ {"setdomainname", {fmt_data, fmt_data_size}, FMT_STATUS}, + /* 164 */ {"rtschedule", + {fmt_hex, fmt_hex, fmt_hex, fmt_hex, fmt_hex}, + fmt_unknown}, + /* + * I am unsure of the parameters for rtschedule. + */ + /* 165 */ {"quotactl", + {fmt_dec, fmt_string, fmt_dec, fmt_ptr}, + FMT_STATUS}, + /* 166 */ {"_exportfs", {fmt_string, fmt_ptr}, FMT_STATUS}, + /* 167 */ {"mount", + {fmt_string, fmt_string, FMT_FLAGS, fmt_ptr}, + FMT_STATUS}, + /* 168 */ {"ustat", {fmt_hex, fmt_ptr}, FMT_STATUS}, + /* 169 */ {"_semsys", + {fmt_dec, fmt_hex, fmt_hex, fmt_hex, fmt_hex}, + fmt_dec}, + /* 170 */ {"_msgsys", + {fmt_dec, fmt_hex, fmt_hex, fmt_hex, fmt_hex, fmt_hex}, + fmt_dec}, + /* 171 */ {"_shmsys", {fmt_dec, fmt_hex, fmt_hex, fmt_hex}, fmt_dec}, + /* 172 */ {"_auditsys", {fmt_dec, fmt_hex, fmt_hex, fmt_hex}, fmt_dec}, + /* 173 */ {"_rfssys", + {fmt_dec, fmt_hex, fmt_hex, fmt_hex, fmt_hex}, + fmt_dec}, + /* 174 */ {"getdents", + {fmt_fd, fmt_post_data, FMT_SIZE}, + fmt_post_data_size}, + /* 175 */ {"_setsid", {fmt_dec}, fmt_dec}, + /* 176 */ {"fchdir", {fmt_fd}, FMT_STATUS}, + /* 177 */ {"fchroot", {fmt_fd}, FMT_STATUS}, + /* 178 */ {"vpixsys", {fmt_hex, fmt_hex}, fmt_unknown}, + /* + * I am unsure of the parameters for vpixsys. + */ + /* 179 */ {"aioread", + {fmt_fd, fmt_ptr, FMT_SIZE, FMT_SIZE, fmt_dec, fmt_ptr}, + FMT_STATUS}, + /* 180 */ {"aiowrite", + {fmt_fd, fmt_data, fmt_data_size, FMT_SIZE, fmt_dec, fmt_ptr}, + FMT_STATUS}, + /* 181 */ {"aiowait", {fmt_ptr}, fmt_ptr}, + /* 182 */ {"aiocancel", {fmt_ptr}, FMT_STATUS}, + /* 183 */ {"sigpending", {fmt_ptr}, FMT_STATUS}, + /* 184 */ {"_unknown_184", {fmt_unknown}, fmt_unknown}, + /* 185 */ {"setpgid", {fmt_dec, fmt_dec}, FMT_STATUS}, + /* 186 */ {"_pathconf", {fmt_string, fmt_dec}, fmt_dec}, + /* 187 */ {"fpathconf", {fmt_fd, fmt_dec}, fmt_dec}, + /* 188 */ {"sysconf", {fmt_dec}, fmt_dec}, + /* 189 */ {"uname", {fmt_ptr}, FMT_STATUS} + /* + * Next 8 system calls are for loadable system calls. Not declared since + * they are likely to change from one O/S release to the next. + */ +}; + +int no_system_calls = sizeof(system_calls) / sizeof(call_desc); + +call_desc system_call_open_simple = + /* 5 */ {"open", {fmt_string, fmt_open_flags}, fmt_fd}; + + +/* + * Table containing signal names. + */ + +char *signal_names[] = { + /* 0 */ "0", + /* 1 */ "SIGHUP", + /* 2 */ "SIGINT", + /* 3 */ "SIGQUIT", + /* 4 */ "SIGILL", + /* 5 */ "SIGTRAP", + /* 6 */ "SIGABRT", + /* 7 */ "SIGEMT", + /* 8 */ "SIGFPE", + /* 9 */ "SIGKILL", + /* 10 */ "SIGBUS", + /* 11 */ "SIGSEGV", + /* 12 */ "SIGSYS", + /* 13 */ "SIGPIPE", + /* 14 */ "SIGALRM", + /* 15 */ "SIGTERM", + /* 16 */ "SIGURG", + /* 17 */ "SIGSTOP", + /* 18 */ "SIGTSTP", + /* 19 */ "SIGCONT", + /* 20 */ "SIGCHLD", + /* 21 */ "SIGTTIN", + /* 22 */ "SIGTTOU", + /* 23 */ "SIGIO", + /* 24 */ "SIGXCPU", + /* 25 */ "SIGXFSZ", + /* 26 */ "SIGVTALRM", + /* 27 */ "SIGPROF", + /* 28 */ "SIGWINCH", + /* 29 */ "SIGLOST", + /* 30 */ "SIGUSR1", + /* 31 */ "SIGUSR2" +}; + +int no_signal_names = sizeof(signal_names) / sizeof(char *); + + +/* + * Table containing error messages. + */ + +char *error_names[] = { + /* 0 */ "0", + /* 1 */ "EPERM", + /* 2 */ "ENOENT", + /* 3 */ "ESRCH", + /* 4 */ "EINTR", + /* 5 */ "EIO", + /* 6 */ "ENXIO", + /* 7 */ "E2BIG", + /* 8 */ "ENOEXEC", + /* 9 */ "EBADF", + /* 10 */ "ECHILD", + /* 11 */ "EAGAIN", + /* 12 */ "ENOMEM", + /* 13 */ "EACCES", + /* 14 */ "EFAULT", + /* 15 */ "ENOTBLK", + /* 16 */ "EBUSY", + /* 17 */ "EEXIST", + /* 18 */ "EXDEV", + /* 19 */ "ENODEV", + /* 20 */ "ENOTDIR", + /* 21 */ "EISDIR", + /* 22 */ "EINVAL", + /* 23 */ "ENFILE", + /* 24 */ "EMFILE", + /* 25 */ "ENOTTY", + /* 26 */ "ETXTBSY", + /* 27 */ "EFBIG", + /* 28 */ "ENOSPC", + /* 29 */ "ESPIPE", + /* 30 */ "EROFS", + /* 31 */ "EMLINK", + /* 32 */ "EPIPE", + /* 33 */ "EDOM", + /* 34 */ "ERANGE", + /* 35 */ "EWOULDBLOCK", + /* 36 */ "EINPROGRESS", + /* 37 */ "EALREADY", + /* 38 */ "ENOTSOCK", + /* 39 */ "EDESTADDRREQ", + /* 40 */ "EMSGSIZE", + /* 41 */ "EPROTOTYPE", + /* 42 */ "ENOPROTOOPT", + /* 43 */ "EPROTONOSUPPORT", + /* 44 */ "ESOCKTNOSUPPORT", + /* 45 */ "EOPNOTSUPP", + /* 46 */ "EPFNOSUPPORT", + /* 47 */ "EAFNOSUPPORT", + /* 48 */ "EADDRINUSE", + /* 49 */ "EADDRNOTAVAIL", + /* 50 */ "ENETDOWN", + /* 51 */ "ENETUNREACH", + /* 52 */ "ENETRESET", + /* 53 */ "ECONNABORTED", + /* 54 */ "ECONNRESET", + /* 55 */ "ENOBUFS", + /* 56 */ "EISCONN", + /* 57 */ "ENOTCONN", + /* 58 */ "ESHUTDOWN", + /* 59 */ "ETOOMANYREFS", + /* 60 */ "ETIMEDOUT", + /* 61 */ "ECONNREFUSED", + /* 62 */ "ELOOP", + /* 63 */ "ENAMETOOLONG", + /* 64 */ "EHOSTDOWN", + /* 65 */ "EHOSTUNREACH", + /* 66 */ "ENOTEMPTY", + /* 67 */ "EPROCLIM", + /* 68 */ "EUSERS", + /* 69 */ "EDQUOT", + /* 70 */ "ESTALE", + /* 71 */ "EREMOTE", + /* 72 */ "ENOSTR", + /* 73 */ "ETIME", + /* 74 */ "ENOSR", + /* 75 */ "ENOMSG", + /* 76 */ "EBADMSG", + /* 77 */ "EIDRM", + /* 78 */ "EDEADLK", + /* 79 */ "ENOLCK", + /* 80 */ "ENONET", + /* 81 */ "ERREMOTE", + /* 82 */ "ENOLINK", + /* 83 */ "EADV", + /* 84 */ "ESRMNT", + /* 85 */ "ECOMM", + /* 86 */ "EPROTO", + /* 87 */ "EMULTIHOP", + /* 88 */ "EDOTDOT", + /* 89 */ "EREMCHG", + /* 90 */ "ENOSYS" +}; + +int no_error_names = sizeof(error_names) / sizeof(char *); + diff --git a/sim/ppc/spa-system-calls.h b/sim/ppc/spa-system-calls.h new file mode 100644 index 0000000000..1ee9c1edbe --- /dev/null +++ b/sim/ppc/spa-system-calls.h @@ -0,0 +1,119 @@ +/* + * Copyright (C) 1991 Gordon Irlam. All rights reserved. + */ + +/* + * Declaration of system calls for sparc trace generator. + */ + + +#if !defined(SYSCALLS_H) +#define SYSCALLS_H 1 + +/* + * Imported declarations. + */ + +#include "agent_msg.h" + + +/* + * Declaration of table containing system calls, and their parameter profile. + */ + +/* + * Words, such as the parameters and results of system calls, are capable of + * being displayed in a number of different formats. + * + * fmt_none - indicates the absense of further arguments, functions that don't + * return a value, etc. + * + * The function format_value(..) can be used to display a word in one of the + * following formats. + * + * fmt_dec - a signed decimal number : 0, 21, -1 + * fmt_hex - a unsigned hex number : 0x0, 0x15, 0xffffffff + * fmt_ptr - a pointer : NULL, 0x00000015, 0xffffffff + * fmt_fd - a file descriptor : fd0, fd15, fd-1 + * fmt_signal - the name of a signal : 0, SIGTTIN, -1 + * fmt_error - the name of an error : 0, EISDIR, -1 + * fmt_open_flags - the flags to open : O_RDONLY, O_WRONLY|0x14, 0xffffffff + * fmt_unknown - representation unknown : .., .., .. + * fmt_string - if the null termintated string at word is printable displays + * the string within quotes, otherwise displays like fmt_ptr + * fmt_post_string - displays like fmt_ptr, value of word is also saved, + * following the system call a printable string exists at + * address word the address and the string will be displayed + * fmt_data - only permitted in argument lists, next argument must be + * format_data_size, if printable data exists at word having length + * specified by the next argument it is printed, otherwise displays + * like fmt_ptr + * fmt_data_size - displays like FMT_SIZE + * fmt_post_data - displays like fmt_ptr, value of word is also saved, + * following call if a printable length delimited string exists + * it will be displayed + * fmt_post_data_size - displays like FMT_SIZE, value is saved for use as + * length for fmt_post_data display format + * fmt_string_array - word is the address of a null terminted array of strings + * to be printed if possible + * + * Unlike the string formats which typically represent filenames it is not so + * important that length delimited data be fully displayed. When printable, + * it will be truncate much more harshly than the string formats. + * + * Only one item can be pending for display at the end of a system call. + * + * At a later date this program may be extended to display length delimited + * data as a hex dump if it is not printable. + * + * The following macros are employed to make it easy to alter how a whole + * class of values is displayed by changing their definition. + * + * FMT_STATUS - function calls that return 0 on success and -1 on error + * FMT_FLAGS - bit field objects + * FMT_SIZE - length of an object in bytes + */ +typedef enum fmt_type {fmt_none = 0, fmt_dec, fmt_hex, fmt_ptr, fmt_fd, + fmt_signal, fmt_error, fmt_open_flags, fmt_unknown, fmt_string, + fmt_post_string, fmt_data, fmt_post_data, fmt_data_size, + fmt_post_data_size, fmt_string_array} fmt_type; + +#define FMT_STATUS fmt_none +#define FMT_FLAGS fmt_hex +#define FMT_SIZE fmt_dec + +typedef struct _spa_call_desc { + char *name; + fmt_type arg[NO_PARAMS]; + fmt_type result; +} spa_call_desc; + +extern spa_call_desc spa_system_calls[]; + +extern int no_system_calls; + +extern spa_call_desc spa_system_call_open_simple; + +#define SPA_DATA_SIZE_LIMIT 20 +#define SPA_STRING_SIZE_LIMIT 201 +#define SPA_ARRAY_SIZE_LIMIT 21 + + +/* + * Declaration of table containing signal names. + */ + +extern char *spa_signal_names[]; + +extern int spa_no_signal_names; + + +/* + * Declaration of table containing error messages. + */ + +char *spa_error_names[]; + +extern int spa_no_error_names; + +#endif diff --git a/sim/ppc/std-config.h b/sim/ppc/std-config.h index 07018bfaa1..9e06267c06 100644 --- a/sim/ppc/std-config.h +++ b/sim/ppc/std-config.h @@ -29,32 +29,52 @@ of the host/target it is able to eliminate slower generic endian handling code. - If ENDIAN_OK is true then no byte swapping is required. If it is - false, copy-in / copy-out functions assume that data should be byte - reversed as part of the copy. */ + Possible values are 0 (unknown), LITTLE_ENDIAN, BIG_ENDIAN */ +#ifndef WITH_HOST_BYTE_ORDER #define WITH_HOST_BYTE_ORDER 0 /*unknown*/ +#endif + +#ifndef WITH_TARGET_BYTE_ORDER #define WITH_TARGET_BYTE_ORDER 0 /*unknown*/ +#endif extern int current_host_byte_order; -extern int current_target_byte_order; #define CURRENT_HOST_BYTE_ORDER (WITH_HOST_BYTE_ORDER \ ? WITH_HOST_BYTE_ORDER \ : current_host_byte_order) +extern int current_target_byte_order; #define CURRENT_TARGET_BYTE_ORDER (WITH_TARGET_BYTE_ORDER \ ? WITH_TARGET_BYTE_ORDER \ : current_target_byte_order) +/* Intel host BSWAP support: + + Whether to use bswap on the 486 and pentiums rather than the 386 + sequence that uses xchgb/rorl/xchgb */ +#ifndef WITH_BSWAP +#define WITH_BSWAP 0 +#endif + + /* SMP support: Sets a limit on the number of processors that can be simulated. If WITH_SMP is set to zero (0), the simulator is restricted to suporting only on processor (and as a consequence leaves the SMP - code out of the build process). */ + code out of the build process). + + The actual number of processors is taken from the device + /options/smp@ */ #ifndef WITH_SMP -#define WITH_SMP 0 +#define WITH_SMP 2 +#endif +#if WITH_SMP +#define MAX_NR_PROCESSORS WITH_SMP +#else +#define MAX_NR_PROCESSORS 1 #endif @@ -68,6 +88,7 @@ extern int current_target_byte_order; #ifndef WITH_TARGET_WORD_BITSIZE #define WITH_TARGET_WORD_BITSIZE 32 /* compiled only */ #endif + #ifndef WITH_HOST_WORD_BITSIZE #define WITH_HOST_WORD_BITSIZE 32 /* 64bit ready? */ #endif @@ -85,10 +106,13 @@ extern int current_target_byte_order; CURRENT_ENVIRONMENT specifies which of vea or oea is required for the current runtime. */ -#define WITH_ENVIRONMENT 0 #define VIRTUAL_ENVIRONMENT 1 #define OPERATING_ENVIRONMENT 2 +#ifndef WITH_ENVIRONMENT +#define WITH_ENVIRONMENT 0 +#endif + extern int current_environment; #define CURRENT_ENVIRONMENT (WITH_ENVIRONMENT \ ? WITH_ENVIRONMENT \ @@ -170,6 +194,7 @@ extern int current_environment; #ifndef WITH_ALIGNMENT #define WITH_ALIGNMENT 0 #endif + extern int current_alignment; #define CURRENT_ALIGNMENT (WITH_ALIGNMENT \ ? WITH_ALIGNMENT \ @@ -210,254 +235,16 @@ extern int current_floating_point; #define WITH_ASSERT 1 #endif -/* include profiling code that doesn't yet exist */ - -#ifndef WITH_PROFILE -#define WITH_PROFILE 1 -#endif - - -/* INSTRUCTION TABLE CODE GENERATION: - - The program gen takes the files ppc.instructions and spr.table and - creates from them code that provides: - - o instruction decode and issue - o spr information - - The program gen does this according to the configuration - information that follows. */ - - -/* Line numbering of generated code: - - When generating the semantic and idecode files, gen can also output - line number information (w.r.t. ppc.instructions). It may be - useful to disable this if you suspect that gen.c is incorrectly - generating itermediate code files. */ - -#ifndef WITH_LINE_NUMBERS -#define WITH_LINE_NUMBERS 1 -#endif - - -/* Instruction cache: - - Instead of the idecode routine calling the semantic function - directly, idecode can instead return a descriptor of the - instruction (cache entry). - - With level one caching, idecode just returns the address of the - semantic function. With level two caching, in addition to this, - the idecode routine decodes key fields within the instruction and - also enters them into the cache. The table IDECODE_CACHE_RULES - controls what goes into the cache.*/ - -#ifndef WITH_IDECODE_CACHE -#define WITH_IDECODE_CACHE 0 -#endif -#ifndef IDECODE_CACHE_SIZE -#define IDECODE_CACHE_SIZE 1024 -#endif - - -/* Semantic code expansion: - - For a given instruction there is the potential to improve - performance bo creating copies of the instructions code for one or - more of its possible variations. Eg branch being relative. This - macro determines of semantic functions should be expanded. How - well they are expanded is determined by the table - WITH_IDECODE_OPCODE_RULES. */ - -#ifndef WITH_IDECODE_EXPAND_SEMANTICS -#define WITH_IDECODE_EXPAND_SEMANTICS 0 -#endif - - -/* SPR database: - - The attributes of the SPR's are kept in a `lookup table'. This - table can be implemented as either a true table or a switch - statement. +/* include monitoring code */ - A swith statement may be a performance advantage if the SPR's are - known at compile time. The compiler is then able to eliminate the - switch. */ - -#ifndef WITH_SPREG_LOOKUP_TABLE -#define WITH_SPREG_LOOKUP_TABLE 1 +#define MONITOR_INSTRUCTION_ISSUE 1 +#define MONITOR_LOAD_STORE_UNIT 2 +#ifndef WITH_MON +#define WITH_MON (MONITOR_LOAD_STORE_UNIT \ + | MONITOR_INSTRUCTION_ISSUE) #endif -/* Instruction decode: - - The table that follows is used by gen to construct a decision tree - that can identify each possible instruction. Gen then outputs this - decision tree as (according to config) a table or switch statement - as the function idecode. - - In parallel to this, as mentioned above, WITH_EXPANDED_SEMANTICS - determines of the semantic functions themselves should be expanded - in a similar way. - - The table contains the following entries: - - - - Must be 1 for the entry to be considered. The last entry must be - zero. - - - - - Range of bits (within the instruction) that should be searched for - an instruction field. Within such ranges, gen looks for opcodes - (constants), registers (strings) and reserved bits (slash) and - according to the rules that follows includes or excludes them from - a possible instruction field. - - - - - If an instructioin field was found, enlarge the field size so that - it is forced to at least include bits starting from - (). To stop this occuring, use = - + 1 and = - 1. - - - - Treat `/' fields as a constant instead of variable when looking for - an instruction field. - - - - Treat any contained register (string) fields as constant when - determining the instruction field. For the instruction decode (and - controled by IDECODE_EXPAND_SEMANTICS) this forces the expansion of - what would otherwize be non constant bits of an instruction. - - - - Should this table be expanded using a switch statement (val 1) and - if so, should it be padded with entries so as to force the compiler - to generate a jump table (val 2). - - - - - - Special rule to fine tune how specific (or groups) of instructions - are expanded. The applicability of the rule is determined by - - != 0 && (instruction> & ) == - - Where is obtained by looking only at constant fields - with in an instructions spec. When determining an expansion, the - rule is only considered when a node contains a single instruction. - can be any of: - - 0: for this instruction, expand by earlier rules - 1: expand bits .. only - 2: boolean expansion of only zero/non-zero cases - - Ok? */ - - -#define WITH_IDECODE_OPCODE_RULES { \ - { 1, 0, 5, 0, 5, 0, 0, 1, 0x00000000, 0x00000000, 0 }, \ - { 1, 21, 31, 32, -1, 0, 0, 1, 0x00000000, 0x00000000, 0 }, \ - { 0 } \ -} - - -/* Instruction unpacking: - - Once the instruction has been decoded, the register (and other) - fields within the instruction need to be extracted. - - The table that follows determines how each field should be treated. - Importantly it considers the case where the extracted field is to - be used immediatly or stored in an instruction cache. - - - - Zero marks the end of the table. More importantly 1. indicates - that the entry is valid and can be cached. 2. indicates that that - the entry is valid but can not be cached. - - - - The field name as given in the instruction spec. - - - - A name for once it has been extracted from the - instructioin (and possibly stored in the instruction cache). - - - - String specifying the storage type for (the extracted - field>. - - - - Specifies how to get from . If null, old and - new name had better be the same. */ - -#define WITH_IDECODE_CACHE_RULES { \ - { 1, "RA", "RA", 0, 0 }, \ - { 1, "RA", "rA", "signed_word *", \ - "(cpu_registers(processor)->gpr + RA)" }, \ - { 1, "RT", "RT", 0, 0 }, \ - { 1, "RT", "rT", "signed_word *", \ - "(cpu_registers(processor)->gpr + RT)" }, \ - { 2, "RS", "RS", 0, 0 }, \ - { 1, "RS", "rS", "signed_word *", \ - "(cpu_registers(processor)->gpr + RS)" }, \ - { 2, "RB", "RB", 0, 0 }, \ - { 1, "RB", "rB", "signed_word *", \ - "(cpu_registers(processor)->gpr + RB)" }, \ - { 2, "FRA", "FRA", 0, 0 }, \ - { 1, "FRA", "frA", "unsigned64 *", \ - "(cpu_registers(processor)->fpr + FRA)" }, \ - { 2, "FRB", "FRB", 0, 0 }, \ - { 1, "FRB", "frB", "unsigned64 *", \ - "(cpu_registers(processor)->fpr + FRB)" }, \ - { 2, "FRC", "FRC", 0, 0 }, \ - { 1, "FRC", "frC", "unsigned64 *", \ - "(cpu_registers(processor)->fpr + FRC)" }, \ - { 2, "FRS", "FRS", 0, 0 }, \ - { 1, "FRS", "frS", "unsigned64 *", \ - "(cpu_registers(processor)->fpr + FRS)" }, \ - { 2, "FRT", "FRT", 0, 0 }, \ - { 1, "FRT", "frT", "unsigned64 *", \ - "(cpu_registers(processor)->fpr + FRT)" }, \ - { 1, "SI", "EXTS_SI", "unsigned_word", \ - "((signed_word)(signed16)instruction)" }, \ - { 2, "BI", "BI", 0, 0 }, \ - { 1, "BI", "BIT32_BI", 0, \ - "BIT32(BI)" }, \ - { 2, "BA", "BA", 0, 0 }, \ - { 1, "BA", "BIT32_BA", 0, \ - "BIT32(BA)" }, \ - { 2, "BB", "BB", 0, 0 }, \ - { 1, "BB", "BIT32_BB", 0, \ - "BIT32(BB)" }, \ - { 1, "BD", "EXTS_BD_0b00", "unsigned_word", \ - "(((signed_word)(signed16)instruction) & ~3)" }, \ -/*{ 1, "BD", "CIA_plus_EXTS_BD_0b00", "unsigned_word", */ \ -/* "CIA + EXTS(BD_0b00)" }, */ \ - { 1, "LI", "EXTS_LI_0b00", "unsigned_word", \ - "((((signed_word)(signed32)(instruction << 6)) >> 6) & ~0x3)" }, \ - { 1, "D", "EXTS_D", "unsigned_word", \ - "((signed_word)(signed16)(instruction))" }, \ - { 1, "DS", "EXTS_DS_0b00", "unsigned_word", \ - "(((signed_word)(signed16)instruction) & ~0x3)" }, \ - { 0 } \ -}; - - /* INLINE CODE SELECTION: @@ -486,12 +273,14 @@ extern int current_floating_point; controled by the _INLINE macro's. Where each can have a value: - 0 ppc.c should call external module + 0 Make a normal external call to functions in the module. - 1 ppc.c should have local copy (and hence possibly facilitate - the in lineing of that modules external calls) + 1 Include the module but to not inline functions within it. + This allows functions within the module to inline functions + from other modules that have been included. - 2 ppc.c should inline this module + 2 Both include the module and inline functions contained within + it. Finally, this is not for the faint harted. I've seen GCC get up to 200mb trying to compile what this can create */ @@ -512,86 +301,92 @@ extern int current_floating_point; #define STATIC_INLINE static INLINE #endif -/* Default macro to control several of the inlines */ +/* Default macro to simplify control several of key the inlines */ #ifndef DEFAULT_INLINE +#if defined(__GNUC__) && defined(__OPTIMIZE__) +#define DEFAULT_INLINE 2 +#else #define DEFAULT_INLINE 0 #endif +#endif -/* Code that does byte swapping used on any memory access */ +/* Code that converts between hosts and target byte order. Used on + every memory access (instruction and data). (See ppc-endian.h for + additional byte swapping configuration information) */ #ifndef ENDIAN_INLINE #define ENDIAN_INLINE DEFAULT_INLINE #endif -/* Instruction cache if in use */ - -#if 0 /*DNE*/ -#ifndef ICACHE_INLINE -#define ICACHE_INLINE 0 -#endif -#endif - -/* Given a translated address, core maps it onto either simulator data - or a function call, this is performed once for each - data/instruction access */ +/* Code that gives access to various CPU internals such as registers. + Used every time an instruction is executed */ - -#ifndef CORE_INLINE -#define CORE_INLINE DEFAULT_INLINE +#ifndef CPU_INLINE +#define CPU_INLINE DEFAULT_INLINE #endif - -/* The cpu object. May things call upon this module to manipulate - each cpu object for instance register updates (from semantics) or - instruction execution from psim */ +/* Code that translates between an effective and real address. Used + by every load or store. */ #ifndef VM_INLINE #define VM_INLINE DEFAULT_INLINE #endif -/* Physical memory is implemented using the memory map module */ +/* Code that loads/stores data to/from the memory data structure. + Used by every load or store */ -#ifndef CPU_INLINE -#define CPU_INLINE DEFAULT_INLINE +#ifndef CORE_INLINE +#define CORE_INLINE DEFAULT_INLINE #endif -/* handle the queue of events to happen in the future */ +/* Code to check for and process any events scheduled in the future. + Called once per instruction cycle */ #ifndef EVENTS_INLINE #define EVENTS_INLINE DEFAULT_INLINE #endif -/* not so important register manipulation code. Most important - register operations are performed directly on the register file */ +/* Code monotoring the processors performance. It counts events on + every instruction cycle */ -#ifndef REGISTERS_INLINE -#define REGISTERS_INLINE DEFAULT_INLINE +#ifndef MON_INLINE +#define MON_INLINE DEFAULT_INLINE #endif -/* interrupt handling code */ +/* Code called on the rare occasions that an interrupt occures. */ #ifndef INTERRUPTS_INLINE -#define INTERRUPTS_INLINE DEFAULT_INLINE +#define INTERRUPTS_INLINE 0 +#endif + +/* Code called on the rare occasion that either gdb or the device tree + need to manipulate a register within a processor */ + +#ifndef REGISTERS_INLINE +#define REGISTERS_INLINE 0 #endif -/* device code. While possibly important, this isn't as critical as - the cpu/memory path +/* Code called on the rare occasion that a processor is manipulating + real hardware instead of RAM. + + Also, most of the functions in devices.c are always called through + a jump table. There seems to be some problem with making either device_tree or - devices inline. It reports the message: - device_tree_find_node() not a leaf */ + devices inline. It reports the message: device_tree_find_node() + not a leaf */ #ifndef DEVICE_TREE_INLINE -#define DEVICE_TREE_INLINE 0 +#define DEVICE_TREE_INLINE DEFAULT_INLINE #endif #ifndef DEVICES_INLINE #define DEVICES_INLINE 0 #endif -/* Special Purpose Register tables. Provide information on the - attributes of given SPR's. */ +/* Code called whenever information on a Special Purpose Register is + required. Called by the mflr/mtlr pseudo instructions */ #ifndef SPREG_INLINE #define SPREG_INLINE DEFAULT_INLINE @@ -610,163 +405,14 @@ extern int current_floating_point; inline all of their called functions */ #ifndef SEMANTICS_INLINE -#define SEMANTICS_INLINE 0 +#define SEMANTICS_INLINE (DEFAULT_INLINE ? 1 : 0) #endif -/* Functions that decode an instruction. Called by the cpu module. - Part of the performance critical fetch - decode - issue sequence */ +/* Code to decode an instruction. Normally called on every instruction + cycle */ #ifndef IDECODE_INLINE #define IDECODE_INLINE DEFAULT_INLINE #endif - - -/* If you're confused by the above, check out some of the generic - configurations below. */ - - -#if 0 -/* Allow the expansion of the semantic functions. That is, if the - branch instruction is called with AA=0 and AA=1, generate separate - functions for each case */ - -#undef WITH_IDECODE_EXPAND_SEMANTICS -#define WITH_IDECODE_EXPAND_SEMANTICS 1 - -#undef WITH_IDECODE_OPCODE_RULES -#define WITH_IDECODE_OPCODE_RULES { \ - { 1, 0, 5, 0, 5, 0, 0, 0, 0x00000000, 0x00000000, 0 }, \ - { 1, 21, 31, 32, -1, 0, "OE,LR,AA,Rc,LK", 0, 0x00000000, 0x00000000, 0 }, \ - { 1, 6, 9, 6, 9, 0, "BO", 0, 0xfc000000, 0x40000000, 1 }, \ - { 1, 11, 15, 11, 15, 0, "RA", 0, 0xfc000000, 0x38000000, 2 }, \ - { 1, 11, 15, 11, 15, 0, "RA", 0, 0xfc000000, 0x3c000000, 2 }, \ - { 0 } \ -} -#endif - - -#if 0 -/* eliminate any debugging noise */ - -#undef WITH_TRACE -#define WITH_TRACE 0 - -#undef WITH_ASSERT -#define WITH_ASSERT 0 - -#endif - - -#if 0 -/* A reasonable set of inline macro's that give the compiler a - fighting chance at eliminating much of the function call overhead. - - Typically, with the below the -O3 option (to get inline of all - functioins) isn't of any greate benefit. */ - -#undef INLINE -#define INLINE inline - -#undef STATIC_INLINE -#define STATIC_INLINE static INLINE - -#undef ENDIAN_INLINE -#define ENDIAN_INLINE 2 - -#if 0 /*DNE*/ -#undef ICACHE_INLINE -#define ICACHE_INLINE 0 -#endif - -#undef CORE_INLINE -#define CORE_INLINE 2 - -#undef VM_INLINE -#define VM_INLINE 2 - -#undef CPU_INLINE -#define CPU_INLINE 2 - -#undef EVENTS_INLINE -#define EVENTS_INLINE 2 - -#undef REGISTERS_INLINE -#define REGISTERS_INLINE 2 - -#undef INTERRUPTS_INLINE -#define INTERRUPTS_INLINE 2 - -#undef DEVICE_TREE_INLINE -#define DEVICE_TREE_INLINE 0 - -#undef DEVICES_INLINE -#define DEVICES_INLINE 0 - -#undef SPREG_INLINE -#define SPREG_INLINE 2 - -#undef SEMANTICS_INLINE -#define SEMANTICS_INLINE 1 /* not 2! as it blows away the compiler */ - -#undef IDECODE_INLINE -#define IDECODE_INLINE 2 - -#endif - - -#if 0 -/* Enable the full cracking cache. The cracked instruction cache - appears to give best performance if most functions have been lined - as well */ - -#undef WITH_IDECODE_CACHE -#define WITH_IDECODE_CACHE 2 - -#endif - - - -#if 0 -/* With the VEA model, can eliminate some things. Not least of which - is support for the OEA model */ - -#undef WITH_ENVIRONMENT -#define WITH_ENVIRONMENT VIRTUAL_ENVIRONMENT - -#undef WITH_EVENTS -#define WITH_EVENTS 0 - -#undef WITH_SMP -#define WITH_SMP 0 - -#undef WITH_TARGET_BYTE_ORDER -#define WITH_TARGET_BYTE_ORDER WITH_HOST_BYTE_ORDER - -#endif - - - - -#if 0 -/* Finally, the expansion rules below are extreemly agressive. Only - consider them if your build machine is VERY VERY VERY VERY VERY - well configured */ - -#undef WITH_IDECODE_EXPAND_SEMANTICS -#define WITH_IDECODE_EXPAND_SEMANTICS 1 - -#undef WITH_IDECODE_OPCODE_RULES -#define WITH_IDECODE_OPCODE_RULES { \ - { 1, 0, 5, 0, 5, 0, 0, 0, 0x00000000, 0x00000000, 0 }, \ - { 1, 21, 31, 32, -1, 0, "OE,LR,AA,Rc,LK", 0, 0x00000000, 0x00000000, 0 }, \ - { 1, 6, 15, 6, 15, 0, "BO,BI", 0, 0xfc000000, 0x40000000, 0 }, \ - { 1, 11, 15, 11, 15, 0, "RA", 0, 0xfc000000, 0x38000000, 0 }, \ - { 1, 11, 15, 11, 15, 0, "RA", 0, 0xfc000000, 0x3c000000, 0 }, \ - { 1, 11, 20, 11, 20, 0, "spr", 0, 0xfc000000, 0x7c000000, 0 }, \ - { 0 } \ -} -#endif - - #endif /* _CONFIG_H */ diff --git a/sim/ppc/system.c b/sim/ppc/system.c deleted file mode 100644 index 25ea8eb3ce..0000000000 --- a/sim/ppc/system.c +++ /dev/null @@ -1,720 +0,0 @@ -/* This file is part of the program psim. - - Copyright (C) 1994-1995, Andrew Cagney - - 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 _SYSTEM_C_ -#define _SYSTEM_C_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#if (NetBSD >= 199306) /* here NetBSD as that is what we're emulating */ -#include /* FIXME - should not be including this one */ -#include -#endif - -#if (BSD < 199306) /* here BSD as just a bug */ -extern int errno; -#endif - -#include "cpu.h" -#include "idecode.h" -#include "system.h" - - -#ifndef STATIC_INLINE_SYSTEM -#define STATIC_INLINE_SYSTEM STATIC_INLINE -#endif - - -#if (NetBSD >= 199306) -#define SYS(X) ASSERT(call == (SYS_##X)) -#else -#define SYS(X) -#endif - -#if (NetBSD >= 199306 && PATH_MAX != 1024) -#error "PATH_MAX not 1024" -#elif !defined(PATH_MAX) -#define PATH_MAX 1024 -#endif - - -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; -} - - -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; -} - - -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 - 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); -} - - -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), - scratch_buffer, - buf, - status, - 0/*violate_ro*/); - if (nr_moved != status) - error("system_call()read - write to buffer failed\n"); - } - } - - zfree(scratch_buffer); -} - - -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) - 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 - 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("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/table.h b/sim/ppc/table.h new file mode 100644 index 0000000000..1fe29d2146 --- /dev/null +++ b/sim/ppc/table.h @@ -0,0 +1,49 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1995, Andrew Cagney + + 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. + + */ + + +/* load a table into memory */ + +typedef struct _table table; + +typedef struct _table_entry table_entry; +struct _table_entry { + int line_nr; + int nr_fields; + char *file_name; + char *annex; + char *fields[0]; /* User defined */ +}; + + +extern table *table_open +(char *file_name, + int max_nr_fields); + +extern table_entry *table_entry_read +(table *file); + +extern void dump_table_entry +(table_entry *entry, + int indent); + +extern void table_entry_lf_c_line_nr +(lf *file, + table_entry *entry); -- 2.34.1