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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Generate a core file for the inferior process.
2
 
3
   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "elf-bfd.h"
23
#include "infcall.h"
24
#include "inferior.h"
25
#include "gdbcore.h"
26
#include "objfiles.h"
27
#include "symfile.h"
28
 
29
#include "cli/cli-decode.h"
30
 
31
#include "gdb_assert.h"
32
 
33
/* The largest amount of memory to read from the target at once.  We
34
   must throttle it to limit the amount of memory used by GDB during
35
   generate-core-file for programs with large resident data.  */
36
#define MAX_COPY_BYTES (1024 * 1024)
37
 
38
static char *default_gcore_target (void);
39
static enum bfd_architecture default_gcore_arch (void);
40
static unsigned long default_gcore_mach (void);
41
static int gcore_memory_sections (bfd *);
42
 
43
/* Generate a core file from the inferior process.  */
44
 
45
static void
46
gcore_command (char *args, int from_tty)
47
{
48
  struct cleanup *old_chain;
49
  char *corefilename, corefilename_buffer[40];
50
  asection *note_sec = NULL;
51
  bfd *obfd;
52
  void *note_data = NULL;
53
  int note_size = 0;
54
 
55
  /* No use generating a corefile without a target process.  */
56
  if (!target_has_execution)
57
    noprocess ();
58
 
59
  if (args && *args)
60
    corefilename = args;
61
  else
62
    {
63
      /* Default corefile name is "core.PID".  */
64
      sprintf (corefilename_buffer, "core.%d", PIDGET (inferior_ptid));
65
      corefilename = corefilename_buffer;
66
    }
67
 
68
  if (info_verbose)
69
    fprintf_filtered (gdb_stdout,
70
                      "Opening corefile '%s' for output.\n", corefilename);
71
 
72
  /* Open the output file.  */
73
  obfd = bfd_openw (corefilename, default_gcore_target ());
74
  if (!obfd)
75
    error (_("Failed to open '%s' for output."), corefilename);
76
 
77
  /* Need a cleanup that will close the file (FIXME: delete it?).  */
78
  old_chain = make_cleanup_bfd_close (obfd);
79
 
80
  bfd_set_format (obfd, bfd_core);
81
  bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ());
82
 
83
  /* An external target method must build the notes section.  */
84
  note_data = target_make_corefile_notes (obfd, &note_size);
85
 
86
  /* Create the note section.  */
87
  if (note_data != NULL && note_size != 0)
88
    {
89
      note_sec = bfd_make_section_anyway_with_flags (obfd, "note0",
90
                                                     SEC_HAS_CONTENTS
91
                                                     | SEC_READONLY
92
                                                     | SEC_ALLOC);
93
      if (note_sec == NULL)
94
        error (_("Failed to create 'note' section for corefile: %s"),
95
               bfd_errmsg (bfd_get_error ()));
96
 
97
      bfd_set_section_vma (obfd, note_sec, 0);
98
      bfd_set_section_alignment (obfd, note_sec, 0);
99
      bfd_set_section_size (obfd, note_sec, note_size);
100
    }
101
 
102
  /* Now create the memory/load sections.  */
103
  if (gcore_memory_sections (obfd) == 0)
104
    error (_("gcore: failed to get corefile memory sections from target."));
105
 
106
  /* Write out the contents of the note section.  */
107
  if (note_data != NULL && note_size != 0)
108
    {
109
      if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size))
110
        warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ()));
111
    }
112
 
113
  /* Succeeded.  */
114
  fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename);
115
 
116
  /* Clean-ups will close the output file and free malloc memory.  */
117
  do_cleanups (old_chain);
118
  return;
119
}
120
 
121
static unsigned long
122
default_gcore_mach (void)
123
{
124
#if 1   /* See if this even matters...  */
125
  return 0;
126
#else
127
 
128
  const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (current_gdbarch);
129
 
130
  if (bfdarch != NULL)
131
    return bfdarch->mach;
132
  if (exec_bfd == NULL)
133
    error (_("Can't find default bfd machine type (need execfile)."));
134
 
135
  return bfd_get_mach (exec_bfd);
136
#endif /* 1 */
137
}
138
 
139
static enum bfd_architecture
140
default_gcore_arch (void)
141
{
142
  const struct bfd_arch_info * bfdarch = gdbarch_bfd_arch_info
143
                                         (current_gdbarch);
144
 
145
  if (bfdarch != NULL)
146
    return bfdarch->arch;
147
  if (exec_bfd == NULL)
148
    error (_("Can't find bfd architecture for corefile (need execfile)."));
149
 
150
  return bfd_get_arch (exec_bfd);
151
}
152
 
153
static char *
154
default_gcore_target (void)
155
{
156
  /* FIXME: This may only work for ELF targets.  */
157
  if (exec_bfd == NULL)
158
    return NULL;
159
  else
160
    return bfd_get_target (exec_bfd);
161
}
162
 
163
/* Derive a reasonable stack segment by unwinding the target stack,
164
   and store its limits in *BOTTOM and *TOP.  Return non-zero if
165
   successful.  */
166
 
167
static int
168
derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
169
{
170
  struct frame_info *fi, *tmp_fi;
171
 
172
  gdb_assert (bottom);
173
  gdb_assert (top);
174
 
175
  /* Can't succeed without stack and registers.  */
176
  if (!target_has_stack || !target_has_registers)
177
    return 0;
178
 
179
  /* Can't succeed without current frame.  */
180
  fi = get_current_frame ();
181
  if (fi == NULL)
182
    return 0;
183
 
184
  /* Save frame pointer of TOS frame.  */
185
  *top = get_frame_base (fi);
186
  /* If current stack pointer is more "inner", use that instead.  */
187
  if (gdbarch_inner_than (get_frame_arch (fi), get_frame_sp (fi), *top))
188
    *top = get_frame_sp (fi);
189
 
190
  /* Find prev-most frame.  */
191
  while ((tmp_fi = get_prev_frame (fi)) != NULL)
192
    fi = tmp_fi;
193
 
194
  /* Save frame pointer of prev-most frame.  */
195
  *bottom = get_frame_base (fi);
196
 
197
  /* Now canonicalize their order, so that BOTTOM is a lower address
198
     (as opposed to a lower stack frame).  */
199
  if (*bottom > *top)
200
    {
201
      bfd_vma tmp_vma;
202
 
203
      tmp_vma = *top;
204
      *top = *bottom;
205
      *bottom = tmp_vma;
206
    }
207
 
208
  return 1;
209
}
210
 
211
/* Derive a reasonable heap segment for ABFD by looking at sbrk and
212
   the static data sections.  Store its limits in *BOTTOM and *TOP.
213
   Return non-zero if successful.  */
214
 
215
static int
216
derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
217
{
218
  bfd_vma top_of_data_memory = 0;
219
  bfd_vma top_of_heap = 0;
220
  bfd_size_type sec_size;
221
  struct value *zero, *sbrk;
222
  bfd_vma sec_vaddr;
223
  asection *sec;
224
 
225
  gdb_assert (bottom);
226
  gdb_assert (top);
227
 
228
  /* This function depends on being able to call a function in the
229
     inferior.  */
230
  if (!target_has_execution)
231
    return 0;
232
 
233
  /* The following code assumes that the link map is arranged as
234
     follows (low to high addresses):
235
 
236
     ---------------------------------
237
     | text sections                 |
238
     ---------------------------------
239
     | data sections (including bss) |
240
     ---------------------------------
241
     | heap                          |
242
     --------------------------------- */
243
 
244
  for (sec = abfd->sections; sec; sec = sec->next)
245
    {
246
      if (bfd_get_section_flags (abfd, sec) & SEC_DATA
247
          || strcmp (".bss", bfd_section_name (abfd, sec)) == 0)
248
        {
249
          sec_vaddr = bfd_get_section_vma (abfd, sec);
250
          sec_size = bfd_get_section_size (sec);
251
          if (sec_vaddr + sec_size > top_of_data_memory)
252
            top_of_data_memory = sec_vaddr + sec_size;
253
        }
254
    }
255
 
256
  /* Now get the top-of-heap by calling sbrk in the inferior.  */
257
  if (lookup_minimal_symbol ("sbrk", NULL, NULL) != NULL)
258
    {
259
      sbrk = find_function_in_inferior ("sbrk");
260
      if (sbrk == NULL)
261
        return 0;
262
    }
263
  else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) != NULL)
264
    {
265
      sbrk = find_function_in_inferior ("_sbrk");
266
      if (sbrk == NULL)
267
        return 0;
268
    }
269
  else
270
    return 0;
271
 
272
  zero = value_from_longest (builtin_type_int, 0);
273
  gdb_assert (zero);
274
  sbrk = call_function_by_hand (sbrk, 1, &zero);
275
  if (sbrk == NULL)
276
    return 0;
277
  top_of_heap = value_as_long (sbrk);
278
 
279
  /* Return results.  */
280
  if (top_of_heap > top_of_data_memory)
281
    {
282
      *bottom = top_of_data_memory;
283
      *top = top_of_heap;
284
      return 1;
285
    }
286
 
287
  /* No additional heap space needs to be saved.  */
288
  return 0;
289
}
290
 
291
static void
292
make_output_phdrs (bfd *obfd, asection *osec, void *ignored)
293
{
294
  int p_flags = 0;
295
  int p_type;
296
 
297
  /* FIXME: these constants may only be applicable for ELF.  */
298
  if (strncmp (bfd_section_name (obfd, osec), "load", 4) == 0)
299
    p_type = PT_LOAD;
300
  else
301
    p_type = PT_NOTE;
302
 
303
  p_flags |= PF_R;      /* Segment is readable.  */
304
  if (!(bfd_get_section_flags (obfd, osec) & SEC_READONLY))
305
    p_flags |= PF_W;    /* Segment is writable.  */
306
  if (bfd_get_section_flags (obfd, osec) & SEC_CODE)
307
    p_flags |= PF_X;    /* Segment is executable.  */
308
 
309
  bfd_record_phdr (obfd, p_type, 1, p_flags, 0, 0, 0, 0, 1, &osec);
310
}
311
 
312
static int
313
gcore_create_callback (CORE_ADDR vaddr, unsigned long size,
314
                       int read, int write, int exec, void *data)
315
{
316
  bfd *obfd = data;
317
  asection *osec;
318
  flagword flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_LOAD;
319
 
320
  /* If the memory segment has no permissions set, ignore it, otherwise
321
     when we later try to access it for read/write, we'll get an error
322
     or jam the kernel.  */
323
  if (read == 0 && write == 0 && exec == 0)
324
    {
325
      if (info_verbose)
326
        {
327
          fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at 0x%s\n",
328
                           paddr_d (size), paddr_nz (vaddr));
329
        }
330
 
331
      return 0;
332
    }
333
 
334
  if (write == 0)
335
    {
336
      /* See if this region of memory lies inside a known file on disk.
337
         If so, we can avoid copying its contents by clearing SEC_LOAD.  */
338
      struct objfile *objfile;
339
      struct obj_section *objsec;
340
 
341
      ALL_OBJSECTIONS (objfile, objsec)
342
        {
343
          bfd *abfd = objfile->obfd;
344
          asection *asec = objsec->the_bfd_section;
345
          bfd_vma align = (bfd_vma) 1 << bfd_get_section_alignment (abfd,
346
                                                                    asec);
347
          bfd_vma start = objsec->addr & -align;
348
          bfd_vma end = (objsec->endaddr + align - 1) & -align;
349
          /* Match if either the entire memory region lies inside the
350
             section (i.e. a mapping covering some pages of a large
351
             segment) or the entire section lies inside the memory region
352
             (i.e. a mapping covering multiple small sections).
353
 
354
             This BFD was synthesized from reading target memory,
355
             we don't want to omit that.  */
356
          if (((vaddr >= start && vaddr + size <= end)
357
               || (start >= vaddr && end <= vaddr + size))
358
              && !(bfd_get_file_flags (abfd) & BFD_IN_MEMORY))
359
            {
360
              flags &= ~SEC_LOAD;
361
              flags |= SEC_NEVER_LOAD;
362
              goto keep;        /* break out of two nested for loops */
363
            }
364
        }
365
 
366
    keep:
367
      flags |= SEC_READONLY;
368
    }
369
 
370
  if (exec)
371
    flags |= SEC_CODE;
372
  else
373
    flags |= SEC_DATA;
374
 
375
  osec = bfd_make_section_anyway_with_flags (obfd, "load", flags);
376
  if (osec == NULL)
377
    {
378
      warning (_("Couldn't make gcore segment: %s"),
379
               bfd_errmsg (bfd_get_error ()));
380
      return 1;
381
    }
382
 
383
  if (info_verbose)
384
    {
385
      fprintf_filtered (gdb_stdout, "Save segment, %s bytes at 0x%s\n",
386
                        paddr_d (size), paddr_nz (vaddr));
387
    }
388
 
389
  bfd_set_section_size (obfd, osec, size);
390
  bfd_set_section_vma (obfd, osec, vaddr);
391
  bfd_section_lma (obfd, osec) = 0; /* ??? bfd_set_section_lma?  */
392
  return 0;
393
}
394
 
395
static int
396
objfile_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
397
                                          int, int, int, void *),
398
                             void *obfd)
399
{
400
  /* Use objfile data to create memory sections.  */
401
  struct objfile *objfile;
402
  struct obj_section *objsec;
403
  bfd_vma temp_bottom, temp_top;
404
 
405
  /* Call callback function for each objfile section.  */
406
  ALL_OBJSECTIONS (objfile, objsec)
407
    {
408
      bfd *ibfd = objfile->obfd;
409
      asection *isec = objsec->the_bfd_section;
410
      flagword flags = bfd_get_section_flags (ibfd, isec);
411
      int ret;
412
 
413
      if ((flags & SEC_ALLOC) || (flags & SEC_LOAD))
414
        {
415
          int size = bfd_section_size (ibfd, isec);
416
          int ret;
417
 
418
          ret = (*func) (objsec->addr, bfd_section_size (ibfd, isec),
419
                         1, /* All sections will be readable.  */
420
                         (flags & SEC_READONLY) == 0, /* Writable.  */
421
                         (flags & SEC_CODE) != 0, /* Executable.  */
422
                         obfd);
423
          if (ret != 0)
424
            return ret;
425
        }
426
    }
427
 
428
  /* Make a stack segment.  */
429
  if (derive_stack_segment (&temp_bottom, &temp_top))
430
    (*func) (temp_bottom, temp_top - temp_bottom,
431
             1, /* Stack section will be readable.  */
432
             1, /* Stack section will be writable.  */
433
             0, /* Stack section will not be executable.  */
434
             obfd);
435
 
436
  /* Make a heap segment. */
437
  if (derive_heap_segment (exec_bfd, &temp_bottom, &temp_top))
438
    (*func) (temp_bottom, temp_top - temp_bottom,
439
             1, /* Heap section will be readable.  */
440
             1, /* Heap section will be writable.  */
441
             0, /* Heap section will not be executable.  */
442
             obfd);
443
 
444
  return 0;
445
}
446
 
447
static void
448
gcore_copy_callback (bfd *obfd, asection *osec, void *ignored)
449
{
450
  bfd_size_type size, total_size = bfd_section_size (obfd, osec);
451
  file_ptr offset = 0;
452
  struct cleanup *old_chain = NULL;
453
  void *memhunk;
454
 
455
  /* Read-only sections are marked; we don't have to copy their contents.  */
456
  if ((bfd_get_section_flags (obfd, osec) & SEC_LOAD) == 0)
457
    return;
458
 
459
  /* Only interested in "load" sections.  */
460
  if (strncmp ("load", bfd_section_name (obfd, osec), 4) != 0)
461
    return;
462
 
463
  size = min (total_size, MAX_COPY_BYTES);
464
  memhunk = xmalloc (size);
465
  /* ??? This is crap since xmalloc should never return NULL.  */
466
  if (memhunk == NULL)
467
    error (_("Not enough memory to create corefile."));
468
  old_chain = make_cleanup (xfree, memhunk);
469
 
470
  while (total_size > 0)
471
    {
472
      if (size > total_size)
473
        size = total_size;
474
 
475
      if (target_read_memory (bfd_section_vma (obfd, osec) + offset,
476
                              memhunk, size) != 0)
477
        {
478
          warning (_("Memory read failed for corefile section, %s bytes at 0x%s."),
479
                   paddr_d (size), paddr (bfd_section_vma (obfd, osec)));
480
          break;
481
        }
482
      if (!bfd_set_section_contents (obfd, osec, memhunk, offset, size))
483
        {
484
          warning (_("Failed to write corefile contents (%s)."),
485
                   bfd_errmsg (bfd_get_error ()));
486
          break;
487
        }
488
 
489
      total_size -= size;
490
      offset += size;
491
    }
492
 
493
  do_cleanups (old_chain);      /* Frees MEMHUNK.  */
494
}
495
 
496
static int
497
gcore_memory_sections (bfd *obfd)
498
{
499
  if (target_find_memory_regions (gcore_create_callback, obfd) != 0)
500
    return 0;                    /* FIXME: error return/msg?  */
501
 
502
  /* Record phdrs for section-to-segment mapping.  */
503
  bfd_map_over_sections (obfd, make_output_phdrs, NULL);
504
 
505
  /* Copy memory region contents.  */
506
  bfd_map_over_sections (obfd, gcore_copy_callback, NULL);
507
 
508
  return 1;
509
}
510
 
511
void
512
_initialize_gcore (void)
513
{
514
  add_com ("generate-core-file", class_files, gcore_command, _("\
515
Save a core file with the current state of the debugged process.\n\
516
Argument is optional filename.  Default filename is 'core.<process_id>'."));
517
 
518
  add_com_alias ("gcore", "generate-core-file", class_files, 1);
519
  exec_set_find_memory_regions (objfile_find_memory_regions);
520
}

powered by: WebSVN 2.1.0

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