gdb/m32r-rom.c

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