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