General cleanup; add -t options support to print all options

diff --git a/sim/ppc/.Sanitize b/sim/ppc/.Sanitize
index f72289bf55ae6c6142a2ba6443fc00625ce56e67..1c8e3c963bdc2d13a393740a6b7281332afc4f3e 100644 (file)
--- a/sim/ppc/.Sanitize
+++ b/sim/ppc/.Sanitize
@@ -78,6 +78,8 @@ mon.c
 mon.h
 os_emul.c
 os_emul.h
+options.c
+options.h
 ppc-cache-rules
 ppc-instructions
 ppc-opcode-complex

diff --git a/sim/ppc/ChangeLog b/sim/ppc/ChangeLog
index 60decfdaf4189a06392aecde983d66caf837d9f7..cbfa812f5613d614e182d6ae4391c8394905b371 100644 (file)
--- a/sim/ppc/ChangeLog
+++ b/sim/ppc/ChangeLog
@@ -1,5 +1,53 @@
 Wed Nov  8 13:19:47 1995  Michael Meissner  <meissner@tiktok.cygnus.com>
 
+       * options.c: New file to print out all of the WITH_ options.
+       * options.h: New include file to declare print_options.
+       * debug.h (trace_options): Add trace_opts to call print_options.
+       * debug.c (trace_description): Add trace_opts support.
+       * main.c (main): If user requested options, print them.
+       * sim_calls.c (sim_open): Ditto.
+       
+       * igen.c (opcode_field_new): Add void to make it a proper prototype.
+
+       * emul_generic.c (emul_enter_call): Make printf_filtered arguments
+       type correct.
+       * emul_netbsd.c (do_kill): Ditto.
+       * registers.c (registers_dump): Ditto.
+       * vm.c (om_translate_effective_to_real): Ditto.
+       * vm_n.h (vm_data_map_read_N): Ditto.
+       (vm_data_map_write_N): Ditto.
+       * devices.h (DTRACE_INIT): Ditto.
+       (DTRACE_{ATTACH,DETACH}_ADDRESS): Ditto.
+       (DTRACE_IO_{READ,WRITE}_BUFFER): Ditto.
+       (DTRACE_DMA_{READ,WRITE}_BUFFER): Ditto.
+       * devices.c (update_for_binary_section): Ditto.
+       (write_stack_arguments): Ditto.
+       (stack_ioctl_callback): Ditto.
+       * device_tree.c (device_tree_add_passthrough): Ditto.
+       (device_tree_{add,find}_device): Ditto.
+       (device_tree_{add,find}_integer): Ditto.
+       (device_tree_find_{string,boolean}): Ditto.
+       (device_tree_init{,_device}): Ditto.
+       (device_tree_dump): Ditto.
+       * sim_calls.c (sim_{read,write}): Ditto.
+       (sim_{fetch,store}_register): Ditto.
+       (sim_stop_reason): Ditto.
+
+       * sim_callbacks.h (printf_filtered): Declare with attribute
+       printf, so we can enable format checks.
+
+       * devices.c (console_io_{read,write}_buffer_callback): Cast swtich
+       argument to int, since ANSI doesn't allow long switch values.
+       * emul_netbsd.c (do___sysctl): Ditto.
+
+       * emul_netbsd.c (do___sysctl): Fix up printf call.
+       
+       * corefile.c (core_translate): Don't do arithmetic with void *
+       pointers.  Cast to char * first.
+       
+       * function_unit.c (FUNC_{LOAD,STORE}): Rename from {LOAD,STORE}
+       and change all uses.
+
        * Makefile.in ({FUNC,MODEL,WARNING}_CFLAGS): New flags set by
        configure --enable switches.
        (CONFIG_CFLAGS): Include FUNC_CFLAGS and MODE_CFLAGS.
@@ -11,9 +59,9 @@ Wed Nov  8 13:19:47 1995  Michael Meissner  <meissner@tiktok.cygnus.com>
        (BUILT_SRC): Include BUILT_SRC_WO_CONFIG, config.h and
        ppc-config.h.
        (filter_filename.o): Include config.h/ppc-config.h dependencies.
-       (idecode.o, semantics.o): Specify CC line without WARNING_CFLAGS
-       so that we don't get all of the unused variable warnings that are
-       generated.
+       (idecode.o, semantics.o, psim.o): Specify CC line without
+       WARNING_CFLAGS so that we don't get all of the unused variable
+       warnings that are generated.
        (function_unit.o): Add rule to build.
        (main.o, sim_calls.o): Add function_unit.h, itable.h dependencies.
        (mon.o): Include mon.c dependency.

diff --git a/sim/ppc/Makefile.in b/sim/ppc/Makefile.in
index 0a12ee794327812c597204301ec971ce53bc313b..4bf46ce24fd3ad9afac4a24e023961e06f84392b 100644 (file)
--- a/sim/ppc/Makefile.in
+++ b/sim/ppc/Makefile.in
@@ -214,7 +214,8 @@ LIB_SRC = \
        interrupts.c \
        devices.c \
        device_tree.c \
-       mon.c
+       mon.c \
+       options.c
 
 MAIN_SRC = \
        main.c \
@@ -225,6 +226,7 @@ MAIN_SRC = \
 #       first
 LIB_OBJ = \
        debug.o \
+       options.o \
        filter_filename.o \
        bits.o \
        sim-endian.o \
@@ -266,6 +268,7 @@ $(TARGETLIB): tmp-igen tmp-dgen $(LIB_OBJ) $(GDB_OBJ)
 # Given that inlines are turned on now, rebuild psim whenever
 # anything changes.
 psim.o: psim.c psim.h $(CPU_H) $(IDECODE_H) $(INLINE) $(LIB_SRC) $(BUILT_SRC)
+       $(CC) -c $(CFLAGS) $(INLINE_CFLAGS) $(CONFIG_CFLAGS) $(SIM_CFLAGS) $(HDEFINES) $(TDEFINES) $(INCLUDES) $<
 
 bits.o: bits.c $(BASICS_H)
 
@@ -298,11 +301,11 @@ function_unit.o: function_unit.c $(CPU_H)
 
 events.o: events.c events.h $(BASICS_H) 
 
-sim_calls.o: sim_calls.c $(PSIM_H) function_unit.h itable.h ../../gdb/tm.h devices.h
+sim_calls.o: sim_calls.c $(PSIM_H) function_unit.h itable.h ../../gdb/tm.h devices.h options.h
 
 spreg.o: spreg.h spreg.c words.h
 
-main.o: main.c $(PSIM_H) function_unit.h itable.h
+main.o: main.c $(PSIM_H) function_unit.h itable.h options.h
 
 devices.o: devices.c devices.h $(BASICS_H) \
        device_tree.h events.h
@@ -316,6 +319,8 @@ itable.o: itable.c itable.h
 
 mon.o: mon.c $(CPU_H)
 
+options.o: options.c $(BASICS_H)
+
 #
 # Rules to create the built c source code files
 #

diff --git a/sim/ppc/configure b/sim/ppc/configure
index 9c3b40d040e79acf46a17059969de2675fa4d53e..28c40ecf5c1f944b4da570e9599baa464314433e 100755 (executable)
--- a/sim/ppc/configure
+++ b/sim/ppc/configure
@@ -14,7 +14,7 @@ ac_default_prefix=/usr/local
 ac_help="$ac_help
   --enable-sim-cflags=opts             Extra CFLAGS for use in building simulator"
 ac_help="$ac_help
-  --enable-sim-warnings=opts           Extra CFLAGS for turning on compiler warnings"
+  --enable-sim-warnings=opts           Extra CFLAGS for turning on compiler warnings except for idecode.o, semantics.o and psim.o"
 ac_help="$ac_help
   --enable-sim-config=file             Override default config file"
 ac_help="$ac_help
@@ -465,7 +465,7 @@ fi
 enableval="$enable_sim_warnings"
 if test -n "$enableval"; then
   case "${enableval}" in
-  yes) sim_warnings="-Wall";;
+  yes) sim_warnings="-Wall -Wpointer-arith -Wbad-function-cast -Wmissing-prototypes -Wmissing-declarations";;
   no)  sim_warnings="-w";;
   *)   sim_warnings=`echo "${enableval}" | sed -e "s/,/ /g"`;;
 esac

diff --git a/sim/ppc/configure.in b/sim/ppc/configure.in
index 4ebcefbcf2ffcf326b3a734d1251bc0aea9cb214..9c195a7f89e3c4e1a2fe4c0b131153824e8fb0be 100644 (file)
--- a/sim/ppc/configure.in
+++ b/sim/ppc/configure.in
@@ -11,9 +11,9 @@ AC_ARG_ENABLE(sim-cflags,
 esac],[sim_cflags=""])dnl
 
 AC_ARG_ENABLE(sim-warnings,
-[  --enable-sim-warnings=opts          Extra CFLAGS for turning on compiler warnings except for idecode.o and semantics.o],
+[  --enable-sim-warnings=opts          Extra CFLAGS for turning on compiler warnings except for idecode.o, semantics.o and psim.o],
 [case "${enableval}" in
-  yes) sim_warnings="-Wall";;
+  yes) sim_warnings="-Wall -Wpointer-arith -Wbad-function-cast -Wmissing-prototypes -Wmissing-declarations";;
   no)  sim_warnings="-w";;
   *)   sim_warnings=`echo "${enableval}" | sed -e "s/,/ /g"`;;
 esac],[sim_warnings=""])dnl

diff --git a/sim/ppc/device_tree.c b/sim/ppc/device_tree.c
index 2997388dcdb7a6284ddce75f49550063507c2678..0fb019b1a24c2a678c2fed2498d3cce4968f9564 100644 (file)
--- a/sim/ppc/device_tree.c
+++ b/sim/ppc/device_tree.c
@@ -207,7 +207,7 @@ device_tree_add_passthrough(device_tree *root,
 {
   device_tree *new_node;
   TRACE(trace_device_tree,
-       ("device_tree_add_passthrough(root=0x%x, path=%s)\n", root, path));
+       ("device_tree_add_passthrough(root=0x%lx, path=%s)\n", (long)root, path));
   new_node = device_tree_find_node(root,
                                   path,
                                   path, /*full_path*/
@@ -220,7 +220,7 @@ device_tree_add_passthrough(device_tree *root,
                                        new_node->parent->device);
   
   TRACE(trace_device_tree,
-       ("device_tree_add_passthrough() = 0x%x\n", new_node));
+       ("device_tree_add_passthrough() = 0x%lx\n", (long)new_node));
   return new_node;
 }
 
@@ -232,8 +232,8 @@ device_tree_add_device(device_tree *root,
 {
   device_tree *new_node;
   TRACE(trace_device_tree,
-       ("device_tree_add_device(root=0x%x, path=%s, dev=0x%x)\n",
-        root, path, dev));
+       ("device_tree_add_device(root=0x%lx, path=%s, dev=0x%lx)\n",
+        (long)root, path, (long)dev));
   new_node = device_tree_find_node(root,
                                   path,
                                   path, /* full-path */
@@ -241,7 +241,7 @@ device_tree_add_device(device_tree *root,
                                   device_tree_grow);
   new_node->device = dev;
   TRACE(trace_device_tree,
-       ("device_tree_add_device() = 0x%x\n", new_node));
+       ("device_tree_add_device() = 0x%lx\n", (long)new_node));
   return new_node;
 }
 
@@ -252,8 +252,8 @@ device_tree_add_integer(device_tree *root,
 {
   device_tree *new_node;
   TRACE(trace_device_tree,
-       ("device_tree_add_integer(root=0x%x, path=%s, integer=%d)\n",
-        root, path, integer));
+       ("device_tree_add_integer(root=0x%lx, path=%s, integer=%ld)\n",
+        (long)root, path, (long)integer));
   new_node = device_tree_find_node(root,
                                   path,
                                   path, /* full-name */
@@ -261,7 +261,7 @@ device_tree_add_integer(device_tree *root,
                                   device_tree_grow);
   new_node->integer = integer;
   TRACE(trace_device_tree,
-       ("device_tree_add_integer() = 0x%x\n", new_node));
+       ("device_tree_add_integer() = 0x%lx\n", (long)new_node));
   return new_node;
 }
 
@@ -272,8 +272,8 @@ device_tree_add_string(device_tree *root,
 {
   device_tree *new_node;
   TRACE(trace_device_tree,
-       ("device_tree_add_device(root=0x%x, path=%s, string=%s)\n",
-        root, path, string));
+       ("device_tree_add_device(root=0x%lx, path=%s, string=%s)\n",
+        (long)root, path, string));
   new_node = device_tree_find_node(root,
                                   path,
                                   path, /* full-name */
@@ -281,7 +281,7 @@ device_tree_add_string(device_tree *root,
                                   device_tree_grow);
   new_node->string = strdup(string);
   TRACE(trace_device_tree,
-       ("device_tree_add_string() = 0x%x\n", new_node));
+       ("device_tree_add_string() = 0x%lx\n", (long)new_node));
   return new_node;
 }
 
@@ -292,8 +292,8 @@ device_tree_add_boolean(device_tree *root,
 {
   device_tree *new_node;
   TRACE(trace_device_tree,
-       ("device_tree_add_boolean(root=0x%x, path=%s, boolean=%d)\n",
-        root, path, boolean));
+       ("device_tree_add_boolean(root=0x%lx, path=%s, boolean=%d)\n",
+        (long)root, path, boolean));
   new_node = device_tree_find_node(root,
                                   path,
                                   path, /* full-name */
@@ -301,7 +301,7 @@ device_tree_add_boolean(device_tree *root,
                                   device_tree_grow);
   new_node->boolean = boolean;
   TRACE(trace_device_tree,
-       ("device_tree_add_boolean() = 0x%x\n", new_node));
+       ("device_tree_add_boolean() = 0x%lx\n", (long)new_node));
   return new_node;
 }
 
@@ -311,14 +311,14 @@ device_tree_add_found_device(device_tree *root,
 {
   device_tree *new_node;
   TRACE(trace_device_tree,
-       ("device_tree_add_found_device(root=0x%x, path=%s)\n",
-        root, path));
+       ("device_tree_add_found_device(root=0x%lx, path=%s)\n",
+        (long)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));
+       ("device_tree_add_found_device() = 0x%lx\n", (long)new_node));
   return new_node;
 }
 
@@ -331,14 +331,14 @@ device_tree_find_device(device_tree *root,
 {
   device_tree *node;
   TRACE(trace_device_tree,
-       ("device_tree_find_device(root=0x%x, path=%s)\n", root, path));
+       ("device_tree_find_device(root=0x%lx, path=%s)\n", (long)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));
+       ("device_tree_find_device() = 0x%lx\n", (long)node->device));
   return node->device;
 }
 
@@ -348,14 +348,14 @@ device_tree_find_integer(device_tree *root,
 {
   device_tree *node;
   TRACE(trace_device_tree,
-       ("device_tree_find_integer(root=0x%x, path=%s)\n", root, path));
+       ("device_tree_find_integer(root=0x%lx, path=%s)\n", (long)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));
+       ("device_tree_find_integer() = %ld\n", (long)node->integer));
   return node->integer;
 }
 
@@ -365,14 +365,14 @@ device_tree_find_string(device_tree *root,
 {
   device_tree *node;
   TRACE(trace_device_tree,
-       ("device_tree_find_string(root=0x%x, path=%s)\n", root, path));
+       ("device_tree_find_string(root=0x%lx, path=%s)\n", (long)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));
+       ("device_tree_find_string() = 0x%lx\n", (long)node->string));
   return node->string;
 }
 
@@ -382,14 +382,14 @@ device_tree_find_boolean(device_tree *root,
 {
   device_tree *node;
   TRACE(trace_device_tree,
-       ("device_tree_find_boolean(root=0x%x, path=%s)\n", root, path));
+       ("device_tree_find_boolean(root=0x%lx, path=%s)\n", (long)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));
+       ("device_tree_find_boolean() = %ld\n", (long)node->boolean));
   return node->boolean;
 }
 
@@ -404,8 +404,8 @@ device_tree_init_device(device_tree *root,
   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));
+         ("device_tree_init() initializing device=0x%lx:%s\n",
+          (long)root->device, root->device->full_name));
     root->device->callback->init(root->device, system);
   }
 }
@@ -416,7 +416,7 @@ 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_init(root=0x%lx, system=0x%lx)\n", (long)root, (long)system));
   device_tree_traverse(root, device_tree_init_device, NULL, system);
   TRACE(trace_device_tree,
        ("device_tree_init() = void\n"));
@@ -448,16 +448,16 @@ INLINE_DEVICE_TREE void
 device_tree_dump(device_tree *device,
                 void *ignore_data_argument)
 {
-  printf_filtered("(device_tree@0x%x\n", device);
-  printf_filtered(" (parent 0x%x)\n", device->parent);
-  printf_filtered(" (children 0x%x)\n", device->children);
-  printf_filtered(" (sibling 0x%x)\n", device->sibling);
-  printf_filtered(" (type %d)\n", device->type);
+  printf_filtered("(device_tree@0x%lx\n", (long)device);
+  printf_filtered(" (parent 0x%lx)\n", (long)device->parent);
+  printf_filtered(" (children 0x%lx)\n", (long)device->children);
+  printf_filtered(" (sibling 0x%lx)\n", (long)device->sibling);
+  printf_filtered(" (type %ld)\n", (long)device->type);
   printf_filtered(" (name %s)\n", device->name);
-  printf_filtered(" (device 0x%x)\n", device->device);
-  printf_filtered(" (boolean %d)\n", device->boolean);
+  printf_filtered(" (device 0x%lx)\n", (long)device->device);
+  printf_filtered(" (boolean %ld)\n", (long)device->boolean);
   printf_filtered(" (string %s)\n", device->string);
-  printf_filtered(" (integer %d)\n", device->integer);
+  printf_filtered(" (integer %ld)\n", (long)device->integer);
   printf_filtered(")\n");
 }
 

diff --git a/sim/ppc/devices.c b/sim/ppc/devices.c
index b0368d53d299eee81f53fabf3e3223fdf770a327..257b8eb1b575dadc21daa14e0dd7161eaf0e7bd9 100644 (file)
--- a/sim/ppc/devices.c
+++ b/sim/ppc/devices.c
@@ -370,7 +370,7 @@ console_io_read_buffer_callback(const device *me,
 
   /* determine what was read */
 
-  switch (addr) {
+  switch ((int)addr) {
 
   case console_read_buffer:
     val = console->input.buffer;
@@ -441,7 +441,7 @@ console_io_write_buffer_callback(const device *me,
   unsigned_1 val = *(unsigned8*)source;
   DTRACE_IO_WRITE_BUFFER(console);
 
-  switch (addr) {
+  switch ((int)addr) {
   case console_read_buffer:
     console->input.buffer = val;
     break;
@@ -1223,10 +1223,11 @@ update_for_binary_section(bfd *abfd,
   section_vma = bfd_get_section_vma(abfd, the_section);
 
   DTRACE(binary,
-        ("name=%-7s, vma=0x%.8x, size=%6d, flags=%3x(%s%s%s%s )\n",
+        ("name=%-7s, vma=0x%.8lx, size=%6ld, flags=%3lx(%s%s%s%s%s )\n",
          bfd_get_section_name(abfd, the_section),
-         section_vma, section_size,
-         bfd_get_section_flags(abfd, the_section),
+         (long)section_vma,
+         (long)section_size,
+         (long)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" : "",
@@ -1387,8 +1388,8 @@ write_stack_arguments(psim *system,
                      unsigned_word end_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));
+       ("write_stack_arguments(system=0x%lx, arg=0x%lx, start_block=0x%lx, end_block=0x%lx, start_arg=0x%lx, end_arg=0x%lx)\n",
+        (long)system, (long)arg, (long)start_block, (long)end_block, (long)start_arg, (long)end_arg));
   if (arg == NULL)
     error("write_arguments: character array NULL\n");
   /* only copy in arguments, memory is already zero */
@@ -1396,9 +1397,9 @@ write_stack_arguments(psim *system,
     int len = strlen(*arg)+1;
     unsigned_word target_start_block;
     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));
+         ("write_stack_arguments() write %s=%s at %s=0x%lx %s=0x%lx %s=0x%lx\n",
+          "**arg", *arg, "start_block", (long)start_block,
+          "len", (long)len, "start_arg", (long)start_arg));
     if (psim_write_memory(system, 0, *arg,
                          start_block, len,
                          0/*violate_readonly*/) != len)
@@ -1518,8 +1519,8 @@ stack_ioctl_callback(const device *me,
   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));
+        ("stack_ioctl_callback(me=0x%lx:%s, system=0x%lx, processor=0x%lx, cia=0x%lx, argv=0x%lx, envp=0x%lx)\n",
+         (long)me, me->full_name, (long)system, (long)processor, (long)cia, (long)argv, (long)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)

diff --git a/sim/ppc/devices.h b/sim/ppc/devices.h
index fd22a549b88f5a09255f73203715d8b8822ffa21..5fad839387f856b119ba44355c5e76c3848cb853 100644 (file)
--- a/sim/ppc/devices.h
+++ b/sim/ppc/devices.h
@@ -81,8 +81,8 @@ typedef void (device_init_callback)
 
 #define DTRACE_INIT(OBJECT) \
      DTRACE(OBJECT, \
-           (#OBJECT "_init(me=0x%x:%s system=0x%x)\n", \
-            me, me->full_name, system))
+           (#OBJECT "_init(me=0x%lx:%s system=0x%lx)\n", \
+            (long)me, me->full_name, (long)system))
 
 /* Data transfers:
 
@@ -173,12 +173,14 @@ typedef void (device_config_address_callback)
 
 #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))
+           (#OBJECT "_attach_address(me=0x%lx:%s, name=%s, attach=%ld, space=%ld, addr=0x%lx, nr_bytes=%ld, access=%ld, who=0x%lx)\n", \
+            (long)me, me->full_name, name, (long)attach, (long)space, \
+            (long)addr, (long)nr_bytes, (long)access, (long)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))
+           (#OBJECT "_detach_address(me=0x%lx:%s, name=%s, attach=%ld, space=%ld, addr=0x%lx, nr_bytes=%ld, access=%ld, who=0x%lx)\n", \
+            (long)me, me->full_name, name, (long)attach, (long)space, \
+            (long)addr, (long)nr_bytes, (long)access, (long)who))
 
 
 typedef unsigned (device_io_read_buffer_callback)
@@ -201,12 +203,14 @@ typedef unsigned (device_io_write_buffer_callback)
 
 #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))
+           (#OBJECT "_io_read_buffer(me=0x%lx:%s dest=0x%lx space=%ld addr=0x%lx nr_bytes=%ld processor=0x%lx cia=0x%lx)\n", \
+            (long)me, me->full_name, (long)dest, (long)space, (long)addr, \
+            (long)nr_bytes, (long)processor, (long)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))
+           (#OBJECT "_io_write_buffer(me=0x%lx:%s source=0x%lx space=%ld addr=0x%lx nr_bytes=%ld processor=0x%lx cia=0x%lx)\n", \
+            (long)me, me->full_name, (long)source, (long)space, (long)addr, \
+            (long)nr_bytes, (long)processor, (long)cia))
 
 
 typedef unsigned (device_dma_read_buffer_callback)
@@ -226,12 +230,12 @@ typedef unsigned (device_dma_write_buffer_callback)
 
 #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))
+           (#OBJECT "_dma_read_buffer(me=0x%lx:%s dest=0x%lx space=%ld addr=0x%lx nr_bytes=%ld)\n", \
+            (long)me, me->full_name, (long)dest, (long)space, (long)addr, (long)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))
+           (#OBJECT "_dma_write_buffer(me=0x%lx:%s source=0x%lx space=%ld addr=0x%lx nr_bytes=%ld)\n", \
+            (long)me, me->full_name, (long)source, (long)space, (long)addr, (long)nr_bytes))
 
 
 /* Interrupts:

diff --git a/sim/ppc/function_unit.c b/sim/ppc/function_unit.c
index 7793c7b374bae2e71741db5a07cb793a7d40aa99..a4f2768a6a1dce08f5b445c23e5553a394c8c02e 100644 (file)
--- a/sim/ppc/function_unit.c
+++ b/sim/ppc/function_unit.c
@@ -79,8 +79,8 @@ struct _function_unit {
 
 /* Flags used in timing info */
 
-#define LOAD   0x00000001                              /* this is a load */
-#define        STORE   0x00000002                              /* this is a store */
+#define FUNC_LOAD      0x00000001                      /* this is a load */
+#define        FUNC_STORE      0x00000002                      /* this is a store */
 
 \f
 /* 603 timings */
@@ -162,36 +162,36 @@ static timing time_603[] = {
   { itable_Floating_Subtract_Single,                                   UNIT_FPU,       1,      0 },
   { itable_Instruction_Cache_Block_Invalidate,                         UNIT_MEM,       3,      0 },
   { itable_Instruction_Synchronize,                                    UNIT_SREG,      1,      0 },
-  { itable_Load_Byte_and_Zero,                                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_Byte_and_Zero_Indexed,                                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_Byte_and_Zero_with_Update,                             UNIT_MEM,       2,      LOAD },
-  { itable_Load_Byte_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Double,                                  UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Double_Indexed,                          UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Double_with_Update,                      UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Double_with_Update_Indexed,              UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Single,                                  UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Single_Indexed,                          UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Single_with_Update,                      UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Single_with_Update_Indexed,              UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_Algebraic,                                    UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_Algebraic_Indexed,                            UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_Algebraic_with_Update,                                UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_Algebraic_with_Update_Indexed,                        UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_ByteReverse_Indexed,                          UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero,                                     UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero_Indexed,                             UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero_with_Update,                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero_with_Update_Indexed,                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_Multiple_Word,                                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_String_Word_Immediate,                                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_String_Word_Indexed,                                   UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_And_Reserve_Indexed,                              UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_ByteReverse_Indexed,                              UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero,                                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero_Indexed,                                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero_with_Update,                             UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      LOAD },
+  { itable_Load_Byte_and_Zero,                                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Byte_and_Zero_Indexed,                                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Byte_and_Zero_with_Update,                             UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Byte_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double,                                  UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double_Indexed,                          UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double_with_Update,                      UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double_with_Update_Indexed,              UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single,                                  UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single_Indexed,                          UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single_with_Update,                      UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single_with_Update_Indexed,              UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic,                                    UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic_Indexed,                            UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic_with_Update,                                UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic_with_Update_Indexed,                        UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_ByteReverse_Indexed,                          UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero,                                     UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero_Indexed,                             UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero_with_Update,                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero_with_Update_Indexed,                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Multiple_Word,                                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_String_Word_Immediate,                                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_String_Word_Indexed,                                   UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_And_Reserve_Indexed,                              UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_ByteReverse_Indexed,                              UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero,                                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero_Indexed,                                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero_with_Update,                             UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      FUNC_LOAD },
   { itable_Move_Condition_Register_Field,                              UNIT_SREG,      1,      0 },
   { itable_Move_From_Condition_Register,                               UNIT_SREG,      1,      0 },
   { itable_Move_From_FPSCR,                                            UNIT_FPU,       1,      0 },
@@ -230,33 +230,33 @@ static timing time_603[] = {
   { itable_Shift_Right_Algebraic_Word,                                 UNIT_INT,       1,      0 },
   { itable_Shift_Right_Algebraic_Word_Immediate,                       UNIT_INT,       1,      0 },
   { itable_Shift_Right_Word,                                           UNIT_INT,       1,      0 },
-  { itable_Store_Byte,                                                 UNIT_MEM,       1,      STORE },
-  { itable_Store_Byte_Indexed,                                         UNIT_MEM,       1,      STORE },
-  { itable_Store_Byte_with_Update,                                     UNIT_MEM,       1,      STORE },
-  { itable_Store_Byte_with_Update_Indexed,                             UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Double,                                 UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Double_Indexed,                         UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Double_with_Update,                     UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Double_with_Update_Indexed,             UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Single,                                 UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Single_Indexed,                         UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Single_with_Update,                     UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_Single_with_Update_Indexed,             UNIT_MEM,       1,      STORE },
-  { itable_Store_FloatingPoint_as_Integer_Word_Indexed,                        UNIT_MEM,       1,      STORE },
-  { itable_Store_Half_Word,                                            UNIT_MEM,       1,      STORE },
-  { itable_Store_Half_Word_ByteReversed_Indexed,                       UNIT_MEM,       1,      STORE },
-  { itable_Store_Half_Word_Indexed,                                    UNIT_MEM,       1,      STORE },
-  { itable_Store_Half_Word_with_Update,                                        UNIT_MEM,       1,      STORE },
-  { itable_Store_Half_Word_with_Update_Indexed,                                UNIT_MEM,       1,      STORE },
-  { itable_Store_Multiple_Word,                                                UNIT_MEM,       1,      STORE },
-  { itable_Store_String_Word_Immedate,                                 UNIT_MEM,       1,      STORE },
-  { itable_Store_String_Word_Indexed,                                  UNIT_MEM,       1,      STORE },
-  { itable_Store_Word,                                                 UNIT_MEM,       1,      STORE },
-  { itable_Store_Word_ByteReversed_Indexed,                            UNIT_MEM,       1,      STORE },
-  { itable_Store_Word_Conditional_Indexed,                             UNIT_MEM,       1,      STORE },
-  { itable_Store_Word_Indexed,                                         UNIT_MEM,       1,      STORE },
-  { itable_Store_Word_with_Update,                                     UNIT_MEM,       1,      STORE },
-  { itable_Store_Word_with_Update_Indexed,                             UNIT_MEM,       1,      STORE },
+  { itable_Store_Byte,                                                 UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Byte_Indexed,                                         UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Byte_with_Update,                                     UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Byte_with_Update_Indexed,                             UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double,                                 UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double_Indexed,                         UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double_with_Update,                     UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double_with_Update_Indexed,             UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single,                                 UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single_Indexed,                         UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single_with_Update,                     UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single_with_Update_Indexed,             UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_FloatingPoint_as_Integer_Word_Indexed,                        UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Half_Word,                                            UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Half_Word_ByteReversed_Indexed,                       UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Half_Word_Indexed,                                    UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Half_Word_with_Update,                                        UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Half_Word_with_Update_Indexed,                                UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Multiple_Word,                                                UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_String_Word_Immedate,                                 UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_String_Word_Indexed,                                  UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Word,                                                 UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Word_ByteReversed_Indexed,                            UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Word_Conditional_Indexed,                             UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Word_Indexed,                                         UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Word_with_Update,                                     UNIT_MEM,       1,      FUNC_STORE },
+  { itable_Store_Word_with_Update_Indexed,                             UNIT_MEM,       1,      FUNC_STORE },
   { itable_Subtract_From,                                              UNIT_INT,       1,      0 },
   { itable_Subtract_From_Carrying,                                     UNIT_INT,       1,      0 },
   { itable_Subtract_From_Extended,                                     UNIT_INT,       1,      0 },
@@ -356,36 +356,36 @@ static timing time_604[] = {
   { itable_Floating_Subtract_Single,                                   UNIT_FPU,       3,      0 },
   { itable_Instruction_Cache_Block_Invalidate,                         UNIT_MEM,       1,      0 },
   { itable_Instruction_Synchronize,                                    UNIT_INT,       1,      0 },
-  { itable_Load_Byte_and_Zero,                                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_Byte_and_Zero_Indexed,                                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_Byte_and_Zero_with_Update,                             UNIT_MEM,       2,      LOAD },
-  { itable_Load_Byte_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      LOAD },
-  { itable_Load_FloatingPoint_Double,                                  UNIT_MEM,       3,      LOAD },
-  { itable_Load_FloatingPoint_Double_Indexed,                          UNIT_MEM,       3,      LOAD },
-  { itable_Load_FloatingPoint_Double_with_Update,                      UNIT_MEM,       3,      LOAD },
-  { itable_Load_FloatingPoint_Double_with_Update_Indexed,              UNIT_MEM,       3,      LOAD },
-  { itable_Load_FloatingPoint_Single,                                  UNIT_MEM,       3,      LOAD },
-  { itable_Load_FloatingPoint_Single_Indexed,                          UNIT_MEM,       3,      LOAD },
-  { itable_Load_FloatingPoint_Single_with_Update,                      UNIT_MEM,       3,      LOAD },
-  { itable_Load_FloatingPoint_Single_with_Update_Indexed,              UNIT_MEM,       3,      LOAD },
-  { itable_Load_Halfword_Algebraic,                                    UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_Algebraic_Indexed,                            UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_Algebraic_with_Update,                                UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_Algebraic_with_Update_Indexed,                        UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_ByteReverse_Indexed,                          UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero,                                     UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero_Indexed,                             UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero_with_Update,                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_Halfword_and_Zero_with_Update_Indexed,                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_Multiple_Word,                                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_String_Word_Immediate,                                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_String_Word_Indexed,                                   UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_And_Reserve_Indexed,                              UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_ByteReverse_Indexed,                              UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero,                                         UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero_Indexed,                                 UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero_with_Update,                             UNIT_MEM,       2,      LOAD },
-  { itable_Load_Word_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      LOAD },
+  { itable_Load_Byte_and_Zero,                                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Byte_and_Zero_Indexed,                                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Byte_and_Zero_with_Update,                             UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Byte_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double,                                  UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double_Indexed,                          UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double_with_Update,                      UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Double_with_Update_Indexed,              UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single,                                  UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single_Indexed,                          UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single_with_Update,                      UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_FloatingPoint_Single_with_Update_Indexed,              UNIT_MEM,       3,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic,                                    UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic_Indexed,                            UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic_with_Update,                                UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_Algebraic_with_Update_Indexed,                        UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_ByteReverse_Indexed,                          UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero,                                     UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero_Indexed,                             UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero_with_Update,                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Halfword_and_Zero_with_Update_Indexed,                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Multiple_Word,                                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_String_Word_Immediate,                                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_String_Word_Indexed,                                   UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_And_Reserve_Indexed,                              UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_ByteReverse_Indexed,                              UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero,                                         UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero_Indexed,                                 UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero_with_Update,                             UNIT_MEM,       2,      FUNC_LOAD },
+  { itable_Load_Word_and_Zero_with_Update_Indexed,                     UNIT_MEM,       2,      FUNC_LOAD },
   { itable_Move_Condition_Register_Field,                              UNIT_BRANCH,    1,      0 },
   { itable_Move_From_Condition_Register,                               UNIT_CINT,      3,      0 },
   { itable_Move_From_FPSCR,                                            UNIT_FPU,       3,      0 },
@@ -424,33 +424,33 @@ static timing time_604[] = {
   { itable_Shift_Right_Algebraic_Word,                                 UNIT_INT,       1,      0 },
   { itable_Shift_Right_Algebraic_Word_Immediate,                       UNIT_INT,       1,      0 },
   { itable_Shift_Right_Word,                                           UNIT_INT,       1,      0 },
-  { itable_Store_Byte,                                                 UNIT_MEM,       3,      STORE },
-  { itable_Store_Byte_Indexed,                                         UNIT_MEM,       3,      STORE },
-  { itable_Store_Byte_with_Update,                                     UNIT_MEM,       3,      STORE },
-  { itable_Store_Byte_with_Update_Indexed,                             UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Double,                                 UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Double_Indexed,                         UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Double_with_Update,                     UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Double_with_Update_Indexed,             UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Single,                                 UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Single_Indexed,                         UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Single_with_Update,                     UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_Single_with_Update_Indexed,             UNIT_MEM,       3,      STORE },
-  { itable_Store_FloatingPoint_as_Integer_Word_Indexed,                        UNIT_MEM,       3,      STORE },
-  { itable_Store_Half_Word,                                            UNIT_MEM,       3,      STORE },
-  { itable_Store_Half_Word_ByteReversed_Indexed,                       UNIT_MEM,       3,      STORE },
-  { itable_Store_Half_Word_Indexed,                                    UNIT_MEM,       3,      STORE },
-  { itable_Store_Half_Word_with_Update,                                        UNIT_MEM,       3,      STORE },
-  { itable_Store_Half_Word_with_Update_Indexed,                                UNIT_MEM,       3,      STORE },
-  { itable_Store_Multiple_Word,                                                UNIT_MEM,       3,      STORE },
-  { itable_Store_String_Word_Immedate,                                 UNIT_MEM,       3,      STORE },
-  { itable_Store_String_Word_Indexed,                                  UNIT_MEM,       3,      STORE },
-  { itable_Store_Word,                                                 UNIT_MEM,       3,      STORE },
-  { itable_Store_Word_ByteReversed_Indexed,                            UNIT_MEM,       3,      STORE },
-  { itable_Store_Word_Conditional_Indexed,                             UNIT_MEM,       3,      STORE },
-  { itable_Store_Word_Indexed,                                         UNIT_MEM,       3,      STORE },
-  { itable_Store_Word_with_Update,                                     UNIT_MEM,       3,      STORE },
-  { itable_Store_Word_with_Update_Indexed,                             UNIT_MEM,       3,      STORE },
+  { itable_Store_Byte,                                                 UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Byte_Indexed,                                         UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Byte_with_Update,                                     UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Byte_with_Update_Indexed,                             UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double,                                 UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double_Indexed,                         UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double_with_Update,                     UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Double_with_Update_Indexed,             UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single,                                 UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single_Indexed,                         UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single_with_Update,                     UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_Single_with_Update_Indexed,             UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_FloatingPoint_as_Integer_Word_Indexed,                        UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Half_Word,                                            UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Half_Word_ByteReversed_Indexed,                       UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Half_Word_Indexed,                                    UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Half_Word_with_Update,                                        UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Half_Word_with_Update_Indexed,                                UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Multiple_Word,                                                UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_String_Word_Immedate,                                 UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_String_Word_Indexed,                                  UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Word,                                                 UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Word_ByteReversed_Indexed,                            UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Word_Conditional_Indexed,                             UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Word_Indexed,                                         UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Word_with_Update,                                     UNIT_MEM,       3,      FUNC_STORE },
+  { itable_Store_Word_with_Update_Indexed,                             UNIT_MEM,       3,      FUNC_STORE },
   { itable_Subtract_From,                                              UNIT_INT,       1,      0 },
   { itable_Subtract_From_Carrying,                                     UNIT_INT,       1,      0 },
   { itable_Subtract_From_Extended,                                     UNIT_INT,       1,      0 },

diff --git a/sim/ppc/igen.c b/sim/ppc/igen.c
index 3db56c06bfbf5c9c1a30e1f9e7d9a8bdbf54b7d8..b017d9a40b3b7695c4f65afe5e266f51be546a57 100644 (file)
--- a/sim/ppc/igen.c
+++ b/sim/ppc/igen.c
@@ -503,7 +503,7 @@ struct _opcode_field {
 };
 
 static opcode_field *
-opcode_field_new()
+opcode_field_new(void)
 {
   opcode_field *new_field = (opcode_field*)zalloc(sizeof(opcode_field));
   ASSERT(new_field != NULL);

diff --git a/sim/ppc/options.c b/sim/ppc/options.c
new file mode 100644 (file)
index 0000000..ba7f91a
--- /dev/null
+++ b/sim/ppc/options.c
@@ -0,0 +1,146 @@
+/*  This file is part of the program psim.
+
+    Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef _OPTIONS_C_
+#define _OPTIONS_C_
+
+#include "basics.h"
+#include "options.h"
+
+STATIC_INLINE const char *
+options_byte_order (int order)
+{
+  switch (order) {
+  case 0:              return "0";
+  case BIG_ENDIAN:     return "BIG_ENDIAN";
+  case LITTLE_ENDIAN:  return "LITTLE_ENDIAN";
+  }
+
+  return "UNKNOWN";
+}
+
+STATIC_INLINE const char *
+options_env (int env)
+{
+  switch (env) {
+  case OPERATING_ENVIRONMENT:  return "OPERATING";
+  case VIRTUAL_ENVIRONMENT:    return "VIRTUAL";
+  case USER_ENVIRONMENT:       return "USER";
+  case 0:                      return 0;
+  }
+
+  return "UNKNOWN";
+}
+
+STATIC_INLINE const char *
+options_align (int align)
+{
+  switch (align) {
+  case NONSTRICT_ALIGNMENT:    return "NONSTRICT";
+  case STRICT_ALIGNMENT:       return "STRICT";
+  case 0:                      return "0";
+  }
+
+  return "UNKNOWN";
+}
+
+STATIC_INLINE const char *
+options_float (int float_type)
+{
+  switch (float_type) {
+  case SOFT_FLOATING_POINT:    return "SOFTWARE";
+  case HARD_FLOATING_POINT:    return "HARDWARE";
+  }
+
+  return "UNKNOWN";
+}
+
+STATIC_INLINE const char *
+options_mon (int mon)
+{
+  switch (mon) {
+  case MONITOR_INSTRUCTION_ISSUE|MONITOR_LOAD_STORE_UNIT:      return "ALL";
+  case MONITOR_INSTRUCTION_ISSUE:                              return "INSTRUCTION";
+  case MONITOR_LOAD_STORE_UNIT:                                        return "MEMORY";
+  case 0:                                                      return "0";
+  }
+
+  return "UNKNOWN";
+}
+
+STATIC_INLINE const char *
+options_ppc (ppc_model ppc)
+{
+  switch (ppc) {
+  case PPC_MODEL_UNKNOWN:      return "NONE";
+  case PPC_MODEL_601:          return "601";
+  case PPC_MODEL_602:          return "602";
+  case PPC_MODEL_603:          return "603";
+  case PPC_MODEL_603e:         return "603e";
+  case PPC_MODEL_604:          return "604";
+  case PPC_MODEL_403:          return "403";
+  case PPC_MODEL_505:          return "505";
+  case PPC_MODEL_821:          return "821";
+  case PPC_MODEL_860:          return "860";
+  }
+
+  return "UNKNOWN";
+}
+
+void
+print_options (void)
+{
+  printf_filtered ("WITH_HOST_BYTE_ORDER     = %s\n", options_byte_order (WITH_HOST_BYTE_ORDER));
+  printf_filtered ("WITH_TARGET_BYTE_ORDER   = %s\n", options_byte_order (WITH_TARGET_BYTE_ORDER));
+  printf_filtered ("WITH_BSWAP               = %d\n", WITH_BSWAP);
+  printf_filtered ("WITH_SMP                 = %d\n", WITH_SMP);
+  printf_filtered ("WITH_HOST_WORD_BITSIZE   = %d\n", WITH_HOST_WORD_BITSIZE);
+  printf_filtered ("WITH_TARGET_WORD_BITSIZE = %d\n", WITH_TARGET_WORD_BITSIZE);
+  printf_filtered ("WITH_ENVIRONMENT         = %s\n", options_env(WITH_ENVIRONMENT));
+  printf_filtered ("WITH_EVENTS              = %d\n", WITH_EVENTS);
+  printf_filtered ("WITH_TIME_BASE           = %d\n", WITH_TIME_BASE);
+  printf_filtered ("WITH_CALLBACK_MEMORY     = %d\n", WITH_CALLBACK_MEMORY);
+  printf_filtered ("WITH_ALIGNMENT           = %s\n", options_align (WITH_ALIGNMENT));
+  printf_filtered ("WITH_FLOATING_POINT      = %s\n", options_float (WITH_FLOATING_POINT));
+  printf_filtered ("WITH_TRACE               = %d\n", WITH_TRACE);
+  printf_filtered ("WITH_ASSERT              = %d\n", WITH_ASSERT);
+  printf_filtered ("WITH_MON                 = %s\n", options_mon (WITH_MON));
+  printf_filtered ("WITH_FUNCTION_UNIT       = %d\n", WITH_FUNCTION_UNIT);
+  printf_filtered ("WITH_DEFAULT_PPC_MODEL   = %s\n", options_ppc (WITH_DEFAULT_PPC_MODEL));
+  printf_filtered ("WITH_PPC_MODEL           = %s\n", options_ppc (WITH_PPC_MODEL));
+  printf_filtered ("DEFAULT_INLINE           = %d\n", DEFAULT_INLINE);
+  printf_filtered ("SIM_ENDIAN_INLINE        = %d\n", SIM_ENDIAN_INLINE);
+  printf_filtered ("BITS_INLINE              = %d\n", BITS_INLINE);
+  printf_filtered ("CPU_INLINE               = %d\n", CPU_INLINE);
+  printf_filtered ("VM_INLINE                = %d\n", VM_INLINE);
+  printf_filtered ("CORE_INLINE              = %d\n", CORE_INLINE);
+  printf_filtered ("EVENTS_INLINE            = %d\n", EVENTS_INLINE);
+  printf_filtered ("MON_INLINE               = %d\n", MON_INLINE);
+  printf_filtered ("INTERRUPTS_INLINE        = %d\n", INTERRUPTS_INLINE);
+  printf_filtered ("REGISTERS_INLINE         = %d\n", REGISTERS_INLINE);
+  printf_filtered ("DEVICE_TREE_INLINE       = %d\n", DEVICE_TREE_INLINE);
+  printf_filtered ("DEVICES_INLINE           = %d\n", DEVICES_INLINE);
+  printf_filtered ("SPREG_INLINE             = %d\n", SPREG_INLINE);
+  printf_filtered ("SEMANTICS_INLINE         = %d\n", SEMANTICS_INLINE);
+  printf_filtered ("IDECODE_INLINE           = %d\n", IDECODE_INLINE);
+  printf_filtered ("FUNCTION_UNIT_INLINE     = %d\n", FUNCTION_UNIT_INLINE);
+}
+
+#endif /* _OPTIONS_C_ */