gdb/m32r-rom.c

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