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