gdb/solib-irix.c

   1 /* Shared library support for IRIX.
   2    Copyright (C) 1993-2014 Free Software Foundation, Inc.
   3
   4    This file was created using portions of irix5-nat.c originally
   5    contributed to GDB by Ian Lance Taylor.
   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
  24 #include "symtab.h"
  25 #include "bfd.h"
  26 /* FIXME: ezannoni/2004-02-13 Verify that the include below is
  27    really needed.  */
  28 #include "symfile.h"
  29 #include "objfiles.h"
  30 #include "gdbcore.h"
  31 #include "target.h"
  32 #include "inferior.h"
  33 #include "infrun.h"
  34 #include "gdbthread.h"
  35
  36 #include "solist.h"
  37 #include "solib.h"
  38 #include "solib-irix.h"
  39
  40
  41 /* Link map info to include in an allocate so_list entry.  Unlike some
  42    of the other solib backends, this (Irix) backend chooses to decode
  43    the link map info obtained from the target and store it as (mostly)
  44    CORE_ADDRs which need no further decoding.  This is more convenient
  45    because there are three different link map formats to worry about.
  46    We use a single routine (fetch_lm_info) to read (and decode) the target
  47    specific link map data.  */
  48
  49 struct lm_info
  50 {
  51   CORE_ADDR addr;               /* address of obj_info or obj_list
  52                                    struct on target (from which the
  53                                    following information is obtained).  */
  54   CORE_ADDR next;               /* address of next item in list.  */
  55   CORE_ADDR reloc_offset;       /* amount to relocate by  */
  56   CORE_ADDR pathname_addr;      /* address of pathname  */
  57   int pathname_len;             /* length of pathname */
  58 };
  59
  60 /* It's not desirable to use the system header files to obtain the
  61    structure of the obj_list or obj_info structs.  Therefore, we use a
  62    platform neutral representation which has been derived from the IRIX
  63    header files.  */
  64
  65 typedef struct
  66 {
  67   gdb_byte b[4];
  68 }
  69 gdb_int32_bytes;
  70 typedef struct
  71 {
  72   gdb_byte b[8];
  73 }
  74 gdb_int64_bytes;
  75
  76 /* The "old" obj_list struct.  This is used with old (o32) binaries.
  77    The ``data'' member points at a much larger and more complicated
  78    struct which we will only refer to by offsets.  See
  79    fetch_lm_info().  */
  80
  81 struct irix_obj_list
  82 {
  83   gdb_int32_bytes data;
  84   gdb_int32_bytes next;
  85   gdb_int32_bytes prev;
  86 };
  87
  88 /* The ELF32 and ELF64 versions of the above struct.  The oi_magic value
  89    corresponds to the ``data'' value in the "old" struct.  When this value
  90    is 0xffffffff, the data will be in one of the following formats.  The
  91    ``oi_size'' field is used to decide which one we actually have.  */
  92
  93 struct irix_elf32_obj_info
  94 {
  95   gdb_int32_bytes oi_magic;
  96   gdb_int32_bytes oi_size;
  97   gdb_int32_bytes oi_next;
  98   gdb_int32_bytes oi_prev;
  99   gdb_int32_bytes oi_ehdr;
 100   gdb_int32_bytes oi_orig_ehdr;
 101   gdb_int32_bytes oi_pathname;
 102   gdb_int32_bytes oi_pathname_len;
 103 };
 104
 105 struct irix_elf64_obj_info
 106 {
 107   gdb_int32_bytes oi_magic;
 108   gdb_int32_bytes oi_size;
 109   gdb_int64_bytes oi_next;
 110   gdb_int64_bytes oi_prev;
 111   gdb_int64_bytes oi_ehdr;
 112   gdb_int64_bytes oi_orig_ehdr;
 113   gdb_int64_bytes oi_pathname;
 114   gdb_int32_bytes oi_pathname_len;
 115   gdb_int32_bytes padding;
 116 };
 117
 118 /* Union of all of the above (plus a split out magic field).  */
 119
 120 union irix_obj_info
 121 {
 122   gdb_int32_bytes magic;
 123   struct irix_obj_list ol32;
 124   struct irix_elf32_obj_info oi32;
 125   struct irix_elf64_obj_info oi64;
 126 };
 127
 128 /* MIPS sign extends its 32 bit addresses.  We could conceivably use
 129    extract_typed_address here, but to do so, we'd have to construct an
 130    appropriate type.  Calling extract_signed_integer seems simpler.  */
 131
 132 static CORE_ADDR
 133 extract_mips_address (void *addr, int len, enum bfd_endian byte_order)
 134 {
 135   return extract_signed_integer (addr, len, byte_order);
 136 }
 137
 138 /* Fetch and return the link map data associated with ADDR.  Note that
 139    this routine automatically determines which (of three) link map
 140    formats is in use by the target.  */
 141
 142 static struct lm_info
 143 fetch_lm_info (CORE_ADDR addr)
 144 {
 145   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 146   struct lm_info li;
 147   union irix_obj_info buf;
 148
 149   li.addr = addr;
 150
 151   /* The smallest region that we'll need is for buf.ol32.  We'll read
 152      that first.  We'll read more of the buffer later if we have to deal
 153      with one of the other cases.  (We don't want to incur a memory error
 154      if we were to read a larger region that generates an error due to
 155      being at the end of a page or the like.)  */
 156   read_memory (addr, (gdb_byte *) &buf, sizeof (buf.ol32));
 157
 158   if (extract_unsigned_integer (buf.magic.b, sizeof (buf.magic), byte_order)
 159       != 0xffffffff)
 160     {
 161       /* Use buf.ol32...  */
 162       gdb_byte obj_buf[432];
 163       CORE_ADDR obj_addr = extract_mips_address (&buf.ol32.data,
 164                                                  sizeof (buf.ol32.data),
 165                                                  byte_order);
 166
 167       li.next = extract_mips_address (&buf.ol32.next,
 168                                       sizeof (buf.ol32.next), byte_order);
 169
 170       read_memory (obj_addr, obj_buf, sizeof (obj_buf));
 171
 172       li.pathname_addr = extract_mips_address (&obj_buf[236], 4, byte_order);
 173       li.pathname_len = 0;      /* unknown */
 174       li.reloc_offset = extract_mips_address (&obj_buf[196], 4, byte_order)
 175         - extract_mips_address (&obj_buf[248], 4, byte_order);
 176
 177     }
 178   else if (extract_unsigned_integer (buf.oi32.oi_size.b,
 179                                      sizeof (buf.oi32.oi_size), byte_order)
 180            == sizeof (buf.oi32))
 181     {
 182       /* Use buf.oi32...  */
 183
 184       /* Read rest of buffer.  */
 185       read_memory (addr + sizeof (buf.ol32),
 186                    ((gdb_byte *) &buf) + sizeof (buf.ol32),
 187                    sizeof (buf.oi32) - sizeof (buf.ol32));
 188
 189       /* Fill in fields using buffer contents.  */
 190       li.next = extract_mips_address (&buf.oi32.oi_next,
 191                                       sizeof (buf.oi32.oi_next), byte_order);
 192       li.reloc_offset = extract_mips_address (&buf.oi32.oi_ehdr,
 193                                               sizeof (buf.oi32.oi_ehdr),
 194                                               byte_order)
 195         - extract_mips_address (&buf.oi32.oi_orig_ehdr,
 196                                 sizeof (buf.oi32.oi_orig_ehdr), byte_order);
 197       li.pathname_addr = extract_mips_address (&buf.oi32.oi_pathname,
 198                                                sizeof (buf.oi32.oi_pathname),
 199                                                byte_order);
 200       li.pathname_len = extract_unsigned_integer (buf.oi32.oi_pathname_len.b,
 201                                                   sizeof (buf.oi32.
 202                                                           oi_pathname_len),
 203                                                   byte_order);
 204     }
 205   else if (extract_unsigned_integer (buf.oi64.oi_size.b,
 206                                      sizeof (buf.oi64.oi_size), byte_order)
 207            == sizeof (buf.oi64))
 208     {
 209       /* Use buf.oi64...  */
 210
 211       /* Read rest of buffer.  */
 212       read_memory (addr + sizeof (buf.ol32),
 213                    ((gdb_byte *) &buf) + sizeof (buf.ol32),
 214                    sizeof (buf.oi64) - sizeof (buf.ol32));
 215
 216       /* Fill in fields using buffer contents.  */
 217       li.next = extract_mips_address (&buf.oi64.oi_next,
 218                                       sizeof (buf.oi64.oi_next), byte_order);
 219       li.reloc_offset = extract_mips_address (&buf.oi64.oi_ehdr,
 220                                               sizeof (buf.oi64.oi_ehdr),
 221                                               byte_order)
 222         - extract_mips_address (&buf.oi64.oi_orig_ehdr,
 223                                 sizeof (buf.oi64.oi_orig_ehdr), byte_order);
 224       li.pathname_addr = extract_mips_address (&buf.oi64.oi_pathname,
 225                                                sizeof (buf.oi64.oi_pathname),
 226                                                byte_order);
 227       li.pathname_len = extract_unsigned_integer (buf.oi64.oi_pathname_len.b,
 228                                                   sizeof (buf.oi64.
 229                                                           oi_pathname_len),
 230                                                   byte_order);
 231     }
 232   else
 233     {
 234       error (_("Unable to fetch shared library obj_info or obj_list info."));
 235     }
 236
 237   return li;
 238 }
 239
 240 /* The symbol which starts off the list of shared libraries.  */
 241 #define DEBUG_BASE "__rld_obj_head"
 242
 243 static void *base_breakpoint;
 244
 245 static CORE_ADDR debug_base;    /* Base of dynamic linker structures.  */
 246
 247 /* Locate the base address of dynamic linker structs.
 248
 249    For both the SunOS and SVR4 shared library implementations, if the
 250    inferior executable has been linked dynamically, there is a single
 251    address somewhere in the inferior's data space which is the key to
 252    locating all of the dynamic linker's runtime structures.  This
 253    address is the value of the symbol defined by the macro DEBUG_BASE.
 254    The job of this function is to find and return that address, or to
 255    return 0 if there is no such address (the executable is statically
 256    linked for example).
 257
 258    For SunOS, the job is almost trivial, since the dynamic linker and
 259    all of it's structures are statically linked to the executable at
 260    link time.  Thus the symbol for the address we are looking for has
 261    already been added to the minimal symbol table for the executable's
 262    objfile at the time the symbol file's symbols were read, and all we
 263    have to do is look it up there.  Note that we explicitly do NOT want
 264    to find the copies in the shared library.
 265
 266    The SVR4 version is much more complicated because the dynamic linker
 267    and it's structures are located in the shared C library, which gets
 268    run as the executable's "interpreter" by the kernel.  We have to go
 269    to a lot more work to discover the address of DEBUG_BASE.  Because
 270    of this complexity, we cache the value we find and return that value
 271    on subsequent invocations.  Note there is no copy in the executable
 272    symbol tables.
 273
 274    Irix 5 is basically like SunOS.
 275
 276    Note that we can assume nothing about the process state at the time
 277    we need to find this address.  We may be stopped on the first instruc-
 278    tion of the interpreter (C shared library), the first instruction of
 279    the executable itself, or somewhere else entirely (if we attached
 280    to the process for example).  */
 281
 282 static CORE_ADDR
 283 locate_base (void)
 284 {
 285   struct bound_minimal_symbol msymbol;
 286   CORE_ADDR address = 0;
 287
 288   msymbol = lookup_minimal_symbol (DEBUG_BASE, NULL, symfile_objfile);
 289   if ((msymbol.minsym != NULL) && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0))
 290     {
 291       address = BMSYMBOL_VALUE_ADDRESS (msymbol);
 292     }
 293   return (address);
 294 }
 295
 296 /* Remove the "mapping changed" breakpoint.
 297
 298    Removes the breakpoint that gets hit when the dynamic linker
 299    completes a mapping change.  */
 300
 301 static int
 302 disable_break (void)
 303 {
 304   int status = 1;
 305
 306   /* Note that breakpoint address and original contents are in our address
 307      space, so we just need to write the original contents back.  */
 308
 309   if (deprecated_remove_raw_breakpoint (target_gdbarch (), base_breakpoint) != 0)
 310     {
 311       status = 0;
 312     }
 313
 314   base_breakpoint = NULL;
 315
 316   /* Note that it is possible that we have stopped at a location that
 317      is different from the location where we inserted our breakpoint.
 318      On mips-irix, we can actually land in __dbx_init(), so we should
 319      not check the PC against our breakpoint address here.  See procfs.c
 320      for more details.  */
 321
 322   return (status);
 323 }
 324
 325 /* Arrange for dynamic linker to hit breakpoint.
 326
 327    This functions inserts a breakpoint at the entry point of the
 328    main executable, where all shared libraries are mapped in.  */
 329
 330 static int
 331 enable_break (void)
 332 {
 333   if (symfile_objfile != NULL && has_stack_frames ())
 334     {
 335       struct frame_info *frame = get_current_frame ();
 336       struct address_space *aspace = get_frame_address_space (frame);
 337       CORE_ADDR entry_point;
 338
 339       if (!entry_point_address_query (&entry_point))
 340         return 0;
 341
 342       base_breakpoint = deprecated_insert_raw_breakpoint (target_gdbarch (),
 343                                                           aspace, entry_point);
 344
 345       if (base_breakpoint != NULL)
 346         return 1;
 347     }
 348
 349   return 0;
 350 }
 351
 352 /* Implement the "create_inferior_hook" target_solib_ops method.
 353
 354    For SunOS executables, this first instruction is typically the
 355    one at "_start", or a similar text label, regardless of whether
 356    the executable is statically or dynamically linked.  The runtime
 357    startup code takes care of dynamically linking in any shared
 358    libraries, once gdb allows the inferior to continue.
 359
 360    For SVR4 executables, this first instruction is either the first
 361    instruction in the dynamic linker (for dynamically linked
 362    executables) or the instruction at "start" for statically linked
 363    executables.  For dynamically linked executables, the system
 364    first exec's /lib/libc.so.N, which contains the dynamic linker,
 365    and starts it running.  The dynamic linker maps in any needed
 366    shared libraries, maps in the actual user executable, and then
 367    jumps to "start" in the user executable.
 368
 369    For both SunOS shared libraries, and SVR4 shared libraries, we
 370    can arrange to cooperate with the dynamic linker to discover the
 371    names of shared libraries that are dynamically linked, and the
 372    base addresses to which they are linked.
 373
 374    This function is responsible for discovering those names and
 375    addresses, and saving sufficient information about them to allow
 376    their symbols to be read at a later time.
 377
 378    FIXME
 379
 380    Between enable_break() and disable_break(), this code does not
 381    properly handle hitting breakpoints which the user might have
 382    set in the startup code or in the dynamic linker itself.  Proper
 383    handling will probably have to wait until the implementation is
 384    changed to use the "breakpoint handler function" method.
 385
 386    Also, what if child has exit()ed?  Must exit loop somehow.  */
 387
 388 static void
 389 irix_solib_create_inferior_hook (int from_tty)
 390 {
 391   struct inferior *inf;
 392   struct thread_info *tp;
 393
 394   inf = current_inferior ();
 395
 396   /* If we are attaching to the inferior, the shared libraries
 397      have already been mapped, so nothing more to do.  */
 398   if (inf->attach_flag)
 399     return;
 400
 401   /* Likewise when debugging from a core file, the shared libraries
 402      have already been mapped, so nothing more to do.  */
 403   if (!target_can_run (&current_target))
 404     return;
 405
 406   if (!enable_break ())
 407     {
 408       warning (_("shared library handler failed to enable breakpoint"));
 409       return;
 410     }
 411
 412   /* Now run the target.  It will eventually hit the breakpoint, at
 413      which point all of the libraries will have been mapped in and we
 414      can go groveling around in the dynamic linker structures to find
 415      out what we need to know about them.  */
 416
 417   tp = inferior_thread ();
 418
 419   clear_proceed_status ();
 420
 421   inf->control.stop_soon = STOP_QUIETLY;
 422   tp->suspend.stop_signal = GDB_SIGNAL_0;
 423
 424   do
 425     {
 426       target_resume (pid_to_ptid (-1), 0, tp->suspend.stop_signal);
 427       wait_for_inferior ();
 428     }
 429   while (tp->suspend.stop_signal != GDB_SIGNAL_TRAP);
 430
 431   /* We are now either at the "mapping complete" breakpoint (or somewhere
 432      else, a condition we aren't prepared to deal with anyway), so adjust
 433      the PC as necessary after a breakpoint, disable the breakpoint, and
 434      add any shared libraries that were mapped in.  */
 435
 436   if (!disable_break ())
 437     {
 438       warning (_("shared library handler failed to disable breakpoint"));
 439     }
 440
 441   /* solib_add will call reinit_frame_cache.
 442      But we are stopped in the startup code and we might not have symbols
 443      for the startup code, so heuristic_proc_start could be called
 444      and will put out an annoying warning.
 445      Delaying the resetting of stop_soon until after symbol loading
 446      suppresses the warning.  */
 447   solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add);
 448   inf->control.stop_soon = NO_STOP_QUIETLY;
 449 }
 450
 451 /* Implement the "current_sos" target_so_ops method.  */
 452
 453 static struct so_list *
 454 irix_current_sos (void)
 455 {
 456   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 457   int addr_size = gdbarch_addr_bit (target_gdbarch ()) / TARGET_CHAR_BIT;
 458   CORE_ADDR lma;
 459   gdb_byte addr_buf[8];
 460   struct so_list *head = 0;
 461   struct so_list **link_ptr = &head;
 462   int is_first = 1;
 463   struct lm_info lm;
 464
 465   /* Make sure we've looked up the inferior's dynamic linker's base
 466      structure.  */
 467   if (!debug_base)
 468     {
 469       debug_base = locate_base ();
 470
 471       /* If we can't find the dynamic linker's base structure, this
 472          must not be a dynamically linked executable.  Hmm.  */
 473       if (!debug_base)
 474         return 0;
 475     }
 476
 477   read_memory (debug_base, addr_buf, addr_size);
 478   lma = extract_mips_address (addr_buf, addr_size, byte_order);
 479
 480   while (lma)
 481     {
 482       lm = fetch_lm_info (lma);
 483       if (!is_first)
 484         {
 485           int errcode;
 486           char *name_buf;
 487           int name_size;
 488           struct so_list *new
 489             = (struct so_list *) xmalloc (sizeof (struct so_list));
 490           struct cleanup *old_chain = make_cleanup (xfree, new);
 491
 492           memset (new, 0, sizeof (*new));
 493
 494           new->lm_info = xmalloc (sizeof (struct lm_info));
 495           make_cleanup (xfree, new->lm_info);
 496
 497           *new->lm_info = lm;
 498
 499           /* Extract this shared object's name.  */
 500           name_size = lm.pathname_len;
 501           if (name_size == 0)
 502             name_size = SO_NAME_MAX_PATH_SIZE - 1;
 503
 504           if (name_size >= SO_NAME_MAX_PATH_SIZE)
 505             {
 506               name_size = SO_NAME_MAX_PATH_SIZE - 1;
 507               warning (_("current_sos: truncating name of "
 508                          "%d characters to only %d characters"),
 509                        lm.pathname_len, name_size);
 510             }
 511
 512           target_read_string (lm.pathname_addr, &name_buf,
 513                               name_size, &errcode);
 514           if (errcode != 0)
 515             warning (_("Can't read pathname for load map: %s."),
 516                        safe_strerror (errcode));
 517           else
 518             {
 519               strncpy (new->so_name, name_buf, name_size);
 520               new->so_name[name_size] = '\0';
 521               xfree (name_buf);
 522               strcpy (new->so_original_name, new->so_name);
 523             }
 524
 525           new->next = 0;
 526           *link_ptr = new;
 527           link_ptr = &new->next;
 528
 529           discard_cleanups (old_chain);
 530         }
 531       is_first = 0;
 532       lma = lm.next;
 533     }
 534
 535   return head;
 536 }
 537
 538 /* Implement the "open_symbol_file_object" target_so_ops method.
 539
 540    If no open symbol file, attempt to locate and open the main symbol
 541    file.  On IRIX, this is the first link map entry.  If its name is
 542    here, we can open it.  Useful when attaching to a process without
 543    first loading its symbol file.  */
 544
 545 static int
 546 irix_open_symbol_file_object (void *from_ttyp)
 547 {
 548   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 549   int addr_size = gdbarch_addr_bit (target_gdbarch ()) / TARGET_CHAR_BIT;
 550   CORE_ADDR lma;
 551   gdb_byte addr_buf[8];
 552   struct lm_info lm;
 553   struct cleanup *cleanups;
 554   int errcode;
 555   int from_tty = *(int *) from_ttyp;
 556   char *filename;
 557
 558   if (symfile_objfile)
 559     if (!query (_("Attempt to reload symbols from process? ")))
 560       return 0;
 561
 562   if ((debug_base = locate_base ()) == 0)
 563     return 0;                   /* failed somehow...  */
 564
 565   /* First link map member should be the executable.  */
 566   read_memory (debug_base, addr_buf, addr_size);
 567   lma = extract_mips_address (addr_buf, addr_size, byte_order);
 568   if (lma == 0)
 569     return 0;                   /* failed somehow...  */
 570
 571   lm = fetch_lm_info (lma);
 572
 573   if (lm.pathname_addr == 0)
 574     return 0;                   /* No filename.  */
 575
 576   /* Now fetch the filename from target memory.  */
 577   target_read_string (lm.pathname_addr, &filename, SO_NAME_MAX_PATH_SIZE - 1,
 578                       &errcode);
 579
 580   if (errcode)
 581     {
 582       warning (_("failed to read exec filename from attached file: %s"),
 583                safe_strerror (errcode));
 584       return 0;
 585     }
 586
 587   cleanups = make_cleanup (xfree, filename);
 588   /* Have a pathname: read the symbol file.  */
 589   symbol_file_add_main (filename, from_tty);
 590
 591   do_cleanups (cleanups);
 592
 593   return 1;
 594 }
 595
 596 /* Implement the "special_symbol_handling" target_so_ops method.
 597
 598    For IRIX, there's nothing to do.  */
 599
 600 static void
 601 irix_special_symbol_handling (void)
 602 {
 603 }
 604
 605 /* Using the solist entry SO, relocate the addresses in SEC.  */
 606
 607 static void
 608 irix_relocate_section_addresses (struct so_list *so,
 609                                  struct target_section *sec)
 610 {
 611   sec->addr += so->lm_info->reloc_offset;
 612   sec->endaddr += so->lm_info->reloc_offset;
 613 }
 614
 615 /* Free the lm_info struct.  */
 616
 617 static void
 618 irix_free_so (struct so_list *so)
 619 {
 620   xfree (so->lm_info);
 621 }
 622
 623 /* Clear backend specific state.  */
 624
 625 static void
 626 irix_clear_solib (void)
 627 {
 628   debug_base = 0;
 629 }
 630
 631 /* Return 1 if PC lies in the dynamic symbol resolution code of the
 632    run time loader.  */
 633 static int
 634 irix_in_dynsym_resolve_code (CORE_ADDR pc)
 635 {
 636   return 0;
 637 }
 638
 639 struct target_so_ops irix_so_ops;
 640
 641 /* Provide a prototype to silence -Wmissing-prototypes.  */
 642 extern initialize_file_ftype _initialize_irix_solib;
 643
 644 void
 645 _initialize_irix_solib (void)
 646 {
 647   irix_so_ops.relocate_section_addresses = irix_relocate_section_addresses;
 648   irix_so_ops.free_so = irix_free_so;
 649   irix_so_ops.clear_solib = irix_clear_solib;
 650   irix_so_ops.solib_create_inferior_hook = irix_solib_create_inferior_hook;
 651   irix_so_ops.special_symbol_handling = irix_special_symbol_handling;
 652   irix_so_ops.current_sos = irix_current_sos;
 653   irix_so_ops.open_symbol_file_object = irix_open_symbol_file_object;
 654   irix_so_ops.in_dynsym_resolve_code = irix_in_dynsym_resolve_code;
 655   irix_so_ops.bfd_open = solib_bfd_open;
 656 }