1 /* BFD back-end for archive files (libraries). 2 Copyright 1990-2013 Free Software Foundation, Inc. 3 Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault. 4 5 This file is part of BFD, the Binary File Descriptor library. 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, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 20 21 /* 22 @setfilename archive-info 23 SECTION 24 Archives 25 26 DESCRIPTION 27 An archive (or library) is just another BFD. It has a symbol 28 table, although there's not much a user program will do with it. 29 30 The big difference between an archive BFD and an ordinary BFD 31 is that the archive doesn't have sections. Instead it has a 32 chain of BFDs that are considered its contents. These BFDs can 33 be manipulated like any other. The BFDs contained in an 34 archive opened for reading will all be opened for reading. You 35 may put either input or output BFDs into an archive opened for 36 output; they will be handled correctly when the archive is closed. 37 38 Use <<bfd_openr_next_archived_file>> to step through 39 the contents of an archive opened for input. You don't 40 have to read the entire archive if you don't want 41 to! Read it until you find what you want. 42 43 A BFD returned by <<bfd_openr_next_archived_file>> can be 44 closed manually with <<bfd_close>>. If you do not close it, 45 then a second iteration through the members of an archive may 46 return the same BFD. If you close the archive BFD, then all 47 the member BFDs will automatically be closed as well. 48 49 Archive contents of output BFDs are chained through the 50 <<archive_next>> pointer in a BFD. The first one is findable 51 through the <<archive_head>> slot of the archive. Set it with 52 <<bfd_set_archive_head>> (q.v.). A given BFD may be in only 53 one open output archive at a time. 54 55 As expected, the BFD archive code is more general than the 56 archive code of any given environment. BFD archives may 57 contain files of different formats (e.g., a.out and coff) and 58 even different architectures. You may even place archives 59 recursively into archives! 60 61 This can cause unexpected confusion, since some archive 62 formats are more expressive than others. For instance, Intel 63 COFF archives can preserve long filenames; SunOS a.out archives 64 cannot. If you move a file from the first to the second 65 format and back again, the filename may be truncated. 66 Likewise, different a.out environments have different 67 conventions as to how they truncate filenames, whether they 68 preserve directory names in filenames, etc. When 69 interoperating with native tools, be sure your files are 70 homogeneous. 71 72 Beware: most of these formats do not react well to the 73 presence of spaces in filenames. We do the best we can, but 74 can't always handle this case due to restrictions in the format of 75 archives. Many Unix utilities are braindead in regards to 76 spaces and such in filenames anyway, so this shouldn't be much 77 of a restriction. 78 79 Archives are supported in BFD in <<archive.c>>. 80 81 SUBSECTION 82 Archive functions 83 */ 84 85 /* Assumes: 86 o - all archive elements start on an even boundary, newline padded; 87 o - all arch headers are char *; 88 o - all arch headers are the same size (across architectures). 89 */ 90 91 /* Some formats provide a way to cram a long filename into the short 92 (16 chars) space provided by a BSD archive. The trick is: make a 93 special "file" in the front of the archive, sort of like the SYMDEF 94 entry. If the filename is too long to fit, put it in the extended 95 name table, and use its index as the filename. To prevent 96 confusion prepend the index with a space. This means you can't 97 have filenames that start with a space, but then again, many Unix 98 utilities can't handle that anyway. 99 100 This scheme unfortunately requires that you stand on your head in 101 order to write an archive since you need to put a magic file at the 102 front, and need to touch every entry to do so. C'est la vie. 103 104 We support two variants of this idea: 105 The SVR4 format (extended name table is named "//"), 106 and an extended pseudo-BSD variant (extended name table is named 107 "ARFILENAMES/"). The origin of the latter format is uncertain. 108 109 BSD 4.4 uses a third scheme: It writes a long filename 110 directly after the header. This allows 'ar q' to work. 111 */ 112 113 /* Summary of archive member names: 114 115 Symbol table (must be first): 116 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib. 117 "/ " - Symbol table, system 5 style. 118 119 Long name table (must be before regular file members): 120 "// " - Long name table, System 5 R4 style. 121 "ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4). 122 123 Regular file members with short names: 124 "filename.o/ " - Regular file, System 5 style (embedded spaces ok). 125 "filename.o " - Regular file, Berkeley style (no embedded spaces). 126 127 Regular files with long names (or embedded spaces, for BSD variants): 128 "/18 " - SVR4 style, name at offset 18 in name table. 129 "#1/23 " - Long name (or embedded spaces) 23 characters long, 130 BSD 4.4 style, full name follows header. 131 " 18 " - Long name 18 characters long, extended pseudo-BSD. 132 */ 133 134 #include "sysdep.h" 135 #include "bfd.h" 136 #include "libiberty.h" 137 #include "libbfd.h" 138 #include "aout/ar.h" 139 #include "aout/ranlib.h" 140 #include "safe-ctype.h" 141 #include "hashtab.h" 142 #include "filenames.h" 143 144 #ifndef errno 145 extern int errno; 146 #endif 147 148 /* We keep a cache of archive filepointers to archive elements to 149 speed up searching the archive by filepos. We only add an entry to 150 the cache when we actually read one. We also don't sort the cache; 151 it's generally short enough to search linearly. 152 Note that the pointers here point to the front of the ar_hdr, not 153 to the front of the contents! */ 154 struct ar_cache 155 { 156 file_ptr ptr; 157 bfd *arbfd; 158 }; 159 160 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char) 161 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen) 162 163 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data)) 164 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata (bfd)->arch_header) 165 166 /* True iff NAME designated a BSD 4.4 extended name. */ 167 168 #define is_bsd44_extended_name(NAME) \ 169 (NAME[0] == '#' && NAME[1] == '1' && NAME[2] == '/' && ISDIGIT (NAME[3])) 170 171 void 172 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val) 173 { 174 static char buf[20]; 175 size_t len; 176 177 snprintf (buf, sizeof (buf), fmt, val); 178 len = strlen (buf); 179 if (len < n) 180 { 181 memcpy (p, buf, len); 182 memset (p + len, ' ', n - len); 183 } 184 else 185 memcpy (p, buf, n); 186 } 187 188 bfd_boolean 189 _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size) 190 { 191 static char buf[21]; 192 size_t len; 193 194 snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size); 195 len = strlen (buf); 196 if (len > n) 197 { 198 bfd_set_error (bfd_error_file_too_big); 199 return FALSE; 200 } 201 if (len < n) 202 { 203 memcpy (p, buf, len); 204 memset (p + len, ' ', n - len); 205 } 206 else 207 memcpy (p, buf, n); 208 return TRUE; 209 } 210 211 bfd_boolean 212 _bfd_generic_mkarchive (bfd *abfd) 213 { 214 bfd_size_type amt = sizeof (struct artdata); 215 216 abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt); 217 if (bfd_ardata (abfd) == NULL) 218 return FALSE; 219 220 /* Already cleared by bfd_zalloc above. 221 bfd_ardata (abfd)->cache = NULL; 222 bfd_ardata (abfd)->archive_head = NULL; 223 bfd_ardata (abfd)->symdefs = NULL; 224 bfd_ardata (abfd)->extended_names = NULL; 225 bfd_ardata (abfd)->extended_names_size = 0; 226 bfd_ardata (abfd)->tdata = NULL; */ 227 228 return TRUE; 229 } 230 231 /* 232 FUNCTION 233 bfd_get_next_mapent 234 235 SYNOPSIS 236 symindex bfd_get_next_mapent 237 (bfd *abfd, symindex previous, carsym **sym); 238 239 DESCRIPTION 240 Step through archive @var{abfd}'s symbol table (if it 241 has one). Successively update @var{sym} with the next symbol's 242 information, returning that symbol's (internal) index into the 243 symbol table. 244 245 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get 246 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already 247 got the last one. 248 249 A <<carsym>> is a canonical archive symbol. The only 250 user-visible element is its name, a null-terminated string. 251 */ 252 253 symindex 254 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry) 255 { 256 if (!bfd_has_map (abfd)) 257 { 258 bfd_set_error (bfd_error_invalid_operation); 259 return BFD_NO_MORE_SYMBOLS; 260 } 261 262 if (prev == BFD_NO_MORE_SYMBOLS) 263 prev = 0; 264 else 265 ++prev; 266 if (prev >= bfd_ardata (abfd)->symdef_count) 267 return BFD_NO_MORE_SYMBOLS; 268 269 *entry = (bfd_ardata (abfd)->symdefs + prev); 270 return prev; 271 } 272 273 /* To be called by backends only. */ 274 275 bfd * 276 _bfd_create_empty_archive_element_shell (bfd *obfd) 277 { 278 return _bfd_new_bfd_contained_in (obfd); 279 } 280 281 /* 282 FUNCTION 283 bfd_set_archive_head 284 285 SYNOPSIS 286 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head); 287 288 DESCRIPTION 289 Set the head of the chain of 290 BFDs contained in the archive @var{output} to @var{new_head}. 291 */ 292 293 bfd_boolean 294 bfd_set_archive_head (bfd *output_archive, bfd *new_head) 295 { 296 output_archive->archive_head = new_head; 297 return TRUE; 298 } 299 300 bfd * 301 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos) 302 { 303 htab_t hash_table = bfd_ardata (arch_bfd)->cache; 304 struct ar_cache m; 305 306 m.ptr = filepos; 307 308 if (hash_table) 309 { 310 struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m); 311 if (!entry) 312 return NULL; 313 else 314 return entry->arbfd; 315 } 316 else 317 return NULL; 318 } 319 320 static hashval_t 321 hash_file_ptr (const void * p) 322 { 323 return (hashval_t) (((struct ar_cache *) p)->ptr); 324 } 325 326 /* Returns non-zero if P1 and P2 are equal. */ 327 328 static int 329 eq_file_ptr (const void * p1, const void * p2) 330 { 331 struct ar_cache *arc1 = (struct ar_cache *) p1; 332 struct ar_cache *arc2 = (struct ar_cache *) p2; 333 return arc1->ptr == arc2->ptr; 334 } 335 336 /* The calloc function doesn't always take size_t (e.g. on VMS) 337 so wrap it to avoid a compile time warning. */ 338 339 static void * 340 _bfd_calloc_wrapper (size_t a, size_t b) 341 { 342 return calloc (a, b); 343 } 344 345 /* Kind of stupid to call cons for each one, but we don't do too many. */ 346 347 bfd_boolean 348 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt) 349 { 350 struct ar_cache *cache; 351 htab_t hash_table = bfd_ardata (arch_bfd)->cache; 352 353 /* If the hash table hasn't been created, create it. */ 354 if (hash_table == NULL) 355 { 356 hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr, 357 NULL, _bfd_calloc_wrapper, free); 358 if (hash_table == NULL) 359 return FALSE; 360 bfd_ardata (arch_bfd)->cache = hash_table; 361 } 362 363 /* Insert new_elt into the hash table by filepos. */ 364 cache = (struct ar_cache *) bfd_zalloc (arch_bfd, sizeof (struct ar_cache)); 365 cache->ptr = filepos; 366 cache->arbfd = new_elt; 367 *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache; 368 369 /* Provide a means of accessing this from child. */ 370 arch_eltdata (new_elt)->parent_cache = hash_table; 371 arch_eltdata (new_elt)->key = filepos; 372 373 return TRUE; 374 } 375 376 static bfd * 377 _bfd_find_nested_archive (bfd *arch_bfd, const char *filename) 378 { 379 bfd *abfd; 380 const char *target; 381 382 /* PR 15140: Don't allow a nested archive pointing to itself. */ 383 if (filename_cmp (filename, arch_bfd->filename) == 0) 384 { 385 bfd_set_error (bfd_error_malformed_archive); 386 return NULL; 387 } 388 389 for (abfd = arch_bfd->nested_archives; 390 abfd != NULL; 391 abfd = abfd->archive_next) 392 { 393 if (filename_cmp (filename, abfd->filename) == 0) 394 return abfd; 395 } 396 target = NULL; 397 if (!arch_bfd->target_defaulted) 398 target = arch_bfd->xvec->name; 399 abfd = bfd_openr (filename, target); 400 if (abfd) 401 { 402 abfd->archive_next = arch_bfd->nested_archives; 403 arch_bfd->nested_archives = abfd; 404 } 405 return abfd; 406 } 407 408 /* The name begins with space. Hence the rest of the name is an index into 409 the string table. */ 410 411 static char * 412 get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp) 413 { 414 unsigned long table_index = 0; 415 const char *endp; 416 417 /* Should extract string so that I can guarantee not to overflow into 418 the next region, but I'm too lazy. */ 419 errno = 0; 420 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */ 421 table_index = strtol (name + 1, (char **) &endp, 10); 422 if (errno != 0 || table_index >= bfd_ardata (arch)->extended_names_size) 423 { 424 bfd_set_error (bfd_error_malformed_archive); 425 return NULL; 426 } 427 /* In a thin archive, a member of an archive-within-an-archive 428 will have the offset in the inner archive encoded here. */ 429 if (bfd_is_thin_archive (arch) && endp != NULL && *endp == ':') 430 { 431 file_ptr origin = strtol (endp + 1, NULL, 10); 432 433 if (errno != 0) 434 { 435 bfd_set_error (bfd_error_malformed_archive); 436 return NULL; 437 } 438 *originp = origin; 439 } 440 else 441 *originp = 0; 442 443 return bfd_ardata (arch)->extended_names + table_index; 444 } 445 446 /* This functions reads an arch header and returns an areltdata pointer, or 447 NULL on error. 448 449 Presumes the file pointer is already in the right place (ie pointing 450 to the ar_hdr in the file). Moves the file pointer; on success it 451 should be pointing to the front of the file contents; on failure it 452 could have been moved arbitrarily. */ 453 454 void * 455 _bfd_generic_read_ar_hdr (bfd *abfd) 456 { 457 return _bfd_generic_read_ar_hdr_mag (abfd, NULL); 458 } 459 460 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a 461 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */ 462 463 void * 464 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag) 465 { 466 struct ar_hdr hdr; 467 char *hdrp = (char *) &hdr; 468 bfd_size_type parsed_size; 469 struct areltdata *ared; 470 char *filename = NULL; 471 bfd_size_type namelen = 0; 472 bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr); 473 char *allocptr = 0; 474 file_ptr origin = 0; 475 unsigned int extra_size = 0; 476 char fmag_save; 477 int scan; 478 479 if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr)) 480 { 481 if (bfd_get_error () != bfd_error_system_call) 482 bfd_set_error (bfd_error_no_more_archived_files); 483 return NULL; 484 } 485 if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0 486 && (mag == NULL 487 || strncmp (hdr.ar_fmag, mag, 2) != 0)) 488 { 489 bfd_set_error (bfd_error_malformed_archive); 490 return NULL; 491 } 492 493 errno = 0; 494 fmag_save = hdr.ar_fmag[0]; 495 hdr.ar_fmag[0] = 0; 496 scan = sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size); 497 hdr.ar_fmag[0] = fmag_save; 498 if (scan != 1) 499 { 500 bfd_set_error (bfd_error_malformed_archive); 501 return NULL; 502 } 503 504 /* Extract the filename from the archive - there are two ways to 505 specify an extended name table, either the first char of the 506 name is a space, or it's a slash. */ 507 if ((hdr.ar_name[0] == '/' 508 || (hdr.ar_name[0] == ' ' 509 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL)) 510 && bfd_ardata (abfd)->extended_names != NULL) 511 { 512 filename = get_extended_arelt_filename (abfd, hdr.ar_name, &origin); 513 if (filename == NULL) 514 return NULL; 515 } 516 /* BSD4.4-style long filename. */ 517 else if (is_bsd44_extended_name (hdr.ar_name)) 518 { 519 /* BSD-4.4 extended name */ 520 namelen = atoi (&hdr.ar_name[3]); 521 allocsize += namelen + 1; 522 parsed_size -= namelen; 523 extra_size = namelen; 524 525 allocptr = (char *) bfd_zmalloc (allocsize); 526 if (allocptr == NULL) 527 return NULL; 528 filename = (allocptr 529 + sizeof (struct areltdata) 530 + sizeof (struct ar_hdr)); 531 if (bfd_bread (filename, namelen, abfd) != namelen) 532 { 533 free (allocptr); 534 if (bfd_get_error () != bfd_error_system_call) 535 bfd_set_error (bfd_error_no_more_archived_files); 536 return NULL; 537 } 538 filename[namelen] = '\0'; 539 } 540 else 541 { 542 /* We judge the end of the name by looking for '/' or ' '. 543 Note: The SYSV format (terminated by '/') allows embedded 544 spaces, so only look for ' ' if we don't find '/'. */ 545 546 char *e; 547 e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd)); 548 if (e == NULL) 549 { 550 e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)); 551 if (e == NULL) 552 e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd)); 553 } 554 555 if (e != NULL) 556 namelen = e - hdr.ar_name; 557 else 558 { 559 /* If we didn't find a termination character, then the name 560 must be the entire field. */ 561 namelen = ar_maxnamelen (abfd); 562 } 563 564 allocsize += namelen + 1; 565 } 566 567 if (!allocptr) 568 { 569 allocptr = (char *) bfd_zmalloc (allocsize); 570 if (allocptr == NULL) 571 return NULL; 572 } 573 574 ared = (struct areltdata *) allocptr; 575 576 ared->arch_header = allocptr + sizeof (struct areltdata); 577 memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr)); 578 ared->parsed_size = parsed_size; 579 ared->extra_size = extra_size; 580 ared->origin = origin; 581 582 if (filename != NULL) 583 ared->filename = filename; 584 else 585 { 586 ared->filename = allocptr + (sizeof (struct areltdata) + 587 sizeof (struct ar_hdr)); 588 if (namelen) 589 memcpy (ared->filename, hdr.ar_name, namelen); 590 ared->filename[namelen] = '\0'; 591 } 592 593 return ared; 594 } 595 596 /* Append the relative pathname for a member of the thin archive 597 to the pathname of the directory containing the archive. */ 598 599 char * 600 _bfd_append_relative_path (bfd *arch, char *elt_name) 601 { 602 const char *arch_name = arch->filename; 603 const char *base_name = lbasename (arch_name); 604 size_t prefix_len; 605 char *filename; 606 607 if (base_name == arch_name) 608 return elt_name; 609 610 prefix_len = base_name - arch_name; 611 filename = (char *) bfd_alloc (arch, prefix_len + strlen (elt_name) + 1); 612 if (filename == NULL) 613 return NULL; 614 615 strncpy (filename, arch_name, prefix_len); 616 strcpy (filename + prefix_len, elt_name); 617 return filename; 618 } 619 620 /* This is an internal function; it's mainly used when indexing 621 through the archive symbol table, but also used to get the next 622 element, since it handles the bookkeeping so nicely for us. */ 623 624 bfd * 625 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos) 626 { 627 struct areltdata *new_areldata; 628 bfd *n_nfd; 629 char *filename; 630 631 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos); 632 if (n_nfd) 633 return n_nfd; 634 635 if (0 > bfd_seek (archive, filepos, SEEK_SET)) 636 return NULL; 637 638 if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL) 639 return NULL; 640 641 filename = new_areldata->filename; 642 643 if (bfd_is_thin_archive (archive)) 644 { 645 const char *target; 646 647 /* This is a proxy entry for an external file. */ 648 if (! IS_ABSOLUTE_PATH (filename)) 649 { 650 filename = _bfd_append_relative_path (archive, filename); 651 if (filename == NULL) 652 { 653 free (new_areldata); 654 return NULL; 655 } 656 } 657 658 if (new_areldata->origin > 0) 659 { 660 /* This proxy entry refers to an element of a nested archive. 661 Locate the member of that archive and return a bfd for it. */ 662 bfd *ext_arch = _bfd_find_nested_archive (archive, filename); 663 664 if (ext_arch == NULL 665 || ! bfd_check_format (ext_arch, bfd_archive)) 666 { 667 free (new_areldata); 668 return NULL; 669 } 670 n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin); 671 if (n_nfd == NULL) 672 { 673 free (new_areldata); 674 return NULL; 675 } 676 n_nfd->proxy_origin = bfd_tell (archive); 677 return n_nfd; 678 } 679 /* It's not an element of a nested archive; 680 open the external file as a bfd. */ 681 target = NULL; 682 if (!archive->target_defaulted) 683 target = archive->xvec->name; 684 n_nfd = bfd_openr (filename, target); 685 if (n_nfd == NULL) 686 bfd_set_error (bfd_error_malformed_archive); 687 } 688 else 689 { 690 n_nfd = _bfd_create_empty_archive_element_shell (archive); 691 } 692 693 if (n_nfd == NULL) 694 { 695 free (new_areldata); 696 return NULL; 697 } 698 699 n_nfd->proxy_origin = bfd_tell (archive); 700 701 if (bfd_is_thin_archive (archive)) 702 { 703 n_nfd->origin = 0; 704 } 705 else 706 { 707 n_nfd->origin = n_nfd->proxy_origin; 708 n_nfd->filename = filename; 709 } 710 711 n_nfd->arelt_data = new_areldata; 712 713 /* Copy BFD_COMPRESS and BFD_DECOMPRESS flags. */ 714 n_nfd->flags |= archive->flags & (BFD_COMPRESS | BFD_DECOMPRESS); 715 716 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd)) 717 return n_nfd; 718 719 free (new_areldata); 720 n_nfd->arelt_data = NULL; 721 return NULL; 722 } 723 724 /* Return the BFD which is referenced by the symbol in ABFD indexed by 725 SYM_INDEX. SYM_INDEX should have been returned by bfd_get_next_mapent. */ 726 727 bfd * 728 _bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index) 729 { 730 carsym *entry; 731 732 entry = bfd_ardata (abfd)->symdefs + sym_index; 733 return _bfd_get_elt_at_filepos (abfd, entry->file_offset); 734 } 735 736 /* 737 FUNCTION 738 bfd_openr_next_archived_file 739 740 SYNOPSIS 741 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous); 742 743 DESCRIPTION 744 Provided a BFD, @var{archive}, containing an archive and NULL, open 745 an input BFD on the first contained element and returns that. 746 Subsequent calls should pass 747 the archive and the previous return value to return a created 748 BFD to the next contained element. NULL is returned when there 749 are no more. 750 */ 751 752 bfd * 753 bfd_openr_next_archived_file (bfd *archive, bfd *last_file) 754 { 755 if ((bfd_get_format (archive) != bfd_archive) 756 || (archive->direction == write_direction)) 757 { 758 bfd_set_error (bfd_error_invalid_operation); 759 return NULL; 760 } 761 762 return BFD_SEND (archive, 763 openr_next_archived_file, (archive, last_file)); 764 } 765 766 bfd * 767 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file) 768 { 769 file_ptr filestart; 770 771 if (!last_file) 772 filestart = bfd_ardata (archive)->first_file_filepos; 773 else 774 { 775 bfd_size_type size = arelt_size (last_file); 776 777 filestart = last_file->proxy_origin; 778 if (! bfd_is_thin_archive (archive)) 779 filestart += size; 780 /* Pad to an even boundary... 781 Note that last_file->origin can be odd in the case of 782 BSD-4.4-style element with a long odd size. */ 783 filestart += filestart % 2; 784 } 785 786 return _bfd_get_elt_at_filepos (archive, filestart); 787 } 788 789 const bfd_target * 790 bfd_generic_archive_p (bfd *abfd) 791 { 792 struct artdata *tdata_hold; 793 char armag[SARMAG + 1]; 794 bfd_size_type amt; 795 796 if (bfd_bread (armag, SARMAG, abfd) != SARMAG) 797 { 798 if (bfd_get_error () != bfd_error_system_call) 799 bfd_set_error (bfd_error_wrong_format); 800 return NULL; 801 } 802 803 bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0); 804 805 if (strncmp (armag, ARMAG, SARMAG) != 0 806 && strncmp (armag, ARMAGB, SARMAG) != 0 807 && ! bfd_is_thin_archive (abfd)) 808 return NULL; 809 810 tdata_hold = bfd_ardata (abfd); 811 812 amt = sizeof (struct artdata); 813 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt); 814 if (bfd_ardata (abfd) == NULL) 815 { 816 bfd_ardata (abfd) = tdata_hold; 817 return NULL; 818 } 819 820 bfd_ardata (abfd)->first_file_filepos = SARMAG; 821 /* Cleared by bfd_zalloc above. 822 bfd_ardata (abfd)->cache = NULL; 823 bfd_ardata (abfd)->archive_head = NULL; 824 bfd_ardata (abfd)->symdefs = NULL; 825 bfd_ardata (abfd)->extended_names = NULL; 826 bfd_ardata (abfd)->extended_names_size = 0; 827 bfd_ardata (abfd)->tdata = NULL; */ 828 829 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd)) 830 || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd))) 831 { 832 if (bfd_get_error () != bfd_error_system_call) 833 bfd_set_error (bfd_error_wrong_format); 834 bfd_release (abfd, bfd_ardata (abfd)); 835 bfd_ardata (abfd) = tdata_hold; 836 return NULL; 837 } 838 839 if (abfd->target_defaulted && bfd_has_map (abfd)) 840 { 841 bfd *first; 842 843 /* This archive has a map, so we may presume that the contents 844 are object files. Make sure that if the first file in the 845 archive can be recognized as an object file, it is for this 846 target. If not, assume that this is the wrong format. If 847 the first file is not an object file, somebody is doing 848 something weird, and we permit it so that ar -t will work. 849 850 This is done because any normal format will recognize any 851 normal archive, regardless of the format of the object files. 852 We do accept an empty archive. */ 853 854 first = bfd_openr_next_archived_file (abfd, NULL); 855 if (first != NULL) 856 { 857 first->target_defaulted = FALSE; 858 if (bfd_check_format (first, bfd_object) 859 && first->xvec != abfd->xvec) 860 bfd_set_error (bfd_error_wrong_object_format); 861 /* And we ought to close `first' here too. */ 862 } 863 } 864 865 return abfd->xvec; 866 } 867 868 /* Some constants for a 32 bit BSD archive structure. We do not 869 support 64 bit archives presently; so far as I know, none actually 870 exist. Supporting them would require changing these constants, and 871 changing some H_GET_32 to H_GET_64. */ 872 873 /* The size of an external symdef structure. */ 874 #define BSD_SYMDEF_SIZE 8 875 876 /* The offset from the start of a symdef structure to the file offset. */ 877 #define BSD_SYMDEF_OFFSET_SIZE 4 878 879 /* The size of the symdef count. */ 880 #define BSD_SYMDEF_COUNT_SIZE 4 881 882 /* The size of the string count. */ 883 #define BSD_STRING_COUNT_SIZE 4 884 885 /* Read a BSD-style archive symbol table. Returns FALSE on error, 886 TRUE otherwise. */ 887 888 static bfd_boolean 889 do_slurp_bsd_armap (bfd *abfd) 890 { 891 struct areltdata *mapdata; 892 unsigned int counter; 893 bfd_byte *raw_armap, *rbase; 894 struct artdata *ardata = bfd_ardata (abfd); 895 char *stringbase; 896 bfd_size_type parsed_size, amt; 897 carsym *set; 898 899 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); 900 if (mapdata == NULL) 901 return FALSE; 902 parsed_size = mapdata->parsed_size; 903 free (mapdata); 904 905 raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size); 906 if (raw_armap == NULL) 907 return FALSE; 908 909 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size) 910 { 911 if (bfd_get_error () != bfd_error_system_call) 912 bfd_set_error (bfd_error_malformed_archive); 913 byebye: 914 bfd_release (abfd, raw_armap); 915 return FALSE; 916 } 917 918 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE; 919 920 if (ardata->symdef_count * BSD_SYMDEF_SIZE > 921 parsed_size - BSD_SYMDEF_COUNT_SIZE) 922 { 923 /* Probably we're using the wrong byte ordering. */ 924 bfd_set_error (bfd_error_wrong_format); 925 goto byebye; 926 } 927 928 ardata->cache = 0; 929 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE; 930 stringbase = ((char *) rbase 931 + ardata->symdef_count * BSD_SYMDEF_SIZE 932 + BSD_STRING_COUNT_SIZE); 933 amt = ardata->symdef_count * sizeof (carsym); 934 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt); 935 if (!ardata->symdefs) 936 return FALSE; 937 938 for (counter = 0, set = ardata->symdefs; 939 counter < ardata->symdef_count; 940 counter++, set++, rbase += BSD_SYMDEF_SIZE) 941 { 942 set->name = H_GET_32 (abfd, rbase) + stringbase; 943 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE); 944 } 945 946 ardata->first_file_filepos = bfd_tell (abfd); 947 /* Pad to an even boundary if you have to. */ 948 ardata->first_file_filepos += (ardata->first_file_filepos) % 2; 949 /* FIXME, we should provide some way to free raw_ardata when 950 we are done using the strings from it. For now, it seems 951 to be allocated on an objalloc anyway... */ 952 bfd_has_map (abfd) = TRUE; 953 return TRUE; 954 } 955 956 /* Read a COFF archive symbol table. Returns FALSE on error, TRUE 957 otherwise. */ 958 959 static bfd_boolean 960 do_slurp_coff_armap (bfd *abfd) 961 { 962 struct areltdata *mapdata; 963 int *raw_armap, *rawptr; 964 struct artdata *ardata = bfd_ardata (abfd); 965 char *stringbase; 966 bfd_size_type stringsize; 967 bfd_size_type parsed_size; 968 carsym *carsyms; 969 bfd_size_type nsymz; /* Number of symbols in armap. */ 970 bfd_vma (*swap) (const void *); 971 char int_buf[sizeof (long)]; 972 bfd_size_type carsym_size, ptrsize; 973 unsigned int i; 974 975 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); 976 if (mapdata == NULL) 977 return FALSE; 978 parsed_size = mapdata->parsed_size; 979 free (mapdata); 980 981 if (bfd_bread (int_buf, 4, abfd) != 4) 982 { 983 if (bfd_get_error () != bfd_error_system_call) 984 bfd_set_error (bfd_error_malformed_archive); 985 return FALSE; 986 } 987 /* It seems that all numeric information in a coff archive is always 988 in big endian format, nomatter the host or target. */ 989 swap = bfd_getb32; 990 nsymz = bfd_getb32 (int_buf); 991 stringsize = parsed_size - (4 * nsymz) - 4; 992 993 /* ... except that some archive formats are broken, and it may be our 994 fault - the i960 little endian coff sometimes has big and sometimes 995 little, because our tools changed. Here's a horrible hack to clean 996 up the crap. */ 997 998 if (stringsize > 0xfffff 999 && bfd_get_arch (abfd) == bfd_arch_i960 1000 && bfd_get_flavour (abfd) == bfd_target_coff_flavour) 1001 { 1002 /* This looks dangerous, let's do it the other way around. */ 1003 nsymz = bfd_getl32 (int_buf); 1004 stringsize = parsed_size - (4 * nsymz) - 4; 1005 swap = bfd_getl32; 1006 } 1007 1008 /* The coff armap must be read sequentially. So we construct a 1009 bsd-style one in core all at once, for simplicity. */ 1010 1011 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym)) 1012 return FALSE; 1013 1014 carsym_size = (nsymz * sizeof (carsym)); 1015 ptrsize = (4 * nsymz); 1016 1017 if (carsym_size + stringsize + 1 <= carsym_size) 1018 return FALSE; 1019 1020 ardata->symdefs = (struct carsym *) bfd_zalloc (abfd, 1021 carsym_size + stringsize + 1); 1022 if (ardata->symdefs == NULL) 1023 return FALSE; 1024 carsyms = ardata->symdefs; 1025 stringbase = ((char *) ardata->symdefs) + carsym_size; 1026 1027 /* Allocate and read in the raw offsets. */ 1028 raw_armap = (int *) bfd_alloc (abfd, ptrsize); 1029 if (raw_armap == NULL) 1030 goto release_symdefs; 1031 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize 1032 || (bfd_bread (stringbase, stringsize, abfd) != stringsize)) 1033 { 1034 if (bfd_get_error () != bfd_error_system_call) 1035 bfd_set_error (bfd_error_malformed_archive); 1036 goto release_raw_armap; 1037 } 1038 1039 /* OK, build the carsyms. */ 1040 for (i = 0; i < nsymz; i++) 1041 { 1042 rawptr = raw_armap + i; 1043 carsyms->file_offset = swap ((bfd_byte *) rawptr); 1044 carsyms->name = stringbase; 1045 stringbase += strlen (stringbase) + 1; 1046 carsyms++; 1047 } 1048 *stringbase = 0; 1049 1050 ardata->symdef_count = nsymz; 1051 ardata->first_file_filepos = bfd_tell (abfd); 1052 /* Pad to an even boundary if you have to. */ 1053 ardata->first_file_filepos += (ardata->first_file_filepos) % 2; 1054 1055 bfd_has_map (abfd) = TRUE; 1056 bfd_release (abfd, raw_armap); 1057 1058 /* Check for a second archive header (as used by PE). */ 1059 { 1060 struct areltdata *tmp; 1061 1062 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET); 1063 tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd); 1064 if (tmp != NULL) 1065 { 1066 if (tmp->arch_header[0] == '/' 1067 && tmp->arch_header[1] == ' ') 1068 { 1069 ardata->first_file_filepos += 1070 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1; 1071 } 1072 free (tmp); 1073 } 1074 } 1075 1076 return TRUE; 1077 1078 release_raw_armap: 1079 bfd_release (abfd, raw_armap); 1080 release_symdefs: 1081 bfd_release (abfd, (ardata)->symdefs); 1082 return FALSE; 1083 } 1084 1085 /* This routine can handle either coff-style or bsd-style armaps 1086 (archive symbol table). Returns FALSE on error, TRUE otherwise */ 1087 1088 bfd_boolean 1089 bfd_slurp_armap (bfd *abfd) 1090 { 1091 char nextname[17]; 1092 int i = bfd_bread (nextname, 16, abfd); 1093 1094 if (i == 0) 1095 return TRUE; 1096 if (i != 16) 1097 return FALSE; 1098 1099 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) 1100 return FALSE; 1101 1102 if (CONST_STRNEQ (nextname, "__.SYMDEF ") 1103 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */ 1104 return do_slurp_bsd_armap (abfd); 1105 else if (CONST_STRNEQ (nextname, "/ ")) 1106 return do_slurp_coff_armap (abfd); 1107 else if (CONST_STRNEQ (nextname, "/SYM64/ ")) 1108 { 1109 /* 64bit ELF (Irix 6) archive. */ 1110 #ifdef BFD64 1111 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *); 1112 return bfd_elf64_archive_slurp_armap (abfd); 1113 #else 1114 bfd_set_error (bfd_error_wrong_format); 1115 return FALSE; 1116 #endif 1117 } 1118 else if (CONST_STRNEQ (nextname, "#1/20 ")) 1119 { 1120 /* Mach-O has a special name for armap when the map is sorted by name. 1121 However because this name has a space it is slightly more difficult 1122 to check it. */ 1123 struct ar_hdr hdr; 1124 char extname[21]; 1125 1126 if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr)) 1127 return FALSE; 1128 /* Read the extended name. We know its length. */ 1129 if (bfd_bread (extname, 20, abfd) != 20) 1130 return FALSE; 1131 if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0) 1132 return FALSE; 1133 if (CONST_STRNEQ (extname, "__.SYMDEF SORTED") 1134 || CONST_STRNEQ (extname, "__.SYMDEF")) 1135 return do_slurp_bsd_armap (abfd); 1136 } 1137 1138 bfd_has_map (abfd) = FALSE; 1139 return TRUE; 1140 } 1141 1142 /* Returns FALSE on error, TRUE otherwise. */ 1143 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the 1144 header is in a slightly different order and the map name is '/'. 1145 This flavour is used by hp300hpux. */ 1146 1147 #define HPUX_SYMDEF_COUNT_SIZE 2 1148 1149 bfd_boolean 1150 bfd_slurp_bsd_armap_f2 (bfd *abfd) 1151 { 1152 struct areltdata *mapdata; 1153 char nextname[17]; 1154 unsigned int counter; 1155 bfd_byte *raw_armap, *rbase; 1156 struct artdata *ardata = bfd_ardata (abfd); 1157 char *stringbase; 1158 unsigned int stringsize; 1159 unsigned int left; 1160 bfd_size_type amt; 1161 carsym *set; 1162 int i = bfd_bread (nextname, 16, abfd); 1163 1164 if (i == 0) 1165 return TRUE; 1166 if (i != 16) 1167 return FALSE; 1168 1169 /* The archive has at least 16 bytes in it. */ 1170 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) 1171 return FALSE; 1172 1173 if (CONST_STRNEQ (nextname, "__.SYMDEF ") 1174 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */ 1175 return do_slurp_bsd_armap (abfd); 1176 1177 if (! CONST_STRNEQ (nextname, "/ ")) 1178 { 1179 bfd_has_map (abfd) = FALSE; 1180 return TRUE; 1181 } 1182 1183 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); 1184 if (mapdata == NULL) 1185 return FALSE; 1186 1187 if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE) 1188 { 1189 free (mapdata); 1190 wrong_format: 1191 bfd_set_error (bfd_error_wrong_format); 1192 byebye: 1193 return FALSE; 1194 } 1195 left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE; 1196 1197 amt = mapdata->parsed_size; 1198 free (mapdata); 1199 1200 raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt); 1201 if (raw_armap == NULL) 1202 goto byebye; 1203 1204 if (bfd_bread (raw_armap, amt, abfd) != amt) 1205 { 1206 if (bfd_get_error () != bfd_error_system_call) 1207 bfd_set_error (bfd_error_malformed_archive); 1208 goto byebye; 1209 } 1210 1211 ardata->symdef_count = H_GET_16 (abfd, raw_armap); 1212 1213 ardata->cache = 0; 1214 1215 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE); 1216 if (stringsize > left) 1217 goto wrong_format; 1218 left -= stringsize; 1219 1220 /* Skip sym count and string sz. */ 1221 stringbase = ((char *) raw_armap 1222 + HPUX_SYMDEF_COUNT_SIZE 1223 + BSD_STRING_COUNT_SIZE); 1224 rbase = (bfd_byte *) stringbase + stringsize; 1225 amt = ardata->symdef_count * BSD_SYMDEF_SIZE; 1226 if (amt > left) 1227 goto wrong_format; 1228 1229 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt); 1230 if (!ardata->symdefs) 1231 return FALSE; 1232 1233 for (counter = 0, set = ardata->symdefs; 1234 counter < ardata->symdef_count; 1235 counter++, set++, rbase += BSD_SYMDEF_SIZE) 1236 { 1237 set->name = H_GET_32 (abfd, rbase) + stringbase; 1238 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE); 1239 } 1240 1241 ardata->first_file_filepos = bfd_tell (abfd); 1242 /* Pad to an even boundary if you have to. */ 1243 ardata->first_file_filepos += (ardata->first_file_filepos) % 2; 1244 /* FIXME, we should provide some way to free raw_ardata when 1245 we are done using the strings from it. For now, it seems 1246 to be allocated on an objalloc anyway... */ 1247 bfd_has_map (abfd) = TRUE; 1248 return TRUE; 1249 } 1250 1251 /** Extended name table. 1252 1253 Normally archives support only 14-character filenames. 1254 1255 Intel has extended the format: longer names are stored in a special 1256 element (the first in the archive, or second if there is an armap); 1257 the name in the ar_hdr is replaced by <space><index into filename 1258 element>. Index is the P.R. of an int (decimal). Data General have 1259 extended the format by using the prefix // for the special element. */ 1260 1261 /* Returns FALSE on error, TRUE otherwise. */ 1262 1263 bfd_boolean 1264 _bfd_slurp_extended_name_table (bfd *abfd) 1265 { 1266 char nextname[17]; 1267 struct areltdata *namedata; 1268 bfd_size_type amt; 1269 1270 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ, 1271 we probably don't want to return TRUE. */ 1272 if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0) 1273 return FALSE; 1274 1275 if (bfd_bread (nextname, 16, abfd) == 16) 1276 { 1277 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) 1278 return FALSE; 1279 1280 if (! CONST_STRNEQ (nextname, "ARFILENAMES/ ") 1281 && ! CONST_STRNEQ (nextname, "// ")) 1282 { 1283 bfd_ardata (abfd)->extended_names = NULL; 1284 bfd_ardata (abfd)->extended_names_size = 0; 1285 return TRUE; 1286 } 1287 1288 namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd); 1289 if (namedata == NULL) 1290 return FALSE; 1291 1292 amt = namedata->parsed_size; 1293 if (amt + 1 == 0) 1294 goto byebye; 1295 1296 bfd_ardata (abfd)->extended_names_size = amt; 1297 bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1); 1298 if (bfd_ardata (abfd)->extended_names == NULL) 1299 { 1300 byebye: 1301 free (namedata); 1302 return FALSE; 1303 } 1304 1305 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt) 1306 { 1307 if (bfd_get_error () != bfd_error_system_call) 1308 bfd_set_error (bfd_error_malformed_archive); 1309 bfd_release (abfd, (bfd_ardata (abfd)->extended_names)); 1310 bfd_ardata (abfd)->extended_names = NULL; 1311 goto byebye; 1312 } 1313 1314 /* Since the archive is supposed to be printable if it contains 1315 text, the entries in the list are newline-padded, not null 1316 padded. In SVR4-style archives, the names also have a 1317 trailing '/'. DOS/NT created archive often have \ in them 1318 We'll fix all problems here.. */ 1319 { 1320 char *ext_names = bfd_ardata (abfd)->extended_names; 1321 char *temp = ext_names; 1322 char *limit = temp + namedata->parsed_size; 1323 for (; temp < limit; ++temp) 1324 { 1325 if (*temp == ARFMAG[1]) 1326 temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0'; 1327 if (*temp == '\\') 1328 *temp = '/'; 1329 } 1330 *limit = '\0'; 1331 } 1332 1333 /* Pad to an even boundary if you have to. */ 1334 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd); 1335 bfd_ardata (abfd)->first_file_filepos += 1336 (bfd_ardata (abfd)->first_file_filepos) % 2; 1337 1338 free (namedata); 1339 } 1340 return TRUE; 1341 } 1342 1343 #ifdef VMS 1344 1345 /* Return a copy of the stuff in the filename between any :]> and a 1346 semicolon. */ 1347 1348 static const char * 1349 normalize (bfd *abfd, const char *file) 1350 { 1351 const char *first; 1352 const char *last; 1353 char *copy; 1354 1355 first = file + strlen (file) - 1; 1356 last = first + 1; 1357 1358 while (first != file) 1359 { 1360 if (*first == ';') 1361 last = first; 1362 if (*first == ':' || *first == ']' || *first == '>') 1363 { 1364 first++; 1365 break; 1366 } 1367 first--; 1368 } 1369 1370 copy = bfd_alloc (abfd, last - first + 1); 1371 if (copy == NULL) 1372 return NULL; 1373 1374 memcpy (copy, first, last - first); 1375 copy[last - first] = 0; 1376 1377 return copy; 1378 } 1379 1380 #else 1381 static const char * 1382 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file) 1383 { 1384 return lbasename (file); 1385 } 1386 #endif 1387 1388 /* Adjust a relative path name based on the reference path. 1389 For example: 1390 1391 Relative path Reference path Result 1392 ------------- -------------- ------ 1393 bar.o lib.a bar.o 1394 foo/bar.o lib.a foo/bar.o 1395 bar.o foo/lib.a ../bar.o 1396 foo/bar.o baz/lib.a ../foo/bar.o 1397 bar.o ../lib.a <parent of current dir>/bar.o 1398 ; ../bar.o ../lib.a bar.o 1399 ; ../bar.o lib.a ../bar.o 1400 foo/bar.o ../lib.a <parent of current dir>/foo/bar.o 1401 bar.o ../../lib.a <grandparent>/<parent>/bar.o 1402 bar.o foo/baz/lib.a ../../bar.o 1403 1404 Note - the semicolons above are there to prevent the BFD chew 1405 utility from interpreting those lines as prototypes to put into 1406 the autogenerated bfd.h header... 1407 1408 Note - the string is returned in a static buffer. */ 1409 1410 static const char * 1411 adjust_relative_path (const char * path, const char * ref_path) 1412 { 1413 static char *pathbuf = NULL; 1414 static unsigned int pathbuf_len = 0; 1415 const char *pathp; 1416 const char *refp; 1417 char * lpath; 1418 char * rpath; 1419 unsigned int len; 1420 unsigned int dir_up = 0; 1421 unsigned int dir_down = 0; 1422 char *newp; 1423 char * pwd = getpwd (); 1424 const char * down; 1425 1426 /* Remove symlinks, '.' and '..' from the paths, if possible. */ 1427 lpath = lrealpath (path); 1428 pathp = lpath == NULL ? path : lpath; 1429 1430 rpath = lrealpath (ref_path); 1431 refp = rpath == NULL ? ref_path : rpath; 1432 1433 /* Remove common leading path elements. */ 1434 for (;;) 1435 { 1436 const char *e1 = pathp; 1437 const char *e2 = refp; 1438 1439 while (*e1 && ! IS_DIR_SEPARATOR (*e1)) 1440 ++e1; 1441 while (*e2 && ! IS_DIR_SEPARATOR (*e2)) 1442 ++e2; 1443 if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp 1444 || filename_ncmp (pathp, refp, e1 - pathp) != 0) 1445 break; 1446 pathp = e1 + 1; 1447 refp = e2 + 1; 1448 } 1449 1450 len = strlen (pathp) + 1; 1451 /* For each leading path element in the reference path, 1452 insert "../" into the path. */ 1453 for (; *refp; ++refp) 1454 if (IS_DIR_SEPARATOR (*refp)) 1455 { 1456 /* PR 12710: If the path element is "../" then instead of 1457 inserting "../" we need to insert the name of the directory 1458 at the current level. */ 1459 if (refp > ref_path + 1 1460 && refp[-1] == '.' 1461 && refp[-2] == '.') 1462 dir_down ++; 1463 else 1464 dir_up ++; 1465 } 1466 1467 /* If the lrealpath calls above succeeded then we should never 1468 see dir_up and dir_down both being non-zero. */ 1469 1470 len += 3 * dir_up; 1471 1472 if (dir_down) 1473 { 1474 down = pwd + strlen (pwd) - 1; 1475 1476 while (dir_down && down > pwd) 1477 { 1478 if (IS_DIR_SEPARATOR (*down)) 1479 --dir_down; 1480 } 1481 BFD_ASSERT (dir_down == 0); 1482 len += strlen (down) + 1; 1483 } 1484 else 1485 down = NULL; 1486 1487 if (len > pathbuf_len) 1488 { 1489 if (pathbuf != NULL) 1490 free (pathbuf); 1491 pathbuf_len = 0; 1492 pathbuf = (char *) bfd_malloc (len); 1493 if (pathbuf == NULL) 1494 goto out; 1495 pathbuf_len = len; 1496 } 1497 1498 newp = pathbuf; 1499 while (dir_up-- > 0) 1500 { 1501 /* FIXME: Support Windows style path separators as well. */ 1502 strcpy (newp, "../"); 1503 newp += 3; 1504 } 1505 1506 if (down) 1507 sprintf (newp, "%s/%s", down, pathp); 1508 else 1509 strcpy (newp, pathp); 1510 1511 out: 1512 free (lpath); 1513 free (rpath); 1514 return pathbuf; 1515 } 1516 1517 /* Build a BFD style extended name table. */ 1518 1519 bfd_boolean 1520 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd, 1521 char **tabloc, 1522 bfd_size_type *tablen, 1523 const char **name) 1524 { 1525 *name = "ARFILENAMES/"; 1526 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen); 1527 } 1528 1529 /* Build an SVR4 style extended name table. */ 1530 1531 bfd_boolean 1532 _bfd_archive_coff_construct_extended_name_table (bfd *abfd, 1533 char **tabloc, 1534 bfd_size_type *tablen, 1535 const char **name) 1536 { 1537 *name = "//"; 1538 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen); 1539 } 1540 1541 /* Follows archive_head and produces an extended name table if 1542 necessary. Returns (in tabloc) a pointer to an extended name 1543 table, and in tablen the length of the table. If it makes an entry 1544 it clobbers the filename so that the element may be written without 1545 further massage. Returns TRUE if it ran successfully, FALSE if 1546 something went wrong. A successful return may still involve a 1547 zero-length tablen! */ 1548 1549 bfd_boolean 1550 _bfd_construct_extended_name_table (bfd *abfd, 1551 bfd_boolean trailing_slash, 1552 char **tabloc, 1553 bfd_size_type *tablen) 1554 { 1555 unsigned int maxname = ar_maxnamelen (abfd); 1556 bfd_size_type total_namelen = 0; 1557 bfd *current; 1558 char *strptr; 1559 const char *last_filename; 1560 long last_stroff; 1561 1562 *tablen = 0; 1563 last_filename = NULL; 1564 1565 /* Figure out how long the table should be. */ 1566 for (current = abfd->archive_head; 1567 current != NULL; 1568 current = current->archive_next) 1569 { 1570 const char *normal; 1571 unsigned int thislen; 1572 1573 if (bfd_is_thin_archive (abfd)) 1574 { 1575 const char *filename = current->filename; 1576 1577 /* If the element being added is a member of another archive 1578 (i.e., we are flattening), use the containing archive's name. */ 1579 if (current->my_archive 1580 && ! bfd_is_thin_archive (current->my_archive)) 1581 filename = current->my_archive->filename; 1582 1583 /* If the path is the same as the previous path seen, 1584 reuse it. This can happen when flattening a thin 1585 archive that contains other archives. */ 1586 if (last_filename && filename_cmp (last_filename, filename) == 0) 1587 continue; 1588 1589 last_filename = filename; 1590 1591 /* If the path is relative, adjust it relative to 1592 the containing archive. */ 1593 if (! IS_ABSOLUTE_PATH (filename) 1594 && ! IS_ABSOLUTE_PATH (abfd->filename)) 1595 normal = adjust_relative_path (filename, abfd->filename); 1596 else 1597 normal = filename; 1598 1599 /* In a thin archive, always store the full pathname 1600 in the extended name table. */ 1601 total_namelen += strlen (normal) + 1; 1602 if (trailing_slash) 1603 /* Leave room for trailing slash. */ 1604 ++total_namelen; 1605 1606 continue; 1607 } 1608 1609 normal = normalize (current, current->filename); 1610 if (normal == NULL) 1611 return FALSE; 1612 1613 thislen = strlen (normal); 1614 1615 if (thislen > maxname 1616 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0) 1617 thislen = maxname; 1618 1619 if (thislen > maxname) 1620 { 1621 /* Add one to leave room for \n. */ 1622 total_namelen += thislen + 1; 1623 if (trailing_slash) 1624 { 1625 /* Leave room for trailing slash. */ 1626 ++total_namelen; 1627 } 1628 } 1629 else 1630 { 1631 struct ar_hdr *hdr = arch_hdr (current); 1632 if (filename_ncmp (normal, hdr->ar_name, thislen) != 0 1633 || (thislen < sizeof hdr->ar_name 1634 && hdr->ar_name[thislen] != ar_padchar (current))) 1635 { 1636 /* Must have been using extended format even though it 1637 didn't need to. Fix it to use normal format. */ 1638 memcpy (hdr->ar_name, normal, thislen); 1639 if (thislen < maxname 1640 || (thislen == maxname && thislen < sizeof hdr->ar_name)) 1641 hdr->ar_name[thislen] = ar_padchar (current); 1642 } 1643 } 1644 } 1645 1646 if (total_namelen == 0) 1647 return TRUE; 1648 1649 *tabloc = (char *) bfd_zalloc (abfd, total_namelen); 1650 if (*tabloc == NULL) 1651 return FALSE; 1652 1653 *tablen = total_namelen; 1654 strptr = *tabloc; 1655 1656 last_filename = NULL; 1657 last_stroff = 0; 1658 1659 for (current = abfd->archive_head; 1660 current != NULL; 1661 current = current->archive_next) 1662 { 1663 const char *normal; 1664 unsigned int thislen; 1665 long stroff; 1666 const char *filename = current->filename; 1667 1668 if (bfd_is_thin_archive (abfd)) 1669 { 1670 /* If the element being added is a member of another archive 1671 (i.e., we are flattening), use the containing archive's name. */ 1672 if (current->my_archive 1673 && ! bfd_is_thin_archive (current->my_archive)) 1674 filename = current->my_archive->filename; 1675 /* If the path is the same as the previous path seen, 1676 reuse it. This can happen when flattening a thin 1677 archive that contains other archives. 1678 If the path is relative, adjust it relative to 1679 the containing archive. */ 1680 if (last_filename && filename_cmp (last_filename, filename) == 0) 1681 normal = last_filename; 1682 else if (! IS_ABSOLUTE_PATH (filename) 1683 && ! IS_ABSOLUTE_PATH (abfd->filename)) 1684 normal = adjust_relative_path (filename, abfd->filename); 1685 else 1686 normal = filename; 1687 } 1688 else 1689 { 1690 normal = normalize (current, filename); 1691 if (normal == NULL) 1692 return FALSE; 1693 } 1694 1695 thislen = strlen (normal); 1696 if (thislen > maxname || bfd_is_thin_archive (abfd)) 1697 { 1698 /* Works for now; may need to be re-engineered if we 1699 encounter an oddball archive format and want to 1700 generalise this hack. */ 1701 struct ar_hdr *hdr = arch_hdr (current); 1702 if (normal == last_filename) 1703 stroff = last_stroff; 1704 else 1705 { 1706 strcpy (strptr, normal); 1707 if (! trailing_slash) 1708 strptr[thislen] = ARFMAG[1]; 1709 else 1710 { 1711 strptr[thislen] = '/'; 1712 strptr[thislen + 1] = ARFMAG[1]; 1713 } 1714 stroff = strptr - *tabloc; 1715 last_stroff = stroff; 1716 } 1717 hdr->ar_name[0] = ar_padchar (current); 1718 if (bfd_is_thin_archive (abfd) && current->origin > 0) 1719 { 1720 int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:", 1721 stroff); 1722 _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len, 1723 "%-ld", 1724 current->origin - sizeof (struct ar_hdr)); 1725 } 1726 else 1727 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff); 1728 if (normal != last_filename) 1729 { 1730 strptr += thislen + 1; 1731 if (trailing_slash) 1732 ++strptr; 1733 last_filename = filename; 1734 } 1735 } 1736 } 1737 1738 return TRUE; 1739 } 1740 1741 /* Do not construct an extended name table but transforms name field into 1742 its extended form. */ 1743 1744 bfd_boolean 1745 _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd, 1746 char **tabloc, 1747 bfd_size_type *tablen, 1748 const char **name) 1749 { 1750 unsigned int maxname = ar_maxnamelen (abfd); 1751 bfd *current; 1752 1753 *tablen = 0; 1754 *tabloc = NULL; 1755 *name = NULL; 1756 1757 for (current = abfd->archive_head; 1758 current != NULL; 1759 current = current->archive_next) 1760 { 1761 const char *normal = normalize (current, current->filename); 1762 int has_space = 0; 1763 unsigned int len; 1764 1765 if (normal == NULL) 1766 return FALSE; 1767 1768 for (len = 0; normal[len]; len++) 1769 if (normal[len] == ' ') 1770 has_space = 1; 1771 1772 if (len > maxname || has_space) 1773 { 1774 struct ar_hdr *hdr = arch_hdr (current); 1775 1776 len = (len + 3) & ~3; 1777 arch_eltdata (current)->extra_size = len; 1778 _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len); 1779 } 1780 } 1781 1782 return TRUE; 1783 } 1784 1785 /* Write an archive header. */ 1786 1787 bfd_boolean 1788 _bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd) 1789 { 1790 struct ar_hdr *hdr = arch_hdr (abfd); 1791 1792 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr)) 1793 return FALSE; 1794 return TRUE; 1795 } 1796 1797 /* Write an archive header using BSD4.4 convention. */ 1798 1799 bfd_boolean 1800 _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd) 1801 { 1802 struct ar_hdr *hdr = arch_hdr (abfd); 1803 1804 if (is_bsd44_extended_name (hdr->ar_name)) 1805 { 1806 /* This is a BSD 4.4 extended name. */ 1807 const char *fullname = normalize (abfd, abfd->filename); 1808 unsigned int len = strlen (fullname); 1809 unsigned int padded_len = (len + 3) & ~3; 1810 1811 BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size); 1812 1813 if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), 1814 arch_eltdata (abfd)->parsed_size + padded_len)) 1815 return FALSE; 1816 1817 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr)) 1818 return FALSE; 1819 1820 if (bfd_bwrite (fullname, len, archive) != len) 1821 return FALSE; 1822 1823 if (len & 3) 1824 { 1825 static const char pad[3] = { 0, 0, 0 }; 1826 1827 len = 4 - (len & 3); 1828 if (bfd_bwrite (pad, len, archive) != len) 1829 return FALSE; 1830 } 1831 } 1832 else 1833 { 1834 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr)) 1835 return FALSE; 1836 } 1837 return TRUE; 1838 } 1839 1840 /* A couple of functions for creating ar_hdrs. */ 1841 1842 #ifdef HPUX_LARGE_AR_IDS 1843 /* Function to encode large UID/GID values according to HP. */ 1844 1845 static void 1846 hpux_uid_gid_encode (char str[6], long int id) 1847 { 1848 int cnt; 1849 1850 str[5] = '@' + (id & 3); 1851 id >>= 2; 1852 1853 for (cnt = 4; cnt >= 0; --cnt, id >>= 6) 1854 str[cnt] = ' ' + (id & 0x3f); 1855 } 1856 #endif /* HPUX_LARGE_AR_IDS */ 1857 1858 #ifndef HAVE_GETUID 1859 #define getuid() 0 1860 #endif 1861 1862 #ifndef HAVE_GETGID 1863 #define getgid() 0 1864 #endif 1865 1866 /* Takes a filename, returns an arelt_data for it, or NULL if it can't 1867 make one. The filename must refer to a filename in the filesystem. 1868 The filename field of the ar_hdr will NOT be initialized. If member 1869 is set, and it's an in-memory bfd, we fake it. */ 1870 1871 static struct areltdata * 1872 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member) 1873 { 1874 struct stat status; 1875 struct areltdata *ared; 1876 struct ar_hdr *hdr; 1877 bfd_size_type amt; 1878 1879 if (member && (member->flags & BFD_IN_MEMORY) != 0) 1880 { 1881 /* Assume we just "made" the member, and fake it. */ 1882 struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream; 1883 time (&status.st_mtime); 1884 status.st_uid = getuid (); 1885 status.st_gid = getgid (); 1886 status.st_mode = 0644; 1887 status.st_size = bim->size; 1888 } 1889 else if (stat (filename, &status) != 0) 1890 { 1891 bfd_set_error (bfd_error_system_call); 1892 return NULL; 1893 } 1894 1895 /* If the caller requested that the BFD generate deterministic output, 1896 fake values for modification time, UID, GID, and file mode. */ 1897 if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0) 1898 { 1899 status.st_mtime = 0; 1900 status.st_uid = 0; 1901 status.st_gid = 0; 1902 status.st_mode = 0644; 1903 } 1904 1905 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata); 1906 ared = (struct areltdata *) bfd_zmalloc (amt); 1907 if (ared == NULL) 1908 return NULL; 1909 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata)); 1910 1911 /* ar headers are space padded, not null padded! */ 1912 memset (hdr, ' ', sizeof (struct ar_hdr)); 1913 1914 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld", 1915 status.st_mtime); 1916 #ifdef HPUX_LARGE_AR_IDS 1917 /* HP has a very "special" way to handle UID/GID's with numeric values 1918 > 99999. */ 1919 if (status.st_uid > 99999) 1920 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid); 1921 else 1922 #endif 1923 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld", 1924 status.st_uid); 1925 #ifdef HPUX_LARGE_AR_IDS 1926 /* HP has a very "special" way to handle UID/GID's with numeric values 1927 > 99999. */ 1928 if (status.st_gid > 99999) 1929 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid); 1930 else 1931 #endif 1932 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld", 1933 status.st_gid); 1934 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo", 1935 status.st_mode); 1936 if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size)) 1937 { 1938 free (ared); 1939 return NULL; 1940 } 1941 memcpy (hdr->ar_fmag, ARFMAG, 2); 1942 ared->parsed_size = status.st_size; 1943 ared->arch_header = (char *) hdr; 1944 1945 return ared; 1946 } 1947 1948 /* Analogous to stat call. */ 1949 1950 int 1951 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf) 1952 { 1953 struct ar_hdr *hdr; 1954 char *aloser; 1955 1956 if (abfd->arelt_data == NULL) 1957 { 1958 bfd_set_error (bfd_error_invalid_operation); 1959 return -1; 1960 } 1961 1962 hdr = arch_hdr (abfd); 1963 1964 #define foo(arelt, stelt, size) \ 1965 buf->stelt = strtol (hdr->arelt, &aloser, size); \ 1966 if (aloser == hdr->arelt) \ 1967 return -1; 1968 1969 /* Some platforms support special notations for large IDs. */ 1970 #ifdef HPUX_LARGE_AR_IDS 1971 # define foo2(arelt, stelt, size) \ 1972 if (hdr->arelt[5] == ' ') \ 1973 { \ 1974 foo (arelt, stelt, size); \ 1975 } \ 1976 else \ 1977 { \ 1978 int cnt; \ 1979 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \ 1980 { \ 1981 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \ 1982 return -1; \ 1983 buf->stelt <<= 6; \ 1984 buf->stelt += hdr->arelt[cnt] - ' '; \ 1985 } \ 1986 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \ 1987 return -1; \ 1988 buf->stelt <<= 2; \ 1989 buf->stelt += hdr->arelt[5] - '@'; \ 1990 } 1991 #else 1992 # define foo2(arelt, stelt, size) foo (arelt, stelt, size) 1993 #endif 1994 1995 foo (ar_date, st_mtime, 10); 1996 foo2 (ar_uid, st_uid, 10); 1997 foo2 (ar_gid, st_gid, 10); 1998 foo (ar_mode, st_mode, 8); 1999 2000 buf->st_size = arch_eltdata (abfd)->parsed_size; 2001 2002 return 0; 2003 } 2004 2005 void 2006 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) 2007 { 2008 /* FIXME: This interacts unpleasantly with ar's quick-append option. 2009 Fortunately ic960 users will never use that option. Fixing this 2010 is very hard; fortunately I know how to do it and will do so once 2011 intel's release is out the door. */ 2012 2013 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 2014 size_t length; 2015 const char *filename; 2016 size_t maxlen = ar_maxnamelen (abfd); 2017 2018 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0) 2019 { 2020 bfd_bsd_truncate_arname (abfd, pathname, arhdr); 2021 return; 2022 } 2023 2024 filename = normalize (abfd, pathname); 2025 if (filename == NULL) 2026 { 2027 /* FIXME */ 2028 abort (); 2029 } 2030 2031 length = strlen (filename); 2032 2033 if (length <= maxlen) 2034 memcpy (hdr->ar_name, filename, length); 2035 2036 /* Add the padding character if there is room for it. */ 2037 if (length < maxlen 2038 || (length == maxlen && length < sizeof hdr->ar_name)) 2039 (hdr->ar_name)[length] = ar_padchar (abfd); 2040 } 2041 2042 void 2043 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) 2044 { 2045 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 2046 size_t length; 2047 const char *filename = lbasename (pathname); 2048 size_t maxlen = ar_maxnamelen (abfd); 2049 2050 length = strlen (filename); 2051 2052 if (length <= maxlen) 2053 memcpy (hdr->ar_name, filename, length); 2054 else 2055 { 2056 /* pathname: meet procrustes */ 2057 memcpy (hdr->ar_name, filename, maxlen); 2058 length = maxlen; 2059 } 2060 2061 if (length < maxlen) 2062 (hdr->ar_name)[length] = ar_padchar (abfd); 2063 } 2064 2065 /* Store name into ar header. Truncates the name to fit. 2066 1> strip pathname to be just the basename. 2067 2> if it's short enuf to fit, stuff it in. 2068 3> If it doesn't end with .o, truncate it to fit 2069 4> truncate it before the .o, append .o, stuff THAT in. */ 2070 2071 /* This is what gnu ar does. It's better but incompatible with the 2072 bsd ar. */ 2073 2074 void 2075 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) 2076 { 2077 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 2078 size_t length; 2079 const char *filename = lbasename (pathname); 2080 size_t maxlen = ar_maxnamelen (abfd); 2081 2082 length = strlen (filename); 2083 2084 if (length <= maxlen) 2085 memcpy (hdr->ar_name, filename, length); 2086 else 2087 { 2088 /* pathname: meet procrustes. */ 2089 memcpy (hdr->ar_name, filename, maxlen); 2090 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o')) 2091 { 2092 hdr->ar_name[maxlen - 2] = '.'; 2093 hdr->ar_name[maxlen - 1] = 'o'; 2094 } 2095 length = maxlen; 2096 } 2097 2098 if (length < 16) 2099 (hdr->ar_name)[length] = ar_padchar (abfd); 2100 } 2101 2102 /* The BFD is open for write and has its format set to bfd_archive. */ 2103 2104 bfd_boolean 2105 _bfd_write_archive_contents (bfd *arch) 2106 { 2107 bfd *current; 2108 char *etable = NULL; 2109 bfd_size_type elength = 0; 2110 const char *ename = NULL; 2111 bfd_boolean makemap = bfd_has_map (arch); 2112 /* If no .o's, don't bother to make a map. */ 2113 bfd_boolean hasobjects = FALSE; 2114 bfd_size_type wrote; 2115 int tries; 2116 char *armag; 2117 2118 /* Verify the viability of all entries; if any of them live in the 2119 filesystem (as opposed to living in an archive open for input) 2120 then construct a fresh ar_hdr for them. */ 2121 for (current = arch->archive_head; 2122 current != NULL; 2123 current = current->archive_next) 2124 { 2125 /* This check is checking the bfds for the objects we're reading 2126 from (which are usually either an object file or archive on 2127 disk), not the archive entries we're writing to. We don't 2128 actually create bfds for the archive members, we just copy 2129 them byte-wise when we write out the archive. */ 2130 if (bfd_write_p (current)) 2131 { 2132 bfd_set_error (bfd_error_invalid_operation); 2133 goto input_err; 2134 } 2135 if (!current->arelt_data) 2136 { 2137 current->arelt_data = 2138 bfd_ar_hdr_from_filesystem (arch, current->filename, current); 2139 if (!current->arelt_data) 2140 goto input_err; 2141 2142 /* Put in the file name. */ 2143 BFD_SEND (arch, _bfd_truncate_arname, 2144 (arch, current->filename, (char *) arch_hdr (current))); 2145 } 2146 2147 if (makemap && ! hasobjects) 2148 { /* Don't bother if we won't make a map! */ 2149 if ((bfd_check_format (current, bfd_object))) 2150 hasobjects = TRUE; 2151 } 2152 } 2153 2154 if (!BFD_SEND (arch, _bfd_construct_extended_name_table, 2155 (arch, &etable, &elength, &ename))) 2156 return FALSE; 2157 2158 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0) 2159 return FALSE; 2160 armag = ARMAG; 2161 if (bfd_is_thin_archive (arch)) 2162 armag = ARMAGT; 2163 wrote = bfd_bwrite (armag, SARMAG, arch); 2164 if (wrote != SARMAG) 2165 return FALSE; 2166 2167 if (makemap && hasobjects) 2168 { 2169 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength)) 2170 return FALSE; 2171 } 2172 2173 if (elength != 0) 2174 { 2175 struct ar_hdr hdr; 2176 2177 memset (&hdr, ' ', sizeof (struct ar_hdr)); 2178 memcpy (hdr.ar_name, ename, strlen (ename)); 2179 /* Round size up to even number in archive header. */ 2180 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), 2181 (elength + 1) & ~(bfd_size_type) 1)) 2182 return FALSE; 2183 memcpy (hdr.ar_fmag, ARFMAG, 2); 2184 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) 2185 != sizeof (struct ar_hdr)) 2186 || bfd_bwrite (etable, elength, arch) != elength) 2187 return FALSE; 2188 if ((elength % 2) == 1) 2189 { 2190 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1) 2191 return FALSE; 2192 } 2193 } 2194 2195 for (current = arch->archive_head; 2196 current != NULL; 2197 current = current->archive_next) 2198 { 2199 char buffer[DEFAULT_BUFFERSIZE]; 2200 bfd_size_type remaining = arelt_size (current); 2201 2202 /* Write ar header. */ 2203 if (!_bfd_write_ar_hdr (arch, current)) 2204 return FALSE; 2205 if (bfd_is_thin_archive (arch)) 2206 continue; 2207 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0) 2208 goto input_err; 2209 2210 while (remaining) 2211 { 2212 unsigned int amt = DEFAULT_BUFFERSIZE; 2213 2214 if (amt > remaining) 2215 amt = remaining; 2216 errno = 0; 2217 if (bfd_bread (buffer, amt, current) != amt) 2218 { 2219 if (bfd_get_error () != bfd_error_system_call) 2220 bfd_set_error (bfd_error_file_truncated); 2221 goto input_err; 2222 } 2223 if (bfd_bwrite (buffer, amt, arch) != amt) 2224 return FALSE; 2225 remaining -= amt; 2226 } 2227 2228 if ((arelt_size (current) % 2) == 1) 2229 { 2230 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1) 2231 return FALSE; 2232 } 2233 } 2234 2235 if (makemap && hasobjects) 2236 { 2237 /* Verify the timestamp in the archive file. If it would not be 2238 accepted by the linker, rewrite it until it would be. If 2239 anything odd happens, break out and just return. (The 2240 Berkeley linker checks the timestamp and refuses to read the 2241 table-of-contents if it is >60 seconds less than the file's 2242 modified-time. That painful hack requires this painful hack. */ 2243 tries = 1; 2244 do 2245 { 2246 if (bfd_update_armap_timestamp (arch)) 2247 break; 2248 (*_bfd_error_handler) 2249 (_("Warning: writing archive was slow: rewriting timestamp\n")); 2250 } 2251 while (++tries < 6); 2252 } 2253 2254 return TRUE; 2255 2256 input_err: 2257 bfd_set_error (bfd_error_on_input, current, bfd_get_error ()); 2258 return FALSE; 2259 } 2260 2261 /* Note that the namidx for the first symbol is 0. */ 2262 2263 bfd_boolean 2264 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength) 2265 { 2266 char *first_name = NULL; 2267 bfd *current; 2268 file_ptr elt_no = 0; 2269 struct orl *map = NULL; 2270 unsigned int orl_max = 1024; /* Fine initial default. */ 2271 unsigned int orl_count = 0; 2272 int stridx = 0; 2273 asymbol **syms = NULL; 2274 long syms_max = 0; 2275 bfd_boolean ret; 2276 bfd_size_type amt; 2277 2278 /* Dunno if this is the best place for this info... */ 2279 if (elength != 0) 2280 elength += sizeof (struct ar_hdr); 2281 elength += elength % 2; 2282 2283 amt = orl_max * sizeof (struct orl); 2284 map = (struct orl *) bfd_malloc (amt); 2285 if (map == NULL) 2286 goto error_return; 2287 2288 /* We put the symbol names on the arch objalloc, and then discard 2289 them when done. */ 2290 first_name = (char *) bfd_alloc (arch, 1); 2291 if (first_name == NULL) 2292 goto error_return; 2293 2294 /* Drop all the files called __.SYMDEF, we're going to make our own. */ 2295 while (arch->archive_head 2296 && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0) 2297 arch->archive_head = arch->archive_head->archive_next; 2298 2299 /* Map over each element. */ 2300 for (current = arch->archive_head; 2301 current != NULL; 2302 current = current->archive_next, elt_no++) 2303 { 2304 if (bfd_check_format (current, bfd_object) 2305 && (bfd_get_file_flags (current) & HAS_SYMS) != 0) 2306 { 2307 long storage; 2308 long symcount; 2309 long src_count; 2310 2311 storage = bfd_get_symtab_upper_bound (current); 2312 if (storage < 0) 2313 goto error_return; 2314 2315 if (storage != 0) 2316 { 2317 if (storage > syms_max) 2318 { 2319 if (syms_max > 0) 2320 free (syms); 2321 syms_max = storage; 2322 syms = (asymbol **) bfd_malloc (syms_max); 2323 if (syms == NULL) 2324 goto error_return; 2325 } 2326 symcount = bfd_canonicalize_symtab (current, syms); 2327 if (symcount < 0) 2328 goto error_return; 2329 2330 /* Now map over all the symbols, picking out the ones we 2331 want. */ 2332 for (src_count = 0; src_count < symcount; src_count++) 2333 { 2334 flagword flags = (syms[src_count])->flags; 2335 asection *sec = syms[src_count]->section; 2336 2337 if (((flags & (BSF_GLOBAL 2338 | BSF_WEAK 2339 | BSF_INDIRECT 2340 | BSF_GNU_UNIQUE)) != 0 2341 || bfd_is_com_section (sec)) 2342 && ! bfd_is_und_section (sec)) 2343 { 2344 bfd_size_type namelen; 2345 struct orl *new_map; 2346 2347 /* This symbol will go into the archive header. */ 2348 if (orl_count == orl_max) 2349 { 2350 orl_max *= 2; 2351 amt = orl_max * sizeof (struct orl); 2352 new_map = (struct orl *) bfd_realloc (map, amt); 2353 if (new_map == NULL) 2354 goto error_return; 2355 2356 map = new_map; 2357 } 2358 2359 namelen = strlen (syms[src_count]->name); 2360 amt = sizeof (char *); 2361 map[orl_count].name = (char **) bfd_alloc (arch, amt); 2362 if (map[orl_count].name == NULL) 2363 goto error_return; 2364 *(map[orl_count].name) = (char *) bfd_alloc (arch, 2365 namelen + 1); 2366 if (*(map[orl_count].name) == NULL) 2367 goto error_return; 2368 strcpy (*(map[orl_count].name), syms[src_count]->name); 2369 map[orl_count].u.abfd = current; 2370 map[orl_count].namidx = stridx; 2371 2372 stridx += namelen + 1; 2373 ++orl_count; 2374 } 2375 } 2376 } 2377 2378 /* Now ask the BFD to free up any cached information, so we 2379 don't fill all of memory with symbol tables. */ 2380 if (! bfd_free_cached_info (current)) 2381 goto error_return; 2382 } 2383 } 2384 2385 /* OK, now we have collected all the data, let's write them out. */ 2386 ret = BFD_SEND (arch, write_armap, 2387 (arch, elength, map, orl_count, stridx)); 2388 2389 if (syms_max > 0) 2390 free (syms); 2391 if (map != NULL) 2392 free (map); 2393 if (first_name != NULL) 2394 bfd_release (arch, first_name); 2395 2396 return ret; 2397 2398 error_return: 2399 if (syms_max > 0) 2400 free (syms); 2401 if (map != NULL) 2402 free (map); 2403 if (first_name != NULL) 2404 bfd_release (arch, first_name); 2405 2406 return FALSE; 2407 } 2408 2409 bfd_boolean 2410 bsd_write_armap (bfd *arch, 2411 unsigned int elength, 2412 struct orl *map, 2413 unsigned int orl_count, 2414 int stridx) 2415 { 2416 int padit = stridx & 1; 2417 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE; 2418 unsigned int stringsize = stridx + padit; 2419 /* Include 8 bytes to store ranlibsize and stringsize in output. */ 2420 unsigned int mapsize = ranlibsize + stringsize + 8; 2421 file_ptr firstreal; 2422 bfd *current = arch->archive_head; 2423 bfd *last_elt = current; /* Last element arch seen. */ 2424 bfd_byte temp[4]; 2425 unsigned int count; 2426 struct ar_hdr hdr; 2427 long uid, gid; 2428 2429 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG; 2430 2431 /* If deterministic, we use 0 as the timestamp in the map. 2432 Some linkers may require that the archive filesystem modification 2433 time is less than (or near to) the archive map timestamp. Those 2434 linkers should not be used with deterministic mode. (GNU ld and 2435 Gold do not have this restriction.) */ 2436 bfd_ardata (arch)->armap_timestamp = 0; 2437 uid = 0; 2438 gid = 0; 2439 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0) 2440 { 2441 struct stat statbuf; 2442 2443 if (stat (arch->filename, &statbuf) == 0) 2444 bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime 2445 + ARMAP_TIME_OFFSET); 2446 uid = getuid(); 2447 gid = getgid(); 2448 } 2449 2450 memset (&hdr, ' ', sizeof (struct ar_hdr)); 2451 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG)); 2452 bfd_ardata (arch)->armap_datepos = (SARMAG 2453 + offsetof (struct ar_hdr, ar_date[0])); 2454 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 2455 bfd_ardata (arch)->armap_timestamp); 2456 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid); 2457 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid); 2458 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize)) 2459 return FALSE; 2460 memcpy (hdr.ar_fmag, ARFMAG, 2); 2461 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) 2462 != sizeof (struct ar_hdr)) 2463 return FALSE; 2464 H_PUT_32 (arch, ranlibsize, temp); 2465 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp)) 2466 return FALSE; 2467 2468 for (count = 0; count < orl_count; count++) 2469 { 2470 unsigned int offset; 2471 bfd_byte buf[BSD_SYMDEF_SIZE]; 2472 2473 if (map[count].u.abfd != last_elt) 2474 { 2475 do 2476 { 2477 struct areltdata *ared = arch_eltdata (current); 2478 2479 firstreal += (ared->parsed_size + ared->extra_size 2480 + sizeof (struct ar_hdr)); 2481 firstreal += firstreal % 2; 2482 current = current->archive_next; 2483 } 2484 while (current != map[count].u.abfd); 2485 } 2486 2487 /* The archive file format only has 4 bytes to store the offset 2488 of the member. Check to make sure that firstreal has not grown 2489 too big. */ 2490 offset = (unsigned int) firstreal; 2491 if (firstreal != (file_ptr) offset) 2492 { 2493 bfd_set_error (bfd_error_file_truncated); 2494 return FALSE; 2495 } 2496 2497 last_elt = current; 2498 H_PUT_32 (arch, map[count].namidx, buf); 2499 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE); 2500 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch) 2501 != BSD_SYMDEF_SIZE) 2502 return FALSE; 2503 } 2504 2505 /* Now write the strings themselves. */ 2506 H_PUT_32 (arch, stringsize, temp); 2507 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp)) 2508 return FALSE; 2509 for (count = 0; count < orl_count; count++) 2510 { 2511 size_t len = strlen (*map[count].name) + 1; 2512 2513 if (bfd_bwrite (*map[count].name, len, arch) != len) 2514 return FALSE; 2515 } 2516 2517 /* The spec sez this should be a newline. But in order to be 2518 bug-compatible for sun's ar we use a null. */ 2519 if (padit) 2520 { 2521 if (bfd_bwrite ("", 1, arch) != 1) 2522 return FALSE; 2523 } 2524 2525 return TRUE; 2526 } 2527 2528 /* At the end of archive file handling, update the timestamp in the 2529 file, so the linker will accept it. 2530 2531 Return TRUE if the timestamp was OK, or an unusual problem happened. 2532 Return FALSE if we updated the timestamp. */ 2533 2534 bfd_boolean 2535 _bfd_archive_bsd_update_armap_timestamp (bfd *arch) 2536 { 2537 struct stat archstat; 2538 struct ar_hdr hdr; 2539 2540 /* If creating deterministic archives, just leave the timestamp as-is. */ 2541 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0) 2542 return TRUE; 2543 2544 /* Flush writes, get last-write timestamp from file, and compare it 2545 to the timestamp IN the file. */ 2546 bfd_flush (arch); 2547 if (bfd_stat (arch, &archstat) == -1) 2548 { 2549 bfd_perror (_("Reading archive file mod timestamp")); 2550 2551 /* Can't read mod time for some reason. */ 2552 return TRUE; 2553 } 2554 if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp) 2555 /* OK by the linker's rules. */ 2556 return TRUE; 2557 2558 /* Update the timestamp. */ 2559 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET; 2560 2561 /* Prepare an ASCII version suitable for writing. */ 2562 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date)); 2563 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 2564 bfd_ardata (arch)->armap_timestamp); 2565 2566 /* Write it into the file. */ 2567 bfd_ardata (arch)->armap_datepos = (SARMAG 2568 + offsetof (struct ar_hdr, ar_date[0])); 2569 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0 2570 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch) 2571 != sizeof (hdr.ar_date))) 2572 { 2573 bfd_perror (_("Writing updated armap timestamp")); 2574 2575 /* Some error while writing. */ 2576 return TRUE; 2577 } 2578 2579 /* We updated the timestamp successfully. */ 2580 return FALSE; 2581 } 2582 2583 /* A coff armap looks like : 2584 lARMAG 2585 struct ar_hdr with name = '/' 2586 number of symbols 2587 offset of file for symbol 0 2588 offset of file for symbol 1 2589 2590 offset of file for symbol n-1 2591 symbol name 0 2592 symbol name 1 2593 2594 symbol name n-1 */ 2595 2596 bfd_boolean 2597 coff_write_armap (bfd *arch, 2598 unsigned int elength, 2599 struct orl *map, 2600 unsigned int symbol_count, 2601 int stridx) 2602 { 2603 /* The size of the ranlib is the number of exported symbols in the 2604 archive * the number of bytes in an int, + an int for the count. */ 2605 unsigned int ranlibsize = (symbol_count * 4) + 4; 2606 unsigned int stringsize = stridx; 2607 unsigned int mapsize = stringsize + ranlibsize; 2608 file_ptr archive_member_file_ptr; 2609 bfd *current = arch->archive_head; 2610 unsigned int count; 2611 struct ar_hdr hdr; 2612 int padit = mapsize & 1; 2613 2614 if (padit) 2615 mapsize++; 2616 2617 /* Work out where the first object file will go in the archive. */ 2618 archive_member_file_ptr = (mapsize 2619 + elength 2620 + sizeof (struct ar_hdr) 2621 + SARMAG); 2622 2623 memset (&hdr, ' ', sizeof (struct ar_hdr)); 2624 hdr.ar_name[0] = '/'; 2625 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize)) 2626 return FALSE; 2627 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 2628 ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0 2629 ? time (NULL) : 0)); 2630 /* This, at least, is what Intel coff sets the values to. */ 2631 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0); 2632 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0); 2633 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0); 2634 memcpy (hdr.ar_fmag, ARFMAG, 2); 2635 2636 /* Write the ar header for this item and the number of symbols. */ 2637 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) 2638 != sizeof (struct ar_hdr)) 2639 return FALSE; 2640 2641 if (!bfd_write_bigendian_4byte_int (arch, symbol_count)) 2642 return FALSE; 2643 2644 /* Two passes, first write the file offsets for each symbol - 2645 remembering that each offset is on a two byte boundary. */ 2646 2647 /* Write out the file offset for the file associated with each 2648 symbol, and remember to keep the offsets padded out. */ 2649 2650 current = arch->archive_head; 2651 count = 0; 2652 while (current != NULL && count < symbol_count) 2653 { 2654 /* For each symbol which is used defined in this object, write 2655 out the object file's address in the archive. */ 2656 2657 while (count < symbol_count && map[count].u.abfd == current) 2658 { 2659 unsigned int offset = (unsigned int) archive_member_file_ptr; 2660 2661 /* Catch an attempt to grow an archive past its 4Gb limit. */ 2662 if (archive_member_file_ptr != (file_ptr) offset) 2663 { 2664 bfd_set_error (bfd_error_file_truncated); 2665 return FALSE; 2666 } 2667 if (!bfd_write_bigendian_4byte_int (arch, offset)) 2668 return FALSE; 2669 count++; 2670 } 2671 archive_member_file_ptr += sizeof (struct ar_hdr); 2672 if (! bfd_is_thin_archive (arch)) 2673 { 2674 /* Add size of this archive entry. */ 2675 archive_member_file_ptr += arelt_size (current); 2676 /* Remember about the even alignment. */ 2677 archive_member_file_ptr += archive_member_file_ptr % 2; 2678 } 2679 current = current->archive_next; 2680 } 2681 2682 /* Now write the strings themselves. */ 2683 for (count = 0; count < symbol_count; count++) 2684 { 2685 size_t len = strlen (*map[count].name) + 1; 2686 2687 if (bfd_bwrite (*map[count].name, len, arch) != len) 2688 return FALSE; 2689 } 2690 2691 /* The spec sez this should be a newline. But in order to be 2692 bug-compatible for arc960 we use a null. */ 2693 if (padit) 2694 { 2695 if (bfd_bwrite ("", 1, arch) != 1) 2696 return FALSE; 2697 } 2698 2699 return TRUE; 2700 } 2701 2702 static int 2703 archive_close_worker (void **slot, void *inf ATTRIBUTE_UNUSED) 2704 { 2705 struct ar_cache *ent = (struct ar_cache *) *slot; 2706 2707 bfd_close_all_done (ent->arbfd); 2708 return 1; 2709 } 2710 2711 bfd_boolean 2712 _bfd_archive_close_and_cleanup (bfd *abfd) 2713 { 2714 if (bfd_read_p (abfd) && abfd->format == bfd_archive) 2715 { 2716 bfd *nbfd; 2717 bfd *next; 2718 htab_t htab; 2719 2720 /* Close nested archives (if this bfd is a thin archive). */ 2721 for (nbfd = abfd->nested_archives; nbfd; nbfd = next) 2722 { 2723 next = nbfd->archive_next; 2724 bfd_close (nbfd); 2725 } 2726 2727 htab = bfd_ardata (abfd)->cache; 2728 if (htab) 2729 { 2730 htab_traverse_noresize (htab, archive_close_worker, NULL); 2731 htab_delete (htab); 2732 bfd_ardata (abfd)->cache = NULL; 2733 } 2734 } 2735 else if (arch_eltdata (abfd) != NULL) 2736 { 2737 struct areltdata *ared = arch_eltdata (abfd); 2738 htab_t htab = (htab_t) ared->parent_cache; 2739 2740 if (htab) 2741 { 2742 struct ar_cache ent; 2743 void **slot; 2744 2745 ent.ptr = ared->key; 2746 slot = htab_find_slot (htab, &ent, NO_INSERT); 2747 if (slot != NULL) 2748 { 2749 BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd); 2750 htab_clear_slot (htab, slot); 2751 } 2752 } 2753 } 2754 return TRUE; 2755 } 2756