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