gdb/v850ice.c

   1 /* ICE interface for the NEC V850 for GDB, the GNU debugger.
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "frame.h"
  25 #include "symtab.h"
  26 #include "inferior.h"
  27 #include "breakpoint.h"
  28 #include "symfile.h"
  29 #include "target.h"
  30 #include "objfiles.h"
  31 #include "gdbcore.h"
  32 #include "value.h"
  33 #include "command.h"
  34 #include "regcache.h"
  35
  36 #include <tcl.h>
  37 #include <windows.h>
  38 #include <winuser.h>            /* for WM_USER */
  39
  40 extern unsigned long int strtoul (const char *nptr, char **endptr,
  41                                   int base);
  42
  43 /* Local data definitions */
  44 struct MessageIO
  45   {
  46     int size;                   /* length of input or output in bytes         */
  47     char *buf;                  /* buffer having the input/output information */
  48   };
  49
  50 /* Prototypes for functions located in other files */
  51 extern void break_command (char *, int);
  52
  53 /* Prototypes for local functions */
  54 static int init_hidden_window (void);
  55
  56 static LRESULT CALLBACK v850ice_wndproc (HWND, UINT, WPARAM, LPARAM);
  57
  58 static void v850ice_files_info (struct target_ops *ignore);
  59
  60 static int v850ice_xfer_memory (CORE_ADDR memaddr, char *myaddr,
  61                                 int len, int should_write,
  62                                 struct target_ops *target);
  63
  64 static void v850ice_prepare_to_store (void);
  65
  66 static void v850ice_fetch_registers (int regno);
  67
  68 static void v850ice_resume (ptid_t ptid, int step,
  69                             enum target_signal siggnal);
  70
  71 static void v850ice_open (char *name, int from_tty);
  72
  73 static void v850ice_close (int quitting);
  74
  75 static void v850ice_stop (void);
  76
  77 static void v850ice_store_registers (int regno);
  78
  79 static void v850ice_mourn (void);
  80
  81 static ptid_t v850ice_wait (ptid_t ptid,
  82                                   struct target_waitstatus *status);
  83
  84 static void v850ice_kill (void);
  85
  86 static void v850ice_detach (char *args, int from_tty);
  87
  88 static int v850ice_insert_breakpoint (CORE_ADDR, char *);
  89
  90 static int v850ice_remove_breakpoint (CORE_ADDR, char *);
  91
  92 static void v850ice_command (char *, int);
  93
  94 static int ice_disassemble (unsigned long, int, char *);
  95
  96 static int ice_lookup_addr (unsigned long *, char *, char *);
  97
  98 static int ice_lookup_symbol (unsigned long, char *);
  99
 100 static void ice_SimulateDisassemble (char *, int);
 101
 102 static void ice_SimulateAddrLookup (char *, int);
 103
 104 static void ice_Simulate_SymLookup (char *, int);
 105
 106 static void ice_fputs (const char *, struct ui_file *);
 107
 108 static int ice_file (char *);
 109
 110 static int ice_cont (char *);
 111
 112 static int ice_stepi (char *);
 113
 114 static int ice_nexti (char *);
 115
 116 static void togdb_force_update (void);
 117
 118 static void view_source (CORE_ADDR);
 119
 120 static void do_gdb (char *, char *, void (*func) (char *, int), int);
 121
 122
 123 /* Globals */
 124 static HWND hidden_hwnd;        /* HWND for messages */
 125
 126 long (__stdcall * ExeAppReq) (char *, long, char *, struct MessageIO *);
 127
 128 long (__stdcall * RegisterClient) (HWND);
 129
 130 long (__stdcall * UnregisterClient) (void);
 131
 132 extern Tcl_Interp *gdbtk_interp;
 133
 134 /* Globals local to this file only */
 135 static int ice_open = 0;        /* Is ICE open? */
 136
 137 static char *v850_CB_Result;    /* special char array for saving 'callback' results */
 138
 139 static int SimulateCallback;    /* simulate a callback event */
 140
 141 #define MAX_BLOCK_SIZE    64*1024       /* Cannot transfer memory in blocks bigger
 142                                            than this */
 143 /* MDI/ICE Message IDs */
 144 #define GSINGLESTEP     0x200   /* single-step target          */
 145 #define GRESUME         0x201   /* resume target               */
 146 #define GREADREG        0x202   /* read a register             */
 147 #define GWRITEREG       0x203   /* write a register            */
 148 #define GWRITEBLOCK     0x204   /* write a block of memory     */
 149 #define GREADBLOCK      0x205   /* read a block of memory      */
 150 #define GSETBREAK       0x206   /* set a breakpoint            */
 151 #define GREMOVEBREAK    0x207   /* remove a breakpoint         */
 152 #define GHALT           0x208   /* ??? */
 153 #define GCHECKSTATUS    0x209   /* check status of ICE         */
 154 #define GMDIREPLY       0x210   /* Reply for previous query - NOT USED */
 155 #define GDOWNLOAD       0x211   /* something for MDI           */
 156 #define GCOMMAND        0x212   /* execute command in ice      */
 157 #define GLOADFILENAME   0x213   /* retrieve load filename      */
 158 #define GWRITEMEM       0x214   /* write word, half-word, or byte */
 159
 160 /* GCHECKSTATUS return codes: */
 161 #define ICE_Idle        0x00
 162 #define ICE_Breakpoint  0x01    /* hit a breakpoint */
 163 #define ICE_Stepped     0x02    /* have stepped     */
 164 #define ICE_Exception   0x03    /* have exception   */
 165 #define ICE_Halted      0x04    /* hit a user halt  */
 166 #define ICE_Exited      0x05    /* called exit      */
 167 #define ICE_Terminated  0x06    /* user terminated  */
 168 #define ICE_Running     0x07
 169 #define ICE_Unknown     0x99
 170
 171 /* Windows messages */
 172 #define WM_STATE_CHANGE WM_USER+101
 173 #define WM_SYM_TO_ADDR  WM_USER+102
 174 #define WM_ADDR_TO_SYM  WM_USER+103
 175 #define WM_DISASSEMBLY  WM_USER+104
 176 #define WM_SOURCE       WM_USER+105
 177
 178 /* STATE_CHANGE codes */
 179 #define STATE_CHANGE_REGS   1   /* Register(s) changed */
 180 #define STATE_CHANGE_LOAD   2   /* HW reset            */
 181 #define STATE_CHANGE_RESET  3   /* Load new file       */
 182 #define STATE_CHANGE_CONT   4   /* Run target          */
 183 #define STATE_CHANGE_STOP   5   /* Stop target         */
 184 #define STATE_CHANGE_STEPI  6   /* Stepi target        */
 185 #define STATE_CHANGE_NEXTI  7   /* Nexti target        */
 186
 187 static struct target_ops v850ice_ops;   /* Forward decl */
 188
 189 /* This function creates a hidden window */
 190 static int
 191 init_hidden_window (void)
 192 {
 193   WNDCLASS class;
 194
 195   if (hidden_hwnd != NULL)
 196     return 1;
 197
 198   class.style = 0;
 199   class.cbClsExtra = 0;
 200   class.cbWndExtra = 0;
 201   class.hInstance = GetModuleHandle (0);
 202   class.hbrBackground = NULL;
 203   class.lpszMenuName = NULL;
 204   class.lpszClassName = "gdb_v850ice";
 205   class.lpfnWndProc = v850ice_wndproc;
 206   class.hIcon = NULL;
 207   class.hCursor = NULL;
 208
 209   if (!RegisterClass (&class))
 210     return 0;
 211
 212   hidden_hwnd = CreateWindow ("gdb_v850ice", "gdb_v850ice", WS_TILED,
 213                               0, 0, 0, 0, NULL, NULL, class.hInstance,
 214                               NULL);
 215   if (hidden_hwnd == NULL)
 216     {
 217       char buf[200];
 218       DWORD err;
 219
 220       err = GetLastError ();
 221       FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
 222                      0, buf, 200, NULL);
 223       printf_unfiltered ("Could not create window: %s", buf);
 224       return 0;
 225     }
 226
 227   return 1;
 228 }
 229
 230 /*
 231    This function is installed as the message handler for the hidden window
 232    which QBox will use to communicate with gdb. It recognize and acts
 233    on the following messages:
 234
 235    WM_SYM_TO_ADDR  \
 236    WM_ADDR_TO_SYM   | Not implemented at NEC's request
 237    WM_DISASSEMBLY  /
 238    WM_STATE_CHANGE - tells us that a state change has occured in the ICE
 239  */
 240 static LRESULT CALLBACK
 241 v850ice_wndproc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 242 {
 243   LRESULT result = FALSE;
 244
 245   switch (message)
 246     {
 247     case WM_SYM_TO_ADDR:
 248       MessageBox (0, "Symbol resolution\nNot implemented", "GDB", MB_OK);
 249       break;
 250     case WM_ADDR_TO_SYM:
 251       MessageBox (0, "Address resolution\nNot implemented", "GDB", MB_OK);
 252       break;
 253     case WM_SOURCE:
 254       view_source ((CORE_ADDR) lParam);
 255       break;
 256     case WM_STATE_CHANGE:
 257       switch (wParam)
 258         {
 259         case STATE_CHANGE_LOAD:
 260           {
 261             struct MessageIO iob;
 262             char buf[128];
 263
 264             iob.buf = buf;
 265             iob.size = 128;
 266
 267             /* Load in a new file... Need filename */
 268             ExeAppReq ("GDB", GLOADFILENAME, NULL, &iob);
 269             if (!catch_errors ((catch_errors_ftype *) ice_file, iob.buf, "", RETURN_MASK_ALL))
 270               printf_unfiltered ("load errored\n");
 271           }
 272           break;
 273         case STATE_CHANGE_RESET:
 274           registers_changed ();
 275           flush_cached_frames ();
 276           togdb_force_update ();
 277           result = TRUE;
 278           break;
 279         case STATE_CHANGE_REGS:
 280           registers_changed ();
 281           togdb_force_update ();
 282           result = TRUE;
 283           break;
 284         case STATE_CHANGE_CONT:
 285           if (!catch_errors ((catch_errors_ftype *) ice_cont, NULL, "", RETURN_MASK_ALL))
 286             printf_unfiltered ("continue errored\n");
 287           result = TRUE;
 288           break;
 289         case STATE_CHANGE_STEPI:
 290           if (!catch_errors ((catch_errors_ftype *) ice_stepi, (int) lParam, "",
 291                              RETURN_MASK_ALL))
 292             printf_unfiltered ("stepi errored\n");
 293           result = TRUE;
 294           break;
 295         case STATE_CHANGE_NEXTI:
 296           if (!catch_errors ((catch_errors_ftype *) ice_nexti, (int) lParam, "",
 297                              RETURN_MASK_ALL))
 298             printf_unfiltered ("nexti errored\n");
 299           result = TRUE;
 300           break;
 301         }
 302     }
 303
 304   if (result == FALSE)
 305     return DefWindowProc (hwnd, message, wParam, lParam);
 306
 307   return FALSE;
 308 }
 309
 310 /* Code for opening a connection to the ICE.  */
 311
 312 static void
 313 v850ice_open (char *name, int from_tty)
 314 {
 315   HINSTANCE handle;
 316
 317   if (name)
 318     error ("Too many arguments.");
 319
 320   target_preopen (from_tty);
 321
 322   unpush_target (&v850ice_ops);
 323
 324   if (from_tty)
 325     puts_filtered ("V850ice debugging\n");
 326
 327   push_target (&v850ice_ops);   /* Switch to using v850ice target now */
 328
 329   target_terminal_init ();
 330
 331   /* Initialize everything necessary to facilitate communication
 332      between QBox, gdb, and the DLLs which control the ICE */
 333   if (ExeAppReq == NULL)
 334     {
 335       handle = LoadLibrary ("necmsg.dll");
 336       if (handle == NULL)
 337         error ("Cannot load necmsg.dll");
 338
 339       ExeAppReq = (long (*) (char *, long, char *, struct MessageIO *))
 340         GetProcAddress (handle, "ExeAppReq");
 341       RegisterClient = (long (*) (HWND))
 342         GetProcAddress (handle, "RegisterClient");
 343       UnregisterClient = (long (*) (void))
 344         GetProcAddress (handle, "UnregisterClient");
 345
 346       if (ExeAppReq == NULL || RegisterClient == NULL || UnregisterClient == NULL)
 347         error ("Could not find requisite functions in necmsg.dll.");
 348
 349       if (!init_hidden_window ())
 350         error ("could not initialize message handling");
 351     }
 352
 353   /* Tell the DLL we are here */
 354   RegisterClient (hidden_hwnd);
 355
 356   ice_open = 1;
 357
 358   /* Without this, some commands which require an active target (such as kill)
 359      won't work.  This variable serves (at least) double duty as both the pid
 360      of the target process (if it has such), and as a flag indicating that a
 361      target is active.  These functions should be split out into seperate
 362      variables, especially since GDB will someday have a notion of debugging
 363      several processes.  */
 364   inferior_ptid = pid_to_ptid (42000);
 365
 366   start_remote ();
 367   return;
 368 }
 369
 370 /* Clean up connection to a remote debugger.  */
 371
 372 static void
 373 v850ice_close (int quitting)
 374 {
 375   if (ice_open)
 376     {
 377       UnregisterClient ();
 378       ice_open = 0;
 379       inferior_ptid = null_ptid;
 380     }
 381 }
 382
 383 /* Stop the process on the ice. */
 384 static void
 385 v850ice_stop (void)
 386 {
 387   /* This is silly, but it works... */
 388   v850ice_command ("stop", 0);
 389 }
 390
 391 static void
 392 v850ice_detach (char *args, int from_tty)
 393 {
 394   if (args)
 395     error ("Argument given to \"detach\" when remotely debugging.");
 396
 397   pop_target ();
 398   if (from_tty)
 399     puts_filtered ("Ending v850ice debugging.\n");
 400 }
 401
 402 /* Tell the remote machine to resume.  */
 403
 404 static void
 405 v850ice_resume (ptid_t ptid, int step, enum target_signal siggnal)
 406 {
 407   long retval;
 408   char buf[256];
 409   struct MessageIO iob;
 410
 411   iob.size = 0;
 412   iob.buf = buf;
 413
 414   if (step)
 415     retval = ExeAppReq ("GDB", GSINGLESTEP, "step", &iob);
 416   else
 417     retval = ExeAppReq ("GDB", GRESUME, "run", &iob);
 418
 419   if (retval)
 420     error ("ExeAppReq (step = %d) returned %d", step, retval);
 421 }
 422
 423 /* Wait until the remote machine stops, then return,
 424    storing status in STATUS just as `wait' would.
 425    Returns "pid" (though it's not clear what, if anything, that
 426    means in the case of this target).  */
 427
 428 static ptid_t
 429 v850ice_wait (ptid_t ptid, struct target_waitstatus *status)
 430 {
 431   long v850_status;
 432   char buf[256];
 433   struct MessageIO iob;
 434   int done = 0;
 435   int count = 0;
 436
 437   iob.size = 0;
 438   iob.buf = buf;
 439
 440   do
 441     {
 442       if (count++ % 100000)
 443         {
 444           deprecated_ui_loop_hook (0);
 445           count = 0;
 446         }
 447
 448       v850_status = ExeAppReq ("GDB", GCHECKSTATUS, NULL, &iob);
 449
 450       switch (v850_status)
 451         {
 452         case ICE_Idle:
 453         case ICE_Breakpoint:
 454         case ICE_Stepped:
 455         case ICE_Halted:
 456           status->kind = TARGET_WAITKIND_STOPPED;
 457           status->value.sig = TARGET_SIGNAL_TRAP;
 458           done = 1;
 459           break;
 460         case ICE_Exception:
 461           status->kind = TARGET_WAITKIND_SIGNALLED;
 462           status->value.sig = TARGET_SIGNAL_SEGV;
 463           done = 1;
 464           break;
 465         case ICE_Exited:
 466           status->kind = TARGET_WAITKIND_EXITED;
 467           status->value.integer = 0;
 468           done = 1;
 469           break;
 470         case ICE_Terminated:
 471           status->kind = TARGET_WAITKIND_SIGNALLED;
 472           status->value.sig = TARGET_SIGNAL_KILL;
 473           done = 1;
 474           break;
 475         default:
 476           break;
 477         }
 478     }
 479   while (!done);
 480
 481   return inferior_ptid;
 482 }
 483
 484 static int
 485 convert_register (int regno, char *buf)
 486 {
 487   if (regno <= 31)
 488     sprintf (buf, "r%d", regno);
 489   else if (REGISTER_NAME (regno)[0] == 's'
 490            && REGISTER_NAME (regno)[1] == 'r')
 491     return 0;
 492   else
 493     sprintf (buf, "%s", REGISTER_NAME (regno));
 494
 495   return 1;
 496 }
 497
 498 /* Read the remote registers into the block REGS.  */
 499 /* Note that the ICE returns register contents as ascii hex strings.  We have
 500    to convert that to an unsigned long, and then call store_unsigned_integer to
 501    convert it to target byte-order if necessary.  */
 502
 503 static void
 504 v850ice_fetch_registers (int regno)
 505 {
 506   long retval;
 507   char cmd[100];
 508   char val[100];
 509   struct MessageIO iob;
 510   unsigned long regval;
 511   char *p;
 512
 513   if (regno == -1)
 514     {
 515       for (regno = 0; regno < NUM_REGS; regno++)
 516         v850ice_fetch_registers (regno);
 517       return;
 518     }
 519
 520   strcpy (cmd, "reg ");
 521   if (!convert_register (regno, &cmd[4]))
 522     return;
 523
 524   iob.size = sizeof val;
 525   iob.buf = val;
 526   retval = ExeAppReq ("GDB", GREADREG, cmd, &iob);
 527   if (retval)
 528     error ("1: ExeAppReq returned %d: cmd = %s", retval, cmd);
 529
 530   regval = strtoul (val, NULL, 16);
 531   if (regval == 0 && p == val)
 532     error ("v850ice_fetch_registers (%d):  bad value from ICE: %s.",
 533            regno, val);
 534
 535   store_unsigned_integer (val, register_size (current_gdbarch, regno), regval);
 536   regcache_raw_supply (current_regcache, regno, val);
 537 }
 538
 539 /* Store register REGNO, or all registers if REGNO == -1, from the contents
 540    of REGISTERS.  */
 541
 542 static void
 543 v850ice_store_registers (int regno)
 544 {
 545   long retval;
 546   char cmd[100];
 547   unsigned long regval;
 548   char buf[256];
 549   struct MessageIO iob;
 550   iob.size = 0;
 551   iob.buf = buf;
 552
 553   if (regno == -1)
 554     {
 555       for (regno = 0; regno < NUM_REGS; regno++)
 556         v850ice_store_registers (regno);
 557       return;
 558     }
 559
 560   regval = extract_unsigned_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)],
 561                                      register_size (current_gdbarch, regno));
 562   strcpy (cmd, "reg ");
 563   if (!convert_register (regno, &cmd[4]))
 564     return;
 565   sprintf (cmd + strlen (cmd), "=0x%x", regval);
 566
 567   retval = ExeAppReq ("GDB", GWRITEREG, cmd, &iob);
 568   if (retval)
 569     error ("2: ExeAppReq returned %d: cmd = %s", retval, cmd);
 570 }
 571
 572 /* Prepare to store registers.  Nothing to do here, since the ICE can write one
 573    register at a time.  */
 574
 575 static void
 576 v850ice_prepare_to_store (void)
 577 {
 578 }
 579
 580 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
 581    to or from debugger address MYADDR.  Write to inferior if SHOULD_WRITE is
 582    nonzero.  TARGET is unused.  Returns length of data written or read;
 583    0 for error.
 584
 585    We can only read/write MAX_BLOCK_SIZE bytes at a time, though, or the DLL
 586    dies.  */
 587 static int
 588 v850ice_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 589                      int should_write, struct target_ops *target)
 590 {
 591   long retval;
 592   char cmd[100];
 593   struct MessageIO iob;
 594   int sent;
 595
 596   if (should_write)
 597     {
 598       if (len == 4 || len == 2 || len == 1)
 599         {
 600           long value = 0;
 601           char buf[256];
 602           char c;
 603
 604           iob.size = 0;
 605           iob.buf = buf;
 606
 607           sent = 0;
 608           switch (len)
 609             {
 610             case 4:
 611               c = 'w';
 612               value |= (long) ((myaddr[3] << 24) & 0xff000000);
 613               value |= (long) ((myaddr[2] << 16) & 0x00ff0000);
 614               value |= (long) ((myaddr[1] << 8) & 0x0000ff00);
 615               value |= (long) (myaddr[0] & 0x000000ff);
 616               break;
 617             case 2:
 618               c = 'h';
 619               value |= (long) ((myaddr[1] << 8) & 0xff00);
 620               value |= (long) (myaddr[0] & 0x00ff);
 621               break;
 622             case 1:
 623               c = 'b';
 624               value |= (long) (myaddr[0] & 0xff);
 625               break;
 626             }
 627
 628           sprintf (cmd, "memory %c c 0x%x=0x%x", c, (int) memaddr, value);
 629           retval = ExeAppReq ("GDB", GWRITEMEM, cmd, &iob);
 630           if (retval == 0)
 631             sent = len;
 632         }
 633       else
 634         {
 635           sent = 0;
 636           do
 637             {
 638               iob.size = len > MAX_BLOCK_SIZE ? MAX_BLOCK_SIZE : len;
 639               iob.buf = myaddr;
 640               sprintf (cmd, "memory b c 0x%x=0x00 l=%d", (int) memaddr, iob.size);
 641               retval = ExeAppReq ("GDB", GWRITEBLOCK, cmd, &iob);
 642               if (retval != 0)
 643                 break;
 644               len -= iob.size;
 645               memaddr += iob.size;
 646               myaddr += iob.size;
 647               sent += iob.size;
 648             }
 649           while (len > 0);
 650         }
 651     }
 652   else
 653     {
 654       unsigned char *tmp;
 655       unsigned char *t;
 656       int i;
 657
 658       tmp = alloca (len + 100);
 659       t = tmp;
 660       memset (tmp + len, 0xff, 100);
 661
 662       sent = 0;
 663       do
 664         {
 665           iob.size = len > MAX_BLOCK_SIZE ? MAX_BLOCK_SIZE : len;
 666           iob.buf = tmp;
 667           sprintf (cmd, "memory b 0x%x l=%d", (int) memaddr, iob.size);
 668           retval = ExeAppReq ("GDB", GREADBLOCK, cmd, &iob);
 669           if (retval != 0)
 670             break;
 671           len -= iob.size;
 672           memaddr += iob.size;
 673           sent += iob.size;
 674           tmp += iob.size;
 675         }
 676       while (len > 0);
 677
 678       if (retval == 0)
 679         {
 680           for (i = 0; i < 100; i++)
 681             {
 682               if (t[sent + i] != 0xff)
 683                 {
 684                   warning ("GREADBLOCK trashed bytes after transfer area.");
 685                   break;
 686                 }
 687             }
 688           memcpy (myaddr, t, sent);
 689         }
 690     }
 691
 692   if (retval != 0)
 693     error ("3: ExeAppReq returned %d: cmd = %s", retval, cmd);
 694
 695   return sent;
 696 }
 697
 698 static void
 699 v850ice_files_info (struct target_ops *ignore)
 700 {
 701   puts_filtered ("Debugging a target via the NEC V850 ICE.\n");
 702 }
 703
 704 static int
 705 v850ice_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
 706 {
 707   long retval;
 708   char cmd[100];
 709   char buf[256];
 710   struct MessageIO iob;
 711
 712   iob.size = 0;
 713   iob.buf = buf;
 714   sprintf (cmd, "%d, ", addr);
 715
 716   retval = ExeAppReq ("GDB", GSETBREAK, cmd, &iob);
 717   if (retval)
 718     error ("ExeAppReq (GSETBREAK) returned %d: cmd = %s", retval, cmd);
 719
 720   return 0;
 721 }
 722
 723 static int
 724 v850ice_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 725 {
 726   long retval;
 727   char cmd[100];
 728   char buf[256];
 729   struct MessageIO iob;
 730
 731   iob.size = 0;
 732   iob.buf = buf;
 733
 734   sprintf (cmd, "%d, ", addr);
 735
 736   retval = ExeAppReq ("GDB", GREMOVEBREAK, cmd, &iob);
 737   if (retval)
 738     error ("ExeAppReq (GREMOVEBREAK) returned %d: cmd = %s", retval, cmd);
 739
 740   return 0;
 741 }
 742
 743 static void
 744 v850ice_kill (void)
 745 {
 746   target_mourn_inferior ();
 747   inferior_ptid = null_ptid;
 748 }
 749
 750 static void
 751 v850ice_mourn (void)
 752 {
 753 }
 754
 755 static void
 756 v850ice_load (char *filename, int from_tty)
 757 {
 758   struct MessageIO iob;
 759   char buf[256];
 760
 761   iob.size = 0;
 762   iob.buf = buf;
 763   generic_load (filename, from_tty);
 764   ExeAppReq ("GDB", GDOWNLOAD, filename, &iob);
 765 }
 766
 767 static int
 768 ice_file (char *arg)
 769 {
 770   char *s;
 771
 772   target_detach (NULL, 0);
 773   pop_target ();
 774
 775   printf_unfiltered ("\n");
 776
 777   s = arg;
 778   while (*s != '\0')
 779     {
 780       if (*s == '\\')
 781         *s = '/';
 782       s++;
 783     }
 784
 785   /* Safegaurd against confusing the breakpoint routines... */
 786   delete_command (NULL, 0);
 787
 788   /* Must supress from_tty, otherwise we could start asking if the
 789      user really wants to load a new symbol table, etc... */
 790   printf_unfiltered ("Reading symbols from %s...", arg);
 791   exec_open (arg, 0);
 792   symbol_file_add_main (arg, 0);
 793   printf_unfiltered ("done\n");
 794
 795   /* exec_open will kill our target, so reinstall the ICE as
 796      the target. */
 797   v850ice_open (NULL, 0);
 798
 799   togdb_force_update ();
 800   return 1;
 801 }
 802
 803 static int
 804 ice_cont (char *c)
 805 {
 806   printf_filtered ("continue (ice)\n");
 807   ReplyMessage ((LRESULT) 1);
 808
 809   if (gdbtk_interp == NULL)
 810     {
 811       continue_command (NULL, 1);
 812     }
 813   else
 814     Tcl_Eval (gdbtk_interp, "gdb_immediate continue");
 815
 816   return 1;
 817 }
 818
 819 static void
 820 do_gdb (char *cmd, char *str, void (*func) (char *, int), int count)
 821 {
 822   ReplyMessage ((LRESULT) 1);
 823
 824   while (count--)
 825     {
 826       printf_unfiltered (str);
 827
 828       if (gdbtk_interp == NULL)
 829         {
 830           func (NULL, 0);
 831         }
 832       else
 833         Tcl_Eval (gdbtk_interp, cmd);
 834     }
 835 }
 836
 837
 838 static int
 839 ice_stepi (char *c)
 840 {
 841   int count = (int) c;
 842
 843   do_gdb ("gdb_immediate stepi", "stepi (ice)\n", stepi_command, count);
 844   return 1;
 845 }
 846
 847 static int
 848 ice_nexti (char *c)
 849 {
 850   int count = (int) c;
 851
 852   do_gdb ("gdb_immediate nexti", "nexti (ice)\n", nexti_command, count);
 853   return 1;
 854 }
 855
 856 static void
 857 v850ice_command (char *arg, int from_tty)
 858 {
 859   struct MessageIO iob;
 860   char buf[256];
 861
 862   iob.buf = buf;
 863   iob.size = 0;
 864   ExeAppReq ("GDB", GCOMMAND, arg, &iob);
 865 }
 866
 867 static void
 868 togdb_force_update (void)
 869 {
 870   if (gdbtk_interp != NULL)
 871     Tcl_Eval (gdbtk_interp, "gdbtk_update");
 872 }
 873
 874 static void
 875 view_source (CORE_ADDR addr)
 876 {
 877   char c[256];
 878
 879   if (gdbtk_interp != NULL)
 880     {
 881       sprintf (c, "catch {set src [lindex [ManagedWin::find SrcWin] 0]\n$src location BROWSE [gdb_loc *0x%x]}", addr);
 882       Tcl_Eval (gdbtk_interp, c);
 883     }
 884 }
 885
 886 /* Define the target subroutine names */
 887
 888 static void
 889 init_850ice_ops (void)
 890 {
 891   v850ice_ops.to_shortname = "ice";
 892   v850ice_ops.to_longname = "NEC V850 ICE interface";
 893   v850ice_ops.to_doc = "Debug a system controlled by a NEC 850 ICE.";
 894   v850ice_ops.to_open = v850ice_open;
 895   v850ice_ops.to_close = v850ice_close;
 896   v850ice_ops.to_detach = v850ice_detach;
 897   v850ice_ops.to_resume = v850ice_resume;
 898   v850ice_ops.to_wait = v850ice_wait;
 899   v850ice_ops.to_fetch_registers = v850ice_fetch_registers;
 900   v850ice_ops.to_store_registers = v850ice_store_registers;
 901   v850ice_ops.to_prepare_to_store = v850ice_prepare_to_store;
 902   v850ice_ops.to_xfer_memory = v850ice_xfer_memory;
 903   v850ice_ops.to_files_info = v850ice_files_info;
 904   v850ice_ops.to_insert_breakpoint = v850ice_insert_breakpoint;
 905   v850ice_ops.to_remove_breakpoint = v850ice_remove_breakpoint;
 906   v850ice_ops.to_kill = v850ice_kill;
 907   v850ice_ops.to_load = v850ice_load;
 908   v850ice_ops.to_mourn_inferior = v850ice_mourn;
 909   v850ice_ops.to_stop = v850ice_stop;
 910   v850ice_ops.to_stratum = process_stratum;
 911   v850ice_ops.to_has_all_memory = 1;
 912   v850ice_ops.to_has_memory = 1;
 913   v850ice_ops.to_has_stack = 1;
 914   v850ice_ops.to_has_registers = 1;
 915   v850ice_ops.to_has_execution = 1;
 916   v850ice_ops.to_magic = OPS_MAGIC;
 917 }
 918
 919 void
 920 _initialize_v850ice (void)
 921 {
 922   init_850ice_ops ();
 923   add_target (&v850ice_ops);
 924
 925   add_com ("ice", class_obscure, v850ice_command,
 926            "Send command to ICE");
 927 }