OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [m32r-rom.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
2
   the GNU debugger.
3
 
4
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2004, 2005, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   Adapted by Michael Snyder of Cygnus Support.
8
 
9
   This file is part of GDB.
10
 
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.
15
 
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.
20
 
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/>.  */
23
 
24
/* This module defines communication with the Renesas m32r monitor */
25
 
26
#include "defs.h"
27
#include "gdbcore.h"
28
#include "target.h"
29
#include "exceptions.h"
30
#include "monitor.h"
31
#include "serial.h"
32
#include "symtab.h"
33
#include "command.h"
34
#include "gdbcmd.h"
35
#include "symfile.h"            /* for generic load */
36
#include <sys/time.h>
37
#include <time.h>               /* for time_t */
38
#include "gdb_string.h"
39
#include "objfiles.h"           /* for ALL_OBJFILES etc. */
40
#include "inferior.h"           /* for write_pc() */
41
#include <ctype.h>
42
#include "regcache.h"
43
 
44
/*
45
 * All this stuff just to get my host computer's IP address!
46
 */
47
#ifdef __MINGW32__
48
#include <winsock.h>
49
#else
50
#include <sys/types.h>
51
#include <netdb.h>              /* for hostent */
52
#include <netinet/in.h>         /* for struct in_addr */
53
#if 1
54
#include <arpa/inet.h>          /* for inet_ntoa */
55
#endif
56
#endif
57
 
58
static char *board_addr;        /* user-settable IP address for M32R-EVA */
59
static char *server_addr;       /* user-settable IP address for gdb host */
60
static char *download_path;     /* user-settable path for SREC files     */
61
 
62
 
63
/* REGNUM */
64
#define PSW_REGNUM      16
65
#define SPI_REGNUM      18
66
#define SPU_REGNUM      19
67
#define ACCL_REGNUM     22
68
#define ACCH_REGNUM     23
69
 
70
 
71
/*
72
 * Function: m32r_load_1 (helper function)
73
 */
74
 
75
static void
76
m32r_load_section (bfd *abfd, asection *s, void *obj)
77
{
78
  unsigned int *data_count = obj;
79
  if (s->flags & SEC_LOAD)
80
    {
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 (section_base), gdb_stdout);
91
      printf_filtered ("\n");
92
      gdb_flush (gdb_stdout);
93
      monitor_printf ("%s mw\r", paddr_nz (section_base));
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
108
m32r_load_1 (void *dummy)
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
  asection *s;
125
  unsigned int i, data_count = 0;
126
  struct timeval start_time, end_time;
127
 
128
  if (filename == NULL || filename[0] == 0)
129
    filename = get_exec_file (1);
130
 
131
  abfd = bfd_openr (filename, 0);
132
  if (!abfd)
133
    error (_("Unable to open file %s."), filename);
134
  if (bfd_check_format (abfd, bfd_object) == 0)
135
    error (_("File is not an object file."));
136
  gettimeofday (&start_time, NULL);
137
#if 0
138
  for (s = abfd->sections; s; s = s->next)
139
    if (s->flags & SEC_LOAD)
140
      {
141
        bfd_size_type section_size = bfd_section_size (abfd, s);
142
        bfd_vma section_base = bfd_section_vma (abfd, s);
143
        unsigned int buffer;
144
 
145
        data_count += section_size;
146
 
147
        printf_filtered ("Loading section %s, size 0x%lx vma ",
148
                         bfd_section_name (abfd, s), section_size);
149
        fputs_filtered (paddress (section_base), gdb_stdout);
150
        printf_filtered ("\n");
151
        gdb_flush (gdb_stdout);
152
        monitor_printf ("%x mw\r", section_base);
153
        for (i = 0; i < section_size; i += 4)
154
          {
155
            monitor_expect (" -> ", NULL, 0);
156
            bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
157
            monitor_printf ("%x\n", buffer);
158
          }
159
        monitor_expect (" -> ", NULL, 0);
160
        monitor_printf ("q\n");
161
        monitor_expect_prompt (NULL, 0);
162
      }
163
#else
164
  if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL)))
165
    {
166
      monitor_printf ("q\n");
167
      return;
168
    }
169
#endif
170
  gettimeofday (&end_time, NULL);
171
  printf_filtered ("Start address 0x%lx\n",
172
                   (unsigned long) bfd_get_start_address (abfd));
173
  print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
174
                              &end_time);
175
 
176
  /* Finally, make the PC point at the start address */
177
  if (exec_bfd)
178
    write_pc (bfd_get_start_address (exec_bfd));
179
 
180
  inferior_ptid = null_ptid;    /* No process now */
181
 
182
  /* This is necessary because many things were based on the PC at the
183
     time that we attached to the monitor, which is no longer valid
184
     now that we have loaded new code (and just changed the PC).
185
     Another way to do this might be to call normal_stop, except that
186
     the stack may not be valid, and things would get horribly
187
     confused... */
188
 
189
  clear_symtab_users ();
190
}
191
 
192
static void
193
m32r_load_gen (char *filename, int from_tty)
194
{
195
  generic_load (filename, from_tty);
196
}
197
 
198
static void m32r_open (char *args, int from_tty);
199
static void mon2000_open (char *args, int from_tty);
200
 
201
/* This array of registers needs to match the indexes used by GDB. The
202
   whole reason this exists is because the various ROM monitors use
203
   different names than GDB does, and don't support all the registers
204
   either. So, typing "info reg sp" becomes an "A7". */
205
 
206
static char *m32r_regnames[] =
207
  { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
208
  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
209
  "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
210
};
211
 
212
static void
213
m32r_supply_register (struct regcache *regcache, char *regname,
214
                      int regnamelen, char *val, int vallen)
215
{
216
  int regno;
217
  int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]);
218
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
219
 
220
  for (regno = 0; regno < num_regs; regno++)
221
    if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0)
222
      break;
223
 
224
  if (regno >= num_regs)
225
    return;                     /* no match */
226
 
227
  if (regno == ACCL_REGNUM)
228
    {                           /* special handling for 64-bit acc reg */
229
      monitor_supply_register (regcache, ACCH_REGNUM, val);
230
      val = strchr (val, ':');  /* skip past ':' to get 2nd word */
231
      if (val != NULL)
232
        monitor_supply_register (regcache, ACCL_REGNUM, val + 1);
233
    }
234
  else
235
    {
236
      monitor_supply_register (regcache, regno, val);
237
      if (regno == PSW_REGNUM)
238
        {
239
          unsigned long psw = strtoul (val, NULL, 16);
240
          char *zero = "00000000", *one = "00000001";
241
 
242
#ifdef SM_REGNUM
243
          /* Stack mode bit */
244
          monitor_supply_register (regcache, SM_REGNUM, (psw & 0x80) ? one : zero);
245
#endif
246
#ifdef BSM_REGNUM
247
          /* Backup stack mode bit */
248
          monitor_supply_register (regcache, BSM_REGNUM, (psw & 0x8000) ? one : zero);
249
#endif
250
#ifdef IE_REGNUM
251
          /* Interrupt enable bit */
252
          monitor_supply_register (regcache, IE_REGNUM, (psw & 0x40) ? one : zero);
253
#endif
254
#ifdef BIE_REGNUM
255
          /* Backup interrupt enable bit */
256
          monitor_supply_register (regcache, BIE_REGNUM, (psw & 0x4000) ? one : zero);
257
#endif
258
#ifdef COND_REGNUM
259
          /* Condition bit (carry etc.) */
260
          monitor_supply_register (regcache, COND_REGNUM, (psw & 0x1) ? one : zero);
261
#endif
262
#ifdef CBR_REGNUM
263
          monitor_supply_register (regcache, CBR_REGNUM, (psw & 0x1) ? one : zero);
264
#endif
265
#ifdef BPC_REGNUM
266
          monitor_supply_register (regcache, BPC_REGNUM, zero); /* KLUDGE:   (???????) */
267
#endif
268
#ifdef BCARRY_REGNUM
269
          monitor_supply_register (regcache, BCARRY_REGNUM, zero);      /* KLUDGE: (??????) */
270
#endif
271
        }
272
 
273
      if (regno == SPI_REGNUM || regno == SPU_REGNUM)
274
        {                       /* special handling for stack pointer (spu or spi) */
275
          ULONGEST stackmode, psw;
276
          regcache_cooked_read_unsigned (regcache, PSW_REGNUM, &psw);
277
          stackmode = psw & 0x80;
278
 
279
          if (regno == SPI_REGNUM && !stackmode)        /* SP == SPI */
280
            monitor_supply_register (regcache,
281
                                     gdbarch_sp_regnum (gdbarch), val);
282
          else if (regno == SPU_REGNUM && stackmode)    /* SP == SPU */
283
            monitor_supply_register (regcache,
284
                                     gdbarch_sp_regnum (gdbarch), val);
285
        }
286
    }
287
}
288
 
289
/* m32r RevC board monitor */
290
 
291
static struct target_ops m32r_ops;
292
 
293
static char *m32r_inits[] = { "\r", NULL };
294
 
295
static struct monitor_ops m32r_cmds;
296
 
297
static void
298
init_m32r_cmds (void)
299
{
300
  m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
301
  m32r_cmds.init = m32r_inits;  /* Init strings */
302
  m32r_cmds.cont = "go\r";      /* continue command */
303
  m32r_cmds.step = "step\r";    /* single step */
304
  m32r_cmds.stop = NULL;        /* interrupt command */
305
  m32r_cmds.set_break = "%x +bp\r";     /* set a breakpoint */
306
  m32r_cmds.clr_break = "%x -bp\r";     /* clear a breakpoint */
307
  m32r_cmds.clr_all_break = "bpoff\r";  /* clear all breakpoints */
308
  m32r_cmds.fill = "%x %x %x fill\r";   /* fill (start length val) */
309
  m32r_cmds.setmem.cmdb = "%x 1 %x fill\r";     /* setmem.cmdb (addr, value) */
310
  m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r";    /* setmem.cmdw (addr, value) */
311
  m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r";    /* setmem.cmdl (addr, value) */
312
  m32r_cmds.setmem.cmdll = NULL;        /* setmem.cmdll (addr, value) */
313
  m32r_cmds.setmem.resp_delim = NULL;   /* setmem.resp_delim */
314
  m32r_cmds.setmem.term = NULL; /* setmem.term */
315
  m32r_cmds.setmem.term_cmd = NULL;     /* setmem.term_cmd */
316
  m32r_cmds.getmem.cmdb = "%x %x dump\r";       /* getmem.cmdb (addr, len) */
317
  m32r_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */
318
  m32r_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */
319
  m32r_cmds.getmem.cmdll = NULL;        /* getmem.cmdll (addr, len) */
320
  m32r_cmds.getmem.resp_delim = ": ";   /* getmem.resp_delim */
321
  m32r_cmds.getmem.term = NULL; /* getmem.term */
322
  m32r_cmds.getmem.term_cmd = NULL;     /* getmem.term_cmd */
323
  m32r_cmds.setreg.cmd = "%x to %%%s\r";        /* setreg.cmd (name, value) */
324
  m32r_cmds.setreg.resp_delim = NULL;   /* setreg.resp_delim */
325
  m32r_cmds.setreg.term = NULL; /* setreg.term */
326
  m32r_cmds.setreg.term_cmd = NULL;     /* setreg.term_cmd */
327
  m32r_cmds.getreg.cmd = NULL;  /* getreg.cmd (name) */
328
  m32r_cmds.getreg.resp_delim = NULL;   /* getreg.resp_delim */
329
  m32r_cmds.getreg.term = NULL; /* getreg.term */
330
  m32r_cmds.getreg.term_cmd = NULL;     /* getreg.term_cmd */
331
  m32r_cmds.dump_registers = ".reg\r";  /* dump_registers */
332
  m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";   /* register_pattern */
333
  m32r_cmds.supply_register = m32r_supply_register;
334
  m32r_cmds.load_routine = NULL;        /* load_routine (defaults to SRECs) */
335
  m32r_cmds.load = NULL;        /* download command */
336
  m32r_cmds.loadresp = NULL;    /* load response */
337
  m32r_cmds.prompt = "ok ";     /* monitor command prompt */
338
  m32r_cmds.line_term = "\r";   /* end-of-line terminator */
339
  m32r_cmds.cmd_end = NULL;     /* optional command terminator */
340
  m32r_cmds.target = &m32r_ops; /* target operations */
341
  m32r_cmds.stopbits = SERIAL_1_STOPBITS;       /* number of stop bits */
342
  m32r_cmds.regnames = m32r_regnames;   /* registers names */
343
  m32r_cmds.magic = MONITOR_OPS_MAGIC;  /* magic */
344
}                               /* init_m32r_cmds */
345
 
346
static void
347
m32r_open (char *args, int from_tty)
348
{
349
  monitor_open (args, &m32r_cmds, from_tty);
350
}
351
 
352
/* Mon2000 monitor (MSA2000 board) */
353
 
354
static struct target_ops mon2000_ops;
355
static struct monitor_ops mon2000_cmds;
356
 
357
static void
358
init_mon2000_cmds (void)
359
{
360
  mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
361
  mon2000_cmds.init = m32r_inits;       /* Init strings */
362
  mon2000_cmds.cont = "go\r";   /* continue command */
363
  mon2000_cmds.step = "step\r"; /* single step */
364
  mon2000_cmds.stop = NULL;     /* interrupt command */
365
  mon2000_cmds.set_break = "%x +bp\r";  /* set a breakpoint */
366
  mon2000_cmds.clr_break = "%x -bp\r";  /* clear a breakpoint */
367
  mon2000_cmds.clr_all_break = "bpoff\r";       /* clear all breakpoints */
368
  mon2000_cmds.fill = "%x %x %x fill\r";        /* fill (start length val) */
369
  mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r";  /* setmem.cmdb (addr, value) */
370
  mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
371
  mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
372
  mon2000_cmds.setmem.cmdll = NULL;     /* setmem.cmdll (addr, value) */
373
  mon2000_cmds.setmem.resp_delim = NULL;        /* setmem.resp_delim */
374
  mon2000_cmds.setmem.term = NULL;      /* setmem.term */
375
  mon2000_cmds.setmem.term_cmd = NULL;  /* setmem.term_cmd */
376
  mon2000_cmds.getmem.cmdb = "%x %x dump\r";    /* getmem.cmdb (addr, len) */
377
  mon2000_cmds.getmem.cmdw = NULL;      /* getmem.cmdw (addr, len) */
378
  mon2000_cmds.getmem.cmdl = NULL;      /* getmem.cmdl (addr, len) */
379
  mon2000_cmds.getmem.cmdll = NULL;     /* getmem.cmdll (addr, len) */
380
  mon2000_cmds.getmem.resp_delim = ": ";        /* getmem.resp_delim */
381
  mon2000_cmds.getmem.term = NULL;      /* getmem.term */
382
  mon2000_cmds.getmem.term_cmd = NULL;  /* getmem.term_cmd */
383
  mon2000_cmds.setreg.cmd = "%x to %%%s\r";     /* setreg.cmd (name, value) */
384
  mon2000_cmds.setreg.resp_delim = NULL;        /* setreg.resp_delim */
385
  mon2000_cmds.setreg.term = NULL;      /* setreg.term */
386
  mon2000_cmds.setreg.term_cmd = NULL;  /* setreg.term_cmd */
387
  mon2000_cmds.getreg.cmd = NULL;       /* getreg.cmd (name) */
388
  mon2000_cmds.getreg.resp_delim = NULL;        /* getreg.resp_delim */
389
  mon2000_cmds.getreg.term = NULL;      /* getreg.term */
390
  mon2000_cmds.getreg.term_cmd = NULL;  /* getreg.term_cmd */
391
  mon2000_cmds.dump_registers = ".reg\r";       /* dump_registers */
392
  mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";        /* register_pattern */
393
  mon2000_cmds.supply_register = m32r_supply_register;
394
  mon2000_cmds.load_routine = NULL;     /* load_routine (defaults to SRECs) */
395
  mon2000_cmds.load = NULL;     /* download command */
396
  mon2000_cmds.loadresp = NULL; /* load response */
397
  mon2000_cmds.prompt = "Mon2000>";     /* monitor command prompt */
398
  mon2000_cmds.line_term = "\r";        /* end-of-line terminator */
399
  mon2000_cmds.cmd_end = NULL;  /* optional command terminator */
400
  mon2000_cmds.target = &mon2000_ops;   /* target operations */
401
  mon2000_cmds.stopbits = SERIAL_1_STOPBITS;    /* number of stop bits */
402
  mon2000_cmds.regnames = m32r_regnames;        /* registers names */
403
  mon2000_cmds.magic = MONITOR_OPS_MAGIC;       /* magic */
404
}                               /* init_mon2000_cmds */
405
 
406
static void
407
mon2000_open (char *args, int from_tty)
408
{
409
  monitor_open (args, &mon2000_cmds, from_tty);
410
}
411
 
412
static void
413
m32r_upload_command (char *args, int from_tty)
414
{
415
  bfd *abfd;
416
  asection *s;
417
  struct timeval start_time, end_time;
418
  int resp_len, data_count = 0;
419
  char buf[1024];
420
  struct hostent *hostent;
421
  struct in_addr inet_addr;
422
 
423
  /* first check to see if there's an ethernet port! */
424
  monitor_printf ("ust\r");
425
  resp_len = monitor_expect_prompt (buf, sizeof (buf));
426
  if (!strchr (buf, ':'))
427
    error (_("No ethernet connection!"));
428
 
429
  if (board_addr == 0)
430
    {
431
      /* scan second colon in the output from the "ust" command */
432
      char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1;
433
 
434
      while (isspace (*myIPaddress))
435
        myIPaddress++;
436
 
437
      if (!strncmp (myIPaddress, "0.0.", 4))    /* empty */
438
        error
439
          ("Please use 'set board-address' to set the M32R-EVA board's IP address.");
440
      if (strchr (myIPaddress, '('))
441
        *(strchr (myIPaddress, '(')) = '\0';    /* delete trailing junk */
442
      board_addr = xstrdup (myIPaddress);
443
    }
444
  if (server_addr == 0)
445
    {
446
#ifdef __MINGW32__
447
      WSADATA wd;
448
      /* Winsock initialization. */
449
      if (WSAStartup (MAKEWORD (1, 1), &wd))
450
        error (_("Couldn't initialize WINSOCK."));
451
#endif
452
 
453
      buf[0] = 0;
454
      gethostname (buf, sizeof (buf));
455
      if (buf[0] != 0)
456
        {
457
          hostent = gethostbyname (buf);
458
          if (hostent != 0)
459
            {
460
#if 1
461
              memcpy (&inet_addr.s_addr, hostent->h_addr,
462
                      sizeof (inet_addr.s_addr));
463
              server_addr = (char *) inet_ntoa (inet_addr);
464
#else
465
              server_addr = (char *) inet_ntoa (hostent->h_addr);
466
#endif
467
            }
468
        }
469
      if (server_addr == 0)      /* failed? */
470
        error
471
          ("Need to know gdb host computer's IP address (use 'set server-address')");
472
    }
473
 
474
  if (args == 0 || args[0] == 0)   /* no args: upload the current file */
475
    args = get_exec_file (1);
476
 
477
  if (args[0] != '/' && download_path == 0)
478
    {
479
      if (current_directory)
480
        download_path = xstrdup (current_directory);
481
      else
482
        error
483
          ("Need to know default download path (use 'set download-path')");
484
    }
485
 
486
  gettimeofday (&start_time, NULL);
487
  monitor_printf ("uhip %s\r", server_addr);
488
  resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
489
  monitor_printf ("ulip %s\r", board_addr);
490
  resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
491
  if (args[0] != '/')
492
    monitor_printf ("up %s\r", download_path);  /* use default path */
493
  else
494
    monitor_printf ("up\r");    /* rooted filename/path */
495
  resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
496
 
497
  if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec"))
498
    monitor_printf ("ul %s\r", args);
499
  else                          /* add ".srec" suffix */
500
    monitor_printf ("ul %s.srec\r", args);
501
  resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
502
 
503
  if (buf[0] == 0 || strstr (buf, "complete") == 0)
504
    error
505
      ("Upload file not found: %s.srec\nCheck IP addresses and download path.",
506
       args);
507
  else
508
    printf_filtered (" -- Ethernet load complete.\n");
509
 
510
  gettimeofday (&end_time, NULL);
511
  abfd = bfd_openr (args, 0);
512
  if (abfd != NULL)
513
    {                           /* Download is done -- print section statistics */
514
      if (bfd_check_format (abfd, bfd_object) == 0)
515
        {
516
          printf_filtered ("File is not an object file\n");
517
        }
518
      for (s = abfd->sections; s; s = s->next)
519
        if (s->flags & SEC_LOAD)
520
          {
521
            bfd_size_type section_size = bfd_section_size (abfd, s);
522
            bfd_vma section_base = bfd_section_lma (abfd, s);
523
            unsigned int buffer;
524
 
525
            data_count += section_size;
526
 
527
            printf_filtered ("Loading section %s, size 0x%lx lma ",
528
                             bfd_section_name (abfd, s),
529
                             (unsigned long) section_size);
530
            fputs_filtered (paddress (section_base), gdb_stdout);
531
            printf_filtered ("\n");
532
            gdb_flush (gdb_stdout);
533
          }
534
      /* Finally, make the PC point at the start address */
535
      write_pc (bfd_get_start_address (abfd));
536
      printf_filtered ("Start address 0x%lx\n",
537
                       (unsigned long) bfd_get_start_address (abfd));
538
      print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
539
                                  &end_time);
540
    }
541
  inferior_ptid = null_ptid;    /* No process now */
542
 
543
  /* This is necessary because many things were based on the PC at the
544
     time that we attached to the monitor, which is no longer valid
545
     now that we have loaded new code (and just changed the PC).
546
     Another way to do this might be to call normal_stop, except that
547
     the stack may not be valid, and things would get horribly
548
     confused... */
549
 
550
  clear_symtab_users ();
551
}
552
 
553
void
554
_initialize_m32r_rom (void)
555
{
556
  /* Initialize m32r RevC monitor target */
557
  init_m32r_cmds ();
558
  init_monitor_ops (&m32r_ops);
559
 
560
  m32r_ops.to_shortname = "m32r";
561
  m32r_ops.to_longname = "m32r monitor";
562
  m32r_ops.to_load = m32r_load_gen;     /* monitor lacks a download command */
563
  m32r_ops.to_doc = "Debug via the m32r monitor.\n\
564
Specify the serial device it is connected to (e.g. /dev/ttya).";
565
  m32r_ops.to_open = m32r_open;
566
  add_target (&m32r_ops);
567
 
568
  /* Initialize mon2000 monitor target */
569
  init_mon2000_cmds ();
570
  init_monitor_ops (&mon2000_ops);
571
 
572
  mon2000_ops.to_shortname = "mon2000";
573
  mon2000_ops.to_longname = "Mon2000 monitor";
574
  mon2000_ops.to_load = m32r_load_gen;  /* monitor lacks a download command */
575
  mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\
576
Specify the serial device it is connected to (e.g. /dev/ttya).";
577
  mon2000_ops.to_open = mon2000_open;
578
  add_target (&mon2000_ops);
579
 
580
  add_setshow_string_cmd ("download-path", class_obscure, &download_path, _("\
581
Set the default path for downloadable SREC files."), _("\
582
Show the default path for downloadable SREC files."), _("\
583
Determines the default path for downloadable SREC files."),
584
                          NULL,
585
                          NULL, /* FIXME: i18n: The default path for downloadable SREC files is %s.  */
586
                          &setlist, &showlist);
587
 
588
  add_setshow_string_cmd ("board-address", class_obscure, &board_addr, _("\
589
Set IP address for M32R-EVA target board."), _("\
590
Show IP address for M32R-EVA target board."), _("\
591
Determine the IP address for M32R-EVA target board."),
592
                          NULL,
593
                          NULL, /* FIXME: i18n: IP address for M32R-EVA target board is %s.  */
594
                          &setlist, &showlist);
595
 
596
  add_setshow_string_cmd ("server-address", class_obscure, &server_addr, _("\
597
Set IP address for download server (GDB's host computer)."), _("\
598
Show IP address for download server (GDB's host computer)."), _("\
599
Determine the IP address for download server (GDB's host computer)."),
600
                          NULL,
601
                          NULL, /* FIXME: i18n: IP address for download server (GDB's host computer) is %s.  */
602
                          &setlist, &showlist);
603
 
604
  add_com ("upload", class_obscure, m32r_upload_command, _("\
605
Upload the srec file via the monitor's Ethernet upload capability."));
606
 
607
  add_com ("tload", class_obscure, m32r_load, _("test upload command."));
608
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.