1 /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001
4 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 2 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, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* This module defines communication with the Mitsubishi m32r monitor */
35 #include "symfile.h" /* for generic load */
36 #include <time.h> /* for time_t */
37 #include "gdb_string.h"
38 #include "objfiles.h" /* for ALL_OBJFILES etc. */
39 #include "inferior.h" /* for write_pc() */
43 extern void report_transfer_performance (unsigned long, time_t, time_t);
47 * 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 */
63 * Function: m32r_load_1 (helper function)
67 m32r_load_section (bfd
*abfd
, asection
*s
, void *obj
)
69 unsigned int *data_count
= obj
;
70 if (s
->flags
& SEC_LOAD
)
72 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
73 bfd_vma section_base
= bfd_section_lma (abfd
, s
);
74 unsigned int buffer
, i
;
76 *data_count
+= section_size
;
78 printf_filtered ("Loading section %s, size 0x%lx lma ",
79 bfd_section_name (abfd
, s
), section_size
);
80 print_address_numeric (section_base
, 1, gdb_stdout
);
81 printf_filtered ("\n");
82 gdb_flush (gdb_stdout
);
83 monitor_printf ("%s mw\r", paddr_nz (section_base
));
84 for (i
= 0; i
< section_size
; i
+= 4)
87 monitor_expect (" -> ", NULL
, 0);
88 bfd_get_section_contents (abfd
, s
, (char *) &buffer
, i
, 4);
89 monitor_printf ("%x\n", buffer
);
91 monitor_expect (" -> ", NULL
, 0);
92 monitor_printf ("q\n");
93 monitor_expect_prompt (NULL
, 0);
98 m32r_load_1 (void *dummy
)
102 bfd_map_over_sections ((bfd
*) dummy
, m32r_load_section
, &data_count
);
107 * Function: m32r_load (an alternate way to load)
111 m32r_load (char *filename
, int from_tty
)
115 unsigned int i
, data_count
= 0;
116 time_t start_time
, end_time
; /* for timing of download */
118 if (filename
== NULL
|| filename
[0] == 0)
119 filename
= get_exec_file (1);
121 abfd
= bfd_openr (filename
, 0);
123 error ("Unable to open file %s\n", filename
);
124 if (bfd_check_format (abfd
, bfd_object
) == 0)
125 error ("File is not an object file\n");
126 start_time
= time (NULL
);
128 for (s
= abfd
->sections
; s
; s
= s
->next
)
129 if (s
->flags
& SEC_LOAD
)
131 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
132 bfd_vma section_base
= bfd_section_vma (abfd
, s
);
135 data_count
+= section_size
;
137 printf_filtered ("Loading section %s, size 0x%lx vma ",
138 bfd_section_name (abfd
, s
), section_size
);
139 print_address_numeric (section_base
, 1, gdb_stdout
);
140 printf_filtered ("\n");
141 gdb_flush (gdb_stdout
);
142 monitor_printf ("%x mw\r", section_base
);
143 for (i
= 0; i
< section_size
; i
+= 4)
145 monitor_expect (" -> ", NULL
, 0);
146 bfd_get_section_contents (abfd
, s
, (char *) &buffer
, i
, 4);
147 monitor_printf ("%x\n", buffer
);
149 monitor_expect (" -> ", NULL
, 0);
150 monitor_printf ("q\n");
151 monitor_expect_prompt (NULL
, 0);
154 if (!(catch_errors (m32r_load_1
, abfd
, "Load aborted!\n", RETURN_MASK_ALL
)))
156 monitor_printf ("q\n");
160 end_time
= time (NULL
);
161 printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd
));
162 report_transfer_performance (data_count
, start_time
, end_time
);
164 /* Finally, make the PC point at the start address */
166 write_pc (bfd_get_start_address (exec_bfd
));
168 inferior_ptid
= null_ptid
; /* No process now */
170 /* This is necessary because many things were based on the PC at the
171 time that we attached to the monitor, which is no longer valid
172 now that we have loaded new code (and just changed the PC).
173 Another way to do this might be to call normal_stop, except that
174 the stack may not be valid, and things would get horribly
177 clear_symtab_users ();
181 m32r_load_gen (char *filename
, int from_tty
)
183 generic_load (filename
, from_tty
);
186 static void m32r_open (char *args
, int from_tty
);
187 static void mon2000_open (char *args
, int from_tty
);
189 /* This array of registers needs to match the indexes used by GDB. The
190 whole reason this exists is because the various ROM monitors use
191 different names than GDB does, and don't support all the registers
192 either. So, typing "info reg sp" becomes an "A7". */
194 static char *m32r_regnames
[] =
195 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
196 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
197 "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
201 m32r_supply_register (char *regname
, int regnamelen
, char *val
, int vallen
)
204 int num_regs
= sizeof (m32r_regnames
) / sizeof (m32r_regnames
[0]);
206 for (regno
= 0; regno
< num_regs
; regno
++)
207 if (strncmp (regname
, m32r_regnames
[regno
], regnamelen
) == 0)
210 if (regno
>= num_regs
)
211 return; /* no match */
213 if (regno
== ACCL_REGNUM
)
214 { /* special handling for 64-bit acc reg */
215 monitor_supply_register (ACCH_REGNUM
, val
);
216 val
= strchr (val
, ':'); /* skip past ':' to get 2nd word */
218 monitor_supply_register (ACCL_REGNUM
, val
+ 1);
222 monitor_supply_register (regno
, val
);
223 if (regno
== PSW_REGNUM
)
225 unsigned long psw
= strtoul (val
, NULL
, 16);
226 char *zero
= "00000000", *one
= "00000001";
230 monitor_supply_register (SM_REGNUM
, (psw
& 0x80) ? one
: zero
);
233 /* Backup stack mode bit */
234 monitor_supply_register (BSM_REGNUM
, (psw
& 0x8000) ? one
: zero
);
237 /* Interrupt enable bit */
238 monitor_supply_register (IE_REGNUM
, (psw
& 0x40) ? one
: zero
);
241 /* Backup interrupt enable bit */
242 monitor_supply_register (BIE_REGNUM
, (psw
& 0x4000) ? one
: zero
);
245 /* Condition bit (carry etc.) */
246 monitor_supply_register (COND_REGNUM
, (psw
& 0x1) ? one
: zero
);
249 monitor_supply_register (CBR_REGNUM
, (psw
& 0x1) ? one
: zero
);
252 monitor_supply_register (BPC_REGNUM
, zero
); /* KLUDGE: (???????) */
255 monitor_supply_register (BCARRY_REGNUM
, zero
); /* KLUDGE: (??????) */
259 if (regno
== SPI_REGNUM
|| regno
== SPU_REGNUM
)
260 { /* special handling for stack pointer (spu or spi) */
261 unsigned long stackmode
= read_register (PSW_REGNUM
) & 0x80;
263 if (regno
== SPI_REGNUM
&& !stackmode
) /* SP == SPI */
264 monitor_supply_register (SP_REGNUM
, val
);
265 else if (regno
== SPU_REGNUM
&& stackmode
) /* SP == SPU */
266 monitor_supply_register (SP_REGNUM
, val
);
271 /* m32r RevC board monitor */
273 static struct target_ops m32r_ops
;
275 static char *m32r_inits
[] =
278 static struct monitor_ops m32r_cmds
;
281 init_m32r_cmds (void)
283 m32r_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_REGISTER_VALUE_FIRST
;
284 m32r_cmds
.init
= m32r_inits
; /* Init strings */
285 m32r_cmds
.cont
= "go\r"; /* continue command */
286 m32r_cmds
.step
= "step\r"; /* single step */
287 m32r_cmds
.stop
= NULL
; /* interrupt command */
288 m32r_cmds
.set_break
= "%x +bp\r"; /* set a breakpoint */
289 m32r_cmds
.clr_break
= "%x -bp\r"; /* clear a breakpoint */
290 m32r_cmds
.clr_all_break
= "bpoff\r"; /* clear all breakpoints */
291 m32r_cmds
.fill
= "%x %x %x fill\r"; /* fill (start length val) */
292 m32r_cmds
.setmem
.cmdb
= "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */
293 m32r_cmds
.setmem
.cmdw
= "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
294 m32r_cmds
.setmem
.cmdl
= "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
295 m32r_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
296 m32r_cmds
.setmem
.resp_delim
= NULL
; /* setmem.resp_delim */
297 m32r_cmds
.setmem
.term
= NULL
; /* setmem.term */
298 m32r_cmds
.setmem
.term_cmd
= NULL
; /* setmem.term_cmd */
299 m32r_cmds
.getmem
.cmdb
= "%x %x dump\r"; /* getmem.cmdb (addr, len) */
300 m32r_cmds
.getmem
.cmdw
= NULL
; /* getmem.cmdw (addr, len) */
301 m32r_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, len) */
302 m32r_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, len) */
303 m32r_cmds
.getmem
.resp_delim
= ": "; /* getmem.resp_delim */
304 m32r_cmds
.getmem
.term
= NULL
; /* getmem.term */
305 m32r_cmds
.getmem
.term_cmd
= NULL
; /* getmem.term_cmd */
306 m32r_cmds
.setreg
.cmd
= "%x to %%%s\r"; /* setreg.cmd (name, value) */
307 m32r_cmds
.setreg
.resp_delim
= NULL
; /* setreg.resp_delim */
308 m32r_cmds
.setreg
.term
= NULL
; /* setreg.term */
309 m32r_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
310 m32r_cmds
.getreg
.cmd
= NULL
; /* getreg.cmd (name) */
311 m32r_cmds
.getreg
.resp_delim
= NULL
; /* getreg.resp_delim */
312 m32r_cmds
.getreg
.term
= NULL
; /* getreg.term */
313 m32r_cmds
.getreg
.term_cmd
= NULL
; /* getreg.term_cmd */
314 m32r_cmds
.dump_registers
= ".reg\r"; /* dump_registers */
315 m32r_cmds
.register_pattern
= "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
316 m32r_cmds
.supply_register
= m32r_supply_register
; /* supply_register */
317 m32r_cmds
.load_routine
= NULL
; /* load_routine (defaults to SRECs) */
318 m32r_cmds
.load
= NULL
; /* download command */
319 m32r_cmds
.loadresp
= NULL
; /* load response */
320 m32r_cmds
.prompt
= "ok "; /* monitor command prompt */
321 m32r_cmds
.line_term
= "\r"; /* end-of-line terminator */
322 m32r_cmds
.cmd_end
= NULL
; /* optional command terminator */
323 m32r_cmds
.target
= &m32r_ops
; /* target operations */
324 m32r_cmds
.stopbits
= SERIAL_1_STOPBITS
; /* number of stop bits */
325 m32r_cmds
.regnames
= m32r_regnames
; /* registers names */
326 m32r_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
327 } /* init_m32r_cmds */
330 m32r_open (char *args
, int from_tty
)
332 monitor_open (args
, &m32r_cmds
, from_tty
);
335 /* Mon2000 monitor (MSA2000 board) */
337 static struct target_ops mon2000_ops
;
338 static struct monitor_ops mon2000_cmds
;
341 init_mon2000_cmds (void)
343 mon2000_cmds
.flags
= MO_CLR_BREAK_USES_ADDR
| MO_REGISTER_VALUE_FIRST
;
344 mon2000_cmds
.init
= m32r_inits
; /* Init strings */
345 mon2000_cmds
.cont
= "go\r"; /* continue command */
346 mon2000_cmds
.step
= "step\r"; /* single step */
347 mon2000_cmds
.stop
= NULL
; /* interrupt command */
348 mon2000_cmds
.set_break
= "%x +bp\r"; /* set a breakpoint */
349 mon2000_cmds
.clr_break
= "%x -bp\r"; /* clear a breakpoint */
350 mon2000_cmds
.clr_all_break
= "bpoff\r"; /* clear all breakpoints */
351 mon2000_cmds
.fill
= "%x %x %x fill\r"; /* fill (start length val) */
352 mon2000_cmds
.setmem
.cmdb
= "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */
353 mon2000_cmds
.setmem
.cmdw
= "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
354 mon2000_cmds
.setmem
.cmdl
= "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
355 mon2000_cmds
.setmem
.cmdll
= NULL
; /* setmem.cmdll (addr, value) */
356 mon2000_cmds
.setmem
.resp_delim
= NULL
; /* setmem.resp_delim */
357 mon2000_cmds
.setmem
.term
= NULL
; /* setmem.term */
358 mon2000_cmds
.setmem
.term_cmd
= NULL
; /* setmem.term_cmd */
359 mon2000_cmds
.getmem
.cmdb
= "%x %x dump\r"; /* getmem.cmdb (addr, len) */
360 mon2000_cmds
.getmem
.cmdw
= NULL
; /* getmem.cmdw (addr, len) */
361 mon2000_cmds
.getmem
.cmdl
= NULL
; /* getmem.cmdl (addr, len) */
362 mon2000_cmds
.getmem
.cmdll
= NULL
; /* getmem.cmdll (addr, len) */
363 mon2000_cmds
.getmem
.resp_delim
= ": "; /* getmem.resp_delim */
364 mon2000_cmds
.getmem
.term
= NULL
; /* getmem.term */
365 mon2000_cmds
.getmem
.term_cmd
= NULL
; /* getmem.term_cmd */
366 mon2000_cmds
.setreg
.cmd
= "%x to %%%s\r"; /* setreg.cmd (name, value) */
367 mon2000_cmds
.setreg
.resp_delim
= NULL
; /* setreg.resp_delim */
368 mon2000_cmds
.setreg
.term
= NULL
; /* setreg.term */
369 mon2000_cmds
.setreg
.term_cmd
= NULL
; /* setreg.term_cmd */
370 mon2000_cmds
.getreg
.cmd
= NULL
; /* getreg.cmd (name) */
371 mon2000_cmds
.getreg
.resp_delim
= NULL
; /* getreg.resp_delim */
372 mon2000_cmds
.getreg
.term
= NULL
; /* getreg.term */
373 mon2000_cmds
.getreg
.term_cmd
= NULL
; /* getreg.term_cmd */
374 mon2000_cmds
.dump_registers
= ".reg\r"; /* dump_registers */
375 mon2000_cmds
.register_pattern
= "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
376 mon2000_cmds
.supply_register
= m32r_supply_register
; /* supply_register */
377 mon2000_cmds
.load_routine
= NULL
; /* load_routine (defaults to SRECs) */
378 mon2000_cmds
.load
= NULL
; /* download command */
379 mon2000_cmds
.loadresp
= NULL
; /* load response */
380 mon2000_cmds
.prompt
= "Mon2000>"; /* monitor command prompt */
381 mon2000_cmds
.line_term
= "\r"; /* end-of-line terminator */
382 mon2000_cmds
.cmd_end
= NULL
; /* optional command terminator */
383 mon2000_cmds
.target
= &mon2000_ops
; /* target operations */
384 mon2000_cmds
.stopbits
= SERIAL_1_STOPBITS
; /* number of stop bits */
385 mon2000_cmds
.regnames
= m32r_regnames
; /* registers names */
386 mon2000_cmds
.magic
= MONITOR_OPS_MAGIC
; /* magic */
387 } /* init_mon2000_cmds */
390 mon2000_open (char *args
, int from_tty
)
392 monitor_open (args
, &mon2000_cmds
, from_tty
);
397 /* Function: set_board_address
398 Tell the BootOne monitor what it's ethernet IP address is. */
401 m32r_set_board_address (char *args
, int from_tty
)
408 monitor_printf ("ulip %s\n", args
);
409 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
410 /* now parse the result for success */
413 error ("Requires argument (IP address for M32R-EVA board)");
416 /* Function: set_server_address
417 Tell the BootOne monitor what gdb's ethernet IP address is. */
420 m32r_set_server_address (char *args
, int from_tty
)
427 monitor_printf ("uhip %s\n", args
);
428 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
429 /* now parse the result for success */
432 error ("Requires argument (IP address of GDB's host computer)");
435 /* Function: set_download_path
436 Tell the BootOne monitor the default path for downloadable SREC files. */
439 m32r_set_download_path (char *args
, int from_tty
)
446 monitor_printf ("up %s\n", args
);
447 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
448 /* now parse the result for success */
451 error ("Requires argument (default path for downloadable SREC files)");
455 m32r_upload_command (char *args
, int from_tty
)
459 time_t start_time
, end_time
; /* for timing of download */
460 int resp_len
, data_count
= 0;
462 struct hostent
*hostent
;
463 struct in_addr inet_addr
;
465 /* first check to see if there's an ethernet port! */
466 monitor_printf ("ust\r");
467 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
468 if (!strchr (buf
, ':'))
469 error ("No ethernet connection!");
473 /* scan second colon in the output from the "ust" command */
474 char *myIPaddress
= strchr (strchr (buf
, ':') + 1, ':') + 1;
476 while (isspace (*myIPaddress
))
479 if (!strncmp (myIPaddress
, "0.0.", 4)) /* empty */
480 error ("Please use 'set board-address' to set the M32R-EVA board's IP address.");
481 if (strchr (myIPaddress
, '('))
482 *(strchr (myIPaddress
, '(')) = '\0'; /* delete trailing junk */
483 board_addr
= xstrdup (myIPaddress
);
485 if (server_addr
== 0)
488 gethostname (buf
, sizeof (buf
));
490 hostent
= gethostbyname (buf
);
494 memcpy (&inet_addr
.s_addr
, hostent
->h_addr
,
495 sizeof (inet_addr
.s_addr
));
496 server_addr
= (char *) inet_ntoa (inet_addr
);
498 server_addr
= (char *) inet_ntoa (hostent
->h_addr
);
501 if (server_addr
== 0) /* failed? */
502 error ("Need to know gdb host computer's IP address (use 'set server-address')");
505 if (args
== 0 || args
[0] == 0) /* no args: upload the current file */
506 args
= get_exec_file (1);
508 if (args
[0] != '/' && download_path
== 0)
510 if (current_directory
)
511 download_path
= xstrdup (current_directory
);
513 error ("Need to know default download path (use 'set download-path')");
516 start_time
= time (NULL
);
517 monitor_printf ("uhip %s\r", server_addr
);
518 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
519 monitor_printf ("ulip %s\r", board_addr
);
520 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
522 monitor_printf ("up %s\r", download_path
); /* use default path */
524 monitor_printf ("up\r"); /* rooted filename/path */
525 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
527 if (strrchr (args
, '.') && !strcmp (strrchr (args
, '.'), ".srec"))
528 monitor_printf ("ul %s\r", args
);
529 else /* add ".srec" suffix */
530 monitor_printf ("ul %s.srec\r", args
);
531 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
)); /* parse result? */
533 if (buf
[0] == 0 || strstr (buf
, "complete") == 0)
534 error ("Upload file not found: %s.srec\nCheck IP addresses and download path.", args
);
536 printf_filtered (" -- Ethernet load complete.\n");
538 end_time
= time (NULL
);
539 abfd
= bfd_openr (args
, 0);
541 { /* Download is done -- print section statistics */
542 if (bfd_check_format (abfd
, bfd_object
) == 0)
544 printf_filtered ("File is not an object file\n");
546 for (s
= abfd
->sections
; s
; s
= s
->next
)
547 if (s
->flags
& SEC_LOAD
)
549 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
550 bfd_vma section_base
= bfd_section_lma (abfd
, s
);
553 data_count
+= section_size
;
555 printf_filtered ("Loading section %s, size 0x%lx lma ",
556 bfd_section_name (abfd
, s
), section_size
);
557 print_address_numeric (section_base
, 1, gdb_stdout
);
558 printf_filtered ("\n");
559 gdb_flush (gdb_stdout
);
561 /* Finally, make the PC point at the start address */
562 write_pc (bfd_get_start_address (abfd
));
563 report_transfer_performance (data_count
, start_time
, end_time
);
564 printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd
));
566 inferior_ptid
= null_ptid
; /* No process now */
568 /* This is necessary because many things were based on the PC at the
569 time that we attached to the monitor, which is no longer valid
570 now that we have loaded new code (and just changed the PC).
571 Another way to do this might be to call normal_stop, except that
572 the stack may not be valid, and things would get horribly
575 clear_symtab_users ();
578 #endif /* ! _MSC_VER */
581 _initialize_m32r_rom (void)
583 /* Initialize m32r RevC monitor target */
585 init_monitor_ops (&m32r_ops
);
587 m32r_ops
.to_shortname
= "m32r";
588 m32r_ops
.to_longname
= "m32r monitor";
589 m32r_ops
.to_load
= m32r_load_gen
; /* monitor lacks a download command */
590 m32r_ops
.to_doc
= "Debug via the m32r monitor.\n\
591 Specify the serial device it is connected to (e.g. /dev/ttya).";
592 m32r_ops
.to_open
= m32r_open
;
593 add_target (&m32r_ops
);
595 /* Initialize mon2000 monitor target */
596 init_mon2000_cmds ();
597 init_monitor_ops (&mon2000_ops
);
599 mon2000_ops
.to_shortname
= "mon2000";
600 mon2000_ops
.to_longname
= "Mon2000 monitor";
601 mon2000_ops
.to_load
= m32r_load_gen
; /* monitor lacks a download command */
602 mon2000_ops
.to_doc
= "Debug via the Mon2000 monitor.\n\
603 Specify the serial device it is connected to (e.g. /dev/ttya).";
604 mon2000_ops
.to_open
= mon2000_open
;
605 add_target (&mon2000_ops
);
609 (add_set_cmd ("download-path", class_obscure
, var_string
,
610 (char *) &download_path
,
611 "Set the default path for downloadable SREC files.",
616 (add_set_cmd ("board-address", class_obscure
, var_string
,
617 (char *) &board_addr
,
618 "Set IP address for M32R-EVA target board.",
623 (add_set_cmd ("server-address", class_obscure
, var_string
,
624 (char *) &server_addr
,
625 "Set IP address for download server (GDB's host computer).",
629 add_com ("upload", class_obscure
, m32r_upload_command
,
630 "Upload the srec file via the monitor's Ethernet upload capability.");
632 add_com ("tload", class_obscure
, m32r_load
, "test upload command.");