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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [exec.c] - Blame information for rev 816

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Work with executable files, for GDB.
2
 
3
   Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4
   1998, 1999, 2000, 2001, 2002, 2003, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "frame.h"
24
#include "inferior.h"
25
#include "target.h"
26
#include "gdbcmd.h"
27
#include "language.h"
28
#include "symfile.h"
29
#include "objfiles.h"
30
#include "completer.h"
31
#include "value.h"
32
#include "exec.h"
33
#include "observer.h"
34
#include "arch-utils.c"
35
 
36
#include <fcntl.h>
37
#include "readline/readline.h"
38
#include "gdb_string.h"
39
 
40
#include "gdbcore.h"
41
 
42
#include <ctype.h>
43
#include "gdb_stat.h"
44
 
45
#include "xcoffsolib.h"
46
 
47
struct vmap *map_vmap (bfd *, bfd *);
48
 
49
void (*deprecated_file_changed_hook) (char *);
50
 
51
/* Prototypes for local functions */
52
 
53
static void exec_close (int);
54
 
55
static void file_command (char *, int);
56
 
57
static void set_section_command (char *, int);
58
 
59
static void exec_files_info (struct target_ops *);
60
 
61
static void init_exec_ops (void);
62
 
63
void _initialize_exec (void);
64
 
65
/* The target vector for executable files.  */
66
 
67
struct target_ops exec_ops;
68
 
69
/* The Binary File Descriptor handle for the executable file.  */
70
 
71
bfd *exec_bfd = NULL;
72
 
73
/* Whether to open exec and core files read-only or read-write.  */
74
 
75
int write_files = 0;
76
static void
77
show_write_files (struct ui_file *file, int from_tty,
78
                  struct cmd_list_element *c, const char *value)
79
{
80
  fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
81
                    value);
82
}
83
 
84
 
85
struct vmap *vmap;
86
 
87
static void
88
exec_open (char *args, int from_tty)
89
{
90
  target_preopen (from_tty);
91
  exec_file_attach (args, from_tty);
92
}
93
 
94
static void
95
exec_close (int quitting)
96
{
97
  int need_symtab_cleanup = 0;
98
  struct vmap *vp, *nxt;
99
 
100
  for (nxt = vmap; nxt != NULL;)
101
    {
102
      vp = nxt;
103
      nxt = vp->nxt;
104
 
105
      /* if there is an objfile associated with this bfd,
106
         free_objfile() will do proper cleanup of objfile *and* bfd. */
107
 
108
      if (vp->objfile)
109
        {
110
          free_objfile (vp->objfile);
111
          need_symtab_cleanup = 1;
112
        }
113
      else if (vp->bfd != exec_bfd)
114
        /* FIXME-leak: We should be freeing vp->name too, I think.  */
115
        if (!bfd_close (vp->bfd))
116
          warning (_("cannot close \"%s\": %s"),
117
                   vp->name, bfd_errmsg (bfd_get_error ()));
118
 
119
      /* FIXME: This routine is #if 0'd in symfile.c.  What should we
120
         be doing here?  Should we just free everything in
121
         vp->objfile->symtabs?  Should free_objfile do that?
122
         FIXME-as-well: free_objfile already free'd vp->name, so it isn't
123
         valid here.  */
124
      free_named_symtabs (vp->name);
125
      xfree (vp);
126
    }
127
 
128
  vmap = NULL;
129
 
130
  if (exec_bfd)
131
    {
132
      char *name = bfd_get_filename (exec_bfd);
133
 
134
      if (!bfd_close (exec_bfd))
135
        warning (_("cannot close \"%s\": %s"),
136
                 name, bfd_errmsg (bfd_get_error ()));
137
      xfree (name);
138
      exec_bfd = NULL;
139
    }
140
 
141
  if (exec_ops.to_sections)
142
    {
143
      xfree (exec_ops.to_sections);
144
      exec_ops.to_sections = NULL;
145
      exec_ops.to_sections_end = NULL;
146
    }
147
}
148
 
149
void
150
exec_file_clear (int from_tty)
151
{
152
  /* Remove exec file.  */
153
  unpush_target (&exec_ops);
154
 
155
  if (from_tty)
156
    printf_unfiltered (_("No executable file now.\n"));
157
}
158
 
159
/*  Process the first arg in ARGS as the new exec file.
160
 
161
   This function is intended to be behave essentially the same
162
   as exec_file_command, except that the latter will detect when
163
   a target is being debugged, and will ask the user whether it
164
   should be shut down first.  (If the answer is "no", then the
165
   new file is ignored.)
166
 
167
   This file is used by exec_file_command, to do the work of opening
168
   and processing the exec file after any prompting has happened.
169
 
170
   And, it is used by child_attach, when the attach command was
171
   given a pid but not a exec pathname, and the attach command could
172
   figure out the pathname from the pid.  (In this case, we shouldn't
173
   ask the user whether the current target should be shut down --
174
   we're supplying the exec pathname late for good reason.)
175
 
176
   ARGS is assumed to be the filename. */
177
 
178
void
179
exec_file_attach (char *filename, int from_tty)
180
{
181
  /* Remove any previous exec file.  */
182
  unpush_target (&exec_ops);
183
 
184
  /* Now open and digest the file the user requested, if any.  */
185
 
186
  if (!filename)
187
    {
188
      if (from_tty)
189
        printf_unfiltered (_("No executable file now.\n"));
190
 
191
      set_gdbarch_from_file (NULL);
192
    }
193
  else
194
    {
195
      char *scratch_pathname;
196
      int scratch_chan;
197
 
198
      scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
199
                   write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
200
                            &scratch_pathname);
201
#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
202
      if (scratch_chan < 0)
203
        {
204
          char *exename = alloca (strlen (filename) + 5);
205
          strcat (strcpy (exename, filename), ".exe");
206
          scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
207
             write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
208
             &scratch_pathname);
209
        }
210
#endif
211
      if (scratch_chan < 0)
212
        perror_with_name (filename);
213
      exec_bfd = bfd_fopen (scratch_pathname, gnutarget,
214
                            write_files ? FOPEN_RUB : FOPEN_RB,
215
                            scratch_chan);
216
 
217
      if (!exec_bfd)
218
        error (_("\"%s\": could not open as an executable file: %s"),
219
               scratch_pathname, bfd_errmsg (bfd_get_error ()));
220
 
221
      /* At this point, scratch_pathname and exec_bfd->name both point to the
222
         same malloc'd string.  However exec_close() will attempt to free it
223
         via the exec_bfd->name pointer, so we need to make another copy and
224
         leave exec_bfd as the new owner of the original copy. */
225
      scratch_pathname = xstrdup (scratch_pathname);
226
      make_cleanup (xfree, scratch_pathname);
227
 
228
      if (!bfd_check_format (exec_bfd, bfd_object))
229
        {
230
          /* Make sure to close exec_bfd, or else "run" might try to use
231
             it.  */
232
          exec_close (0);
233
          error (_("\"%s\": not in executable format: %s"),
234
                 scratch_pathname, bfd_errmsg (bfd_get_error ()));
235
        }
236
 
237
      /* FIXME - This should only be run for RS6000, but the ifdef is a poor
238
         way to accomplish.  */
239
#ifdef DEPRECATED_IBM6000_TARGET
240
      /* Setup initial vmap. */
241
 
242
      map_vmap (exec_bfd, 0);
243
      if (vmap == NULL)
244
        {
245
          /* Make sure to close exec_bfd, or else "run" might try to use
246
             it.  */
247
          exec_close (0);
248
          error (_("\"%s\": can't find the file sections: %s"),
249
                 scratch_pathname, bfd_errmsg (bfd_get_error ()));
250
        }
251
#endif /* DEPRECATED_IBM6000_TARGET */
252
 
253
      if (build_section_table (exec_bfd, &exec_ops.to_sections,
254
                               &exec_ops.to_sections_end))
255
        {
256
          /* Make sure to close exec_bfd, or else "run" might try to use
257
             it.  */
258
          exec_close (0);
259
          error (_("\"%s\": can't find the file sections: %s"),
260
                 scratch_pathname, bfd_errmsg (bfd_get_error ()));
261
        }
262
 
263
      validate_files ();
264
 
265
      set_gdbarch_from_file (exec_bfd);
266
 
267
      push_target (&exec_ops);
268
 
269
      /* Tell display code (if any) about the changed file name.  */
270
      if (deprecated_exec_file_display_hook)
271
        (*deprecated_exec_file_display_hook) (filename);
272
    }
273
  bfd_cache_close_all ();
274
  observer_notify_executable_changed (NULL);
275
}
276
 
277
/*  Process the first arg in ARGS as the new exec file.
278
 
279
   Note that we have to explicitly ignore additional args, since we can
280
   be called from file_command(), which also calls symbol_file_command()
281
   which can take multiple args.
282
 
283
   If ARGS is NULL, we just want to close the exec file. */
284
 
285
static void
286
exec_file_command (char *args, int from_tty)
287
{
288
  char **argv;
289
  char *filename;
290
 
291
  if (from_tty && target_has_execution
292
      && !query (_("A program is being debugged already.\n"
293
                   "Are you sure you want to change the file? ")))
294
    error (_("File not changed."));
295
 
296
  if (args)
297
    {
298
      /* Scan through the args and pick up the first non option arg
299
         as the filename.  */
300
 
301
      argv = buildargv (args);
302
      if (argv == NULL)
303
        nomem (0);
304
 
305
      make_cleanup_freeargv (argv);
306
 
307
      for (; (*argv != NULL) && (**argv == '-'); argv++)
308
        {;
309
        }
310
      if (*argv == NULL)
311
        error (_("No executable file name was specified"));
312
 
313
      filename = tilde_expand (*argv);
314
      make_cleanup (xfree, filename);
315
      exec_file_attach (filename, from_tty);
316
    }
317
  else
318
    exec_file_attach (NULL, from_tty);
319
}
320
 
321
/* Set both the exec file and the symbol file, in one command.
322
   What a novelty.  Why did GDB go through four major releases before this
323
   command was added?  */
324
 
325
static void
326
file_command (char *arg, int from_tty)
327
{
328
  /* FIXME, if we lose on reading the symbol file, we should revert
329
     the exec file, but that's rough.  */
330
  exec_file_command (arg, from_tty);
331
  symbol_file_command (arg, from_tty);
332
  if (deprecated_file_changed_hook)
333
    deprecated_file_changed_hook (arg);
334
}
335
 
336
 
337
/* Locate all mappable sections of a BFD file.
338
   table_pp_char is a char * to get it through bfd_map_over_sections;
339
   we cast it back to its proper type.  */
340
 
341
static void
342
add_to_section_table (bfd *abfd, struct bfd_section *asect,
343
                      void *table_pp_char)
344
{
345
  struct section_table **table_pp = (struct section_table **) table_pp_char;
346
  flagword aflag;
347
 
348
  /* Check the section flags, but do not discard zero-length sections, since
349
     some symbols may still be attached to this section.  For instance, we
350
     encountered on sparc-solaris 2.10 a shared library with an empty .bss
351
     section to which a symbol named "_end" was attached.  The address
352
     of this symbol still needs to be relocated.  */
353
  aflag = bfd_get_section_flags (abfd, asect);
354
  if (!(aflag & SEC_ALLOC))
355
    return;
356
 
357
  (*table_pp)->bfd = abfd;
358
  (*table_pp)->the_bfd_section = asect;
359
  (*table_pp)->addr = bfd_section_vma (abfd, asect);
360
  (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
361
  (*table_pp)++;
362
}
363
 
364
/* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
365
   Returns 0 if OK, 1 on error.  */
366
 
367
int
368
build_section_table (struct bfd *some_bfd, struct section_table **start,
369
                     struct section_table **end)
370
{
371
  unsigned count;
372
 
373
  count = bfd_count_sections (some_bfd);
374
  if (*start)
375
    xfree (* start);
376
  *start = (struct section_table *) xmalloc (count * sizeof (**start));
377
  *end = *start;
378
  bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
379
  if (*end > *start + count)
380
    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
381
  /* We could realloc the table, but it probably loses for most files.  */
382
  return 0;
383
}
384
 
385
static void
386
bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
387
{
388
  struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
389
  struct vmap *vp;
390
 
391
  vp = vmap_bfd->pvmap;
392
 
393
  if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
394
    return;
395
 
396
  if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
397
    {
398
      vp->tstart = bfd_section_vma (abfd, sect);
399
      vp->tend = vp->tstart + bfd_section_size (abfd, sect);
400
      vp->tvma = bfd_section_vma (abfd, sect);
401
      vp->toffs = sect->filepos;
402
    }
403
  else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
404
    {
405
      vp->dstart = bfd_section_vma (abfd, sect);
406
      vp->dend = vp->dstart + bfd_section_size (abfd, sect);
407
      vp->dvma = bfd_section_vma (abfd, sect);
408
    }
409
  /* Silently ignore other types of sections. (FIXME?)  */
410
}
411
 
412
/* Make a vmap for ABFD which might be a member of the archive ARCH.
413
   Return the new vmap.  */
414
 
415
struct vmap *
416
map_vmap (bfd *abfd, bfd *arch)
417
{
418
  struct vmap_and_bfd vmap_bfd;
419
  struct vmap *vp, **vpp;
420
 
421
  vp = (struct vmap *) xmalloc (sizeof (*vp));
422
  memset ((char *) vp, '\0', sizeof (*vp));
423
  vp->nxt = 0;
424
  vp->bfd = abfd;
425
  vp->name = bfd_get_filename (arch ? arch : abfd);
426
  vp->member = arch ? bfd_get_filename (abfd) : "";
427
 
428
  vmap_bfd.pbfd = arch;
429
  vmap_bfd.pvmap = vp;
430
  bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
431
 
432
  /* Find the end of the list and append. */
433
  for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
434
    ;
435
  *vpp = vp;
436
 
437
  return vp;
438
}
439
 
440
/* Read or write the exec file.
441
 
442
   Args are address within a BFD file, address within gdb address-space,
443
   length, and a flag indicating whether to read or write.
444
 
445
   Result is a length:
446
 
447
   0:    We cannot handle this address and length.
448
   > 0:  We have handled N bytes starting at this address.
449
   (If N == length, we did it all.)  We might be able
450
   to handle more bytes beyond this length, but no
451
   promises.
452
   < 0:  We cannot handle this address, but if somebody
453
   else handles (-N) bytes, we can start from there.
454
 
455
   The same routine is used to handle both core and exec files;
456
   we just tail-call it with more arguments to select between them.  */
457
 
458
int
459
xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
460
             struct mem_attrib *attrib, struct target_ops *target)
461
{
462
  int res;
463
  struct section_table *p;
464
  CORE_ADDR nextsectaddr, memend;
465
  asection *section = NULL;
466
 
467
  if (len <= 0)
468
    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
469
 
470
  if (overlay_debugging)
471
    {
472
      section = find_pc_overlay (memaddr);
473
      if (pc_in_unmapped_range (memaddr, section))
474
        memaddr = overlay_mapped_address (memaddr, section);
475
    }
476
 
477
  memend = memaddr + len;
478
  nextsectaddr = memend;
479
 
480
  for (p = target->to_sections; p < target->to_sections_end; p++)
481
    {
482
      if (overlay_debugging && section &&
483
          strcmp (section->name, p->the_bfd_section->name) != 0)
484
        continue;               /* not the section we need */
485
      if (memaddr >= p->addr)
486
        {
487
          if (memend <= p->endaddr)
488
            {
489
              /* Entire transfer is within this section.  */
490
              if (write)
491
                res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
492
                                                myaddr, memaddr - p->addr,
493
                                                len);
494
              else
495
                res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
496
                                                myaddr, memaddr - p->addr,
497
                                                len);
498
              return (res != 0) ? len : 0;
499
            }
500
          else if (memaddr >= p->endaddr)
501
            {
502
              /* This section ends before the transfer starts.  */
503
              continue;
504
            }
505
          else
506
            {
507
              /* This section overlaps the transfer.  Just do half.  */
508
              len = p->endaddr - memaddr;
509
              if (write)
510
                res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
511
                                                myaddr, memaddr - p->addr,
512
                                                len);
513
              else
514
                res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
515
                                                myaddr, memaddr - p->addr,
516
                                                len);
517
              return (res != 0) ? len : 0;
518
            }
519
        }
520
      else
521
        nextsectaddr = min (nextsectaddr, p->addr);
522
    }
523
 
524
  if (nextsectaddr >= memend)
525
    return 0;                    /* We can't help */
526
  else
527
    return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
528
}
529
 
530
 
531
void
532
print_section_info (struct target_ops *t, bfd *abfd)
533
{
534
  struct section_table *p;
535
  /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
536
  int wid = gdbarch_addr_bit (gdbarch_from_bfd (abfd)) <= 32 ? 8 : 16;
537
 
538
  printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
539
  wrap_here ("        ");
540
  printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
541
  if (abfd == exec_bfd)
542
    {
543
      printf_filtered (_("\tEntry point: "));
544
      fputs_filtered (paddress (bfd_get_start_address (abfd)), gdb_stdout);
545
    }
546
  for (p = t->to_sections; p < t->to_sections_end; p++)
547
    {
548
      printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
549
      printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
550
 
551
      /* FIXME: A format of "08l" is not wide enough for file offsets
552
         larger than 4GB.  OTOH, making it "016l" isn't desirable either
553
         since most output will then be much wider than necessary.  It
554
         may make sense to test the size of the file and choose the
555
         format string accordingly.  */
556
      /* FIXME: i18n: Need to rewrite this sentence.  */
557
      if (info_verbose)
558
        printf_filtered (" @ %s",
559
                         hex_string_custom (p->the_bfd_section->filepos, 8));
560
      printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
561
      if (p->bfd != abfd)
562
        printf_filtered (" in %s", bfd_get_filename (p->bfd));
563
      printf_filtered ("\n");
564
    }
565
}
566
 
567
static void
568
exec_files_info (struct target_ops *t)
569
{
570
  print_section_info (t, exec_bfd);
571
 
572
  if (vmap)
573
    {
574
      struct vmap *vp;
575
 
576
      printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
577
      printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
578
                         strlen_paddr (), "tstart",
579
                         strlen_paddr (), "tend",
580
                         strlen_paddr (), "dstart",
581
                         strlen_paddr (), "dend",
582
                         "section",
583
                         "file(member)");
584
 
585
      for (vp = vmap; vp; vp = vp->nxt)
586
        printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
587
                           paddr (vp->tstart),
588
                           paddr (vp->tend),
589
                           paddr (vp->dstart),
590
                           paddr (vp->dend),
591
                           vp->name,
592
                           *vp->member ? "(" : "", vp->member,
593
                           *vp->member ? ")" : "");
594
    }
595
}
596
 
597
/* msnyder 5/21/99:
598
   exec_set_section_offsets sets the offsets of all the sections
599
   in the exec objfile.  */
600
 
601
void
602
exec_set_section_offsets (bfd_signed_vma text_off, bfd_signed_vma data_off,
603
                          bfd_signed_vma bss_off)
604
{
605
  struct section_table *sect;
606
 
607
  for (sect = exec_ops.to_sections;
608
       sect < exec_ops.to_sections_end;
609
       sect++)
610
    {
611
      flagword flags;
612
 
613
      flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
614
 
615
      if (flags & SEC_CODE)
616
        {
617
          sect->addr += text_off;
618
          sect->endaddr += text_off;
619
        }
620
      else if (flags & (SEC_DATA | SEC_LOAD))
621
        {
622
          sect->addr += data_off;
623
          sect->endaddr += data_off;
624
        }
625
      else if (flags & SEC_ALLOC)
626
        {
627
          sect->addr += bss_off;
628
          sect->endaddr += bss_off;
629
        }
630
    }
631
}
632
 
633
static void
634
set_section_command (char *args, int from_tty)
635
{
636
  struct section_table *p;
637
  char *secname;
638
  unsigned seclen;
639
  unsigned long secaddr;
640
  char secprint[100];
641
  long offset;
642
 
643
  if (args == 0)
644
    error (_("Must specify section name and its virtual address"));
645
 
646
  /* Parse out section name */
647
  for (secname = args; !isspace (*args); args++);
648
  seclen = args - secname;
649
 
650
  /* Parse out new virtual address */
651
  secaddr = parse_and_eval_address (args);
652
 
653
  for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
654
    {
655
      if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
656
          && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
657
        {
658
          offset = secaddr - p->addr;
659
          p->addr += offset;
660
          p->endaddr += offset;
661
          if (from_tty)
662
            exec_files_info (&exec_ops);
663
          return;
664
        }
665
    }
666
  if (seclen >= sizeof (secprint))
667
    seclen = sizeof (secprint) - 1;
668
  strncpy (secprint, secname, seclen);
669
  secprint[seclen] = '\0';
670
  error (_("Section %s not found"), secprint);
671
}
672
 
673
/* If we can find a section in FILENAME with BFD index INDEX, and the
674
   user has not assigned an address to it yet (via "set section"), adjust it
675
   to ADDRESS.  */
676
 
677
void
678
exec_set_section_address (const char *filename, int index, CORE_ADDR address)
679
{
680
  struct section_table *p;
681
 
682
  for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
683
    {
684
      if (strcmp (filename, p->bfd->filename) == 0
685
          && index == p->the_bfd_section->index
686
          && p->addr == 0)
687
        {
688
          p->addr = address;
689
          p->endaddr += address;
690
        }
691
    }
692
}
693
 
694
/* If mourn is being called in all the right places, this could be say
695
   `gdb internal error' (since generic_mourn calls
696
   breakpoint_init_inferior).  */
697
 
698
static int
699
ignore (struct bp_target_info *bp_tgt)
700
{
701
  return 0;
702
}
703
 
704
/* Find mapped memory. */
705
 
706
extern void
707
exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
708
                                                    unsigned long,
709
                                                    int, int, int,
710
                                                    void *),
711
                                           void *))
712
{
713
  exec_ops.to_find_memory_regions = func;
714
}
715
 
716
static char *exec_make_note_section (bfd *, int *);
717
 
718
/* Fill in the exec file target vector.  Very few entries need to be
719
   defined.  */
720
 
721
static void
722
init_exec_ops (void)
723
{
724
  exec_ops.to_shortname = "exec";
725
  exec_ops.to_longname = "Local exec file";
726
  exec_ops.to_doc = "Use an executable file as a target.\n\
727
Specify the filename of the executable file.";
728
  exec_ops.to_open = exec_open;
729
  exec_ops.to_close = exec_close;
730
  exec_ops.to_attach = find_default_attach;
731
  exec_ops.deprecated_xfer_memory = xfer_memory;
732
  exec_ops.to_files_info = exec_files_info;
733
  exec_ops.to_insert_breakpoint = ignore;
734
  exec_ops.to_remove_breakpoint = ignore;
735
  exec_ops.to_create_inferior = find_default_create_inferior;
736
  exec_ops.to_stratum = file_stratum;
737
  exec_ops.to_has_memory = 1;
738
  exec_ops.to_make_corefile_notes = exec_make_note_section;
739
  exec_ops.to_magic = OPS_MAGIC;
740
}
741
 
742
void
743
_initialize_exec (void)
744
{
745
  struct cmd_list_element *c;
746
 
747
  init_exec_ops ();
748
 
749
  if (!dbx_commands)
750
    {
751
      c = add_cmd ("file", class_files, file_command, _("\
752
Use FILE as program to be debugged.\n\
753
It is read for its symbols, for getting the contents of pure memory,\n\
754
and it is the program executed when you use the `run' command.\n\
755
If FILE cannot be found as specified, your execution directory path\n\
756
($PATH) is searched for a command of that name.\n\
757
No arg means to have no executable file and no symbols."), &cmdlist);
758
      set_cmd_completer (c, filename_completer);
759
    }
760
 
761
  c = add_cmd ("exec-file", class_files, exec_file_command, _("\
762
Use FILE as program for getting contents of pure memory.\n\
763
If FILE cannot be found as specified, your execution directory path\n\
764
is searched for a command of that name.\n\
765
No arg means have no executable file."), &cmdlist);
766
  set_cmd_completer (c, filename_completer);
767
 
768
  add_com ("section", class_files, set_section_command, _("\
769
Change the base address of section SECTION of the exec file to ADDR.\n\
770
This can be used if the exec file does not contain section addresses,\n\
771
(such as in the a.out format), or when the addresses specified in the\n\
772
file itself are wrong.  Each section must be changed separately.  The\n\
773
``info files'' command lists all the sections and their addresses."));
774
 
775
  add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
776
Set writing into executable and core files."), _("\
777
Show writing into executable and core files."), NULL,
778
                           NULL,
779
                           show_write_files,
780
                           &setlist, &showlist);
781
 
782
  add_target (&exec_ops);
783
}
784
 
785
static char *
786
exec_make_note_section (bfd *obfd, int *note_size)
787
{
788
  error (_("Can't create a corefile"));
789
}

powered by: WebSVN 2.1.0

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