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