gdb/remote-z8k.c

   1 /* Remote debugging interface for Zilog Z8000 simulator
   2    Copyright 1992,1993 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.  Written by Steve Chamberlain
   4    (sac@cygnus.com).
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "wait.h"
  25 #include "value.h"
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31 #include <errno.h>
  32 #include "terminal.h"
  33 #include "target.h"
  34 #include "gdbcore.h"
  35 #include "../sim/z8k/sim.h"
  36
  37 /* External data declarations */
  38 extern int stop_soon_quietly;   /* for wait_for_inferior */
  39
  40 /* Forward data declarations */
  41 extern struct target_ops sim_ops;       /* Forward declaration */
  42
  43 void sim_store_register ();
  44 void sim_set_oc ();
  45
  46 int
  47 sim_write_inferior_memory (memaddr, myaddr, len)
  48      CORE_ADDR memaddr;
  49      unsigned char *myaddr;
  50      int len;
  51 {
  52   sim_write (memaddr, myaddr, len);
  53   return 1;
  54 }
  55
  56 static void
  57 store_register (regno)
  58      int regno;
  59 {
  60   if (regno == -1)
  61     {
  62       for (regno = 0; regno < 16; regno++)
  63         {
  64           store_register (regno);
  65         }
  66     }
  67   else
  68     {
  69       sim_store_register (regno, read_register (regno));
  70     }
  71 }
  72
  73 void
  74 sim_kill (arg, from_tty)
  75      char *arg;
  76      int from_tty;
  77 {
  78
  79 }
  80
  81 /*
  82  * Download a file specified in 'args', to the sim.
  83  */
  84 static void
  85 sim_load (args, fromtty)
  86      char *args;
  87      int fromtty;
  88 {
  89   bfd *abfd;
  90   asection *s;
  91
  92   inferior_pid = 0;
  93   abfd = bfd_openr (args, "coff-z8k");
  94
  95   if (!abfd)
  96     {
  97       printf_filtered ("Unable to open file %s\n", args);
  98       return;
  99     }
 100
 101   if (bfd_check_format (abfd, bfd_object) == 0)
 102     {
 103       printf_filtered ("File is not an object file\n");
 104       return;
 105     }
 106
 107   s = abfd->sections;
 108   while (s != (asection *) NULL)
 109     {
 110       if (s->flags & SEC_LOAD)
 111         {
 112           int i;
 113           int delta = 4096;
 114           char *buffer = xmalloc (delta);
 115
 116           printf_filtered ("%s\t: 0x%4x .. 0x%4x  ",
 117                            s->name, s->vma, s->vma + s->_raw_size);
 118           for (i = 0; i < s->_raw_size; i += delta)
 119             {
 120               int sub_delta = delta;
 121
 122               if (sub_delta > s->_raw_size - i)
 123                 sub_delta = s->_raw_size - i;
 124
 125               bfd_get_section_contents (abfd, s, buffer, i, sub_delta);
 126               sim_write_inferior_memory (s->vma + i, buffer, sub_delta);
 127               printf_filtered ("*");
 128               gdb_flush (gdb_stdout);
 129             }
 130           printf_filtered ("\n");
 131           free (buffer);
 132         }
 133       s = s->next;
 134     }
 135
 136   sim_set_pc (abfd->start_address);
 137 }
 138
 139 /* This is called not only when we first attach, but also when the
 140    user types "run" after having attached.  */
 141 static void
 142 sim_create_inferior (execfile, args, env)
 143      char *execfile;
 144      char *args;
 145      char **env;
 146 {
 147   int entry_pt;
 148
 149   if (args && *args)
 150     error ("Can't pass arguments to remote sim process.");
 151
 152   if (execfile == 0 || exec_bfd == 0)
 153     error ("No exec file specified");
 154
 155   entry_pt = (int) bfd_get_start_address (exec_bfd);
 156
 157   sim_kill (NULL, NULL);
 158   sim_clear_breakpoints ();
 159   init_wait_for_inferior ();
 160   insert_breakpoints ();
 161   proceed (entry_pt, -1, 0);
 162 }
 163
 164 static void
 165 sim_open (name, from_tty)
 166      char *name;
 167      int from_tty;
 168 {
 169   if (name == 0)
 170     {
 171       name = "";
 172     }
 173
 174   /* Clear any break points */
 175   sim_clear_breakpoints ();
 176
 177   push_target (&sim_ops);
 178   target_fetch_registers (-1);
 179
 180   printf_filtered ("Connected to the Z8000 Simulator.\n");
 181 }
 182
 183 /* Close out all files and local state before this target loses control. */
 184
 185 static void
 186 sim_close (quitting)
 187      int quitting;
 188 {
 189   sim_clear_breakpoints ();
 190 }
 191
 192 /* Terminate the open connection to the remote debugger.
 193    Use this when you want to detach and do something else
 194    with your gdb.  */
 195 static void
 196 sim_detach (args, from_tty)
 197      char *args;
 198      int from_tty;
 199 {
 200   sim_clear_breakpoints ();
 201
 202   pop_target ();                /* calls sim_close to do the real work */
 203   if (from_tty)
 204     printf_filtered ("Ending remote %s debugging\n", target_shortname);
 205 }
 206
 207 /* Tell the remote machine to resume.  */
 208
 209 /* Wait until the remote machine stops, then return,
 210    storing status in STATUS just as `wait' would.  */
 211
 212 int
 213 sim_wait (pid, status)
 214      int pid;
 215      WAITTYPE *status;
 216 {
 217   *status = sim_stop_signal ();
 218   return 0;
 219 }
 220
 221 /* Get ready to modify the registers array.  On machines which store
 222    individual registers, this doesn't need to do anything.  On machines
 223    which store all the registers in one fell swoop, this makes sure
 224    that registers contains all the registers from the program being
 225    debugged.  */
 226
 227 static void
 228 sim_prepare_to_store ()
 229 {
 230   /* Do nothing, since we can store individual regs */
 231 }
 232
 233 static void
 234 fetch_register (regno)
 235      int regno;
 236 {
 237   if (regno == -1)
 238     {
 239       for (regno = 0; regno < 16; regno++)
 240         fetch_register (regno);
 241     }
 242   else
 243     {
 244       char buf[MAX_REGISTER_RAW_SIZE];
 245
 246       sim_fetch_register (regno, buf);
 247       supply_register (regno, buf);
 248     }
 249 }
 250
 251 /* Write a word WORD into remote address ADDR.
 252    This goes through the data cache.  */
 253
 254 void
 255 sim_store_word (addr, word)
 256      CORE_ADDR addr;
 257      int word;
 258 {
 259 /*      dcache_poke (addr, word);*/
 260 }
 261
 262 int
 263 sim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 264      CORE_ADDR memaddr;
 265      char *myaddr;
 266      int len;
 267      int write;
 268      struct target_ops *target; /* ignored */
 269 {
 270   if (write)
 271     {
 272       sim_write (memaddr, myaddr, len);
 273
 274     }
 275   else
 276     {
 277       sim_read (memaddr, myaddr, len);
 278     }
 279   return len;
 280 }
 281
 282 void
 283 sim_files_info ()
 284 {
 285   char *file = "nothing";
 286
 287   if (exec_bfd)
 288     file = bfd_get_filename (exec_bfd);
 289
 290   printf_filtered ("\tAttached to %s running on the z8k simulator\n", file);
 291 }
 292
 293 /* This routine is run as a hook, just before the main command loop is
 294    entered.  If gdb is configured for the H8, but has not had its
 295    target specified yet, this will loop prompting the user to do so.
 296 */
 297
 298 void
 299 sim_before_main_loop ()
 300 {
 301   push_target (&sim_ops);
 302 }
 303
 304 /* Clear the sims notion of what the break points are */
 305 static void
 306 sim_mourn ()
 307 {
 308   sim_clear_breakpoints ();
 309   unpush_target (&sim_ops);
 310   generic_mourn_inferior ();
 311 }
 312
 313 static void
 314 rem_resume (pid, a, b)
 315      int pid;
 316      int a;
 317      int b;
 318 {
 319   sim_resume (a, b);
 320 }
 321
 322 /* Define the target subroutine names */
 323
 324 struct target_ops sim_ops =
 325 {
 326   "sim", "Remote SIM monitor",
 327   "Use the Z8000 simulator",
 328   sim_open, sim_close,
 329   0, sim_detach, rem_resume, sim_wait,  /* attach */
 330   fetch_register, store_register,
 331   sim_prepare_to_store,
 332   sim_xfer_inferior_memory,
 333   sim_files_info,
 334   0, 0,                         /* Breakpoints */
 335   0, 0, 0, 0, 0,                /* Terminal handling */
 336   sim_kill,                     /* FIXME, kill */
 337   sim_load,
 338   0,                            /* lookup_symbol */
 339   sim_create_inferior,          /* create_inferior */
 340   sim_mourn,                    /* mourn_inferior FIXME */
 341   0,                            /* can_run */
 342   0,                            /* notice_signals */
 343   process_stratum, 0,           /* next */
 344   1, 1, 1, 1, 1,                /* all mem, mem, stack, regs, exec */
 345   0, 0,                         /* Section pointers */
 346   OPS_MAGIC,                    /* Always the last thing */
 347 };
 348
 349 /***********************************************************************/
 350
 351 void
 352 _initialize_remote_sim ()
 353 {
 354   extern int sim_z8001_mode;
 355
 356   sim_z8001_mode = z8001_mode;
 357   add_target (&sim_ops);
 358
 359 }