1/* Handle FR-V (FDPIC) shared libraries for GDB, the GNU Debugger. 2 Copyright (C) 2004, 2007, 2008, 2009, 2010, 2011 3 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 21#include "defs.h" 22#include "gdb_string.h" 23#include "inferior.h" 24#include "gdbcore.h" 25#include "solib.h" 26#include "solist.h" 27#include "frv-tdep.h" 28#include "objfiles.h" 29#include "symtab.h" 30#include "language.h" 31#include "command.h" 32#include "gdbcmd.h" 33#include "elf/frv.h" 34#include "exceptions.h" 35 36/* Flag which indicates whether internal debug messages should be printed. */ 37static int solib_frv_debug; 38 39/* FR-V pointers are four bytes wide. */ 40enum { FRV_PTR_SIZE = 4 }; 41 42/* Representation of loadmap and related structs for the FR-V FDPIC ABI. */ 43 44/* External versions; the size and alignment of the fields should be 45 the same as those on the target. When loaded, the placement of 46 the bits in each field will be the same as on the target. */ 47typedef gdb_byte ext_Elf32_Half[2]; 48typedef gdb_byte ext_Elf32_Addr[4]; 49typedef gdb_byte ext_Elf32_Word[4]; 50 51struct ext_elf32_fdpic_loadseg 52{ 53 /* Core address to which the segment is mapped. */ 54 ext_Elf32_Addr addr; 55 /* VMA recorded in the program header. */ 56 ext_Elf32_Addr p_vaddr; 57 /* Size of this segment in memory. */ 58 ext_Elf32_Word p_memsz; 59}; 60 61struct ext_elf32_fdpic_loadmap { 62 /* Protocol version number, must be zero. */ 63 ext_Elf32_Half version; 64 /* Number of segments in this map. */ 65 ext_Elf32_Half nsegs; 66 /* The actual memory map. */ 67 struct ext_elf32_fdpic_loadseg segs[1 /* nsegs, actually */]; 68}; 69 70/* Internal versions; the types are GDB types and the data in each 71 of the fields is (or will be) decoded from the external struct 72 for ease of consumption. */ 73struct int_elf32_fdpic_loadseg 74{ 75 /* Core address to which the segment is mapped. */ 76 CORE_ADDR addr; 77 /* VMA recorded in the program header. */ 78 CORE_ADDR p_vaddr; 79 /* Size of this segment in memory. */ 80 long p_memsz; 81}; 82 83struct int_elf32_fdpic_loadmap { 84 /* Protocol version number, must be zero. */ 85 int version; 86 /* Number of segments in this map. */ 87 int nsegs; 88 /* The actual memory map. */ 89 struct int_elf32_fdpic_loadseg segs[1 /* nsegs, actually */]; 90}; 91 92/* Given address LDMADDR, fetch and decode the loadmap at that address. 93 Return NULL if there is a problem reading the target memory or if 94 there doesn't appear to be a loadmap at the given address. The 95 allocated space (representing the loadmap) returned by this 96 function may be freed via a single call to xfree(). */ 97 98static struct int_elf32_fdpic_loadmap * 99fetch_loadmap (CORE_ADDR ldmaddr) 100{ 101 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 102 struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial; 103 struct ext_elf32_fdpic_loadmap *ext_ldmbuf; 104 struct int_elf32_fdpic_loadmap *int_ldmbuf; 105 int ext_ldmbuf_size, int_ldmbuf_size; 106 int version, seg, nsegs; 107 108 /* Fetch initial portion of the loadmap. */ 109 if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial, 110 sizeof ext_ldmbuf_partial)) 111 { 112 /* Problem reading the target's memory. */ 113 return NULL; 114 } 115 116 /* Extract the version. */ 117 version = extract_unsigned_integer (ext_ldmbuf_partial.version, 118 sizeof ext_ldmbuf_partial.version, 119 byte_order); 120 if (version != 0) 121 { 122 /* We only handle version 0. */ 123 return NULL; 124 } 125 126 /* Extract the number of segments. */ 127 nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs, 128 sizeof ext_ldmbuf_partial.nsegs, 129 byte_order); 130 131 if (nsegs <= 0) 132 return NULL; 133 134 /* Allocate space for the complete (external) loadmap. */ 135 ext_ldmbuf_size = sizeof (struct ext_elf32_fdpic_loadmap) 136 + (nsegs - 1) * sizeof (struct ext_elf32_fdpic_loadseg); 137 ext_ldmbuf = xmalloc (ext_ldmbuf_size); 138 139 /* Copy over the portion of the loadmap that's already been read. */ 140 memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial); 141 142 /* Read the rest of the loadmap from the target. */ 143 if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial, 144 (gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial, 145 ext_ldmbuf_size - sizeof ext_ldmbuf_partial)) 146 { 147 /* Couldn't read rest of the loadmap. */ 148 xfree (ext_ldmbuf); 149 return NULL; 150 } 151 152 /* Allocate space into which to put information extract from the 153 external loadsegs. I.e, allocate the internal loadsegs. */ 154 int_ldmbuf_size = sizeof (struct int_elf32_fdpic_loadmap) 155 + (nsegs - 1) * sizeof (struct int_elf32_fdpic_loadseg); 156 int_ldmbuf = xmalloc (int_ldmbuf_size); 157 158 /* Place extracted information in internal structs. */ 159 int_ldmbuf->version = version; 160 int_ldmbuf->nsegs = nsegs; 161 for (seg = 0; seg < nsegs; seg++) 162 { 163 int_ldmbuf->segs[seg].addr 164 = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr, 165 sizeof (ext_ldmbuf->segs[seg].addr), 166 byte_order); 167 int_ldmbuf->segs[seg].p_vaddr 168 = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr, 169 sizeof (ext_ldmbuf->segs[seg].p_vaddr), 170 byte_order); 171 int_ldmbuf->segs[seg].p_memsz 172 = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz, 173 sizeof (ext_ldmbuf->segs[seg].p_memsz), 174 byte_order); 175 } 176 177 xfree (ext_ldmbuf); 178 return int_ldmbuf; 179} 180 181/* External link_map and elf32_fdpic_loadaddr struct definitions. */ 182 183typedef gdb_byte ext_ptr[4]; 184 185struct ext_elf32_fdpic_loadaddr 186{ 187 ext_ptr map; /* struct elf32_fdpic_loadmap *map; */ 188 ext_ptr got_value; /* void *got_value; */ 189}; 190 191struct ext_link_map 192{ 193 struct ext_elf32_fdpic_loadaddr l_addr; 194 195 /* Absolute file name object was found in. */ 196 ext_ptr l_name; /* char *l_name; */ 197 198 /* Dynamic section of the shared object. */ 199 ext_ptr l_ld; /* ElfW(Dyn) *l_ld; */ 200 201 /* Chain of loaded objects. */ 202 ext_ptr l_next, l_prev; /* struct link_map *l_next, *l_prev; */ 203}; 204 205/* Link map info to include in an allocated so_list entry. */ 206 207struct lm_info 208 { 209 /* The loadmap, digested into an easier to use form. */ 210 struct int_elf32_fdpic_loadmap *map; 211 /* The GOT address for this link map entry. */ 212 CORE_ADDR got_value; 213 /* The link map address, needed for frv_fetch_objfile_link_map(). */ 214 CORE_ADDR lm_addr; 215 216 /* Cached dynamic symbol table and dynamic relocs initialized and 217 used only by find_canonical_descriptor_in_load_object(). 218 219 Note: kevinb/2004-02-26: It appears that calls to 220 bfd_canonicalize_dynamic_reloc() will use the same symbols as 221 those supplied to the first call to this function. Therefore, 222 it's important to NOT free the asymbol ** data structure 223 supplied to the first call. Thus the caching of the dynamic 224 symbols (dyn_syms) is critical for correct operation. The 225 caching of the dynamic relocations could be dispensed with. */ 226 asymbol **dyn_syms; 227 arelent **dyn_relocs; 228 int dyn_reloc_count; /* Number of dynamic relocs. */ 229 230 }; 231 232/* The load map, got value, etc. are not available from the chain 233 of loaded shared objects. ``main_executable_lm_info'' provides 234 a way to get at this information so that it doesn't need to be 235 frequently recomputed. Initialized by frv_relocate_main_executable(). */ 236static struct lm_info *main_executable_lm_info; 237 238static void frv_relocate_main_executable (void); 239static CORE_ADDR main_got (void); 240static int enable_break2 (void); 241 242/* 243 244 LOCAL FUNCTION 245 246 bfd_lookup_symbol -- lookup the value for a specific symbol 247 248 SYNOPSIS 249 250 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname) 251 252 DESCRIPTION 253 254 An expensive way to lookup the value of a single symbol for 255 bfd's that are only temporary anyway. This is used by the 256 shared library support to find the address of the debugger 257 interface structures in the shared library. 258 259 Note that 0 is specifically allowed as an error return (no 260 such symbol). 261 */ 262 263static CORE_ADDR 264bfd_lookup_symbol (bfd *abfd, char *symname) 265{ 266 long storage_needed; 267 asymbol *sym; 268 asymbol **symbol_table; 269 unsigned int number_of_symbols; 270 unsigned int i; 271 struct cleanup *back_to; 272 CORE_ADDR symaddr = 0; 273 274 storage_needed = bfd_get_symtab_upper_bound (abfd); 275 276 if (storage_needed > 0) 277 { 278 symbol_table = (asymbol **) xmalloc (storage_needed); 279 back_to = make_cleanup (xfree, symbol_table); 280 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 281 282 for (i = 0; i < number_of_symbols; i++) 283 { 284 sym = *symbol_table++; 285 if (strcmp (sym->name, symname) == 0) 286 { 287 /* Bfd symbols are section relative. */ 288 symaddr = sym->value + sym->section->vma; 289 break; 290 } 291 } 292 do_cleanups (back_to); 293 } 294 295 if (symaddr) 296 return symaddr; 297 298 /* Look for the symbol in the dynamic string table too. */ 299 300 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); 301 302 if (storage_needed > 0) 303 { 304 symbol_table = (asymbol **) xmalloc (storage_needed); 305 back_to = make_cleanup (xfree, symbol_table); 306 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table); 307 308 for (i = 0; i < number_of_symbols; i++) 309 { 310 sym = *symbol_table++; 311 if (strcmp (sym->name, symname) == 0) 312 { 313 /* Bfd symbols are section relative. */ 314 symaddr = sym->value + sym->section->vma; 315 break; 316 } 317 } 318 do_cleanups (back_to); 319 } 320 321 return symaddr; 322} 323 324 325/* 326 327 LOCAL FUNCTION 328 329 open_symbol_file_object 330 331 SYNOPSIS 332 333 void open_symbol_file_object (void *from_tty) 334 335 DESCRIPTION 336 337 If no open symbol file, attempt to locate and open the main symbol 338 file. 339 340 If FROM_TTYP dereferences to a non-zero integer, allow messages to 341 be printed. This parameter is a pointer rather than an int because 342 open_symbol_file_object() is called via catch_errors() and 343 catch_errors() requires a pointer argument. */ 344 345static int 346open_symbol_file_object (void *from_ttyp) 347{ 348 /* Unimplemented. */ 349 return 0; 350} 351 352/* Cached value for lm_base(), below. */ 353static CORE_ADDR lm_base_cache = 0; 354 355/* Link map address for main module. */ 356static CORE_ADDR main_lm_addr = 0; 357 358/* Return the address from which the link map chain may be found. On 359 the FR-V, this may be found in a number of ways. Assuming that the 360 main executable has already been relocated, the easiest way to find 361 this value is to look up the address of _GLOBAL_OFFSET_TABLE_. A 362 pointer to the start of the link map will be located at the word found 363 at _GLOBAL_OFFSET_TABLE_ + 8. (This is part of the dynamic linker 364 reserve area mandated by the ABI.) */ 365 366static CORE_ADDR 367lm_base (void) 368{ 369 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 370 struct minimal_symbol *got_sym; 371 CORE_ADDR addr; 372 gdb_byte buf[FRV_PTR_SIZE]; 373 374 /* One of our assumptions is that the main executable has been relocated. 375 Bail out if this has not happened. (Note that post_create_inferior() 376 in infcmd.c will call solib_add prior to solib_create_inferior_hook(). 377 If we allow this to happen, lm_base_cache will be initialized with 378 a bogus value. */ 379 if (main_executable_lm_info == 0) 380 return 0; 381 382 /* If we already have a cached value, return it. */ 383 if (lm_base_cache) 384 return lm_base_cache; 385 386 got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL, 387 symfile_objfile); 388 if (got_sym == 0) 389 { 390 if (solib_frv_debug) 391 fprintf_unfiltered (gdb_stdlog, 392 "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n"); 393 return 0; 394 } 395 396 addr = SYMBOL_VALUE_ADDRESS (got_sym) + 8; 397 398 if (solib_frv_debug) 399 fprintf_unfiltered (gdb_stdlog, 400 "lm_base: _GLOBAL_OFFSET_TABLE_ + 8 = %s\n", 401 hex_string_custom (addr, 8)); 402 403 if (target_read_memory (addr, buf, sizeof buf) != 0) 404 return 0; 405 lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order); 406 407 if (solib_frv_debug) 408 fprintf_unfiltered (gdb_stdlog, 409 "lm_base: lm_base_cache = %s\n", 410 hex_string_custom (lm_base_cache, 8)); 411 412 return lm_base_cache; 413} 414 415 416/* LOCAL FUNCTION 417 418 frv_current_sos -- build a list of currently loaded shared objects 419 420 SYNOPSIS 421 422 struct so_list *frv_current_sos () 423 424 DESCRIPTION 425 426 Build a list of `struct so_list' objects describing the shared 427 objects currently loaded in the inferior. This list does not 428 include an entry for the main executable file. 429 430 Note that we only gather information directly available from the 431 inferior --- we don't examine any of the shared library files 432 themselves. The declaration of `struct so_list' says which fields 433 we provide values for. */ 434 435static struct so_list * 436frv_current_sos (void) 437{ 438 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 439 CORE_ADDR lm_addr, mgot; 440 struct so_list *sos_head = NULL; 441 struct so_list **sos_next_ptr = &sos_head; 442 443 /* Make sure that the main executable has been relocated. This is 444 required in order to find the address of the global offset table, 445 which in turn is used to find the link map info. (See lm_base() 446 for details.) 447 448 Note that the relocation of the main executable is also performed 449 by SOLIB_CREATE_INFERIOR_HOOK(), however, in the case of core 450 files, this hook is called too late in order to be of benefit to 451 SOLIB_ADD. SOLIB_ADD eventually calls this this function, 452 frv_current_sos, and also precedes the call to 453 SOLIB_CREATE_INFERIOR_HOOK(). (See post_create_inferior() in 454 infcmd.c.) */ 455 if (main_executable_lm_info == 0 && core_bfd != NULL) 456 frv_relocate_main_executable (); 457 458 /* Fetch the GOT corresponding to the main executable. */ 459 mgot = main_got (); 460 461 /* Locate the address of the first link map struct. */ 462 lm_addr = lm_base (); 463 464 /* We have at least one link map entry. Fetch the lot of them, 465 building the solist chain. */ 466 while (lm_addr) 467 { 468 struct ext_link_map lm_buf; 469 CORE_ADDR got_addr; 470 471 if (solib_frv_debug) 472 fprintf_unfiltered (gdb_stdlog, 473 "current_sos: reading link_map entry at %s\n", 474 hex_string_custom (lm_addr, 8)); 475 476 if (target_read_memory (lm_addr, (gdb_byte *) &lm_buf, 477 sizeof (lm_buf)) != 0) 478 { 479 warning (_("frv_current_sos: Unable to read link map entry. " 480 "Shared object chain may be incomplete.")); 481 break; 482 } 483 484 got_addr 485 = extract_unsigned_integer (lm_buf.l_addr.got_value, 486 sizeof (lm_buf.l_addr.got_value), 487 byte_order); 488 /* If the got_addr is the same as mgotr, then we're looking at the 489 entry for the main executable. By convention, we don't include 490 this in the list of shared objects. */ 491 if (got_addr != mgot) 492 { 493 int errcode; 494 char *name_buf; 495 struct int_elf32_fdpic_loadmap *loadmap; 496 struct so_list *sop; 497 CORE_ADDR addr; 498 499 /* Fetch the load map address. */ 500 addr = extract_unsigned_integer (lm_buf.l_addr.map, 501 sizeof lm_buf.l_addr.map, 502 byte_order); 503 loadmap = fetch_loadmap (addr); 504 if (loadmap == NULL) 505 { 506 warning (_("frv_current_sos: Unable to fetch load map. " 507 "Shared object chain may be incomplete.")); 508 break; 509 } 510 511 sop = xcalloc (1, sizeof (struct so_list)); 512 sop->lm_info = xcalloc (1, sizeof (struct lm_info)); 513 sop->lm_info->map = loadmap; 514 sop->lm_info->got_value = got_addr; 515 sop->lm_info->lm_addr = lm_addr; 516 /* Fetch the name. */ 517 addr = extract_unsigned_integer (lm_buf.l_name, 518 sizeof (lm_buf.l_name), 519 byte_order); 520 target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1, 521 &errcode); 522 523 if (solib_frv_debug) 524 fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n", 525 name_buf); 526 527 if (errcode != 0) 528 warning (_("Can't read pathname for link map entry: %s."), 529 safe_strerror (errcode)); 530 else 531 { 532 strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1); 533 sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; 534 xfree (name_buf); 535 strcpy (sop->so_original_name, sop->so_name); 536 } 537 538 *sos_next_ptr = sop; 539 sos_next_ptr = &sop->next; 540 } 541 else 542 { 543 main_lm_addr = lm_addr; 544 } 545 546 lm_addr = extract_unsigned_integer (lm_buf.l_next, 547 sizeof (lm_buf.l_next), byte_order); 548 } 549 550 enable_break2 (); 551 552 return sos_head; 553} 554 555 556/* Return 1 if PC lies in the dynamic symbol resolution code of the 557 run time loader. */ 558 559static CORE_ADDR interp_text_sect_low; 560static CORE_ADDR interp_text_sect_high; 561static CORE_ADDR interp_plt_sect_low; 562static CORE_ADDR interp_plt_sect_high; 563 564static int 565frv_in_dynsym_resolve_code (CORE_ADDR pc) 566{ 567 return ((pc >= interp_text_sect_low && pc < interp_text_sect_high) 568 || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high) 569 || in_plt_section (pc, NULL)); 570} 571 572/* Given a loadmap and an address, return the displacement needed 573 to relocate the address. */ 574 575static CORE_ADDR 576displacement_from_map (struct int_elf32_fdpic_loadmap *map, 577 CORE_ADDR addr) 578{ 579 int seg; 580 581 for (seg = 0; seg < map->nsegs; seg++) 582 { 583 if (map->segs[seg].p_vaddr <= addr 584 && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz) 585 { 586 return map->segs[seg].addr - map->segs[seg].p_vaddr; 587 } 588 } 589 590 return 0; 591} 592 593/* Print a warning about being unable to set the dynamic linker 594 breakpoint. */ 595 596static void 597enable_break_failure_warning (void) 598{ 599 warning (_("Unable to find dynamic linker breakpoint function.\n" 600 "GDB will be unable to debug shared library initializers\n" 601 "and track explicitly loaded dynamic code.")); 602} 603 604/* 605 606 LOCAL FUNCTION 607 608 enable_break -- arrange for dynamic linker to hit breakpoint 609 610 SYNOPSIS 611 612 int enable_break (void) 613 614 DESCRIPTION 615 616 The dynamic linkers has, as part of its debugger interface, support 617 for arranging for the inferior to hit a breakpoint after mapping in 618 the shared libraries. This function enables that breakpoint. 619 620 On the FR-V, using the shared library (FDPIC) ABI, the symbol 621 _dl_debug_addr points to the r_debug struct which contains 622 a field called r_brk. r_brk is the address of the function 623 descriptor upon which a breakpoint must be placed. Being a 624 function descriptor, we must extract the entry point in order 625 to set the breakpoint. 626 627 Our strategy will be to get the .interp section from the 628 executable. This section will provide us with the name of the 629 interpreter. We'll open the interpreter and then look up 630 the address of _dl_debug_addr. We then relocate this address 631 using the interpreter's loadmap. Once the relocated address 632 is known, we fetch the value (address) corresponding to r_brk 633 and then use that value to fetch the entry point of the function 634 we're interested in. 635 636 */ 637 638static int enable_break2_done = 0; 639 640static int 641enable_break2 (void) 642{ 643 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 644 int success = 0; 645 char **bkpt_namep; 646 asection *interp_sect; 647 648 if (enable_break2_done) 649 return 1; 650 651 interp_text_sect_low = interp_text_sect_high = 0; 652 interp_plt_sect_low = interp_plt_sect_high = 0; 653 654 /* Find the .interp section; if not found, warn the user and drop 655 into the old breakpoint at symbol code. */ 656 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 657 if (interp_sect) 658 { 659 unsigned int interp_sect_size; 660 gdb_byte *buf; 661 bfd *tmp_bfd = NULL; 662 int status; 663 CORE_ADDR addr, interp_loadmap_addr; 664 gdb_byte addr_buf[FRV_PTR_SIZE]; 665 struct int_elf32_fdpic_loadmap *ldm; 666 volatile struct gdb_exception ex; 667 668 /* Read the contents of the .interp section into a local buffer; 669 the contents specify the dynamic linker this program uses. */ 670 interp_sect_size = bfd_section_size (exec_bfd, interp_sect); 671 buf = alloca (interp_sect_size); 672 bfd_get_section_contents (exec_bfd, interp_sect, 673 buf, 0, interp_sect_size); 674 675 /* Now we need to figure out where the dynamic linker was 676 loaded so that we can load its symbols and place a breakpoint 677 in the dynamic linker itself. 678 679 This address is stored on the stack. However, I've been unable 680 to find any magic formula to find it for Solaris (appears to 681 be trivial on GNU/Linux). Therefore, we have to try an alternate 682 mechanism to find the dynamic linker's base address. */ 683 684 TRY_CATCH (ex, RETURN_MASK_ALL) 685 { 686 tmp_bfd = solib_bfd_open (buf); 687 } 688 if (tmp_bfd == NULL) 689 { 690 enable_break_failure_warning (); 691 return 0; 692 } 693 694 status = frv_fdpic_loadmap_addresses (target_gdbarch, 695 &interp_loadmap_addr, 0); 696 if (status < 0) 697 { 698 warning (_("Unable to determine dynamic linker loadmap address.")); 699 enable_break_failure_warning (); 700 bfd_close (tmp_bfd); 701 return 0; 702 } 703 704 if (solib_frv_debug) 705 fprintf_unfiltered (gdb_stdlog, 706 "enable_break: interp_loadmap_addr = %s\n", 707 hex_string_custom (interp_loadmap_addr, 8)); 708 709 ldm = fetch_loadmap (interp_loadmap_addr); 710 if (ldm == NULL) 711 { 712 warning (_("Unable to load dynamic linker loadmap at address %s."), 713 hex_string_custom (interp_loadmap_addr, 8)); 714 enable_break_failure_warning (); 715 bfd_close (tmp_bfd); 716 return 0; 717 } 718 719 /* Record the relocated start and end address of the dynamic linker 720 text and plt section for svr4_in_dynsym_resolve_code. */ 721 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text"); 722 if (interp_sect) 723 { 724 interp_text_sect_low 725 = bfd_section_vma (tmp_bfd, interp_sect); 726 interp_text_sect_low 727 += displacement_from_map (ldm, interp_text_sect_low); 728 interp_text_sect_high 729 = interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect); 730 } 731 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt"); 732 if (interp_sect) 733 { 734 interp_plt_sect_low = 735 bfd_section_vma (tmp_bfd, interp_sect); 736 interp_plt_sect_low 737 += displacement_from_map (ldm, interp_plt_sect_low); 738 interp_plt_sect_high = 739 interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); 740 } 741 742 addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr"); 743 if (addr == 0) 744 { 745 warning (_("Could not find symbol _dl_debug_addr " 746 "in dynamic linker")); 747 enable_break_failure_warning (); 748 bfd_close (tmp_bfd); 749 return 0; 750 } 751 752 if (solib_frv_debug) 753 fprintf_unfiltered (gdb_stdlog, 754 "enable_break: _dl_debug_addr " 755 "(prior to relocation) = %s\n", 756 hex_string_custom (addr, 8)); 757 758 addr += displacement_from_map (ldm, addr); 759 760 if (solib_frv_debug) 761 fprintf_unfiltered (gdb_stdlog, 762 "enable_break: _dl_debug_addr " 763 "(after relocation) = %s\n", 764 hex_string_custom (addr, 8)); 765 766 /* Fetch the address of the r_debug struct. */ 767 if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0) 768 { 769 warning (_("Unable to fetch contents of _dl_debug_addr " 770 "(at address %s) from dynamic linker"), 771 hex_string_custom (addr, 8)); 772 } 773 addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order); 774 775 if (solib_frv_debug) 776 fprintf_unfiltered (gdb_stdlog, 777 "enable_break: _dl_debug_addr[0..3] = %s\n", 778 hex_string_custom (addr, 8)); 779 780 /* If it's zero, then the ldso hasn't initialized yet, and so 781 there are no shared libs yet loaded. */ 782 if (addr == 0) 783 { 784 if (solib_frv_debug) 785 fprintf_unfiltered (gdb_stdlog, 786 "enable_break: ldso not yet initialized\n"); 787 /* Do not warn, but mark to run again. */ 788 return 0; 789 } 790 791 /* Fetch the r_brk field. It's 8 bytes from the start of 792 _dl_debug_addr. */ 793 if (target_read_memory (addr + 8, addr_buf, sizeof addr_buf) != 0) 794 { 795 warning (_("Unable to fetch _dl_debug_addr->r_brk " 796 "(at address %s) from dynamic linker"), 797 hex_string_custom (addr + 8, 8)); 798 enable_break_failure_warning (); 799 bfd_close (tmp_bfd); 800 return 0; 801 } 802 addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order); 803 804 /* Now fetch the function entry point. */ 805 if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0) 806 { 807 warning (_("Unable to fetch _dl_debug_addr->.r_brk entry point " 808 "(at address %s) from dynamic linker"), 809 hex_string_custom (addr, 8)); 810 enable_break_failure_warning (); 811 bfd_close (tmp_bfd); 812 return 0; 813 } 814 addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order); 815 816 /* We're done with the temporary bfd. */ 817 bfd_close (tmp_bfd); 818 819 /* We're also done with the loadmap. */ 820 xfree (ldm); 821 822 /* Remove all the solib event breakpoints. Their addresses 823 may have changed since the last time we ran the program. */ 824 remove_solib_event_breakpoints (); 825 826 /* Now (finally!) create the solib breakpoint. */ 827 create_solib_event_breakpoint (target_gdbarch, addr); 828 829 enable_break2_done = 1; 830 831 return 1; 832 } 833 834 /* Tell the user we couldn't set a dynamic linker breakpoint. */ 835 enable_break_failure_warning (); 836 837 /* Failure return. */ 838 return 0; 839} 840 841static int 842enable_break (void) 843{ 844 asection *interp_sect; 845 846 if (symfile_objfile == NULL) 847 { 848 if (solib_frv_debug) 849 fprintf_unfiltered (gdb_stdlog, 850 "enable_break: No symbol file found.\n"); 851 return 0; 852 } 853 854 if (!symfile_objfile->ei.entry_point_p) 855 { 856 if (solib_frv_debug) 857 fprintf_unfiltered (gdb_stdlog, 858 "enable_break: Symbol file has no entry point.\n"); 859 return 0; 860 } 861 862 /* Check for the presence of a .interp section. If there is no 863 such section, the executable is statically linked. */ 864 865 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 866 867 if (interp_sect == NULL) 868 { 869 if (solib_frv_debug) 870 fprintf_unfiltered (gdb_stdlog, 871 "enable_break: No .interp section found.\n"); 872 return 0; 873 } 874 875 create_solib_event_breakpoint (target_gdbarch, 876 symfile_objfile->ei.entry_point); 877 878 if (solib_frv_debug) 879 fprintf_unfiltered (gdb_stdlog, 880 "enable_break: solib event breakpoint " 881 "placed at entry point: %s\n", 882 hex_string_custom (symfile_objfile->ei.entry_point, 883 8)); 884 return 1; 885} 886 887/* 888 889 LOCAL FUNCTION 890 891 special_symbol_handling -- additional shared library symbol handling 892 893 SYNOPSIS 894 895 void special_symbol_handling () 896 897 DESCRIPTION 898 899 Once the symbols from a shared object have been loaded in the usual 900 way, we are called to do any system specific symbol handling that 901 is needed. 902 903 */ 904 905static void 906frv_special_symbol_handling (void) 907{ 908 /* Nothing needed (yet) for FRV. */ 909} 910 911static void 912frv_relocate_main_executable (void) 913{ 914 int status; 915 CORE_ADDR exec_addr, interp_addr; 916 struct int_elf32_fdpic_loadmap *ldm; 917 struct cleanup *old_chain; 918 struct section_offsets *new_offsets; 919 int changed; 920 struct obj_section *osect; 921 922 status = frv_fdpic_loadmap_addresses (target_gdbarch, 923 &interp_addr, &exec_addr); 924 925 if (status < 0 || (exec_addr == 0 && interp_addr == 0)) 926 { 927 /* Not using FDPIC ABI, so do nothing. */ 928 return; 929 } 930 931 /* Fetch the loadmap located at ``exec_addr''. */ 932 ldm = fetch_loadmap (exec_addr); 933 if (ldm == NULL) 934 error (_("Unable to load the executable's loadmap.")); 935 936 if (main_executable_lm_info) 937 xfree (main_executable_lm_info); 938 main_executable_lm_info = xcalloc (1, sizeof (struct lm_info)); 939 main_executable_lm_info->map = ldm; 940 941 new_offsets = xcalloc (symfile_objfile->num_sections, 942 sizeof (struct section_offsets)); 943 old_chain = make_cleanup (xfree, new_offsets); 944 changed = 0; 945 946 ALL_OBJFILE_OSECTIONS (symfile_objfile, osect) 947 { 948 CORE_ADDR orig_addr, addr, offset; 949 int osect_idx; 950 int seg; 951 952 osect_idx = osect->the_bfd_section->index; 953 954 /* Current address of section. */ 955 addr = obj_section_addr (osect); 956 /* Offset from where this section started. */ 957 offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx); 958 /* Original address prior to any past relocations. */ 959 orig_addr = addr - offset; 960 961 for (seg = 0; seg < ldm->nsegs; seg++) 962 { 963 if (ldm->segs[seg].p_vaddr <= orig_addr 964 && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz) 965 { 966 new_offsets->offsets[osect_idx] 967 = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr; 968 969 if (new_offsets->offsets[osect_idx] != offset) 970 changed = 1; 971 break; 972 } 973 } 974 } 975 976 if (changed) 977 objfile_relocate (symfile_objfile, new_offsets); 978 979 do_cleanups (old_chain); 980 981 /* Now that symfile_objfile has been relocated, we can compute the 982 GOT value and stash it away. */ 983 main_executable_lm_info->got_value = main_got (); 984} 985 986/* 987 988 GLOBAL FUNCTION 989 990 frv_solib_create_inferior_hook -- shared library startup support 991 992 SYNOPSIS 993 994 void frv_solib_create_inferior_hook () 995 996 DESCRIPTION 997 998 When gdb starts up the inferior, it nurses it along (through the 999 shell) until it is ready to execute it's first instruction. At this 1000 point, this function gets called via expansion of the macro 1001 SOLIB_CREATE_INFERIOR_HOOK. 1002 1003 For the FR-V shared library ABI (FDPIC), the main executable 1004 needs to be relocated. The shared library breakpoints also need 1005 to be enabled. 1006 */ 1007 1008static void 1009frv_solib_create_inferior_hook (int from_tty) 1010{ 1011 /* Relocate main executable. */ 1012 frv_relocate_main_executable (); 1013 1014 /* Enable shared library breakpoints. */ 1015 if (!enable_break ()) 1016 { 1017 warning (_("shared library handler failed to enable breakpoint")); 1018 return; 1019 } 1020} 1021 1022static void 1023frv_clear_solib (void) 1024{ 1025 lm_base_cache = 0; 1026 enable_break2_done = 0; 1027 main_lm_addr = 0; 1028 if (main_executable_lm_info != 0) 1029 { 1030 xfree (main_executable_lm_info->map); 1031 xfree (main_executable_lm_info->dyn_syms); 1032 xfree (main_executable_lm_info->dyn_relocs); 1033 xfree (main_executable_lm_info); 1034 main_executable_lm_info = 0; 1035 } 1036} 1037 1038static void 1039frv_free_so (struct so_list *so) 1040{ 1041 xfree (so->lm_info->map); 1042 xfree (so->lm_info->dyn_syms); 1043 xfree (so->lm_info->dyn_relocs); 1044 xfree (so->lm_info); 1045} 1046 1047static void 1048frv_relocate_section_addresses (struct so_list *so, 1049 struct target_section *sec) 1050{ 1051 int seg; 1052 struct int_elf32_fdpic_loadmap *map; 1053 1054 map = so->lm_info->map; 1055 1056 for (seg = 0; seg < map->nsegs; seg++) 1057 { 1058 if (map->segs[seg].p_vaddr <= sec->addr 1059 && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz) 1060 { 1061 CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr; 1062 1063 sec->addr += displ; 1064 sec->endaddr += displ; 1065 break; 1066 } 1067 } 1068} 1069 1070/* Return the GOT address associated with the main executable. Return 1071 0 if it can't be found. */ 1072 1073static CORE_ADDR 1074main_got (void) 1075{ 1076 struct minimal_symbol *got_sym; 1077 1078 got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", 1079 NULL, symfile_objfile); 1080 if (got_sym == 0) 1081 return 0; 1082 1083 return SYMBOL_VALUE_ADDRESS (got_sym); 1084} 1085 1086/* Find the global pointer for the given function address ADDR. */ 1087 1088CORE_ADDR 1089frv_fdpic_find_global_pointer (CORE_ADDR addr) 1090{ 1091 struct so_list *so; 1092 1093 so = master_so_list (); 1094 while (so) 1095 { 1096 int seg; 1097 struct int_elf32_fdpic_loadmap *map; 1098 1099 map = so->lm_info->map; 1100 1101 for (seg = 0; seg < map->nsegs; seg++) 1102 { 1103 if (map->segs[seg].addr <= addr 1104 && addr < map->segs[seg].addr + map->segs[seg].p_memsz) 1105 return so->lm_info->got_value; 1106 } 1107 1108 so = so->next; 1109 } 1110 1111 /* Didn't find it it any of the shared objects. So assume it's in the 1112 main executable. */ 1113 return main_got (); 1114} 1115 1116/* Forward declarations for frv_fdpic_find_canonical_descriptor(). */ 1117static CORE_ADDR find_canonical_descriptor_in_load_object 1118 (CORE_ADDR, CORE_ADDR, char *, bfd *, struct lm_info *); 1119 1120/* Given a function entry point, attempt to find the canonical descriptor 1121 associated with that entry point. Return 0 if no canonical descriptor 1122 could be found. */ 1123 1124CORE_ADDR 1125frv_fdpic_find_canonical_descriptor (CORE_ADDR entry_point) 1126{ 1127 char *name; 1128 CORE_ADDR addr; 1129 CORE_ADDR got_value; 1130 struct int_elf32_fdpic_loadmap *ldm = 0; 1131 struct symbol *sym; 1132 int status; 1133 CORE_ADDR exec_loadmap_addr; 1134 1135 /* Fetch the corresponding global pointer for the entry point. */ 1136 got_value = frv_fdpic_find_global_pointer (entry_point); 1137 1138 /* Attempt to find the name of the function. If the name is available, 1139 it'll be used as an aid in finding matching functions in the dynamic 1140 symbol table. */ 1141 sym = find_pc_function (entry_point); 1142 if (sym == 0) 1143 name = 0; 1144 else 1145 name = SYMBOL_LINKAGE_NAME (sym); 1146 1147 /* Check the main executable. */ 1148 addr = find_canonical_descriptor_in_load_object 1149 (entry_point, got_value, name, symfile_objfile->obfd, 1150 main_executable_lm_info); 1151 1152 /* If descriptor not found via main executable, check each load object 1153 in list of shared objects. */ 1154 if (addr == 0) 1155 { 1156 struct so_list *so; 1157 1158 so = master_so_list (); 1159 while (so) 1160 { 1161 addr = find_canonical_descriptor_in_load_object 1162 (entry_point, got_value, name, so->abfd, so->lm_info); 1163 1164 if (addr != 0) 1165 break; 1166 1167 so = so->next; 1168 } 1169 } 1170 1171 return addr; 1172} 1173 1174static CORE_ADDR 1175find_canonical_descriptor_in_load_object 1176 (CORE_ADDR entry_point, CORE_ADDR got_value, char *name, bfd *abfd, 1177 struct lm_info *lm) 1178{ 1179 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 1180 arelent *rel; 1181 unsigned int i; 1182 CORE_ADDR addr = 0; 1183 1184 /* Nothing to do if no bfd. */ 1185 if (abfd == 0) 1186 return 0; 1187 1188 /* Nothing to do if no link map. */ 1189 if (lm == 0) 1190 return 0; 1191 1192 /* We want to scan the dynamic relocs for R_FRV_FUNCDESC relocations. 1193 (More about this later.) But in order to fetch the relocs, we 1194 need to first fetch the dynamic symbols. These symbols need to 1195 be cached due to the way that bfd_canonicalize_dynamic_reloc() 1196 works. (See the comments in the declaration of struct lm_info 1197 for more information.) */ 1198 if (lm->dyn_syms == NULL) 1199 { 1200 long storage_needed; 1201 unsigned int number_of_symbols; 1202 1203 /* Determine amount of space needed to hold the dynamic symbol table. */ 1204 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); 1205 1206 /* If there are no dynamic symbols, there's nothing to do. */ 1207 if (storage_needed <= 0) 1208 return 0; 1209 1210 /* Allocate space for the dynamic symbol table. */ 1211 lm->dyn_syms = (asymbol **) xmalloc (storage_needed); 1212 1213 /* Fetch the dynamic symbol table. */ 1214 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, lm->dyn_syms); 1215 1216 if (number_of_symbols == 0) 1217 return 0; 1218 } 1219 1220 /* Fetch the dynamic relocations if not already cached. */ 1221 if (lm->dyn_relocs == NULL) 1222 { 1223 long storage_needed; 1224 1225 /* Determine amount of space needed to hold the dynamic relocs. */ 1226 storage_needed = bfd_get_dynamic_reloc_upper_bound (abfd); 1227 1228 /* Bail out if there are no dynamic relocs. */ 1229 if (storage_needed <= 0) 1230 return 0; 1231 1232 /* Allocate space for the relocs. */ 1233 lm->dyn_relocs = (arelent **) xmalloc (storage_needed); 1234 1235 /* Fetch the dynamic relocs. */ 1236 lm->dyn_reloc_count 1237 = bfd_canonicalize_dynamic_reloc (abfd, lm->dyn_relocs, lm->dyn_syms); 1238 } 1239 1240 /* Search the dynamic relocs. */ 1241 for (i = 0; i < lm->dyn_reloc_count; i++) 1242 { 1243 rel = lm->dyn_relocs[i]; 1244 1245 /* Relocs of interest are those which meet the following 1246 criteria: 1247 1248 - the names match (assuming the caller could provide 1249 a name which matches ``entry_point''). 1250 - the relocation type must be R_FRV_FUNCDESC. Relocs 1251 of this type are used (by the dynamic linker) to 1252 look up the address of a canonical descriptor (allocating 1253 it if need be) and initializing the GOT entry referred 1254 to by the offset to the address of the descriptor. 1255 1256 These relocs of interest may be used to obtain a 1257 candidate descriptor by first adjusting the reloc's 1258 address according to the link map and then dereferencing 1259 this address (which is a GOT entry) to obtain a descriptor 1260 address. */ 1261 if ((name == 0 || strcmp (name, (*rel->sym_ptr_ptr)->name) == 0) 1262 && rel->howto->type == R_FRV_FUNCDESC) 1263 { 1264 gdb_byte buf [FRV_PTR_SIZE]; 1265 1266 /* Compute address of address of candidate descriptor. */ 1267 addr = rel->address + displacement_from_map (lm->map, rel->address); 1268 1269 /* Fetch address of candidate descriptor. */ 1270 if (target_read_memory (addr, buf, sizeof buf) != 0) 1271 continue; 1272 addr = extract_unsigned_integer (buf, sizeof buf, byte_order); 1273 1274 /* Check for matching entry point. */ 1275 if (target_read_memory (addr, buf, sizeof buf) != 0) 1276 continue; 1277 if (extract_unsigned_integer (buf, sizeof buf, byte_order) 1278 != entry_point) 1279 continue; 1280 1281 /* Check for matching got value. */ 1282 if (target_read_memory (addr + 4, buf, sizeof buf) != 0) 1283 continue; 1284 if (extract_unsigned_integer (buf, sizeof buf, byte_order) 1285 != got_value) 1286 continue; 1287 1288 /* Match was successful! Exit loop. */ 1289 break; 1290 } 1291 } 1292 1293 return addr; 1294} 1295 1296/* Given an objfile, return the address of its link map. This value is 1297 needed for TLS support. */ 1298CORE_ADDR 1299frv_fetch_objfile_link_map (struct objfile *objfile) 1300{ 1301 struct so_list *so; 1302 1303 /* Cause frv_current_sos() to be run if it hasn't been already. */ 1304 if (main_lm_addr == 0) 1305 solib_add (0, 0, 0, 1); 1306 1307 /* frv_current_sos() will set main_lm_addr for the main executable. */ 1308 if (objfile == symfile_objfile) 1309 return main_lm_addr; 1310 1311 /* The other link map addresses may be found by examining the list 1312 of shared libraries. */ 1313 for (so = master_so_list (); so; so = so->next) 1314 { 1315 if (so->objfile == objfile) 1316 return so->lm_info->lm_addr; 1317 } 1318 1319 /* Not found! */ 1320 return 0; 1321} 1322 1323struct target_so_ops frv_so_ops; 1324 1325/* Provide a prototype to silence -Wmissing-prototypes. */ 1326extern initialize_file_ftype _initialize_frv_solib; 1327 1328void 1329_initialize_frv_solib (void) 1330{ 1331 frv_so_ops.relocate_section_addresses = frv_relocate_section_addresses; 1332 frv_so_ops.free_so = frv_free_so; 1333 frv_so_ops.clear_solib = frv_clear_solib; 1334 frv_so_ops.solib_create_inferior_hook = frv_solib_create_inferior_hook; 1335 frv_so_ops.special_symbol_handling = frv_special_symbol_handling; 1336 frv_so_ops.current_sos = frv_current_sos; 1337 frv_so_ops.open_symbol_file_object = open_symbol_file_object; 1338 frv_so_ops.in_dynsym_resolve_code = frv_in_dynsym_resolve_code; 1339 frv_so_ops.bfd_open = solib_bfd_open; 1340 1341 /* Debug this file's internals. */ 1342 add_setshow_zinteger_cmd ("solib-frv", class_maintenance, 1343 &solib_frv_debug, _("\ 1344Set internal debugging of shared library code for FR-V."), _("\ 1345Show internal debugging of shared library code for FR-V."), _("\ 1346When non-zero, FR-V solib specific internal debugging is enabled."), 1347 NULL, 1348 NULL, /* FIXME: i18n: */ 1349 &setdebuglist, &showdebuglist); 1350} 1351