Commit | Line | Data |
---|---|---|
a1cd1908 ND |
1 | /* Handle OSF/1, Digital UNIX, and Tru64 shared libraries |
2 | for GDB, the GNU Debugger. | |
9b254dd1 | 3 | Copyright (C) 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2007, 2008 |
a1cd1908 ND |
4 | Free Software Foundation, Inc. |
5 | ||
6 | This file is part of GDB. | |
7 | ||
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 | |
a9762ec7 | 10 | the Free Software Foundation; either version 3 of the License, or |
a1cd1908 ND |
11 | (at your option) any later version. |
12 | ||
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. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
a9762ec7 | 19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
a1cd1908 ND |
20 | |
21 | /* When handling shared libraries, GDB has to find out the pathnames | |
22 | of all shared libraries that are currently loaded (to read in their | |
23 | symbols) and where the shared libraries are loaded in memory | |
24 | (to relocate them properly from their prelinked addresses to the | |
25 | current load address). | |
26 | ||
27 | Under OSF/1 there are two possibilities to get at this information: | |
28 | ||
29 | 1) Peek around in the runtime loader structures. | |
30 | These are not documented, and they are not defined in the system | |
31 | header files. The definitions below were obtained by experimentation, | |
32 | but they seem stable enough. | |
33 | ||
34 | 2) Use the libxproc.a library, which contains the equivalent ldr_* | |
35 | routines. The library is documented in Tru64 5.x, but as of 5.1, it | |
36 | only allows a process to examine itself. On earlier versions, it | |
37 | may require that the GDB executable be dynamically linked and that | |
38 | NAT_CLIBS include -lxproc -Wl,-expect_unresolved,ldr_process_context | |
39 | for GDB and all applications that are using libgdb. | |
40 | ||
41 | We will use the peeking approach until libxproc.a works for other | |
42 | processes. */ | |
43 | ||
44 | #include "defs.h" | |
45 | ||
46 | #include <sys/types.h> | |
47 | #include <signal.h> | |
48 | #include "gdb_string.h" | |
49 | ||
50 | #include "bfd.h" | |
51 | #include "symtab.h" | |
52 | #include "symfile.h" | |
53 | #include "objfiles.h" | |
54 | #include "target.h" | |
55 | #include "inferior.h" | |
2020b7ab | 56 | #include "gdbthread.h" |
a1cd1908 ND |
57 | #include "solist.h" |
58 | ||
59 | #ifdef USE_LDR_ROUTINES | |
60 | # include <loader.h> | |
61 | #endif | |
62 | ||
63 | #ifndef USE_LDR_ROUTINES | |
64 | /* Definition of runtime loader structures, found by experimentation. */ | |
65 | #define RLD_CONTEXT_ADDRESS 0x3ffc0000000 | |
66 | ||
67 | /* Per-module information structure referenced by ldr_context_t.head. */ | |
68 | ||
69 | typedef struct | |
70 | { | |
71 | CORE_ADDR next; | |
72 | CORE_ADDR previous; | |
73 | CORE_ADDR unknown1; | |
74 | CORE_ADDR module_name; | |
75 | CORE_ADDR modinfo_addr; /* used by next_link_map_member() to detect | |
76 | the end of the shared module list */ | |
77 | long module_id; | |
78 | CORE_ADDR unknown2; | |
79 | CORE_ADDR unknown3; | |
80 | long region_count; | |
81 | CORE_ADDR regioninfo_addr; | |
82 | } | |
83 | ldr_module_info_t; | |
84 | ||
85 | /* Per-region structure referenced by ldr_module_info_t.regioninfo_addr. */ | |
86 | ||
87 | typedef struct | |
88 | { | |
89 | long unknown1; | |
90 | CORE_ADDR regionname_addr; | |
91 | long protection; | |
92 | CORE_ADDR vaddr; | |
93 | CORE_ADDR mapaddr; | |
94 | long size; | |
95 | long unknown2[5]; | |
96 | } | |
97 | ldr_region_info_t; | |
98 | ||
99 | /* Structure at RLD_CONTEXT_ADDRESS specifying the start and finish addresses | |
100 | of the shared module list. */ | |
101 | ||
102 | typedef struct | |
103 | { | |
104 | CORE_ADDR unknown1; | |
105 | CORE_ADDR unknown2; | |
106 | CORE_ADDR head; | |
107 | CORE_ADDR tail; | |
108 | } | |
109 | ldr_context_t; | |
110 | #endif /* !USE_LDR_ROUTINES */ | |
111 | ||
112 | /* Per-section information, stored in struct lm_info.secs. */ | |
113 | ||
114 | struct lm_sec | |
115 | { | |
116 | CORE_ADDR offset; /* difference between default and actual | |
117 | virtual addresses of section .name */ | |
118 | CORE_ADDR nameaddr; /* address in inferior of section name */ | |
119 | const char *name; /* name of section, null if not fetched */ | |
120 | }; | |
121 | ||
122 | /* Per-module information, stored in struct so_list.lm_info. */ | |
123 | ||
124 | struct lm_info | |
125 | { | |
126 | int isloader; /* whether the module is /sbin/loader */ | |
127 | int nsecs; /* length of .secs */ | |
128 | struct lm_sec secs[1]; /* variable-length array of sections, sorted | |
129 | by name */ | |
130 | }; | |
131 | ||
132 | /* Context for iterating through the inferior's shared module list. */ | |
133 | ||
134 | struct read_map_ctxt | |
135 | { | |
136 | #ifdef USE_LDR_ROUTINES | |
137 | ldr_process_t proc; | |
138 | ldr_module_t next; | |
139 | #else | |
140 | CORE_ADDR next; /* next element in module list */ | |
141 | CORE_ADDR tail; /* last element in module list */ | |
142 | #endif | |
143 | }; | |
144 | ||
145 | /* Forward declaration for this module's autoinit function. */ | |
146 | ||
147 | extern void _initialize_osf_solib (void); | |
148 | ||
149 | #ifdef USE_LDR_ROUTINES | |
150 | # if 0 | |
151 | /* This routine is intended to be called by ldr_* routines to read memory from | |
152 | the current target. Usage: | |
153 | ||
154 | ldr_process = ldr_core_process (); | |
155 | ldr_set_core_reader (ldr_read_memory); | |
156 | ldr_xdetach (ldr_process); | |
157 | ldr_xattach (ldr_process); | |
158 | ||
159 | ldr_core_process() and ldr_read_memory() are neither documented nor | |
160 | declared in system header files. They work with OSF/1 2.x, and they might | |
161 | work with later versions as well. */ | |
162 | ||
163 | static int | |
164 | ldr_read_memory (CORE_ADDR memaddr, char *myaddr, int len, int readstring) | |
165 | { | |
166 | int result; | |
167 | char *buffer; | |
168 | ||
169 | if (readstring) | |
170 | { | |
171 | target_read_string (memaddr, &buffer, len, &result); | |
172 | if (result == 0) | |
173 | strcpy (myaddr, buffer); | |
174 | xfree (buffer); | |
175 | } | |
176 | else | |
177 | result = target_read_memory (memaddr, myaddr, len); | |
178 | ||
179 | if (result != 0) | |
180 | result = -result; | |
181 | return result; | |
182 | } | |
183 | # endif /* 0 */ | |
184 | #endif /* USE_LDR_ROUTINES */ | |
185 | ||
186 | /* Comparison for qsort() and bsearch(): return -1, 0, or 1 according to | |
187 | whether lm_sec *P1's name is lexically less than, equal to, or greater | |
188 | than that of *P2. */ | |
189 | ||
190 | static int | |
191 | lm_sec_cmp (const void *p1, const void *p2) | |
192 | { | |
193 | const struct lm_sec *lms1 = p1, *lms2 = p2; | |
194 | return strcmp (lms1->name, lms2->name); | |
195 | } | |
196 | ||
197 | /* Sort LMI->secs so that osf_relocate_section_addresses() can binary-search | |
198 | it. */ | |
199 | ||
200 | static void | |
201 | lm_secs_sort (struct lm_info *lmi) | |
202 | { | |
203 | qsort (lmi->secs, lmi->nsecs, sizeof *lmi->secs, lm_sec_cmp); | |
204 | } | |
205 | ||
206 | /* Populate name fields of LMI->secs. */ | |
207 | ||
208 | static void | |
209 | fetch_sec_names (struct lm_info *lmi) | |
210 | { | |
211 | #ifndef USE_LDR_ROUTINES | |
212 | int i, errcode; | |
213 | struct lm_sec *lms; | |
214 | char *name; | |
215 | ||
216 | for (i = 0; i < lmi->nsecs; i++) | |
217 | { | |
218 | lms = lmi->secs + i; | |
219 | target_read_string (lms->nameaddr, &name, PATH_MAX, &errcode); | |
220 | if (errcode != 0) | |
221 | { | |
8a3fe4f8 | 222 | warning (_("unable to read shared sec name at 0x%lx"), lms->nameaddr); |
a1cd1908 ND |
223 | name = xstrdup (""); |
224 | } | |
225 | lms->name = name; | |
226 | } | |
227 | lm_secs_sort (lmi); | |
228 | #endif | |
229 | } | |
230 | ||
231 | /* target_so_ops callback. Adjust SEC's addresses after it's been mapped into | |
232 | the process. */ | |
233 | ||
234 | static void | |
235 | osf_relocate_section_addresses (struct so_list *so, | |
236 | struct section_table *sec) | |
237 | { | |
238 | struct lm_info *lmi; | |
239 | struct lm_sec lms_key, *lms; | |
240 | ||
241 | /* Fetch SO's section names if we haven't done so already. */ | |
242 | lmi = so->lm_info; | |
243 | if (lmi->nsecs && !lmi->secs[0].name) | |
244 | fetch_sec_names (lmi); | |
245 | ||
246 | /* Binary-search for offset information corresponding to SEC. */ | |
247 | lms_key.name = sec->the_bfd_section->name; | |
248 | lms = bsearch (&lms_key, lmi->secs, lmi->nsecs, sizeof *lms, lm_sec_cmp); | |
249 | if (lms) | |
250 | { | |
251 | sec->addr += lms->offset; | |
252 | sec->endaddr += lms->offset; | |
253 | } | |
254 | } | |
255 | ||
256 | /* target_so_ops callback. Free parts of SO allocated by this file. */ | |
257 | ||
258 | static void | |
259 | osf_free_so (struct so_list *so) | |
260 | { | |
261 | int i; | |
262 | const char *name; | |
263 | ||
264 | for (i = 0; i < so->lm_info->nsecs; i++) | |
265 | { | |
266 | name = so->lm_info->secs[i].name; | |
267 | if (name) | |
268 | xfree ((void *) name); | |
269 | } | |
270 | xfree (so->lm_info); | |
271 | } | |
272 | ||
273 | /* target_so_ops callback. Discard information accumulated by this file and | |
274 | not freed by osf_free_so(). */ | |
275 | ||
276 | static void | |
277 | osf_clear_solib (void) | |
278 | { | |
279 | return; | |
280 | } | |
281 | ||
282 | /* target_so_ops callback. Prepare to handle shared libraries after the | |
283 | inferior process has been created but before it's executed any | |
284 | instructions. | |
285 | ||
286 | For a statically bound executable, the inferior's first instruction is the | |
287 | one at "_start", or a similar text label. No further processing is needed | |
288 | in that case. | |
289 | ||
290 | For a dynamically bound executable, this first instruction is somewhere | |
291 | in the rld, and the actual user executable is not yet mapped in. | |
292 | We continue the inferior again, rld then maps in the actual user | |
293 | executable and any needed shared libraries and then sends | |
294 | itself a SIGTRAP. | |
295 | ||
296 | At that point we discover the names of all shared libraries and | |
297 | read their symbols in. | |
298 | ||
299 | FIXME | |
300 | ||
301 | This code does not properly handle hitting breakpoints which the | |
302 | user might have set in the rld itself. Proper handling would have | |
303 | to check if the SIGTRAP happened due to a kill call. | |
304 | ||
305 | Also, what if child has exit()ed? Must exit loop somehow. */ | |
306 | ||
307 | static void | |
308 | osf_solib_create_inferior_hook (void) | |
309 | { | |
d6b48e9c | 310 | struct inferior *inf; |
2020b7ab PA |
311 | struct thread_info *tp; |
312 | ||
181e7f93 PA |
313 | inf = current_inferior (); |
314 | ||
ea8eedbe JB |
315 | /* If we are attaching to the inferior, the shared libraries |
316 | have already been mapped, so nothing more to do. */ | |
181e7f93 | 317 | if (inf->attach_flag) |
ea8eedbe JB |
318 | return; |
319 | ||
a1cd1908 ND |
320 | /* Nothing to do for statically bound executables. */ |
321 | ||
322 | if (symfile_objfile == NULL | |
323 | || symfile_objfile->obfd == NULL | |
324 | || ((bfd_get_file_flags (symfile_objfile->obfd) & DYNAMIC) == 0)) | |
325 | return; | |
326 | ||
327 | /* Now run the target. It will eventually get a SIGTRAP, at | |
328 | which point all of the libraries will have been mapped in and we | |
329 | can go groveling around in the rld structures to find | |
59ddf1e7 JB |
330 | out what we need to know about them. |
331 | ||
332 | If debugging from a core file, we cannot resume the execution | |
333 | of the inferior. But this is actually not an issue, because | |
334 | shared libraries have already been mapped anyways, which means | |
335 | we have nothing more to do. */ | |
336 | if (!target_can_run (¤t_target)) | |
337 | return; | |
a1cd1908 | 338 | |
2020b7ab | 339 | tp = inferior_thread (); |
a1cd1908 | 340 | clear_proceed_status (); |
d6b48e9c | 341 | inf->stop_soon = STOP_QUIETLY; |
2020b7ab | 342 | tp->stop_signal = TARGET_SIGNAL_0; |
a1cd1908 ND |
343 | do |
344 | { | |
2020b7ab | 345 | target_resume (minus_one_ptid, 0, tp->stop_signal); |
ae123ec6 | 346 | wait_for_inferior (0); |
a1cd1908 | 347 | } |
2020b7ab | 348 | while (tp->stop_signal != TARGET_SIGNAL_TRAP); |
a1cd1908 ND |
349 | |
350 | /* solib_add will call reinit_frame_cache. | |
351 | But we are stopped in the runtime loader and we do not have symbols | |
352 | for the runtime loader. So heuristic_proc_start will be called | |
353 | and will put out an annoying warning. | |
c0236d92 | 354 | Delaying the resetting of stop_soon until after symbol loading |
a1cd1908 | 355 | suppresses the warning. */ |
990f9fe3 | 356 | solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add); |
d6b48e9c | 357 | inf->stop_soon = NO_STOP_QUIETLY; |
a1cd1908 ND |
358 | } |
359 | ||
360 | /* target_so_ops callback. Do additional symbol handling, lookup, etc. after | |
361 | symbols for a shared object have been loaded. */ | |
362 | ||
363 | static void | |
364 | osf_special_symbol_handling (void) | |
365 | { | |
366 | return; | |
367 | } | |
368 | ||
369 | /* Initialize CTXT in preparation for iterating through the inferior's module | |
370 | list using read_map(). Return success. */ | |
371 | ||
372 | static int | |
373 | open_map (struct read_map_ctxt *ctxt) | |
374 | { | |
375 | #ifdef USE_LDR_ROUTINES | |
7a5a0534 JB |
376 | /* Note: As originally written, ldr_my_process() was used to obtain |
377 | the value for ctxt->proc. This is incorrect, however, since | |
378 | ldr_my_process() retrieves the "unique identifier" associated | |
379 | with the current process (i.e. GDB) and not the one being | |
380 | debugged. Presumably, the pid of the process being debugged is | |
381 | compatible with the "unique identifier" used by the ldr_ | |
382 | routines, so we use that. */ | |
383 | ctxt->proc = ptid_get_pid (inferior_ptid); | |
a1cd1908 ND |
384 | if (ldr_xattach (ctxt->proc) != 0) |
385 | return 0; | |
386 | ctxt->next = LDR_NULL_MODULE; | |
387 | #else | |
388 | CORE_ADDR ldr_context_addr, prev, next; | |
389 | ldr_context_t ldr_context; | |
390 | ||
391 | if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS, | |
392 | (char *) &ldr_context_addr, | |
393 | sizeof (CORE_ADDR)) != 0) | |
394 | return 0; | |
395 | if (target_read_memory (ldr_context_addr, | |
396 | (char *) &ldr_context, | |
397 | sizeof (ldr_context_t)) != 0) | |
398 | return 0; | |
399 | ctxt->next = ldr_context.head; | |
400 | ctxt->tail = ldr_context.tail; | |
401 | #endif | |
402 | return 1; | |
403 | } | |
404 | ||
405 | /* Initialize SO to have module NAME, /sbin/loader indicator ISLOADR, and | |
406 | space for NSECS sections. */ | |
407 | ||
408 | static void | |
409 | init_so (struct so_list *so, char *name, int isloader, int nsecs) | |
410 | { | |
411 | int namelen, i; | |
412 | ||
413 | /* solib.c requires various fields to be initialized to 0. */ | |
414 | memset (so, 0, sizeof *so); | |
415 | ||
416 | /* Copy the name. */ | |
417 | namelen = strlen (name); | |
418 | if (namelen >= SO_NAME_MAX_PATH_SIZE) | |
419 | namelen = SO_NAME_MAX_PATH_SIZE - 1; | |
420 | ||
421 | memcpy (so->so_original_name, name, namelen); | |
422 | so->so_original_name[namelen] = '\0'; | |
423 | memcpy (so->so_name, so->so_original_name, namelen + 1); | |
424 | ||
425 | /* Allocate section space. */ | |
426 | so->lm_info = xmalloc ((unsigned) &(((struct lm_info *)0)->secs) + | |
427 | nsecs * sizeof *so->lm_info); | |
428 | so->lm_info->isloader = isloader; | |
429 | so->lm_info->nsecs = nsecs; | |
430 | for (i = 0; i < nsecs; i++) | |
431 | so->lm_info->secs[i].name = NULL; | |
432 | } | |
433 | ||
434 | /* Initialize SO's section SECIDX with name address NAMEADDR, name string | |
435 | NAME, default virtual address VADDR, and actual virtual address | |
436 | MAPADDR. */ | |
437 | ||
438 | static void | |
439 | init_sec (struct so_list *so, int secidx, CORE_ADDR nameaddr, | |
440 | const char *name, CORE_ADDR vaddr, CORE_ADDR mapaddr) | |
441 | { | |
442 | struct lm_sec *lms; | |
443 | ||
444 | lms = so->lm_info->secs + secidx; | |
445 | lms->nameaddr = nameaddr; | |
446 | lms->name = name; | |
447 | lms->offset = mapaddr - vaddr; | |
448 | } | |
449 | ||
450 | /* If there are more elements starting at CTXT in inferior's module list, | |
451 | store the next element in SO, advance CTXT to the next element, and return | |
452 | 1, else return 0. */ | |
453 | ||
454 | static int | |
455 | read_map (struct read_map_ctxt *ctxt, struct so_list *so) | |
456 | { | |
457 | ldr_module_info_t minf; | |
458 | ldr_region_info_t rinf; | |
459 | ||
460 | #ifdef USE_LDR_ROUTINES | |
461 | size_t size; | |
462 | ldr_region_t i; | |
463 | ||
464 | /* Retrieve the next element. */ | |
465 | if (ldr_next_module (ctxt->proc, &ctxt->next) != 0) | |
466 | return 0; | |
467 | if (ctxt->next == LDR_NULL_MODULE) | |
468 | return 0; | |
469 | if (ldr_inq_module (ctxt->proc, ctxt->next, &minf, sizeof minf, &size) != 0) | |
470 | return 0; | |
471 | ||
472 | /* Initialize the module name and section count. */ | |
473 | init_so (so, minf.lmi_name, 0, minf.lmi_nregion); | |
474 | ||
475 | /* Retrieve section names and offsets. */ | |
476 | for (i = 0; i < minf.lmi_nregion; i++) | |
477 | { | |
478 | if (ldr_inq_region (ctxt->proc, ctxt->next, i, &rinf, | |
479 | sizeof rinf, &size) != 0) | |
480 | goto err; | |
481 | init_sec (so, (int) i, 0, xstrdup (rinf.lri_name), | |
482 | (CORE_ADDR) rinf.lri_vaddr, (CORE_ADDR) rinf.lri_mapaddr); | |
483 | } | |
484 | lm_secs_sort (so->lm_info); | |
485 | #else | |
486 | char *name; | |
487 | int errcode, i; | |
488 | ||
489 | /* Retrieve the next element. */ | |
490 | if (!ctxt->next) | |
491 | return 0; | |
492 | if (target_read_memory (ctxt->next, (char *) &minf, sizeof minf) != 0) | |
493 | return 0; | |
494 | if (ctxt->next == ctxt->tail) | |
495 | ctxt->next = 0; | |
496 | else | |
497 | ctxt->next = minf.next; | |
498 | ||
499 | /* Initialize the module name and section count. */ | |
500 | target_read_string (minf.module_name, &name, PATH_MAX, &errcode); | |
501 | if (errcode != 0) | |
502 | return 0; | |
503 | init_so (so, name, !minf.modinfo_addr, minf.region_count); | |
504 | xfree (name); | |
505 | ||
506 | /* Retrieve section names and offsets. */ | |
507 | for (i = 0; i < minf.region_count; i++) | |
508 | { | |
509 | if (target_read_memory (minf.regioninfo_addr + i * sizeof rinf, | |
510 | (char *) &rinf, sizeof rinf) != 0) | |
511 | goto err; | |
512 | init_sec (so, i, rinf.regionname_addr, NULL, rinf.vaddr, rinf.mapaddr); | |
513 | } | |
514 | #endif /* !USE_LDR_ROUTINES */ | |
515 | return 1; | |
516 | ||
517 | err: | |
518 | osf_free_so (so); | |
519 | return 0; | |
520 | } | |
521 | ||
522 | /* Free resources allocated by open_map (CTXT). */ | |
523 | ||
524 | static void | |
525 | close_map (struct read_map_ctxt *ctxt) | |
526 | { | |
527 | #ifdef USE_LDR_ROUTINES | |
528 | ldr_xdetach (ctxt->proc); | |
529 | #endif | |
530 | } | |
531 | ||
532 | /* target_so_ops callback. Return a list of shared objects currently loaded | |
533 | in the inferior. */ | |
534 | ||
535 | static struct so_list * | |
536 | osf_current_sos (void) | |
537 | { | |
538 | struct so_list *head = NULL, *tail, *newtail, so; | |
539 | struct read_map_ctxt ctxt; | |
540 | int skipped_main; | |
541 | ||
542 | if (!open_map (&ctxt)) | |
543 | return NULL; | |
544 | ||
545 | /* Read subsequent elements. */ | |
546 | for (skipped_main = 0;;) | |
547 | { | |
548 | if (!read_map (&ctxt, &so)) | |
549 | break; | |
550 | ||
551 | /* Skip the main program module, which is first in the list after | |
552 | /sbin/loader. */ | |
553 | if (!so.lm_info->isloader && !skipped_main) | |
554 | { | |
555 | osf_free_so (&so); | |
556 | skipped_main = 1; | |
557 | continue; | |
558 | } | |
559 | ||
560 | newtail = xmalloc (sizeof *newtail); | |
561 | if (!head) | |
562 | head = newtail; | |
563 | else | |
564 | tail->next = newtail; | |
565 | tail = newtail; | |
566 | ||
567 | memcpy (tail, &so, sizeof so); | |
568 | tail->next = NULL; | |
569 | } | |
570 | ||
a1cd1908 ND |
571 | close_map (&ctxt); |
572 | return head; | |
573 | } | |
574 | ||
575 | /* target_so_ops callback. Attempt to locate and open the main symbol | |
576 | file. */ | |
577 | ||
578 | static int | |
579 | osf_open_symbol_file_object (void *from_ttyp) | |
580 | { | |
581 | struct read_map_ctxt ctxt; | |
582 | struct so_list so; | |
583 | int found; | |
584 | ||
585 | if (symfile_objfile) | |
586 | if (!query ("Attempt to reload symbols from process? ")) | |
587 | return 0; | |
588 | ||
589 | /* The first module after /sbin/loader is the main program. */ | |
590 | if (!open_map (&ctxt)) | |
591 | return 0; | |
592 | for (found = 0; !found;) | |
593 | { | |
594 | if (!read_map (&ctxt, &so)) | |
595 | break; | |
596 | found = !so.lm_info->isloader; | |
597 | osf_free_so (&so); | |
598 | } | |
599 | close_map (&ctxt); | |
600 | ||
601 | if (found) | |
602 | symbol_file_add_main (so.so_name, *(int *) from_ttyp); | |
603 | return found; | |
604 | } | |
605 | ||
606 | /* target_so_ops callback. Return whether PC is in the dynamic linker. */ | |
607 | ||
608 | static int | |
609 | osf_in_dynsym_resolve_code (CORE_ADDR pc) | |
610 | { | |
b184b287 JB |
611 | /* This function currently always return False. This is a temporary |
612 | solution which only consequence is to introduce a minor incovenience | |
613 | for the user: When stepping inside a subprogram located in a shared | |
614 | library, gdb might stop inside the dynamic loader code instead of | |
615 | inside the subprogram itself. See the explanations in infrun.c about | |
cfd8ab24 | 616 | the in_solib_dynsym_resolve_code() function for more details. */ |
a1cd1908 ND |
617 | return 0; |
618 | } | |
619 | ||
620 | static struct target_so_ops osf_so_ops; | |
621 | ||
622 | void | |
623 | _initialize_osf_solib (void) | |
624 | { | |
625 | osf_so_ops.relocate_section_addresses = osf_relocate_section_addresses; | |
626 | osf_so_ops.free_so = osf_free_so; | |
627 | osf_so_ops.clear_solib = osf_clear_solib; | |
628 | osf_so_ops.solib_create_inferior_hook = osf_solib_create_inferior_hook; | |
629 | osf_so_ops.special_symbol_handling = osf_special_symbol_handling; | |
630 | osf_so_ops.current_sos = osf_current_sos; | |
631 | osf_so_ops.open_symbol_file_object = osf_open_symbol_file_object; | |
632 | osf_so_ops.in_dynsym_resolve_code = osf_in_dynsym_resolve_code; | |
633 | ||
634 | /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */ | |
635 | current_target_so_ops = &osf_so_ops; | |
636 | } |