| 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 --- 141 unchanged lines hidden (view full) --- 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) --- 5 unchanged lines hidden (view full) --- 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); --- 10 unchanged lines hidden (view full) --- 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)) --- 53 unchanged lines hidden (view full) --- 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. */ --- 8 unchanged lines hidden (view full) --- 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; --- 22 unchanged lines hidden (view full) --- 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 } --- 14 unchanged lines hidden (view full) --- 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 --- 16 unchanged lines hidden (view full) --- 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 --- 4 unchanged lines hidden (view full) --- 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) --- 19 unchanged lines hidden (view full) --- 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); --- 18 unchanged lines hidden (view full) --- 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); --- 9 unchanged lines hidden (view full) --- 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), "%-12ld", (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. */ --- 29 unchanged lines hidden (view full) --- 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; --- 38 unchanged lines hidden (view full) --- 1469 foo (ar_mode, st_mode, 8); 1470 1471 buf->st_size = arch_eltdata (abfd)->parsed_size; 1472 1473 return 0; 1474} 1475 1476void |
| 1477bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) |
| 1478{ 1479 /* FIXME: This interacts unpleasantly with ar's quick-append option. 1480 Fortunately ic960 users will never use that option. Fixing this 1481 is very hard; fortunately I know how to do it and will do so once 1482 intel's release is out the door. */ 1483 1484 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 1485 size_t length; --- 20 unchanged lines hidden (view full) --- 1506 1507 /* Add the padding character if there is room for it. */ 1508 if (length < maxlen 1509 || (length == maxlen && length < sizeof hdr->ar_name)) 1510 (hdr->ar_name)[length] = ar_padchar (abfd); 1511} 1512 1513void |
| 1514bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) |
| 1515{ 1516 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 1517 size_t length; 1518 const char *filename = strrchr (pathname, '/'); 1519 size_t maxlen = ar_maxnamelen (abfd); 1520 1521#ifdef HAVE_DOS_BASED_FILE_SYSTEM 1522 { --- 31 unchanged lines hidden (view full) --- 1554 2> if it's short enuf to fit, stuff it in. 1555 3> If it doesn't end with .o, truncate it to fit 1556 4> truncate it before the .o, append .o, stuff THAT in. */ 1557 1558/* This is what gnu ar does. It's better but incompatible with the 1559 bsd ar. */ 1560 1561void |
| 1562bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) |
| 1563{ 1564 struct ar_hdr *hdr = (struct ar_hdr *) arhdr; 1565 size_t length; 1566 const char *filename = strrchr (pathname, '/'); 1567 size_t maxlen = ar_maxnamelen (abfd); 1568 1569#ifdef HAVE_DOS_BASED_FILE_SYSTEM 1570 { --- 27 unchanged lines hidden (view full) --- 1598 } 1599 1600 if (length < 16) 1601 (hdr->ar_name)[length] = ar_padchar (abfd); 1602} 1603 1604/* The BFD is open for write and has its format set to bfd_archive. */ 1605 |
| 1606bfd_boolean 1607_bfd_write_archive_contents (bfd *arch) |
| 1608{ 1609 bfd *current; 1610 char *etable = NULL; 1611 bfd_size_type elength = 0; 1612 const char *ename = NULL; |
| 1613 bfd_boolean makemap = bfd_has_map (arch); 1614 /* If no .o's, don't bother to make a map. */ 1615 bfd_boolean hasobjects = FALSE; |
| 1616 bfd_size_type wrote; 1617 unsigned int i; 1618 int tries; 1619 1620 /* Verify the viability of all entries; if any of them live in the 1621 filesystem (as opposed to living in an archive open for input) 1622 then construct a fresh ar_hdr for them. */ 1623 for (current = arch->archive_head; current; current = current->next) 1624 { 1625 /* This check is checking the bfds for the objects we're reading 1626 from (which are usually either an object file or archive on 1627 disk), not the archive entries we're writing to. We don't 1628 actually create bfds for the archive members, we just copy 1629 them byte-wise when we write out the archive. */ 1630 if (bfd_write_p (current)) 1631 { 1632 bfd_set_error (bfd_error_invalid_operation); |
| 1633 return FALSE; |
| 1634 } 1635 if (!current->arelt_data) 1636 { 1637 current->arelt_data = |
| 1638 bfd_ar_hdr_from_filesystem (arch, current->filename, current); |
| 1639 if (!current->arelt_data) |
| 1640 return FALSE; |
| 1641 1642 /* Put in the file name. */ |
| 1643 BFD_SEND (arch, _bfd_truncate_arname, 1644 (arch, current->filename, (char *) arch_hdr (current))); |
| 1645 } 1646 1647 if (makemap && ! hasobjects) 1648 { /* Don't bother if we won't make a map! */ 1649 if ((bfd_check_format (current, bfd_object)) 1650#if 0 /* FIXME -- these are not set correctly */ 1651 && ((bfd_get_file_flags (current) & HAS_SYMS)) 1652#endif 1653 ) |
| 1654 hasobjects = TRUE; |
| 1655 } 1656 } 1657 1658 if (!BFD_SEND (arch, _bfd_construct_extended_name_table, 1659 (arch, &etable, &elength, &ename))) |
| 1660 return FALSE; |
| 1661 1662 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0) |
| 1663 return FALSE; |
| 1664#ifdef GNU960 |
| 1665 wrote = bfd_bwrite (BFD_GNU960_ARMAG (arch), SARMAG, arch); |
| 1666#else |
| 1667 wrote = bfd_bwrite (ARMAG, SARMAG, arch); |
| 1668#endif 1669 if (wrote != SARMAG) |
| 1670 return FALSE; |
| 1671 1672 if (makemap && hasobjects) 1673 { 1674 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength)) |
| 1675 return FALSE; |
| 1676 } 1677 1678 if (elength != 0) 1679 { 1680 struct ar_hdr hdr; 1681 |
| 1682 memset (&hdr, 0, sizeof (struct ar_hdr)); |
| 1683 strcpy (hdr.ar_name, ename); 1684 /* Round size up to even number in archive header. */ 1685 sprintf (&(hdr.ar_size[0]), "%-10d", 1686 (int) ((elength + 1) & ~(bfd_size_type) 1)); 1687 strncpy (hdr.ar_fmag, ARFMAG, 2); 1688 for (i = 0; i < sizeof (struct ar_hdr); i++) 1689 if (((char *) (&hdr))[i] == '\0') 1690 (((char *) (&hdr))[i]) = ' '; |
| 1691 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) |
| 1692 != sizeof (struct ar_hdr)) 1693 || bfd_bwrite (etable, elength, arch) != elength) |
| 1694 return FALSE; |
| 1695 if ((elength % 2) == 1) 1696 { |
| 1697 if (bfd_bwrite ("\012", 1, arch) != 1) 1698 return FALSE; |
| 1699 } 1700 } 1701 1702 for (current = arch->archive_head; current; current = current->next) 1703 { 1704 char buffer[DEFAULT_BUFFERSIZE]; 1705 unsigned int remaining = arelt_size (current); 1706 struct ar_hdr *hdr = arch_hdr (current); 1707 1708 /* Write ar header. */ |
| 1709 if (bfd_bwrite (hdr, sizeof (*hdr), arch) |
| 1710 != sizeof (*hdr)) |
| 1711 return FALSE; |
| 1712 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0) |
| 1713 return FALSE; |
| 1714 while (remaining) 1715 { 1716 unsigned int amt = DEFAULT_BUFFERSIZE; 1717 if (amt > remaining) 1718 amt = remaining; 1719 errno = 0; |
| 1720 if (bfd_bread (buffer, amt, current) != amt) |
| 1721 { 1722 if (bfd_get_error () != bfd_error_system_call) 1723 bfd_set_error (bfd_error_malformed_archive); |
| 1724 return FALSE; |
| 1725 } |
| 1726 if (bfd_bwrite (buffer, amt, arch) != amt) 1727 return FALSE; |
| 1728 remaining -= amt; 1729 } 1730 if ((arelt_size (current) % 2) == 1) 1731 { |
| 1732 if (bfd_bwrite ("\012", 1, arch) != 1) 1733 return FALSE; |
| 1734 } 1735 } 1736 1737 if (makemap && hasobjects) 1738 { 1739 /* Verify the timestamp in the archive file. If it would not be 1740 accepted by the linker, rewrite it until it would be. If 1741 anything odd happens, break out and just return. (The --- 6 unchanged lines hidden (view full) --- 1748 if (bfd_update_armap_timestamp (arch)) 1749 break; 1750 (*_bfd_error_handler) 1751 (_("Warning: writing archive was slow: rewriting timestamp\n")); 1752 } 1753 while (++tries < 6); 1754 } 1755 |
| 1756 return TRUE; |
| 1757} 1758 1759/* Note that the namidx for the first symbol is 0. */ 1760 |
| 1761bfd_boolean 1762_bfd_compute_and_write_armap (bfd *arch, unsigned int elength) |
| 1763{ 1764 char *first_name = NULL; 1765 bfd *current; 1766 file_ptr elt_no = 0; 1767 struct orl *map = NULL; 1768 unsigned int orl_max = 1024; /* fine initial default */ 1769 unsigned int orl_count = 0; 1770 int stridx = 0; /* string index */ 1771 asymbol **syms = NULL; 1772 long syms_max = 0; |
| 1773 bfd_boolean ret; |
| 1774 bfd_size_type amt; 1775 1776 /* Dunno if this is the best place for this info... */ 1777 if (elength != 0) 1778 elength += sizeof (struct ar_hdr); 1779 elength += elength % 2; 1780 |
| 1781 amt = orl_max * sizeof (struct orl); 1782 map = bfd_malloc (amt); |
| 1783 if (map == NULL) 1784 goto error_return; 1785 1786 /* We put the symbol names on the arch objalloc, and then discard 1787 them when done. */ |
| 1788 first_name = bfd_alloc (arch, 1); |
| 1789 if (first_name == NULL) 1790 goto error_return; 1791 1792 /* Drop all the files called __.SYMDEF, we're going to make our own. */ 1793 while (arch->archive_head && 1794 strcmp (arch->archive_head->filename, "__.SYMDEF") == 0) 1795 arch->archive_head = arch->archive_head->next; 1796 1797 /* Map over each element. */ 1798 for (current = arch->archive_head; |
| 1799 current != NULL; |
| 1800 current = current->next, elt_no++) 1801 { 1802 if (bfd_check_format (current, bfd_object) 1803 && (bfd_get_file_flags (current) & HAS_SYMS) != 0) 1804 { 1805 long storage; 1806 long symcount; 1807 long src_count; --- 4 unchanged lines hidden (view full) --- 1812 1813 if (storage != 0) 1814 { 1815 if (storage > syms_max) 1816 { 1817 if (syms_max > 0) 1818 free (syms); 1819 syms_max = storage; |
| 1820 syms = bfd_malloc (syms_max); |
| 1821 if (syms == NULL) 1822 goto error_return; 1823 } 1824 symcount = bfd_canonicalize_symtab (current, syms); 1825 if (symcount < 0) 1826 goto error_return; 1827 1828 /* Now map over all the symbols, picking out the ones we --- 11 unchanged lines hidden (view full) --- 1840 { 1841 bfd_size_type namelen; 1842 struct orl *new_map; 1843 1844 /* This symbol will go into the archive header. */ 1845 if (orl_count == orl_max) 1846 { 1847 orl_max *= 2; |
| 1848 amt = orl_max * sizeof (struct orl); 1849 new_map = bfd_realloc (map, amt); 1850 if (new_map == NULL) |
| 1851 goto error_return; 1852 1853 map = new_map; 1854 } 1855 1856 namelen = strlen (syms[src_count]->name); 1857 amt = sizeof (char *); |
| 1858 map[orl_count].name = bfd_alloc (arch, amt); |
| 1859 if (map[orl_count].name == NULL) 1860 goto error_return; 1861 *(map[orl_count].name) = bfd_alloc (arch, namelen + 1); 1862 if (*(map[orl_count].name) == NULL) 1863 goto error_return; 1864 strcpy (*(map[orl_count].name), syms[src_count]->name); 1865 map[orl_count].u.abfd = current; 1866 map[orl_count].namidx = stridx; --- 27 unchanged lines hidden (view full) --- 1894 error_return: 1895 if (syms_max > 0) 1896 free (syms); 1897 if (map != NULL) 1898 free (map); 1899 if (first_name != NULL) 1900 bfd_release (arch, first_name); 1901 |
| 1902 return FALSE; |
| 1903} 1904 |
| 1905bfd_boolean 1906bsd_write_armap (bfd *arch, 1907 unsigned int elength, 1908 struct orl *map, 1909 unsigned int orl_count, 1910 int stridx) |
| 1911{ 1912 int padit = stridx & 1; 1913 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE; 1914 unsigned int stringsize = stridx + padit; 1915 /* Include 8 bytes to store ranlibsize and stringsize in output. */ 1916 unsigned int mapsize = ranlibsize + stringsize + 8; 1917 file_ptr firstreal; 1918 bfd *current = arch->archive_head; 1919 bfd *last_elt = current; /* last element arch seen */ 1920 bfd_byte temp[4]; 1921 unsigned int count; 1922 struct ar_hdr hdr; 1923 struct stat statbuf; 1924 unsigned int i; 1925 1926 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG; 1927 1928 stat (arch->filename, &statbuf); |
| 1929 memset (&hdr, 0, sizeof (struct ar_hdr)); |
| 1930 sprintf (hdr.ar_name, RANLIBMAG); 1931 /* Remember the timestamp, to keep it holy. But fudge it a little. */ 1932 bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET; 1933 bfd_ardata (arch)->armap_datepos = (SARMAG 1934 + offsetof (struct ar_hdr, ar_date[0])); 1935 sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp); 1936 sprintf (hdr.ar_uid, "%ld", (long) getuid ()); 1937 sprintf (hdr.ar_gid, "%ld", (long) getgid ()); 1938 sprintf (hdr.ar_size, "%-10d", (int) mapsize); 1939 strncpy (hdr.ar_fmag, ARFMAG, 2); 1940 for (i = 0; i < sizeof (struct ar_hdr); i++) 1941 if (((char *) (&hdr))[i] == '\0') 1942 (((char *) (&hdr))[i]) = ' '; |
| 1943 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) |
| 1944 != sizeof (struct ar_hdr)) |
| 1945 return FALSE; |
| 1946 H_PUT_32 (arch, ranlibsize, temp); |
| 1947 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp)) 1948 return FALSE; |
| 1949 1950 for (count = 0; count < orl_count; count++) 1951 { 1952 bfd_byte buf[BSD_SYMDEF_SIZE]; 1953 1954 if (map[count].u.abfd != last_elt) 1955 { 1956 do 1957 { 1958 firstreal += arelt_size (current) + sizeof (struct ar_hdr); 1959 firstreal += firstreal % 2; 1960 current = current->next; 1961 } 1962 while (current != map[count].u.abfd); 1963 } /* if new archive element */ 1964 1965 last_elt = current; 1966 H_PUT_32 (arch, map[count].namidx, buf); 1967 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE); |
| 1968 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch) |
| 1969 != BSD_SYMDEF_SIZE) |
| 1970 return FALSE; |
| 1971 } 1972 1973 /* Now write the strings themselves. */ 1974 H_PUT_32 (arch, stringsize, temp); |
| 1975 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp)) 1976 return FALSE; |
| 1977 for (count = 0; count < orl_count; count++) 1978 { 1979 size_t len = strlen (*map[count].name) + 1; 1980 |
| 1981 if (bfd_bwrite (*map[count].name, len, arch) != len) 1982 return FALSE; |
| 1983 } 1984 1985 /* The spec sez this should be a newline. But in order to be 1986 bug-compatible for sun's ar we use a null. */ 1987 if (padit) 1988 { |
| 1989 if (bfd_bwrite ("", 1, arch) != 1) 1990 return FALSE; |
| 1991 } 1992 |
| 1993 return TRUE; |
| 1994} 1995 1996/* At the end of archive file handling, update the timestamp in the 1997 file, so the linker will accept it. 1998 |
| 1999 Return TRUE if the timestamp was OK, or an unusual problem happened. 2000 Return FALSE if we updated the timestamp. */ |
| 2001 |
| 2002bfd_boolean 2003_bfd_archive_bsd_update_armap_timestamp (bfd *arch) |
| 2004{ 2005 struct stat archstat; 2006 struct ar_hdr hdr; 2007 unsigned int i; 2008 2009 /* Flush writes, get last-write timestamp from file, and compare it 2010 to the timestamp IN the file. */ 2011 bfd_flush (arch); 2012 if (bfd_stat (arch, &archstat) == -1) 2013 { |
| 2014 bfd_perror (_("Reading archive file mod timestamp")); |
| 2015 2016 /* Can't read mod time for some reason. */ |
| 2017 return TRUE; |
| 2018 } 2019 if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp) 2020 /* OK by the linker's rules. */ |
| 2021 return TRUE; |
| 2022 2023 /* Update the timestamp. */ 2024 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET; 2025 2026 /* Prepare an ASCII version suitable for writing. */ 2027 memset (hdr.ar_date, 0, sizeof (hdr.ar_date)); 2028 sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp); 2029 for (i = 0; i < sizeof (hdr.ar_date); i++) 2030 if (hdr.ar_date[i] == '\0') 2031 (hdr.ar_date)[i] = ' '; 2032 2033 /* Write it into the file. */ 2034 bfd_ardata (arch)->armap_datepos = (SARMAG 2035 + offsetof (struct ar_hdr, ar_date[0])); 2036 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0 |
| 2037 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch) |
| 2038 != sizeof (hdr.ar_date))) 2039 { |
| 2040 bfd_perror (_("Writing updated armap timestamp")); |
| 2041 2042 /* Some error while writing. */ |
| 2043 return TRUE; |
| 2044 } 2045 2046 /* We updated the timestamp successfully. */ |
| 2047 return FALSE; |
| 2048} 2049 2050/* A coff armap looks like : 2051 lARMAG 2052 struct ar_hdr with name = '/' 2053 number of symbols 2054 offset of file for symbol 0 2055 offset of file for symbol 1 2056 2057 offset of file for symbol n-1 2058 symbol name 0 2059 symbol name 1 2060 2061 symbol name n-1 2062*/ 2063 |
| 2064bfd_boolean 2065coff_write_armap (bfd *arch, 2066 unsigned int elength, 2067 struct orl *map, 2068 unsigned int symbol_count, 2069 int stridx) |
| 2070{ 2071 /* The size of the ranlib is the number of exported symbols in the 2072 archive * the number of bytes in an int, + an int for the count. */ 2073 unsigned int ranlibsize = (symbol_count * 4) + 4; 2074 unsigned int stringsize = stridx; 2075 unsigned int mapsize = stringsize + ranlibsize; 2076 unsigned int archive_member_file_ptr; 2077 bfd *current = arch->archive_head; --- 6 unchanged lines hidden (view full) --- 2084 mapsize++; 2085 2086 /* Work out where the first object file will go in the archive. */ 2087 archive_member_file_ptr = (mapsize 2088 + elength 2089 + sizeof (struct ar_hdr) 2090 + SARMAG); 2091 |
| 2092 memset (&hdr, 0, sizeof (struct ar_hdr)); |
| 2093 hdr.ar_name[0] = '/'; 2094 sprintf (hdr.ar_size, "%-10d", (int) mapsize); 2095 sprintf (hdr.ar_date, "%ld", (long) time (NULL)); 2096 /* This, at least, is what Intel coff sets the values to. */ 2097 sprintf ((hdr.ar_uid), "%d", 0); 2098 sprintf ((hdr.ar_gid), "%d", 0); 2099 sprintf ((hdr.ar_mode), "%-7o", (unsigned) 0); 2100 strncpy (hdr.ar_fmag, ARFMAG, 2); 2101 2102 for (i = 0; i < sizeof (struct ar_hdr); i++) 2103 if (((char *) (&hdr))[i] == '\0') 2104 (((char *) (&hdr))[i]) = ' '; 2105 2106 /* Write the ar header for this item and the number of symbols. */ 2107 |
| 2108 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) |
| 2109 != sizeof (struct ar_hdr)) |
| 2110 return FALSE; |
| 2111 2112 if (!bfd_write_bigendian_4byte_int (arch, symbol_count)) |
| 2113 return FALSE; |
| 2114 2115 /* Two passes, first write the file offsets for each symbol - 2116 remembering that each offset is on a two byte boundary. */ 2117 2118 /* Write out the file offset for the file associated with each 2119 symbol, and remember to keep the offsets padded out. */ 2120 2121 current = arch->archive_head; 2122 count = 0; |
| 2123 while (current != NULL && count < symbol_count) |
| 2124 { 2125 /* For each symbol which is used defined in this object, write 2126 out the object file's address in the archive. */ 2127 2128 while (count < symbol_count && map[count].u.abfd == current) 2129 { 2130 if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr)) |
| 2131 return FALSE; |
| 2132 count++; 2133 } 2134 /* Add size of this archive entry. */ |
| 2135 archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr); |
| 2136 /* Remember aboout the even alignment. */ 2137 archive_member_file_ptr += archive_member_file_ptr % 2; 2138 current = current->next; 2139 } 2140 2141 /* Now write the strings themselves. */ 2142 for (count = 0; count < symbol_count; count++) 2143 { 2144 size_t len = strlen (*map[count].name) + 1; 2145 |
| 2146 if (bfd_bwrite (*map[count].name, len, arch) != len) 2147 return FALSE; |
| 2148 } 2149 2150 /* The spec sez this should be a newline. But in order to be 2151 bug-compatible for arc960 we use a null. */ 2152 if (padit) 2153 { |
| 2154 if (bfd_bwrite ("", 1, arch) != 1) 2155 return FALSE; |
| 2156 } 2157 |
| 2158 return TRUE; |
| 2159} |