1 /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
4 Copyright (C) 1996-2001, 2004-2005, 2007-2012 Free Software
7 Adapted by Michael Snyder of Cygnus Support.
9 This file is part of GDB.
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
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
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.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 /* This module defines communication with the Renesas m32r monitor. */
29 #include "exceptions.h"
35 #include "symfile.h" /* for generic load */
37 #include <time.h> /* for time_t */
38 #include "gdb_string.h"
39 #include "objfiles.h" /* for ALL_OBJFILES etc. */
46 * All this stuff just to get my host computer's IP address!
51 #include <sys/types.h>
52 #include <netdb.h> /* for hostent */
53 #include <netinet/in.h> /* for struct in_addr */
55 #include <arpa/inet.h> /* for inet_ntoa */
59 static char *board_addr
; /* user-settable IP address for M32R-EVA */
60 static char *server_addr
; /* user-settable IP address for gdb host */
61 static char *download_path
; /* user-settable path for SREC files */
68 #define ACCL_REGNUM 22
69 #define ACCH_REGNUM 23
73 * Function: m32r_load_1 (helper function)
77 m32r_load_section (bfd
*abfd
, asection
*s
, void *obj
)
79 unsigned int *data_count
= obj
;
80 if (s
->flags
& SEC_LOAD
)
82 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
83 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
84 bfd_vma section_base
= bfd_section_lma (abfd
, s
);
85 unsigned int buffer
, i
;
87 *data_count
+= section_size
;
89 printf_filtered ("Loading section %s, size 0x%lx lma ",
90 bfd_section_name (abfd
, s
),
91 (unsigned long) section_size
);
92 fputs_filtered (paddress (target_gdbarch
, section_base
), gdb_stdout
);
93 printf_filtered ("\n");
94 gdb_flush (gdb_stdout
);
95 monitor_printf ("%s mw\r", phex_nz (section_base
, addr_size
));
96 for (i
= 0; i
< section_size
; i
+= 4)
99 monitor_expect (" -> ", NULL
, 0);
100 bfd_get_section_contents (abfd
, s
, (char *) &buffer
, i
, 4);
101 monitor_printf ("%x\n", buffer
);
103 monitor_expect (" -> ", NULL
, 0);
104 monitor_printf ("q\n");
105 monitor_expect_prompt (NULL
, 0);
110 m32r_load_1 (void *dummy
)
114 bfd_map_over_sections ((bfd
*) dummy
, m32r_load_section
, &data_count
);
119 * Function: m32r_load (an alternate way to load)
123 m32r_load (char *filename
, int from_tty
)
126 unsigned int data_count
= 0;
127 struct timeval start_time
, end_time
;
129 if (filename
== NULL
|| filename
[0] == 0)
130 filename
= get_exec_file (1);
132 abfd
= gdb_bfd_ref (bfd_openr (filename
, 0));
134 error (_("Unable to open file %s."), filename
);
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");
171 gettimeofday (&end_time
, NULL
);
172 printf_filtered ("Start address 0x%lx\n",
173 (unsigned long) bfd_get_start_address (abfd
));
174 print_transfer_performance (gdb_stdout
, data_count
, 0, &start_time
,
177 /* Finally, make the PC point at the start address. */
179 regcache_write_pc (get_current_regcache (),
180 bfd_get_start_address (exec_bfd
));
182 inferior_ptid
= null_ptid
; /* No process now. */
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
191 clear_symtab_users (0);
195 m32r_load_gen (char *filename
, int from_tty
)
197 generic_load (filename
, from_tty
);
200 static void m32r_open (char *args
, int from_tty
);
201 static void mon2000_open (char *args
, int from_tty
);
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". */
208 static 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",
215 m32r_supply_register (struct regcache
*regcache
, char *regname
,
216 int regnamelen
, char *val
, int vallen
)
219 int num_regs
= sizeof (m32r_regnames
) / sizeof (m32r_regnames
[0]);
220 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
222 for (regno
= 0; regno
< num_regs
; regno
++)
223 if (strncmp (regname
, m32r_regnames
[regno
], regnamelen
) == 0)
226 if (regno
>= num_regs
)
227 return; /* no match */
229 if (regno
== ACCL_REGNUM
)
230 { /* Special handling for 64-bit acc reg. */
231 monitor_supply_register (regcache
, ACCH_REGNUM
, val
);
232 val
= strchr (val
, ':'); /* Skip past ':' to get 2nd word. */
234 monitor_supply_register (regcache
, ACCL_REGNUM
, val
+ 1);
238 monitor_supply_register (regcache
, regno
, val
);
239 if (regno
== PSW_REGNUM
)
241 #if (defined SM_REGNUM || defined BSM_REGNUM || defined IE_REGNUM \
242 || defined BIE_REGNUM || defined COND_REGNUM || defined CBR_REGNUM \
243 || defined BPC_REGNUM || defined BCARRY_REGNUM)
244 unsigned long psw
= strtoul (val
, NULL
, 16);
245 char *zero
= "00000000", *one
= "00000001";
250 monitor_supply_register (regcache
, SM_REGNUM
,
251 (psw
& 0x80) ? one
: zero
);
254 /* Backup stack mode bit */
255 monitor_supply_register (regcache
, BSM_REGNUM
,
256 (psw
& 0x8000) ? one
: zero
);
259 /* Interrupt enable bit */
260 monitor_supply_register (regcache
, IE_REGNUM
,
261 (psw
& 0x40) ? one
: zero
);
264 /* Backup interrupt enable bit */
265 monitor_supply_register (regcache
, BIE_REGNUM
,
266 (psw
& 0x4000) ? one
: zero
);
269 /* Condition bit (carry etc.) */
270 monitor_supply_register (regcache
, COND_REGNUM
,
271 (psw
& 0x1) ? one
: zero
);
274 monitor_supply_register (regcache
, CBR_REGNUM
,
275 (psw
& 0x1) ? one
: zero
);
278 monitor_supply_register (regcache
, BPC_REGNUM
,
279 zero
); /* KLUDGE: (???????) */
282 monitor_supply_register (regcache
, BCARRY_REGNUM
,
283 zero
); /* KLUDGE: (??????) */
287 if (regno
== SPI_REGNUM
|| regno
== SPU_REGNUM
)
288 { /* special handling for stack pointer (spu or spi). */
289 ULONGEST stackmode
, psw
;
290 regcache_cooked_read_unsigned (regcache
, PSW_REGNUM
, &psw
);
291 stackmode
= psw
& 0x80;
293 if (regno
== SPI_REGNUM
&& !stackmode
) /* SP == SPI */
294 monitor_supply_register (regcache
,
295 gdbarch_sp_regnum (gdbarch
), val
);
296 else if (regno
== SPU_REGNUM
&& stackmode
) /* SP == SPU */
297 monitor_supply_register (regcache
,
298 gdbarch_sp_regnum (gdbarch
), val
);
303 /* m32r RevC board monitor */
305 static struct target_ops m32r_ops
;
307 static char *m32r_inits
[] = { "\r", NULL
};
309 static struct monitor_ops m32r_cmds
;
312 init_m32r_cmds (void)
314 m32r_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_REGISTER_VALUE_FIRST
;
315 m32r_cmds
.init
= m32r_inits
; /* Init strings */
316 m32r_cmds
.cont
= "go\r"; /* continue command */
317 m32r_cmds
.step
= "step\r"; /* single step */
318 m32r_cmds
.stop
= NULL
; /* interrupt command */
319 m32r_cmds
.set_break
= "%x +bp\r"; /* set a breakpoint */
320 m32r_cmds
.clr_break
= "%x -bp\r"; /* clear a breakpoint */
321 m32r_cmds
.clr_all_break
= "bpoff\r"; /* clear all breakpoints */
322 m32r_cmds
.fill
= "%x %x %x fill\r"; /* fill (start length val) */
323 m32r_cmds
.setmem
.cmdb
= "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */
324 m32r_cmds
.setmem
.cmdw
= "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
325 m32r_cmds
.setmem
.cmdl
= "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
326 m32r_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
327 m32r_cmds
.setmem
.resp_delim
= NULL
; /* setmem.resp_delim */
328 m32r_cmds
.setmem
.term
= NULL
; /* setmem.term */
329 m32r_cmds
.setmem
.term_cmd
= NULL
; /* setmem.term_cmd */
330 m32r_cmds
.getmem
.cmdb
= "%x %x dump\r"; /* getmem.cmdb (addr, len) */
331 m32r_cmds
.getmem
.cmdw
= NULL
; /* getmem.cmdw (addr, len) */
332 m32r_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, len) */
333 m32r_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, len) */
334 m32r_cmds
.getmem
.resp_delim
= ": "; /* getmem.resp_delim */
335 m32r_cmds
.getmem
.term
= NULL
; /* getmem.term */
336 m32r_cmds
.getmem
.term_cmd
= NULL
; /* getmem.term_cmd */
337 m32r_cmds
.setreg
.cmd
= "%x to %%%s\r"; /* setreg.cmd (name, value) */
338 m32r_cmds
.setreg
.resp_delim
= NULL
; /* setreg.resp_delim */
339 m32r_cmds
.setreg
.term
= NULL
; /* setreg.term */
340 m32r_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
341 m32r_cmds
.getreg
.cmd
= NULL
; /* getreg.cmd (name) */
342 m32r_cmds
.getreg
.resp_delim
= NULL
; /* getreg.resp_delim */
343 m32r_cmds
.getreg
.term
= NULL
; /* getreg.term */
344 m32r_cmds
.getreg
.term_cmd
= NULL
; /* getreg.term_cmd */
345 m32r_cmds
.dump_registers
= ".reg\r"; /* dump_registers */
346 /* register_pattern */
347 m32r_cmds
.register_pattern
= "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
348 m32r_cmds
.supply_register
= m32r_supply_register
;
349 m32r_cmds
.load_routine
= NULL
; /* load_routine (defaults to SRECs) */
350 m32r_cmds
.load
= NULL
; /* download command */
351 m32r_cmds
.loadresp
= NULL
; /* load response */
352 m32r_cmds
.prompt
= "ok "; /* monitor command prompt */
353 m32r_cmds
.line_term
= "\r"; /* end-of-line terminator */
354 m32r_cmds
.cmd_end
= NULL
; /* optional command terminator */
355 m32r_cmds
.target
= &m32r_ops
; /* target operations */
356 m32r_cmds
.stopbits
= SERIAL_1_STOPBITS
; /* number of stop bits */
357 m32r_cmds
.regnames
= m32r_regnames
; /* registers names */
358 m32r_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
359 } /* init_m32r_cmds */
362 m32r_open (char *args
, int from_tty
)
364 monitor_open (args
, &m32r_cmds
, from_tty
);
367 /* Mon2000 monitor (MSA2000 board) */
369 static struct target_ops mon2000_ops
;
370 static struct monitor_ops mon2000_cmds
;
373 init_mon2000_cmds (void)
375 mon2000_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_REGISTER_VALUE_FIRST
;
376 mon2000_cmds
.init
= m32r_inits
; /* Init strings */
377 mon2000_cmds
.cont
= "go\r"; /* continue command */
378 mon2000_cmds
.step
= "step\r"; /* single step */
379 mon2000_cmds
.stop
= NULL
; /* interrupt command */
380 mon2000_cmds
.set_break
= "%x +bp\r"; /* set a breakpoint */
381 mon2000_cmds
.clr_break
= "%x -bp\r"; /* clear a breakpoint */
382 mon2000_cmds
.clr_all_break
= "bpoff\r"; /* clear all breakpoints */
383 mon2000_cmds
.fill
= "%x %x %x fill\r"; /* fill (start length val) */
384 mon2000_cmds
.setmem
.cmdb
= "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */
385 mon2000_cmds
.setmem
.cmdw
= "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
386 mon2000_cmds
.setmem
.cmdl
= "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
387 mon2000_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
388 mon2000_cmds
.setmem
.resp_delim
= NULL
; /* setmem.resp_delim */
389 mon2000_cmds
.setmem
.term
= NULL
; /* setmem.term */
390 mon2000_cmds
.setmem
.term_cmd
= NULL
; /* setmem.term_cmd */
391 mon2000_cmds
.getmem
.cmdb
= "%x %x dump\r"; /* getmem.cmdb (addr, len) */
392 mon2000_cmds
.getmem
.cmdw
= NULL
; /* getmem.cmdw (addr, len) */
393 mon2000_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, len) */
394 mon2000_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, len) */
395 mon2000_cmds
.getmem
.resp_delim
= ": "; /* getmem.resp_delim */
396 mon2000_cmds
.getmem
.term
= NULL
; /* getmem.term */
397 mon2000_cmds
.getmem
.term_cmd
= NULL
; /* getmem.term_cmd */
398 mon2000_cmds
.setreg
.cmd
= "%x to %%%s\r"; /* setreg.cmd (name, value) */
399 mon2000_cmds
.setreg
.resp_delim
= NULL
; /* setreg.resp_delim */
400 mon2000_cmds
.setreg
.term
= NULL
; /* setreg.term */
401 mon2000_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
402 mon2000_cmds
.getreg
.cmd
= NULL
; /* getreg.cmd (name) */
403 mon2000_cmds
.getreg
.resp_delim
= NULL
; /* getreg.resp_delim */
404 mon2000_cmds
.getreg
.term
= NULL
; /* getreg.term */
405 mon2000_cmds
.getreg
.term_cmd
= NULL
; /* getreg.term_cmd */
406 mon2000_cmds
.dump_registers
= ".reg\r"; /* dump_registers */
407 /* register_pattern */
408 mon2000_cmds
.register_pattern
= "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
409 mon2000_cmds
.supply_register
= m32r_supply_register
;
410 mon2000_cmds
.load_routine
= NULL
; /* load_routine (defaults to SRECs) */
411 mon2000_cmds
.load
= NULL
; /* download command */
412 mon2000_cmds
.loadresp
= NULL
; /* load response */
413 mon2000_cmds
.prompt
= "Mon2000>"; /* monitor command prompt */
414 mon2000_cmds
.line_term
= "\r"; /* end-of-line terminator */
415 mon2000_cmds
.cmd_end
= NULL
; /* optional command terminator */
416 mon2000_cmds
.target
= &mon2000_ops
; /* target operations */
417 mon2000_cmds
.stopbits
= SERIAL_1_STOPBITS
; /* number of stop bits */
418 mon2000_cmds
.regnames
= m32r_regnames
; /* registers names */
419 mon2000_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
420 } /* init_mon2000_cmds */
423 mon2000_open (char *args
, int from_tty
)
425 monitor_open (args
, &mon2000_cmds
, from_tty
);
429 m32r_upload_command (char *args
, int from_tty
)
433 struct timeval start_time
, end_time
;
434 int resp_len
, data_count
= 0;
436 struct hostent
*hostent
;
437 struct in_addr inet_addr
;
439 /* First check to see if there's an ethernet port! */
440 monitor_printf ("ust\r");
441 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
442 if (!strchr (buf
, ':'))
443 error (_("No ethernet connection!"));
447 /* Scan second colon in the output from the "ust" command. */
448 char *myIPaddress
= strchr (strchr (buf
, ':') + 1, ':') + 1;
450 while (isspace (*myIPaddress
))
453 if (!strncmp (myIPaddress
, "0.0.", 4)) /* empty */
454 error (_("Please use 'set board-address' to "
455 "set the M32R-EVA board's IP address."));
456 if (strchr (myIPaddress
, '('))
457 *(strchr (myIPaddress
, '(')) = '\0'; /* delete trailing junk */
458 board_addr
= xstrdup (myIPaddress
);
460 if (server_addr
== 0)
464 /* Winsock initialization. */
465 if (WSAStartup (MAKEWORD (1, 1), &wd
))
466 error (_("Couldn't initialize WINSOCK."));
470 gethostname (buf
, sizeof (buf
));
473 hostent
= gethostbyname (buf
);
477 memcpy (&inet_addr
.s_addr
, hostent
->h_addr
,
478 sizeof (inet_addr
.s_addr
));
479 server_addr
= (char *) inet_ntoa (inet_addr
);
481 server_addr
= (char *) inet_ntoa (hostent
->h_addr
);
485 if (server_addr
== 0) /* failed? */
486 error (_("Need to know gdb host computer's "
487 "IP address (use 'set server-address')"));
490 if (args
== 0 || args
[0] == 0) /* No args: upload the current
492 args
= get_exec_file (1);
494 if (args
[0] != '/' && download_path
== 0)
496 if (current_directory
)
497 download_path
= xstrdup (current_directory
);
499 error (_("Need to know default download "
500 "path (use 'set download-path')"));
503 gettimeofday (&start_time
, NULL
);
504 monitor_printf ("uhip %s\r", server_addr
);
505 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
506 monitor_printf ("ulip %s\r", board_addr
);
507 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
509 monitor_printf ("up %s\r", download_path
); /* use default path */
511 monitor_printf ("up\r"); /* rooted filename/path */
512 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
514 if (strrchr (args
, '.') && !strcmp (strrchr (args
, '.'), ".srec"))
515 monitor_printf ("ul %s\r", args
);
516 else /* add ".srec" suffix */
517 monitor_printf ("ul %s.srec\r", args
);
518 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
520 if (buf
[0] == 0 || strstr (buf
, "complete") == 0)
521 error (_("Upload file not found: %s.srec\n"
522 "Check IP addresses and download path."),
525 printf_filtered (" -- Ethernet load complete.\n");
527 gettimeofday (&end_time
, NULL
);
528 abfd
= gdb_bfd_ref (bfd_openr (args
, 0));
530 { /* Download is done -- print section statistics. */
531 if (bfd_check_format (abfd
, bfd_object
) == 0)
533 printf_filtered ("File is not an object file\n");
535 for (s
= abfd
->sections
; s
; s
= s
->next
)
536 if (s
->flags
& SEC_LOAD
)
538 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
539 bfd_vma section_base
= bfd_section_lma (abfd
, s
);
541 data_count
+= section_size
;
543 printf_filtered ("Loading section %s, size 0x%lx lma ",
544 bfd_section_name (abfd
, s
),
545 (unsigned long) section_size
);
546 fputs_filtered (paddress (target_gdbarch
, section_base
),
548 printf_filtered ("\n");
549 gdb_flush (gdb_stdout
);
551 /* Finally, make the PC point at the start address. */
552 regcache_write_pc (get_current_regcache (),
553 bfd_get_start_address (abfd
));
554 printf_filtered ("Start address 0x%lx\n",
555 (unsigned long) bfd_get_start_address (abfd
));
556 print_transfer_performance (gdb_stdout
, data_count
, 0, &start_time
,
559 inferior_ptid
= null_ptid
; /* No process now. */
561 /* This is necessary because many things were based on the PC at the
562 time that we attached to the monitor, which is no longer valid
563 now that we have loaded new code (and just changed the PC).
564 Another way to do this might be to call normal_stop, except that
565 the stack may not be valid, and things would get horribly
568 clear_symtab_users (0);
571 /* Provide a prototype to silence -Wmissing-prototypes. */
572 extern initialize_file_ftype _initialize_m32r_rom
;
575 _initialize_m32r_rom (void)
577 /* Initialize m32r RevC monitor target. */
579 init_monitor_ops (&m32r_ops
);
581 m32r_ops
.to_shortname
= "m32r";
582 m32r_ops
.to_longname
= "m32r monitor";
583 m32r_ops
.to_load
= m32r_load_gen
; /* Monitor lacks a download
585 m32r_ops
.to_doc
= "Debug via the m32r monitor.\n\
586 Specify the serial device it is connected to (e.g. /dev/ttya).";
587 m32r_ops
.to_open
= m32r_open
;
588 add_target (&m32r_ops
);
590 /* Initialize mon2000 monitor target */
591 init_mon2000_cmds ();
592 init_monitor_ops (&mon2000_ops
);
594 mon2000_ops
.to_shortname
= "mon2000";
595 mon2000_ops
.to_longname
= "Mon2000 monitor";
596 mon2000_ops
.to_load
= m32r_load_gen
; /* Monitor lacks a download
598 mon2000_ops
.to_doc
= "Debug via the Mon2000 monitor.\n\
599 Specify the serial device it is connected to (e.g. /dev/ttya).";
600 mon2000_ops
.to_open
= mon2000_open
;
601 add_target (&mon2000_ops
);
603 add_setshow_string_cmd ("download-path", class_obscure
, &download_path
, _("\
604 Set the default path for downloadable SREC files."), _("\
605 Show the default path for downloadable SREC files."), _("\
606 Determines the default path for downloadable SREC files."),
608 NULL
, /* FIXME: i18n: The default path for
609 downloadable SREC files is %s. */
610 &setlist
, &showlist
);
612 add_setshow_string_cmd ("board-address", class_obscure
, &board_addr
, _("\
613 Set IP address for M32R-EVA target board."), _("\
614 Show IP address for M32R-EVA target board."), _("\
615 Determine the IP address for M32R-EVA target board."),
617 NULL
, /* FIXME: i18n: IP address for
618 M32R-EVA target board is %s. */
619 &setlist
, &showlist
);
621 add_setshow_string_cmd ("server-address", class_obscure
, &server_addr
, _("\
622 Set IP address for download server (GDB's host computer)."), _("\
623 Show IP address for download server (GDB's host computer)."), _("\
624 Determine the IP address for download server (GDB's host computer)."),
626 NULL
, /* FIXME: i18n: IP address for
627 download server (GDB's host
629 &setlist
, &showlist
);
631 add_com ("upload", class_obscure
, m32r_upload_command
, _("\
632 Upload the srec file via the monitor's Ethernet upload capability."));
634 add_com ("tload", class_obscure
, m32r_load
, _("test upload command."));