gdb/m32r-rom.c

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