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