141142Sobrien/* BFD back-end for archive files (libraries). 241142Sobrien Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 341142Sobrien 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 441142Sobrien Free Software Foundation, Inc. 541142Sobrien Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault. 641142Sobrien 741142Sobrien This file is part of BFD, the Binary File Descriptor library. 841142Sobrien 941142Sobrien This program is free software; you can redistribute it and/or modify 1041142Sobrien it under the terms of the GNU General Public License as published by 1141142Sobrien the Free Software Foundation; either version 2 of the License, or 1241142Sobrien (at your option) any later version. 1341142Sobrien 1451292Sobrien This program is distributed in the hope that it will be useful, 1551292Sobrien but WITHOUT ANY WARRANTY; without even the implied warranty of 1651292Sobrien MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1751292Sobrien GNU General Public License for more details. 1851292Sobrien 1951292Sobrien You should have received a copy of the GNU General Public License 2051292Sobrien along with this program; if not, write to the Free Software 2151292Sobrien Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 2251292Sobrien 2351292Sobrien/* 2441142Sobrien@setfilename archive-info 25131702SmbrSECTION 26131702Smbr Archives 2782794Sobrien 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 "sysdep.h" 133#include "bfd.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; 1238 current != NULL; 1239 current = current->archive_next) 1240 { 1241 const char *normal; 1242 unsigned int thislen; 1243 1244 normal = normalize (current, current->filename); 1245 if (normal == NULL) 1246 return FALSE; 1247 1248 thislen = strlen (normal); 1249 1250 if (thislen > maxname 1251 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0) 1252 thislen = maxname; 1253 1254 if (thislen > maxname) 1255 { 1256 /* Add one to leave room for \n. */ 1257 total_namelen += thislen + 1; 1258 if (trailing_slash) 1259 { 1260 /* Leave room for trailing slash. */ 1261 ++total_namelen; 1262 } 1263 } 1264 else 1265 { 1266 struct ar_hdr *hdr = arch_hdr (current); 1267 if (strncmp (normal, hdr->ar_name, thislen) != 0 1268 || (thislen < sizeof hdr->ar_name 1269 && hdr->ar_name[thislen] != ar_padchar (current))) 1270 { 1271 /* Must have been using extended format even though it 1272 didn't need to. Fix it to use normal format. */ 1273 memcpy (hdr->ar_name, normal, thislen); 1274 if (thislen < maxname 1275 || (thislen == maxname && thislen < sizeof hdr->ar_name)) 1276 hdr->ar_name[thislen] = ar_padchar (current); 1277 } 1278 } 1279 } 1280 1281 if (total_namelen == 0) 1282 return TRUE; 1283 1284 *tabloc = bfd_zalloc (abfd, total_namelen); 1285 if (*tabloc == NULL) 1286 return FALSE; 1287 1288 *tablen = total_namelen; 1289 strptr = *tabloc; 1290 1291 for (current = abfd->archive_head; 1292 current != NULL; 1293 current = current->archive_next) 1294 { 1295 const char *normal; 1296 unsigned int thislen; 1297 1298 normal = normalize (current, current->filename); 1299 if (normal == NULL) 1300 return FALSE; 1301 1302 thislen = strlen (normal); 1303 if (thislen > maxname) 1304 { 1305 /* Works for now; may need to be re-engineered if we 1306 encounter an oddball archive format and want to 1307 generalise this hack. */ 1308 struct ar_hdr *hdr = arch_hdr (current); 1309 strcpy (strptr, normal); 1310 if (! trailing_slash) 1311 strptr[thislen] = '\012'; 1312 else 1313 { 1314 strptr[thislen] = '/'; 1315 strptr[thislen + 1] = '\012'; 1316 } 1317 hdr->ar_name[0] = ar_padchar (current); 1318 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", 1319 strptr - *tabloc); 1320 strptr += thislen + 1; 1321 if (trailing_slash) 1322 ++strptr; 1323 } 1324 } 1325 1326 return TRUE; 1327} 1328 1329/* A couple of functions for creating ar_hdrs. */ 1330 1331#ifdef HPUX_LARGE_AR_IDS 1332/* Function to encode large UID/GID values according to HP. */ 1333 1334static void 1335hpux_uid_gid_encode (char str[6], long int id) 1336{ 1337 int cnt; 1338 1339 str[5] = '@' + (id & 3); 1340 id >>= 2; 1341 1342 for (cnt = 4; cnt >= 0; --cnt, id >>= 6) 1343 str[cnt] = ' ' + (id & 0x3f); 1344} 1345#endif /* HPUX_LARGE_AR_IDS */ 1346 1347#ifndef HAVE_GETUID 1348#define getuid() 0 1349#endif 1350 1351#ifndef HAVE_GETGID 1352#define getgid() 0 1353#endif 1354 1355/* Takes a filename, returns an arelt_data for it, or NULL if it can't 1356 make one. The filename must refer to a filename in the filesystem. 1357 The filename field of the ar_hdr will NOT be initialized. If member 1358 is set, and it's an in-memory bfd, we fake it. */ 1359 1360static struct areltdata * 1361bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member) 1362{ 1363 struct stat status; 1364 struct areltdata *ared; 1365 struct ar_hdr *hdr; 1366 bfd_size_type amt; 1367 1368 if (member && (member->flags & BFD_IN_MEMORY) != 0) 1369 { 1370 /* Assume we just "made" the member, and fake it. */ 1371 struct bfd_in_memory *bim = member->iostream; 1372 time (&status.st_mtime); 1373 status.st_uid = getuid (); 1374 status.st_gid = getgid (); 1375 status.st_mode = 0644; 1376 status.st_size = bim->size; 1377 } 1378 else if (stat (filename, &status) != 0) 1379 { 1380 bfd_set_error (bfd_error_system_call); 1381 return NULL; 1382 } 1383 1384 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata); 1385 ared = bfd_zalloc (abfd, amt); 1386 if (ared == NULL) 1387 return NULL; 1388 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata)); 1389 1390 /* ar headers are space padded, not null padded! */ 1391 memset (hdr, ' ', sizeof (struct ar_hdr)); 1392 1393 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld", 1394 status.st_mtime); 1395#ifdef HPUX_LARGE_AR_IDS 1396 /* HP has a very "special" way to handle UID/GID's with numeric values 1397 > 99999. */ 1398 if (status.st_uid > 99999) 1399 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid); 1400 else 1401#endif 1402 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld", 1403 status.st_uid); 1404#ifdef HPUX_LARGE_AR_IDS 1405 /* HP has a very "special" way to handle UID/GID's with numeric values 1406 > 99999. */ 1407 if (status.st_gid > 99999) 1408 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid); 1409 else 1410#endif 1411 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld", 1412 status.st_gid); 1413 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo", 1414 status.st_mode); 1415 _bfd_ar_spacepad (hdr->ar_size, sizeof (hdr->ar_size), "%-10ld", 1416 status.st_size); 1417 memcpy (hdr->ar_fmag, ARFMAG, 2); 1418 ared->parsed_size = status.st_size; 1419 ared->arch_header = (char *) hdr; 1420 1421 return ared; 1422} 1423 1424/* This is magic required by the "ar" program. Since it's 1425 undocumented, it's undocumented. You may think that it would take 1426 a strong stomach to write this, and it does, but it takes even a 1427 stronger stomach to try to code around such a thing! */ 1428 1429struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *); 1430 1431struct ar_hdr * 1432bfd_special_undocumented_glue (bfd *abfd, const char *filename) 1433{ 1434 struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0); 1435 if (ar_elt == NULL) 1436 return NULL; 1437 return (struct ar_hdr *) ar_elt->arch_header; 1438} 1439 1440/* Analogous to stat call. */ 1441 1442int 1443bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf) 1444{ 1445 struct ar_hdr *hdr; 1446 char *aloser; 1447 1448 if (abfd->arelt_data == NULL) 1449 { 1450 bfd_set_error (bfd_error_invalid_operation); 1451 return -1; 1452 } 1453 1454 hdr = arch_hdr (abfd); 1455 1456#define foo(arelt, stelt, size) \ 1457 buf->stelt = strtol (hdr->arelt, &aloser, size); \ 1458 if (aloser == hdr->arelt) \ 1459 return -1; 1460 1461 /* Some platforms support special notations for large IDs. */ 1462#ifdef HPUX_LARGE_AR_IDS 1463# define foo2(arelt, stelt, size) \ 1464 if (hdr->arelt[5] == ' ') \ 1465 { \ 1466 foo (arelt, stelt, size); \ 1467 } \ 1468 else \ 1469 { \ 1470 int cnt; \ 1471 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \ 1472 { \ 1473 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \ 1474 return -1; \ 1475 buf->stelt <<= 6; \ 1476 buf->stelt += hdr->arelt[cnt] - ' '; \ 1477 } \ 1478 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \ 1479 return -1; \ 1480 buf->stelt <<= 2; \ 1481 buf->stelt += hdr->arelt[5] - '@'; \ 1482 } 1483#else 1484# define foo2(arelt, stelt, size) foo (arelt, stelt, size) 1485#endif 1486 1487 foo (ar_date, st_mtime, 10); 1488 foo2 (ar_uid, st_uid, 10); 1489 foo2 (ar_gid, st_gid, 10); 1490 foo (ar_mode, st_mode, 8); 1491 1492 buf->st_size = arch_eltdata (abfd)->parsed_size; 1493 1494 return 0; 1495} 1496 1497void 1498bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) 1499{ 1500 /* FIXME: This interacts unpleasantly with ar's quick-append option. 1501 Fortunately ic960 users will never use that option. Fixing this 1502 is very hard; fortunately I know how to do it and will do so once 1503 intel's release is out the door. */ 1504 1505 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 1506 size_t length; 1507 const char *filename; 1508 size_t maxlen = ar_maxnamelen (abfd); 1509 1510 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0) 1511 { 1512 bfd_bsd_truncate_arname (abfd, pathname, arhdr); 1513 return; 1514 } 1515 1516 filename = normalize (abfd, pathname); 1517 if (filename == NULL) 1518 { 1519 /* FIXME */ 1520 abort (); 1521 } 1522 1523 length = strlen (filename); 1524 1525 if (length <= maxlen) 1526 memcpy (hdr->ar_name, filename, length); 1527 1528 /* Add the padding character if there is room for it. */ 1529 if (length < maxlen 1530 || (length == maxlen && length < sizeof hdr->ar_name)) 1531 (hdr->ar_name)[length] = ar_padchar (abfd); 1532} 1533 1534void 1535bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) 1536{ 1537 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 1538 size_t length; 1539 const char *filename = strrchr (pathname, '/'); 1540 size_t maxlen = ar_maxnamelen (abfd); 1541 1542#ifdef HAVE_DOS_BASED_FILE_SYSTEM 1543 { 1544 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */ 1545 char *bslash = strrchr (pathname, '\\'); 1546 if (filename == NULL || (bslash != NULL && bslash > filename)) 1547 filename = bslash; 1548 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':') 1549 filename = pathname + 1; 1550 } 1551#endif 1552 1553 if (filename == NULL) 1554 filename = pathname; 1555 else 1556 ++filename; 1557 1558 length = strlen (filename); 1559 1560 if (length <= maxlen) 1561 memcpy (hdr->ar_name, filename, length); 1562 else 1563 { 1564 /* pathname: meet procrustes */ 1565 memcpy (hdr->ar_name, filename, maxlen); 1566 length = maxlen; 1567 } 1568 1569 if (length < maxlen) 1570 (hdr->ar_name)[length] = ar_padchar (abfd); 1571} 1572 1573/* Store name into ar header. Truncates the name to fit. 1574 1> strip pathname to be just the basename. 1575 2> if it's short enuf to fit, stuff it in. 1576 3> If it doesn't end with .o, truncate it to fit 1577 4> truncate it before the .o, append .o, stuff THAT in. */ 1578 1579/* This is what gnu ar does. It's better but incompatible with the 1580 bsd ar. */ 1581 1582void 1583bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) 1584{ 1585 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 1586 size_t length; 1587 const char *filename = strrchr (pathname, '/'); 1588 size_t maxlen = ar_maxnamelen (abfd); 1589 1590#ifdef HAVE_DOS_BASED_FILE_SYSTEM 1591 { 1592 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */ 1593 char *bslash = strrchr (pathname, '\\'); 1594 if (filename == NULL || (bslash != NULL && bslash > filename)) 1595 filename = bslash; 1596 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':') 1597 filename = pathname + 1; 1598 } 1599#endif 1600 1601 if (filename == NULL) 1602 filename = pathname; 1603 else 1604 ++filename; 1605 1606 length = strlen (filename); 1607 1608 if (length <= maxlen) 1609 memcpy (hdr->ar_name, filename, length); 1610 else 1611 { /* pathname: meet procrustes */ 1612 memcpy (hdr->ar_name, filename, maxlen); 1613 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o')) 1614 { 1615 hdr->ar_name[maxlen - 2] = '.'; 1616 hdr->ar_name[maxlen - 1] = 'o'; 1617 } 1618 length = maxlen; 1619 } 1620 1621 if (length < 16) 1622 (hdr->ar_name)[length] = ar_padchar (abfd); 1623} 1624 1625/* The BFD is open for write and has its format set to bfd_archive. */ 1626 1627bfd_boolean 1628_bfd_write_archive_contents (bfd *arch) 1629{ 1630 bfd *current; 1631 char *etable = NULL; 1632 bfd_size_type elength = 0; 1633 const char *ename = NULL; 1634 bfd_boolean makemap = bfd_has_map (arch); 1635 /* If no .o's, don't bother to make a map. */ 1636 bfd_boolean hasobjects = FALSE; 1637 bfd_size_type wrote; 1638 int tries; 1639 1640 /* Verify the viability of all entries; if any of them live in the 1641 filesystem (as opposed to living in an archive open for input) 1642 then construct a fresh ar_hdr for them. */ 1643 for (current = arch->archive_head; 1644 current != NULL; 1645 current = current->archive_next) 1646 { 1647 /* This check is checking the bfds for the objects we're reading 1648 from (which are usually either an object file or archive on 1649 disk), not the archive entries we're writing to. We don't 1650 actually create bfds for the archive members, we just copy 1651 them byte-wise when we write out the archive. */ 1652 if (bfd_write_p (current)) 1653 { 1654 bfd_set_error (bfd_error_invalid_operation); 1655 goto input_err; 1656 } 1657 if (!current->arelt_data) 1658 { 1659 current->arelt_data = 1660 bfd_ar_hdr_from_filesystem (arch, current->filename, current); 1661 if (!current->arelt_data) 1662 goto input_err; 1663 1664 /* Put in the file name. */ 1665 BFD_SEND (arch, _bfd_truncate_arname, 1666 (arch, current->filename, (char *) arch_hdr (current))); 1667 } 1668 1669 if (makemap && ! hasobjects) 1670 { /* Don't bother if we won't make a map! */ 1671 if ((bfd_check_format (current, bfd_object))) 1672 hasobjects = TRUE; 1673 } 1674 } 1675 1676 if (!BFD_SEND (arch, _bfd_construct_extended_name_table, 1677 (arch, &etable, &elength, &ename))) 1678 return FALSE; 1679 1680 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0) 1681 return FALSE; 1682 wrote = bfd_bwrite (ARMAG, SARMAG, arch); 1683 if (wrote != SARMAG) 1684 return FALSE; 1685 1686 if (makemap && hasobjects) 1687 { 1688 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength)) 1689 return FALSE; 1690 } 1691 1692 if (elength != 0) 1693 { 1694 struct ar_hdr hdr; 1695 1696 memset (&hdr, ' ', sizeof (struct ar_hdr)); 1697 memcpy (hdr.ar_name, ename, strlen (ename)); 1698 /* Round size up to even number in archive header. */ 1699 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", 1700 (elength + 1) & ~(bfd_size_type) 1); 1701 memcpy (hdr.ar_fmag, ARFMAG, 2); 1702 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) 1703 != sizeof (struct ar_hdr)) 1704 || bfd_bwrite (etable, elength, arch) != elength) 1705 return FALSE; 1706 if ((elength % 2) == 1) 1707 { 1708 if (bfd_bwrite ("\012", 1, arch) != 1) 1709 return FALSE; 1710 } 1711 } 1712 1713 for (current = arch->archive_head; 1714 current != NULL; 1715 current = current->archive_next) 1716 { 1717 char buffer[DEFAULT_BUFFERSIZE]; 1718 unsigned int remaining = arelt_size (current); 1719 struct ar_hdr *hdr = arch_hdr (current); 1720 1721 /* Write ar header. */ 1722 if (bfd_bwrite (hdr, sizeof (*hdr), arch) 1723 != sizeof (*hdr)) 1724 return FALSE; 1725 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0) 1726 goto input_err; 1727 while (remaining) 1728 { 1729 unsigned int amt = DEFAULT_BUFFERSIZE; 1730 if (amt > remaining) 1731 amt = remaining; 1732 errno = 0; 1733 if (bfd_bread (buffer, amt, current) != amt) 1734 { 1735 if (bfd_get_error () != bfd_error_system_call) 1736 bfd_set_error (bfd_error_file_truncated); 1737 goto input_err; 1738 } 1739 if (bfd_bwrite (buffer, amt, arch) != amt) 1740 return FALSE; 1741 remaining -= amt; 1742 } 1743 if ((arelt_size (current) % 2) == 1) 1744 { 1745 if (bfd_bwrite ("\012", 1, arch) != 1) 1746 return FALSE; 1747 } 1748 } 1749 1750 if (makemap && hasobjects) 1751 { 1752 /* Verify the timestamp in the archive file. If it would not be 1753 accepted by the linker, rewrite it until it would be. If 1754 anything odd happens, break out and just return. (The 1755 Berkeley linker checks the timestamp and refuses to read the 1756 table-of-contents if it is >60 seconds less than the file's 1757 modified-time. That painful hack requires this painful hack. */ 1758 tries = 1; 1759 do 1760 { 1761 if (bfd_update_armap_timestamp (arch)) 1762 break; 1763 (*_bfd_error_handler) 1764 (_("Warning: writing archive was slow: rewriting timestamp\n")); 1765 } 1766 while (++tries < 6); 1767 } 1768 1769 return TRUE; 1770 1771 input_err: 1772 bfd_set_error (bfd_error_on_input, current, bfd_get_error ()); 1773 return FALSE; 1774} 1775 1776/* Note that the namidx for the first symbol is 0. */ 1777 1778bfd_boolean 1779_bfd_compute_and_write_armap (bfd *arch, unsigned int elength) 1780{ 1781 char *first_name = NULL; 1782 bfd *current; 1783 file_ptr elt_no = 0; 1784 struct orl *map = NULL; 1785 unsigned int orl_max = 1024; /* Fine initial default. */ 1786 unsigned int orl_count = 0; 1787 int stridx = 0; 1788 asymbol **syms = NULL; 1789 long syms_max = 0; 1790 bfd_boolean ret; 1791 bfd_size_type amt; 1792 1793 /* Dunno if this is the best place for this info... */ 1794 if (elength != 0) 1795 elength += sizeof (struct ar_hdr); 1796 elength += elength % 2; 1797 1798 amt = orl_max * sizeof (struct orl); 1799 map = bfd_malloc (amt); 1800 if (map == NULL) 1801 goto error_return; 1802 1803 /* We put the symbol names on the arch objalloc, and then discard 1804 them when done. */ 1805 first_name = bfd_alloc (arch, 1); 1806 if (first_name == NULL) 1807 goto error_return; 1808 1809 /* Drop all the files called __.SYMDEF, we're going to make our own. */ 1810 while (arch->archive_head && 1811 strcmp (arch->archive_head->filename, "__.SYMDEF") == 0) 1812 arch->archive_head = arch->archive_head->archive_next; 1813 1814 /* Map over each element. */ 1815 for (current = arch->archive_head; 1816 current != NULL; 1817 current = current->archive_next, elt_no++) 1818 { 1819 if (bfd_check_format (current, bfd_object) 1820 && (bfd_get_file_flags (current) & HAS_SYMS) != 0) 1821 { 1822 long storage; 1823 long symcount; 1824 long src_count; 1825 1826 storage = bfd_get_symtab_upper_bound (current); 1827 if (storage < 0) 1828 goto error_return; 1829 1830 if (storage != 0) 1831 { 1832 if (storage > syms_max) 1833 { 1834 if (syms_max > 0) 1835 free (syms); 1836 syms_max = storage; 1837 syms = bfd_malloc (syms_max); 1838 if (syms == NULL) 1839 goto error_return; 1840 } 1841 symcount = bfd_canonicalize_symtab (current, syms); 1842 if (symcount < 0) 1843 goto error_return; 1844 1845 /* Now map over all the symbols, picking out the ones we 1846 want. */ 1847 for (src_count = 0; src_count < symcount; src_count++) 1848 { 1849 flagword flags = (syms[src_count])->flags; 1850 asection *sec = syms[src_count]->section; 1851 1852 if ((flags & BSF_GLOBAL || 1853 flags & BSF_WEAK || 1854 flags & BSF_INDIRECT || 1855 bfd_is_com_section (sec)) 1856 && ! bfd_is_und_section (sec)) 1857 { 1858 bfd_size_type namelen; 1859 struct orl *new_map; 1860 1861 /* This symbol will go into the archive header. */ 1862 if (orl_count == orl_max) 1863 { 1864 orl_max *= 2; 1865 amt = orl_max * sizeof (struct orl); 1866 new_map = bfd_realloc (map, amt); 1867 if (new_map == NULL) 1868 goto error_return; 1869 1870 map = new_map; 1871 } 1872 1873 namelen = strlen (syms[src_count]->name); 1874 amt = sizeof (char *); 1875 map[orl_count].name = bfd_alloc (arch, amt); 1876 if (map[orl_count].name == NULL) 1877 goto error_return; 1878 *(map[orl_count].name) = bfd_alloc (arch, namelen + 1); 1879 if (*(map[orl_count].name) == NULL) 1880 goto error_return; 1881 strcpy (*(map[orl_count].name), syms[src_count]->name); 1882 map[orl_count].u.abfd = current; 1883 map[orl_count].namidx = stridx; 1884 1885 stridx += namelen + 1; 1886 ++orl_count; 1887 } 1888 } 1889 } 1890 1891 /* Now ask the BFD to free up any cached information, so we 1892 don't fill all of memory with symbol tables. */ 1893 if (! bfd_free_cached_info (current)) 1894 goto error_return; 1895 } 1896 } 1897 1898 /* OK, now we have collected all the data, let's write them out. */ 1899 ret = BFD_SEND (arch, write_armap, 1900 (arch, elength, map, orl_count, stridx)); 1901 1902 if (syms_max > 0) 1903 free (syms); 1904 if (map != NULL) 1905 free (map); 1906 if (first_name != NULL) 1907 bfd_release (arch, first_name); 1908 1909 return ret; 1910 1911 error_return: 1912 if (syms_max > 0) 1913 free (syms); 1914 if (map != NULL) 1915 free (map); 1916 if (first_name != NULL) 1917 bfd_release (arch, first_name); 1918 1919 return FALSE; 1920} 1921 1922bfd_boolean 1923bsd_write_armap (bfd *arch, 1924 unsigned int elength, 1925 struct orl *map, 1926 unsigned int orl_count, 1927 int stridx) 1928{ 1929 int padit = stridx & 1; 1930 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE; 1931 unsigned int stringsize = stridx + padit; 1932 /* Include 8 bytes to store ranlibsize and stringsize in output. */ 1933 unsigned int mapsize = ranlibsize + stringsize + 8; 1934 file_ptr firstreal; 1935 bfd *current = arch->archive_head; 1936 bfd *last_elt = current; /* Last element arch seen. */ 1937 bfd_byte temp[4]; 1938 unsigned int count; 1939 struct ar_hdr hdr; 1940 struct stat statbuf; 1941 1942 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG; 1943 1944 stat (arch->filename, &statbuf); 1945 memset (&hdr, ' ', sizeof (struct ar_hdr)); 1946 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG)); 1947 /* Remember the timestamp, to keep it holy. But fudge it a little. */ 1948 bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET; 1949 bfd_ardata (arch)->armap_datepos = (SARMAG 1950 + offsetof (struct ar_hdr, ar_date[0])); 1951 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 1952 bfd_ardata (arch)->armap_timestamp); 1953 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", getuid ()); 1954 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", getgid ()); 1955 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize); 1956 memcpy (hdr.ar_fmag, ARFMAG, 2); 1957 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) 1958 != sizeof (struct ar_hdr)) 1959 return FALSE; 1960 H_PUT_32 (arch, ranlibsize, temp); 1961 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp)) 1962 return FALSE; 1963 1964 for (count = 0; count < orl_count; count++) 1965 { 1966 bfd_byte buf[BSD_SYMDEF_SIZE]; 1967 1968 if (map[count].u.abfd != last_elt) 1969 { 1970 do 1971 { 1972 firstreal += arelt_size (current) + sizeof (struct ar_hdr); 1973 firstreal += firstreal % 2; 1974 current = current->archive_next; 1975 } 1976 while (current != map[count].u.abfd); 1977 } 1978 1979 last_elt = current; 1980 H_PUT_32 (arch, map[count].namidx, buf); 1981 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE); 1982 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch) 1983 != BSD_SYMDEF_SIZE) 1984 return FALSE; 1985 } 1986 1987 /* Now write the strings themselves. */ 1988 H_PUT_32 (arch, stringsize, temp); 1989 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp)) 1990 return FALSE; 1991 for (count = 0; count < orl_count; count++) 1992 { 1993 size_t len = strlen (*map[count].name) + 1; 1994 1995 if (bfd_bwrite (*map[count].name, len, arch) != len) 1996 return FALSE; 1997 } 1998 1999 /* The spec sez this should be a newline. But in order to be 2000 bug-compatible for sun's ar we use a null. */ 2001 if (padit) 2002 { 2003 if (bfd_bwrite ("", 1, arch) != 1) 2004 return FALSE; 2005 } 2006 2007 return TRUE; 2008} 2009 2010/* At the end of archive file handling, update the timestamp in the 2011 file, so the linker will accept it. 2012 2013 Return TRUE if the timestamp was OK, or an unusual problem happened. 2014 Return FALSE if we updated the timestamp. */ 2015 2016bfd_boolean 2017_bfd_archive_bsd_update_armap_timestamp (bfd *arch) 2018{ 2019 struct stat archstat; 2020 struct ar_hdr hdr; 2021 2022 /* Flush writes, get last-write timestamp from file, and compare it 2023 to the timestamp IN the file. */ 2024 bfd_flush (arch); 2025 if (bfd_stat (arch, &archstat) == -1) 2026 { 2027 bfd_perror (_("Reading archive file mod timestamp")); 2028 2029 /* Can't read mod time for some reason. */ 2030 return TRUE; 2031 } 2032 if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp) 2033 /* OK by the linker's rules. */ 2034 return TRUE; 2035 2036 /* Update the timestamp. */ 2037 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET; 2038 2039 /* Prepare an ASCII version suitable for writing. */ 2040 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date)); 2041 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 2042 bfd_ardata (arch)->armap_timestamp); 2043 2044 /* Write it into the file. */ 2045 bfd_ardata (arch)->armap_datepos = (SARMAG 2046 + offsetof (struct ar_hdr, ar_date[0])); 2047 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0 2048 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch) 2049 != sizeof (hdr.ar_date))) 2050 { 2051 bfd_perror (_("Writing updated armap timestamp")); 2052 2053 /* Some error while writing. */ 2054 return TRUE; 2055 } 2056 2057 /* We updated the timestamp successfully. */ 2058 return FALSE; 2059} 2060 2061/* A coff armap looks like : 2062 lARMAG 2063 struct ar_hdr with name = '/' 2064 number of symbols 2065 offset of file for symbol 0 2066 offset of file for symbol 1 2067 2068 offset of file for symbol n-1 2069 symbol name 0 2070 symbol name 1 2071 2072 symbol name n-1 */ 2073 2074bfd_boolean 2075coff_write_armap (bfd *arch, 2076 unsigned int elength, 2077 struct orl *map, 2078 unsigned int symbol_count, 2079 int stridx) 2080{ 2081 /* The size of the ranlib is the number of exported symbols in the 2082 archive * the number of bytes in an int, + an int for the count. */ 2083 unsigned int ranlibsize = (symbol_count * 4) + 4; 2084 unsigned int stringsize = stridx; 2085 unsigned int mapsize = stringsize + ranlibsize; 2086 unsigned int archive_member_file_ptr; 2087 bfd *current = arch->archive_head; 2088 unsigned int count; 2089 struct ar_hdr hdr; 2090 int padit = mapsize & 1; 2091 2092 if (padit) 2093 mapsize++; 2094 2095 /* Work out where the first object file will go in the archive. */ 2096 archive_member_file_ptr = (mapsize 2097 + elength 2098 + sizeof (struct ar_hdr) 2099 + SARMAG); 2100 2101 memset (&hdr, ' ', sizeof (struct ar_hdr)); 2102 hdr.ar_name[0] = '/'; 2103 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", 2104 mapsize); 2105 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 2106 time (NULL)); 2107 /* This, at least, is what Intel coff sets the values to. */ 2108 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0); 2109 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0); 2110 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0); 2111 memcpy (hdr.ar_fmag, ARFMAG, 2); 2112 2113 /* Write the ar header for this item and the number of symbols. */ 2114 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) 2115 != sizeof (struct ar_hdr)) 2116 return FALSE; 2117 2118 if (!bfd_write_bigendian_4byte_int (arch, symbol_count)) 2119 return FALSE; 2120 2121 /* Two passes, first write the file offsets for each symbol - 2122 remembering that each offset is on a two byte boundary. */ 2123 2124 /* Write out the file offset for the file associated with each 2125 symbol, and remember to keep the offsets padded out. */ 2126 2127 current = arch->archive_head; 2128 count = 0; 2129 while (current != NULL && count < symbol_count) 2130 { 2131 /* For each symbol which is used defined in this object, write 2132 out the object file's address in the archive. */ 2133 2134 while (count < symbol_count && map[count].u.abfd == current) 2135 { 2136 if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr)) 2137 return FALSE; 2138 count++; 2139 } 2140 /* Add size of this archive entry. */ 2141 archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr); 2142 /* Remember aboout the even alignment. */ 2143 archive_member_file_ptr += archive_member_file_ptr % 2; 2144 current = current->archive_next; 2145 } 2146 2147 /* Now write the strings themselves. */ 2148 for (count = 0; count < symbol_count; count++) 2149 { 2150 size_t len = strlen (*map[count].name) + 1; 2151 2152 if (bfd_bwrite (*map[count].name, len, arch) != len) 2153 return FALSE; 2154 } 2155 2156 /* The spec sez this should be a newline. But in order to be 2157 bug-compatible for arc960 we use a null. */ 2158 if (padit) 2159 { 2160 if (bfd_bwrite ("", 1, arch) != 1) 2161 return FALSE; 2162 } 2163 2164 return TRUE; 2165} 2166