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