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