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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [exec.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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