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