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