gdb/m32r-rom.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
  2.    the GNU debugger.

  4.    Copyright (C) 1996-2015 Free Software Foundation, Inc.

  6.    Adapted by Michael Snyder of Cygnus Support.

  8.    This file is part of GDB.

  10.    This program is free software; you can redistribute it and/or modify
  11.    it under the terms of the GNU General Public License as published by
  12.    the Free Software Foundation; either version 3 of the License, or
  13.    (at your option) any later version.

  15.    This program is distributed in the hope that it will be useful,
  16.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.

  20.    You should have received a copy of the GNU General Public License
  21.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  23. /* This module defines communication with the Renesas m32r monitor.  */

  25. #include "defs.h"
  26. #include "gdbcore.h"
  27. #include "target.h"
  28. #include "monitor.h"
  29. #include "serial.h"
  30. #include "symtab.h"
  31. #include "command.h"
  32. #include "gdbcmd.h"
  33. #include "symfile.h"                /* for generic load */
  34. #include <sys/time.h>
  35. #include <time.h>                /* for time_t */
  36. #include "objfiles.h"                /* for ALL_OBJFILES etc.  */
  37. #include "inferior.h"
  38. #include <ctype.h>
  39. #include "regcache.h"
  40. #include "gdb_bfd.h"
  41. #include "cli/cli-utils.h"

  43. /*
  44. * All this stuff just to get my host computer's IP address!
  45. */
  46. #ifdef __MINGW32__
  47. #include <winsock2.h>
  48. #else
  49. #include <sys/types.h>
  50. #include <netdb.h>                /* for hostent */
  51. #include <netinet/in.h>                /* for struct in_addr */
  52. #if 1
  53. #include <arpa/inet.h>                /* for inet_ntoa */
  54. #endif
  55. #endif

  57. ‌static char *board_addr;        /* user-settable IP address for M32R-EVA */
  58. ‌static char *server_addr;        /* user-settable IP address for gdb host */
  59. ‌static char *download_path;        /* user-settable path for SREC files     */


  62. /* REGNUM */
  63. ‌#define PSW_REGNUM      16
  64. ‌#define SPI_REGNUM      18
  65. ‌#define SPU_REGNUM      19
  66. ‌#define ACCL_REGNUM     22
  67. ‌#define ACCH_REGNUM     23


  70. /*
  71. * Function: m32r_load_1 (helper function)
  72. */

  74. static void
  75. ‌m32r_load_section (bfd *abfd, asection *s, void *obj)
  76. {
  77.   unsigned int *data_count = obj;
  78.   if (s->flags & SEC_LOAD)
  79.     {
  80.       int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
  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;

  85.       *data_count += section_size;

  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 (target_gdbarch (), section_base), gdb_stdout);
  91.       printf_filtered ("\n");
  92.       gdb_flush (gdb_stdout);
  93.       monitor_printf ("%s mw\r", phex_nz (section_base, addr_size));
  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. }

  107. static int
  108. ‌m32r_load_1 (void *dummy)
  109. {
  110.   int data_count = 0;

  112.   bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count);
  113.   return data_count;
  114. }

  116. /*
  117. * Function: m32r_load (an alternate way to load)
  118. */

  120. static void
  121. ‌m32r_load (char *filename, int from_tty)
  122. {
  123.   bfd *abfd;
  124.   unsigned int data_count = 0;
  125.   struct timeval start_time, end_time;
  126.   struct cleanup *cleanup;

  128.   if (filename == NULL || filename[0] == 0)
  129.     filename = get_exec_file (1);

  131.   abfd = gdb_bfd_open (filename, NULL, -1);
  132.   if (!abfd)
  133.     error (_("Unable to open file %s."), filename);
  134.   cleanup = make_cleanup_bfd_unref (abfd);
  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;

  146.         data_count += section_size;

  148.         printf_filtered ("Loading section %s, size 0x%lx vma ",
  149.                          bfd_section_name (abfd, s), section_size);
  150.         fputs_filtered (paddress (target_gdbarch (), section_base), 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.       do_cleanups (cleanup);
  169.       return;
  170.     }
  171. #endif
  172.   gettimeofday (&end_time, NULL);
  173.   printf_filtered ("Start address 0x%lx\n",
  174.                    (unsigned long) bfd_get_start_address (abfd));
  175.   print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
  176.                               &end_time);

  178.   /* Finally, make the PC point at the start address.  */
  179.   if (exec_bfd)
  180.     regcache_write_pc (get_current_regcache (),
  181.                        bfd_get_start_address (exec_bfd));

  183.   inferior_ptid = null_ptid;        /* No process now.  */

  185.   /* This is necessary because many things were based on the PC at the
  186.      time that we attached to the monitor, which is no longer valid
  187.      now that we have loaded new code (and just changed the PC).
  188.      Another way to do this might be to call normal_stop, except that
  189.      the stack may not be valid, and things would get horribly
  190.      confused...  */

  192.   clear_symtab_users (0);
  193.   do_cleanups (cleanup);
  194. }

  196. static void
  197. ‌m32r_load_gen (struct target_ops *self, const char *filename, int from_tty)
  198. {
  199.   generic_load (filename, from_tty);
  200. }

  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".  */

  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. };

  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);

  221.   for (regno = 0; regno < num_regs; regno++)
  222.     if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0)
  223.       break;

  225.   if (regno >= num_regs)
  226.     return;                        /* no match */

  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. #if (defined SM_REGNUM || defined BSM_REGNUM || defined IE_REGNUM \
  241.      || defined BIE_REGNUM || defined COND_REGNUM  || defined CBR_REGNUM \
  242.      || defined BPC_REGNUM || defined BCARRY_REGNUM)
  243.           unsigned long psw = strtoul (val, NULL, 16);
  244.           char *zero = "00000000", *one = "00000001";
  245. #endif

  247. #ifdef SM_REGNUM
  248.           /* Stack mode bit */
  249.           monitor_supply_register (regcache, SM_REGNUM,
  250.                                    (psw & 0x80) ? one : zero);
  251. #endif
  252. #ifdef BSM_REGNUM
  253.           /* Backup stack mode bit */
  254.           monitor_supply_register (regcache, BSM_REGNUM,
  255.                                    (psw & 0x8000) ? one : zero);
  256. #endif
  257. #ifdef IE_REGNUM
  258.           /* Interrupt enable bit */
  259.           monitor_supply_register (regcache, IE_REGNUM,
  260.                                    (psw & 0x40) ? one : zero);
  261. #endif
  262. #ifdef BIE_REGNUM
  263.           /* Backup interrupt enable bit */
  264.           monitor_supply_register (regcache, BIE_REGNUM,
  265.                                    (psw & 0x4000) ? one : zero);
  266. #endif
  267. #ifdef COND_REGNUM
  268.           /* Condition bit (carry etc.) */
  269.           monitor_supply_register (regcache, COND_REGNUM,
  270.                                    (psw & 0x1) ? one : zero);
  271. #endif
  272. #ifdef CBR_REGNUM
  273.           monitor_supply_register (regcache, CBR_REGNUM,
  274.                                    (psw & 0x1) ? one : zero);
  275. #endif
  276. #ifdef BPC_REGNUM
  277.           monitor_supply_register (regcache, BPC_REGNUM,
  278.                                    zero);        /* KLUDGE:   (???????) */
  279. #endif
  280. #ifdef BCARRY_REGNUM
  281.           monitor_supply_register (regcache, BCARRY_REGNUM,
  282.                                    zero);        /* KLUDGE: (??????) */
  283. #endif
  284.         }

  286.       if (regno == SPI_REGNUM || regno == SPU_REGNUM)
  287.         {        /* special handling for stack pointer (spu or spi).  */
  288.           ULONGEST stackmode, psw;
  289.           regcache_cooked_read_unsigned (regcache, PSW_REGNUM, &psw);
  290.           stackmode = psw & 0x80;

  292.           if (regno == SPI_REGNUM && !stackmode)        /* SP == SPI */
  293.             monitor_supply_register (regcache,
  294.                                      gdbarch_sp_regnum (gdbarch), val);
  295.           else if (regno == SPU_REGNUM && stackmode)        /* SP == SPU */
  296.             monitor_supply_register (regcache,
  297.                                      gdbarch_sp_regnum (gdbarch), val);
  298.         }
  299.     }
  300. }

  302. /* m32r RevC board monitor */

  304. ‌static struct target_ops m32r_ops;

  306. ‌static char *m32r_inits[] = { "\r", NULL };

  308. ‌static struct monitor_ops m32r_cmds;

  310. static void
  311. ‌init_m32r_cmds (void)
  312. {
  313.   m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
  314.   m32r_cmds.init = m32r_inits;        /* Init strings */
  315.   m32r_cmds.cont = "go\r";        /* continue command */
  316.   m32r_cmds.step = "step\r";        /* single step */
  317.   m32r_cmds.stop = NULL;        /* interrupt command */
  318.   m32r_cmds.set_break = "%x +bp\r";        /* set a breakpoint */
  319.   m32r_cmds.clr_break = "%x -bp\r";        /* clear a breakpoint */
  320.   m32r_cmds.clr_all_break = "bpoff\r";        /* clear all breakpoints */
  321.   m32r_cmds.fill = "%x %x %x fill\r";        /* fill (start length val) */
  322.   m32r_cmds.setmem.cmdb = "%x 1 %x fill\r";        /* setmem.cmdb (addr, value) */
  323.   m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r";        /* setmem.cmdw (addr, value) */
  324.   m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r";        /* setmem.cmdl (addr, value) */
  325.   m32r_cmds.setmem.cmdll = NULL;        /* setmem.cmdll (addr, value) */
  326.   m32r_cmds.setmem.resp_delim = NULL;        /* setmem.resp_delim */
  327.   m32r_cmds.setmem.term = NULL;        /* setmem.term */
  328.   m32r_cmds.setmem.term_cmd = NULL;        /* setmem.term_cmd */
  329.   m32r_cmds.getmem.cmdb = "%x %x dump\r";        /* getmem.cmdb (addr, len) */
  330.   m32r_cmds.getmem.cmdw = NULL;        /* getmem.cmdw (addr, len) */
  331.   m32r_cmds.getmem.cmdl = NULL;        /* getmem.cmdl (addr, len) */
  332.   m32r_cmds.getmem.cmdll = NULL;        /* getmem.cmdll (addr, len) */
  333.   m32r_cmds.getmem.resp_delim = ": ";        /* getmem.resp_delim */
  334.   m32r_cmds.getmem.term = NULL;        /* getmem.term */
  335.   m32r_cmds.getmem.term_cmd = NULL;        /* getmem.term_cmd */
  336.   m32r_cmds.setreg.cmd = "%x to %%%s\r";        /* setreg.cmd (name, value) */
  337.   m32r_cmds.setreg.resp_delim = NULL;        /* setreg.resp_delim */
  338.   m32r_cmds.setreg.term = NULL;        /* setreg.term */
  339.   m32r_cmds.setreg.term_cmd = NULL;        /* setreg.term_cmd */
  340.   m32r_cmds.getreg.cmd = NULL;        /* getreg.cmd (name) */
  341.   m32r_cmds.getreg.resp_delim = NULL;        /* getreg.resp_delim */
  342.   m32r_cmds.getreg.term = NULL;        /* getreg.term */
  343.   m32r_cmds.getreg.term_cmd = NULL;        /* getreg.term_cmd */
  344.   m32r_cmds.dump_registers = ".reg\r";        /* dump_registers */
  345.                                           /* register_pattern */
  346.   m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
  347.   m32r_cmds.supply_register = m32r_supply_register;
  348.   m32r_cmds.load = NULL;        /* download command */
  349.   m32r_cmds.loadresp = NULL;        /* load response */
  350.   m32r_cmds.prompt = "ok ";        /* monitor command prompt */
  351.   m32r_cmds.line_term = "\r";        /* end-of-line terminator */
  352.   m32r_cmds.cmd_end = NULL;        /* optional command terminator */
  353.   m32r_cmds.target = &m32r_ops;        /* target operations */
  354.   m32r_cmds.stopbits = SERIAL_1_STOPBITS;        /* number of stop bits */
  355.   m32r_cmds.regnames = m32r_regnames;        /* registers names */
  356.   m32r_cmds.magic = MONITOR_OPS_MAGIC;        /* magic */
  357. }                                /* init_m32r_cmds */

  359. static void
  360. ‌m32r_open (const char *args, int from_tty)
  361. {
  362.   monitor_open (args, &m32r_cmds, from_tty);
  363. }

  365. /* Mon2000 monitor (MSA2000 board) */

  367. ‌static struct target_ops mon2000_ops;
  368. ‌static struct monitor_ops mon2000_cmds;

  370. static void
  371. ‌init_mon2000_cmds (void)
  372. {
  373.   mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
  374.   mon2000_cmds.init = m32r_inits;        /* Init strings */
  375.   mon2000_cmds.cont = "go\r";        /* continue command */
  376.   mon2000_cmds.step = "step\r";        /* single step */
  377.   mon2000_cmds.stop = NULL;        /* interrupt command */
  378.   mon2000_cmds.set_break = "%x +bp\r";        /* set a breakpoint */
  379.   mon2000_cmds.clr_break = "%x -bp\r";        /* clear a breakpoint */
  380.   mon2000_cmds.clr_all_break = "bpoff\r";        /* clear all breakpoints */
  381.   mon2000_cmds.fill = "%x %x %x fill\r";        /* fill (start length val) */
  382.   mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r";        /* setmem.cmdb (addr, value) */
  383.   mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r";        /* setmem.cmdw (addr, value) */
  384.   mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r";        /* setmem.cmdl (addr, value) */
  385.   mon2000_cmds.setmem.cmdll = NULL;        /* setmem.cmdll (addr, value) */
  386.   mon2000_cmds.setmem.resp_delim = NULL;        /* setmem.resp_delim */
  387.   mon2000_cmds.setmem.term = NULL;        /* setmem.term */
  388.   mon2000_cmds.setmem.term_cmd = NULL;        /* setmem.term_cmd */
  389.   mon2000_cmds.getmem.cmdb = "%x %x dump\r";        /* getmem.cmdb (addr, len) */
  390.   mon2000_cmds.getmem.cmdw = NULL;        /* getmem.cmdw (addr, len) */
  391.   mon2000_cmds.getmem.cmdl = NULL;        /* getmem.cmdl (addr, len) */
  392.   mon2000_cmds.getmem.cmdll = NULL;        /* getmem.cmdll (addr, len) */
  393.   mon2000_cmds.getmem.resp_delim = ": ";        /* getmem.resp_delim */
  394.   mon2000_cmds.getmem.term = NULL;        /* getmem.term */
  395.   mon2000_cmds.getmem.term_cmd = NULL;        /* getmem.term_cmd */
  396.   mon2000_cmds.setreg.cmd = "%x to %%%s\r";        /* setreg.cmd (name, value) */
  397.   mon2000_cmds.setreg.resp_delim = NULL;        /* setreg.resp_delim */
  398.   mon2000_cmds.setreg.term = NULL;        /* setreg.term */
  399.   mon2000_cmds.setreg.term_cmd = NULL;        /* setreg.term_cmd */
  400.   mon2000_cmds.getreg.cmd = NULL;        /* getreg.cmd (name) */
  401.   mon2000_cmds.getreg.resp_delim = NULL;        /* getreg.resp_delim */
  402.   mon2000_cmds.getreg.term = NULL;        /* getreg.term */
  403.   mon2000_cmds.getreg.term_cmd = NULL;        /* getreg.term_cmd */
  404.   mon2000_cmds.dump_registers = ".reg\r";        /* dump_registers */
  405.                                                 /* register_pattern */
  406.   mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
  407.   mon2000_cmds.supply_register = m32r_supply_register;
  408.   mon2000_cmds.load = NULL;        /* download command */
  409.   mon2000_cmds.loadresp = NULL;        /* load response */
  410.   mon2000_cmds.prompt = "Mon2000>";        /* monitor command prompt */
  411.   mon2000_cmds.line_term = "\r";        /* end-of-line terminator */
  412.   mon2000_cmds.cmd_end = NULL;        /* optional command terminator */
  413.   mon2000_cmds.target = &mon2000_ops;        /* target operations */
  414.   mon2000_cmds.stopbits = SERIAL_1_STOPBITS;        /* number of stop bits */
  415.   mon2000_cmds.regnames = m32r_regnames;        /* registers names */
  416.   mon2000_cmds.magic = MONITOR_OPS_MAGIC;        /* magic */
  417. }                                /* init_mon2000_cmds */

  419. static void
  420. ‌mon2000_open (const char *args, int from_tty)
  421. {
  422.   monitor_open (args, &mon2000_cmds, from_tty);
  423. }

  425. static void
  426. ‌m32r_upload_command (char *args, int from_tty)
  427. {
  428.   bfd *abfd;
  429.   asection *s;
  430.   struct timeval start_time, end_time;
  431.   int resp_len, data_count = 0;
  432.   char buf[1024];
  433.   struct hostent *hostent;
  434.   struct in_addr inet_addr;
  435.   struct cleanup *cleanup;

  437.   /* First check to see if there's an ethernet port!  */
  438.   monitor_printf ("ust\r");
  439.   resp_len = monitor_expect_prompt (buf, sizeof (buf));
  440.   if (!strchr (buf, ':'))
  441.     error (_("No ethernet connection!"));

  443.   if (board_addr == 0)
  444.     {
  445.       /* Scan second colon in the output from the "ust" command.  */
  446.       char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1;

  448.       myIPaddress = skip_spaces (myIPaddress);

  450.       if (!strncmp (myIPaddress, "0.0.", 4))        /* empty */
  451.         error (_("Please use 'set board-address' to "
  452.                  "set the M32R-EVA board's IP address."));
  453.       if (strchr (myIPaddress, '('))
  454.         *(strchr (myIPaddress, '(')) = '\0';        /* delete trailing junk */
  455.       board_addr = xstrdup (myIPaddress);
  456.     }
  457.   if (server_addr == 0)
  458.     {
  459. #ifdef __MINGW32__
  460.       WSADATA wd;
  461.       /* Winsock initialization.  */
  462.       if (WSAStartup (MAKEWORD (1, 1), &wd))
  463.         error (_("Couldn't initialize WINSOCK."));
  464. #endif

  466.       buf[0] = 0;
  467.       gethostname (buf, sizeof (buf));
  468.       if (buf[0] != 0)
  469.         {
  470.           hostent = gethostbyname (buf);
  471.           if (hostent != 0)
  472.             {
  473. #if 1
  474.               memcpy (&inet_addr.s_addr, hostent->h_addr,
  475.                       sizeof (inet_addr.s_addr));
  476.               server_addr = (char *) inet_ntoa (inet_addr);
  477. #else
  478.               server_addr = (char *) inet_ntoa (hostent->h_addr);
  479. #endif
  480.             }
  481.         }
  482.       if (server_addr == 0)        /* failed?  */
  483.         error (_("Need to know gdb host computer's "
  484.                  "IP address (use 'set server-address')"));
  485.     }

  487.   if (args == 0 || args[0] == 0)        /* No args: upload the current
  488.                                            file.  */
  489.     args = get_exec_file (1);

  491.   if (args[0] != '/' && download_path == 0)
  492.     {
  493.       if (current_directory)
  494.         download_path = xstrdup (current_directory);
  495.       else
  496.         error (_("Need to know default download "
  497.                  "path (use 'set download-path')"));
  498.     }

  500.   gettimeofday (&start_time, NULL);
  501.   monitor_printf ("uhip %s\r", server_addr);
  502.   resp_len = monitor_expect_prompt (buf, sizeof (buf));        /* parse result?  */
  503.   monitor_printf ("ulip %s\r", board_addr);
  504.   resp_len = monitor_expect_prompt (buf, sizeof (buf));        /* parse result?  */
  505.   if (args[0] != '/')
  506.     monitor_printf ("up %s\r", download_path);        /* use default path */
  507.   else
  508.     monitor_printf ("up\r");        /* rooted filename/path */
  509.   resp_len = monitor_expect_prompt (buf, sizeof (buf));        /* parse result?  */

  511.   if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec"))
  512.     monitor_printf ("ul %s\r", args);
  513.   else                                /* add ".srec" suffix */
  514.     monitor_printf ("ul %s.srec\r", args);
  515.   resp_len = monitor_expect_prompt (buf, sizeof (buf));        /* parse result?  */

  517.   if (buf[0] == 0 || strstr (buf, "complete") == 0)
  518.     error (_("Upload file not found: %s.srec\n"
  519.              "Check IP addresses and download path."),
  520.            args);
  521.   else
  522.     printf_filtered (" -- Ethernet load complete.\n");

  524.   gettimeofday (&end_time, NULL);
  525.   abfd = gdb_bfd_open (args, NULL, -1);
  526.   cleanup = make_cleanup_bfd_unref (abfd);
  527.   if (abfd != NULL)
  528.     {                /* Download is done -- print section statistics.  */
  529.       if (bfd_check_format (abfd, bfd_object) == 0)
  530.         {
  531.           printf_filtered ("File is not an object file\n");
  532.         }
  533.       for (s = abfd->sections; s; s = s->next)
  534.         if (s->flags & SEC_LOAD)
  535.           {
  536.             bfd_size_type section_size = bfd_section_size (abfd, s);
  537.             bfd_vma section_base = bfd_section_lma (abfd, s);

  539.             data_count += section_size;

  541.             printf_filtered ("Loading section %s, size 0x%lx lma ",
  542.                              bfd_section_name (abfd, s),
  543.                              (unsigned long) section_size);
  544.             fputs_filtered (paddress (target_gdbarch (), section_base),
  545.                             gdb_stdout);
  546.             printf_filtered ("\n");
  547.             gdb_flush (gdb_stdout);
  548.           }
  549.       /* Finally, make the PC point at the start address.  */
  550.       regcache_write_pc (get_current_regcache (),
  551.                          bfd_get_start_address (abfd));
  552.       printf_filtered ("Start address 0x%lx\n",
  553.                        (unsigned long) bfd_get_start_address (abfd));
  554.       print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
  555.                                   &end_time);
  556.     }
  557.   inferior_ptid = null_ptid;        /* No process now.  */

  559.   /* This is necessary because many things were based on the PC at the
  560.      time that we attached to the monitor, which is no longer valid
  561.      now that we have loaded new code (and just changed the PC).
  562.      Another way to do this might be to call normal_stop, except that
  563.      the stack may not be valid, and things would get horribly
  564.      confused...  */

  566.   clear_symtab_users (0);
  567.   do_cleanups (cleanup);
  568. }

  570. /* Provide a prototype to silence -Wmissing-prototypes.  */
  571. extern initialize_file_ftype _initialize_m32r_rom;

  573. void
  574. ‌_initialize_m32r_rom (void)
  575. {
  576.   /* Initialize m32r RevC monitor target.  */
  577.   init_m32r_cmds ();
  578.   init_monitor_ops (&m32r_ops);

  580.   m32r_ops.to_shortname = "m32r";
  581.   m32r_ops.to_longname = "m32r monitor";
  582.   m32r_ops.to_load = m32r_load_gen;        /* Monitor lacks a download
  583.                                            command.  */
  584.   m32r_ops.to_doc = "Debug via the m32r monitor.\n\
  585. Specify the serial device it is connected to (e.g. /dev/ttya).";
  586.   m32r_ops.to_open = m32r_open;
  587.   add_target (&m32r_ops);

  589.   /* Initialize mon2000 monitor target */
  590.   init_mon2000_cmds ();
  591.   init_monitor_ops (&mon2000_ops);

  593.   mon2000_ops.to_shortname = "mon2000";
  594.   mon2000_ops.to_longname = "Mon2000 monitor";
  595.   mon2000_ops.to_load = m32r_load_gen;        /* Monitor lacks a download
  596.                                            command.  */
  597.   mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\
  598. Specify the serial device it is connected to (e.g. /dev/ttya).";
  599.   mon2000_ops.to_open = mon2000_open;
  600.   add_target (&mon2000_ops);

  602.   add_setshow_string_cmd ("download-path", class_obscure, &download_path, _("\
  603. Set the default path for downloadable SREC files."), _("\
  604. Show the default path for downloadable SREC files."), _("\
  605. Determines the default path for downloadable SREC files."),
  606.                           NULL,
  607.                           NULL, /* FIXME: i18n: The default path for
  608.                                    downloadable SREC files is %s.  */
  609.                           &setlist, &showlist);

  611.   add_setshow_string_cmd ("board-address", class_obscure, &board_addr, _("\
  612. Set IP address for M32R-EVA target board."), _("\
  613. Show IP address for M32R-EVA target board."), _("\
  614. Determine the IP address for M32R-EVA target board."),
  615.                           NULL,
  616.                           NULL, /* FIXME: i18n: IP address for
  617.                                    M32R-EVA target board is %s.  */
  618.                           &setlist, &showlist);

  620.   add_setshow_string_cmd ("server-address", class_obscure, &server_addr, _("\
  621. Set IP address for download server (GDB's host computer)."), _("\
  622. Show IP address for download server (GDB's host computer)."), _("\
  623. Determine the IP address for download server (GDB's host computer)."),
  624.                           NULL,
  625.                           NULL, /* FIXME: i18n: IP address for
  626.                                    download server (GDB's host
  627.                                    computer) is %s.  */
  628.                           &setlist, &showlist);

  630.   add_com ("upload", class_obscure, m32r_upload_command, _("\
  631. Upload the srec file via the monitor's Ethernet upload capability."));

  633.   add_com ("tload", class_obscure, m32r_load, _("test upload command."));
  634. }