1 /* Core dump and executable file functions below target vector, for GDB.
3 Copyright (C) 1986-2018 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 #ifdef HAVE_SYS_FILE_H
25 #include <sys/file.h> /* needed for F_OK and friends */
27 #include "frame.h" /* required by inferior.h */
35 #include "gdbthread.h"
40 #include "readline/readline.h"
42 #include "filenames.h"
43 #include "progspace.h"
46 #include "completer.h"
47 #include "filestuff.h"
53 /* List of all available core_fns. On gdb startup, each core file
54 register reader calls deprecated_add_core_fns() to register
55 information on each core format it is prepared to read. */
57 static struct core_fns *core_file_fns = NULL;
59 /* The core_fns for a core file handler that is prepared to read the
60 core file currently open on core_bfd. */
62 static struct core_fns *core_vec = NULL;
64 /* FIXME: kettenis/20031023: Eventually this variable should
67 static struct gdbarch *core_gdbarch = NULL;
69 /* Per-core data. Currently, only the section table. Note that these
70 target sections are *not* mapped in the current address spaces' set
71 of target sections --- those should come only from pure executable
72 or shared library bfds. The core bfd sections are an
73 implementation detail of the core target, just like ptrace is for
74 unix child targets. */
75 static struct target_section_table *core_data;
77 static void core_files_info (struct target_ops *);
79 static struct core_fns *sniff_core_bfd (bfd *);
81 static int gdb_check_format (bfd *);
83 static void core_close (struct target_ops *self);
85 static void core_close_cleanup (void *ignore);
87 static void add_to_thread_list (bfd *, asection *, void *);
89 static void init_core_ops (void);
91 static struct target_ops core_ops;
93 /* An arbitrary identifier for the core inferior. */
96 /* Link a new core_fns into the global core_file_fns list. Called on
97 gdb startup by the _initialize routine in each core file register
98 reader, to register information about each format the reader is
99 prepared to handle. */
102 deprecated_add_core_fns (struct core_fns *cf)
104 cf->next = core_file_fns;
108 /* The default function that core file handlers can use to examine a
109 core file BFD and decide whether or not to accept the job of
110 reading the core file. */
113 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
117 result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
121 /* Walk through the list of core functions to find a set that can
122 handle the core file open on ABFD. Returns pointer to set that is
125 static struct core_fns *
126 sniff_core_bfd (bfd *abfd)
129 struct core_fns *yummy = NULL;
132 /* Don't sniff if we have support for register sets in
134 if (core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
137 for (cf = core_file_fns; cf != NULL; cf = cf->next)
139 if (cf->core_sniffer (cf, abfd))
147 warning (_("\"%s\": ambiguous core format, %d handlers match"),
148 bfd_get_filename (abfd), matches);
150 else if (matches == 0)
151 error (_("\"%s\": no core file handler recognizes format"),
152 bfd_get_filename (abfd));
157 /* The default is to reject every core file format we see. Either
158 BFD has to recognize it, or we have to provide a function in the
159 core file handler that recognizes it. */
162 default_check_format (bfd *abfd)
167 /* Attempt to recognize core file formats that BFD rejects. */
170 gdb_check_format (bfd *abfd)
174 for (cf = core_file_fns; cf != NULL; cf = cf->next)
176 if (cf->check_format (abfd))
184 /* Discard all vestiges of any previous core file and mark data and
185 stack spaces as empty. */
188 core_close (struct target_ops *self)
192 int pid = ptid_get_pid (inferior_ptid);
193 inferior_ptid = null_ptid; /* Avoid confusion from thread
196 exit_inferior_silent (pid);
198 /* Clear out solib state while the bfd is still open. See
199 comments in clear_solib in solib.c. */
204 xfree (core_data->sections);
209 gdb_bfd_unref (core_bfd);
217 core_close_cleanup (void *ignore)
222 /* Look for sections whose names start with `.reg/' so that we can
223 extract the list of threads in a core file. */
226 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
231 asection *reg_sect = (asection *) reg_sect_arg;
233 struct inferior *inf;
235 if (!startswith (bfd_section_name (abfd, asect), ".reg/"))
238 core_tid = atoi (bfd_section_name (abfd, asect) + 5);
240 pid = bfd_core_file_pid (core_bfd);
249 inf = current_inferior ();
252 inferior_appeared (inf, pid);
253 inf->fake_pid_p = fake_pid_p;
256 ptid = ptid_build (pid, lwpid, 0);
260 /* Warning, Will Robinson, looking at BFD private data! */
263 && asect->filepos == reg_sect->filepos) /* Did we find .reg? */
264 inferior_ptid = ptid; /* Yes, make it current. */
267 /* This routine opens and sets up the core file bfd. */
270 core_open (const char *arg, int from_tty)
274 struct cleanup *old_chain;
278 target_preopen (from_tty);
282 error (_("No core file specified. (Use `detach' "
283 "to stop debugging a core file.)"));
285 error (_("No core file specified."));
288 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg));
289 if (!IS_ABSOLUTE_PATH (filename.get ()))
290 filename.reset (concat (current_directory, "/",
291 filename.get (), (char *) NULL));
293 flags = O_BINARY | O_LARGEFILE;
298 scratch_chan = gdb_open_cloexec (filename.get (), flags, 0);
299 if (scratch_chan < 0)
300 perror_with_name (filename.get ());
302 gdb_bfd_ref_ptr temp_bfd (gdb_bfd_fopen (filename.get (), gnutarget,
303 write_files ? FOPEN_RUB : FOPEN_RB,
305 if (temp_bfd == NULL)
306 perror_with_name (filename.get ());
308 if (!bfd_check_format (temp_bfd.get (), bfd_core)
309 && !gdb_check_format (temp_bfd.get ()))
311 /* Do it after the err msg */
312 /* FIXME: should be checking for errors from bfd_close (for one
313 thing, on error it does not free all the storage associated
315 error (_("\"%s\" is not a core dump: %s"),
316 filename.get (), bfd_errmsg (bfd_get_error ()));
319 /* Looks semi-reasonable. Toss the old core file and work on the
322 unpush_target (&core_ops);
323 core_bfd = temp_bfd.release ();
324 old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
326 core_gdbarch = gdbarch_from_bfd (core_bfd);
328 /* Find a suitable core file handler to munch on core_bfd */
329 core_vec = sniff_core_bfd (core_bfd);
333 core_data = XCNEW (struct target_section_table);
335 /* Find the data section */
336 if (build_section_table (core_bfd,
337 &core_data->sections,
338 &core_data->sections_end))
339 error (_("\"%s\": Can't find sections: %s"),
340 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
342 /* If we have no exec file, try to set the architecture from the
343 core file. We don't do this unconditionally since an exec file
344 typically contains more information that helps us determine the
345 architecture than a core file. */
347 set_gdbarch_from_file (core_bfd);
349 push_target (&core_ops);
350 discard_cleanups (old_chain);
352 /* Do this before acknowledging the inferior, so if
353 post_create_inferior throws (can happen easilly if you're loading
354 a core file with the wrong exec), we aren't left with threads
355 from the previous inferior. */
358 inferior_ptid = null_ptid;
360 /* Need to flush the register cache (and the frame cache) from a
361 previous debug session. If inferior_ptid ends up the same as the
362 last debug session --- e.g., b foo; run; gcore core1; step; gcore
363 core2; core core1; core core2 --- then there's potential for
364 get_current_regcache to return the cached regcache of the
365 previous session, and the frame cache being stale. */
366 registers_changed ();
368 /* Build up thread list from BFD sections, and possibly set the
369 current thread to the .reg/NN section matching the .reg
371 bfd_map_over_sections (core_bfd, add_to_thread_list,
372 bfd_get_section_by_name (core_bfd, ".reg"));
374 if (ptid_equal (inferior_ptid, null_ptid))
376 /* Either we found no .reg/NN section, and hence we have a
377 non-threaded core (single-threaded, from gdb's perspective),
378 or for some reason add_to_thread_list couldn't determine
379 which was the "main" thread. The latter case shouldn't
380 usually happen, but we're dealing with input here, which can
381 always be broken in different ways. */
382 struct thread_info *thread = first_thread_of_process (-1);
386 inferior_appeared (current_inferior (), CORELOW_PID);
387 inferior_ptid = pid_to_ptid (CORELOW_PID);
388 add_thread_silent (inferior_ptid);
391 switch_to_thread (thread->ptid);
394 post_create_inferior (&core_ops, from_tty);
396 /* Now go through the target stack looking for threads since there
397 may be a thread_stratum target loaded on top of target core by
398 now. The layer above should claim threads found in the BFD
402 target_update_thread_list ();
405 CATCH (except, RETURN_MASK_ERROR)
407 exception_print (gdb_stderr, except);
411 p = bfd_core_file_failing_command (core_bfd);
413 printf_filtered (_("Core was generated by `%s'.\n"), p);
415 /* Clearing any previous state of convenience variables. */
416 clear_exit_convenience_vars ();
418 siggy = bfd_core_file_failing_signal (core_bfd);
421 /* If we don't have a CORE_GDBARCH to work with, assume a native
422 core (map gdb_signal from host signals). If we do have
423 CORE_GDBARCH to work with, but no gdb_signal_from_target
424 implementation for that gdbarch, as a fallback measure,
425 assume the host signal mapping. It'll be correct for native
426 cores, but most likely incorrect for cross-cores. */
427 enum gdb_signal sig = (core_gdbarch != NULL
428 && gdbarch_gdb_signal_from_target_p (core_gdbarch)
429 ? gdbarch_gdb_signal_from_target (core_gdbarch,
431 : gdb_signal_from_host (siggy));
433 printf_filtered (_("Program terminated with signal %s, %s.\n"),
434 gdb_signal_to_name (sig), gdb_signal_to_string (sig));
436 /* Set the value of the internal variable $_exitsignal,
437 which holds the signal uncaught by the inferior. */
438 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
442 /* Fetch all registers from core file. */
443 target_fetch_registers (get_current_regcache (), -1);
445 /* Now, set up the frame cache, and print the top of stack. */
446 reinit_frame_cache ();
447 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
449 /* Current thread should be NUM 1 but the user does not know that.
450 If a program is single threaded gdb in general does not mention
451 anything about threads. That is why the test is >= 2. */
452 if (thread_count () >= 2)
456 thread_command (NULL, from_tty);
458 CATCH (except, RETURN_MASK_ERROR)
460 exception_print (gdb_stderr, except);
467 core_detach (struct target_ops *ops, int from_tty)
470 reinit_frame_cache ();
472 printf_filtered (_("No core file now.\n"));
475 /* Try to retrieve registers from a section in core_bfd, and supply
476 them to core_vec->core_read_registers, as the register set numbered
479 If ptid's lwp member is zero, do the single-threaded
480 thing: look for a section named NAME. If ptid's lwp
481 member is non-zero, do the multi-threaded thing: look for a section
482 named "NAME/LWP", where LWP is the shortest ASCII decimal
483 representation of ptid's lwp member.
485 HUMAN_NAME is a human-readable name for the kind of registers the
486 NAME section contains, for use in error messages.
488 If REQUIRED is non-zero, print an error if the core file doesn't
489 have a section by the appropriate name. Otherwise, just do
493 get_core_register_section (struct regcache *regcache,
494 const struct regset *regset,
498 const char *human_name,
501 struct bfd_section *section;
504 bool variable_size_section = (regset != NULL
505 && regset->flags & REGSET_VARIABLE_SIZE);
507 thread_section_name section_name (name, regcache->ptid ());
509 section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
513 warning (_("Couldn't find %s registers in core file."),
518 size = bfd_section_size (core_bfd, section);
521 warning (_("Section `%s' in core file too small."),
522 section_name.c_str ());
525 if (size != min_size && !variable_size_section)
527 warning (_("Unexpected size of section `%s' in core file."),
528 section_name.c_str ());
531 contents = (char *) alloca (size);
532 if (! bfd_get_section_contents (core_bfd, section, contents,
535 warning (_("Couldn't read %s registers from `%s' section in core file."),
536 human_name, section_name.c_str ());
542 regset->supply_regset (regset, regcache, -1, contents, size);
546 gdb_assert (core_vec);
547 core_vec->core_read_registers (regcache, contents, size, which,
549 bfd_section_vma (core_bfd, section)));
552 /* Callback for get_core_registers that handles a single core file
553 register note section. */
556 get_core_registers_cb (const char *sect_name, int size,
557 const struct regset *regset,
558 const char *human_name, void *cb_data)
560 struct regcache *regcache = (struct regcache *) cb_data;
563 if (strcmp (sect_name, ".reg") == 0)
566 if (human_name == NULL)
567 human_name = "general-purpose";
569 else if (strcmp (sect_name, ".reg2") == 0)
571 if (human_name == NULL)
572 human_name = "floating-point";
575 /* The 'which' parameter is only used when no regset is provided.
576 Thus we just set it to -1. */
577 get_core_register_section (regcache, regset, sect_name,
578 size, -1, human_name, required);
581 /* Get the registers out of a core file. This is the machine-
582 independent part. Fetch_core_registers is the machine-dependent
583 part, typically implemented in the xm-file for each
586 /* We just get all the registers, so we don't use regno. */
589 get_core_registers (struct target_ops *ops,
590 struct regcache *regcache, int regno)
593 struct gdbarch *gdbarch;
595 if (!(core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
596 && (core_vec == NULL || core_vec->core_read_registers == NULL))
598 fprintf_filtered (gdb_stderr,
599 "Can't fetch registers from this type of core file\n");
603 gdbarch = regcache->arch ();
604 if (gdbarch_iterate_over_regset_sections_p (gdbarch))
605 gdbarch_iterate_over_regset_sections (gdbarch,
606 get_core_registers_cb,
607 (void *) regcache, NULL);
610 get_core_register_section (regcache, NULL,
611 ".reg", 0, 0, "general-purpose", 1);
612 get_core_register_section (regcache, NULL,
613 ".reg2", 0, 2, "floating-point", 0);
616 /* Mark all registers not found in the core as unavailable. */
617 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
618 if (regcache_register_status (regcache, i) == REG_UNKNOWN)
619 regcache_raw_supply (regcache, i, NULL);
623 core_files_info (struct target_ops *t)
625 print_section_info (core_data, core_bfd);
638 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
640 struct spuid_list *list = (struct spuid_list *) list_p;
641 enum bfd_endian byte_order
642 = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
645 sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
649 if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
651 store_unsigned_integer (list->buf + list->pos - list->offset,
658 static enum target_xfer_status
659 core_xfer_partial (struct target_ops *ops, enum target_object object,
660 const char *annex, gdb_byte *readbuf,
661 const gdb_byte *writebuf, ULONGEST offset,
662 ULONGEST len, ULONGEST *xfered_len)
666 case TARGET_OBJECT_MEMORY:
667 return section_table_xfer_memory_partial (readbuf, writebuf,
668 offset, len, xfered_len,
670 core_data->sections_end,
673 case TARGET_OBJECT_AUXV:
676 /* When the aux vector is stored in core file, BFD
677 represents this with a fake section called ".auxv". */
679 struct bfd_section *section;
682 section = bfd_get_section_by_name (core_bfd, ".auxv");
684 return TARGET_XFER_E_IO;
686 size = bfd_section_size (core_bfd, section);
688 return TARGET_XFER_EOF;
694 return TARGET_XFER_EOF;
695 if (!bfd_get_section_contents (core_bfd, section, readbuf,
696 (file_ptr) offset, size))
698 warning (_("Couldn't read NT_AUXV note in core file."));
699 return TARGET_XFER_E_IO;
702 *xfered_len = (ULONGEST) size;
703 return TARGET_XFER_OK;
705 return TARGET_XFER_E_IO;
707 case TARGET_OBJECT_WCOOKIE:
710 /* When the StackGhost cookie is stored in core file, BFD
711 represents this with a fake section called
714 struct bfd_section *section;
717 section = bfd_get_section_by_name (core_bfd, ".wcookie");
719 return TARGET_XFER_E_IO;
721 size = bfd_section_size (core_bfd, section);
723 return TARGET_XFER_EOF;
729 return TARGET_XFER_EOF;
730 if (!bfd_get_section_contents (core_bfd, section, readbuf,
731 (file_ptr) offset, size))
733 warning (_("Couldn't read StackGhost cookie in core file."));
734 return TARGET_XFER_E_IO;
737 *xfered_len = (ULONGEST) size;
738 return TARGET_XFER_OK;
741 return TARGET_XFER_E_IO;
743 case TARGET_OBJECT_LIBRARIES:
745 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
748 return TARGET_XFER_E_IO;
751 *xfered_len = gdbarch_core_xfer_shared_libraries (core_gdbarch,
755 if (*xfered_len == 0)
756 return TARGET_XFER_EOF;
758 return TARGET_XFER_OK;
763 case TARGET_OBJECT_LIBRARIES_AIX:
765 && gdbarch_core_xfer_shared_libraries_aix_p (core_gdbarch))
768 return TARGET_XFER_E_IO;
772 = gdbarch_core_xfer_shared_libraries_aix (core_gdbarch,
776 if (*xfered_len == 0)
777 return TARGET_XFER_EOF;
779 return TARGET_XFER_OK;
784 case TARGET_OBJECT_SPU:
785 if (readbuf && annex)
787 /* When the SPU contexts are stored in a core file, BFD
788 represents this with a fake section called
791 struct bfd_section *section;
793 char sectionstr[100];
795 xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
797 section = bfd_get_section_by_name (core_bfd, sectionstr);
799 return TARGET_XFER_E_IO;
801 size = bfd_section_size (core_bfd, section);
803 return TARGET_XFER_EOF;
809 return TARGET_XFER_EOF;
810 if (!bfd_get_section_contents (core_bfd, section, readbuf,
811 (file_ptr) offset, size))
813 warning (_("Couldn't read SPU section in core file."));
814 return TARGET_XFER_E_IO;
817 *xfered_len = (ULONGEST) size;
818 return TARGET_XFER_OK;
822 /* NULL annex requests list of all present spuids. */
823 struct spuid_list list;
826 list.offset = offset;
830 bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
832 if (list.written == 0)
833 return TARGET_XFER_EOF;
836 *xfered_len = (ULONGEST) list.written;
837 return TARGET_XFER_OK;
840 return TARGET_XFER_E_IO;
842 case TARGET_OBJECT_SIGNAL_INFO:
846 && gdbarch_core_xfer_siginfo_p (core_gdbarch))
848 LONGEST l = gdbarch_core_xfer_siginfo (core_gdbarch, readbuf,
855 return TARGET_XFER_EOF;
857 return TARGET_XFER_OK;
861 return TARGET_XFER_E_IO;
864 return ops->beneath->to_xfer_partial (ops->beneath, object,
866 writebuf, offset, len,
872 /* If mourn is being called in all the right places, this could be say
873 `gdb internal error' (since generic_mourn calls
874 breakpoint_init_inferior). */
877 ignore (struct target_ops *ops, struct gdbarch *gdbarch,
878 struct bp_target_info *bp_tgt)
883 /* Implement the to_remove_breakpoint method. */
886 core_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
887 struct bp_target_info *bp_tgt,
888 enum remove_bp_reason reason)
894 /* Okay, let's be honest: threads gleaned from a core file aren't
895 exactly lively, are they? On the other hand, if we don't claim
896 that each & every one is alive, then we don't get any of them
897 to appear in an "info thread" command, which is quite a useful
901 core_thread_alive (struct target_ops *ops, ptid_t ptid)
906 /* Ask the current architecture what it knows about this core file.
907 That will be used, in turn, to pick a better architecture. This
908 wrapper could be avoided if targets got a chance to specialize
911 static const struct target_desc *
912 core_read_description (struct target_ops *target)
914 if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
916 const struct target_desc *result;
918 result = gdbarch_core_read_description (core_gdbarch,
924 return target->beneath->to_read_description (target->beneath);
928 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
931 struct inferior *inf;
934 /* The preferred way is to have a gdbarch/OS specific
937 && gdbarch_core_pid_to_str_p (core_gdbarch))
938 return gdbarch_core_pid_to_str (core_gdbarch, ptid);
940 /* Otherwise, if we don't have one, we'll just fallback to
941 "process", with normal_pid_to_str. */
943 /* Try the LWPID field first. */
944 pid = ptid_get_lwp (ptid);
946 return normal_pid_to_str (pid_to_ptid (pid));
948 /* Otherwise, this isn't a "threaded" core -- use the PID field, but
949 only if it isn't a fake PID. */
950 inf = find_inferior_ptid (ptid);
951 if (inf != NULL && !inf->fake_pid_p)
952 return normal_pid_to_str (ptid);
954 /* No luck. We simply don't have a valid PID to print. */
955 xsnprintf (buf, sizeof buf, "<main task>");
960 core_thread_name (struct target_ops *self, struct thread_info *thr)
963 && gdbarch_core_thread_name_p (core_gdbarch))
964 return gdbarch_core_thread_name (core_gdbarch, thr);
969 core_has_memory (struct target_ops *ops)
971 return (core_bfd != NULL);
975 core_has_stack (struct target_ops *ops)
977 return (core_bfd != NULL);
981 core_has_registers (struct target_ops *ops)
983 return (core_bfd != NULL);
986 /* Implement the to_info_proc method. */
989 core_info_proc (struct target_ops *ops, const char *args,
990 enum info_proc_what request)
992 struct gdbarch *gdbarch = get_current_arch ();
994 /* Since this is the core file target, call the 'core_info_proc'
995 method on gdbarch, not 'info_proc'. */
996 if (gdbarch_core_info_proc_p (gdbarch))
997 gdbarch_core_info_proc (gdbarch, args, request);
1000 /* Fill in core_ops with its defined operations and properties. */
1003 init_core_ops (void)
1005 core_ops.to_shortname = "core";
1006 core_ops.to_longname = "Local core dump file";
1008 "Use a core file as a target. Specify the filename of the core file.";
1009 core_ops.to_open = core_open;
1010 core_ops.to_close = core_close;
1011 core_ops.to_detach = core_detach;
1012 core_ops.to_fetch_registers = get_core_registers;
1013 core_ops.to_xfer_partial = core_xfer_partial;
1014 core_ops.to_files_info = core_files_info;
1015 core_ops.to_insert_breakpoint = ignore;
1016 core_ops.to_remove_breakpoint = core_remove_breakpoint;
1017 core_ops.to_thread_alive = core_thread_alive;
1018 core_ops.to_read_description = core_read_description;
1019 core_ops.to_pid_to_str = core_pid_to_str;
1020 core_ops.to_thread_name = core_thread_name;
1021 core_ops.to_stratum = process_stratum;
1022 core_ops.to_has_memory = core_has_memory;
1023 core_ops.to_has_stack = core_has_stack;
1024 core_ops.to_has_registers = core_has_registers;
1025 core_ops.to_info_proc = core_info_proc;
1026 core_ops.to_magic = OPS_MAGIC;
1029 internal_error (__FILE__, __LINE__,
1030 _("init_core_ops: core target already exists (\"%s\")."),
1031 core_target->to_longname);
1032 core_target = &core_ops;
1036 _initialize_corelow (void)
1040 add_target_with_completer (&core_ops, filename_completer);