1 /* Core dump and executable file functions below target vector, for GDB.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "arch-utils.h"
24 #include "frame.h" /* required by inferior.h */
31 #include "process-stratum-target.h"
33 #include "gdbthread.h"
38 #include "readline/readline.h"
40 #include "filenames.h"
41 #include "progspace.h"
44 #include "completer.h"
45 #include "gdbsupport/filestuff.h"
51 static core_fns
*sniff_core_bfd (gdbarch
*core_gdbarch
,
54 /* The core file target. */
56 static const target_info core_target_info
= {
58 N_("Local core dump file"),
59 N_("Use a core file as a target.\n\
60 Specify the filename of the core file.")
63 class core_target final
: public process_stratum_target
67 ~core_target () override
;
69 const target_info
&info () const override
70 { return core_target_info
; }
72 void close () override
;
73 void detach (inferior
*, int) override
;
74 void fetch_registers (struct regcache
*, int) override
;
76 enum target_xfer_status
xfer_partial (enum target_object object
,
79 const gdb_byte
*writebuf
,
80 ULONGEST offset
, ULONGEST len
,
81 ULONGEST
*xfered_len
) override
;
82 void files_info () override
;
84 bool thread_alive (ptid_t ptid
) override
;
85 const struct target_desc
*read_description () override
;
87 std::string
pid_to_str (ptid_t
) override
;
89 const char *thread_name (struct thread_info
*) override
;
91 bool has_all_memory () override
{ return false; }
92 bool has_memory () override
;
93 bool has_stack () override
;
94 bool has_registers () override
;
95 bool has_execution (ptid_t
) override
{ return false; }
97 bool info_proc (const char *, enum info_proc_what
) override
;
101 /* Getter, see variable definition. */
102 struct gdbarch
*core_gdbarch ()
104 return m_core_gdbarch
;
107 /* See definition. */
108 void get_core_register_section (struct regcache
*regcache
,
109 const struct regset
*regset
,
111 int section_min_size
,
113 const char *human_name
,
116 private: /* per-core data */
118 /* The core's section table. Note that these target sections are
119 *not* mapped in the current address spaces' set of target
120 sections --- those should come only from pure executable or
121 shared library bfds. The core bfd sections are an implementation
122 detail of the core target, just like ptrace is for unix child
124 target_section_table m_core_section_table
{};
126 /* The core_fns for a core file handler that is prepared to read the
127 core file currently open on core_bfd. */
128 core_fns
*m_core_vec
= NULL
;
130 /* FIXME: kettenis/20031023: Eventually this field should
132 struct gdbarch
*m_core_gdbarch
= NULL
;
135 core_target::core_target ()
137 m_core_gdbarch
= gdbarch_from_bfd (core_bfd
);
139 /* Find a suitable core file handler to munch on core_bfd */
140 m_core_vec
= sniff_core_bfd (m_core_gdbarch
, core_bfd
);
142 /* Find the data section */
143 if (build_section_table (core_bfd
,
144 &m_core_section_table
.sections
,
145 &m_core_section_table
.sections_end
))
146 error (_("\"%s\": Can't find sections: %s"),
147 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
150 core_target::~core_target ()
152 xfree (m_core_section_table
.sections
);
155 /* List of all available core_fns. On gdb startup, each core file
156 register reader calls deprecated_add_core_fns() to register
157 information on each core format it is prepared to read. */
159 static struct core_fns
*core_file_fns
= NULL
;
161 static int gdb_check_format (bfd
*);
163 static void add_to_thread_list (bfd
*, asection
*, void *);
165 /* An arbitrary identifier for the core inferior. */
166 #define CORELOW_PID 1
168 /* Link a new core_fns into the global core_file_fns list. Called on
169 gdb startup by the _initialize routine in each core file register
170 reader, to register information about each format the reader is
171 prepared to handle. */
174 deprecated_add_core_fns (struct core_fns
*cf
)
176 cf
->next
= core_file_fns
;
180 /* The default function that core file handlers can use to examine a
181 core file BFD and decide whether or not to accept the job of
182 reading the core file. */
185 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
189 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
193 /* Walk through the list of core functions to find a set that can
194 handle the core file open on ABFD. Returns pointer to set that is
197 static struct core_fns
*
198 sniff_core_bfd (struct gdbarch
*core_gdbarch
, bfd
*abfd
)
201 struct core_fns
*yummy
= NULL
;
204 /* Don't sniff if we have support for register sets in
206 if (core_gdbarch
&& gdbarch_iterate_over_regset_sections_p (core_gdbarch
))
209 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
211 if (cf
->core_sniffer (cf
, abfd
))
219 warning (_("\"%s\": ambiguous core format, %d handlers match"),
220 bfd_get_filename (abfd
), matches
);
222 else if (matches
== 0)
223 error (_("\"%s\": no core file handler recognizes format"),
224 bfd_get_filename (abfd
));
229 /* The default is to reject every core file format we see. Either
230 BFD has to recognize it, or we have to provide a function in the
231 core file handler that recognizes it. */
234 default_check_format (bfd
*abfd
)
239 /* Attempt to recognize core file formats that BFD rejects. */
242 gdb_check_format (bfd
*abfd
)
246 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
248 if (cf
->check_format (abfd
))
256 /* Close the core target. */
259 core_target::close ()
263 inferior_ptid
= null_ptid
; /* Avoid confusion from thread
265 exit_inferior_silent (current_inferior ());
267 /* Clear out solib state while the bfd is still open. See
268 comments in clear_solib in solib.c. */
271 current_program_space
->cbfd
.reset (nullptr);
274 /* Core targets are heap-allocated (see core_target_open), so here
275 we delete ourselves. */
279 /* Look for sections whose names start with `.reg/' so that we can
280 extract the list of threads in a core file. */
283 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
288 asection
*reg_sect
= (asection
*) reg_sect_arg
;
289 bool fake_pid_p
= false;
290 struct inferior
*inf
;
292 if (!startswith (bfd_section_name (asect
), ".reg/"))
295 core_tid
= atoi (bfd_section_name (asect
) + 5);
297 pid
= bfd_core_file_pid (core_bfd
);
306 inf
= current_inferior ();
309 inferior_appeared (inf
, pid
);
310 inf
->fake_pid_p
= fake_pid_p
;
313 ptid
= ptid_t (pid
, lwpid
, 0);
317 /* Warning, Will Robinson, looking at BFD private data! */
320 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
321 inferior_ptid
= ptid
; /* Yes, make it current. */
324 /* Issue a message saying we have no core to debug, if FROM_TTY. */
327 maybe_say_no_core_file_now (int from_tty
)
330 printf_filtered (_("No core file now.\n"));
333 /* Backward compatability with old way of specifying core files. */
336 core_file_command (const char *filename
, int from_tty
)
338 dont_repeat (); /* Either way, seems bogus. */
340 if (filename
== NULL
)
342 if (core_bfd
!= NULL
)
344 target_detach (current_inferior (), from_tty
);
345 gdb_assert (core_bfd
== NULL
);
348 maybe_say_no_core_file_now (from_tty
);
351 core_target_open (filename
, from_tty
);
357 core_target_open (const char *arg
, int from_tty
)
364 target_preopen (from_tty
);
368 error (_("No core file specified. (Use `detach' "
369 "to stop debugging a core file.)"));
371 error (_("No core file specified."));
374 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (arg
));
375 if (!IS_ABSOLUTE_PATH (filename
.get ()))
376 filename
.reset (concat (current_directory
, "/",
377 filename
.get (), (char *) NULL
));
379 flags
= O_BINARY
| O_LARGEFILE
;
384 scratch_chan
= gdb_open_cloexec (filename
.get (), flags
, 0);
385 if (scratch_chan
< 0)
386 perror_with_name (filename
.get ());
388 gdb_bfd_ref_ptr
temp_bfd (gdb_bfd_fopen (filename
.get (), gnutarget
,
389 write_files
? FOPEN_RUB
: FOPEN_RB
,
391 if (temp_bfd
== NULL
)
392 perror_with_name (filename
.get ());
394 if (!bfd_check_format (temp_bfd
.get (), bfd_core
)
395 && !gdb_check_format (temp_bfd
.get ()))
397 /* Do it after the err msg */
398 /* FIXME: should be checking for errors from bfd_close (for one
399 thing, on error it does not free all the storage associated
401 error (_("\"%s\" is not a core dump: %s"),
402 filename
.get (), bfd_errmsg (bfd_get_error ()));
405 current_program_space
->cbfd
= std::move (temp_bfd
);
407 core_target
*target
= new core_target ();
409 /* Own the target until it is successfully pushed. */
410 target_ops_up
target_holder (target
);
414 /* If we have no exec file, try to set the architecture from the
415 core file. We don't do this unconditionally since an exec file
416 typically contains more information that helps us determine the
417 architecture than a core file. */
419 set_gdbarch_from_file (core_bfd
);
421 push_target (std::move (target_holder
));
423 inferior_ptid
= null_ptid
;
425 /* Need to flush the register cache (and the frame cache) from a
426 previous debug session. If inferior_ptid ends up the same as the
427 last debug session --- e.g., b foo; run; gcore core1; step; gcore
428 core2; core core1; core core2 --- then there's potential for
429 get_current_regcache to return the cached regcache of the
430 previous session, and the frame cache being stale. */
431 registers_changed ();
433 /* Build up thread list from BFD sections, and possibly set the
434 current thread to the .reg/NN section matching the .reg
436 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
437 bfd_get_section_by_name (core_bfd
, ".reg"));
439 if (inferior_ptid
== null_ptid
)
441 /* Either we found no .reg/NN section, and hence we have a
442 non-threaded core (single-threaded, from gdb's perspective),
443 or for some reason add_to_thread_list couldn't determine
444 which was the "main" thread. The latter case shouldn't
445 usually happen, but we're dealing with input here, which can
446 always be broken in different ways. */
447 thread_info
*thread
= first_thread_of_inferior (current_inferior ());
451 inferior_appeared (current_inferior (), CORELOW_PID
);
452 inferior_ptid
= ptid_t (CORELOW_PID
);
453 add_thread_silent (inferior_ptid
);
456 switch_to_thread (thread
);
459 post_create_inferior (target
, from_tty
);
461 /* Now go through the target stack looking for threads since there
462 may be a thread_stratum target loaded on top of target core by
463 now. The layer above should claim threads found in the BFD
467 target_update_thread_list ();
470 catch (const gdb_exception_error
&except
)
472 exception_print (gdb_stderr
, except
);
475 p
= bfd_core_file_failing_command (core_bfd
);
477 printf_filtered (_("Core was generated by `%s'.\n"), p
);
479 /* Clearing any previous state of convenience variables. */
480 clear_exit_convenience_vars ();
482 siggy
= bfd_core_file_failing_signal (core_bfd
);
485 gdbarch
*core_gdbarch
= target
->core_gdbarch ();
487 /* If we don't have a CORE_GDBARCH to work with, assume a native
488 core (map gdb_signal from host signals). If we do have
489 CORE_GDBARCH to work with, but no gdb_signal_from_target
490 implementation for that gdbarch, as a fallback measure,
491 assume the host signal mapping. It'll be correct for native
492 cores, but most likely incorrect for cross-cores. */
493 enum gdb_signal sig
= (core_gdbarch
!= NULL
494 && gdbarch_gdb_signal_from_target_p (core_gdbarch
)
495 ? gdbarch_gdb_signal_from_target (core_gdbarch
,
497 : gdb_signal_from_host (siggy
));
499 printf_filtered (_("Program terminated with signal %s, %s.\n"),
500 gdb_signal_to_name (sig
), gdb_signal_to_string (sig
));
502 /* Set the value of the internal variable $_exitsignal,
503 which holds the signal uncaught by the inferior. */
504 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
508 /* Fetch all registers from core file. */
509 target_fetch_registers (get_current_regcache (), -1);
511 /* Now, set up the frame cache, and print the top of stack. */
512 reinit_frame_cache ();
513 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
515 /* Current thread should be NUM 1 but the user does not know that.
516 If a program is single threaded gdb in general does not mention
517 anything about threads. That is why the test is >= 2. */
518 if (thread_count () >= 2)
522 thread_command (NULL
, from_tty
);
524 catch (const gdb_exception_error
&except
)
526 exception_print (gdb_stderr
, except
);
532 core_target::detach (inferior
*inf
, int from_tty
)
534 /* Note that 'this' is dangling after this call. unpush_target
535 closes the target, and our close implementation deletes
537 unpush_target (this);
539 /* Clear the register cache and the frame cache. */
540 registers_changed ();
541 reinit_frame_cache ();
542 maybe_say_no_core_file_now (from_tty
);
545 /* Try to retrieve registers from a section in core_bfd, and supply
546 them to m_core_vec->core_read_registers, as the register set
549 If ptid's lwp member is zero, do the single-threaded
550 thing: look for a section named NAME. If ptid's lwp
551 member is non-zero, do the multi-threaded thing: look for a section
552 named "NAME/LWP", where LWP is the shortest ASCII decimal
553 representation of ptid's lwp member.
555 HUMAN_NAME is a human-readable name for the kind of registers the
556 NAME section contains, for use in error messages.
558 If REQUIRED is true, print an error if the core file doesn't have a
559 section by the appropriate name. Otherwise, just do nothing. */
562 core_target::get_core_register_section (struct regcache
*regcache
,
563 const struct regset
*regset
,
565 int section_min_size
,
567 const char *human_name
,
570 struct bfd_section
*section
;
573 bool variable_size_section
= (regset
!= NULL
574 && regset
->flags
& REGSET_VARIABLE_SIZE
);
576 thread_section_name
section_name (name
, regcache
->ptid ());
578 section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
582 warning (_("Couldn't find %s registers in core file."),
587 size
= bfd_section_size (section
);
588 if (size
< section_min_size
)
590 warning (_("Section `%s' in core file too small."),
591 section_name
.c_str ());
594 if (size
!= section_min_size
&& !variable_size_section
)
596 warning (_("Unexpected size of section `%s' in core file."),
597 section_name
.c_str ());
600 contents
= (char *) alloca (size
);
601 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
604 warning (_("Couldn't read %s registers from `%s' section in core file."),
605 human_name
, section_name
.c_str ());
611 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
615 gdb_assert (m_core_vec
!= nullptr);
616 m_core_vec
->core_read_registers (regcache
, contents
, size
, which
,
617 (CORE_ADDR
) bfd_section_vma (section
));
620 /* Data passed to gdbarch_iterate_over_regset_sections's callback. */
621 struct get_core_registers_cb_data
624 struct regcache
*regcache
;
627 /* Callback for get_core_registers that handles a single core file
628 register note section. */
631 get_core_registers_cb (const char *sect_name
, int supply_size
, int collect_size
,
632 const struct regset
*regset
,
633 const char *human_name
, void *cb_data
)
635 auto *data
= (get_core_registers_cb_data
*) cb_data
;
636 bool required
= false;
637 bool variable_size_section
= (regset
!= NULL
638 && regset
->flags
& REGSET_VARIABLE_SIZE
);
640 if (!variable_size_section
)
641 gdb_assert (supply_size
== collect_size
);
643 if (strcmp (sect_name
, ".reg") == 0)
646 if (human_name
== NULL
)
647 human_name
= "general-purpose";
649 else if (strcmp (sect_name
, ".reg2") == 0)
651 if (human_name
== NULL
)
652 human_name
= "floating-point";
655 /* The 'which' parameter is only used when no regset is provided.
656 Thus we just set it to -1. */
657 data
->target
->get_core_register_section (data
->regcache
, regset
, sect_name
,
658 supply_size
, -1, human_name
,
662 /* Get the registers out of a core file. This is the machine-
663 independent part. Fetch_core_registers is the machine-dependent
664 part, typically implemented in the xm-file for each
667 /* We just get all the registers, so we don't use regno. */
670 core_target::fetch_registers (struct regcache
*regcache
, int regno
)
673 struct gdbarch
*gdbarch
;
675 if (!(m_core_gdbarch
!= nullptr
676 && gdbarch_iterate_over_regset_sections_p (m_core_gdbarch
))
677 && (m_core_vec
== NULL
|| m_core_vec
->core_read_registers
== NULL
))
679 fprintf_filtered (gdb_stderr
,
680 "Can't fetch registers from this type of core file\n");
684 gdbarch
= regcache
->arch ();
685 if (gdbarch_iterate_over_regset_sections_p (gdbarch
))
687 get_core_registers_cb_data data
= { this, regcache
};
688 gdbarch_iterate_over_regset_sections (gdbarch
,
689 get_core_registers_cb
,
690 (void *) &data
, NULL
);
694 get_core_register_section (regcache
, NULL
,
695 ".reg", 0, 0, "general-purpose", 1);
696 get_core_register_section (regcache
, NULL
,
697 ".reg2", 0, 2, "floating-point", 0);
700 /* Mark all registers not found in the core as unavailable. */
701 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
702 if (regcache
->get_register_status (i
) == REG_UNKNOWN
)
703 regcache
->raw_supply (i
, NULL
);
707 core_target::files_info ()
709 print_section_info (&m_core_section_table
, core_bfd
);
712 enum target_xfer_status
713 core_target::xfer_partial (enum target_object object
, const char *annex
,
714 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
715 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
719 case TARGET_OBJECT_MEMORY
:
720 return (section_table_xfer_memory_partial
722 offset
, len
, xfered_len
,
723 m_core_section_table
.sections
,
724 m_core_section_table
.sections_end
,
727 case TARGET_OBJECT_AUXV
:
730 /* When the aux vector is stored in core file, BFD
731 represents this with a fake section called ".auxv". */
733 struct bfd_section
*section
;
736 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
738 return TARGET_XFER_E_IO
;
740 size
= bfd_section_size (section
);
742 return TARGET_XFER_EOF
;
748 return TARGET_XFER_EOF
;
749 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
,
750 (file_ptr
) offset
, size
))
752 warning (_("Couldn't read NT_AUXV note in core file."));
753 return TARGET_XFER_E_IO
;
756 *xfered_len
= (ULONGEST
) size
;
757 return TARGET_XFER_OK
;
759 return TARGET_XFER_E_IO
;
761 case TARGET_OBJECT_WCOOKIE
:
764 /* When the StackGhost cookie is stored in core file, BFD
765 represents this with a fake section called
768 struct bfd_section
*section
;
771 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
773 return TARGET_XFER_E_IO
;
775 size
= bfd_section_size (section
);
777 return TARGET_XFER_EOF
;
783 return TARGET_XFER_EOF
;
784 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
,
785 (file_ptr
) offset
, size
))
787 warning (_("Couldn't read StackGhost cookie in core file."));
788 return TARGET_XFER_E_IO
;
791 *xfered_len
= (ULONGEST
) size
;
792 return TARGET_XFER_OK
;
795 return TARGET_XFER_E_IO
;
797 case TARGET_OBJECT_LIBRARIES
:
798 if (m_core_gdbarch
!= nullptr
799 && gdbarch_core_xfer_shared_libraries_p (m_core_gdbarch
))
802 return TARGET_XFER_E_IO
;
805 *xfered_len
= gdbarch_core_xfer_shared_libraries (m_core_gdbarch
,
809 if (*xfered_len
== 0)
810 return TARGET_XFER_EOF
;
812 return TARGET_XFER_OK
;
817 case TARGET_OBJECT_LIBRARIES_AIX
:
818 if (m_core_gdbarch
!= nullptr
819 && gdbarch_core_xfer_shared_libraries_aix_p (m_core_gdbarch
))
822 return TARGET_XFER_E_IO
;
826 = gdbarch_core_xfer_shared_libraries_aix (m_core_gdbarch
,
830 if (*xfered_len
== 0)
831 return TARGET_XFER_EOF
;
833 return TARGET_XFER_OK
;
838 case TARGET_OBJECT_SIGNAL_INFO
:
841 if (m_core_gdbarch
!= nullptr
842 && gdbarch_core_xfer_siginfo_p (m_core_gdbarch
))
844 LONGEST l
= gdbarch_core_xfer_siginfo (m_core_gdbarch
, readbuf
,
851 return TARGET_XFER_EOF
;
853 return TARGET_XFER_OK
;
857 return TARGET_XFER_E_IO
;
860 return this->beneath ()->xfer_partial (object
, annex
, readbuf
,
861 writebuf
, offset
, len
,
868 /* Okay, let's be honest: threads gleaned from a core file aren't
869 exactly lively, are they? On the other hand, if we don't claim
870 that each & every one is alive, then we don't get any of them
871 to appear in an "info thread" command, which is quite a useful
875 core_target::thread_alive (ptid_t ptid
)
880 /* Ask the current architecture what it knows about this core file.
881 That will be used, in turn, to pick a better architecture. This
882 wrapper could be avoided if targets got a chance to specialize
885 const struct target_desc
*
886 core_target::read_description ()
888 if (m_core_gdbarch
&& gdbarch_core_read_description_p (m_core_gdbarch
))
890 const struct target_desc
*result
;
892 result
= gdbarch_core_read_description (m_core_gdbarch
, this, core_bfd
);
897 return this->beneath ()->read_description ();
901 core_target::pid_to_str (ptid_t ptid
)
903 struct inferior
*inf
;
906 /* The preferred way is to have a gdbarch/OS specific
908 if (m_core_gdbarch
!= nullptr
909 && gdbarch_core_pid_to_str_p (m_core_gdbarch
))
910 return gdbarch_core_pid_to_str (m_core_gdbarch
, ptid
);
912 /* Otherwise, if we don't have one, we'll just fallback to
913 "process", with normal_pid_to_str. */
915 /* Try the LWPID field first. */
918 return normal_pid_to_str (ptid_t (pid
));
920 /* Otherwise, this isn't a "threaded" core -- use the PID field, but
921 only if it isn't a fake PID. */
922 inf
= find_inferior_ptid (ptid
);
923 if (inf
!= NULL
&& !inf
->fake_pid_p
)
924 return normal_pid_to_str (ptid
);
926 /* No luck. We simply don't have a valid PID to print. */
927 return "<main task>";
931 core_target::thread_name (struct thread_info
*thr
)
933 if (m_core_gdbarch
!= nullptr
934 && gdbarch_core_thread_name_p (m_core_gdbarch
))
935 return gdbarch_core_thread_name (m_core_gdbarch
, thr
);
940 core_target::has_memory ()
942 return (core_bfd
!= NULL
);
946 core_target::has_stack ()
948 return (core_bfd
!= NULL
);
952 core_target::has_registers ()
954 return (core_bfd
!= NULL
);
957 /* Implement the to_info_proc method. */
960 core_target::info_proc (const char *args
, enum info_proc_what request
)
962 struct gdbarch
*gdbarch
= get_current_arch ();
964 /* Since this is the core file target, call the 'core_info_proc'
965 method on gdbarch, not 'info_proc'. */
966 if (gdbarch_core_info_proc_p (gdbarch
))
967 gdbarch_core_info_proc (gdbarch
, args
, request
);
973 _initialize_corelow (void)
975 add_target (core_target_info
, core_target_open
, filename_completer
);