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