gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.h"
  24 #include "gdb_string.h"
  25 #include <errno.h>
  26 #include <signal.h>
  27 #include <fcntl.h>
  28 #ifdef HAVE_SYS_FILE_H
  29 #include <sys/file.h>           /* needed for F_OK and friends */
  30 #endif
  31 #include "frame.h"              /* required by inferior.h */
  32 #include "inferior.h"
  33 #include "symtab.h"
  34 #include "command.h"
  35 #include "bfd.h"
  36 #include "target.h"
  37 #include "gdbcore.h"
  38 #include "gdbthread.h"
  39 #include "regcache.h"
  40 #include "regset.h"
  41 #include "symfile.h"
  42 #include "exec.h"
  43 #include "readline/readline.h"
  44 #include "gdb_assert.h"
  45 #include "exceptions.h"
  46 #include "solib.h"
  47 #include "filenames.h"
  48
  49
  50 #ifndef O_LARGEFILE
  51 #define O_LARGEFILE 0
  52 #endif
  53
  54 /* List of all available core_fns.  On gdb startup, each core file
  55    register reader calls deprecated_add_core_fns() to register
  56    information on each core format it is prepared to read.  */
  57
  58 static struct core_fns *core_file_fns = NULL;
  59
  60 /* The core_fns for a core file handler that is prepared to read the core
  61    file currently open on core_bfd. */
  62
  63 static struct core_fns *core_vec = NULL;
  64
  65 /* FIXME: kettenis/20031023: Eventually this variable should
  66    disappear.  */
  67
  68 struct gdbarch *core_gdbarch = NULL;
  69
  70 static void core_files_info (struct target_ops *);
  71
  72 static struct core_fns *sniff_core_bfd (bfd *);
  73
  74 static int gdb_check_format (bfd *);
  75
  76 static void core_open (char *, int);
  77
  78 static void core_detach (struct target_ops *ops, char *, int);
  79
  80 static void core_close (int);
  81
  82 static void core_close_cleanup (void *ignore);
  83
  84 static void get_core_registers (struct regcache *, int);
  85
  86 static void add_to_thread_list (bfd *, asection *, void *);
  87
  88 static int core_file_thread_alive (ptid_t tid);
  89
  90 static void init_core_ops (void);
  91
  92 void _initialize_corelow (void);
  93
  94 struct target_ops core_ops;
  95
  96 /* An arbitrary identifier for the core inferior.  */
  97 #define CORELOW_PID 1
  98
  99 /* Link a new core_fns into the global core_file_fns list.  Called on gdb
 100    startup by the _initialize routine in each core file register reader, to
 101    register information about each format the the reader is prepared to
 102    handle. */
 103
 104 void
 105 deprecated_add_core_fns (struct core_fns *cf)
 106 {
 107   cf->next = core_file_fns;
 108   core_file_fns = cf;
 109 }
 110
 111 /* The default function that core file handlers can use to examine a
 112    core file BFD and decide whether or not to accept the job of
 113    reading the core file. */
 114
 115 int
 116 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
 117 {
 118   int result;
 119
 120   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
 121   return (result);
 122 }
 123
 124 /* Walk through the list of core functions to find a set that can
 125    handle the core file open on ABFD.  Default to the first one in the
 126    list if nothing matches.  Returns pointer to set that is
 127    selected. */
 128
 129 static struct core_fns *
 130 sniff_core_bfd (bfd *abfd)
 131 {
 132   struct core_fns *cf;
 133   struct core_fns *yummy = NULL;
 134   int matches = 0;;
 135
 136   /* Don't sniff if we have support for register sets in CORE_GDBARCH.  */
 137   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 138     return NULL;
 139
 140   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 141     {
 142       if (cf->core_sniffer (cf, abfd))
 143         {
 144           yummy = cf;
 145           matches++;
 146         }
 147     }
 148   if (matches > 1)
 149     {
 150       warning (_("\"%s\": ambiguous core format, %d handlers match"),
 151                bfd_get_filename (abfd), matches);
 152     }
 153   else if (matches == 0)
 154     {
 155       warning (_("\"%s\": no core file handler recognizes format, using default"),
 156                bfd_get_filename (abfd));
 157     }
 158   if (yummy == NULL)
 159     {
 160       yummy = core_file_fns;
 161     }
 162   return (yummy);
 163 }
 164
 165 /* The default is to reject every core file format we see.  Either
 166    BFD has to recognize it, or we have to provide a function in the
 167    core file handler that recognizes it. */
 168
 169 int
 170 default_check_format (bfd *abfd)
 171 {
 172   return (0);
 173 }
 174
 175 /* Attempt to recognize core file formats that BFD rejects. */
 176
 177 static int
 178 gdb_check_format (bfd *abfd)
 179 {
 180   struct core_fns *cf;
 181
 182   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 183     {
 184       if (cf->check_format (abfd))
 185         {
 186           return (1);
 187         }
 188     }
 189   return (0);
 190 }
 191
 192 /* Discard all vestiges of any previous core file and mark data and stack
 193    spaces as empty.  */
 194
 195 static void
 196 core_close (int quitting)
 197 {
 198   char *name;
 199
 200   if (core_bfd)
 201     {
 202       inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff */
 203       delete_inferior_silent (CORELOW_PID);
 204
 205       /* Clear out solib state while the bfd is still open. See
 206          comments in clear_solib in solib.c. */
 207       clear_solib ();
 208
 209       name = bfd_get_filename (core_bfd);
 210       if (!bfd_close (core_bfd))
 211         warning (_("cannot close \"%s\": %s"),
 212                  name, bfd_errmsg (bfd_get_error ()));
 213       xfree (name);
 214       core_bfd = NULL;
 215       if (core_ops.to_sections)
 216         {
 217           xfree (core_ops.to_sections);
 218           core_ops.to_sections = NULL;
 219           core_ops.to_sections_end = NULL;
 220         }
 221     }
 222   core_vec = NULL;
 223   core_gdbarch = NULL;
 224 }
 225
 226 static void
 227 core_close_cleanup (void *ignore)
 228 {
 229   core_close (0/*ignored*/);
 230 }
 231
 232 /* Look for sections whose names start with `.reg/' so that we can extract the
 233    list of threads in a core file.  */
 234
 235 static void
 236 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
 237 {
 238   ptid_t ptid;
 239   int thread_id;
 240   asection *reg_sect = (asection *) reg_sect_arg;
 241
 242   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 243     return;
 244
 245   thread_id = atoi (bfd_section_name (abfd, asect) + 5);
 246
 247   ptid = ptid_build (ptid_get_pid (inferior_ptid), thread_id, 0);
 248
 249   if (ptid_get_lwp (inferior_ptid) == 0)
 250     /* The main thread has already been added before getting here, and
 251        this is the first time we hear about a thread id.  Assume this
 252        is the main thread.  */
 253     thread_change_ptid (inferior_ptid, ptid);
 254   else
 255     /* Nope, really a new thread.  */
 256     add_thread (ptid);
 257
 258 /* Warning, Will Robinson, looking at BFD private data! */
 259
 260   if (reg_sect != NULL
 261       && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
 262     inferior_ptid = ptid;                        /* Yes, make it current */
 263 }
 264
 265 /* This routine opens and sets up the core file bfd.  */
 266
 267 static void
 268 core_open (char *filename, int from_tty)
 269 {
 270   const char *p;
 271   int siggy;
 272   struct cleanup *old_chain;
 273   char *temp;
 274   bfd *temp_bfd;
 275   int scratch_chan;
 276   int flags;
 277   int corelow_pid = CORELOW_PID;
 278
 279   target_preopen (from_tty);
 280   if (!filename)
 281     {
 282       if (core_bfd)
 283         error (_("No core file specified.  (Use `detach' to stop debugging a core file.)"));
 284       else
 285         error (_("No core file specified."));
 286     }
 287
 288   filename = tilde_expand (filename);
 289   if (!IS_ABSOLUTE_PATH(filename))
 290     {
 291       temp = concat (current_directory, "/", filename, (char *)NULL);
 292       xfree (filename);
 293       filename = temp;
 294     }
 295
 296   old_chain = make_cleanup (xfree, filename);
 297
 298   flags = O_BINARY | O_LARGEFILE;
 299   if (write_files)
 300     flags |= O_RDWR;
 301   else
 302     flags |= O_RDONLY;
 303   scratch_chan = open (filename, flags, 0);
 304   if (scratch_chan < 0)
 305     perror_with_name (filename);
 306
 307   temp_bfd = bfd_fopen (filename, gnutarget,
 308                         write_files ? FOPEN_RUB : FOPEN_RB,
 309                         scratch_chan);
 310   if (temp_bfd == NULL)
 311     perror_with_name (filename);
 312
 313   if (!bfd_check_format (temp_bfd, bfd_core) &&
 314       !gdb_check_format (temp_bfd))
 315     {
 316       /* Do it after the err msg */
 317       /* FIXME: should be checking for errors from bfd_close (for one thing,
 318          on error it does not free all the storage associated with the
 319          bfd).  */
 320       make_cleanup_bfd_close (temp_bfd);
 321       error (_("\"%s\" is not a core dump: %s"),
 322              filename, bfd_errmsg (bfd_get_error ()));
 323     }
 324
 325   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 326
 327   discard_cleanups (old_chain); /* Don't free filename any more */
 328   unpush_target (&core_ops);
 329   core_bfd = temp_bfd;
 330   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 331
 332   /* FIXME: kettenis/20031023: This is very dangerous.  The
 333      CORE_GDBARCH that results from this call may very well be
 334      different from CURRENT_GDBARCH.  However, its methods may only
 335      work if it is selected as the current architecture, because they
 336      rely on swapped data (see gdbarch.c).  We should get rid of that
 337      swapped data.  */
 338   core_gdbarch = gdbarch_from_bfd (core_bfd);
 339
 340   /* Find a suitable core file handler to munch on core_bfd */
 341   core_vec = sniff_core_bfd (core_bfd);
 342
 343   validate_files ();
 344
 345   /* Find the data section */
 346   if (build_section_table (core_bfd, &core_ops.to_sections,
 347                            &core_ops.to_sections_end))
 348     error (_("\"%s\": Can't find sections: %s"),
 349            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 350
 351   /* If we have no exec file, try to set the architecture from the
 352      core file.  We don't do this unconditionally since an exec file
 353      typically contains more information that helps us determine the
 354      architecture than a core file.  */
 355   if (!exec_bfd)
 356     set_gdbarch_from_file (core_bfd);
 357
 358   push_target (&core_ops);
 359   discard_cleanups (old_chain);
 360
 361   add_inferior_silent (corelow_pid);
 362
 363   /* Do this before acknowledging the inferior, so if
 364      post_create_inferior throws (can happen easilly if you're loading
 365      a core file with the wrong exec), we aren't left with threads
 366      from the previous inferior.  */
 367   init_thread_list ();
 368
 369   /* Set INFERIOR_PTID early, so an upper layer can rely on it being
 370      set while in the target_find_new_threads call below.  */
 371   inferior_ptid = pid_to_ptid (corelow_pid);
 372
 373   /* Assume ST --- Add a main task.  We'll later detect when we go
 374      from ST to MT.  */
 375   add_thread_silent (inferior_ptid);
 376
 377   /* This is done first, before anything has a chance to query the
 378      inferior for information such as symbols.  */
 379   post_create_inferior (&core_ops, from_tty);
 380
 381   /* Build up thread list from BFD sections, and possibly set the
 382      current thread to the .reg/NN section matching the .reg
 383      section. */
 384   bfd_map_over_sections (core_bfd, add_to_thread_list,
 385                          bfd_get_section_by_name (core_bfd, ".reg"));
 386
 387   /* Now go through the target stack looking for threads since there
 388      may be a thread_stratum target loaded on top of target core by
 389      now.  The layer above should claim threads found in the BFD
 390      sections.  */
 391   target_find_new_threads ();
 392
 393   p = bfd_core_file_failing_command (core_bfd);
 394   if (p)
 395     printf_filtered (_("Core was generated by `%s'.\n"), p);
 396
 397   siggy = bfd_core_file_failing_signal (core_bfd);
 398   if (siggy > 0)
 399     /* NOTE: target_signal_from_host() converts a target signal value
 400        into gdb's internal signal value.  Unfortunately gdb's internal
 401        value is called ``target_signal'' and this function got the
 402        name ..._from_host(). */
 403     printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
 404                      target_signal_to_string (
 405                        gdbarch_target_signal_from_host (core_gdbarch, siggy)));
 406
 407   /* Fetch all registers from core file.  */
 408   target_fetch_registers (get_current_regcache (), -1);
 409
 410   /* Now, set up the frame cache, and print the top of stack.  */
 411   reinit_frame_cache ();
 412   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 413 }
 414
 415 static void
 416 core_detach (struct target_ops *ops, char *args, int from_tty)
 417 {
 418   if (args)
 419     error (_("Too many arguments"));
 420   unpush_target (ops);
 421   reinit_frame_cache ();
 422   if (from_tty)
 423     printf_filtered (_("No core file now.\n"));
 424 }
 425
 426
 427 /* Try to retrieve registers from a section in core_bfd, and supply
 428    them to core_vec->core_read_registers, as the register set numbered
 429    WHICH.
 430
 431    If inferior_ptid's lwp member is zero, do the single-threaded
 432    thing: look for a section named NAME.  If inferior_ptid's lwp
 433    member is non-zero, do the multi-threaded thing: look for a section
 434    named "NAME/LWP", where LWP is the shortest ASCII decimal
 435    representation of inferior_ptid's lwp member.
 436
 437    HUMAN_NAME is a human-readable name for the kind of registers the
 438    NAME section contains, for use in error messages.
 439
 440    If REQUIRED is non-zero, print an error if the core file doesn't
 441    have a section by the appropriate name.  Otherwise, just do nothing.  */
 442
 443 static void
 444 get_core_register_section (struct regcache *regcache,
 445                            char *name,
 446                            int which,
 447                            char *human_name,
 448                            int required)
 449 {
 450   static char *section_name = NULL;
 451   struct bfd_section *section;
 452   bfd_size_type size;
 453   char *contents;
 454
 455   xfree (section_name);
 456   if (ptid_get_lwp (inferior_ptid))
 457     section_name = xstrprintf ("%s/%ld", name, ptid_get_lwp (inferior_ptid));
 458   else
 459     section_name = xstrdup (name);
 460
 461   section = bfd_get_section_by_name (core_bfd, section_name);
 462   if (! section)
 463     {
 464       if (required)
 465         warning (_("Couldn't find %s registers in core file."), human_name);
 466       return;
 467     }
 468
 469   size = bfd_section_size (core_bfd, section);
 470   contents = alloca (size);
 471   if (! bfd_get_section_contents (core_bfd, section, contents,
 472                                   (file_ptr) 0, size))
 473     {
 474       warning (_("Couldn't read %s registers from `%s' section in core file."),
 475                human_name, name);
 476       return;
 477     }
 478
 479   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 480     {
 481       const struct regset *regset;
 482
 483       regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
 484       if (regset == NULL)
 485         {
 486           if (required)
 487             warning (_("Couldn't recognize %s registers in core file."),
 488                      human_name);
 489           return;
 490         }
 491
 492       regset->supply_regset (regset, regcache, -1, contents, size);
 493       return;
 494     }
 495
 496   gdb_assert (core_vec);
 497   core_vec->core_read_registers (regcache, contents, size, which,
 498                                  ((CORE_ADDR)
 499                                   bfd_section_vma (core_bfd, section)));
 500 }
 501
 502
 503 /* Get the registers out of a core file.  This is the machine-
 504    independent part.  Fetch_core_registers is the machine-dependent
 505    part, typically implemented in the xm-file for each architecture.  */
 506
 507 /* We just get all the registers, so we don't use regno.  */
 508
 509 static void
 510 get_core_registers (struct regcache *regcache, int regno)
 511 {
 512   int i;
 513
 514   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 515       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 516     {
 517       fprintf_filtered (gdb_stderr,
 518                      "Can't fetch registers from this type of core file\n");
 519       return;
 520     }
 521
 522   get_core_register_section (regcache,
 523                              ".reg", 0, "general-purpose", 1);
 524   get_core_register_section (regcache,
 525                              ".reg2", 2, "floating-point", 0);
 526   get_core_register_section (regcache,
 527                              ".reg-xfp", 3, "extended floating-point", 0);
 528   get_core_register_section (regcache,
 529                              ".reg-ppc-vmx", 3, "ppc Altivec", 0);
 530   get_core_register_section (regcache,
 531                              ".reg-ppc-vsx", 4, "POWER7 VSX", 0);
 532
 533   /* Supply dummy value for all registers not found in the core.  */
 534   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 535     if (!regcache_valid_p (regcache, i))
 536       regcache_raw_supply (regcache, i, NULL);
 537 }
 538
 539 static void
 540 core_files_info (struct target_ops *t)
 541 {
 542   print_section_info (t, core_bfd);
 543 }
 544 \f
 545 static LONGEST
 546 core_xfer_partial (struct target_ops *ops, enum target_object object,
 547                    const char *annex, gdb_byte *readbuf,
 548                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
 549 {
 550   switch (object)
 551     {
 552     case TARGET_OBJECT_MEMORY:
 553       if (readbuf)
 554         return (*ops->deprecated_xfer_memory) (offset, readbuf,
 555                                                len, 0/*read*/, NULL, ops);
 556       if (writebuf)
 557         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
 558                                                len, 1/*write*/, NULL, ops);
 559       return -1;
 560
 561     case TARGET_OBJECT_AUXV:
 562       if (readbuf)
 563         {
 564           /* When the aux vector is stored in core file, BFD
 565              represents this with a fake section called ".auxv".  */
 566
 567           struct bfd_section *section;
 568           bfd_size_type size;
 569           char *contents;
 570
 571           section = bfd_get_section_by_name (core_bfd, ".auxv");
 572           if (section == NULL)
 573             return -1;
 574
 575           size = bfd_section_size (core_bfd, section);
 576           if (offset >= size)
 577             return 0;
 578           size -= offset;
 579           if (size > len)
 580             size = len;
 581           if (size > 0
 582               && !bfd_get_section_contents (core_bfd, section, readbuf,
 583                                             (file_ptr) offset, size))
 584             {
 585               warning (_("Couldn't read NT_AUXV note in core file."));
 586               return -1;
 587             }
 588
 589           return size;
 590         }
 591       return -1;
 592
 593     case TARGET_OBJECT_WCOOKIE:
 594       if (readbuf)
 595         {
 596           /* When the StackGhost cookie is stored in core file, BFD
 597              represents this with a fake section called ".wcookie".  */
 598
 599           struct bfd_section *section;
 600           bfd_size_type size;
 601           char *contents;
 602
 603           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 604           if (section == NULL)
 605             return -1;
 606
 607           size = bfd_section_size (core_bfd, section);
 608           if (offset >= size)
 609             return 0;
 610           size -= offset;
 611           if (size > len)
 612             size = len;
 613           if (size > 0
 614               && !bfd_get_section_contents (core_bfd, section, readbuf,
 615                                             (file_ptr) offset, size))
 616             {
 617               warning (_("Couldn't read StackGhost cookie in core file."));
 618               return -1;
 619             }
 620
 621           return size;
 622         }
 623       return -1;
 624
 625     case TARGET_OBJECT_LIBRARIES:
 626       if (core_gdbarch
 627           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 628         {
 629           if (writebuf)
 630             return -1;
 631           return
 632             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 633                                                 readbuf, offset, len);
 634         }
 635       /* FALL THROUGH */
 636
 637     default:
 638       if (ops->beneath != NULL)
 639         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
 640                                               readbuf, writebuf, offset, len);
 641       return -1;
 642     }
 643 }
 644
 645 \f
 646 /* If mourn is being called in all the right places, this could be say
 647    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 648
 649 static int
 650 ignore (struct bp_target_info *bp_tgt)
 651 {
 652   return 0;
 653 }
 654
 655
 656 /* Okay, let's be honest: threads gleaned from a core file aren't
 657    exactly lively, are they?  On the other hand, if we don't claim
 658    that each & every one is alive, then we don't get any of them
 659    to appear in an "info thread" command, which is quite a useful
 660    behaviour.
 661  */
 662 static int
 663 core_file_thread_alive (ptid_t tid)
 664 {
 665   return 1;
 666 }
 667
 668 /* Ask the current architecture what it knows about this core file.
 669    That will be used, in turn, to pick a better architecture.  This
 670    wrapper could be avoided if targets got a chance to specialize
 671    core_ops.  */
 672
 673 static const struct target_desc *
 674 core_read_description (struct target_ops *target)
 675 {
 676   if (gdbarch_core_read_description_p (current_gdbarch))
 677     return gdbarch_core_read_description (current_gdbarch, target, core_bfd);
 678
 679   return NULL;
 680 }
 681
 682 static char *
 683 core_pid_to_str (ptid_t ptid)
 684 {
 685   static char buf[64];
 686
 687   if (ptid_get_lwp (ptid) == 0)
 688     xsnprintf (buf, sizeof buf, "<main task>");
 689   else
 690     xsnprintf (buf, sizeof buf, "Thread %ld", ptid_get_lwp (ptid));
 691
 692   return buf;
 693 }
 694
 695 /* Fill in core_ops with its defined operations and properties.  */
 696
 697 static void
 698 init_core_ops (void)
 699 {
 700   core_ops.to_shortname = "core";
 701   core_ops.to_longname = "Local core dump file";
 702   core_ops.to_doc =
 703     "Use a core file as a target.  Specify the filename of the core file.";
 704   core_ops.to_open = core_open;
 705   core_ops.to_close = core_close;
 706   core_ops.to_attach = find_default_attach;
 707   core_ops.to_detach = core_detach;
 708   core_ops.to_fetch_registers = get_core_registers;
 709   core_ops.to_xfer_partial = core_xfer_partial;
 710   core_ops.deprecated_xfer_memory = xfer_memory;
 711   core_ops.to_files_info = core_files_info;
 712   core_ops.to_insert_breakpoint = ignore;
 713   core_ops.to_remove_breakpoint = ignore;
 714   core_ops.to_create_inferior = find_default_create_inferior;
 715   core_ops.to_thread_alive = core_file_thread_alive;
 716   core_ops.to_read_description = core_read_description;
 717   core_ops.to_pid_to_str = core_pid_to_str;
 718   core_ops.to_stratum = core_stratum;
 719   core_ops.to_has_memory = 1;
 720   core_ops.to_has_stack = 1;
 721   core_ops.to_has_registers = 1;
 722   core_ops.to_magic = OPS_MAGIC;
 723 }
 724
 725 /* non-zero if we should not do the add_target call in
 726    _initialize_corelow; not initialized (i.e., bss) so that
 727    the target can initialize it (i.e., data) if appropriate.
 728    This needs to be set at compile time because we don't know
 729    for sure whether the target's initialize routine is called
 730    before us or after us. */
 731 int coreops_suppress_target;
 732
 733 void
 734 _initialize_corelow (void)
 735 {
 736   init_core_ops ();
 737
 738   if (!coreops_suppress_target)
 739     add_target (&core_ops);
 740 }