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