1 /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
4 Copyright (C) 1996-2015 Free Software Foundation, Inc.
6 Adapted by Michael Snyder of Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* This module defines communication with the Renesas m32r monitor. */
33 #include "symfile.h" /* for generic load */
35 #include <time.h> /* for time_t */
36 #include "objfiles.h" /* for ALL_OBJFILES etc. */
41 #include "cli/cli-utils.h"
44 * All this stuff just to get my host computer's IP address!
49 #include <sys/types.h>
50 #include <netdb.h> /* for hostent */
51 #include <netinet/in.h> /* for struct in_addr */
53 #include <arpa/inet.h> /* for inet_ntoa */
57 static char *board_addr
; /* user-settable IP address for M32R-EVA */
58 static char *server_addr
; /* user-settable IP address for gdb host */
59 static char *download_path
; /* user-settable path for SREC files */
66 #define ACCL_REGNUM 22
67 #define ACCH_REGNUM 23
71 * Function: m32r_load_1 (helper function)
75 m32r_load_section (bfd
*abfd
, asection
*s
, void *obj
)
77 unsigned int *data_count
= obj
;
78 if (s
->flags
& SEC_LOAD
)
80 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
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
;
85 *data_count
+= section_size
;
87 printf_filtered ("Loading section %s, size 0x%lx lma ",
88 bfd_section_name (abfd
, s
),
89 (unsigned long) section_size
);
90 fputs_filtered (paddress (target_gdbarch (), section_base
), gdb_stdout
);
91 printf_filtered ("\n");
92 gdb_flush (gdb_stdout
);
93 monitor_printf ("%s mw\r", phex_nz (section_base
, addr_size
));
94 for (i
= 0; i
< section_size
; i
+= 4)
97 monitor_expect (" -> ", NULL
, 0);
98 bfd_get_section_contents (abfd
, s
, (char *) &buffer
, i
, 4);
99 monitor_printf ("%x\n", buffer
);
101 monitor_expect (" -> ", NULL
, 0);
102 monitor_printf ("q\n");
103 monitor_expect_prompt (NULL
, 0);
108 m32r_load_1 (void *dummy
)
112 bfd_map_over_sections ((bfd
*) dummy
, m32r_load_section
, &data_count
);
117 * Function: m32r_load (an alternate way to load)
121 m32r_load (char *filename
, int from_tty
)
124 unsigned int data_count
= 0;
125 struct timeval start_time
, end_time
;
126 struct cleanup
*cleanup
;
128 if (filename
== NULL
|| filename
[0] == 0)
129 filename
= get_exec_file (1);
131 abfd
= gdb_bfd_open (filename
, NULL
, -1);
133 error (_("Unable to open file %s."), filename
);
134 cleanup
= make_cleanup_bfd_unref (abfd
);
135 if (bfd_check_format (abfd
, bfd_object
) == 0)
136 error (_("File is not an object file."));
137 gettimeofday (&start_time
, NULL
);
139 for (s
= abfd
->sections
; s
; s
= s
->next
)
140 if (s
->flags
& SEC_LOAD
)
142 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
143 bfd_vma section_base
= bfd_section_vma (abfd
, s
);
146 data_count
+= section_size
;
148 printf_filtered ("Loading section %s, size 0x%lx vma ",
149 bfd_section_name (abfd
, s
), section_size
);
150 fputs_filtered (paddress (target_gdbarch (), section_base
), gdb_stdout
);
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)
156 monitor_expect (" -> ", NULL
, 0);
157 bfd_get_section_contents (abfd
, s
, (char *) &buffer
, i
, 4);
158 monitor_printf ("%x\n", buffer
);
160 monitor_expect (" -> ", NULL
, 0);
161 monitor_printf ("q\n");
162 monitor_expect_prompt (NULL
, 0);
165 if (!(catch_errors (m32r_load_1
, abfd
, "Load aborted!\n", RETURN_MASK_ALL
)))
167 monitor_printf ("q\n");
168 do_cleanups (cleanup
);
172 gettimeofday (&end_time
, NULL
);
173 printf_filtered ("Start address 0x%lx\n",
174 (unsigned long) bfd_get_start_address (abfd
));
175 print_transfer_performance (gdb_stdout
, data_count
, 0, &start_time
,
178 /* Finally, make the PC point at the start address. */
180 regcache_write_pc (get_current_regcache (),
181 bfd_get_start_address (exec_bfd
));
183 inferior_ptid
= null_ptid
; /* No process now. */
185 /* This is necessary because many things were based on the PC at the
186 time that we attached to the monitor, which is no longer valid
187 now that we have loaded new code (and just changed the PC).
188 Another way to do this might be to call normal_stop, except that
189 the stack may not be valid, and things would get horribly
192 clear_symtab_users (0);
193 do_cleanups (cleanup
);
197 m32r_load_gen (struct target_ops
*self
, const char *filename
, int from_tty
)
199 generic_load (filename
, from_tty
);
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". */
207 static 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",
214 m32r_supply_register (struct regcache
*regcache
, char *regname
,
215 int regnamelen
, char *val
, int vallen
)
218 int num_regs
= sizeof (m32r_regnames
) / sizeof (m32r_regnames
[0]);
219 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
221 for (regno
= 0; regno
< num_regs
; regno
++)
222 if (strncmp (regname
, m32r_regnames
[regno
], regnamelen
) == 0)
225 if (regno
>= num_regs
)
226 return; /* no match */
228 if (regno
== ACCL_REGNUM
)
229 { /* Special handling for 64-bit acc reg. */
230 monitor_supply_register (regcache
, ACCH_REGNUM
, val
);
231 val
= strchr (val
, ':'); /* Skip past ':' to get 2nd word. */
233 monitor_supply_register (regcache
, ACCL_REGNUM
, val
+ 1);
237 monitor_supply_register (regcache
, regno
, val
);
238 if (regno
== PSW_REGNUM
)
240 #if (defined SM_REGNUM || defined BSM_REGNUM || defined IE_REGNUM \
241 || defined BIE_REGNUM || defined COND_REGNUM || defined CBR_REGNUM \
242 || defined BPC_REGNUM || defined BCARRY_REGNUM)
243 unsigned long psw
= strtoul (val
, NULL
, 16);
244 char *zero
= "00000000", *one
= "00000001";
249 monitor_supply_register (regcache
, SM_REGNUM
,
250 (psw
& 0x80) ? one
: zero
);
253 /* Backup stack mode bit */
254 monitor_supply_register (regcache
, BSM_REGNUM
,
255 (psw
& 0x8000) ? one
: zero
);
258 /* Interrupt enable bit */
259 monitor_supply_register (regcache
, IE_REGNUM
,
260 (psw
& 0x40) ? one
: zero
);
263 /* Backup interrupt enable bit */
264 monitor_supply_register (regcache
, BIE_REGNUM
,
265 (psw
& 0x4000) ? one
: zero
);
268 /* Condition bit (carry etc.) */
269 monitor_supply_register (regcache
, COND_REGNUM
,
270 (psw
& 0x1) ? one
: zero
);
273 monitor_supply_register (regcache
, CBR_REGNUM
,
274 (psw
& 0x1) ? one
: zero
);
277 monitor_supply_register (regcache
, BPC_REGNUM
,
278 zero
); /* KLUDGE: (???????) */
281 monitor_supply_register (regcache
, BCARRY_REGNUM
,
282 zero
); /* KLUDGE: (??????) */
286 if (regno
== SPI_REGNUM
|| regno
== SPU_REGNUM
)
287 { /* special handling for stack pointer (spu or spi). */
288 ULONGEST stackmode
, psw
;
289 regcache_cooked_read_unsigned (regcache
, PSW_REGNUM
, &psw
);
290 stackmode
= psw
& 0x80;
292 if (regno
== SPI_REGNUM
&& !stackmode
) /* SP == SPI */
293 monitor_supply_register (regcache
,
294 gdbarch_sp_regnum (gdbarch
), val
);
295 else if (regno
== SPU_REGNUM
&& stackmode
) /* SP == SPU */
296 monitor_supply_register (regcache
,
297 gdbarch_sp_regnum (gdbarch
), val
);
302 /* m32r RevC board monitor */
304 static struct target_ops m32r_ops
;
306 static char *m32r_inits
[] = { "\r", NULL
};
308 static struct monitor_ops m32r_cmds
;
311 init_m32r_cmds (void)
313 m32r_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_REGISTER_VALUE_FIRST
;
314 m32r_cmds
.init
= m32r_inits
; /* Init strings */
315 m32r_cmds
.cont
= "go\r"; /* continue command */
316 m32r_cmds
.step
= "step\r"; /* single step */
317 m32r_cmds
.stop
= NULL
; /* interrupt command */
318 m32r_cmds
.set_break
= "%x +bp\r"; /* set a breakpoint */
319 m32r_cmds
.clr_break
= "%x -bp\r"; /* clear a breakpoint */
320 m32r_cmds
.clr_all_break
= "bpoff\r"; /* clear all breakpoints */
321 m32r_cmds
.fill
= "%x %x %x fill\r"; /* fill (start length val) */
322 m32r_cmds
.setmem
.cmdb
= "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */
323 m32r_cmds
.setmem
.cmdw
= "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
324 m32r_cmds
.setmem
.cmdl
= "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
325 m32r_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
326 m32r_cmds
.setmem
.resp_delim
= NULL
; /* setmem.resp_delim */
327 m32r_cmds
.setmem
.term
= NULL
; /* setmem.term */
328 m32r_cmds
.setmem
.term_cmd
= NULL
; /* setmem.term_cmd */
329 m32r_cmds
.getmem
.cmdb
= "%x %x dump\r"; /* getmem.cmdb (addr, len) */
330 m32r_cmds
.getmem
.cmdw
= NULL
; /* getmem.cmdw (addr, len) */
331 m32r_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, len) */
332 m32r_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, len) */
333 m32r_cmds
.getmem
.resp_delim
= ": "; /* getmem.resp_delim */
334 m32r_cmds
.getmem
.term
= NULL
; /* getmem.term */
335 m32r_cmds
.getmem
.term_cmd
= NULL
; /* getmem.term_cmd */
336 m32r_cmds
.setreg
.cmd
= "%x to %%%s\r"; /* setreg.cmd (name, value) */
337 m32r_cmds
.setreg
.resp_delim
= NULL
; /* setreg.resp_delim */
338 m32r_cmds
.setreg
.term
= NULL
; /* setreg.term */
339 m32r_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
340 m32r_cmds
.getreg
.cmd
= NULL
; /* getreg.cmd (name) */
341 m32r_cmds
.getreg
.resp_delim
= NULL
; /* getreg.resp_delim */
342 m32r_cmds
.getreg
.term
= NULL
; /* getreg.term */
343 m32r_cmds
.getreg
.term_cmd
= NULL
; /* getreg.term_cmd */
344 m32r_cmds
.dump_registers
= ".reg\r"; /* dump_registers */
345 /* register_pattern */
346 m32r_cmds
.register_pattern
= "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
347 m32r_cmds
.supply_register
= m32r_supply_register
;
348 m32r_cmds
.load
= NULL
; /* download command */
349 m32r_cmds
.loadresp
= NULL
; /* load response */
350 m32r_cmds
.prompt
= "ok "; /* monitor command prompt */
351 m32r_cmds
.line_term
= "\r"; /* end-of-line terminator */
352 m32r_cmds
.cmd_end
= NULL
; /* optional command terminator */
353 m32r_cmds
.target
= &m32r_ops
; /* target operations */
354 m32r_cmds
.stopbits
= SERIAL_1_STOPBITS
; /* number of stop bits */
355 m32r_cmds
.regnames
= m32r_regnames
; /* registers names */
356 m32r_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
357 } /* init_m32r_cmds */
360 m32r_open (const char *args
, int from_tty
)
362 monitor_open (args
, &m32r_cmds
, from_tty
);
365 /* Mon2000 monitor (MSA2000 board) */
367 static struct target_ops mon2000_ops
;
368 static struct monitor_ops mon2000_cmds
;
371 init_mon2000_cmds (void)
373 mon2000_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_REGISTER_VALUE_FIRST
;
374 mon2000_cmds
.init
= m32r_inits
; /* Init strings */
375 mon2000_cmds
.cont
= "go\r"; /* continue command */
376 mon2000_cmds
.step
= "step\r"; /* single step */
377 mon2000_cmds
.stop
= NULL
; /* interrupt command */
378 mon2000_cmds
.set_break
= "%x +bp\r"; /* set a breakpoint */
379 mon2000_cmds
.clr_break
= "%x -bp\r"; /* clear a breakpoint */
380 mon2000_cmds
.clr_all_break
= "bpoff\r"; /* clear all breakpoints */
381 mon2000_cmds
.fill
= "%x %x %x fill\r"; /* fill (start length val) */
382 mon2000_cmds
.setmem
.cmdb
= "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */
383 mon2000_cmds
.setmem
.cmdw
= "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
384 mon2000_cmds
.setmem
.cmdl
= "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
385 mon2000_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
386 mon2000_cmds
.setmem
.resp_delim
= NULL
; /* setmem.resp_delim */
387 mon2000_cmds
.setmem
.term
= NULL
; /* setmem.term */
388 mon2000_cmds
.setmem
.term_cmd
= NULL
; /* setmem.term_cmd */
389 mon2000_cmds
.getmem
.cmdb
= "%x %x dump\r"; /* getmem.cmdb (addr, len) */
390 mon2000_cmds
.getmem
.cmdw
= NULL
; /* getmem.cmdw (addr, len) */
391 mon2000_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, len) */
392 mon2000_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, len) */
393 mon2000_cmds
.getmem
.resp_delim
= ": "; /* getmem.resp_delim */
394 mon2000_cmds
.getmem
.term
= NULL
; /* getmem.term */
395 mon2000_cmds
.getmem
.term_cmd
= NULL
; /* getmem.term_cmd */
396 mon2000_cmds
.setreg
.cmd
= "%x to %%%s\r"; /* setreg.cmd (name, value) */
397 mon2000_cmds
.setreg
.resp_delim
= NULL
; /* setreg.resp_delim */
398 mon2000_cmds
.setreg
.term
= NULL
; /* setreg.term */
399 mon2000_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
400 mon2000_cmds
.getreg
.cmd
= NULL
; /* getreg.cmd (name) */
401 mon2000_cmds
.getreg
.resp_delim
= NULL
; /* getreg.resp_delim */
402 mon2000_cmds
.getreg
.term
= NULL
; /* getreg.term */
403 mon2000_cmds
.getreg
.term_cmd
= NULL
; /* getreg.term_cmd */
404 mon2000_cmds
.dump_registers
= ".reg\r"; /* dump_registers */
405 /* register_pattern */
406 mon2000_cmds
.register_pattern
= "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
407 mon2000_cmds
.supply_register
= m32r_supply_register
;
408 mon2000_cmds
.load
= NULL
; /* download command */
409 mon2000_cmds
.loadresp
= NULL
; /* load response */
410 mon2000_cmds
.prompt
= "Mon2000>"; /* monitor command prompt */
411 mon2000_cmds
.line_term
= "\r"; /* end-of-line terminator */
412 mon2000_cmds
.cmd_end
= NULL
; /* optional command terminator */
413 mon2000_cmds
.target
= &mon2000_ops
; /* target operations */
414 mon2000_cmds
.stopbits
= SERIAL_1_STOPBITS
; /* number of stop bits */
415 mon2000_cmds
.regnames
= m32r_regnames
; /* registers names */
416 mon2000_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
417 } /* init_mon2000_cmds */
420 mon2000_open (const char *args
, int from_tty
)
422 monitor_open (args
, &mon2000_cmds
, from_tty
);
426 m32r_upload_command (char *args
, int from_tty
)
430 struct timeval start_time
, end_time
;
431 int resp_len
, data_count
= 0;
433 struct hostent
*hostent
;
434 struct in_addr inet_addr
;
435 struct cleanup
*cleanup
;
437 /* First check to see if there's an ethernet port! */
438 monitor_printf ("ust\r");
439 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
440 if (!strchr (buf
, ':'))
441 error (_("No ethernet connection!"));
445 /* Scan second colon in the output from the "ust" command. */
446 char *myIPaddress
= strchr (strchr (buf
, ':') + 1, ':') + 1;
448 myIPaddress
= skip_spaces (myIPaddress
);
450 if (!strncmp (myIPaddress
, "0.0.", 4)) /* empty */
451 error (_("Please use 'set board-address' to "
452 "set the M32R-EVA board's IP address."));
453 if (strchr (myIPaddress
, '('))
454 *(strchr (myIPaddress
, '(')) = '\0'; /* delete trailing junk */
455 board_addr
= xstrdup (myIPaddress
);
457 if (server_addr
== 0)
461 /* Winsock initialization. */
462 if (WSAStartup (MAKEWORD (1, 1), &wd
))
463 error (_("Couldn't initialize WINSOCK."));
467 gethostname (buf
, sizeof (buf
));
470 hostent
= gethostbyname (buf
);
474 memcpy (&inet_addr
.s_addr
, hostent
->h_addr
,
475 sizeof (inet_addr
.s_addr
));
476 server_addr
= (char *) inet_ntoa (inet_addr
);
478 server_addr
= (char *) inet_ntoa (hostent
->h_addr
);
482 if (server_addr
== 0) /* failed? */
483 error (_("Need to know gdb host computer's "
484 "IP address (use 'set server-address')"));
487 if (args
== 0 || args
[0] == 0) /* No args: upload the current
489 args
= get_exec_file (1);
491 if (args
[0] != '/' && download_path
== 0)
493 if (current_directory
)
494 download_path
= xstrdup (current_directory
);
496 error (_("Need to know default download "
497 "path (use 'set download-path')"));
500 gettimeofday (&start_time
, NULL
);
501 monitor_printf ("uhip %s\r", server_addr
);
502 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
503 monitor_printf ("ulip %s\r", board_addr
);
504 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
506 monitor_printf ("up %s\r", download_path
); /* use default path */
508 monitor_printf ("up\r"); /* rooted filename/path */
509 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
511 if (strrchr (args
, '.') && !strcmp (strrchr (args
, '.'), ".srec"))
512 monitor_printf ("ul %s\r", args
);
513 else /* add ".srec" suffix */
514 monitor_printf ("ul %s.srec\r", args
);
515 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
517 if (buf
[0] == 0 || strstr (buf
, "complete") == 0)
518 error (_("Upload file not found: %s.srec\n"
519 "Check IP addresses and download path."),
522 printf_filtered (" -- Ethernet load complete.\n");
524 gettimeofday (&end_time
, NULL
);
525 abfd
= gdb_bfd_open (args
, NULL
, -1);
526 cleanup
= make_cleanup_bfd_unref (abfd
);
528 { /* Download is done -- print section statistics. */
529 if (bfd_check_format (abfd
, bfd_object
) == 0)
531 printf_filtered ("File is not an object file\n");
533 for (s
= abfd
->sections
; s
; s
= s
->next
)
534 if (s
->flags
& SEC_LOAD
)
536 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
537 bfd_vma section_base
= bfd_section_lma (abfd
, s
);
539 data_count
+= section_size
;
541 printf_filtered ("Loading section %s, size 0x%lx lma ",
542 bfd_section_name (abfd
, s
),
543 (unsigned long) section_size
);
544 fputs_filtered (paddress (target_gdbarch (), section_base
),
546 printf_filtered ("\n");
547 gdb_flush (gdb_stdout
);
549 /* Finally, make the PC point at the start address. */
550 regcache_write_pc (get_current_regcache (),
551 bfd_get_start_address (abfd
));
552 printf_filtered ("Start address 0x%lx\n",
553 (unsigned long) bfd_get_start_address (abfd
));
554 print_transfer_performance (gdb_stdout
, data_count
, 0, &start_time
,
557 inferior_ptid
= null_ptid
; /* No process now. */
559 /* This is necessary because many things were based on the PC at the
560 time that we attached to the monitor, which is no longer valid
561 now that we have loaded new code (and just changed the PC).
562 Another way to do this might be to call normal_stop, except that
563 the stack may not be valid, and things would get horribly
566 clear_symtab_users (0);
567 do_cleanups (cleanup
);
570 /* Provide a prototype to silence -Wmissing-prototypes. */
571 extern initialize_file_ftype _initialize_m32r_rom
;
574 _initialize_m32r_rom (void)
576 /* Initialize m32r RevC monitor target. */
578 init_monitor_ops (&m32r_ops
);
580 m32r_ops
.to_shortname
= "m32r";
581 m32r_ops
.to_longname
= "m32r monitor";
582 m32r_ops
.to_load
= m32r_load_gen
; /* Monitor lacks a download
584 m32r_ops
.to_doc
= "Debug via the m32r monitor.\n\
585 Specify the serial device it is connected to (e.g. /dev/ttya).";
586 m32r_ops
.to_open
= m32r_open
;
587 add_target (&m32r_ops
);
589 /* Initialize mon2000 monitor target */
590 init_mon2000_cmds ();
591 init_monitor_ops (&mon2000_ops
);
593 mon2000_ops
.to_shortname
= "mon2000";
594 mon2000_ops
.to_longname
= "Mon2000 monitor";
595 mon2000_ops
.to_load
= m32r_load_gen
; /* Monitor lacks a download
597 mon2000_ops
.to_doc
= "Debug via the Mon2000 monitor.\n\
598 Specify the serial device it is connected to (e.g. /dev/ttya).";
599 mon2000_ops
.to_open
= mon2000_open
;
600 add_target (&mon2000_ops
);
602 add_setshow_string_cmd ("download-path", class_obscure
, &download_path
, _("\
603 Set the default path for downloadable SREC files."), _("\
604 Show the default path for downloadable SREC files."), _("\
605 Determines the default path for downloadable SREC files."),
607 NULL
, /* FIXME: i18n: The default path for
608 downloadable SREC files is %s. */
609 &setlist
, &showlist
);
611 add_setshow_string_cmd ("board-address", class_obscure
, &board_addr
, _("\
612 Set IP address for M32R-EVA target board."), _("\
613 Show IP address for M32R-EVA target board."), _("\
614 Determine the IP address for M32R-EVA target board."),
616 NULL
, /* FIXME: i18n: IP address for
617 M32R-EVA target board is %s. */
618 &setlist
, &showlist
);
620 add_setshow_string_cmd ("server-address", class_obscure
, &server_addr
, _("\
621 Set IP address for download server (GDB's host computer)."), _("\
622 Show IP address for download server (GDB's host computer)."), _("\
623 Determine the IP address for download server (GDB's host computer)."),
625 NULL
, /* FIXME: i18n: IP address for
626 download server (GDB's host
628 &setlist
, &showlist
);
630 add_com ("upload", class_obscure
, m32r_upload_command
, _("\
631 Upload the srec file via the monitor's Ethernet upload capability."));
633 add_com ("tload", class_obscure
, m32r_load
, _("test upload command."));