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
116{
118 SCOPE_EXIT { target_done_generating_core (); };
120}
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 struct obj_section *objsec;
410
413 {
414 bfd *abfd = objfile->obfd.get ();
415 asection *asec = objsec->the_bfd_section;
416 bfd_vma align = (bfd_vma) 1 << bfd_section_alignment (asec);
417 bfd_vma start = objsec->addr () & -align;
418 bfd_vma end = (objsec->endaddr () + align - 1) & -align;
419
420 /* Match if either the entire memory region lies inside the
421 section (i.e. a mapping covering some pages of a large
422 segment) or the entire section lies inside the memory region
423 (i.e. a mapping covering multiple small sections).
424
425 This BFD was synthesized from reading target memory,
426 we don't want to omit that. */
428 && ((vaddr >= start && vaddr + size <= end)
429 || (start >= vaddr && end <= vaddr + size))
430 && !(bfd_get_file_flags (abfd) & BFD_IN_MEMORY))
431 {
432 flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
433 goto keep; /* Break out of two nested for loops. */
434 }
435 }
436
437 keep:;
438 }
439
440 if (write == 0)
441 flags |= SEC_READONLY;
442
443 if (exec)
444 flags |= SEC_CODE;
445 else
446 flags |= SEC_DATA;
447
448 osec = bfd_make_section_anyway_with_flags (obfd, "load", flags);
449 if (osec == NULL)
450 {
451 warning (_("Couldn't make gcore segment: %s"),
452 bfd_errmsg (bfd_get_error ()));
453 return 1;
454 }
455
456 if (info_verbose)
457 {
458 gdb_printf ("Save segment, %s bytes at %s\n",
459 plongest (size), paddress (target_gdbarch (), vaddr));
460 }
461
462 bfd_set_section_size (osec, size);
463 bfd_set_section_vma (osec, vaddr);
464 bfd_set_section_lma (osec, 0);
465 return 0;
466}
467
468/* gdbarch_find_memory_region callback for creating a memory tag section.
469
470 MEMORY_TAGGED is true if the memory region contains memory tags, false
471 otherwise.
472
473 DATA is 'bfd *' for the core file GDB is creating. */
474
475static int
476gcore_create_memtag_section_callback (CORE_ADDR vaddr, unsigned long size,
477 int read, int write, int exec,
478 int modified, bool memory_tagged,
479 void *data)
480{
481 /* Are there memory tags in this particular memory map entry? */
482 if (!memory_tagged)
483 return 0;
484
485 bfd *obfd = (bfd *) data;
486
487 /* Ask the architecture to create a memory tag section for this particular
488 memory map entry. It will be populated with contents later, as we can't
489 start writing the contents before we have all the sections sorted out. */
490 asection *memtag_section
492
493 if (memtag_section == nullptr)
494 {
495 warning (_("Couldn't make gcore memory tag segment: %s"),
496 bfd_errmsg (bfd_get_error ()));
497 return 1;
498 }
499
500 if (info_verbose)
501 {
502 gdb_printf (gdb_stdout, "Saved memory tag segment, %s bytes "
503 "at %s\n",
504 plongest (bfd_section_size (memtag_section)),
505 paddress (target_gdbarch (), vaddr));
506 }
507
508 return 0;
509}
510
511int
514{
515 /* Use objfile data to create memory sections. */
516 struct obj_section *objsec;
517 bfd_vma temp_bottom, temp_top;
518
519 /* Call callback function for each objfile section. */
522 {
523 asection *isec = objsec->the_bfd_section;
524 flagword flags = bfd_section_flags (isec);
525
526 /* Separate debug info files are irrelevant for gcore. */
528 continue;
529
530 if ((flags & SEC_ALLOC) || (flags & SEC_LOAD))
531 {
532 int size = bfd_section_size (isec);
533 int ret;
534
535 ret = (*func) (objsec->addr (), size,
536 1, /* All sections will be readable. */
537 (flags & SEC_READONLY) == 0, /* Writable. */
538 (flags & SEC_CODE) != 0, /* Executable. */
539 1, /* MODIFIED is unknown, pass it as true. */
540 false, /* No memory tags in the object file. */
541 obfd);
542 if (ret != 0)
543 return ret;
544 }
545 }
546
547 /* Make a stack segment. */
548 if (derive_stack_segment (&temp_bottom, &temp_top))
549 (*func) (temp_bottom, temp_top - temp_bottom,
550 1, /* Stack section will be readable. */
551 1, /* Stack section will be writable. */
552 0, /* Stack section will not be executable. */
553 1, /* Stack section will be modified. */
554 false, /* No memory tags in the object file. */
555 obfd);
556
557 /* Make a heap segment. */
559 &temp_top))
560 (*func) (temp_bottom, temp_top - temp_bottom,
561 1, /* Heap section will be readable. */
562 1, /* Heap section will be writable. */
563 0, /* Heap section will not be executable. */
564 1, /* Heap section will be modified. */
565 false, /* No memory tags in the object file. */
566 obfd);
567
568 return 0;
569}
570
571static void
572gcore_copy_callback (bfd *obfd, asection *osec)
573{
574 bfd_size_type size, total_size = bfd_section_size (osec);
575 file_ptr offset = 0;
576
577 /* Read-only sections are marked; we don't have to copy their contents. */
578 if ((bfd_section_flags (osec) & SEC_LOAD) == 0)
579 return;
580
581 /* Only interested in "load" sections. */
582 if (!startswith (bfd_section_name (osec), "load"))
583 return;
584
585 size = std::min (total_size, (bfd_size_type) MAX_COPY_BYTES);
586 gdb::byte_vector memhunk (size);
587
588 while (total_size > 0)
589 {
590 if (size > total_size)
591 size = total_size;
592
593 if (target_read_memory (bfd_section_vma (osec) + offset,
594 memhunk.data (), size) != 0)
595 {
596 warning (_("Memory read failed for corefile "
597 "section, %s bytes at %s."),
598 plongest (size),
599 paddress (target_gdbarch (), bfd_section_vma (osec)));
600 break;
601 }
602 if (!bfd_set_section_contents (obfd, osec, memhunk.data (),
603 offset, size))
604 {
605 warning (_("Failed to write corefile contents (%s)."),
606 bfd_errmsg (bfd_get_error ()));
607 break;
608 }
609
610 total_size -= size;
611 offset += size;
612 }
613}
614
615/* Callback to copy contents to a particular memory tag section. */
616
617static void
619{
620 /* We are only interested in "memtag" sections. */
621 if (!startswith (bfd_section_name (osec), "memtag"))
622 return;
623
624 /* Fill the section with memory tag contents. */
626 error (_("Failed to fill memory tag section for core file."));
627}
628
629static int
631{
632 /* Try gdbarch method first, then fall back to target method. */
636 {
638 return 0; /* FIXME: error return/msg? */
639 }
640
641 /* Take care of dumping memory tags, if there are any. */
645 obfd) != 0)
646 {
648 obfd) != 0)
649 return 0;
650 }
651
652 /* Record phdrs for section-to-segment mapping. */
653 for (asection *sect : gdb_bfd_sections (obfd))
654 make_output_phdrs (obfd, sect);
655
656 /* Copy memory region and memory tag contents. */
657 for (asection *sect : gdb_bfd_sections (obfd))
658 {
661 }
662
663 return 1;
664}
665
666/* See gcore.h. */
667
670{
671 thread_info *curr_thr = inferior_thread ();
672 if (curr_thr->state != THREAD_EXITED
673 && curr_thr->stop_signal () != GDB_SIGNAL_0)
674 return curr_thr;
675
677 if (thr->stop_signal () != GDB_SIGNAL_0)
678 return thr;
679
680 /* Default to the current thread, unless it has exited. */
681 if (curr_thr->state != THREAD_EXITED)
682 return curr_thr;
683
684 return nullptr;
685}
686
687void _initialize_gcore ();
688void
690{
691 cmd_list_element *generate_core_file_cmd
692 = add_com ("generate-core-file", class_files, gcore_command, _("\
693Save a core file with the current state of the debugged process.\n\
694Usage: generate-core-file [FILENAME]\n\
695Argument is optional filename. Default filename is 'core.PROCESS_ID'."));
696
697 add_com_alias ("gcore", generate_core_file_cmd, class_files, 1);
698}
struct gdbarch * target_gdbarch(void)
inf_non_exited_threads_range non_exited_threads()
Definition inferior.h:451
enum thread_state state
Definition gdbthread.h:336
gdb_signal stop_signal() const
Definition gdbthread.h:421
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:2022
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:351
ssize_t read(int fd, void *buf, size_t count)
CORE_ADDR get_frame_sp(frame_info_ptr this_frame)
Definition frame.c:2995
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:2907
frame_info_ptr get_current_frame(void)
Definition frame.c:1615
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
Definition frame.c:2494
CORE_ADDR get_frame_base(frame_info_ptr fi)
Definition frame.c:2759
thread_info * gcore_find_signalled_thread()
Definition gcore.c:669
static void gcore_copy_callback(bfd *obfd, asection *osec)
Definition gcore.c:572
int objfile_find_memory_regions(struct target_ops *self, find_memory_region_ftype func, void *obfd)
Definition gcore.c:512
static void make_output_phdrs(bfd *obfd, asection *osec)
Definition gcore.c:347
static int gcore_memory_sections(bfd *)
Definition gcore.c:630
void _initialize_gcore()
Definition gcore.c:689
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:476
#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:618
gdb_bfd_ref_ptr gdb_bfd_openw(const char *filename, const char *target)
Definition gdb_bfd.c:896
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:78
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition gdb_bfd.h:222
bool gdbarch_fill_memtag_section(struct gdbarch *gdbarch, asection *osec)
Definition gdbarch.c:3748
bfd int * note_size
bool gdbarch_make_corefile_notes_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3669
int gdbarch_find_memory_regions(struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
Definition gdbarch.c:3700
bfd * obfd
gdb::unique_xmalloc_ptr< char > gdbarch_make_corefile_notes(struct gdbarch *gdbarch, bfd *obfd, int *note_size)
Definition gdbarch.c:3676
bool gdbarch_gcore_bfd_target_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3909
asection * gdbarch_create_memtag_section(struct gdbarch *gdbarch, bfd *obfd, CORE_ADDR address, size_t size)
Definition gdbarch.c:3724
const char * gdbarch_gcore_bfd_target(struct gdbarch *gdbarch)
Definition gdbarch.c:3916
int gdbarch_inner_than(struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
Definition gdbarch.c:2695
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition gdbarch.c:1361
bool gdbarch_find_memory_regions_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3693
@ THREAD_EXITED
Definition gdbthread.h:79
struct thread_info * inferior_thread(void)
Definition thread.c:83
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:1862
size_t size
Definition go32-nat.c:241
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
Definition infcall.c:781
ptid_t inferior_ptid
Definition infcmd.c:91
struct inferior * current_inferior(void)
Definition inferior.c:54
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition objfiles.h:130
struct program_space * current_program_space
Definition progspace.c:39
void(* func)(remote_target *remote, char *)
bool solib_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
Definition solib.c:1207
CORE_ADDR addr() const
Definition objfiles.h:822
CORE_ADDR endaddr() const
Definition objfiles.h:829
CORE_ADDR offset() const
Definition objfiles.h:810
struct bfd_section * the_bfd_section
Definition objfiles.h:835
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:743
struct gdbarch * arch() const
Definition objfiles.h:482
gdb_bfd_ref_ptr obfd
Definition objfiles.h:653
objfiles_range objfiles()
Definition progspace.h:209
bfd * exec_bfd() const
Definition progspace.h:264
Definition value.c:181
bool target_supports_dumpcore()
Definition target.c:275
int target_has_stack()
Definition target.c:178
void target_done_generating_core(void)
Definition target.c:4247
void noprocess(void)
Definition target.c:1131
gdb::unique_xmalloc_ptr< char > target_make_corefile_notes(bfd *bfd, int *size_p)
Definition target.c:451
void target_dumpcore(const char *filename)
Definition target.c:283
bool target_has_execution(inferior *inf)
Definition target.c:202
int target_has_registers()
Definition target.c:190
void target_prepare_to_generate_core(void)
Definition target.c:4239
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1771
int target_find_memory_regions(find_memory_region_ftype func, void *data)
Definition target.c:443
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3114
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
#define gdb_stdout
Definition utils.h:188
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:3625
LONGEST value_as_long(struct value *val)
Definition value.c:2791