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