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