gdb/m32r-rom.c

   1 /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
   2    the GNU debugger.
   3    Copyright 1996, 2001 Free Software Foundation, Inc.
   4
   5    Adapted by Michael Snyder of Cygnus Support.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 /* This module defines communication with the Mitsubishi m32r monitor */
  25
  26 #include "defs.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "monitor.h"
  30 #include "serial.h"
  31 #include "symtab.h"
  32 #include "command.h"
  33 #include "gdbcmd.h"
  34 #include "symfile.h"            /* for generic load */
  35 #include <time.h>               /* for time_t */
  36 #include "gdb_string.h"
  37 #include "objfiles.h"           /* for ALL_OBJFILES etc. */
  38 #include "inferior.h"           /* for write_pc() */
  39 #include <ctype.h>
  40 #include "regcache.h"
  41
  42 extern void report_transfer_performance (unsigned long, time_t, time_t);
  43
  44 #ifndef _MSC_VER
  45 /*
  46  * All this stuff just to get my host computer's IP address!
  47  */
  48 #include <sys/types.h>
  49 #include <netdb.h>              /* for hostent */
  50 #include <netinet/in.h>         /* for struct in_addr */
  51 #if 1
  52 #include <arpa/inet.h>          /* for inet_ntoa */
  53 #endif
  54 #endif
  55
  56 static char *board_addr;        /* user-settable IP address for M32R-EVA */
  57 static char *server_addr;       /* user-settable IP address for gdb host */
  58 static char *download_path;     /* user-settable path for SREC files     */
  59
  60
  61 /*
  62  * Function: m32r_load_1 (helper function)
  63  */
  64
  65 static void
  66 m32r_load_section (bfd *abfd, asection *s, void *obj)
  67 {
  68   unsigned int *data_count = obj;
  69   if (s->flags & SEC_LOAD)
  70     {
  71       bfd_size_type section_size = bfd_section_size (abfd, s);
  72       bfd_vma section_base = bfd_section_lma (abfd, s);
  73       unsigned int buffer, i;
  74
  75       *data_count += section_size;
  76
  77       printf_filtered ("Loading section %s, size 0x%lx lma ",
  78                        bfd_section_name (abfd, s), section_size);
  79       print_address_numeric (section_base, 1, gdb_stdout);
  80       printf_filtered ("\n");
  81       gdb_flush (gdb_stdout);
  82       monitor_printf ("%s mw\r", paddr_nz (section_base));
  83       for (i = 0; i < section_size; i += 4)
  84         {
  85           QUIT;
  86           monitor_expect (" -> ", NULL, 0);
  87           bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
  88           monitor_printf ("%x\n", buffer);
  89         }
  90       monitor_expect (" -> ", NULL, 0);
  91       monitor_printf ("q\n");
  92       monitor_expect_prompt (NULL, 0);
  93     }
  94 }
  95
  96 static int
  97 m32r_load_1 (void *dummy)
  98 {
  99   int data_count = 0;
 100
 101   bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count);
 102   return data_count;
 103 }
 104
 105 /*
 106  * Function: m32r_load (an alternate way to load)
 107  */
 108
 109 static void
 110 m32r_load (char *filename, int from_tty)
 111 {
 112   extern int inferior_pid;
 113   bfd *abfd;
 114   asection *s;
 115   unsigned int i, data_count = 0;
 116   time_t start_time, end_time;  /* for timing of download */
 117
 118   if (filename == NULL || filename[0] == 0)
 119     filename = get_exec_file (1);
 120
 121   abfd = bfd_openr (filename, 0);
 122   if (!abfd)
 123     error ("Unable to open file %s\n", filename);
 124   if (bfd_check_format (abfd, bfd_object) == 0)
 125     error ("File is not an object file\n");
 126   start_time = time (NULL);
 127 #if 0
 128   for (s = abfd->sections; s; s = s->next)
 129     if (s->flags & SEC_LOAD)
 130       {
 131         bfd_size_type section_size = bfd_section_size (abfd, s);
 132         bfd_vma section_base = bfd_section_vma (abfd, s);
 133         unsigned int buffer;
 134
 135         data_count += section_size;
 136
 137         printf_filtered ("Loading section %s, size 0x%lx vma ",
 138                          bfd_section_name (abfd, s), section_size);
 139         print_address_numeric (section_base, 1, gdb_stdout);
 140         printf_filtered ("\n");
 141         gdb_flush (gdb_stdout);
 142         monitor_printf ("%x mw\r", section_base);
 143         for (i = 0; i < section_size; i += 4)
 144           {
 145             monitor_expect (" -> ", NULL, 0);
 146             bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
 147             monitor_printf ("%x\n", buffer);
 148           }
 149         monitor_expect (" -> ", NULL, 0);
 150         monitor_printf ("q\n");
 151         monitor_expect_prompt (NULL, 0);
 152       }
 153 #else
 154   if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL)))
 155     {
 156       monitor_printf ("q\n");
 157       return;
 158     }
 159 #endif
 160   end_time = time (NULL);
 161   printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd));
 162   report_transfer_performance (data_count, start_time, end_time);
 163
 164   /* Finally, make the PC point at the start address */
 165   if (exec_bfd)
 166     write_pc (bfd_get_start_address (exec_bfd));
 167
 168   inferior_pid = 0;             /* No process now */
 169
 170   /* This is necessary because many things were based on the PC at the
 171      time that we attached to the monitor, which is no longer valid
 172      now that we have loaded new code (and just changed the PC).
 173      Another way to do this might be to call normal_stop, except that
 174      the stack may not be valid, and things would get horribly
 175      confused... */
 176
 177   clear_symtab_users ();
 178 }
 179
 180 static void
 181 m32r_load_gen (char *filename, int from_tty)
 182 {
 183   generic_load (filename, from_tty);
 184 }
 185
 186 static void m32r_open (char *args, int from_tty);
 187 static void mon2000_open (char *args, int from_tty);
 188
 189 /* This array of registers needs to match the indexes used by GDB. The
 190    whole reason this exists is because the various ROM monitors use
 191    different names than GDB does, and don't support all the registers
 192    either. So, typing "info reg sp" becomes an "A7". */
 193
 194 static char *m32r_regnames[] =
 195 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 196  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 197  "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
 198 };
 199
 200 static void
 201 m32r_supply_register (char *regname, int regnamelen, char *val, int vallen)
 202 {
 203   int regno;
 204   int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]);
 205
 206   for (regno = 0; regno < num_regs; regno++)
 207     if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0)
 208       break;
 209
 210   if (regno >= num_regs)
 211     return;                     /* no match */
 212
 213   if (regno == ACCL_REGNUM)
 214     {                           /* special handling for 64-bit acc reg */
 215       monitor_supply_register (ACCH_REGNUM, val);
 216       val = strchr (val, ':');  /* skip past ':' to get 2nd word */
 217       if (val != NULL)
 218         monitor_supply_register (ACCL_REGNUM, val + 1);
 219     }
 220   else
 221     {
 222       monitor_supply_register (regno, val);
 223       if (regno == PSW_REGNUM)
 224         {
 225           unsigned long psw = strtoul (val, NULL, 16);
 226           char *zero = "00000000", *one = "00000001";
 227
 228 #ifdef SM_REGNUM
 229           /* Stack mode bit */
 230           monitor_supply_register (SM_REGNUM, (psw & 0x80) ? one : zero);
 231 #endif
 232 #ifdef BSM_REGNUM
 233           /* Backup stack mode bit */
 234           monitor_supply_register (BSM_REGNUM, (psw & 0x8000) ? one : zero);
 235 #endif
 236 #ifdef IE_REGNUM
 237           /* Interrupt enable bit */
 238           monitor_supply_register (IE_REGNUM, (psw & 0x40) ? one : zero);
 239 #endif
 240 #ifdef BIE_REGNUM
 241           /* Backup interrupt enable bit */
 242           monitor_supply_register (BIE_REGNUM, (psw & 0x4000) ? one : zero);
 243 #endif
 244 #ifdef COND_REGNUM
 245           /* Condition bit (carry etc.) */
 246           monitor_supply_register (COND_REGNUM, (psw & 0x1) ? one : zero);
 247 #endif
 248 #ifdef CBR_REGNUM
 249           monitor_supply_register (CBR_REGNUM, (psw & 0x1) ? one : zero);
 250 #endif
 251 #ifdef BPC_REGNUM
 252           monitor_supply_register (BPC_REGNUM, zero);   /* KLUDGE:   (???????) */
 253 #endif
 254 #ifdef BCARRY_REGNUM
 255           monitor_supply_register (BCARRY_REGNUM, zero);        /* KLUDGE: (??????) */
 256 #endif
 257         }
 258
 259       if (regno == SPI_REGNUM || regno == SPU_REGNUM)
 260         {                       /* special handling for stack pointer (spu or spi) */
 261           unsigned long stackmode = read_register (PSW_REGNUM) & 0x80;
 262
 263           if (regno == SPI_REGNUM && !stackmode)        /* SP == SPI */
 264             monitor_supply_register (SP_REGNUM, val);
 265           else if (regno == SPU_REGNUM && stackmode)    /* SP == SPU */
 266             monitor_supply_register (SP_REGNUM, val);
 267         }
 268     }
 269 }
 270
 271 /* m32r RevC board monitor */
 272
 273 static struct target_ops m32r_ops;
 274
 275 static char *m32r_inits[] =
 276 {"\r", NULL};
 277
 278 static struct monitor_ops m32r_cmds;
 279
 280 static void
 281 init_m32r_cmds (void)
 282 {
 283   m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
 284   m32r_cmds.init = m32r_inits;  /* Init strings */
 285   m32r_cmds.cont = "go\r";      /* continue command */
 286   m32r_cmds.step = "step\r";    /* single step */
 287   m32r_cmds.stop = NULL;        /* interrupt command */
 288   m32r_cmds.set_break = "%x +bp\r";     /* set a breakpoint */
 289   m32r_cmds.clr_break = "%x -bp\r";     /* clear a breakpoint */
 290   m32r_cmds.clr_all_break = "bpoff\r";  /* clear all breakpoints */
 291   m32r_cmds.fill = "%x %x %x fill\r";   /* fill (start length val) */
 292   m32r_cmds.setmem.cmdb = "%x 1 %x fill\r";     /* setmem.cmdb (addr, value) */
 293   m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r";    /* setmem.cmdw (addr, value) */
 294   m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r";    /* setmem.cmdl (addr, value) */
 295   m32r_cmds.setmem.cmdll = NULL;        /* setmem.cmdll (addr, value) */
 296   m32r_cmds.setmem.resp_delim = NULL;   /* setmem.resp_delim */
 297   m32r_cmds.setmem.term = NULL; /* setmem.term */
 298   m32r_cmds.setmem.term_cmd = NULL;     /* setmem.term_cmd */
 299   m32r_cmds.getmem.cmdb = "%x %x dump\r";       /* getmem.cmdb (addr, len) */
 300   m32r_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */
 301   m32r_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */
 302   m32r_cmds.getmem.cmdll = NULL;        /* getmem.cmdll (addr, len) */
 303   m32r_cmds.getmem.resp_delim = ": ";   /* getmem.resp_delim */
 304   m32r_cmds.getmem.term = NULL; /* getmem.term */
 305   m32r_cmds.getmem.term_cmd = NULL;     /* getmem.term_cmd */
 306   m32r_cmds.setreg.cmd = "%x to %%%s\r";        /* setreg.cmd (name, value) */
 307   m32r_cmds.setreg.resp_delim = NULL;   /* setreg.resp_delim */
 308   m32r_cmds.setreg.term = NULL; /* setreg.term */
 309   m32r_cmds.setreg.term_cmd = NULL;     /* setreg.term_cmd */
 310   m32r_cmds.getreg.cmd = NULL;  /* getreg.cmd (name) */
 311   m32r_cmds.getreg.resp_delim = NULL;   /* getreg.resp_delim */
 312   m32r_cmds.getreg.term = NULL; /* getreg.term */
 313   m32r_cmds.getreg.term_cmd = NULL;     /* getreg.term_cmd */
 314   m32r_cmds.dump_registers = ".reg\r";  /* dump_registers */
 315   m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";   /* register_pattern */
 316   m32r_cmds.supply_register = m32r_supply_register;     /* supply_register */
 317   m32r_cmds.load_routine = NULL;        /* load_routine (defaults to SRECs) */
 318   m32r_cmds.load = NULL;        /* download command */
 319   m32r_cmds.loadresp = NULL;    /* load response */
 320   m32r_cmds.prompt = "ok ";     /* monitor command prompt */
 321   m32r_cmds.line_term = "\r";   /* end-of-line terminator */
 322   m32r_cmds.cmd_end = NULL;     /* optional command terminator */
 323   m32r_cmds.target = &m32r_ops; /* target operations */
 324   m32r_cmds.stopbits = SERIAL_1_STOPBITS;       /* number of stop bits */
 325   m32r_cmds.regnames = m32r_regnames;   /* registers names */
 326   m32r_cmds.magic = MONITOR_OPS_MAGIC;  /* magic */
 327 }                               /* init_m32r_cmds */
 328
 329 static void
 330 m32r_open (char *args, int from_tty)
 331 {
 332   monitor_open (args, &m32r_cmds, from_tty);
 333 }
 334
 335 /* Mon2000 monitor (MSA2000 board) */
 336
 337 static struct target_ops mon2000_ops;
 338 static struct monitor_ops mon2000_cmds;
 339
 340 static void
 341 init_mon2000_cmds (void)
 342 {
 343   mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
 344   mon2000_cmds.init = m32r_inits;       /* Init strings */
 345   mon2000_cmds.cont = "go\r";   /* continue command */
 346   mon2000_cmds.step = "step\r"; /* single step */
 347   mon2000_cmds.stop = NULL;     /* interrupt command */
 348   mon2000_cmds.set_break = "%x +bp\r";  /* set a breakpoint */
 349   mon2000_cmds.clr_break = "%x -bp\r";  /* clear a breakpoint */
 350   mon2000_cmds.clr_all_break = "bpoff\r";       /* clear all breakpoints */
 351   mon2000_cmds.fill = "%x %x %x fill\r";        /* fill (start length val) */
 352   mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r";  /* setmem.cmdb (addr, value) */
 353   mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r";         /* setmem.cmdw (addr, value) */
 354   mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r";         /* setmem.cmdl (addr, value) */
 355   mon2000_cmds.setmem.cmdll = NULL;     /* setmem.cmdll (addr, value) */
 356   mon2000_cmds.setmem.resp_delim = NULL;        /* setmem.resp_delim */
 357   mon2000_cmds.setmem.term = NULL;      /* setmem.term */
 358   mon2000_cmds.setmem.term_cmd = NULL;  /* setmem.term_cmd */
 359   mon2000_cmds.getmem.cmdb = "%x %x dump\r";    /* getmem.cmdb (addr, len) */
 360   mon2000_cmds.getmem.cmdw = NULL;      /* getmem.cmdw (addr, len) */
 361   mon2000_cmds.getmem.cmdl = NULL;      /* getmem.cmdl (addr, len) */
 362   mon2000_cmds.getmem.cmdll = NULL;     /* getmem.cmdll (addr, len) */
 363   mon2000_cmds.getmem.resp_delim = ": ";        /* getmem.resp_delim */
 364   mon2000_cmds.getmem.term = NULL;      /* getmem.term */
 365   mon2000_cmds.getmem.term_cmd = NULL;  /* getmem.term_cmd */
 366   mon2000_cmds.setreg.cmd = "%x to %%%s\r";     /* setreg.cmd (name, value) */
 367   mon2000_cmds.setreg.resp_delim = NULL;        /* setreg.resp_delim */
 368   mon2000_cmds.setreg.term = NULL;      /* setreg.term */
 369   mon2000_cmds.setreg.term_cmd = NULL;  /* setreg.term_cmd */
 370   mon2000_cmds.getreg.cmd = NULL;       /* getreg.cmd (name) */
 371   mon2000_cmds.getreg.resp_delim = NULL;        /* getreg.resp_delim */
 372   mon2000_cmds.getreg.term = NULL;      /* getreg.term */
 373   mon2000_cmds.getreg.term_cmd = NULL;  /* getreg.term_cmd */
 374   mon2000_cmds.dump_registers = ".reg\r";       /* dump_registers */
 375   mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";        /* register_pattern */
 376   mon2000_cmds.supply_register = m32r_supply_register;  /* supply_register */
 377   mon2000_cmds.load_routine = NULL;     /* load_routine (defaults to SRECs) */
 378   mon2000_cmds.load = NULL;     /* download command */
 379   mon2000_cmds.loadresp = NULL; /* load response */
 380   mon2000_cmds.prompt = "Mon2000>";     /* monitor command prompt */
 381   mon2000_cmds.line_term = "\r";        /* end-of-line terminator */
 382   mon2000_cmds.cmd_end = NULL;  /* optional command terminator */
 383   mon2000_cmds.target = &mon2000_ops;   /* target operations */
 384   mon2000_cmds.stopbits = SERIAL_1_STOPBITS;    /* number of stop bits */
 385   mon2000_cmds.regnames = m32r_regnames;        /* registers names */
 386   mon2000_cmds.magic = MONITOR_OPS_MAGIC;       /* magic */
 387 }                               /* init_mon2000_cmds */
 388
 389 static void
 390 mon2000_open (char *args, int from_tty)
 391 {
 392   monitor_open (args, &mon2000_cmds, from_tty);
 393 }
 394
 395 #ifndef _MSC_VER
 396
 397 /* Function: set_board_address
 398    Tell the BootOne monitor what it's ethernet IP address is. */
 399
 400 static void
 401 m32r_set_board_address (char *args, int from_tty)
 402 {
 403   int resp_len;
 404   char buf[1024];
 405
 406   if (args && *args)
 407     {
 408       monitor_printf ("ulip %s\n", args);
 409       resp_len = monitor_expect_prompt (buf, sizeof (buf));
 410       /* now parse the result for success */
 411     }
 412   else
 413     error ("Requires argument (IP address for M32R-EVA board)");
 414 }
 415
 416 /* Function: set_server_address
 417    Tell the BootOne monitor what gdb's ethernet IP address is. */
 418
 419 static void
 420 m32r_set_server_address (char *args, int from_tty)
 421 {
 422   int resp_len;
 423   char buf[1024];
 424
 425   if (args && *args)
 426     {
 427       monitor_printf ("uhip %s\n", args);
 428       resp_len = monitor_expect_prompt (buf, sizeof (buf));
 429       /* now parse the result for success */
 430     }
 431   else
 432     error ("Requires argument (IP address of GDB's host computer)");
 433 }
 434
 435 /* Function: set_download_path
 436    Tell the BootOne monitor the default path for downloadable SREC files. */
 437
 438 static void
 439 m32r_set_download_path (char *args, int from_tty)
 440 {
 441   int resp_len;
 442   char buf[1024];
 443
 444   if (args && *args)
 445     {
 446       monitor_printf ("up %s\n", args);
 447       resp_len = monitor_expect_prompt (buf, sizeof (buf));
 448       /* now parse the result for success */
 449     }
 450   else
 451     error ("Requires argument (default path for downloadable SREC files)");
 452 }
 453
 454 static void
 455 m32r_upload_command (char *args, int from_tty)
 456 {
 457   bfd *abfd;
 458   asection *s;
 459   time_t start_time, end_time;  /* for timing of download */
 460   extern int inferior_pid;
 461   int resp_len, data_count = 0;
 462   char buf[1024];
 463   struct hostent *hostent;
 464   struct in_addr inet_addr;
 465
 466   /* first check to see if there's an ethernet port! */
 467   monitor_printf ("ust\r");
 468   resp_len = monitor_expect_prompt (buf, sizeof (buf));
 469   if (!strchr (buf, ':'))
 470     error ("No ethernet connection!");
 471
 472   if (board_addr == 0)
 473     {
 474       /* scan second colon in the output from the "ust" command */
 475       char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1;
 476
 477       while (isspace (*myIPaddress))
 478         myIPaddress++;
 479
 480       if (!strncmp (myIPaddress, "0.0.", 4))    /* empty */
 481         error ("Please use 'set board-address' to set the M32R-EVA board's IP address.");
 482       if (strchr (myIPaddress, '('))
 483         *(strchr (myIPaddress, '(')) = '\0';    /* delete trailing junk */
 484       board_addr = xstrdup (myIPaddress);
 485     }
 486   if (server_addr == 0)
 487     {
 488       buf[0] = 0;
 489       gethostname (buf, sizeof (buf));
 490       if (buf[0] != 0)
 491         hostent = gethostbyname (buf);
 492       if (hostent != 0)
 493         {
 494 #if 1
 495           memcpy (&inet_addr.s_addr, hostent->h_addr,
 496                   sizeof (inet_addr.s_addr));
 497           server_addr = (char *) inet_ntoa (inet_addr);
 498 #else
 499           server_addr = (char *) inet_ntoa (hostent->h_addr);
 500 #endif
 501         }
 502       if (server_addr == 0)     /* failed? */
 503         error ("Need to know gdb host computer's IP address (use 'set server-address')");
 504     }
 505
 506   if (args == 0 || args[0] == 0)        /* no args: upload the current file */
 507     args = get_exec_file (1);
 508
 509   if (args[0] != '/' && download_path == 0)
 510     {
 511       if (current_directory)
 512         download_path = xstrdup (current_directory);
 513       else
 514         error ("Need to know default download path (use 'set download-path')");
 515     }
 516
 517   start_time = time (NULL);
 518   monitor_printf ("uhip %s\r", server_addr);
 519   resp_len = monitor_expect_prompt (buf, sizeof (buf));         /* parse result? */
 520   monitor_printf ("ulip %s\r", board_addr);
 521   resp_len = monitor_expect_prompt (buf, sizeof (buf));         /* parse result? */
 522   if (args[0] != '/')
 523     monitor_printf ("up %s\r", download_path);  /* use default path */
 524   else
 525     monitor_printf ("up\r");    /* rooted filename/path */
 526   resp_len = monitor_expect_prompt (buf, sizeof (buf));         /* parse result? */
 527
 528   if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec"))
 529     monitor_printf ("ul %s\r", args);
 530   else                          /* add ".srec" suffix */
 531     monitor_printf ("ul %s.srec\r", args);
 532   resp_len = monitor_expect_prompt (buf, sizeof (buf));         /* parse result? */
 533
 534   if (buf[0] == 0 || strstr (buf, "complete") == 0)
 535     error ("Upload file not found: %s.srec\nCheck IP addresses and download path.", args);
 536   else
 537     printf_filtered (" -- Ethernet load complete.\n");
 538
 539   end_time = time (NULL);
 540   abfd = bfd_openr (args, 0);
 541   if (abfd != NULL)
 542     {                           /* Download is done -- print section statistics */
 543       if (bfd_check_format (abfd, bfd_object) == 0)
 544         {
 545           printf_filtered ("File is not an object file\n");
 546         }
 547       for (s = abfd->sections; s; s = s->next)
 548         if (s->flags & SEC_LOAD)
 549           {
 550             bfd_size_type section_size = bfd_section_size (abfd, s);
 551             bfd_vma section_base = bfd_section_lma (abfd, s);
 552             unsigned int buffer;
 553
 554             data_count += section_size;
 555
 556             printf_filtered ("Loading section %s, size 0x%lx lma ",
 557                              bfd_section_name (abfd, s), section_size);
 558             print_address_numeric (section_base, 1, gdb_stdout);
 559             printf_filtered ("\n");
 560             gdb_flush (gdb_stdout);
 561           }
 562       /* Finally, make the PC point at the start address */
 563       write_pc (bfd_get_start_address (abfd));
 564       report_transfer_performance (data_count, start_time, end_time);
 565       printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd));
 566     }
 567   inferior_pid = 0;             /* No process now */
 568
 569   /* This is necessary because many things were based on the PC at the
 570      time that we attached to the monitor, which is no longer valid
 571      now that we have loaded new code (and just changed the PC).
 572      Another way to do this might be to call normal_stop, except that
 573      the stack may not be valid, and things would get horribly
 574      confused... */
 575
 576   clear_symtab_users ();
 577 }
 578
 579 #endif /* ! _MSC_VER */
 580
 581 void
 582 _initialize_m32r_rom (void)
 583 {
 584   /* Initialize m32r RevC monitor target */
 585   init_m32r_cmds ();
 586   init_monitor_ops (&m32r_ops);
 587
 588   m32r_ops.to_shortname = "m32r";
 589   m32r_ops.to_longname = "m32r monitor";
 590   m32r_ops.to_load = m32r_load_gen;     /* monitor lacks a download command */
 591   m32r_ops.to_doc = "Debug via the m32r monitor.\n\
 592 Specify the serial device it is connected to (e.g. /dev/ttya).";
 593   m32r_ops.to_open = m32r_open;
 594   add_target (&m32r_ops);
 595
 596   /* Initialize mon2000 monitor target */
 597   init_mon2000_cmds ();
 598   init_monitor_ops (&mon2000_ops);
 599
 600   mon2000_ops.to_shortname = "mon2000";
 601   mon2000_ops.to_longname = "Mon2000 monitor";
 602   mon2000_ops.to_load = m32r_load_gen;  /* monitor lacks a download command */
 603   mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\
 604 Specify the serial device it is connected to (e.g. /dev/ttya).";
 605   mon2000_ops.to_open = mon2000_open;
 606   add_target (&mon2000_ops);
 607
 608 #ifndef _MSC_VER
 609   add_show_from_set
 610     (add_set_cmd ("download-path", class_obscure, var_string,
 611                   (char *) &download_path,
 612                   "Set the default path for downloadable SREC files.",
 613                   &setlist),
 614      &showlist);
 615
 616   add_show_from_set
 617     (add_set_cmd ("board-address", class_obscure, var_string,
 618                   (char *) &board_addr,
 619                   "Set IP address for M32R-EVA target board.",
 620                   &setlist),
 621      &showlist);
 622
 623   add_show_from_set
 624     (add_set_cmd ("server-address", class_obscure, var_string,
 625                   (char *) &server_addr,
 626                 "Set IP address for download server (GDB's host computer).",
 627                   &setlist),
 628      &showlist);
 629
 630   add_com ("upload", class_obscure, m32r_upload_command,
 631       "Upload the srec file via the monitor's Ethernet upload capability.");
 632
 633   add_com ("tload", class_obscure, m32r_load, "test upload command.");
 634 #endif
 635 }