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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [m32r-rom.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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