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