sim/ppc/emul_generic.c

   1 /*  This file is part of the program psim.
   2
   3     Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19     */
  20
  21
  22 #ifndef _EMUL_GENERIC_C_
  23 #define _EMUL_GENERIC_C_
  24
  25 #include "emul_generic.h"
  26
  27 #ifndef STATIC_INLINE_EMUL_GENERIC
  28 #define STATIC_INLINE_EMUL_GENERIC STATIC_INLINE
  29 #endif
  30
  31
  32 STATIC_INLINE_EMUL_GENERIC void
  33 emul_syscall_enter(emul_syscall *emul,
  34                    int call,
  35                    int arg0,
  36                    cpu *processor,
  37                    unsigned_word cia)
  38 {
  39   printf_filtered("%d:0x%lx:%s(",
  40                   cpu_nr(processor) + 1,
  41                   (long)cia,
  42                   emul->syscall_descriptor[call].name);
  43 }
  44
  45
  46 STATIC_INLINE_EMUL_GENERIC void
  47 emul_syscall_exit(emul_syscall *emul,
  48                   int call,
  49                   int arg0,
  50                   cpu *processor,
  51                   unsigned_word cia)
  52 {
  53   int status = cpu_registers(processor)->gpr[3];
  54   int error = cpu_registers(processor)->gpr[0];
  55   printf_filtered(")=%d", status);
  56   if (error > 0 && error < emul->nr_error_names)
  57     printf_filtered("[%s]", emul->error_names[error]);
  58   printf_filtered("\n");
  59 }
  60
  61
  62 INLINE_EMUL_GENERIC unsigned64
  63 emul_read_gpr64(cpu *processor,
  64                 int g)
  65 {
  66   unsigned32 hi;
  67   unsigned32 lo;
  68   if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN) {
  69     hi = cpu_registers(processor)->gpr[g];
  70     lo = cpu_registers(processor)->gpr[g+1];
  71   }
  72   else {
  73     lo = cpu_registers(processor)->gpr[g];
  74     hi = cpu_registers(processor)->gpr[g+1];
  75   }
  76   return (INSERTED64(hi, 0, 31) | INSERTED64(lo, 32, 63));
  77 }
  78
  79
  80 INLINE_EMUL_GENERIC void
  81 emul_write_gpr64(cpu *processor,
  82                  int g,
  83                  unsigned64 val)
  84 {
  85   unsigned32 hi = EXTRACTED64(val, 0, 31);
  86   unsigned32 lo = EXTRACTED64(val, 32, 63);
  87   if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN) {
  88     cpu_registers(processor)->gpr[g] = hi;
  89     cpu_registers(processor)->gpr[g+1] = lo;
  90   }
  91   else {
  92     cpu_registers(processor)->gpr[g] = lo;
  93     cpu_registers(processor)->gpr[g+1] = hi;
  94   }
  95 }
  96
  97
  98 INLINE_EMUL_GENERIC char *
  99 emul_read_string(char *dest,
 100                  unsigned_word addr,
 101                  unsigned nr_bytes,
 102                  cpu *processor,
 103                  unsigned_word cia)
 104 {
 105   unsigned nr_moved = 0;
 106   if (addr == 0)
 107     return NULL;
 108   while (1) {
 109     dest[nr_moved] = vm_data_map_read_1(cpu_data_map(processor),
 110                                         addr + nr_moved,
 111                                         processor, cia);
 112     if (dest[nr_moved] == '\0' || nr_moved >= nr_bytes)
 113       break;
 114     nr_moved++;
 115   }
 116   dest[nr_moved] = '\0';
 117   return dest;
 118 }
 119
 120
 121 INLINE_EMUL_GENERIC void
 122 emul_write_status(cpu *processor,
 123                   int status,
 124                   int errno)
 125 {
 126   cpu_registers(processor)->gpr[3] = status;
 127   if (status < 0)
 128     cpu_registers(processor)->gpr[0] = errno;
 129   else
 130     cpu_registers(processor)->gpr[0] = 0;
 131 }
 132
 133
 134 INLINE_EMUL_GENERIC unsigned_word
 135 emul_read_word(unsigned_word addr,
 136                cpu *processor,
 137                unsigned_word cia)
 138 {
 139   return vm_data_map_read_word(cpu_data_map(processor),
 140                                addr,
 141                                processor, cia);
 142 }
 143
 144
 145 INLINE_EMUL_GENERIC void
 146 emul_write_word(unsigned_word addr,
 147                 unsigned_word buf,
 148                 cpu *processor,
 149                 unsigned_word cia)
 150 {
 151   vm_data_map_write_word(cpu_data_map(processor),
 152                          addr,
 153                          buf,
 154                          processor, cia);
 155 }
 156
 157
 158 INLINE_EMUL_GENERIC void
 159 emul_write_buffer(const void *source,
 160                   unsigned_word addr,
 161                   unsigned nr_bytes,
 162                   cpu *processor,
 163                   unsigned_word cia)
 164 {
 165   int nr_moved;
 166   for (nr_moved = 0; nr_moved < nr_bytes; nr_moved++) {
 167     vm_data_map_write_1(cpu_data_map(processor),
 168                         addr + nr_moved,
 169                         ((const char*)source)[nr_moved],
 170                         processor, cia);
 171   }
 172 }
 173
 174
 175 INLINE_EMUL_GENERIC void
 176 emul_read_buffer(void *dest,
 177                  unsigned_word addr,
 178                  unsigned nr_bytes,
 179                  cpu *processor,
 180                  unsigned_word cia)
 181 {
 182   int nr_moved;
 183   for (nr_moved = 0; nr_moved < nr_bytes; nr_moved++) {
 184     ((char*)dest)[nr_moved] = vm_data_map_read_1(cpu_data_map(processor),
 185                                                  addr + nr_moved,
 186                                                  processor, cia);
 187   }
 188 }
 189
 190
 191 INLINE_EMUL_GENERIC void
 192 emul_do_system_call(os_emul_data *emul_data,
 193                     emul_syscall *emul,
 194                     unsigned call,
 195                     const int arg0,
 196                     cpu *processor,
 197                     unsigned_word cia)
 198 {
 199   emul_syscall_handler *handler = NULL;
 200   if (call >= emul->nr_system_calls)
 201     error("do_call() os_emul call %d out-of-range\n", call);
 202
 203   handler = emul->syscall_descriptor[call].handler;
 204   if (handler == NULL)
 205     error("do_call() unimplemented call %d\n", call);
 206
 207   if (WITH_TRACE && ppc_trace[trace_os_emul])
 208     emul_syscall_enter(emul, call, arg0, processor, cia);
 209
 210   cpu_registers(processor)->gpr[0] = 0; /* default success */
 211   handler(emul_data, call, arg0, processor, cia);
 212
 213   if (WITH_TRACE && ppc_trace[trace_os_emul])
 214     emul_syscall_exit(emul, call, arg0, processor, cia);
 215 }
 216
 217
 218 /* default size for the first bank of memory */
 219
 220 #ifndef OEA_MEMORY_SIZE
 221 #define OEA_MEMORY_SIZE 0x100000
 222 #endif
 223
 224
 225 /* Add options to the device tree */
 226
 227 INLINE_EMUL_GENERIC void
 228 emul_add_tree_options(device *tree,
 229                       bfd *image,
 230                       const char *emul,
 231                       const char *env,
 232                       int oea_interrupt_prefix)
 233 {
 234   int little_endian = 0;
 235
 236   /* sort out little endian */
 237   if (device_find_property(tree, "/options/little-endian?"))
 238     little_endian = device_find_boolean_property(tree, "/options/little-endian?");
 239   else {
 240 #ifdef bfd_little_endian        /* new bfd */
 241     little_endian = (image != NULL && bfd_little_endian(image));
 242 #else
 243     little_endian = (image != NULL &&
 244                      !image->xvec->byteorder_big_p);
 245 #endif
 246     device_tree_add_parsed(tree, "/options/little-endian? %s",
 247                            little_endian ? "true" : "false");
 248   }
 249
 250   /* misc other stuff */
 251   device_tree_add_parsed(tree, "/openprom/options/oea-memory-size 0x%x",
 252                          OEA_MEMORY_SIZE);
 253   device_tree_add_parsed(tree, "/openprom/options/oea-interrupt-prefix %d",
 254                          oea_interrupt_prefix);
 255   device_tree_add_parsed(tree, "/openprom/options/smp 1");
 256   device_tree_add_parsed(tree, "/openprom/options/env %s", env);
 257   device_tree_add_parsed(tree, "/openprom/options/os-emul %s", emul);
 258   device_tree_add_parsed(tree, "/openprom/options/strict-alignment? %s",
 259                          (WITH_ALIGNMENT == STRICT_ALIGNMENT || little_endian)
 260                          ? "true" : "false");
 261   device_tree_add_parsed(tree, "/openprom/options/floating-point? %s",
 262                          WITH_FLOATING_POINT ? "true" : "false");
 263   device_tree_add_parsed(tree, "/openprom/options/model \"%s",
 264                          model_name[WITH_DEFAULT_MODEL]);
 265   device_tree_add_parsed(tree, "/openprom/options/model-issue %d",
 266                          MODEL_ISSUE_IGNORE);
 267 }
 268
 269 INLINE_EMUL_GENERIC void
 270 emul_add_tree_hardware(device *root)
 271 {
 272   /* add some memory */
 273   if (device_tree_find_device(root, "/memory") == NULL) {
 274     unsigned_word memory_size =
 275       device_find_integer_property(root, "/openprom/options/oea-memory-size");
 276     device_tree_add_parsed(root, "/memory@0/reg { 0x0 0x%lx",
 277                            (unsigned long)memory_size);
 278     /* what about allocated? */
 279   }
 280   /* an eeprom */
 281   device_tree_add_parsed(root, "/openprom/eeprom@0xfff00000/reg { 0xfff00000 0x3000");
 282   /* the IO bus */
 283   device_tree_add_parsed(root, "/iobus@0x400000/reg { 0x400000 0x400000");
 284   device_tree_add_parsed(root, "/iobus/console@0x000000/reg { 0x000000 16");
 285   device_tree_add_parsed(root, "/iobus/halt@0x100000/reg    { 0x100000  4");
 286   device_tree_add_parsed(root, "/iobus/icu@0x200000/reg     { 0x200000  8");
 287   device_tree_add_parsed(root, "/iobus/icu > 0 0 /iobus/icu");
 288   device_tree_add_parsed(root, "/iobus/icu > 1 1 /iobus/icu");
 289   /* chosen etc */
 290   device_tree_add_parsed(root, "/chosen/stdin */iobus/console");
 291   device_tree_add_parsed(root, "/chosen/stdout !/chosen/stdin");
 292   device_tree_add_parsed(root, "/chosen/memory */memory");
 293 }
 294
 295 #endif /* _SYSTEM_C_ */