GDB (xrefs)
Loading...
Searching...
No Matches
gcore.c
Go to the documentation of this file.
1/* Generate a core file for the inferior process.
2
3 Copyright (C) 2001-2023 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 3 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, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "elf-bfd.h"
22#include "infcall.h"
23#include "inferior.h"
24#include "gdbcore.h"
25#include "objfiles.h"
26#include "solib.h"
27#include "symfile.h"
28#include "arch-utils.h"
29#include "completer.h"
30#include "gcore.h"
31#include "cli/cli-decode.h"
32#include <fcntl.h>
33#include "regcache.h"
34#include "regset.h"
35#include "gdb_bfd.h"
36#include "readline/tilde.h"
37#include <algorithm>
38#include "gdbsupport/gdb_unlinker.h"
39#include "gdbsupport/byte-vector.h"
40#include "gdbsupport/scope-exit.h"
41
42/* The largest amount of memory to read from the target at once. We
43 must throttle it to limit the amount of memory used by GDB during
44 generate-core-file for programs with large resident data. */
45#define MAX_COPY_BYTES (1024 * 1024)
46
47static const char *default_gcore_target (void);
48static enum bfd_architecture default_gcore_arch (void);
49static int gcore_memory_sections (bfd *);
50
51/* create_gcore_bfd -- helper for gcore_command (exported).
52 Open a new bfd core file for output, and return the handle. */
53
55create_gcore_bfd (const char *filename)
56{
58
59 if (obfd == NULL)
60 error (_("Failed to open '%s' for output."), filename);
61 bfd_set_format (obfd.get (), bfd_core);
62 bfd_set_arch_mach (obfd.get (), default_gcore_arch (), 0);
63 return obfd;
64}
65
66/* write_gcore_file_1 -- do the actual work of write_gcore_file. */
67
68static void
70{
71 gdb::unique_xmalloc_ptr<char> note_data;
72 int note_size = 0;
73 asection *note_sec = NULL;
74
75 /* An external target method must build the notes section. */
76 /* FIXME: uweigand/2011-10-06: All architectures that support core file
77 generation should be converted to gdbarch_make_corefile_notes; at that
78 point, the target vector method can be removed. */
81 else
83 &note_size);
84
85 if (note_data == NULL || note_size == 0)
86 error (_("Target does not support core file generation."));
87
88 /* Create the note section. */
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 (note_sec, 0);
98 bfd_set_section_alignment (note_sec, 0);
99 bfd_set_section_size (note_sec, note_size);
100
101 /* Now create the memory/load sections. */
102 if (gcore_memory_sections (obfd) == 0)
103 error (_("gcore: failed to get corefile memory sections from target."));
104
105 /* Write out the contents of the note section. */
106 if (!bfd_set_section_contents (obfd, note_sec, note_data.get (), 0,
107 note_size))
108 warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ()));
109}
110
111/* write_gcore_file -- helper for gcore_command (exported).
112 Compose and write the corefile data to the core file. */
113
114void
121
122/* gcore_command -- implements the 'gcore' command.
123 Generate a core file from the inferior process. */
124
125static void
126gcore_command (const char *args, int from_tty)
127{
128 gdb::unique_xmalloc_ptr<char> corefilename;
129
130 /* No use generating a corefile without a target process. */
131 if (!target_has_execution ())
132 noprocess ();
133
134 if (args && *args)
135 corefilename.reset (tilde_expand (args));
136 else
137 {
138 /* Default corefile name is "core.PID". */
139 corefilename = xstrprintf ("core.%d", inferior_ptid.pid ());
140 }
141
142 if (info_verbose)
143 gdb_printf ("Opening corefile '%s' for output.\n",
144 corefilename.get ());
145
147 target_dumpcore (corefilename.get ());
148 else
149 {
150 /* Open the output file. */
151 gdb_bfd_ref_ptr obfd (create_gcore_bfd (corefilename.get ()));
152
153 /* Arrange to unlink the file on failure. */
154 gdb::unlinker unlink_file (corefilename.get ());
155
156 /* Call worker function. */
157 write_gcore_file (obfd.get ());
158
159 /* Succeeded. */
160 unlink_file.keep ();
161 }
162
163 gdb_printf ("Saved corefile %s\n", corefilename.get ());
164}
165
166static enum bfd_architecture
168{
169 const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ());
170
171 if (bfdarch != NULL)
172 return bfdarch->arch;
173 if (current_program_space->exec_bfd () == NULL)
174 error (_("Can't find bfd architecture for corefile (need execfile)."));
175
176 return bfd_get_arch (current_program_space->exec_bfd ());
177}
178
179static const char *
181{
182 /* The gdbarch may define a target to use for core files. */
185
186 /* Otherwise, try to fall back to the exec target. This will probably
187 not work for non-ELF targets. */
188 if (current_program_space->exec_bfd () == NULL)
189 return NULL;
190 else
191 return bfd_get_target (current_program_space->exec_bfd ());
192}
193
194/* Derive a reasonable stack segment by unwinding the target stack,
195 and store its limits in *BOTTOM and *TOP. Return non-zero if
196 successful. */
197
198static int
199derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
200{
201 frame_info_ptr fi, tmp_fi;
202
203 gdb_assert (bottom);
204 gdb_assert (top);
205
206 /* Can't succeed without stack and registers. */
208 return 0;
209
210 /* Can't succeed without current frame. */
211 fi = get_current_frame ();
212 if (fi == NULL)
213 return 0;
214
215 /* Save frame pointer of TOS frame. */
216 *top = get_frame_base (fi);
217 /* If current stack pointer is more "inner", use that instead. */
218 if (gdbarch_inner_than (get_frame_arch (fi), get_frame_sp (fi), *top))
219 *top = get_frame_sp (fi);
220
221 /* Find prev-most frame. */
222 while ((tmp_fi = get_prev_frame (fi)) != NULL)
223 fi = tmp_fi;
224
225 /* Save frame pointer of prev-most frame. */
226 *bottom = get_frame_base (fi);
227
228 /* Now canonicalize their order, so that BOTTOM is a lower address
229 (as opposed to a lower stack frame). */
230 if (*bottom > *top)
231 {
232 bfd_vma tmp_vma;
233
234 tmp_vma = *top;
235 *top = *bottom;
236 *bottom = tmp_vma;
237 }
238
239 return 1;
240}
241
242/* call_target_sbrk --
243 helper function for derive_heap_segment. */
244
245static bfd_vma
246call_target_sbrk (int sbrk_arg)
247{
248 struct objfile *sbrk_objf;
249 struct gdbarch *gdbarch;
250 bfd_vma top_of_heap;
251 struct value *target_sbrk_arg;
252 struct value *sbrk_fn, *ret;
253 bfd_vma tmp;
254
255 if (lookup_minimal_symbol ("sbrk", NULL, NULL).minsym != NULL)
256 {
257 sbrk_fn = find_function_in_inferior ("sbrk", &sbrk_objf);
258 if (sbrk_fn == NULL)
259 return (bfd_vma) 0;
260 }
261 else if (lookup_minimal_symbol ("_sbrk", NULL, NULL).minsym != NULL)
262 {
263 sbrk_fn = find_function_in_inferior ("_sbrk", &sbrk_objf);
264 if (sbrk_fn == NULL)
265 return (bfd_vma) 0;
266 }
267 else
268 return (bfd_vma) 0;
269
270 gdbarch = sbrk_objf->arch ();
271 target_sbrk_arg = value_from_longest (builtin_type (gdbarch)->builtin_int,
272 sbrk_arg);
273 gdb_assert (target_sbrk_arg);
274 ret = call_function_by_hand (sbrk_fn, NULL, target_sbrk_arg);
275 if (ret == NULL)
276 return (bfd_vma) 0;
277
278 tmp = value_as_long (ret);
279 if ((LONGEST) tmp <= 0 || (LONGEST) tmp == 0xffffffff)
280 return (bfd_vma) 0;
281
282 top_of_heap = tmp;
283 return top_of_heap;
284}
285
286/* Derive a reasonable heap segment for ABFD by looking at sbrk and
287 the static data sections. Store its limits in *BOTTOM and *TOP.
288 Return non-zero if successful. */
289
290static int
291derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
292{
293 bfd_vma top_of_data_memory = 0;
294 bfd_vma top_of_heap = 0;
295 bfd_size_type sec_size;
296 bfd_vma sec_vaddr;
297 asection *sec;
298
299 gdb_assert (bottom);
300 gdb_assert (top);
301
302 /* This function depends on being able to call a function in the
303 inferior. */
304 if (!target_has_execution ())
305 return 0;
306
307 /* The following code assumes that the link map is arranged as
308 follows (low to high addresses):
309
310 ---------------------------------
311 | text sections |
312 ---------------------------------
313 | data sections (including bss) |
314 ---------------------------------
315 | heap |
316 --------------------------------- */
317
318 for (sec = abfd->sections; sec; sec = sec->next)
319 {
320 if (bfd_section_flags (sec) & SEC_DATA
321 || strcmp (".bss", bfd_section_name (sec)) == 0)
322 {
323 sec_vaddr = bfd_section_vma (sec);
324 sec_size = bfd_section_size (sec);
325 if (sec_vaddr + sec_size > top_of_data_memory)
326 top_of_data_memory = sec_vaddr + sec_size;
327 }
328 }
329
330 top_of_heap = call_target_sbrk (0);
331 if (top_of_heap == (bfd_vma) 0)
332 return 0;
333
334 /* Return results. */
335 if (top_of_heap > top_of_data_memory)
336 {
337 *bottom = top_of_data_memory;
338 *top = top_of_heap;
339 return 1;
340 }
341
342 /* No additional heap space needs to be saved. */
343 return 0;
344}
345
346static void
347make_output_phdrs (bfd *obfd, asection *osec)
348{
349 int p_flags = 0;
350 int p_type = 0;
351
352 /* Memory tag segments have already been handled by the architecture, as
353 those contain arch-specific information. If we have one of those, just
354 return. */
355 if (startswith (bfd_section_name (osec), "memtag"))
356 return;
357
358 /* FIXME: these constants may only be applicable for ELF. */
359 if (startswith (bfd_section_name (osec), "load"))
360 p_type = PT_LOAD;
361 else if (startswith (bfd_section_name (osec), "note"))
362 p_type = PT_NOTE;
363 else
364 p_type = PT_NULL;
365
366 p_flags |= PF_R; /* Segment is readable. */
367 if (!(bfd_section_flags (osec) & SEC_READONLY))
368 p_flags |= PF_W; /* Segment is writable. */
369 if (bfd_section_flags (osec) & SEC_CODE)
370 p_flags |= PF_X; /* Segment is executable. */
371
372 bfd_record_phdr (obfd, p_type, 1, p_flags, 0, 0, 0, 0, 1, &osec);
373}
374
375/* find_memory_region_ftype implementation.
376
377 MEMORY_TAGGED is true if the memory region contains memory tags, false
378 otherwise.
379
380 DATA is 'bfd *' for the core file GDB is creating. */
381
382static int
383gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read,
384 int write, int exec, int modified, bool memory_tagged,
385 void *data)
386{
387 bfd *obfd = (bfd *) data;
388 asection *osec;
389 flagword flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_LOAD;
390
391 /* If the memory segment has no permissions set, ignore it, otherwise
392 when we later try to access it for read/write, we'll get an error
393 or jam the kernel. */
394 if (read == 0 && write == 0 && exec == 0 && modified == 0)
395 {
396 if (info_verbose)
397 {
398 gdb_printf ("Ignore segment, %s bytes at %s\n",
399 plongest (size), paddress (target_gdbarch (), vaddr));
400 }
401
402 return 0;
403 }
404
405 if (write == 0 && modified == 0 && !solib_keep_data_in_core (vaddr, size))
406 {
407 /* See if this region of memory lies inside a known file on disk.
408 If so, we can avoid copying its contents by clearing SEC_LOAD. */
409
411 for (obj_section *objsec : objfile->sections ())
412 {
413 bfd *abfd = objfile->obfd.get ();
414 asection *asec = objsec->the_bfd_section;
415 bfd_vma align = (bfd_vma) 1 << bfd_section_alignment (asec);
416 bfd_vma start = objsec->addr () & -align;
417 bfd_vma end = (objsec->endaddr () + align - 1) & -align;
418
419 /* Match if either the entire memory region lies inside the
420 section (i.e. a mapping covering some pages of a large
421 segment) or the entire section lies inside the memory region
422 (i.e. a mapping covering multiple small sections).
423
424 This BFD was synthesized from reading target memory,
425 we don't want to omit that. */
427 && ((vaddr >= start && vaddr + size <= end)
428 || (start >= vaddr && end <= vaddr + size))
429 && !(bfd_get_file_flags (abfd) & BFD_IN_MEMORY))
430 {
431 flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
432 goto keep; /* Break out of two nested for loops. */
433 }
434 }
435
436 keep:;
437 }
438
439 if (write == 0)
440 flags |= SEC_READONLY;
441
442 if (exec)
443 flags |= SEC_CODE;
444 else
445 flags |= SEC_DATA;
446
447 osec = bfd_make_section_anyway_with_flags (obfd, "load", flags);
448 if (osec == NULL)
449 {
450 warning (_("Couldn't make gcore segment: %s"),
451 bfd_errmsg (bfd_get_error ()));
452 return 1;
453 }
454
455 if (info_verbose)
456 {
457 gdb_printf ("Save segment, %s bytes at %s\n",
458 plongest (size), paddress (target_gdbarch (), vaddr));
459 }
460
461 bfd_set_section_size (osec, size);
462 bfd_set_section_vma (osec, vaddr);
463 bfd_set_section_lma (osec, 0);
464 return 0;
465}
466
467/* gdbarch_find_memory_region callback for creating a memory tag section.
468
469 MEMORY_TAGGED is true if the memory region contains memory tags, false
470 otherwise.
471
472 DATA is 'bfd *' for the core file GDB is creating. */
473
474static int
475gcore_create_memtag_section_callback (CORE_ADDR vaddr, unsigned long size,
476 int read, int write, int exec,
477 int modified, bool memory_tagged,
478 void *data)
479{
480 /* Are there memory tags in this particular memory map entry? */
481 if (!memory_tagged)
482 return 0;
483
484 bfd *obfd = (bfd *) data;
485
486 /* Ask the architecture to create a memory tag section for this particular
487 memory map entry. It will be populated with contents later, as we can't
488 start writing the contents before we have all the sections sorted out. */
489 asection *memtag_section
491
492 if (memtag_section == nullptr)
493 {
494 warning (_("Couldn't make gcore memory tag segment: %s"),
495 bfd_errmsg (bfd_get_error ()));
496 return 1;
497 }
498
499 if (info_verbose)
500 {
501 gdb_printf (gdb_stdout, "Saved memory tag segment, %s bytes "
502 "at %s\n",
503 plongest (bfd_section_size (memtag_section)),
504 paddress (target_gdbarch (), vaddr));
505 }
506
507 return 0;
508}
509
510int
513{
514 /* Use objfile data to create memory sections. */
515 bfd_vma temp_bottom, temp_top;
516
517 /* Call callback function for each objfile section. */
519 for (obj_section *objsec : objfile->sections ())
520 {
521 asection *isec = objsec->the_bfd_section;
522 flagword flags = bfd_section_flags (isec);
523
524 /* Separate debug info files are irrelevant for gcore. */
526 continue;
527
528 if ((flags & SEC_ALLOC) || (flags & SEC_LOAD))
529 {
530 int size = bfd_section_size (isec);
531 int ret;
532
533 ret = (*func) (objsec->addr (), size,
534 1, /* All sections will be readable. */
535 (flags & SEC_READONLY) == 0, /* Writable. */
536 (flags & SEC_CODE) != 0, /* Executable. */
537 1, /* MODIFIED is unknown, pass it as true. */
538 false, /* No memory tags in the object file. */
539 obfd);
540 if (ret != 0)
541 return ret;
542 }
543 }
544
545 /* Make a stack segment. */
546 if (derive_stack_segment (&temp_bottom, &temp_top))
547 (*func) (temp_bottom, temp_top - temp_bottom,
548 1, /* Stack section will be readable. */
549 1, /* Stack section will be writable. */
550 0, /* Stack section will not be executable. */
551 1, /* Stack section will be modified. */
552 false, /* No memory tags in the object file. */
553 obfd);
554
555 /* Make a heap segment. */
557 &temp_top))
558 (*func) (temp_bottom, temp_top - temp_bottom,
559 1, /* Heap section will be readable. */
560 1, /* Heap section will be writable. */
561 0, /* Heap section will not be executable. */
562 1, /* Heap section will be modified. */
563 false, /* No memory tags in the object file. */
564 obfd);
565
566 return 0;
567}
568
569static void
570gcore_copy_callback (bfd *obfd, asection *osec)
571{
572 bfd_size_type size, total_size = bfd_section_size (osec);
573 file_ptr offset = 0;
574
575 /* Read-only sections are marked; we don't have to copy their contents. */
576 if ((bfd_section_flags (osec) & SEC_LOAD) == 0)
577 return;
578
579 /* Only interested in "load" sections. */
580 if (!startswith (bfd_section_name (osec), "load"))
581 return;
582
583 size = std::min (total_size, (bfd_size_type) MAX_COPY_BYTES);
584 gdb::byte_vector memhunk (size);
585
586 while (total_size > 0)
587 {
588 if (size > total_size)
589 size = total_size;
590
591 if (target_read_memory (bfd_section_vma (osec) + offset,
592 memhunk.data (), size) != 0)
593 {
594 warning (_("Memory read failed for corefile "
595 "section, %s bytes at %s."),
596 plongest (size),
597 paddress (target_gdbarch (), bfd_section_vma (osec)));
598 break;
599 }
600 if (!bfd_set_section_contents (obfd, osec, memhunk.data (),
601 offset, size))
602 {
603 warning (_("Failed to write corefile contents (%s)."),
604 bfd_errmsg (bfd_get_error ()));
605 break;
606 }
607
608 total_size -= size;
609 offset += size;
610 }
611}
612
613/* Callback to copy contents to a particular memory tag section. */
614
615static void
617{
618 /* We are only interested in "memtag" sections. */
619 if (!startswith (bfd_section_name (osec), "memtag"))
620 return;
621
622 /* Fill the section with memory tag contents. */
624 error (_("Failed to fill memory tag section for core file."));
625}
626
627static int
629{
630 /* Try gdbarch method first, then fall back to target method. */
634 {
636 return 0; /* FIXME: error return/msg? */
637 }
638
639 /* Take care of dumping memory tags, if there are any. */
643 obfd) != 0)
644 {
646 obfd) != 0)
647 return 0;
648 }
649
650 /* Record phdrs for section-to-segment mapping. */
651 for (asection *sect : gdb_bfd_sections (obfd))
652 make_output_phdrs (obfd, sect);
653
654 /* Copy memory region and memory tag contents. */
655 for (asection *sect : gdb_bfd_sections (obfd))
656 {
659 }
660
661 return 1;
662}
663
664/* See gcore.h. */
665
668{
669 thread_info *curr_thr = inferior_thread ();
670 if (curr_thr->state != THREAD_EXITED
671 && curr_thr->stop_signal () != GDB_SIGNAL_0)
672 return curr_thr;
673
675 if (thr->stop_signal () != GDB_SIGNAL_0)
676 return thr;
677
678 /* Default to the current thread, unless it has exited. */
679 if (curr_thr->state != THREAD_EXITED)
680 return curr_thr;
681
682 return nullptr;
683}
684
685void _initialize_gcore ();
686void
688{
689 cmd_list_element *generate_core_file_cmd
690 = add_com ("generate-core-file", class_files, gcore_command, _("\
691Save a core file with the current state of the debugged process.\n\
692Usage: generate-core-file [FILENAME]\n\
693Argument is optional filename. Default filename is 'core.PROCESS_ID'."));
694
695 add_com_alias ("gcore", generate_core_file_cmd, class_files, 1);
696}
struct gdbarch * target_gdbarch(void)
inf_non_exited_threads_range non_exited_threads()
Definition inferior.h:481
enum thread_state state
Definition gdbthread.h:339
gdb_signal stop_signal() const
Definition gdbthread.h:424
cmd_list_element * add_com_alias(const char *name, cmd_list_element *target, command_class theclass, int abbrev_flag)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
@ class_files
Definition command.h:57
bool info_verbose
Definition top.c:1941
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
Definition defs.h:350
ssize_t read(int fd, void *buf, size_t count)
CORE_ADDR get_frame_sp(frame_info_ptr this_frame)
Definition frame.c:3115
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
frame_info_ptr get_current_frame(void)
Definition frame.c:1670
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
Definition frame.c:2614
CORE_ADDR get_frame_base(frame_info_ptr fi)
Definition frame.c:2879
thread_info * gcore_find_signalled_thread()
Definition gcore.c:667
static void gcore_copy_callback(bfd *obfd, asection *osec)
Definition gcore.c:570
int objfile_find_memory_regions(struct target_ops *self, find_memory_region_ftype func, void *obfd)
Definition gcore.c:511
static void make_output_phdrs(bfd *obfd, asection *osec)
Definition gcore.c:347
static int gcore_memory_sections(bfd *)
Definition gcore.c:628
void _initialize_gcore()
Definition gcore.c:687
static int gcore_create_callback(CORE_ADDR vaddr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
Definition gcore.c:383
static int gcore_create_memtag_section_callback(CORE_ADDR vaddr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
Definition gcore.c:475
#define MAX_COPY_BYTES
Definition gcore.c:45
static void gcore_command(const char *args, int from_tty)
Definition gcore.c:126
static bfd_vma call_target_sbrk(int sbrk_arg)
Definition gcore.c:246
gdb_bfd_ref_ptr create_gcore_bfd(const char *filename)
Definition gcore.c:55
static int derive_heap_segment(bfd *abfd, bfd_vma *bottom, bfd_vma *top)
Definition gcore.c:291
static enum bfd_architecture default_gcore_arch(void)
Definition gcore.c:167
static int derive_stack_segment(bfd_vma *bottom, bfd_vma *top)
Definition gcore.c:199
static const char * default_gcore_target(void)
Definition gcore.c:180
void write_gcore_file(bfd *obfd)
Definition gcore.c:115
static void write_gcore_file_1(bfd *obfd)
Definition gcore.c:69
static void gcore_copy_memtag_section_callback(bfd *obfd, asection *osec)
Definition gcore.c:616
gdb_bfd_ref_ptr gdb_bfd_openw(const char *filename, const char *target)
Definition gdb_bfd.c:883
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:79
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition gdb_bfd.h:234
bool gdbarch_fill_memtag_section(struct gdbarch *gdbarch, asection *osec)
Definition gdbarch.c:3814
bfd int * note_size
bool gdbarch_make_corefile_notes_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3735
int gdbarch_find_memory_regions(struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
Definition gdbarch.c:3766
bfd * obfd
gdb::unique_xmalloc_ptr< char > gdbarch_make_corefile_notes(struct gdbarch *gdbarch, bfd *obfd, int *note_size)
Definition gdbarch.c:3742
bool gdbarch_gcore_bfd_target_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3999
asection * gdbarch_create_memtag_section(struct gdbarch *gdbarch, bfd *obfd, CORE_ADDR address, size_t size)
Definition gdbarch.c:3790
const char * gdbarch_gcore_bfd_target(struct gdbarch *gdbarch)
Definition gdbarch.c:4006
int gdbarch_inner_than(struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
Definition gdbarch.c:2760
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition gdbarch.c:1387
bool gdbarch_find_memory_regions_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3759
@ THREAD_EXITED
Definition gdbthread.h:79
struct thread_info * inferior_thread(void)
Definition thread.c:85
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1861
size_t size
Definition go32-nat.c:239
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
Definition infcall.c:824
ptid_t inferior_ptid
Definition infcmd.c:74
struct inferior * current_inferior(void)
Definition inferior.c:55
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
struct program_space * current_program_space
Definition progspace.c:40
void(* func)(remote_target *remote, char *)
bool solib_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
Definition solib.c:1214
iterator_range< section_iterator > sections()
Definition objfiles.h:685
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:830
struct gdbarch * arch() const
Definition objfiles.h:507
gdb_bfd_ref_ptr obfd
Definition objfiles.h:740
objfiles_range objfiles()
Definition progspace.h:209
bfd * exec_bfd() const
Definition progspace.h:268
Definition value.h:130
LONGEST offset() const
Definition value.h:222
bool target_supports_dumpcore()
Definition target.c:274
int target_has_stack()
Definition target.c:177
void target_done_generating_core(void)
Definition target.c:4254
void noprocess(void)
Definition target.c:1136
gdb::unique_xmalloc_ptr< char > target_make_corefile_notes(bfd *bfd, int *size_p)
Definition target.c:450
void target_dumpcore(const char *filename)
Definition target.c:282
bool target_has_execution(inferior *inf)
Definition target.c:201
int target_has_registers()
Definition target.c:189
void target_prepare_to_generate_core(void)
Definition target.c:4246
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
int target_find_memory_regions(find_memory_region_ftype func, void *data)
Definition target.c:442
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stdout
Definition utils.h:182
struct value * find_function_in_inferior(const char *name, struct objfile **objf_p)
Definition valops.c:117
struct value * value_from_longest(struct type *type, LONGEST num)
Definition value.c:3438
LONGEST value_as_long(struct value *val)
Definition value.c:2554