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