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