1 /* Handle SOM shared libraries.
3 Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "hppa-tdep.h"
33 #include "solib-som.h"
35 #include <sys/utsname.h>
40 /* These ought to be defined in some public interface, but aren't. They
41 define the meaning of the various bits in the distinguished __dld_flags
42 variable that is declared in every debuggable a.out on HP-UX, and that
43 is shared between the debugger and the dynamic linker.
45 #define DLD_FLAGS_MAPPRIVATE 0x1
46 #define DLD_FLAGS_HOOKVALID 0x2
47 #define DLD_FLAGS_LISTVALID 0x4
48 #define DLD_FLAGS_BOR_ENABLE 0x8
52 /* Version of this structure (it is expected to change again in
54 unsigned char struct_version
;
56 /* Binding mode for this library. */
57 unsigned char bind_mode
;
59 /* Version of this library. */
60 short library_version
;
62 /* Start of text address,
63 link-time text location (length of text area),
64 end of text address. */
66 CORE_ADDR text_link_addr
;
69 /* Start of data, start of bss and end of data. */
74 /* Value of linkage pointer (%r19). */
77 /* Address in target of offset from thread-local register of
78 start of this thread's data. I.e., the first thread-local
79 variable in this shared library starts at *(tsd_start_addr)
80 from that area pointed to by cr27 (mpsfu_hi).
82 We do the indirection as soon as we read it, so from then
83 on it's the offset itself. */
84 CORE_ADDR tsd_start_addr
;
86 /* Address of the link map entry in the loader. */
90 /* These addresses should be filled in by som_solib_create_inferior_hook.
91 They are also used elsewhere in this module.
96 struct unwind_table_entry
*unwind
;
100 /* When adding fields, be sure to clear them in _initialize_som_solib. */
104 addr_and_unwind_t hook
;
105 addr_and_unwind_t hook_stub
;
106 addr_and_unwind_t load
;
107 addr_and_unwind_t load_stub
;
108 addr_and_unwind_t unload
;
109 addr_and_unwind_t unload2
;
110 addr_and_unwind_t unload_stub
;
115 som_relocate_section_addresses (struct so_list
*so
,
116 struct target_section
*sec
)
118 flagword aflag
= bfd_get_section_flags(so
->abfd
, sec
->the_bfd_section
);
120 if (aflag
& SEC_CODE
)
122 sec
->addr
+= so
->lm_info
->text_addr
- so
->lm_info
->text_link_addr
;
123 sec
->endaddr
+= so
->lm_info
->text_addr
- so
->lm_info
->text_link_addr
;
125 else if (aflag
& SEC_DATA
)
127 sec
->addr
+= so
->lm_info
->data_start
;
128 sec
->endaddr
+= so
->lm_info
->data_start
;
134 /* Get HP-UX major release number. Returns zero if the
135 release is not known. */
138 get_hpux_major_release (void)
140 static int hpux_major_release
= -1;
142 if (hpux_major_release
== -1)
148 p
= strchr (x
.release
, '.');
149 hpux_major_release
= p
? atoi (p
+ 1) : 0;
152 return hpux_major_release
;
155 /* DL header flag defines. */
156 #define SHLIB_TEXT_PRIVATE_ENABLE 0x4000
158 /* The DL header is documented in <shl.h>. We are only interested
159 in the flags field to determine whether the executable wants shared
160 libraries mapped private. */
166 /* This hook gets called just before the first instruction in the
167 inferior process is executed.
169 This is our opportunity to set magic flags in the inferior so
170 that GDB can be notified when a shared library is mapped in and
171 to tell the dynamic linker that a private copy of the library is
172 needed (so GDB can set breakpoints in the library).
174 __dld_flags is the location of the magic flags; as of this implementation
175 there are 3 flags of interest:
177 bit 0 when set indicates that private copies of the libraries are needed
178 bit 1 when set indicates that the callback hook routine is valid
179 bit 2 when set indicates that the dynamic linker should maintain the
180 __dld_list structure when loading/unloading libraries.
182 Note that shared libraries are not mapped in at this time, so we have
183 run the inferior until the libraries are mapped in. Typically this
184 means running until the "_start" is called. */
187 som_solib_create_inferior_hook (int from_tty
)
189 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
190 struct minimal_symbol
*msymbol
;
191 unsigned int dld_flags
, status
, have_endo
;
192 asection
*shlib_info
;
196 if (symfile_objfile
== NULL
)
199 /* First see if the objfile was dynamically linked. */
200 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
204 /* It's got a $SHLIB_INFO$ section, make sure it's not empty. */
205 if (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) == 0)
208 /* Read the DL header. */
209 bfd_get_section_contents (symfile_objfile
->obfd
, shlib_info
,
210 (char *) &dl_header
, 0, sizeof (dl_header
));
213 /* Slam the pid of the process into __d_pid.
215 We used to warn when this failed, but that warning is only useful
216 on very old HP systems (hpux9 and older). The warnings are an
217 annoyance to users of modern systems and foul up the testsuite as
218 well. As a result, the warnings have been disabled. */
219 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
223 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
224 store_unsigned_integer (buf
, 4, byte_order
, PIDGET (inferior_ptid
));
225 status
= target_write_memory (anaddr
, buf
, 4);
228 warning (_("Unable to write __d_pid.\n"
229 "Suggest linking with /opt/langtools/lib/end.o.\n"
230 "GDB will be unable to track shl_load/shl_unload calls"));
234 /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
235 This will force the dynamic linker to call __d_trap when significant
238 Note that the above is the pre-HP-UX 9.0 behaviour. At 9.0 and above,
239 the dld provides an export stub named "__d_trap" as well as the
240 function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
241 We'll look first for the old flavor and then the new.
243 msymbol
= lookup_minimal_symbol ("_DLD_HOOK", NULL
, symfile_objfile
);
245 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
248 warning (_("Unable to find _DLD_HOOK symbol in object file.\n"
249 "Suggest linking with /opt/langtools/lib/end.o.\n"
250 "GDB will be unable to track shl_load/shl_unload calls"));
253 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
254 dld_cache
.hook
.address
= anaddr
;
256 /* Grrr, this might not be an export symbol! We have to find the
258 msymbol
= hppa_lookup_stub_minimal_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
262 anaddr
= SYMBOL_VALUE (msymbol
);
263 dld_cache
.hook_stub
.address
= anaddr
;
265 store_unsigned_integer (buf
, 4, byte_order
, anaddr
);
267 msymbol
= lookup_minimal_symbol ("__dld_hook", NULL
, symfile_objfile
);
270 warning (_("Unable to find __dld_hook symbol in object file.\n"
271 "Suggest linking with /opt/langtools/lib/end.o.\n"
272 "GDB will be unable to track shl_load/shl_unload calls"));
275 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
276 status
= target_write_memory (anaddr
, buf
, 4);
278 /* Now set a shlib_event breakpoint at __d_trap so we can track
279 significant shared library events. */
280 msymbol
= lookup_minimal_symbol ("__d_trap", NULL
, symfile_objfile
);
283 warning (_("Unable to find __dld_d_trap symbol in object file.\n"
284 "Suggest linking with /opt/langtools/lib/end.o.\n"
285 "GDB will be unable to track shl_load/shl_unload calls"));
288 create_solib_event_breakpoint (target_gdbarch
,
289 SYMBOL_VALUE_ADDRESS (msymbol
));
291 /* We have all the support usually found in end.o, so we can track
292 shl_load and shl_unload calls. */
297 /* Get the address of __dld_flags, if no such symbol exists, then we can
298 not debug the shared code. */
299 msymbol
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
302 error (_("Unable to find __dld_flags symbol in object file."));
305 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
307 /* Read the current contents. */
308 status
= target_read_memory (anaddr
, buf
, 4);
310 error (_("Unable to read __dld_flags."));
311 dld_flags
= extract_unsigned_integer (buf
, 4, byte_order
);
313 /* If the libraries were not mapped private on HP-UX 11 and later, warn
314 the user. On HP-UX 10 and earlier, there is no easy way to specify
315 that shared libraries should be privately mapped. So, we just force
317 if (get_hpux_major_release () >= 11
318 && (dl_header
.flags
& SHLIB_TEXT_PRIVATE_ENABLE
) == 0
319 && (dld_flags
& DLD_FLAGS_MAPPRIVATE
) == 0)
321 (_("Private mapping of shared library text was not specified\n"
322 "by the executable; setting a breakpoint in a shared library which\n"
323 "is not privately mapped will not work. See the HP-UX 11i v3 chatr\n"
324 "manpage for methods to privately map shared library text."));
326 /* Turn on the flags we care about. */
327 if (get_hpux_major_release () < 11)
328 dld_flags
|= DLD_FLAGS_MAPPRIVATE
;
330 dld_flags
|= DLD_FLAGS_HOOKVALID
;
331 store_unsigned_integer (buf
, 4, byte_order
, dld_flags
);
332 status
= target_write_memory (anaddr
, buf
, 4);
334 error (_("Unable to write __dld_flags."));
336 /* Now find the address of _start and set a breakpoint there.
337 We still need this code for two reasons:
339 * Not all sites have /opt/langtools/lib/end.o, so it's not always
340 possible to track the dynamic linker's events.
342 * At this time no events are triggered for shared libraries
343 loaded at startup time (what a crock). */
345 msymbol
= lookup_minimal_symbol ("_start", NULL
, symfile_objfile
);
347 error (_("Unable to find _start symbol in object file."));
349 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
351 /* Make the breakpoint at "_start" a shared library event breakpoint. */
352 create_solib_event_breakpoint (target_gdbarch
, anaddr
);
354 clear_symtab_users (0);
358 som_special_symbol_handling (void)
363 som_solib_desire_dynamic_linker_symbols (void)
365 struct objfile
*objfile
;
366 struct unwind_table_entry
*u
;
367 struct minimal_symbol
*dld_msymbol
;
369 /* Do we already know the value of these symbols? If so, then
372 (If you add clauses to this test, be sure to likewise update the
373 test within the loop.)
375 if (dld_cache
.is_valid
)
378 ALL_OBJFILES (objfile
)
380 dld_msymbol
= lookup_minimal_symbol ("shl_load", NULL
, objfile
);
381 if (dld_msymbol
!= NULL
)
383 dld_cache
.load
.address
= SYMBOL_VALUE (dld_msymbol
);
384 dld_cache
.load
.unwind
= find_unwind_entry (dld_cache
.load
.address
);
387 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_load",
389 if (dld_msymbol
!= NULL
)
391 if (MSYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
393 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
394 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
396 dld_cache
.load_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
397 dld_cache
.load_stub
.unwind
= u
;
402 dld_msymbol
= lookup_minimal_symbol ("shl_unload", NULL
, objfile
);
403 if (dld_msymbol
!= NULL
)
405 dld_cache
.unload
.address
= SYMBOL_VALUE (dld_msymbol
);
406 dld_cache
.unload
.unwind
= find_unwind_entry (dld_cache
.unload
.address
);
408 /* ??rehrauer: I'm not sure exactly what this is, but it appears
409 that on some HPUX 10.x versions, there's two unwind regions to
410 cover the body of "shl_unload", the second being 4 bytes past
411 the end of the first. This is a large hack to handle that
412 case, but since I don't seem to have any legitimate way to
413 look for this thing via the symbol table...
415 if (dld_cache
.unload
.unwind
!= NULL
)
417 u
= find_unwind_entry (dld_cache
.unload
.unwind
->region_end
+ 4);
420 dld_cache
.unload2
.address
= u
->region_start
;
421 dld_cache
.unload2
.unwind
= u
;
426 dld_msymbol
= lookup_minimal_symbol_solib_trampoline ("shl_unload",
428 if (dld_msymbol
!= NULL
)
430 if (MSYMBOL_TYPE (dld_msymbol
) == mst_solib_trampoline
)
432 u
= find_unwind_entry (SYMBOL_VALUE (dld_msymbol
));
433 if ((u
!= NULL
) && (u
->stub_unwind
.stub_type
== EXPORT
))
435 dld_cache
.unload_stub
.address
= SYMBOL_VALUE (dld_msymbol
);
436 dld_cache
.unload_stub
.unwind
= u
;
441 /* Did we find everything we were looking for? If so, stop. */
442 if ((dld_cache
.load
.address
!= 0)
443 && (dld_cache
.load_stub
.address
!= 0)
444 && (dld_cache
.unload
.address
!= 0)
445 && (dld_cache
.unload_stub
.address
!= 0))
447 dld_cache
.is_valid
= 1;
452 dld_cache
.hook
.unwind
= find_unwind_entry (dld_cache
.hook
.address
);
453 dld_cache
.hook_stub
.unwind
= find_unwind_entry (dld_cache
.hook_stub
.address
);
455 /* We're prepared not to find some of these symbols, which is why
456 this function is a "desire" operation, and not a "require".
461 som_in_dynsym_resolve_code (CORE_ADDR pc
)
463 struct unwind_table_entry
*u_pc
;
465 /* Are we in the dld itself?
467 ??rehrauer: Large hack -- We'll assume that any address in a
468 shared text region is the dld's text. This would obviously
469 fall down if the user attached to a process, whose shlibs
470 weren't mapped to a (writeable) private region. However, in
471 that case the debugger probably isn't able to set the fundamental
472 breakpoint in the dld callback anyways, so this hack should be
475 if ((pc
& (CORE_ADDR
) 0xc0000000) == (CORE_ADDR
) 0xc0000000)
478 /* Cache the address of some symbols that are part of the dynamic
479 linker, if not already known.
481 som_solib_desire_dynamic_linker_symbols ();
483 /* Are we in the dld callback? Or its export stub? */
484 u_pc
= find_unwind_entry (pc
);
488 if ((u_pc
== dld_cache
.hook
.unwind
) || (u_pc
== dld_cache
.hook_stub
.unwind
))
491 /* Or the interface of the dld (i.e., "shl_load" or friends)? */
492 if ((u_pc
== dld_cache
.load
.unwind
)
493 || (u_pc
== dld_cache
.unload
.unwind
)
494 || (u_pc
== dld_cache
.unload2
.unwind
)
495 || (u_pc
== dld_cache
.load_stub
.unwind
)
496 || (u_pc
== dld_cache
.unload_stub
.unwind
))
499 /* Apparently this address isn't part of the dld's text. */
504 som_clear_solib (void)
512 char text_link_addr
[4];
519 char tsd_start_addr_ptr
[4];
523 link_map_start (void)
525 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
526 struct minimal_symbol
*sym
;
529 unsigned int dld_flags
;
531 sym
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
533 error (_("Unable to find __dld_flags symbol in object file."));
534 addr
= SYMBOL_VALUE_ADDRESS (sym
);
535 read_memory (addr
, buf
, 4);
536 dld_flags
= extract_unsigned_integer (buf
, 4, byte_order
);
537 if ((dld_flags
& DLD_FLAGS_LISTVALID
) == 0)
538 error (_("__dld_list is not valid according to __dld_flags."));
540 sym
= lookup_minimal_symbol ("__dld_list", NULL
, NULL
);
543 /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
544 but the data is still available if you know where to look. */
545 sym
= lookup_minimal_symbol ("__dld_flags", NULL
, NULL
);
548 error (_("Unable to find dynamic library list."));
551 addr
= SYMBOL_VALUE_ADDRESS (sym
) - 8;
554 addr
= SYMBOL_VALUE_ADDRESS (sym
);
556 read_memory (addr
, buf
, 4);
557 addr
= extract_unsigned_integer (buf
, 4, byte_order
);
561 read_memory (addr
, buf
, 4);
562 return extract_unsigned_integer (buf
, 4, byte_order
);
565 /* Does this so's name match the main binary? */
567 match_main (const char *name
)
569 return strcmp (name
, symfile_objfile
->name
) == 0;
572 static struct so_list
*
573 som_current_sos (void)
575 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
577 struct so_list
*head
= 0;
578 struct so_list
**link_ptr
= &head
;
580 for (lm
= link_map_start (); lm
; )
585 struct cleanup
*old_chain
;
587 struct dld_list dbuf
;
590 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
591 old_chain
= make_cleanup (xfree
, new);
593 memset (new, 0, sizeof (*new));
594 new->lm_info
= xmalloc (sizeof (struct lm_info
));
595 make_cleanup (xfree
, new->lm_info
);
597 read_memory (lm
, (gdb_byte
*)&dbuf
, sizeof (struct dld_list
));
599 addr
= extract_unsigned_integer ((gdb_byte
*)&dbuf
.name
,
600 sizeof (dbuf
.name
), byte_order
);
601 target_read_string (addr
, &namebuf
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
603 warning (_("Can't read pathname for load map: %s."),
604 safe_strerror (errcode
));
607 strncpy (new->so_name
, namebuf
, SO_NAME_MAX_PATH_SIZE
- 1);
608 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
610 strcpy (new->so_original_name
, new->so_name
);
613 if (new->so_name
[0] && !match_main (new->so_name
))
615 struct lm_info
*lmi
= new->lm_info
;
620 #define EXTRACT(_fld) \
621 extract_unsigned_integer ((gdb_byte *)&dbuf._fld, \
622 sizeof (dbuf._fld), byte_order);
624 lmi
->text_addr
= EXTRACT (text_addr
);
625 tmp
= EXTRACT (info
);
626 lmi
->library_version
= (tmp
>> 16) & 0xffff;
627 lmi
->bind_mode
= (tmp
>> 8) & 0xff;
628 lmi
->struct_version
= tmp
& 0xff;
629 lmi
->text_link_addr
= EXTRACT (text_link_addr
);
630 lmi
->text_end
= EXTRACT (text_end
);
631 lmi
->data_start
= EXTRACT (data_start
);
632 lmi
->bss_start
= EXTRACT (bss_start
);
633 lmi
->data_end
= EXTRACT (data_end
);
634 lmi
->got_value
= EXTRACT (got_value
);
635 tmp
= EXTRACT (tsd_start_addr_ptr
);
636 read_memory (tmp
, tsdbuf
, 4);
638 = extract_unsigned_integer (tsdbuf
, 4, byte_order
);
641 printf ("\n+ library \"%s\" is described at %s\n", new->so_name
,
642 paddress (target_gdbarch
, lm
));
643 printf (" 'version' is %d\n", new->lm_info
->struct_version
);
644 printf (" 'bind_mode' is %d\n", new->lm_info
->bind_mode
);
645 printf (" 'library_version' is %d\n",
646 new->lm_info
->library_version
);
647 printf (" 'text_addr' is %s\n",
648 paddress (target_gdbarch
, new->lm_info
->text_addr
));
649 printf (" 'text_link_addr' is %s\n",
650 paddress (target_gdbarch
, new->lm_info
->text_link_addr
));
651 printf (" 'text_end' is %s\n",
652 paddress (target_gdbarch
, new->lm_info
->text_end
));
653 printf (" 'data_start' is %s\n",
654 paddress (target_gdbarch
, new->lm_info
->data_start
));
655 printf (" 'bss_start' is %s\n",
656 paddress (target_gdbarch
, new->lm_info
->bss_start
));
657 printf (" 'data_end' is %s\n",
658 paddress (target_gdbarch
, new->lm_info
->data_end
));
659 printf (" 'got_value' is %s\n",
660 paddress (target_gdbarch
, new->lm_info
->got_value
));
661 printf (" 'tsd_start_addr' is %s\n",
662 paddress (target_gdbarch
, new->lm_info
->tsd_start_addr
));
665 new->addr_low
= lmi
->text_addr
;
666 new->addr_high
= lmi
->text_end
;
668 /* Link the new object onto the list. */
671 link_ptr
= &new->next
;
679 discard_cleanups (old_chain
);
683 /* TODO: The original somsolib code has logic to detect and eliminate
684 duplicate entries. Do we need that? */
690 som_open_symbol_file_object (void *from_ttyp
)
692 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
693 CORE_ADDR lm
, l_name
;
696 int from_tty
= *(int *)from_ttyp
;
700 if (!query (_("Attempt to reload symbols from process? ")))
703 /* First link map member should be the executable. */
704 if ((lm
= link_map_start ()) == 0)
705 return 0; /* failed somehow... */
707 /* Read address of name from target memory to GDB. */
708 read_memory (lm
+ offsetof (struct dld_list
, name
), buf
, 4);
710 /* Convert the address to host format. Assume that the address is
712 l_name
= extract_unsigned_integer (buf
, 4, byte_order
);
715 return 0; /* No filename. */
717 /* Now fetch the filename from target memory. */
718 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
722 warning (_("failed to read exec filename from attached file: %s"),
723 safe_strerror (errcode
));
727 make_cleanup (xfree
, filename
);
728 /* Have a pathname: read the symbol file. */
729 symbol_file_add_main (filename
, from_tty
);
735 som_free_so (struct so_list
*so
)
741 som_solib_thread_start_addr (struct so_list
*so
)
743 return so
->lm_info
->tsd_start_addr
;
746 /* Return the GOT value for the shared library in which ADDR belongs. If
747 ADDR isn't in any known shared library, return zero. */
750 som_solib_get_got_by_pc (CORE_ADDR addr
)
752 struct so_list
*so_list
= master_so_list ();
753 CORE_ADDR got_value
= 0;
757 if (so_list
->lm_info
->text_addr
<= addr
758 && so_list
->lm_info
->text_end
> addr
)
760 got_value
= so_list
->lm_info
->got_value
;
763 so_list
= so_list
->next
;
768 /* Return the address of the handle of the shared library in which
769 ADDR belongs. If ADDR isn't in any known shared library, return
771 /* this function is used in initialize_hp_cxx_exception_support in
775 som_solib_get_solib_by_pc (CORE_ADDR addr
)
777 struct so_list
*so_list
= master_so_list ();
781 if (so_list
->lm_info
->text_addr
<= addr
782 && so_list
->lm_info
->text_end
> addr
)
786 so_list
= so_list
->next
;
789 return so_list
->lm_info
->lm_addr
;
795 static struct target_so_ops som_so_ops
;
797 extern initialize_file_ftype _initialize_som_solib
; /* -Wmissing-prototypes */
800 _initialize_som_solib (void)
802 som_so_ops
.relocate_section_addresses
= som_relocate_section_addresses
;
803 som_so_ops
.free_so
= som_free_so
;
804 som_so_ops
.clear_solib
= som_clear_solib
;
805 som_so_ops
.solib_create_inferior_hook
= som_solib_create_inferior_hook
;
806 som_so_ops
.special_symbol_handling
= som_special_symbol_handling
;
807 som_so_ops
.current_sos
= som_current_sos
;
808 som_so_ops
.open_symbol_file_object
= som_open_symbol_file_object
;
809 som_so_ops
.in_dynsym_resolve_code
= som_in_dynsym_resolve_code
;
810 som_so_ops
.bfd_open
= solib_bfd_open
;
814 som_solib_select (struct gdbarch
*gdbarch
)
816 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
818 set_solib_ops (gdbarch
, &som_so_ops
);
819 tdep
->solib_thread_start_addr
= som_solib_thread_start_addr
;
820 tdep
->solib_get_got_by_pc
= som_solib_get_got_by_pc
;
821 tdep
->solib_get_solib_by_pc
= som_solib_get_solib_by_pc
;
824 /* The rest of these functions are not part of the solib interface; they
825 are used by somread.c or hppa-hpux-tdep.c */
828 som_solib_section_offsets (struct objfile
*objfile
,
829 struct section_offsets
*offsets
)
831 struct so_list
*so_list
= master_so_list ();
835 /* Oh what a pain! We need the offsets before so_list->objfile
836 is valid. The BFDs will never match. Make a best guess. */
837 if (strstr (objfile
->name
, so_list
->so_name
))
839 asection
*private_section
;
841 /* The text offset is easy. */
842 offsets
->offsets
[SECT_OFF_TEXT (objfile
)]
843 = (so_list
->lm_info
->text_addr
844 - so_list
->lm_info
->text_link_addr
);
845 offsets
->offsets
[SECT_OFF_RODATA (objfile
)]
846 = ANOFFSET (offsets
, SECT_OFF_TEXT (objfile
));
848 /* We should look at presumed_dp in the SOM header, but
849 that's not easily available. This should be OK though. */
850 private_section
= bfd_get_section_by_name (objfile
->obfd
,
852 if (!private_section
)
854 warning (_("Unable to find $PRIVATE$ in shared library!"));
855 offsets
->offsets
[SECT_OFF_DATA (objfile
)] = 0;
856 offsets
->offsets
[SECT_OFF_BSS (objfile
)] = 0;
859 offsets
->offsets
[SECT_OFF_DATA (objfile
)]
860 = (so_list
->lm_info
->data_start
- private_section
->vma
);
861 offsets
->offsets
[SECT_OFF_BSS (objfile
)]
862 = ANOFFSET (offsets
, SECT_OFF_DATA (objfile
));
865 so_list
= so_list
->next
;