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