gdb/m32r-rom.c

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