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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [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 227 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, 2009, 2010
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.h"
35
#include "gdbthread.h"
36
#include "progspace.h"
37
 
38
#include <fcntl.h>
39
#include "readline/readline.h"
40
#include "gdb_string.h"
41
 
42
#include "gdbcore.h"
43
 
44
#include <ctype.h>
45
#include "gdb_stat.h"
46
 
47
#include "xcoffsolib.h"
48
 
49
struct vmap *map_vmap (bfd *, bfd *);
50
 
51
void (*deprecated_file_changed_hook) (char *);
52
 
53
/* Prototypes for local functions */
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
/* True if the exec target is pushed on the stack.  */
70
static int using_exec_ops;
71
 
72
/* Whether to open exec and core files read-only or read-write.  */
73
 
74
int write_files = 0;
75
static void
76
show_write_files (struct ui_file *file, int from_tty,
77
                  struct cmd_list_element *c, const char *value)
78
{
79
  fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
80
                    value);
81
}
82
 
83
 
84
struct vmap *vmap;
85
 
86
static void
87
exec_open (char *args, int from_tty)
88
{
89
  target_preopen (from_tty);
90
  exec_file_attach (args, from_tty);
91
}
92
 
93
/* Close and clear exec_bfd.  If we end up with no target sections to
94
   read memory from, this unpushes the exec_ops target.  */
95
 
96
void
97
exec_close (void)
98
{
99
  if (exec_bfd)
100
    {
101
      bfd *abfd = exec_bfd;
102
      char *name = bfd_get_filename (abfd);
103
 
104
      if (!bfd_close (abfd))
105
        warning (_("cannot close \"%s\": %s"),
106
                 name, bfd_errmsg (bfd_get_error ()));
107
      xfree (name);
108
 
109
      /* Removing target sections may close the exec_ops target.
110
         Clear exec_bfd before doing so to prevent recursion.  */
111
      exec_bfd = NULL;
112
      exec_bfd_mtime = 0;
113
 
114
      remove_target_sections (abfd);
115
    }
116
}
117
 
118
/* This is the target_close implementation.  Clears all target
119
   sections and closes all executable bfds from all program spaces.  */
120
 
121
static void
122
exec_close_1 (int quitting)
123
{
124
  int need_symtab_cleanup = 0;
125
  struct vmap *vp, *nxt;
126
 
127
  using_exec_ops = 0;
128
 
129
  for (nxt = vmap; nxt != NULL;)
130
    {
131
      vp = nxt;
132
      nxt = vp->nxt;
133
 
134
      /* if there is an objfile associated with this bfd,
135
         free_objfile() will do proper cleanup of objfile *and* bfd. */
136
 
137
      if (vp->objfile)
138
        {
139
          free_objfile (vp->objfile);
140
          need_symtab_cleanup = 1;
141
        }
142
      else if (vp->bfd != exec_bfd)
143
        /* FIXME-leak: We should be freeing vp->name too, I think.  */
144
        if (!bfd_close (vp->bfd))
145
          warning (_("cannot close \"%s\": %s"),
146
                   vp->name, bfd_errmsg (bfd_get_error ()));
147
 
148
      xfree (vp);
149
    }
150
 
151
  vmap = NULL;
152
 
153
  {
154
    struct program_space *ss;
155
    struct cleanup *old_chain;
156
 
157
    old_chain = save_current_program_space ();
158
    ALL_PSPACES (ss)
159
    {
160
      set_current_program_space (ss);
161
 
162
      /* Delete all target sections.  */
163
      resize_section_table
164
        (current_target_sections,
165
         -resize_section_table (current_target_sections, 0));
166
 
167
      exec_close ();
168
    }
169
 
170
    do_cleanups (old_chain);
171
  }
172
}
173
 
174
void
175
exec_file_clear (int from_tty)
176
{
177
  /* Remove exec file.  */
178
  exec_close ();
179
 
180
  if (from_tty)
181
    printf_unfiltered (_("No executable file now.\n"));
182
}
183
 
184
/* Set FILENAME as the new exec file.
185
 
186
   This function is intended to be behave essentially the same
187
   as exec_file_command, except that the latter will detect when
188
   a target is being debugged, and will ask the user whether it
189
   should be shut down first.  (If the answer is "no", then the
190
   new file is ignored.)
191
 
192
   This file is used by exec_file_command, to do the work of opening
193
   and processing the exec file after any prompting has happened.
194
 
195
   And, it is used by child_attach, when the attach command was
196
   given a pid but not a exec pathname, and the attach command could
197
   figure out the pathname from the pid.  (In this case, we shouldn't
198
   ask the user whether the current target should be shut down --
199
   we're supplying the exec pathname late for good reason.)  */
200
 
201
void
202
exec_file_attach (char *filename, int from_tty)
203
{
204
  /* Remove any previous exec file.  */
205
  exec_close ();
206
 
207
  /* Now open and digest the file the user requested, if any.  */
208
 
209
  if (!filename)
210
    {
211
      if (from_tty)
212
        printf_unfiltered (_("No executable file now.\n"));
213
 
214
      set_gdbarch_from_file (NULL);
215
    }
216
  else
217
    {
218
      struct cleanup *cleanups;
219
      char *scratch_pathname;
220
      int scratch_chan;
221
      struct target_section *sections = NULL, *sections_end = NULL;
222
      char **matching;
223
 
224
      scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
225
                   write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
226
                            &scratch_pathname);
227
#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
228
      if (scratch_chan < 0)
229
        {
230
          char *exename = alloca (strlen (filename) + 5);
231
          strcat (strcpy (exename, filename), ".exe");
232
          scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
233
             write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
234
             &scratch_pathname);
235
        }
236
#endif
237
      if (scratch_chan < 0)
238
        perror_with_name (filename);
239
      exec_bfd = bfd_fopen (scratch_pathname, gnutarget,
240
                            write_files ? FOPEN_RUB : FOPEN_RB,
241
                            scratch_chan);
242
 
243
      if (!exec_bfd)
244
        {
245
          close (scratch_chan);
246
          error (_("\"%s\": could not open as an executable file: %s"),
247
                 scratch_pathname, bfd_errmsg (bfd_get_error ()));
248
        }
249
 
250
      /* At this point, scratch_pathname and exec_bfd->name both point to the
251
         same malloc'd string.  However exec_close() will attempt to free it
252
         via the exec_bfd->name pointer, so we need to make another copy and
253
         leave exec_bfd as the new owner of the original copy. */
254
      scratch_pathname = xstrdup (scratch_pathname);
255
      cleanups = make_cleanup (xfree, scratch_pathname);
256
 
257
      if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
258
        {
259
          /* Make sure to close exec_bfd, or else "run" might try to use
260
             it.  */
261
          exec_close ();
262
          error (_("\"%s\": not in executable format: %s"),
263
                 scratch_pathname,
264
                 gdb_bfd_errmsg (bfd_get_error (), matching));
265
        }
266
 
267
      /* FIXME - This should only be run for RS6000, but the ifdef is a poor
268
         way to accomplish.  */
269
#ifdef DEPRECATED_IBM6000_TARGET
270
      /* Setup initial vmap. */
271
 
272
      map_vmap (exec_bfd, 0);
273
      if (vmap == NULL)
274
        {
275
          /* Make sure to close exec_bfd, or else "run" might try to use
276
             it.  */
277
          exec_close ();
278
          error (_("\"%s\": can't find the file sections: %s"),
279
                 scratch_pathname, bfd_errmsg (bfd_get_error ()));
280
        }
281
#endif /* DEPRECATED_IBM6000_TARGET */
282
 
283
      if (build_section_table (exec_bfd, &sections, &sections_end))
284
        {
285
          /* Make sure to close exec_bfd, or else "run" might try to use
286
             it.  */
287
          exec_close ();
288
          error (_("\"%s\": can't find the file sections: %s"),
289
                 scratch_pathname, bfd_errmsg (bfd_get_error ()));
290
        }
291
 
292
      exec_bfd_mtime = bfd_get_mtime (exec_bfd);
293
 
294
      validate_files ();
295
 
296
      set_gdbarch_from_file (exec_bfd);
297
 
298
      /* Add the executable's sections to the current address spaces'
299
         list of sections.  This possibly pushes the exec_ops
300
         target.  */
301
      add_target_sections (sections, sections_end);
302
      xfree (sections);
303
 
304
      /* Tell display code (if any) about the changed file name.  */
305
      if (deprecated_exec_file_display_hook)
306
        (*deprecated_exec_file_display_hook) (filename);
307
 
308
      do_cleanups (cleanups);
309
    }
310
  bfd_cache_close_all ();
311
  observer_notify_executable_changed ();
312
}
313
 
314
/*  Process the first arg in ARGS as the new exec file.
315
 
316
   Note that we have to explicitly ignore additional args, since we can
317
   be called from file_command(), which also calls symbol_file_command()
318
   which can take multiple args.
319
 
320
   If ARGS is NULL, we just want to close the exec file. */
321
 
322
static void
323
exec_file_command (char *args, int from_tty)
324
{
325
  char **argv;
326
  char *filename;
327
 
328
  if (from_tty && target_has_execution
329
      && !query (_("A program is being debugged already.\n"
330
                   "Are you sure you want to change the file? ")))
331
    error (_("File not changed."));
332
 
333
  if (args)
334
    {
335
      struct cleanup *cleanups;
336
 
337
      /* Scan through the args and pick up the first non option arg
338
         as the filename.  */
339
 
340
      argv = gdb_buildargv (args);
341
      cleanups = make_cleanup_freeargv (argv);
342
 
343
      for (; (*argv != NULL) && (**argv == '-'); argv++)
344
        {;
345
        }
346
      if (*argv == NULL)
347
        error (_("No executable file name was specified"));
348
 
349
      filename = tilde_expand (*argv);
350
      make_cleanup (xfree, filename);
351
      exec_file_attach (filename, from_tty);
352
 
353
      do_cleanups (cleanups);
354
    }
355
  else
356
    exec_file_attach (NULL, from_tty);
357
}
358
 
359
/* Set both the exec file and the symbol file, in one command.
360
   What a novelty.  Why did GDB go through four major releases before this
361
   command was added?  */
362
 
363
static void
364
file_command (char *arg, int from_tty)
365
{
366
  /* FIXME, if we lose on reading the symbol file, we should revert
367
     the exec file, but that's rough.  */
368
  exec_file_command (arg, from_tty);
369
  symbol_file_command (arg, from_tty);
370
  if (deprecated_file_changed_hook)
371
    deprecated_file_changed_hook (arg);
372
}
373
 
374
 
375
/* Locate all mappable sections of a BFD file.
376
   table_pp_char is a char * to get it through bfd_map_over_sections;
377
   we cast it back to its proper type.  */
378
 
379
static void
380
add_to_section_table (bfd *abfd, struct bfd_section *asect,
381
                      void *table_pp_char)
382
{
383
  struct target_section **table_pp = (struct target_section **) table_pp_char;
384
  flagword aflag;
385
 
386
  /* Check the section flags, but do not discard zero-length sections, since
387
     some symbols may still be attached to this section.  For instance, we
388
     encountered on sparc-solaris 2.10 a shared library with an empty .bss
389
     section to which a symbol named "_end" was attached.  The address
390
     of this symbol still needs to be relocated.  */
391
  aflag = bfd_get_section_flags (abfd, asect);
392
  if (!(aflag & SEC_ALLOC))
393
    return;
394
 
395
  (*table_pp)->bfd = abfd;
396
  (*table_pp)->the_bfd_section = asect;
397
  (*table_pp)->addr = bfd_section_vma (abfd, asect);
398
  (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
399
  (*table_pp)++;
400
}
401
 
402
int
403
resize_section_table (struct target_section_table *table, int num_added)
404
{
405
  struct target_section *old_value;
406
  int old_count;
407
  int new_count;
408
 
409
  old_value = table->sections;
410
  old_count = table->sections_end - table->sections;
411
 
412
  new_count = num_added + old_count;
413
 
414
  if (new_count)
415
    {
416
      table->sections = xrealloc (table->sections,
417
                                  sizeof (struct target_section) * new_count);
418
      table->sections_end = table->sections + new_count;
419
    }
420
  else
421
    {
422
      xfree (table->sections);
423
      table->sections = table->sections_end = NULL;
424
    }
425
 
426
  return old_count;
427
}
428
 
429
/* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
430
   Returns 0 if OK, 1 on error.  */
431
 
432
int
433
build_section_table (struct bfd *some_bfd, struct target_section **start,
434
                     struct target_section **end)
435
{
436
  unsigned count;
437
 
438
  count = bfd_count_sections (some_bfd);
439
  if (*start)
440
    xfree (* start);
441
  *start = (struct target_section *) xmalloc (count * sizeof (**start));
442
  *end = *start;
443
  bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
444
  if (*end > *start + count)
445
    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
446
  /* We could realloc the table, but it probably loses for most files.  */
447
  return 0;
448
}
449
 
450
/* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
451
   current set of target sections.  */
452
 
453
void
454
add_target_sections (struct target_section *sections,
455
                     struct target_section *sections_end)
456
{
457
  int count;
458
  struct target_section_table *table = current_target_sections;
459
 
460
  count = sections_end - sections;
461
 
462
  if (count > 0)
463
    {
464
      int space = resize_section_table (table, count);
465
      memcpy (table->sections + space,
466
              sections, count * sizeof (sections[0]));
467
 
468
      /* If these are the first file sections we can provide memory
469
         from, push the file_stratum target.  */
470
      if (!using_exec_ops)
471
        {
472
          using_exec_ops = 1;
473
          push_target (&exec_ops);
474
        }
475
    }
476
}
477
 
478
/* Remove all target sections taken from ABFD.  */
479
 
480
void
481
remove_target_sections (bfd *abfd)
482
{
483
  struct target_section *src, *dest;
484
 
485
  struct target_section_table *table = current_target_sections;
486
 
487
  dest = table->sections;
488
  for (src = table->sections; src < table->sections_end; src++)
489
    if (src->bfd != abfd)
490
      {
491
        /* Keep this section.  */
492
        if (dest < src)
493
          *dest = *src;
494
        dest++;
495
      }
496
 
497
  /* If we've dropped any sections, resize the section table.  */
498
  if (dest < src)
499
    {
500
      int old_count;
501
 
502
      old_count = resize_section_table (table, dest - src);
503
 
504
      /* If we don't have any more sections to read memory from,
505
         remove the file_stratum target from the stack.  */
506
      if (old_count + (dest - src) == 0)
507
        {
508
          struct program_space *pspace;
509
 
510
          ALL_PSPACES (pspace)
511
            if (pspace->target_sections.sections
512
                != pspace->target_sections.sections_end)
513
              return;
514
 
515
          unpush_target (&exec_ops);
516
        }
517
    }
518
}
519
 
520
 
521
static void
522
bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
523
{
524
  struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
525
  struct vmap *vp;
526
 
527
  vp = vmap_bfd->pvmap;
528
 
529
  if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
530
    return;
531
 
532
  if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
533
    {
534
      vp->tstart = bfd_section_vma (abfd, sect);
535
      vp->tend = vp->tstart + bfd_section_size (abfd, sect);
536
      vp->tvma = bfd_section_vma (abfd, sect);
537
      vp->toffs = sect->filepos;
538
    }
539
  else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
540
    {
541
      vp->dstart = bfd_section_vma (abfd, sect);
542
      vp->dend = vp->dstart + bfd_section_size (abfd, sect);
543
      vp->dvma = bfd_section_vma (abfd, sect);
544
    }
545
  /* Silently ignore other types of sections. (FIXME?)  */
546
}
547
 
548
/* Make a vmap for ABFD which might be a member of the archive ARCH.
549
   Return the new vmap.  */
550
 
551
struct vmap *
552
map_vmap (bfd *abfd, bfd *arch)
553
{
554
  struct vmap_and_bfd vmap_bfd;
555
  struct vmap *vp, **vpp;
556
 
557
  vp = (struct vmap *) xmalloc (sizeof (*vp));
558
  memset ((char *) vp, '\0', sizeof (*vp));
559
  vp->nxt = 0;
560
  vp->bfd = abfd;
561
  vp->name = bfd_get_filename (arch ? arch : abfd);
562
  vp->member = arch ? bfd_get_filename (abfd) : "";
563
 
564
  vmap_bfd.pbfd = arch;
565
  vmap_bfd.pvmap = vp;
566
  bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
567
 
568
  /* Find the end of the list and append. */
569
  for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
570
    ;
571
  *vpp = vp;
572
 
573
  return vp;
574
}
575
 
576
 
577
int
578
section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
579
                                   ULONGEST offset, LONGEST len,
580
                                   struct target_section *sections,
581
                                   struct target_section *sections_end,
582
                                   const char *section_name)
583
{
584
  int res;
585
  struct target_section *p;
586
  ULONGEST memaddr = offset;
587
  ULONGEST memend = memaddr + len;
588
 
589
  if (len <= 0)
590
    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
591
 
592
  for (p = sections; p < sections_end; p++)
593
    {
594
      if (section_name && strcmp (section_name, p->the_bfd_section->name) != 0)
595
        continue;               /* not the section we need */
596
      if (memaddr >= p->addr)
597
        {
598
          if (memend <= p->endaddr)
599
            {
600
              /* Entire transfer is within this section.  */
601
              if (writebuf)
602
                res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
603
                                                writebuf, memaddr - p->addr,
604
                                                len);
605
              else
606
                res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
607
                                                readbuf, memaddr - p->addr,
608
                                                len);
609
              return (res != 0) ? len : 0;
610
            }
611
          else if (memaddr >= p->endaddr)
612
            {
613
              /* This section ends before the transfer starts.  */
614
              continue;
615
            }
616
          else
617
            {
618
              /* This section overlaps the transfer.  Just do half.  */
619
              len = p->endaddr - memaddr;
620
              if (writebuf)
621
                res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
622
                                                writebuf, memaddr - p->addr,
623
                                                len);
624
              else
625
                res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
626
                                                readbuf, memaddr - p->addr,
627
                                                len);
628
              return (res != 0) ? len : 0;
629
            }
630
        }
631
    }
632
 
633
  return 0;                      /* We can't help */
634
}
635
 
636
struct target_section_table *
637
exec_get_section_table (struct target_ops *ops)
638
{
639
  return current_target_sections;
640
}
641
 
642
static LONGEST
643
exec_xfer_partial (struct target_ops *ops, enum target_object object,
644
                   const char *annex, gdb_byte *readbuf,
645
                   const gdb_byte *writebuf,
646
                   ULONGEST offset, LONGEST len)
647
{
648
  struct target_section_table *table = target_get_section_table (ops);
649
 
650
  if (object == TARGET_OBJECT_MEMORY)
651
    return section_table_xfer_memory_partial (readbuf, writebuf,
652
                                              offset, len,
653
                                              table->sections,
654
                                              table->sections_end,
655
                                              NULL);
656
  else
657
    return -1;
658
}
659
 
660
 
661
void
662
print_section_info (struct target_section_table *t, bfd *abfd)
663
{
664
  struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
665
  struct target_section *p;
666
  /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
667
  int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
668
 
669
  printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
670
  wrap_here ("        ");
671
  printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
672
  if (abfd == exec_bfd)
673
    {
674
      /* gcc-3.4 does not like the initialization in <p == t->sections_end>.  */
675
      bfd_vma displacement = 0;
676
 
677
      for (p = t->sections; p < t->sections_end; p++)
678
        {
679
          asection *asect = p->the_bfd_section;
680
 
681
          if ((bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD))
682
              != (SEC_ALLOC | SEC_LOAD))
683
            continue;
684
 
685
          if (bfd_get_section_vma (abfd, asect) <= abfd->start_address
686
              && abfd->start_address < (bfd_get_section_vma (abfd, asect)
687
                                        + bfd_get_section_size (asect)))
688
            {
689
              displacement = p->addr - bfd_get_section_vma (abfd, asect);
690
              break;
691
            }
692
        }
693
      if (p == t->sections_end)
694
        warning (_("Cannot find section for the entry point of %s.\n"),
695
                 bfd_get_filename (abfd));
696
 
697
      printf_filtered (_("\tEntry point: %s\n"),
698
                       paddress (gdbarch, (bfd_get_start_address (abfd)
699
                                           + displacement)));
700
    }
701
  for (p = t->sections; p < t->sections_end; p++)
702
    {
703
      printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
704
      printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
705
 
706
      /* FIXME: A format of "08l" is not wide enough for file offsets
707
         larger than 4GB.  OTOH, making it "016l" isn't desirable either
708
         since most output will then be much wider than necessary.  It
709
         may make sense to test the size of the file and choose the
710
         format string accordingly.  */
711
      /* FIXME: i18n: Need to rewrite this sentence.  */
712
      if (info_verbose)
713
        printf_filtered (" @ %s",
714
                         hex_string_custom (p->the_bfd_section->filepos, 8));
715
      printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
716
      if (p->bfd != abfd)
717
        printf_filtered (" in %s", bfd_get_filename (p->bfd));
718
      printf_filtered ("\n");
719
    }
720
}
721
 
722
static void
723
exec_files_info (struct target_ops *t)
724
{
725
  print_section_info (current_target_sections, exec_bfd);
726
 
727
  if (vmap)
728
    {
729
      int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
730
      struct vmap *vp;
731
 
732
      printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
733
      printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
734
                         addr_size * 2, "tstart",
735
                         addr_size * 2, "tend",
736
                         addr_size * 2, "dstart",
737
                         addr_size * 2, "dend",
738
                         "section",
739
                         "file(member)");
740
 
741
      for (vp = vmap; vp; vp = vp->nxt)
742
        printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
743
                           phex (vp->tstart, addr_size),
744
                           phex (vp->tend, addr_size),
745
                           phex (vp->dstart, addr_size),
746
                           phex (vp->dend, addr_size),
747
                           vp->name,
748
                           *vp->member ? "(" : "", vp->member,
749
                           *vp->member ? ")" : "");
750
    }
751
}
752
 
753
static void
754
set_section_command (char *args, int from_tty)
755
{
756
  struct target_section *p;
757
  char *secname;
758
  unsigned seclen;
759
  unsigned long secaddr;
760
  char secprint[100];
761
  long offset;
762
  struct target_section_table *table;
763
 
764
  if (args == 0)
765
    error (_("Must specify section name and its virtual address"));
766
 
767
  /* Parse out section name */
768
  for (secname = args; !isspace (*args); args++);
769
  seclen = args - secname;
770
 
771
  /* Parse out new virtual address */
772
  secaddr = parse_and_eval_address (args);
773
 
774
  table = current_target_sections;
775
  for (p = table->sections; p < table->sections_end; p++)
776
    {
777
      if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
778
          && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
779
        {
780
          offset = secaddr - p->addr;
781
          p->addr += offset;
782
          p->endaddr += offset;
783
          if (from_tty)
784
            exec_files_info (&exec_ops);
785
          return;
786
        }
787
    }
788
  if (seclen >= sizeof (secprint))
789
    seclen = sizeof (secprint) - 1;
790
  strncpy (secprint, secname, seclen);
791
  secprint[seclen] = '\0';
792
  error (_("Section %s not found"), secprint);
793
}
794
 
795
/* If we can find a section in FILENAME with BFD index INDEX, adjust
796
   it to ADDRESS.  */
797
 
798
void
799
exec_set_section_address (const char *filename, int index, CORE_ADDR address)
800
{
801
  struct target_section *p;
802
  struct target_section_table *table;
803
 
804
  table = current_target_sections;
805
  for (p = table->sections; p < table->sections_end; p++)
806
    {
807
      if (strcmp (filename, p->bfd->filename) == 0
808
          && index == p->the_bfd_section->index)
809
        {
810
          p->endaddr += address - p->addr;
811
          p->addr = address;
812
        }
813
    }
814
}
815
 
816
/* If mourn is being called in all the right places, this could be say
817
   `gdb internal error' (since generic_mourn calls
818
   breakpoint_init_inferior).  */
819
 
820
static int
821
ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
822
{
823
  return 0;
824
}
825
 
826
static int
827
exec_has_memory (struct target_ops *ops)
828
{
829
  /* We can provide memory if we have any file/target sections to read
830
     from.  */
831
  return (current_target_sections->sections
832
          != current_target_sections->sections_end);
833
}
834
 
835
/* Find mapped memory. */
836
 
837
extern void
838
exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
839
                                                    unsigned long,
840
                                                    int, int, int,
841
                                                    void *),
842
                                           void *))
843
{
844
  exec_ops.to_find_memory_regions = func;
845
}
846
 
847
static char *exec_make_note_section (bfd *, int *);
848
 
849
/* Fill in the exec file target vector.  Very few entries need to be
850
   defined.  */
851
 
852
static void
853
init_exec_ops (void)
854
{
855
  exec_ops.to_shortname = "exec";
856
  exec_ops.to_longname = "Local exec file";
857
  exec_ops.to_doc = "Use an executable file as a target.\n\
858
Specify the filename of the executable file.";
859
  exec_ops.to_open = exec_open;
860
  exec_ops.to_close = exec_close_1;
861
  exec_ops.to_attach = find_default_attach;
862
  exec_ops.to_xfer_partial = exec_xfer_partial;
863
  exec_ops.to_get_section_table = exec_get_section_table;
864
  exec_ops.to_files_info = exec_files_info;
865
  exec_ops.to_insert_breakpoint = ignore;
866
  exec_ops.to_remove_breakpoint = ignore;
867
  exec_ops.to_create_inferior = find_default_create_inferior;
868
  exec_ops.to_stratum = file_stratum;
869
  exec_ops.to_has_memory = exec_has_memory;
870
  exec_ops.to_make_corefile_notes = exec_make_note_section;
871
  exec_ops.to_magic = OPS_MAGIC;
872
}
873
 
874
void
875
_initialize_exec (void)
876
{
877
  struct cmd_list_element *c;
878
 
879
  init_exec_ops ();
880
 
881
  if (!dbx_commands)
882
    {
883
      c = add_cmd ("file", class_files, file_command, _("\
884
Use FILE as program to be debugged.\n\
885
It is read for its symbols, for getting the contents of pure memory,\n\
886
and it is the program executed when you use the `run' command.\n\
887
If FILE cannot be found as specified, your execution directory path\n\
888
($PATH) is searched for a command of that name.\n\
889
No arg means to have no executable file and no symbols."), &cmdlist);
890
      set_cmd_completer (c, filename_completer);
891
    }
892
 
893
  c = add_cmd ("exec-file", class_files, exec_file_command, _("\
894
Use FILE as program for getting contents of pure memory.\n\
895
If FILE cannot be found as specified, your execution directory path\n\
896
is searched for a command of that name.\n\
897
No arg means have no executable file."), &cmdlist);
898
  set_cmd_completer (c, filename_completer);
899
 
900
  add_com ("section", class_files, set_section_command, _("\
901
Change the base address of section SECTION of the exec file to ADDR.\n\
902
This can be used if the exec file does not contain section addresses,\n\
903
(such as in the a.out format), or when the addresses specified in the\n\
904
file itself are wrong.  Each section must be changed separately.  The\n\
905
``info files'' command lists all the sections and their addresses."));
906
 
907
  add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
908
Set writing into executable and core files."), _("\
909
Show writing into executable and core files."), NULL,
910
                           NULL,
911
                           show_write_files,
912
                           &setlist, &showlist);
913
 
914
  add_target (&exec_ops);
915
}
916
 
917
static char *
918
exec_make_note_section (bfd *obfd, int *note_size)
919
{
920
  error (_("Can't create a corefile"));
921
}

powered by: WebSVN 2.1.0

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