projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* target.h (struct section_table): Rename to ...
[deliverable/binutils-gdb.git] / gdb / m32r-rom.c
CommitLineData
d95a8903
AC		 1/* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
2 the GNU debugger.
3b64bf98 3
0fb0cc75
JB		 4 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2004, 2005, 2007, 2008,
5 2009 Free Software Foundation, Inc.
d95a8903
AC		 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
a9762ec7 13 the Free Software Foundation; either version 3 of the License, or
d95a8903
AC		 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
a9762ec7 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
d95a8903
AC		 23
24/* This module defines communication with the Renesas m32r monitor */
25
26#include "defs.h"
27#include "gdbcore.h"
28#include "target.h"
60250e8b 29#include "exceptions.h"
d95a8903
AC		 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 */
2b71414d 36#include <sys/time.h>
d95a8903
AC		 37#include <time.h> /* for time_t */
38#include "gdb_string.h"
39#include "objfiles.h" /* for ALL_OBJFILES etc. */
fb14de7b 40#include "inferior.h"
d95a8903
AC		 41#include <ctype.h>
42#include "regcache.h"
43
d95a8903
AC		 44/*
45 * All this stuff just to get my host computer's IP address!
46 */
cbba9205
KI		 47#ifdef __MINGW32__
48#include <winsock.h>
49#else
d95a8903
AC		 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
cbba9205 56#endif
d95a8903
AC		 57
58static char *board_addr; /* user-settable IP address for M32R-EVA */
59static char *server_addr; /* user-settable IP address for gdb host */
60static 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
75static void
76m32r_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 ",
ec20a626
UW		 88 bfd_section_name (abfd, s),
89 (unsigned long) section_size);
ed49a04f 90 fputs_filtered (paddress (section_base), gdb_stdout);
d95a8903
AC		 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
107static int
108m32r_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
120static void
121m32r_load (char *filename, int from_tty)
122{
123 bfd *abfd;
124 asection *s;
125 unsigned int i, data_count = 0;
2b71414d 126 struct timeval start_time, end_time;
d95a8903
AC		 127
128 if (filename == NULL || filename[0] == 0)
129 filename = get_exec_file (1);
130
131 abfd = bfd_openr (filename, 0);
132 if (!abfd)
8a3fe4f8 133 error (_("Unable to open file %s."), filename);
d95a8903 134 if (bfd_check_format (abfd, bfd_object) == 0)
8a3fe4f8 135 error (_("File is not an object file."));
2b71414d 136 gettimeofday (&start_time, NULL);
d95a8903
AC		 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);
ed49a04f 149 fputs_filtered (paddress (section_base), gdb_stdout);
d95a8903
AC		 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
2b71414d 170 gettimeofday (&end_time, NULL);
ec20a626
UW		 171 printf_filtered ("Start address 0x%lx\n",
172 (unsigned long) bfd_get_start_address (abfd));
2b71414d
DJ		 173 print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
174 &end_time);
d95a8903
AC		 175
176 /* Finally, make the PC point at the start address */
177 if (exec_bfd)
fb14de7b
UW		 178 regcache_write_pc (get_current_regcache (),
179 bfd_get_start_address (exec_bfd));
d95a8903
AC		 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
193static void
194m32r_load_gen (char *filename, int from_tty)
195{
196 generic_load (filename, from_tty);
197}
198
199static void m32r_open (char *args, int from_tty);
200static 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
207static 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
213static void
c410a84c
UW		 214m32r_supply_register (struct regcache *regcache, char *regname,
215 int regnamelen, char *val, int vallen)
d95a8903
AC		 216{
217 int regno;
218 int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]);
40a6adc1 219 struct gdbarch *gdbarch = get_regcache_arch (regcache);
d95a8903
AC		 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 */
c410a84c 230 monitor_supply_register (regcache, ACCH_REGNUM, val);
d95a8903
AC		 231 val = strchr (val, ':'); /* skip past ':' to get 2nd word */
232 if (val != NULL)
c410a84c 233 monitor_supply_register (regcache, ACCL_REGNUM, val + 1);
d95a8903
AC		 234 }
235 else
236 {
c410a84c 237 monitor_supply_register (regcache, regno, val);
d95a8903
AC		 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 */
c410a84c 245 monitor_supply_register (regcache, SM_REGNUM, (psw & 0x80) ? one : zero);
d95a8903
AC		 246#endif
247#ifdef BSM_REGNUM
248 /* Backup stack mode bit */
c410a84c 249 monitor_supply_register (regcache, BSM_REGNUM, (psw & 0x8000) ? one : zero);
d95a8903
AC		 250#endif
251#ifdef IE_REGNUM
252 /* Interrupt enable bit */
c410a84c 253 monitor_supply_register (regcache, IE_REGNUM, (psw & 0x40) ? one : zero);
d95a8903
AC		 254#endif
255#ifdef BIE_REGNUM
256 /* Backup interrupt enable bit */
c410a84c 257 monitor_supply_register (regcache, BIE_REGNUM, (psw & 0x4000) ? one : zero);
d95a8903
AC		 258#endif
259#ifdef COND_REGNUM
260 /* Condition bit (carry etc.) */
c410a84c 261 monitor_supply_register (regcache, COND_REGNUM, (psw & 0x1) ? one : zero);
d95a8903
AC		 262#endif
263#ifdef CBR_REGNUM
c410a84c 264 monitor_supply_register (regcache, CBR_REGNUM, (psw & 0x1) ? one : zero);
d95a8903
AC		 265#endif
266#ifdef BPC_REGNUM
c410a84c 267 monitor_supply_register (regcache, BPC_REGNUM, zero); /* KLUDGE: (???????) */
d95a8903
AC		 268#endif
269#ifdef BCARRY_REGNUM
c410a84c 270 monitor_supply_register (regcache, BCARRY_REGNUM, zero); /* KLUDGE: (??????) */
d95a8903
AC		 271#endif
272 }
273
274 if (regno == SPI_REGNUM || regno == SPU_REGNUM)
275 { /* special handling for stack pointer (spu or spi) */
7e3dd49e 276 ULONGEST stackmode, psw;
c410a84c 277 regcache_cooked_read_unsigned (regcache, PSW_REGNUM, &psw);
7e3dd49e 278 stackmode = psw & 0x80;
d95a8903
AC		 279
280 if (regno == SPI_REGNUM && !stackmode) /* SP == SPI */
3e8c568d 281 monitor_supply_register (regcache,
40a6adc1 282 gdbarch_sp_regnum (gdbarch), val);
d95a8903 283 else if (regno == SPU_REGNUM && stackmode) /* SP == SPU */
3e8c568d 284 monitor_supply_register (regcache,
40a6adc1 285 gdbarch_sp_regnum (gdbarch), val);
d95a8903
AC		 286 }
287 }
288}
289
290/* m32r RevC board monitor */
291
292static struct target_ops m32r_ops;
293
294static char *m32r_inits[] = { "\r", NULL };
295
296static struct monitor_ops m32r_cmds;
297
298static void
299init_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 */
23a6d369 334 m32r_cmds.supply_register = m32r_supply_register;
d95a8903
AC		 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
347static void
348m32r_open (char *args, int from_tty)
349{
350 monitor_open (args, &m32r_cmds, from_tty);
351}
352
353/* Mon2000 monitor (MSA2000 board) */
354
355static struct target_ops mon2000_ops;
356static struct monitor_ops mon2000_cmds;
357
358static void
359init_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 */
23a6d369 394 mon2000_cmds.supply_register = m32r_supply_register;
d95a8903
AC		 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
407static void
408mon2000_open (char *args, int from_tty)
409{
410 monitor_open (args, &mon2000_cmds, from_tty);
411}
412
d95a8903
AC		 413static void
414m32r_upload_command (char *args, int from_tty)
415{
416 bfd *abfd;
417 asection *s;
2b71414d 418 struct timeval start_time, end_time;
d95a8903
AC		 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, ':'))
8a3fe4f8 428 error (_("No ethernet connection!"));
d95a8903
AC		 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 {
cbba9205
KI		 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
d95a8903
AC		 454 buf[0] = 0;
455 gethostname (buf, sizeof (buf));
456 if (buf[0] != 0)
d95a8903 457 {
880bc914
AC		 458 hostent = gethostbyname (buf);
459 if (hostent != 0)
460 {
d95a8903 461#if 1
880bc914
AC		 462 memcpy (&inet_addr.s_addr, hostent->h_addr,
463 sizeof (inet_addr.s_addr));
464 server_addr = (char *) inet_ntoa (inet_addr);
d95a8903 465#else
880bc914 466 server_addr = (char *) inet_ntoa (hostent->h_addr);
d95a8903 467#endif
880bc914 468 }
d95a8903
AC		 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
2b71414d 487 gettimeofday (&start_time, NULL);
d95a8903
AC		 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
2b71414d 511 gettimeofday (&end_time, NULL);
d95a8903
AC		 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 ",
ec20a626
UW		 529 bfd_section_name (abfd, s),
530 (unsigned long) section_size);
ed49a04f 531 fputs_filtered (paddress (section_base), gdb_stdout);
d95a8903
AC		 532 printf_filtered ("\n");
533 gdb_flush (gdb_stdout);
534 }
535 /* Finally, make the PC point at the start address */
fb14de7b
UW		 536 regcache_write_pc (get_current_regcache (),
537 bfd_get_start_address (abfd));
ec20a626
UW		 538 printf_filtered ("Start address 0x%lx\n",
539 (unsigned long) bfd_get_start_address (abfd));
2b71414d
DJ		 540 print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
541 &end_time);
d95a8903
AC		 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
63807e1d
PA		 555/* Provide a prototype to silence -Wmissing-prototypes. */
556extern initialize_file_ftype _initialize_m32r_rom;
557
d95a8903
AC		 558void
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\
569Specify 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\
581Specify the serial device it is connected to (e.g. /dev/ttya).";
582 mon2000_ops.to_open = mon2000_open;
583 add_target (&mon2000_ops);
584
7915a72c
AC		 585 add_setshow_string_cmd ("download-path", class_obscure, &download_path, _("\
586Set the default path for downloadable SREC files."), _("\
587Show the default path for downloadable SREC files."), _("\
588Determines the default path for downloadable SREC files."),
2c5b56ce 589 NULL,
7915a72c 590 NULL, /* FIXME: i18n: The default path for downloadable SREC files is %s. */
2c5b56ce 591 &setlist, &showlist);
7915a72c
AC		 592
593 add_setshow_string_cmd ("board-address", class_obscure, &board_addr, _("\
594Set IP address for M32R-EVA target board."), _("\
595Show IP address for M32R-EVA target board."), _("\
596Determine the IP address for M32R-EVA target board."),
2c5b56ce 597 NULL,
7915a72c 598 NULL, /* FIXME: i18n: IP address for M32R-EVA target board is %s. */
2c5b56ce 599 &setlist, &showlist);
7915a72c
AC		 600
601 add_setshow_string_cmd ("server-address", class_obscure, &server_addr, _("\
602Set IP address for download server (GDB's host computer)."), _("\
603Show IP address for download server (GDB's host computer)."), _("\
604Determine the IP address for download server (GDB's host computer)."),
2c5b56ce 605 NULL,
7915a72c 606 NULL, /* FIXME: i18n: IP address for download server (GDB's host computer) is %s. */
2c5b56ce 607 &setlist, &showlist);
d95a8903 608
1bedd215
AC		 609 add_com ("upload", class_obscure, m32r_upload_command, _("\
610Upload the srec file via the monitor's Ethernet upload capability."));
d95a8903 611
1bedd215 612 add_com ("tload", class_obscure, m32r_load, _("test upload command."));
d95a8903 613}
GDB Binutils - Deliverables
This page took 0.46835 seconds and 4 git commands to generate.