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 inferior_pid;
  47 int
  48 sim_write_inferior_memory (memaddr, myaddr, len)
  49      CORE_ADDR memaddr;
  50      unsigned char *myaddr;
  51      int len;
  52 {
  53   sim_write (memaddr, myaddr, len);
  54   return 1;
  55 }
  56
  57 static void
  58 store_register (regno)
  59      int regno;
  60 {
  61   if (regno == -1)
  62     {
  63       for (regno = 0; regno < 16; regno++)
  64         {
  65           store_register (regno);
  66         }
  67     }
  68   else
  69     {
  70       sim_store_register (regno, read_register (regno));
  71     }
  72 }
  73
  74 void
  75 sim_kill (arg, from_tty)
  76      char *arg;
  77      int from_tty;
  78 {
  79 }
  80
  81 /*
  82  * Download a file specified in 'args', to the sim.
  83  */
  84 static void
  85 sasassim_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 #if 0
 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 #endif
 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 #if 0
 212 int
 213 sim_wait (pid, status)
 214      int pid;
 215      WAITTYPE *status;
 216 {
 217   sim_stop_reason (&reason, &sigrc);
 218   return inferior_pid;
 219 }
 220 #endif
 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 #if 0
 299 void
 300 sim_before_main_loop ()
 301 {
 302   push_target (&sim_ops);
 303 }
 304
 305
 306 /* Clear the sims notion of what the break points are */
 307 static void
 308 sim_mourn ()
 309 {
 310   sim_clear_breakpoints ();
 311   unpush_target (&sim_ops);
 312   generic_mourn_inferior ();
 313 }
 314 #endif
 315 static void
 316 rem_resume (pid, a, b)
 317      int pid;
 318      int a;
 319      int b;
 320 {
 321   sim_resume (a, b);
 322 }
 323
 324
 325 /* Define the target subroutine names */
 326 #if 0
 327 struct target_ops sim_ops =
 328 {
 329   "sim", "Remote SIM monitor",
 330   "Use the Z8000 simulator",
 331   sim_open, sim_close,
 332   0, sim_detach, rem_resume, sim_wait,  /* attach */
 333   fetch_register, store_register,
 334   sim_prepare_to_store,
 335   sim_xfer_inferior_memory,
 336   sim_files_info,
 337   0, 0,                         /* Breakpoints */
 338   0, 0, 0, 0, 0,                /* Terminal handling */
 339   sim_kill,                     /* FIXME, kill */
 340   sim_load,
 341   0,                            /* lookup_symbol */
 342   sim_create_inferior,          /* create_inferior */
 343   sim_mourn,                    /* mourn_inferior FIXME */
 344   0,                            /* can_run */
 345   0,                            /* notice_signals */
 346   process_stratum, 0,           /* next */
 347   1, 1, 1, 1, 1,                /* all mem, mem, stack, regs, exec */
 348   0, 0,                         /* Section pointers */
 349   OPS_MAGIC,                    /* Always the last thing */
 350 };
 351
 352 /***********************************************************************/
 353
 354 void
 355 _initialize_remote_sim ()
 356 {
 357   add_target (&sim_ops);
 358 }
 359 #endif