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