GDB (xrefs)
/tmp/gdb-7.10/gdb/m32r-rom.c
Go to the documentation of this file.
1 /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
2  the GNU debugger.
3 
4  Copyright (C) 1996-2015 Free Software Foundation, Inc.
5 
6  Adapted by Michael Snyder of Cygnus Support.
7 
8  This file is part of GDB.
9 
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.
14 
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.
19 
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/>. */
22 
23 /* This module defines communication with the Renesas 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 <sys/time.h>
35 #include <time.h> /* for time_t */
36 #include "objfiles.h" /* for ALL_OBJFILES etc. */
37 #include "inferior.h"
38 #include <ctype.h>
39 #include "regcache.h"
40 #include "gdb_bfd.h"
41 #include "cli/cli-utils.h"
42 
43 /*
44  * All this stuff just to get my host computer's IP address!
45  */
46 #ifdef __MINGW32__
47 #include <winsock2.h>
48 #else
49 #include <sys/types.h>
50 #include <netdb.h> /* for hostent */
51 #include <netinet/in.h> /* for struct in_addr */
52 #if 1
53 #include <arpa/inet.h> /* for inet_ntoa */
54 #endif
55 #endif
56 
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 */
60 
61 
62 /* REGNUM */
63 #define PSW_REGNUM 16
64 #define SPI_REGNUM 18
65 #define SPU_REGNUM 19
66 #define ACCL_REGNUM 22
67 #define ACCH_REGNUM 23
68 
69 
70 /*
71  * Function: m32r_load_1 (helper function)
72  */
73 
74 static void
75 m32r_load_section (bfd *abfd, asection *s, void *obj)
76 {
77  unsigned int *data_count = obj;
78  if (s->flags & SEC_LOAD)
79  {
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;
84 
85  *data_count += section_size;
86 
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");
93  monitor_printf ("%s mw\r", phex_nz (section_base, addr_size));
94  for (i = 0; i < section_size; i += 4)
95  {
96  QUIT;
97  monitor_expect (" -> ", NULL, 0);
98  bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
99  monitor_printf ("%x\n", buffer);
100  }
101  monitor_expect (" -> ", NULL, 0);
102  monitor_printf ("q\n");
103  monitor_expect_prompt (NULL, 0);
104  }
105 }
106 
107 static int
109 {
110  int data_count = 0;
111 
112  bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count);
113  return data_count;
114 }
115 
116 /*
117  * Function: m32r_load (an alternate way to load)
118  */
119 
120 static void
121 m32r_load (char *filename, int from_tty)
122 {
123  bfd *abfd;
124  unsigned int data_count = 0;
125  struct timeval start_time, end_time;
126  struct cleanup *cleanup;
127 
128  if (filename == NULL || filename[0] == 0)
129  filename = get_exec_file (1);
130 
131  abfd = gdb_bfd_open (filename, NULL, -1);
132  if (!abfd)
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);
138 #if 0
139  for (s = abfd->sections; s; s = s->next)
140  if (s->flags & SEC_LOAD)
141  {
142  bfd_size_type section_size = bfd_section_size (abfd, s);
143  bfd_vma section_base = bfd_section_vma (abfd, s);
144  unsigned int buffer;
145 
146  data_count += section_size;
147 
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");
153  monitor_printf ("%x mw\r", section_base);
154  for (i = 0; i < section_size; i += 4)
155  {
156  monitor_expect (" -> ", NULL, 0);
157  bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
158  monitor_printf ("%x\n", buffer);
159  }
160  monitor_expect (" -> ", NULL, 0);
161  monitor_printf ("q\n");
162  monitor_expect_prompt (NULL, 0);
163  }
164 #else
165  if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL)))
166  {
167  monitor_printf ("q\n");
168  do_cleanups (cleanup);
169  return;
170  }
171 #endif
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,
176  &end_time);
177 
178  /* Finally, make the PC point at the start address. */
179  if (exec_bfd)
181  bfd_get_start_address (exec_bfd));
182 
183  inferior_ptid = null_ptid; /* No process now. */
184 
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
190  confused... */
191 
192  clear_symtab_users (0);
193  do_cleanups (cleanup);
194 }
195 
196 static void
197 m32r_load_gen (struct target_ops *self, const char *filename, int from_tty)
198 {
199  generic_load (filename, from_tty);
200 }
201 
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". */
206 
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",
211 };
212 
213 static void
214 m32r_supply_register (struct regcache *regcache, char *regname,
215  int regnamelen, char *val, int vallen)
216 {
217  int regno;
218  int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]);
219  struct gdbarch *gdbarch = get_regcache_arch (regcache);
220 
221  for (regno = 0; regno < num_regs; regno++)
222  if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0)
223  break;
224 
225  if (regno >= num_regs)
226  return; /* no match */
227 
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. */
232  if (val != NULL)
233  monitor_supply_register (regcache, ACCL_REGNUM, val + 1);
234  }
235  else
236  {
237  monitor_supply_register (regcache, regno, val);
238  if (regno == PSW_REGNUM)
239  {
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";
245 #endif
246 
247 #ifdef SM_REGNUM
248  /* Stack mode bit */
249  monitor_supply_register (regcache, SM_REGNUM,
250  (psw & 0x80) ? one : zero);
251 #endif
252 #ifdef BSM_REGNUM
253  /* Backup stack mode bit */
254  monitor_supply_register (regcache, BSM_REGNUM,
255  (psw & 0x8000) ? one : zero);
256 #endif
257 #ifdef IE_REGNUM
258  /* Interrupt enable bit */
259  monitor_supply_register (regcache, IE_REGNUM,
260  (psw & 0x40) ? one : zero);
261 #endif
262 #ifdef BIE_REGNUM
263  /* Backup interrupt enable bit */
264  monitor_supply_register (regcache, BIE_REGNUM,
265  (psw & 0x4000) ? one : zero);
266 #endif
267 #ifdef COND_REGNUM
268  /* Condition bit (carry etc.) */
269  monitor_supply_register (regcache, COND_REGNUM,
270  (psw & 0x1) ? one : zero);
271 #endif
272 #ifdef CBR_REGNUM
274  (psw & 0x1) ? one : zero);
275 #endif
276 #ifdef BPC_REGNUM
277  monitor_supply_register (regcache, BPC_REGNUM,
278  zero); /* KLUDGE: (???????) */
279 #endif
280 #ifdef BCARRY_REGNUM
281  monitor_supply_register (regcache, BCARRY_REGNUM,
282  zero); /* KLUDGE: (??????) */
283 #endif
284  }
285 
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;
291 
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);
298  }
299  }
300 }
301 
302 /* m32r RevC board monitor */
303 
304 static struct target_ops m32r_ops;
305 
306 static char *m32r_inits[] = { "\r", NULL };
307 
308 static struct monitor_ops m32r_cmds;
309 
310 static void
312 {
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\\)";
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 */
358 
359 static void
360 m32r_open (const char *args, int from_tty)
361 {
362  monitor_open (args, &m32r_cmds, from_tty);
363 }
364 
365 /* Mon2000 monitor (MSA2000 board) */
366 
367 static struct target_ops mon2000_ops;
368 static struct monitor_ops mon2000_cmds;
369 
370 static void
372 {
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\\)";
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 */
418 
419 static void
420 mon2000_open (const char *args, int from_tty)
421 {
422  monitor_open (args, &mon2000_cmds, from_tty);
423 }
424 
425 static void
426 m32r_upload_command (char *args, int from_tty)
427 {
428  bfd *abfd;
429  asection *s;
430  struct timeval start_time, end_time;
431  int resp_len, data_count = 0;
432  char buf[1024];
433  struct hostent *hostent;
434  struct in_addr inet_addr;
435  struct cleanup *cleanup;
436 
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!"));
442 
443  if (board_addr == 0)
444  {
445  /* Scan second colon in the output from the "ust" command. */
446  char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1;
447 
448  myIPaddress = skip_spaces (myIPaddress);
449 
450  if (startswith (myIPaddress, "0.0.")) /* 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);
456  }
457  if (server_addr == 0)
458  {
459 #ifdef __MINGW32__
460  WSADATA wd;
461  /* Winsock initialization. */
462  if (WSAStartup (MAKEWORD (1, 1), &wd))
463  error (_("Couldn't initialize WINSOCK."));
464 #endif
465 
466  buf[0] = 0;
467  gethostname (buf, sizeof (buf));
468  if (buf[0] != 0)
469  {
470  hostent = gethostbyname (buf);
471  if (hostent != 0)
472  {
473 #if 1
474  memcpy (&inet_addr.s_addr, hostent->h_addr,
475  sizeof (inet_addr.s_addr));
476  server_addr = (char *) inet_ntoa (inet_addr);
477 #else
478  server_addr = (char *) inet_ntoa (hostent->h_addr);
479 #endif
480  }
481  }
482  if (server_addr == 0) /* failed? */
483  error (_("Need to know gdb host computer's "
484  "IP address (use 'set server-address')"));
485  }
486 
487  if (args == 0 || args[0] == 0) /* No args: upload the current
488  file. */
489  args = get_exec_file (1);
490 
491  if (args[0] != '/' && download_path == 0)
492  {
493  if (current_directory)
494  download_path = xstrdup (current_directory);
495  else
496  error (_("Need to know default download "
497  "path (use 'set download-path')"));
498  }
499 
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? */
505  if (args[0] != '/')
506  monitor_printf ("up %s\r", download_path); /* use default path */
507  else
508  monitor_printf ("up\r"); /* rooted filename/path */
509  resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
510 
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? */
516 
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."),
520  args);
521  else
522  printf_filtered (" -- Ethernet load complete.\n");
523 
524  gettimeofday (&end_time, NULL);
525  abfd = gdb_bfd_open (args, NULL, -1);
526  cleanup = make_cleanup_bfd_unref (abfd);
527  if (abfd != NULL)
528  { /* Download is done -- print section statistics. */
529  if (bfd_check_format (abfd, bfd_object) == 0)
530  {
531  printf_filtered ("File is not an object file\n");
532  }
533  for (s = abfd->sections; s; s = s->next)
534  if (s->flags & SEC_LOAD)
535  {
536  bfd_size_type section_size = bfd_section_size (abfd, s);
537  bfd_vma section_base = bfd_section_lma (abfd, s);
538 
539  data_count += section_size;
540 
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),
545  gdb_stdout);
546  printf_filtered ("\n");
548  }
549  /* Finally, make the PC point at the start address. */
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,
555  &end_time);
556  }
557  inferior_ptid = null_ptid; /* No process now. */
558 
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
564  confused... */
565 
566  clear_symtab_users (0);
567  do_cleanups (cleanup);
568 }
569 
570 /* Provide a prototype to silence -Wmissing-prototypes. */
572 
573 void
575 {
576  /* Initialize m32r RevC monitor target. */
577  init_m32r_cmds ();
579 
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
583  command. */
584  m32r_ops.to_doc = "Debug via the m32r monitor.\n\
585 Specify the serial device it is connected to (e.g. /dev/ttya).";
587  add_target (&m32r_ops);
588 
589  /* Initialize mon2000 monitor target */
592 
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
596  command. */
597  mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\
598 Specify the serial device it is connected to (e.g. /dev/ttya).";
601 
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."),
606  NULL,
607  NULL, /* FIXME: i18n: The default path for
608  downloadable SREC files is %s. */
609  &setlist, &showlist);
610 
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."),
615  NULL,
616  NULL, /* FIXME: i18n: IP address for
617  M32R-EVA target board is %s. */
618  &setlist, &showlist);
619 
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)."),
624  NULL,
625  NULL, /* FIXME: i18n: IP address for
626  download server (GDB's host
627  computer) is %s. */
628  &setlist, &showlist);
629 
631 Upload the srec file via the monitor's Ethernet upload capability."));
632 
633  add_com ("tload", class_obscure, m32r_load, _("test upload command."));
634 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
void add_target(struct target_ops *t)
Definition: target.c:395
char * cmdl
Definition: monitor.h:60
#define ACCH_REGNUM
Definition: m32r-rom.c:67
int num_regs
Definition: gdbarch.c:188
static char * board_addr
Definition: m32r-rom.c:57
char ** regnames
Definition: monitor.h:118
char * cmd
Definition: monitor.h:70
int stopbits
Definition: monitor.h:117
void monitor_printf(char *pattern,...)
Definition: monitor.c:328
const char * to_longname
Definition: target.h:433
char * clr_break
Definition: monitor.h:88
char * prompt
Definition: monitor.h:113
char * stop
Definition: monitor.h:84
struct memrw_cmd setmem
Definition: monitor.h:91
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
char * loadresp
Definition: monitor.h:112
char * resp_delim
Definition: monitor.h:62
struct ui_file * gdb_stdout
Definition: main.c:71
char * cmdw
Definition: monitor.h:59
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
Definition: exceptions.c:228
char * skip_spaces(char *chp)
Definition: common-utils.c:259
#define _(String)
Definition: gdb_locale.h:40
static struct target_ops mon2000_ops
Definition: m32r-rom.c:367
struct bfd * gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:320
char * cmdb
Definition: monitor.h:58
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1201
static char * m32r_regnames[]
Definition: m32r-rom.c:207
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
void printf_filtered(const char *format,...)
Definition: utils.c:2388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
void(* supply_register)(struct regcache *regcache, char *name, int namelen, char *val, int vallen)
Definition: monitor.h:103
struct regrw_cmd getreg
Definition: monitor.h:94
char * load
Definition: monitor.h:111
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
static int m32r_load_1(void *dummy)
Definition: m32r-rom.c:108
static void m32r_supply_register(struct regcache *regcache, char *regname, int regnamelen, char *val, int vallen)
Definition: m32r-rom.c:214
void initialize_file_ftype(void)
Definition: defs.h:281
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
char * clr_all_break
Definition: monitor.h:89
int monitor_expect(char *string, char *buf, int buflen)
Definition: monitor.c:487
char * cmdll
Definition: monitor.h:61
#define exec_bfd
Definition: exec.h:32
char * term
Definition: monitor.h:63
#define SPU_REGNUM
Definition: m32r-rom.c:65
static void init_mon2000_cmds(void)
Definition: m32r-rom.c:371
struct regrw_cmd setreg
Definition: monitor.h:93
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
int flags
Definition: monitor.h:80
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
static struct monitor_ops mon2000_cmds
Definition: m32r-rom.c:368
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
char ** init
Definition: monitor.h:81
void generic_load(const char *name, int from_tty)
Definition: symfile.c:2064
#define MO_CLR_BREAK_USES_ADDR
Definition: monitor.h:137
void print_transfer_performance(struct ui_file *stream, unsigned long data_count, unsigned long write_count, const struct timeval *start_time, const struct timeval *end_time)
Definition: symfile.c:2173
#define MONITOR_OPS_MAGIC
Definition: monitor.h:130
void add_setshow_string_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:585
#define ACCL_REGNUM
Definition: m32r-rom.c:66
char * step
Definition: monitor.h:83
unsigned dummy
Definition: go32-nat.c:1071
const char * to_doc
Definition: target.h:434
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
void monitor_open(const char *args, struct monitor_ops *mon_ops, int from_tty)
Definition: monitor.c:700
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
char * term
Definition: monitor.h:73
struct memrw_cmd getmem
Definition: monitor.h:92
char * register_pattern
Definition: monitor.h:101
char * current_directory
Definition: top.c:117
void clear_symtab_users(int add_flags)
Definition: symfile.c:2996
#define SERIAL_1_STOPBITS
Definition: serial.h:183
static void m32r_open(const char *args, int from_tty)
Definition: m32r-rom.c:360
ptid_t null_ptid
Definition: ptid.c:25
void init_monitor_ops(struct target_ops *ops)
Definition: monitor.c:2381
char * dump_registers
Definition: monitor.h:100
char * term_cmd
Definition: monitor.h:74
ptid_t inferior_ptid
Definition: infcmd.c:124
static char * server_addr
Definition: m32r-rom.c:58
static char * download_path
Definition: m32r-rom.c:59
#define PSW_REGNUM
Definition: m32r-rom.c:63
int magic
Definition: monitor.h:124
void(* to_open)(const char *, int)
Definition: target.h:443
Definition: buffer.h:23
#define SPI_REGNUM
Definition: m32r-rom.c:64
char * monitor_supply_register(struct regcache *regcache, int regno, char *valstr)
Definition: monitor.c:874
struct target_ops * target
Definition: monitor.h:116
const char * to_shortname
Definition: target.h:432
char * get_exec_file(int err)
Definition: corefile.c:179
unsigned long long ULONGEST
Definition: common-types.h:53
static void m32r_load(char *filename, int from_tty)
Definition: m32r-rom.c:121
char * fill
Definition: monitor.h:90
static struct monitor_ops m32r_cmds
Definition: m32r-rom.c:308
#define MO_REGISTER_VALUE_FIRST
Definition: monitor.h:187
char * resp_delim
Definition: monitor.h:71
static void m32r_load_section(bfd *abfd, asection *s, void *obj)
Definition: m32r-rom.c:75
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
int monitor_expect_prompt(char *buf, int buflen)
Definition: monitor.c:638
#define QUIT
Definition: defs.h:160
static struct target_ops m32r_ops
Definition: m32r-rom.c:304
static void m32r_load_gen(struct target_ops *self, const char *filename, int from_tty)
Definition: m32r-rom.c:197
char * set_break
Definition: monitor.h:85
static char * m32r_inits[]
Definition: m32r-rom.c:306
char * line_term
Definition: monitor.h:114
char * cont
Definition: monitor.h:82
void error(const char *fmt,...)
Definition: errors.c:38
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
initialize_file_ftype _initialize_m32r_rom
static void m32r_upload_command(char *args, int from_tty)
Definition: m32r-rom.c:426
void(* to_load)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:577
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static void init_m32r_cmds(void)
Definition: m32r-rom.c:311
char * cmd_end
Definition: monitor.h:115
char * term_cmd
Definition: monitor.h:64
static void mon2000_open(const char *args, int from_tty)
Definition: m32r-rom.c:420