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