home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / gdb / remote-es.c < prev    next >
C/C++ Source or Header  |  1995-08-01  |  49KB  |  2,153 lines
  1. /* Memory-access and commands for remote es1800 processes, for GDB.
  2.    Copyright (C) 1988, 1992 Free Software Foundation, Inc.
  3.  
  4.    This file is added to GDB to make it possible to do debugging via an
  5.    ES-1800 emulator. The code was originally written by Johan Holmberg
  6.    TT/SJ Ericsson Telecom AB and later modified by Johan Henriksson
  7.    TT/SJ. It was modified for gdb 4.0 by TX/DK Jan Nordenand by TX/DKG
  8.    Harald Johansen.
  9.  
  10. This file is part of GDB.
  11.  
  12. GDB is free software; you can redistribute it and/or modify
  13. it under the terms of the GNU General Public License as published by
  14. the Free Software Foundation; either version 1, or (at your option)
  15. any later version.
  16.  
  17. GDB is distributed in the hope that it will be useful,
  18. but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. GNU General Public License for more details.
  21.  
  22. You should have received a copy of the GNU General Public License
  23. along with this program; if not, write to the Free Software
  24. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  25.  
  26.  
  27. /* Emulator communication protocol.
  28.    All values are encoded in ascii hex digits.
  29.  
  30.         Request
  31. Command
  32. Reply
  33.     read registers:
  34. DR<cr>
  35.      - 0 -    - 1 -    - 2 -    - 3 -      - 4 -    - 5 -    -- 6 -   - 7 - 
  36. D = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX   XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
  37. A = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX   XXXXXXXX XXXXXXXX XXXXXXXX 
  38.     PC = XXXXXX       SSP = XXXXXX    USP = XXXXXX     SR = XXXXXXXX
  39.  >
  40. Each byte of register data is described by two hex digits.
  41.  
  42.     write regs
  43. D0=XXXXXXXX<cr>
  44.  >D1=XXXXXXXX<cr>
  45.  >D2=XXXXXXXX<cr>
  46.  >D3=XXXXXXXX<cr>
  47.  >D4=XXXXXXXX<cr>
  48.  >D5=XXXXXXXX<cr>
  49.  >D6=XXXXXXXX<cr>
  50.  >D7=XXXXXXXX<cr>
  51.  >A0=XXXXXXXX<cr>
  52.  >A1=XXXXXXXX<cr>
  53.  >A2=XXXXXXXX<cr>
  54.  >A3=XXXXXXXX<cr>
  55.  >A4=XXXXXXXX<cr>
  56.  >A5=XXXXXXXX<cr>
  57.  >A6=XXXXXXXX<cr>
  58.  >A7=XXXXXXXX<cr>
  59.  >SR=XXXXXXXX<cr>
  60.  >PC=XXXXXX<cr>
  61.  >
  62. Each byte of register data is described by two hex digits.
  63.  
  64.     read mem
  65. @.BAA..AA
  66. $FFFFFFXX
  67.  >
  68. AA..AA is address, XXXXXXX is the contents
  69.  
  70.     write mem
  71.     @.BAA..AA=$XXXXXXXX
  72.  >
  73. AA..AA is address, XXXXXXXX is data
  74.  
  75.     cont
  76. PC=$AA..AA
  77.  >RBK
  78. R>
  79. AA..AA is address to resume. If AA..AA is omitted, resume at same address.
  80.  
  81.     step
  82. PC=$AA..AA
  83.  >STP
  84. R>
  85. AA..AA is address to resume. If AA..AA is omitted, resume at same address.
  86.  
  87.     kill req
  88. STP
  89.  >
  90. */
  91.  
  92.  
  93. #include <stdio.h>
  94. #include <signal.h>
  95. #include <sys/ioctl.h>
  96. #include <sys/file.h>
  97. #include <errno.h>
  98. #include <ctype.h>
  99. #include "gdb_string.h"
  100. #include <setjmp.h>
  101. #include <fcntl.h>
  102. #include "defs.h"
  103. #include "frame.h"
  104. #include "inferior.h"
  105. #include "target.h"
  106. #include "wait.h"
  107. #include "command.h"
  108. #include "remote-utils.h"
  109. #include "gdbcore.h"
  110. #include "serial.h"
  111.  
  112. /* Prototypes for local functions */
  113.  
  114. static void
  115. es1800_child_detach PARAMS ((char *, int));
  116.  
  117. static void
  118. es1800_child_open PARAMS ((char *, int));
  119.  
  120. static void 
  121. es1800_transparent PARAMS ((char *, int));
  122.  
  123. static void
  124. es1800_create_inferior PARAMS ((char *, char *, char **));
  125.  
  126. static void
  127. es1800_load PARAMS ((char *, int));
  128.  
  129. static void
  130. es1800_kill PARAMS ((void));
  131.  
  132. static int
  133. verify_break PARAMS ((int));
  134.  
  135. static int
  136. es1800_remove_breakpoint PARAMS ((CORE_ADDR, char *));
  137.  
  138. static int
  139. es1800_insert_breakpoint PARAMS ((CORE_ADDR, char *));
  140.  
  141. static void
  142. es1800_files_info PARAMS ((struct target_ops *));
  143.  
  144. static int
  145. es1800_xfer_inferior_memory PARAMS ((CORE_ADDR, char *, int, int,
  146.                      struct target_ops *));
  147.  
  148. static void 
  149. es1800_prepare_to_store PARAMS ((void));
  150.  
  151. static int es1800_wait PARAMS ((int, struct target_waitstatus *));
  152.  
  153. static void es1800_resume PARAMS ((int, int, enum target_signal));
  154.  
  155. static void
  156. es1800_detach PARAMS ((char *, int));
  157.  
  158. static void
  159. es1800_attach PARAMS ((char *, int));
  160.  
  161. static int
  162. damn_b PARAMS ((char *));
  163.  
  164. static void
  165. es1800_open PARAMS ((char *, int));
  166.  
  167. static void
  168. es1800_timer PARAMS ((void));
  169.  
  170. static void
  171. es1800_reset PARAMS ((char *));
  172.  
  173. static void
  174. es1800_request_quit PARAMS ((void));
  175.  
  176. static int
  177. readchar PARAMS ((void));
  178.  
  179. static void
  180. expect PARAMS ((char *, int));
  181.  
  182. static void
  183. expect_prompt PARAMS ((void));
  184.  
  185. static void
  186. download PARAMS ((FILE *, int, int));
  187.  
  188. #if 0
  189. static void
  190. bfd_copy PARAMS ((bfd *, bfd *));
  191. #endif
  192.  
  193. static void
  194. get_break_addr PARAMS ((int, CORE_ADDR *));
  195.  
  196. static int
  197. fromhex PARAMS ((int));
  198.  
  199. static int
  200. tohex PARAMS ((int));
  201.  
  202. static void
  203. es1800_close PARAMS ((int));
  204.  
  205. static void
  206. es1800_fetch_registers PARAMS ((void));
  207.  
  208. static void
  209. es1800_fetch_register PARAMS ((int));
  210.  
  211. static void
  212. es1800_store_register PARAMS ((int));
  213.  
  214. static void
  215. es1800_read_bytes PARAMS ((CORE_ADDR, char *, int));
  216.  
  217. static void
  218. es1800_write_bytes PARAMS ((CORE_ADDR, char *, int));
  219.  
  220. static void
  221. send_with_reply PARAMS ((char *, char *, int));
  222.  
  223. static void
  224. send_command PARAMS ((char *));
  225.  
  226. static void
  227. send PARAMS ((char *));
  228.  
  229. static void
  230. getmessage PARAMS ((char *, int));
  231.  
  232. static void
  233. es1800_mourn_inferior PARAMS ((void));
  234.  
  235. static void
  236. es1800_create_break_insn PARAMS ((char *, int));
  237.  
  238. static void
  239. es1800_init_break PARAMS ((char *, int));
  240.  
  241. /* Local variables */
  242.  
  243. /* FIXME: Convert this to use "set remotedebug" instead.  */
  244. #define LOG_FILE "es1800.log"
  245. #if defined (LOG_FILE)
  246. static FILE *log_file;
  247. #endif
  248.  
  249. extern struct target_ops es1800_ops;        /* Forward decl */
  250. extern struct target_ops es1800_child_ops;    /* Forward decl */
  251.  
  252. static int kiodebug;
  253. static int timeout = 100; 
  254. static char *savename;                /* Name of i/o device used */
  255. static serial_ttystate es1800_saved_ttystate;
  256. static int es1800_fc_save;            /* Save fcntl state */
  257.  
  258. /* indicates that the emulator uses 32-bit data-adress (68020-mode) 
  259.    instead of 24-bit (68000 -mode) */
  260.  
  261. static int m68020;
  262.  
  263. #define MODE (m68020 ? "M68020" : "M68000" )
  264. #define ES1800_BREAK_VEC (0xf)
  265.  
  266. /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
  267.    es1800_open knows that we don't have a file open when the program
  268.    starts.  */
  269.  
  270. static serial_t es1800_desc = NULL;
  271.  
  272. #define    PBUFSIZ    1000
  273. #define HDRLEN sizeof("@.BAAAAAAAA=$VV\r")
  274.  
  275. /* Maximum number of bytes to read/write at once.  The value here
  276.    is chosen to fill up a packet.  */
  277.  
  278. #define MAXBUFBYTES ((PBUFSIZ-150)*16/75 )
  279.  
  280. static int es1800_break_vec = 0;
  281. static char es1800_break_insn[2];
  282. static long es1800_break_address;
  283. static void (*old_sigint)();        /* Old signal-handler for sigint */
  284. static jmp_buf interrupt;
  285.  
  286. /* Local signalhandler to allow breaking tranfers or program run.
  287.    Rely on global variables: old_sigint(), interrupt */
  288.  
  289. static void
  290. es1800_request_quit ()
  291. {
  292.   /* restore original signalhandler */
  293.   signal (SIGINT, old_sigint);
  294.   longjmp (interrupt, 1);
  295. }
  296.  
  297.  
  298. /* Reset emulator.
  299.    Sending reset character(octal 32) to emulator.
  300.    quit - return to '(esgdb)' prompt or continue    */
  301.  
  302. static void
  303. es1800_reset (quit)
  304.      char *quit;
  305. {
  306.   char buf[80];
  307.  
  308.   if (quit)
  309.     {
  310.       printf ("\nResetting emulator...  ");
  311.     }
  312.   strcpy (buf, "\032");
  313.   send (buf);
  314.   expect_prompt ();
  315.   if (quit)
  316.     {
  317.       error ("done\n");
  318.     }
  319. }
  320.  
  321.  
  322. /* Open a connection to a remote debugger and push the new target
  323.    onto the stack. Check if the emulator is responding and find out
  324.    what kind of processor the emulator is connected to.
  325.    Initiate the breakpoint handling in the emulator.
  326.  
  327.    name     - the filename used for communication (ex. '/dev/tta')
  328.    from_tty - says whether to be verbose or not */
  329.  
  330. static void
  331. es1800_open (name, from_tty)
  332.      char *name;
  333.      int from_tty;
  334. {
  335.   char buf[PBUFSIZ];
  336.   char *p;
  337.   int i, fcflag;
  338.  
  339.   m68020 = 0;
  340.  
  341.   if (!name)           /* no device name given in target command */
  342.     {
  343.       error_no_arg ("serial port device name");
  344.     }
  345.  
  346.   target_preopen (from_tty);
  347.   es1800_close (0);
  348.  
  349.   /* open the device and configure it for communication */
  350.  
  351. #ifndef DEBUG_STDIN
  352.  
  353.   es1800_desc = SERIAL_OPEN (name);
  354.   if (es1800_desc == NULL)
  355.     {
  356.       perror_with_name (name);
  357.     }
  358.   savename = savestring (name, strlen (name));
  359.  
  360.   es1800_saved_ttystate = SERIAL_GET_TTY_STATE (es1800_desc);
  361.  
  362.   if ((fcflag = fcntl (es1800_desc->fd, F_GETFL, 0)) == -1)
  363.     {
  364.       perror_with_name ("fcntl serial");
  365.     }
  366.   es1800_fc_save = fcflag;
  367.  
  368.   fcflag = (fcflag & (FREAD | FWRITE)); /* mask out any funny stuff */
  369.   if (fcntl (es1800_desc->fd, F_SETFL, fcflag) == -1)
  370.     {
  371.       perror_with_name ("fcntl serial");
  372.     }
  373.  
  374.   if (baud_rate != -1)
  375.     {
  376.       if (SERIAL_SETBAUDRATE (es1800_desc, baud_rate))
  377.     {
  378.       SERIAL_CLOSE (es1800_desc);
  379.       perror_with_name (name);
  380.     }
  381.     }
  382.  
  383.   SERIAL_RAW (es1800_desc);
  384.  
  385.   /* If there is something sitting in the buffer we might take it as a
  386.      response to a command, which would be bad.  */
  387.   SERIAL_FLUSH_INPUT (es1800_desc);
  388.  
  389. #endif    /* DEBUG_STDIN */
  390.  
  391.   push_target (&es1800_ops);    /* Switch to using remote target now */
  392.   if (from_tty)
  393.     {
  394.       printf ("Remote ES1800 debugging using %s\n", name);
  395.     }
  396.  
  397. #if defined (LOG_FILE)
  398.  
  399.   log_file = fopen (LOG_FILE, "w");
  400.   if (log_file == NULL)
  401.     {
  402.       perror_with_name (LOG_FILE);
  403.     }
  404.  
  405. #endif    /* LOG_FILE */
  406.  
  407.   /* Hello?  Are you there?, also check mode  */
  408.  
  409.   /*  send_with_reply( "DB 0 TO 1", buf, sizeof(buf)); */
  410.   /*  for (p = buf, i = 0; *p++ =='0';)  */   /* count the number of zeros */
  411.   /*      i++; */
  412.  
  413.   send ("\032");
  414.   getmessage (buf, sizeof (buf));  /* send reset character */
  415.  
  416.   if (from_tty)
  417.     {
  418.       printf ("Checking mode.... ");
  419.     }
  420.   /*  m68020 = (i==8); */   /* if eight zeros then we are in m68020 mode */
  421.  
  422.   /* What kind of processor am i talking to ?*/
  423.   p = buf;
  424.   while (*p++ != '\n') {;}
  425.   while (*p++ != '\n') {;}
  426.   while (*p++ != '\n') {;}
  427.   for (i = 0; i < 20; i++, p++) {;}
  428.   m68020 = !strncmp (p, "68020", 5);
  429.   if (from_tty)
  430.     {
  431.       printf ("You are in %s(%c%c%c%c%c)-mode\n", MODE, p[0], p[1], p[2],
  432.           p[3], p[4]);
  433.     }
  434.  
  435.   /* if no init_break statement is present in .gdb file we have to check 
  436.      whether to download a breakpoint routine or not */
  437.  
  438. #if 0
  439.   if ((es1800_break_vec == 0) || (verify_break (es1800_break_vec) != 0)
  440.       && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
  441.     {
  442.       CORE_ADDR memaddress;
  443.       printf ("Give the start address of the breakpoint routine: ");
  444.       scanf ("%li", &memaddress);
  445.       es1800_init_break ((es1800_break_vec ? es1800_break_vec :
  446.               ES1800_BREAK_VEC), memaddress);
  447.     }
  448. #endif
  449.  
  450. }
  451.  
  452. /*  Close out all files and local state before this target loses control.
  453.     quitting - are we quitting gdb now? */
  454.  
  455. static void
  456. es1800_close (quitting)
  457.      int quitting;
  458. {
  459.   if (es1800_desc != NULL)
  460.     {
  461.       printf ("\nClosing connection to emulator...\n");
  462.       if (SERIAL_SET_TTY_STATE (es1800_desc, es1800_saved_ttystate) < 0)
  463.     print_sys_errmsg ("warning: unable to restore tty state", errno);
  464.       fcntl (es1800_desc->fd, F_SETFL, es1800_fc_save);
  465.       SERIAL_CLOSE (es1800_desc);
  466.       es1800_desc = NULL;
  467.     }
  468.   if (savename != NULL)
  469.     {
  470.       free (savename);
  471.     }
  472.   savename = NULL;
  473.  
  474. #if defined (LOG_FILE)
  475.  
  476.   if (log_file != NULL)
  477.     {
  478.       if (ferror (log_file))
  479.     {
  480.       printf ("Error writing log file.\n");
  481.     }
  482.       if (fclose (log_file) != 0)
  483.     {
  484.       printf ("Error closing log file.\n");
  485.     }
  486.       log_file = NULL;
  487.     }
  488.  
  489. #endif    /* LOG_FILE */
  490.  
  491. }
  492.  
  493. /*  Attaches to a process on the target side
  494.     proc_id  - the id of the process to be attached.
  495.     from_tty - says whether to be verbose or not */
  496.  
  497. static void
  498. es1800_attach (args, from_tty)
  499.     char *args;
  500.     int from_tty;
  501. {
  502.   error ("Cannot attach to pid %s, this feature is not implemented yet.",
  503.      args);
  504. }
  505.  
  506.  
  507. /* Takes a program previously attached to and detaches it.
  508.    We better not have left any breakpoints
  509.    in the program or it'll die when it hits one.
  510.    Close the open connection to the remote debugger.
  511.    Use this when you want to detach and do something else
  512.    with your gdb.
  513.  
  514.    args     - arguments given to the 'detach' command
  515.    from_tty - says whether to be verbose or not */
  516.  
  517. static void
  518. es1800_detach (args, from_tty)
  519.      char *args;
  520.      int from_tty;
  521. {
  522.   if (args)
  523.     {
  524.       error ("Argument given to \"detach\" when remotely debugging.");
  525.     }
  526.   pop_target ();
  527.   if (from_tty)
  528.     {
  529.       printf ("Ending es1800 remote debugging.\n");
  530.     }
  531. }
  532.  
  533.  
  534. /* Tell the remote machine to resume.
  535.    step    - single-step or run free
  536.    siggnal - the signal value to be given to the target (0 = no signal) */
  537.  
  538. static void
  539. es1800_resume (pid, step, siggnal)
  540.      int pid;
  541.      int step;
  542.      enum target_signal siggnal;
  543. {
  544.   char buf[PBUFSIZ];
  545.  
  546.   if (siggnal)
  547.     {
  548.       error ("Can't send signals to a remote system.");
  549.     }
  550.   if (step)
  551.     {
  552.       strcpy (buf,"STP\r");
  553.       send (buf);
  554.     }
  555.   else
  556.     {
  557.       send_command ("RBK");
  558.     }
  559. }
  560.  
  561. /* Wait until the remote machine stops, then return,
  562.    storing status in STATUS just as `wait' would.
  563.    status -  */
  564.  
  565. static int
  566. es1800_wait (pid, status)
  567.      int pid;
  568.      struct target_waitstatus *status;
  569. {
  570.   unsigned char buf[PBUFSIZ];
  571.   int old_timeout = timeout;
  572.  
  573.   status->kind = TARGET_WAITKIND_EXITED;
  574.   status->value.integer = 0;
  575.  
  576.   timeout = 0;        /* Don't time out -- user program is running. */
  577.   if (!setjmp (interrupt))
  578.     {
  579.       old_sigint = signal (SIGINT, es1800_request_quit);
  580.       while (1)
  581.         {
  582.       getmessage (buf, sizeof(buf));
  583.       if (strncmp ( buf, "\r\n* BREAK *", 11) == 0) 
  584.         {
  585.           status->kind = TARGET_WAITKIND_STOPPED;
  586.           status->value.sig = TARGET_SIGNAL_TRAP;
  587.           send_command ("STP");    /* Restore stack and PC and such */
  588.           if (m68020)
  589.         {
  590.           send_command ("STP");
  591.         }
  592.           break;
  593.         }
  594.       if (strncmp (buf, "STP\r\n ", 6) == 0)
  595.         {
  596.           status->kind = TARGET_WAITKIND_STOPPED;
  597.           status->value.sig = TARGET_SIGNAL_TRAP;
  598.           break;
  599.         }
  600.       if (buf[strlen (buf) - 2] == 'R')
  601.         {
  602.           printf ("Unexpected emulator reply: \n%s\n", buf);
  603.         }
  604.       else
  605.         {
  606.           printf ("Unexpected stop: \n%s\n", buf);
  607.           status->kind = TARGET_WAITKIND_STOPPED;
  608.           status->value.sig = TARGET_SIGNAL_QUIT;
  609.           break;
  610.         }
  611.         }
  612.     }
  613.   else
  614.     {
  615.       fflush (stdin);
  616.       printf ("\nStopping emulator...");
  617.       if (!setjmp (interrupt))
  618.     {
  619.       old_sigint = signal (SIGINT, es1800_request_quit);
  620.       send_command ("STP");
  621.       printf (" emulator stopped\n");
  622.       status->kind = TARGET_WAITKIND_STOPPED;
  623.       status->value.sig = TARGET_SIGNAL_INT;
  624.         }
  625.       else
  626.     {
  627.       fflush (stdin);
  628.       es1800_reset ((char*) 1);
  629.     }
  630.     }
  631.   signal (SIGINT, old_sigint);
  632.   timeout = old_timeout;
  633.   return (0);
  634. }
  635.  
  636.  
  637. /* Fetch register values from remote machine.
  638.    regno - the register to be fetched (fetch all registers if -1) */
  639.  
  640. static void
  641. es1800_fetch_register (regno)
  642.      int regno;
  643. {
  644.   char buf[PBUFSIZ];
  645.   int k;
  646.   int r;
  647.   char *p;
  648.   static char regtab[18][4] = 
  649.     {
  650.       "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
  651.       "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
  652.       "SR ", "PC "
  653.     };
  654.  
  655.   if ((regno < 15) || (regno == 16) || (regno == 17))
  656.     {
  657.       r = regno * 4;
  658.       send_with_reply (regtab[regno], buf, sizeof (buf));
  659.       p = buf;
  660.       for (k = 0; k < 4; k++)
  661.     {
  662.       if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
  663.         {
  664.           error ("Emulator reply is too short: %s", buf);
  665.         }
  666.       registers[r++] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
  667.     }
  668.     }
  669.   else
  670.     {
  671.       es1800_fetch_registers ();
  672.     }
  673. }
  674.  
  675. /* Read the remote registers into REGISTERS.
  676.    Always fetches all registers. */
  677.  
  678. static void
  679. es1800_fetch_registers ()
  680. {
  681.   char buf[PBUFSIZ];
  682.   char SR_buf[PBUFSIZ];
  683.   int i;
  684.   int k;
  685.   int r;
  686.   char *p;
  687.  
  688.   send_with_reply ("DR", buf, sizeof (buf));
  689.  
  690.   /* Reply is edited to a string that describes registers byte by byte,
  691.      each byte encoded as two hex characters.  */
  692.  
  693.   p = buf;
  694.   r = 0;
  695.  
  696.   /*  parsing row one - D0-D7-registers  */
  697.  
  698.   while (*p++ != '\n') {;}
  699.   for (i = 4; i < 70; i += (i == 39 ? 3 : 1))
  700.     {
  701.       for (k = 0; k < 4; k++)
  702.     {
  703.       if (p[i+0] == 0 || p[i+1] == 0)
  704.         {
  705.           error ("Emulator reply is too short: %s", buf);
  706.         }
  707.       registers[r++] = (fromhex (p[i+0]) * 16) + fromhex (p[i+1]);
  708.       i += 2;
  709.     }
  710.     }
  711.   p += i;
  712.  
  713.   /*  parsing row two - A0-A6-registers  */
  714.  
  715.   while (*p++ != '\n') {;}
  716.   for (i = 4; i < 61; i += (i == 39 ? 3 : 1))
  717.     {
  718.       for (k = 0; k < 4; k++)
  719.     {
  720.       if (p[i+0] == 0 || p[i+1] == 0)
  721.         {
  722.           error ("Emulator reply is too short: %s", buf);
  723.         }
  724.       registers[r++] = (fromhex (p[i+0])) * 16 + fromhex (p[i+1]);
  725.       i += 2;
  726.     }
  727.     }
  728.   p += i;
  729.  
  730.   while (*p++ != '\n') {;}
  731.  
  732.   /* fetch SSP-, SR- and PC-registers  */
  733.  
  734.   /* first - check STATUS-word and decide which stackpointer to use */
  735.  
  736.   send_with_reply ("SR", SR_buf, sizeof (SR_buf));
  737.   p = SR_buf;
  738.   p += 5;
  739.  
  740.   if (m68020)
  741.     {
  742.       if (*p == '3')         /* use masterstackpointer MSP */
  743.     {
  744.       send_with_reply ("MSP", buf, sizeof (buf));
  745.     }
  746.       else if (*p == '2')    /* use interruptstackpointer ISP  */
  747.     {
  748.       send_with_reply ("ISP", buf, sizeof (buf));
  749.     }
  750.       else            /* use userstackpointer USP  */
  751.     {
  752.       send_with_reply ("USP", buf, sizeof (buf)); 
  753.     }
  754.       p = buf;
  755.       for (k = 0; k<4; k++)
  756.     {
  757.       if (p[k*2+1] == 0 || p[k*2+2] == 0)
  758.         {
  759.           error ("Emulator reply is too short: %s", buf);
  760.         }
  761.       registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
  762.     }
  763.  
  764.       p = SR_buf;
  765.       for (k = 0; k < 4; k++)
  766.     {
  767.       if (p[k*2+1] == 0 || p[k*2+2] == 0)
  768.         {
  769.           error ("Emulator reply is too short: %s", buf);
  770.         }
  771.       registers[r++] =
  772.         fromhex (SR_buf[k*2+1]) * 16 + fromhex (SR_buf[k*2+2]);
  773.     }
  774.       send_with_reply ("PC", buf, sizeof (buf));
  775.       p = buf;
  776.       for (k = 0; k<4; k++)
  777.     {
  778.       if (p[k*2+1] == 0 || p[k*2+2] == 0)
  779.         {
  780.           error ("Emulator reply is too short: %s", buf);
  781.         }
  782.       registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
  783.     }
  784.     }
  785.   else    /* 68000-mode */
  786.     {                       
  787.       if (*p == '2') /* use supervisorstackpointer SSP  */
  788.     {
  789.       send_with_reply ("SSP", buf, sizeof (buf)); 
  790.     }
  791.       else  /* use userstackpointer USP  */
  792.     {
  793.       send_with_reply ("USP", buf, sizeof (buf)); 
  794.     }
  795.  
  796.       /* fetch STACKPOINTER */
  797.  
  798.       p = buf;
  799.       for (k = 0; k < 4; k++)
  800.     {
  801.       if (p[k*2 + 1] == 0 || p[k*2 + 2] == 0)
  802.         {
  803.           error ("Emulator reply is too short: %s", buf);
  804.         }
  805.       registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
  806.     }
  807.  
  808.       /* fetch STATUS */
  809.  
  810.       p = SR_buf;
  811.       for (k = 0; k < 4; k++)
  812.     {
  813.       if (p[k*2+1] == 0 || p[k*2+2] == 0)
  814.         {
  815.           error ("Emulator reply is too short: %s", buf);
  816.         }
  817.       registers[r++] =
  818.         fromhex (SR_buf[k*2+1]) * 16 + fromhex (SR_buf[k*2+2]);
  819.     }
  820.  
  821.       /* fetch PC */
  822.  
  823.       send_with_reply ("PC", buf, sizeof (buf)); 
  824.       p = buf;
  825.       for (k = 0; k < 4; k++)
  826.     {
  827.       if (p[k*2+1] == 0 || p[k*2+2] == 0)
  828.         {
  829.           error ("Emulator reply is too short: %s", buf);
  830.         }
  831.       registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
  832.     }    
  833.     }
  834. }
  835.  
  836. /* Store register value, located in REGISTER, on the target processor.
  837.    regno - the register-number of the register to store
  838.            (-1 means store them all)
  839.    FIXME: Return errno value.  */
  840.  
  841. static void
  842. es1800_store_register(regno)
  843.      int regno;
  844. {
  845.  
  846.   static char regtab[18][4] =
  847.     {
  848.       "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
  849.       "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
  850.       "SR ", "PC "
  851.     };
  852.  
  853.   char buf[PBUFSIZ];
  854.   char SR_buf[PBUFSIZ];
  855.   char stack_pointer[4];
  856.   char *p;
  857.   int i;
  858.   int j;
  859.   int k;
  860.   unsigned char *r;
  861.  
  862.   r = (unsigned char *) registers;
  863.  
  864.   if (regno == -1)  /* write all registers */
  865.     {
  866.       j = 0;
  867.       k = 18;
  868.     }
  869.   else              /* write one register */
  870.     {
  871.       j = regno;
  872.       k = regno+1;
  873.       r += regno * 4; 
  874.     }    
  875.  
  876.   if ((regno == -1) || (regno == 15))
  877.     {
  878.       /* fetch current status */
  879.       send_with_reply ("SR", SR_buf, sizeof (SR_buf));
  880.       p = SR_buf;
  881.       p += 5;
  882.       if (m68020)
  883.     {
  884.       if (*p == '3') /* use masterstackpointer MSP */
  885.         {
  886.           strcpy (stack_pointer,"MSP");  
  887.         }
  888.       else
  889.         {
  890.           if (*p == '2') /* use interruptstackpointer ISP  */
  891.         {
  892.           strcpy (stack_pointer,"ISP");  
  893.         }
  894.           else
  895.         {
  896.           strcpy (stack_pointer,"USP");  /* use userstackpointer USP  */
  897.         }
  898.         }
  899.     }
  900.       else  /* 68000-mode */
  901.     {
  902.       if (*p == '2') /* use supervisorstackpointer SSP  */
  903.         {
  904.           strcpy (stack_pointer,"SSP");  
  905.         }
  906.       else
  907.         {
  908.           strcpy (stack_pointer,"USP");/* use userstackpointer USP  */  
  909.         }
  910.     }
  911.       strcpy (regtab[15],stack_pointer);
  912.     }
  913.  
  914.   for (i = j; i<k; i++)
  915.     {
  916.       buf[0] = regtab[i][0];
  917.       buf[1] = regtab[i][1];
  918.       buf[2] = regtab[i][2];
  919.       buf[3] = '=';
  920.       buf[4] = '$';
  921.       buf[5] = tohex ((*r >> 4) & 0x0f);
  922.       buf[6] = tohex (*r++ & 0x0f);
  923.       buf[7] = tohex ((*r >> 4) & 0x0f);
  924.       buf[8] = tohex (*r++ & 0x0f);
  925.       buf[9] = tohex ((*r >> 4) & 0x0f);
  926.       buf[10] = tohex (*r++ & 0x0f);
  927.       buf[11] = tohex ((*r >> 4) & 0x0f);
  928.       buf[12] = tohex (*r++ & 0x0f);
  929.       buf[13] = 0;
  930.  
  931.       send_with_reply (buf, buf, sizeof (buf)); /* FIXME, reply not used? */
  932.     }
  933. }
  934.  
  935.  
  936. /* Prepare to store registers.  */
  937.  
  938. static void 
  939. es1800_prepare_to_store ()
  940. {
  941.   /* Do nothing, since we can store individual regs */
  942. }
  943.  
  944. /* Convert hex digit A to a number.  */
  945.  
  946. static int
  947. fromhex (a)
  948.      int a;
  949. {
  950.   if (a >= '0' && a <= '9')
  951.     {
  952.       return a - '0';
  953.     }
  954.   else if (a >= 'a' && a <= 'f')
  955.     {
  956.       return a - 'a' + 10;
  957.     }
  958.   else if (a >= 'A' && a <= 'F')
  959.     {
  960.       return a - 'A' + 10;
  961.     }
  962.   else
  963.     {
  964.       error ("Reply contains invalid hex digit");
  965.     }
  966.   return (-1);
  967. }
  968.  
  969.  
  970. /* Convert number NIB to a hex digit.  */
  971.  
  972. static int
  973. tohex (nib)
  974.      int nib;
  975. {
  976.   if (nib < 10)
  977.     {
  978.       return ('0' + nib);
  979.     }
  980.   else
  981.     {
  982.       return ('A' + nib - 10);
  983.     }
  984. }
  985.  
  986. /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
  987.    to or from debugger address MYADDR.  Write to inferior if WRITE is
  988.    nonzero.  Returns length of data written or read; 0 for error. 
  989.  
  990.    memaddr - the target's address
  991.    myaddr  - gdb's address
  992.    len     - number of bytes 
  993.    write   - write if != 0 otherwise read    */
  994.  
  995. static int
  996. es1800_xfer_inferior_memory (memaddr, myaddr, len, write, tops)
  997.      CORE_ADDR memaddr;
  998.      char *myaddr;
  999.      int len;
  1000.      int write;
  1001.      struct target_ops *tops;    /* Unused */
  1002. {
  1003.   int origlen = len;
  1004.   int xfersize;
  1005.  
  1006.   while (len > 0)
  1007.     {
  1008.       xfersize = len > MAXBUFBYTES ? MAXBUFBYTES : len;
  1009.       if (write)
  1010.     {
  1011.       es1800_write_bytes (memaddr, myaddr, xfersize);
  1012.     }
  1013.       else
  1014.     {
  1015.       es1800_read_bytes (memaddr, myaddr, xfersize);
  1016.     }
  1017.       memaddr += xfersize;
  1018.       myaddr += xfersize;
  1019.       len -= xfersize;
  1020.     }
  1021.   return (origlen); /* no error possible */
  1022. }
  1023.  
  1024.  
  1025. /* Write memory data directly to the emulator.
  1026.    This does not inform the data cache; the data cache uses this.
  1027.    MEMADDR is the address in the remote memory space.
  1028.    MYADDR is the address of the buffer in our space.
  1029.    LEN is the number of bytes.
  1030.  
  1031.    memaddr - the target's address
  1032.    myaddr  - gdb's address
  1033.    len     - number of bytes   */
  1034.  
  1035. static void
  1036. es1800_write_bytes (memaddr, myaddr, len)
  1037.      CORE_ADDR memaddr;
  1038.      char *myaddr;
  1039.      int len;
  1040. {
  1041.   char buf[PBUFSIZ];
  1042.   int i;
  1043.   char *p;
  1044.  
  1045.   p = myaddr;
  1046.   for (i = 0; i < len; i++)
  1047.     {
  1048.       sprintf (buf, "@.B$%x=$%x", memaddr+i, (*p++) & 0xff);
  1049.       send_with_reply (buf, buf, sizeof (buf));      /* FIXME send_command? */
  1050.     }
  1051. }
  1052.  
  1053.  
  1054. /* Read memory data directly from the emulator.
  1055.    This does not use the data cache; the data cache uses this.
  1056.  
  1057.    memaddr - the target's address
  1058.    myaddr  - gdb's address
  1059.    len     - number of bytes   */
  1060.  
  1061. static void
  1062. es1800_read_bytes (memaddr, myaddr, len)
  1063.      CORE_ADDR memaddr;
  1064.      char *myaddr;
  1065.      int len;
  1066. {
  1067.   static int DB_tab[16] = {8,11,14,17,20,23,26,29,34,37,40,43,46,49,52,55};
  1068.   char buf[PBUFSIZ];
  1069.   int i;
  1070.   int low_addr;
  1071.   char *p;
  1072.   char *b;
  1073.  
  1074.   if (len > PBUFSIZ / 2 - 1)
  1075.     {
  1076.       abort ();
  1077.     }
  1078.  
  1079.   if (len == 1)    /* The emulator does not like expressions like:  */
  1080.     {
  1081.       len = 2;    /* DB.B $20018 TO $20018                       */
  1082.     }
  1083.  
  1084.   /* Reply describes registers byte by byte, each byte encoded as two hex
  1085.      characters.  */
  1086.  
  1087.   sprintf (buf, "DB.B $%x TO $%x", memaddr, memaddr+len-1);
  1088.   send_with_reply (buf, buf, sizeof (buf));
  1089.   b = buf;
  1090.   low_addr = memaddr&0x0f;
  1091.   for (i = low_addr; i < low_addr + len; i++)
  1092.     {
  1093.       if ((!(i % 16)) && i)
  1094.     {   /* if (i = 16,32,48)  */
  1095.       while (*p++!='\n') {;}
  1096.       b = p;
  1097.     }
  1098.       p = b + DB_tab[i%16] + (m68020 ? 2 : 0);
  1099.       if (p[0] == 32 || p[1] == 32)
  1100.     {
  1101.       error ("Emulator reply is too short: %s", buf);
  1102.     }
  1103.       myaddr[i-low_addr] = fromhex (p[0]) * 16 + fromhex (p[1]);
  1104.     }
  1105. }
  1106.  
  1107. /* Information about the current target  */
  1108.  
  1109. static void
  1110. es1800_files_info (tops)
  1111.      struct target_ops *tops;    /* Unused */
  1112. {
  1113.   printf ("ES1800 Attached to %s at %d baud in %s mode\n", savename, 19200,
  1114.       MODE);
  1115. }
  1116.  
  1117.  
  1118. /* We read the contents of the target location and stash it,
  1119.    then overwrite it with a breakpoint instruction.
  1120.  
  1121.    addr           - is the target location in the target machine.
  1122.    contents_cache - is a pointer to memory allocated for saving the target contents.
  1123.                     It is guaranteed by the caller to be long enough to save sizeof 
  1124.                     BREAKPOINT bytes.
  1125.  
  1126.    FIXME: This size is target_arch dependent and should be available in
  1127.    the target_arch transfer vector, if we ever have one...  */
  1128.  
  1129. static int
  1130. es1800_insert_breakpoint (addr, contents_cache)
  1131.      CORE_ADDR addr;
  1132.      char *contents_cache;
  1133. {
  1134.   int val; 
  1135.  
  1136.   val = target_read_memory (addr, contents_cache, sizeof (es1800_break_insn));
  1137.  
  1138.   if (val == 0)
  1139.     {
  1140.       val = target_write_memory (addr, es1800_break_insn,
  1141.                  sizeof (es1800_break_insn));
  1142.     }
  1143.  
  1144.   return (val);
  1145. }
  1146.  
  1147.  
  1148. /* Write back the stashed instruction
  1149.  
  1150.    addr           - is the target location in the target machine.
  1151.    contents_cache - is a pointer to memory allocated for saving the target contents.
  1152.                     It is guaranteed by the caller to be long enough to save sizeof 
  1153.                     BREAKPOINT bytes.    */
  1154.  
  1155. static int
  1156. es1800_remove_breakpoint (addr, contents_cache)
  1157.      CORE_ADDR addr;
  1158.      char *contents_cache;
  1159. {
  1160.  
  1161.   return (target_write_memory (addr, contents_cache,
  1162.                    sizeof (es1800_break_insn)));
  1163. }
  1164.  
  1165. /* create_break_insn ()
  1166.    Primitive datastructures containing the es1800 breakpoint instruction  */
  1167.  
  1168. static void
  1169. es1800_create_break_insn (ins, vec)
  1170.      char *ins;
  1171.      int vec;
  1172. {
  1173.   if (vec == 15)
  1174.     {
  1175.       ins[0] = 0x4e;
  1176.       ins[1] = 0x4f;
  1177.     }
  1178. }
  1179.  
  1180.  
  1181. /* verify_break ()
  1182.    Seach for breakpoint routine in emulator memory.
  1183.    returns non-zero on failure
  1184.    vec - trap vector used for breakpoints  */
  1185.  
  1186. static int
  1187. verify_break (vec)
  1188.      int vec;
  1189. {
  1190.   CORE_ADDR memaddress;
  1191.   char buf[8];
  1192.   char *instr = "NqNqNqNs";      /* breakpoint routine */
  1193.   int status;
  1194.  
  1195.   get_break_addr (vec, &memaddress);
  1196.  
  1197.   if (memaddress)
  1198.     {
  1199.       status = target_read_memory (memaddress, buf, 8); 
  1200.       if (status != 0)
  1201.     {
  1202.       memory_error (status, memaddress);
  1203.     }
  1204.       return (STRCMP (instr, buf));
  1205.     }
  1206.     return (-1);
  1207. }
  1208.  
  1209.  
  1210. /* get_break_addr ()
  1211.    find address of breakpint routine
  1212.    vec - trap vector used for breakpoints
  1213.    addrp - store the address here    */
  1214.  
  1215. static void
  1216. get_break_addr (vec, addrp)
  1217.      int vec;
  1218.      CORE_ADDR *addrp;
  1219. {
  1220.   CORE_ADDR memaddress = 0;
  1221.   int status;
  1222.   int k;
  1223.   char buf[PBUFSIZ];
  1224.   char base_addr[4];
  1225.   char *p;
  1226.  
  1227.   if (m68020)
  1228.     {
  1229.       send_with_reply ("VBR ", buf, sizeof (buf));
  1230.       p = buf;
  1231.       for (k = 0; k < 4; k++)
  1232.     {
  1233.       if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
  1234.         {
  1235.           error ("Emulator reply is too short: %s", buf);
  1236.         }
  1237.       base_addr[k] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
  1238.     }
  1239.       /* base addr of exception vector table */
  1240.       memaddress = *((CORE_ADDR *) base_addr);
  1241.     }
  1242.  
  1243.     memaddress += (vec + 32) * 4;     /* address of trap vector */
  1244.     status = target_read_memory (memaddress, (char *) addrp, 4); 
  1245.     if (status != 0)                                                   
  1246.       {
  1247.     memory_error (status, memaddress);
  1248.       }
  1249. }
  1250.  
  1251.  
  1252. /* Kill an inferior process */
  1253.  
  1254. static void
  1255. es1800_kill ()
  1256. {
  1257.   if (inferior_pid != 0)
  1258.     {
  1259.       inferior_pid = 0;
  1260.       es1800_mourn_inferior ();
  1261.     }
  1262. }
  1263.  
  1264.  
  1265. /* Load a file to the ES1800 emulator. 
  1266.    Converts the file from a.out format into Extended Tekhex format
  1267.    before the file is loaded.
  1268.    Also loads the trap routine, and sets the ES1800 breakpoint on it
  1269.    filename - the a.out to be loaded
  1270.    from_tty - says whether to be verbose or not
  1271.    FIXME Uses emulator overlay memory for trap routine    */
  1272.  
  1273. static void
  1274. es1800_load (filename, from_tty)
  1275.      char *filename;
  1276.      int from_tty;
  1277. {
  1278.  
  1279.   FILE *instream;
  1280.   char loadname[15];
  1281.   char buf[160];
  1282.   struct cleanup *old_chain;
  1283.   int es1800_load_format = 5;
  1284.  
  1285.   if (es1800_desc == NULL) 
  1286.     {
  1287.       printf ("No emulator attached, type emulator-command first\n");
  1288.       return;
  1289.     }
  1290.  
  1291.   filename = tilde_expand (filename);
  1292.   make_cleanup (free, filename);
  1293.  
  1294.   switch (es1800_load_format)
  1295.     {
  1296.       case 2:   /* Extended Tekhex  */
  1297.         if (from_tty)
  1298.       {
  1299.         printf ("Converting \"%s\" to Extended Tekhex Format\n", filename);
  1300.       }
  1301.     sprintf (buf, "tekhex %s", filename);
  1302.     system (buf);
  1303.     sprintf (loadname, "out.hex");
  1304.     break;
  1305.  
  1306.       case 5:   /* Motorola S-rec  */
  1307.     if (from_tty)
  1308.       {
  1309.         printf ("Converting \"%s\" to Motorola S-record format\n",
  1310.             filename);
  1311.       }
  1312.     /* in the future the source code in copy (part of binutils-1.93) will
  1313.        be included in this file */
  1314.     sprintf (buf,
  1315.          "copy -s \"a.out-sunos-big\" -d \"srec\" %s /tmp/out.hex",
  1316.          filename);
  1317.     system (buf);
  1318.     sprintf (loadname, "/tmp/out.hex");
  1319.     break;
  1320.  
  1321.       default:
  1322.     error ("Downloading format not defined\n");
  1323.     }
  1324.  
  1325.   breakpoint_init_inferior ();
  1326.   inferior_pid = 0;
  1327.   if (from_tty)
  1328.     {
  1329.       printf ("Downloading \"%s\" to the ES 1800\n",filename);
  1330.     }
  1331.   if ((instream = fopen (loadname, "r")) == NULL)
  1332.     {
  1333.       perror_with_name ("fopen:");
  1334.     }
  1335.  
  1336.   old_chain = make_cleanup (fclose, instream);
  1337.   immediate_quit++;
  1338.  
  1339.   es1800_reset (0);
  1340.  
  1341.   download (instream, from_tty, es1800_load_format);
  1342.  
  1343.   /* if breakpoint routine is not present anymore we have to check 
  1344.      whether to download a new breakpoint routine or not */
  1345.  
  1346.   if ((verify_break (es1800_break_vec) != 0)
  1347.       && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
  1348.     {
  1349.       char buf[128];
  1350.       printf ("Using break vector 0x%x\n", es1800_break_vec);
  1351.       sprintf (buf, "0x%x ", es1800_break_vec);
  1352.       printf ("Give the start address of the breakpoint routine: ");
  1353.       fgets (buf + strlen (buf), sizeof (buf) - strlen (buf), stdin);
  1354.       es1800_init_break (buf, 0);
  1355.     }
  1356.  
  1357.   do_cleanups (old_chain);
  1358.   expect_prompt ();
  1359.   readchar ();  /* FIXME I am getting a ^G = 7 after the prompt  */
  1360.   printf ("\n");
  1361.  
  1362.   if (fclose (instream) == EOF)
  1363.     {
  1364.       ;
  1365.     }
  1366.  
  1367.   if (es1800_load_format != 2)
  1368.     {
  1369.       sprintf (buf, "/usr/bin/rm %s", loadname);
  1370.       system (buf);
  1371.     }
  1372.  
  1373.   symbol_file_command (filename, from_tty);   /* reading symbol table */
  1374.   immediate_quit--;
  1375. }
  1376.  
  1377. #if 0
  1378.  
  1379. #define NUMCPYBYTES 20
  1380.  
  1381. static void
  1382. bfd_copy (from_bfd, to_bfd)
  1383.      bfd *from_bfd;
  1384.      bfd *to_bfd;
  1385. {
  1386.   asection *p, *new;
  1387.   int i;
  1388.   char buf[NUMCPYBYTES];
  1389.  
  1390.   for (p = from_bfd->sections; p != NULL; p = p->next)
  1391.     {
  1392.       printf ("  Copying section %s. Size = %x.\n", p->name, p->_cooked_size);
  1393.       printf ("    vma = %x,  offset = %x,  output_sec = %x\n",
  1394.           p->vma, p->output_offset, p->output_section);
  1395.       new = bfd_make_section (to_bfd, p->name);
  1396.       if (p->_cooked_size &&
  1397.       !bfd_set_section_size (to_bfd, new, p->_cooked_size))
  1398.     {
  1399.       error ("Wrong BFD size!\n");
  1400.     }
  1401.       if (!bfd_set_section_flags (to_bfd, new, p->flags))
  1402.     {
  1403.       error ("bfd_set_section_flags");
  1404.     }
  1405.       new->vma = p->vma;
  1406.       
  1407.       for (i = 0; (i + NUMCPYBYTES) < p->_cooked_size ; i += NUMCPYBYTES)
  1408.     {
  1409.       if (!bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
  1410.                     (bfd_size_type) NUMCPYBYTES))
  1411.         {
  1412.           error ("bfd_get_section_contents\n");
  1413.         }
  1414.     if (!bfd_set_section_contents (to_bfd, new, (PTR) buf, (file_ptr) i,
  1415.                       (bfd_size_type) NUMCPYBYTES))
  1416.       {
  1417.         error ("bfd_set_section_contents\n");
  1418.       }
  1419.       }
  1420.       bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
  1421.                 (bfd_size_type) (p->_cooked_size - i));
  1422.       bfd_set_section_contents (to_bfd, new, (PTR) buf,(file_ptr) i,
  1423.                 (bfd_size_type) (p->_cooked_size - i));
  1424.     }
  1425. }
  1426.  
  1427. #endif
  1428.  
  1429. /* Start an process on the es1800 and set inferior_pid to the new
  1430.    process' pid.
  1431.    execfile - the file to run
  1432.    args     - arguments passed to the program
  1433.    env      - the environment vector to pass    */
  1434.  
  1435. static void
  1436. es1800_create_inferior (execfile, args, env)
  1437.      char *execfile;
  1438.      char *args;
  1439.      char **env;
  1440. {
  1441.   int entry_pt;
  1442.   int pid;
  1443. #if 0
  1444.   struct expression *expr;
  1445.   register struct cleanup *old_chain = 0;
  1446.   register value val;
  1447. #endif
  1448.  
  1449.   if (args && *args)
  1450.     {
  1451.       error ("Can't pass arguments to remote ES1800 process");
  1452.     }
  1453.  
  1454. #if 0
  1455.   if (query ("Use 'start' as entry point? "))
  1456.     {
  1457.       expr = parse_c_expression ("start");
  1458.       old_chain = make_cleanup (free_current_contents, &expr);
  1459.       val = evaluate_expression (expr);
  1460.       entry_pt = (val->location).address;
  1461.     }
  1462.   else
  1463.     {
  1464.       printf ("Enter the program's entry point (in hexadecimal): ");
  1465.       scanf ("%x", &entry_pt);
  1466.     }
  1467. #endif
  1468.  
  1469.   if (execfile == 0 || exec_bfd == 0)
  1470.     {
  1471.       error ("No exec file specified");
  1472.     }
  1473.  
  1474.   entry_pt = (int) bfd_get_start_address (exec_bfd);
  1475.  
  1476.   pid = 42;
  1477.  
  1478.   /* Now that we have a child process, make it our target.  */
  1479.  
  1480.   push_target (&es1800_child_ops);
  1481.  
  1482.   /* The "process" (board) is already stopped awaiting our commands, and
  1483.      the program is already downloaded.  We just set its PC and go.  */
  1484.  
  1485.   inferior_pid = pid;        /* Needed for wait_for_inferior below */
  1486.  
  1487.   clear_proceed_status ();
  1488.  
  1489.   /* Tell wait_for_inferior that we've started a new process.  */
  1490.  
  1491.   init_wait_for_inferior ();
  1492.  
  1493.   /* Set up the "saved terminal modes" of the inferior
  1494.      based on what modes we are starting it with.  */
  1495.  
  1496.   target_terminal_init ();
  1497.  
  1498.   /* Install inferior's terminal modes.  */
  1499.  
  1500.   target_terminal_inferior ();
  1501.  
  1502.   /* remote_start (args); */
  1503.   /* trap_expected = 0; */
  1504.   /* insert_step_breakpoint ();  FIXME, do we need this?  */
  1505.  
  1506.   /* Let 'er rip... */
  1507.   proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
  1508.  
  1509. }
  1510.  
  1511.  
  1512. /* The process has died, clean up.  */
  1513.  
  1514. static void
  1515. es1800_mourn_inferior ()
  1516. {
  1517.   remove_breakpoints ();
  1518.   unpush_target (&es1800_child_ops);
  1519.   generic_mourn_inferior ();    /* Do all the proper things now */
  1520. }
  1521.  
  1522. /* ES1800-protocol specific routines */
  1523.  
  1524. /* Keep discarding input from the remote system, until STRING is found. 
  1525.    Let the user break out immediately. 
  1526.    string - the string to expect
  1527.    nowait - break out if string not the emulator's first respond otherwise
  1528.             read until string is found (== 0)   */
  1529.  
  1530. static void
  1531. expect (string, nowait)
  1532.      char *string;
  1533.     int nowait;
  1534. {
  1535.   char c;
  1536.   char *p = string;
  1537.  
  1538.   immediate_quit++;
  1539.   while (1)
  1540.     {
  1541.       c = readchar ();
  1542.       if (isalpha (c))
  1543.     {
  1544.       c = toupper (c);
  1545.     }
  1546.       if (c == toupper (*p))
  1547.     {
  1548.       p++;
  1549.       if (*p == '\0')
  1550.         {
  1551.           immediate_quit--;
  1552.           return;
  1553.         }
  1554.     }
  1555.       else if (!nowait)
  1556.     {
  1557.       p = string;
  1558.     }
  1559.       else
  1560.     {
  1561.       printf ("\'%s\' expected\n" , string);
  1562.       printf ("char %d is %d", p - string, c);
  1563.       error ("\n" );
  1564.     }
  1565.     }
  1566. }
  1567.  
  1568. /* Keep discarding input until we see the prompt.  */
  1569.  
  1570. static void
  1571. expect_prompt ()
  1572. {
  1573.   expect (">", 0);
  1574. }
  1575.  
  1576.  
  1577. /* Read one character */
  1578.  
  1579. #ifdef DEBUG_STDIN
  1580.  
  1581. /* read from stdin */
  1582.  
  1583. static int
  1584. readchar ()
  1585. {
  1586.   char buf[1];
  1587.  
  1588.   buf[0] = '\0';
  1589.   printf ("readchar, give one character\n");
  1590.   read (0, buf, 1);
  1591.  
  1592. #if defined (LOG_FILE)
  1593.   putc (buf[0] & 0x7f, log_file);
  1594. #endif
  1595.  
  1596.   return (buf[0] & 0x7f);
  1597. }
  1598.  
  1599. #else    /* !DEBUG_STDIN */
  1600.  
  1601. /* Read a character from the remote system, doing all the fancy
  1602.    timeout stuff.  */
  1603.  
  1604. static int
  1605. readchar ()
  1606. {
  1607.   int ch;
  1608.  
  1609.   ch = SERIAL_READCHAR (es1800_desc, timeout);
  1610.  
  1611.   /* FIXME: doing an error() here will probably cause trouble, at least if from
  1612.      es1800_wait.  */
  1613.   if (ch == SERIAL_TIMEOUT)
  1614.     error ("Timeout reading from remote system.");
  1615.   else if (ch == SERIAL_ERROR)
  1616.     perror_with_name ("remote read");
  1617.  
  1618. #if defined (LOG_FILE)
  1619.   putc (ch & 0x7f, log_file);
  1620.   fflush (log_file);
  1621. #endif
  1622.  
  1623.   return (ch);
  1624. }
  1625.  
  1626. #endif    /* DEBUG_STDIN */
  1627.  
  1628.  
  1629. /* Send a command to the emulator and save the reply.
  1630.    Report an error if we get an error reply.
  1631.    string - the es1800 command
  1632.    buf    - containing the emulator reply on return
  1633.    len    - size of buf  */
  1634.  
  1635. static void
  1636. send_with_reply (string, buf, len)
  1637.     char *string, *buf;
  1638.     int len;
  1639. {
  1640.   send (string);
  1641.   SERIAL_WRITE (es1800_desc, "\r", 1);
  1642.  
  1643. #ifndef DEBUG_STDIN
  1644.   expect (string, 1);
  1645.   expect ("\r\n", 0);
  1646. #endif
  1647.  
  1648.   getmessage (buf, len);
  1649. }
  1650.  
  1651.  
  1652. /* Send the command in STR to the emulator adding \r. check
  1653.    the echo for consistency. 
  1654.    string - the es1800 command  */
  1655.  
  1656. static void
  1657. send_command (string)
  1658.      char *string;
  1659. {
  1660.   send (string);
  1661.   SERIAL_WRITE (es1800_desc, "\r", 1);
  1662.  
  1663. #ifndef DEBUG_STDIN
  1664.   expect (string, 0);
  1665.   expect_prompt ();
  1666. #endif
  1667.  
  1668. }
  1669.  
  1670. /* Send a string
  1671.    string - the es1800 command  */
  1672.  
  1673. static void
  1674. send (string)
  1675.      char *string;
  1676. {
  1677.   if (kiodebug) 
  1678.     {
  1679.       fprintf (stderr, "Sending: %s\n", string);
  1680.     }
  1681.   SERIAL_WRITE (es1800_desc, string, strlen (string));
  1682. }
  1683.  
  1684.  
  1685. /* Read a message from the emulator and store it in BUF. 
  1686.    buf    - containing the emulator reply on return
  1687.    len    - size of buf  */
  1688.  
  1689. static void
  1690. getmessage (buf, len)
  1691.      char *buf;
  1692.      int len;
  1693. {
  1694.   char *bp;
  1695.   int c;
  1696.   int prompt_found = 0;
  1697.   extern kiodebug;
  1698.  
  1699. #if defined (LOG_FILE)
  1700.   /* This is a convenient place to do this.  The idea is to do it often
  1701.      enough that we never lose much data if we terminate abnormally.  */
  1702.   fflush (log_file);
  1703. #endif
  1704.  
  1705.   bp = buf;
  1706.   c = readchar ();
  1707.   do
  1708.     {
  1709.       if (c) 
  1710.     {
  1711.       if (len-- < 2) /* char and terminaling NULL */
  1712.         {
  1713.           error ("input buffer overrun\n");
  1714.         }
  1715.       *bp++ = c;
  1716.     }
  1717.       c = readchar ();
  1718.       if ((c == '>') && (*(bp - 1) == ' '))
  1719.     {
  1720.       prompt_found = 1;
  1721.     }
  1722.     }
  1723.   while (!prompt_found);
  1724.   *bp = 0;
  1725.   
  1726.   if (kiodebug)
  1727.     {
  1728.       fprintf (stderr,"message received :%s\n", buf);
  1729.     }
  1730. }
  1731.  
  1732. static void
  1733. download (instream, from_tty, format)
  1734. FILE *instream;
  1735.      int from_tty;
  1736.      int format;
  1737. {
  1738.   char c;
  1739.   char buf[160];
  1740.   int i = 0;
  1741.  
  1742.   send_command ("SET #2,$1A");                  /* reset char = ^Z */
  1743.   send_command ("SET #3,$11,$13");              /* XON  XOFF */
  1744.   if (format == 2)
  1745.     {
  1746.       send_command ("SET #26,#2");
  1747.     }
  1748.   else
  1749.     {
  1750.       send_command ("SET #26,#5");        /* Format=Extended Tekhex */
  1751.     }
  1752.   send_command ("DFB = $10");
  1753.   send_command ("PUR");
  1754.   send_command ("CES");
  1755.   send ("DNL\r");
  1756.   expect ("DNL", 1);
  1757.   if (from_tty)
  1758.     {
  1759.       printf ("    0 records loaded...\r");
  1760.     }
  1761.   while (fgets (buf, 160, instream))
  1762.       {
  1763.     send (buf);
  1764.     if (from_tty)
  1765.       {
  1766.         printf ("%5d\b\b\b\b\b",++i);
  1767.         fflush (stdout);
  1768.       }
  1769.     if ((c = readchar ()) != 006) 
  1770.       {
  1771.         error ("expected ACK");
  1772.       }
  1773.       }
  1774.   if (from_tty)
  1775.     {
  1776.       printf ("- All");
  1777.     }
  1778. }
  1779.  
  1780. /* Additional commands */
  1781.  
  1782. #if defined (TIOCGETP) && defined (FNDELAY) && defined (EWOULDBLOCK)
  1783. #define PROVIDE_TRANSPARENT
  1784. #endif
  1785.  
  1786. #ifdef PROVIDE_TRANSPARENT
  1787. /* Talk directly to the emulator
  1788.    FIXME, uses busy wait, and is SUNOS (or at least BSD) specific  */
  1789.  
  1790. /*ARGSUSED*/
  1791. static void 
  1792. es1800_transparent (args, from_tty)
  1793.      char *args;
  1794.      int from_tty;
  1795. {
  1796.   int console;
  1797.   struct sgttyb modebl;
  1798.   int fcflag;
  1799.   int cc;
  1800.   struct sgttyb console_mode_save;
  1801.   int console_fc_save;
  1802.   int es1800_fc_save;
  1803.   int inputcnt = 80;
  1804.   char inputbuf[80];
  1805.   int consolecnt = 0;
  1806.   char consolebuf[80];
  1807.   int es1800_cnt = 0;
  1808.   char es1800_buf[80];
  1809.   int i;
  1810.  
  1811.   dont_repeat ();
  1812.   if (es1800_desc == NULL) 
  1813.     {
  1814.       printf ("No emulator attached, type emulator-command first\n");
  1815.       return;
  1816.     }
  1817.  
  1818.   printf ("\n");
  1819.   printf ("You are now communicating directly with the ES 1800 emulator.\n");
  1820.   printf ("To leave this mode (transparent mode), press ^E.\n");
  1821.   printf ("\n");
  1822.   printf (" >");
  1823.   fflush (stdout);
  1824.  
  1825.   if ((console = open ("/dev/tty", O_RDWR)) == -1) 
  1826.     {
  1827.       perror_with_name ("/dev/tty:");
  1828.     }
  1829.  
  1830.   if ((fcflag = fcntl (console, F_GETFL, 0)) == -1)
  1831.     {
  1832.       perror_with_name ("fcntl console");
  1833.     }
  1834.  
  1835.   console_fc_save = fcflag;
  1836.   fcflag = fcflag | FNDELAY;
  1837.  
  1838.   if (fcntl (console, F_SETFL, fcflag) == -1)
  1839.     {
  1840.       perror_with_name ("fcntl console");
  1841.     }
  1842.  
  1843.   if (ioctl (console, TIOCGETP, &modebl))
  1844.     {
  1845.       perror_with_name ("ioctl console");
  1846.     }
  1847.  
  1848.   console_mode_save = modebl;
  1849.   modebl.sg_flags = RAW; 
  1850.  
  1851.   if (ioctl (console, TIOCSETP, &modebl))
  1852.     {
  1853.       perror_with_name ("ioctl console");
  1854.     }
  1855.  
  1856.   if ((fcflag = fcntl (es1800_desc->fd, F_GETFL, 0)) == -1)
  1857.     {
  1858.       perror_with_name ("fcntl serial");
  1859.     }
  1860.  
  1861.   es1800_fc_save = fcflag;
  1862.   fcflag = fcflag | FNDELAY;
  1863.  
  1864.   if (fcntl (es1800_desc->fd, F_SETFL, fcflag) == -1)
  1865.     {
  1866.       perror_with_name ("fcntl serial");
  1867.     }
  1868.  
  1869.   while (1)
  1870.     { 
  1871.       cc = read (console, inputbuf, inputcnt);
  1872.       if (cc != -1)
  1873.     {
  1874.       if ((*inputbuf & 0x7f) == 0x05)
  1875.         {
  1876.           break;
  1877.         }
  1878.       for (i = 0; i < cc; )
  1879.         {
  1880.           es1800_buf[es1800_cnt++] = inputbuf[i++];
  1881.         }
  1882.       if ((cc = SERIAL_WRITE (es1800_desc, es1800_buf, es1800_cnt)) == -1)
  1883.         {
  1884.           perror_with_name ("FEL! write:");
  1885.         }
  1886.       es1800_cnt -= cc;
  1887.       if (es1800_cnt && cc) 
  1888.         {
  1889.           for (i = 0; i < es1800_cnt; i++)
  1890.         {
  1891.           es1800_buf[i] = es1800_buf[cc+i];
  1892.         }
  1893.         }
  1894.     }
  1895.       else if (errno != EWOULDBLOCK)
  1896.     {
  1897.       perror_with_name ("FEL! read:");
  1898.     }
  1899.       
  1900.       cc = read (es1800_desc->fd,inputbuf,inputcnt);
  1901.       if (cc != -1)
  1902.     {
  1903.       for (i = 0; i < cc; )
  1904.         {
  1905.           consolebuf[consolecnt++] = inputbuf[i++];
  1906.         }
  1907.       if ((cc = write (console,consolebuf,consolecnt)) == -1)
  1908.         {
  1909.           perror_with_name ("FEL! write:");
  1910.         }
  1911.       consolecnt -= cc;
  1912.       if (consolecnt && cc) 
  1913.         {
  1914.           for (i = 0; i < consolecnt; i++)
  1915.         {
  1916.           consolebuf[i] = consolebuf[cc+i];
  1917.         }
  1918.         }
  1919.     }
  1920.       else if (errno != EWOULDBLOCK)
  1921.     {
  1922.       perror_with_name ("FEL! read:");
  1923.     }
  1924.     }
  1925.  
  1926.   console_fc_save = console_fc_save & !FNDELAY;
  1927.   if (fcntl (console, F_SETFL, console_fc_save) == -1)
  1928.     {
  1929.       perror_with_name ("FEL! fcntl");
  1930.     }
  1931.  
  1932.   if (ioctl (console, TIOCSETP, &console_mode_save))
  1933.     {
  1934.       perror_with_name ("FEL! ioctl");
  1935.     }
  1936.  
  1937.   close (console);
  1938.  
  1939.   if (fcntl (es1800_desc->fd, F_SETFL, es1800_fc_save) == -1)
  1940.     {
  1941.       perror_with_name ("FEL! fcntl");
  1942.     }
  1943.  
  1944.   printf ("\n");
  1945.  
  1946. }
  1947. #endif /* PROVIDE_TRANSPARENT */
  1948.  
  1949. static void
  1950. es1800_init_break (args, from_tty)
  1951.      char *args;
  1952.      int from_tty;
  1953. {
  1954.   CORE_ADDR memaddress = 0;
  1955.   char buf[PBUFSIZ];
  1956.   char base_addr[4];
  1957.   char *space_index;
  1958.   char *p;
  1959.   int k;
  1960.  
  1961.   if (args == NULL)
  1962.     {
  1963.       error_no_arg ("a trap vector");
  1964.     }
  1965.  
  1966.   if (!(space_index = strchr (args, ' ')))
  1967.     {
  1968.       error ("Two arguments needed (trap vector and address of break routine).\n");
  1969.     }
  1970.  
  1971.   *space_index = '\0';
  1972.  
  1973.   es1800_break_vec = strtol (args, (char **) NULL, 0);
  1974.   es1800_break_address = parse_and_eval_address (space_index + 1);
  1975.  
  1976.   es1800_create_break_insn (es1800_break_insn, es1800_break_vec);
  1977.  
  1978.   if (m68020)
  1979.     {
  1980.       send_with_reply ("VBR ", buf, sizeof (buf));
  1981.       p = buf;
  1982.       for (k = 0; k < 4; k++)
  1983.     {
  1984.       if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
  1985.         {
  1986.           error ("Emulator reply is too short: %s", buf);
  1987.         }
  1988.       base_addr[k] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
  1989.     }
  1990.       /* base addr of exception vector table */
  1991.       memaddress =  *((CORE_ADDR *) base_addr);
  1992.     }
  1993.  
  1994.   memaddress += (es1800_break_vec + 32) * 4;     /* address of trap vector */
  1995.  
  1996.   sprintf (buf, "@.L%lx=$%lx", memaddress, es1800_break_address);
  1997.   send_command (buf);   /* set the address of the break routine in the */
  1998.                  /* trap vector */
  1999.   
  2000.   sprintf (buf, "@.L%lx=$4E714E71", es1800_break_address);      /* NOP; NOP */
  2001.   send_command (buf);
  2002.   sprintf (buf, "@.L%lx=$4E714E73", es1800_break_address + 4);  /* NOP; RTE */
  2003.   send_command (buf);
  2004.   
  2005.   sprintf (buf, "AC2=$%lx", es1800_break_address + 4);
  2006.   /* breakpoint at es1800-break_address */
  2007.   send_command (buf);
  2008.   send_command ("WHEN AC2 THEN BRK");          /* ie in exception routine */
  2009.  
  2010.   if (from_tty)
  2011.     {
  2012.       printf ("Breakpoint (trap $%x) routine at address: %lx\n",
  2013.           es1800_break_vec, es1800_break_address);
  2014.     }
  2015. }      
  2016.  
  2017. static void
  2018. es1800_child_open (arg, from_tty)
  2019.      char *arg;
  2020.      int from_tty;
  2021. {
  2022.   error ("Use the \"run\" command to start a child process.");
  2023. }
  2024.  
  2025. static void
  2026. es1800_child_detach (args, from_tty)
  2027.      char *args;
  2028.      int from_tty;
  2029. {
  2030.   if (args)
  2031.     {
  2032.       error ("Argument given to \"detach\" when remotely debugging.");
  2033.     }
  2034.   
  2035.   pop_target ();
  2036.   if (from_tty)
  2037.     {
  2038.       printf ("Ending debugging the process %d.\n", inferior_pid);
  2039.     }
  2040. }
  2041.  
  2042.  
  2043. /* Define the target subroutine names  */
  2044.  
  2045. struct target_ops es1800_ops =
  2046. {
  2047.   "es1800",            /* to_shortname */
  2048.                 /* to_longname */
  2049.   "Remote serial target in ES1800-emulator protocol",
  2050.                   /* to_doc */
  2051.   "Remote debugging on the es1800 emulator via a serial line.\n\
  2052. Specify the serial device it is connected to (e.g. /dev/ttya).",
  2053.   es1800_open,            /* to_open */
  2054.   es1800_close,            /* to_close */
  2055.   es1800_attach,        /* to_attach */
  2056.   es1800_detach,        /* to_detach */
  2057.   es1800_resume,        /* to_resume */
  2058.   NULL,                /* to_wait */
  2059.   NULL,                /* to_fetch_registers */
  2060.   NULL,                /* to_store_registers */
  2061.   es1800_prepare_to_store,    /* to_prepare_to_store */
  2062.   es1800_xfer_inferior_memory,    /* to_xfer_memory */
  2063.   es1800_files_info,        /* to_files_info */
  2064.   es1800_insert_breakpoint,    /* to_insert_breakpoint */
  2065.   es1800_remove_breakpoint,    /* to_remove_breakpoint */
  2066.   NULL,                /* to_terminal_init */
  2067.   NULL,                /* to_terminal_inferior */
  2068.   NULL,                /* to_terminal_ours_for_output */
  2069.   NULL,                /* to_terminal_ours */
  2070.   NULL,                /* to_terminal_info */
  2071.   NULL,                /* to_kill */
  2072.   es1800_load,            /* to_load */
  2073.   NULL,                /* to_lookup_symbol */
  2074.   es1800_create_inferior,    /* to_create_inferior */
  2075.   NULL,                /* to_mourn_inferior */
  2076.   0,                /* to_can_run */
  2077.   0,                /* to_notice_signals */
  2078.   0,                /* to_thread_alive */
  2079.   0,                /* to_stop */
  2080.   core_stratum,            /* to_stratum */
  2081.   0,                /* to_next */
  2082.   0,                /* to_has_all_memory */
  2083.   1,                /* to_has_memory */
  2084.   0,                /* to_has_stack */
  2085.   0,                /* to_has_registers */
  2086.   0,                /* to_has_execution */
  2087.   NULL,                /* to_sections */
  2088.   NULL,                /* to_sections_end */
  2089.   OPS_MAGIC            /* to_magic (always last) */
  2090. };
  2091.  
  2092. /* Define the target subroutine names  */
  2093.  
  2094. struct target_ops es1800_child_ops =
  2095. {
  2096.   "es1800_process",        /* to_shortname */
  2097.                   /* to_longname */
  2098.   "Remote serial target in ES1800-emulator protocol",
  2099.                 /* to_doc */
  2100.   "Remote debugging on the es1800 emulator via a serial line.\n\
  2101. Specify the serial device it is connected to (e.g. /dev/ttya).",
  2102.   es1800_child_open,        /* to_open */
  2103.   NULL,                /* to_close */
  2104.   es1800_attach,        /* to_attach */
  2105.   es1800_child_detach,        /* to_detach */
  2106.   es1800_resume,        /* to_resume */
  2107.   es1800_wait,            /* to_wait */
  2108.   es1800_fetch_register,    /* to_fetch_registers */
  2109.   es1800_store_register,    /* to_store_registers */
  2110.   es1800_prepare_to_store,    /* to_prepare_to_store */
  2111.   es1800_xfer_inferior_memory,    /* to_xfer_memory */
  2112.   es1800_files_info,        /* to_files_info */
  2113.   es1800_insert_breakpoint,    /* to_insert_breakpoint */
  2114.   es1800_remove_breakpoint,    /* to_remove_breakpoint */
  2115.   NULL,                /* to_terminal_init */
  2116.   NULL,                /* to_terminal_inferior */
  2117.   NULL,                /* to_terminal_ours_for_output */
  2118.   NULL,                /* to_terminal_ours */
  2119.   NULL,                /* to_terminal_info */
  2120.   es1800_kill,            /* to_kill */
  2121.   es1800_load,            /* to_load */
  2122.   NULL,                /* to_lookup_symbol */
  2123.   es1800_create_inferior,    /* to_create_inferior */
  2124.   es1800_mourn_inferior,    /* to_mourn_inferior */
  2125.   0,                /* to_can_run */
  2126.   0,                /* notice_signals */
  2127.   0,                /* to_thread_alive */
  2128.   0,                /* to_stop */
  2129.   process_stratum,        /* to_stratum */
  2130.   0,                /* to_next */
  2131.   1,                /* to_has_all_memory */
  2132.   1,                /* to_has_memory */
  2133.   1,                /* to_has_stack */
  2134.   1,                /* to_has_registers */
  2135.   1,                /* to_has_execution */
  2136.   NULL,                /* to_sections */
  2137.   NULL,                /* to_sections_end */
  2138.   OPS_MAGIC            /* to_magic (always last) */
  2139. };
  2140.  
  2141. void
  2142. _initialize_es1800 ()
  2143. {
  2144.   add_target (&es1800_ops);
  2145.   add_target (&es1800_child_ops);
  2146. #ifdef PROVIDE_TRANSPARENT
  2147.   add_com ("transparent", class_support, es1800_transparent,
  2148.        "Start transparent communication with the ES 1800 emulator.");
  2149. #endif /* PROVIDE_TRANSPARENT */
  2150.   add_com ("init_break", class_support, es1800_init_break,
  2151.        "Download break routine and initialize break facility on ES 1800");
  2152. }
  2153.