diff --git a/bfd/ChangeLog b/bfd/ChangeLog index f140d33c4e..5ca6b32da8 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,7 @@ +Tue Jan 25 11:46:46 1994 Ian Lance Taylor (ian@tweedledumb.cygnus.com) + + * archive.c: Reindented to GNU standards. + Mon Jan 24 14:41:23 1994 David J. Mackenzie (djm@thepub.cygnus.com) * opncls.c (_bfd_new_bfd, _bfd_new_bfd_contained_in): Add diff --git a/bfd/archive.c b/bfd/archive.c index bc046710f6..31b26fee06 100644 --- a/bfd/archive.c +++ b/bfd/archive.c @@ -158,9 +158,10 @@ extern int errno; Note that the pointers here point to the front of the ar_hdr, not to the front of the contents! */ -struct ar_cache { +struct ar_cache +{ file_ptr ptr; - bfd* arelt; + bfd *arelt; struct ar_cache *next; }; @@ -233,12 +234,14 @@ bfd_get_next_mapent (abfd, prev, entry) symindex prev; carsym **entry; { - if (!bfd_has_map (abfd)) { - bfd_error = invalid_operation; - return BFD_NO_MORE_SYMBOLS; - } - - if (prev == BFD_NO_MORE_SYMBOLS) prev = 0; + if (!bfd_has_map (abfd)) + { + bfd_error = invalid_operation; + return BFD_NO_MORE_SYMBOLS; + } + + if (prev == BFD_NO_MORE_SYMBOLS) + prev = 0; else if (++prev >= bfd_ardata (abfd)->symdef_count) return BFD_NO_MORE_SYMBOLS; @@ -254,7 +257,7 @@ _bfd_create_empty_archive_element_shell (obfd) { bfd *nbfd; - nbfd = _bfd_new_bfd_contained_in(obfd); + nbfd = _bfd_new_bfd_contained_in (obfd); if (nbfd == NULL) { bfd_error = no_memory; @@ -272,7 +275,7 @@ SYNOPSIS DESCRIPTION Set the head of the chain of - BFDs contained in the archive @var{output} to @var{new_head}. + BFDs contained in the archive @var{output} to @var{new_head}. */ boolean @@ -294,7 +297,8 @@ _bfd_look_for_bfd_in_cache (arch_bfd, filepos) for (current = bfd_ardata (arch_bfd)->cache; current != NULL; current = current->next) - if (current->ptr == filepos) return current->arelt; + if (current->ptr == filepos) + return current->arelt; return NULL; } @@ -305,27 +309,30 @@ _bfd_add_bfd_to_archive_cache (arch_bfd, filepos, new_elt) bfd *arch_bfd, *new_elt; file_ptr filepos; { - struct ar_cache *new_cache = (struct ar_cache *) - bfd_zalloc(arch_bfd, sizeof (struct ar_cache)); + struct ar_cache *new_cache = ((struct ar_cache *) + bfd_zalloc (arch_bfd, + sizeof (struct ar_cache))); - if (new_cache == NULL) { - bfd_error = no_memory; - return false; - } + if (new_cache == NULL) + { + bfd_error = no_memory; + return false; + } new_cache->ptr = filepos; new_cache->arelt = new_elt; - new_cache->next = (struct ar_cache *)NULL; + new_cache->next = (struct ar_cache *) NULL; if (bfd_ardata (arch_bfd)->cache == NULL) bfd_ardata (arch_bfd)->cache = new_cache; - else { - struct ar_cache *current = bfd_ardata (arch_bfd)->cache; + else + { + struct ar_cache *current = bfd_ardata (arch_bfd)->cache; + + while (current->next != NULL) + current = current->next; + current->next = new_cache; + } - while (current->next != NULL) - current = current->next; - current->next = new_cache; - } - return true; } @@ -343,14 +350,15 @@ get_extended_arelt_filename (arch, name) the next region, but I'm too lazy. */ errno = 0; /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */ - index = strtol (name+1, NULL, 10); - if (errno != 0) { + index = strtol (name + 1, NULL, 10); + if (errno != 0) + { bfd_error = malformed_archive; return NULL; } return bfd_ardata (arch)->extended_names + index; -} +} /* This functions reads an arch header and returns an areltdata pointer, or NULL on error. @@ -369,121 +377,133 @@ _bfd_snarf_ar_hdr (abfd) extern int errno; #endif - struct ar_hdr hdr; - char *hdrp = (char *) &hdr; - unsigned int parsed_size; - struct areltdata *ared; - char *filename = NULL; - unsigned int namelen = 0; - unsigned int allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr); - char *allocptr = 0; + struct ar_hdr hdr; + char *hdrp = (char *) &hdr; + unsigned int parsed_size; + struct areltdata *ared; + char *filename = NULL; + unsigned int namelen = 0; + unsigned int allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr); + char *allocptr = 0; - if (bfd_read ((PTR)hdrp, 1, sizeof (struct ar_hdr), abfd) - != sizeof (struct ar_hdr)) { - bfd_error = no_more_archived_files; - return NULL; + if (bfd_read ((PTR) hdrp, 1, sizeof (struct ar_hdr), abfd) + != sizeof (struct ar_hdr)) + { + bfd_error = no_more_archived_files; + return NULL; } - if (strncmp ((hdr.ar_fmag), ARFMAG, 2)) { - bfd_error = malformed_archive; - return NULL; + if (strncmp (hdr.ar_fmag, ARFMAG, 2)) + { + bfd_error = malformed_archive; + return NULL; } - errno = 0; - parsed_size = strtol (hdr.ar_size, NULL, 10); - if (errno != 0) { - bfd_error = malformed_archive; - return NULL; + errno = 0; + parsed_size = strtol (hdr.ar_size, NULL, 10); + if (errno != 0) + { + bfd_error = malformed_archive; + return NULL; } - /* extract the filename from the archive - there are two ways to - specify an extendend name table, either the first char of the - name is a space, or it's a slash. */ - if ((hdr.ar_name[0] == '/' - || (hdr.ar_name[0] == ' ' - && memchr (hdr.ar_name, '/', ar_maxnamelen(abfd)) == NULL)) - && bfd_ardata (abfd)->extended_names != NULL) { - filename = get_extended_arelt_filename (abfd, hdr.ar_name); - if (filename == NULL) { - bfd_error = malformed_archive; - return NULL; + /* Extract the filename from the archive - there are two ways to + specify an extendend name table, either the first char of the + name is a space, or it's a slash. */ + if ((hdr.ar_name[0] == '/' + || (hdr.ar_name[0] == ' ' + && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL)) + && bfd_ardata (abfd)->extended_names != NULL) + { + filename = get_extended_arelt_filename (abfd, hdr.ar_name); + if (filename == NULL) + { + bfd_error = malformed_archive; + return NULL; } } - /* BSD4.4-style long filename. - Only implemented for reading, so far! */ - else if (hdr.ar_name[0] == '#' && hdr.ar_name[1] == '1' - && hdr.ar_name[2] == '/' && isdigit(hdr.ar_name[3])) - { - /* BSD-4.4 extended name */ - namelen = atoi (&hdr.ar_name[3]); - allocsize += namelen + 1; - parsed_size -= namelen; + /* BSD4.4-style long filename. + Only implemented for reading, so far! */ + else if (hdr.ar_name[0] == '#' && hdr.ar_name[1] == '1' + && hdr.ar_name[2] == '/' && isdigit (hdr.ar_name[3])) + { + /* BSD-4.4 extended name */ + namelen = atoi (&hdr.ar_name[3]); + allocsize += namelen + 1; + parsed_size -= namelen; - allocptr = bfd_zalloc(abfd, allocsize); - if (allocptr == NULL) { + allocptr = bfd_zalloc (abfd, allocsize); + if (allocptr == NULL) + { bfd_error = no_memory; return NULL; } - filename = allocptr - + (sizeof (struct areltdata) + sizeof (struct ar_hdr)); - if (bfd_read (filename, 1, namelen, abfd) != namelen) { + filename = (allocptr + + sizeof (struct areltdata) + + sizeof (struct ar_hdr)); + if (bfd_read (filename, 1, namelen, abfd) != namelen) + { bfd_error = no_more_archived_files; return NULL; } - filename[namelen] = '\0'; - } - else + filename[namelen] = '\0'; + } + else + { + /* We judge the end of the name by looking for '/' or ' '. + Note: The SYSV format (terminated by '/') allows embedded + spaces, so only look for ' ' if we don't find '/'. */ + + namelen = 0; + while (hdr.ar_name[namelen] != '\0' && + hdr.ar_name[namelen] != '/') { - /* We judge the end of the name by looking for '/' or ' '. - Note: The SYSV format (terminated by '/') allows embedded - spaces, so only look for ' ' if we don't find '/'. */ - - namelen = 0; - while (hdr.ar_name[namelen] != '\0' && - hdr.ar_name[namelen] != '/') { + namelen++; + if (namelen == (unsigned) ar_maxnamelen (abfd)) + { + namelen = 0; + while (hdr.ar_name[namelen] != ' ' + && namelen < (unsigned) ar_maxnamelen (abfd)) namelen++; - if (namelen == (unsigned)ar_maxnamelen(abfd)) { - namelen = 0; - while (hdr.ar_name[namelen] != ' ' - && namelen < (unsigned)ar_maxnamelen(abfd)) { - namelen++; - } - break; - } + break; } - - allocsize += namelen + 1; } - if (!allocptr) { - allocptr = bfd_zalloc(abfd, allocsize); - if (allocptr == NULL) { - bfd_error = no_memory; - return NULL; - } + allocsize += namelen + 1; } - ared = (struct areltdata *) allocptr; - - ared->arch_header = allocptr + sizeof (struct areltdata); - memcpy ((char *) ared->arch_header, (char *) &hdr, sizeof (struct ar_hdr)); - ared->parsed_size = parsed_size; - - if (filename != NULL) ared->filename = filename; - else { - ared->filename = allocptr + (sizeof (struct areltdata) + - sizeof (struct ar_hdr)); - if (namelen) - memcpy (ared->filename, hdr.ar_name, namelen); - ared->filename[namelen] = '\0'; + if (!allocptr) + { + allocptr = bfd_zalloc (abfd, allocsize); + if (allocptr == NULL) + { + bfd_error = no_memory; + return NULL; + } } - - return ared; + + ared = (struct areltdata *) allocptr; + + ared->arch_header = allocptr + sizeof (struct areltdata); + memcpy ((char *) ared->arch_header, (char *) &hdr, sizeof (struct ar_hdr)); + ared->parsed_size = parsed_size; + + if (filename != NULL) + ared->filename = filename; + else + { + ared->filename = allocptr + (sizeof (struct areltdata) + + sizeof (struct ar_hdr)); + if (namelen) + memcpy (ared->filename, hdr.ar_name, namelen); + ared->filename[namelen] = '\0'; + } + + return ared; } /* This is an internal function; it's mainly used when indexing through the archive symbol table, but also used to get the next - element, since it handles the bookkeeping so nicely for us. -*/ + element, since it handles the bookkeeping so nicely for us. */ bfd * _bfd_get_elt_at_filepos (archive, filepos) @@ -505,11 +525,11 @@ _bfd_get_elt_at_filepos (archive, filepos) if ((new_areldata = _bfd_snarf_ar_hdr (archive)) == NULL) return NULL; - + n_nfd = _bfd_create_empty_archive_element_shell (archive); if (n_nfd == NULL) { - bfd_release (archive, (PTR)new_areldata); + bfd_release (archive, (PTR) new_areldata); return NULL; } @@ -521,8 +541,8 @@ _bfd_get_elt_at_filepos (archive, filepos) return n_nfd; /* huh? */ - bfd_release (archive, (PTR)n_nfd); - bfd_release (archive, (PTR)new_areldata); + bfd_release (archive, (PTR) n_nfd); + bfd_release (archive, (PTR) new_areldata); return NULL; } @@ -544,10 +564,10 @@ bfd_get_elt_at_index (abfd, index) bfd *abfd; int index; { - bfd *result = - _bfd_get_elt_at_filepos - (abfd, (bfd_ardata (abfd)->symdefs + index)->file_offset); - return result; + carsym *entry; + + entry = bfd_ardata (abfd)->symdefs + index; + return _bfd_get_elt_at_filepos (abfd, entry->file_offset); } /* @@ -594,14 +614,15 @@ bfd_generic_openr_next_archived_file (archive, last_file) if (!last_file) filestart = bfd_ardata (archive)->first_file_filepos; - else { - unsigned int size = arelt_size(last_file); - /* Pad to an even boundary... - Note that last_file->origin can be odd in the case of - BSD-4.4-style element with a long odd size. */ - filestart = last_file->origin + size; - filestart += filestart % 2; - } + else + { + unsigned int size = arelt_size (last_file); + /* Pad to an even boundary... + Note that last_file->origin can be odd in the case of + BSD-4.4-style element with a long odd size. */ + filestart = last_file->origin + size; + filestart += filestart % 2; + } return _bfd_get_elt_at_filepos (archive, filestart); } @@ -611,7 +632,7 @@ bfd_target * bfd_generic_archive_p (abfd) bfd *abfd; { - char armag[SARMAG+1]; + char armag[SARMAG + 1]; if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG) { @@ -620,7 +641,7 @@ bfd_generic_archive_p (abfd) } #ifdef GNU960 - if (strncmp (armag, BFD_GNU960_ARMAG(abfd), SARMAG) != 0) + if (strncmp (armag, BFD_GNU960_ARMAG (abfd), SARMAG) != 0) return 0; #else if (strncmp (armag, ARMAG, SARMAG) != 0 && @@ -645,21 +666,21 @@ bfd_generic_archive_p (abfd) bfd_ardata (abfd)->symdefs = NULL; bfd_ardata (abfd)->extended_names = NULL; bfd_ardata (abfd)->tdata = NULL; - - if (! BFD_SEND (abfd, _bfd_slurp_armap, (abfd))) + + if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))) { - bfd_release(abfd, bfd_ardata (abfd)); + bfd_release (abfd, bfd_ardata (abfd)); abfd->tdata.aout_ar_data = NULL; return NULL; } - if (! BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd))) + if (!BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd))) { - bfd_release(abfd, bfd_ardata (abfd)); + bfd_release (abfd, bfd_ardata (abfd)); abfd->tdata.aout_ar_data = NULL; return NULL; } - + return abfd->xvec; } @@ -679,47 +700,51 @@ do_slurp_bsd_armap (abfd) if (mapdata == NULL) return false; parsed_size = mapdata->parsed_size; - bfd_release (abfd, (PTR)mapdata); /* Don't need it any more. */ - - raw_armap = (int *) bfd_zalloc(abfd, parsed_size); - if (raw_armap == NULL) { + bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */ + + raw_armap = (int *) bfd_zalloc (abfd, parsed_size); + if (raw_armap == NULL) + { bfd_error = no_memory; return false; - } - - if (bfd_read ((PTR)raw_armap, 1, parsed_size, abfd) != parsed_size) { + } + + if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size) + { bfd_error = malformed_archive; byebye: - bfd_release (abfd, (PTR)raw_armap); + bfd_release (abfd, (PTR) raw_armap); return false; - } - + } + ardata->symdef_count = (bfd_h_get_32 (abfd, (bfd_byte *) raw_armap) / sizeof (struct symdef)); - + if (ardata->symdef_count * sizeof (struct symdef) - > parsed_size - sizeof (*raw_armap)) { + > parsed_size - sizeof (*raw_armap)) + { /* Probably we're using the wrong byte ordering. */ bfd_error = wrong_format; goto byebye; - } - + } + ardata->cache = 0; - rbase = raw_armap+1; + rbase = raw_armap + 1; ardata->symdefs = (carsym *) rbase; stringbase = ((char *) (ardata->symdefs + ardata->symdef_count)) + 4; - - for (;counter < ardata->symdef_count; counter++) { + + for (; counter < ardata->symdef_count; counter++) + { struct symdef *sym = ((struct symdef *) rbase) + counter; sym->s.name = (bfd_h_get_32 (abfd, (bfd_byte *) (&sym->s.string_offset)) + stringbase); sym->file_offset = bfd_h_get_32 (abfd, (bfd_byte *) (&(sym->file_offset))); - } - + } + ardata->first_file_filepos = bfd_tell (abfd); /* Pad to an even boundary if you have to */ - ardata->first_file_filepos += (ardata-> first_file_filepos) %2; + ardata->first_file_filepos += (ardata->first_file_filepos) % 2; /* FIXME, we should provide some way to free raw_ardata when we are done using the strings from it. For now, it seems to be allocated on an obstack anyway... */ @@ -739,25 +764,26 @@ do_slurp_coff_armap (abfd) unsigned int stringsize; unsigned int parsed_size; carsym *carsyms; - unsigned int nsymz; /* Number of symbols in armap. */ - bfd_vma (*swap) PARAMS ((const bfd_byte*)); - char int_buf[sizeof(long)]; + unsigned int nsymz; /* Number of symbols in armap. */ + bfd_vma (*swap) PARAMS ((const bfd_byte *)); + char int_buf[sizeof (long)]; unsigned int carsym_size, ptrsize, i; - + mapdata = _bfd_snarf_ar_hdr (abfd); if (mapdata == NULL) return false; parsed_size = mapdata->parsed_size; - bfd_release (abfd, (PTR)mapdata); /* Don't need it any more. */ + bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */ - if (bfd_read ((PTR)int_buf, 1, 4, abfd) != 4) { - bfd_error = malformed_archive; - return false; - } + if (bfd_read ((PTR) int_buf, 1, 4, abfd) != 4) + { + bfd_error = malformed_archive; + return false; + } /* It seems that all numeric information in a coff archive is always in big endian format, nomatter the host or target. */ swap = bfd_getb32; - nsymz = bfd_getb32((PTR)int_buf); + nsymz = bfd_getb32 ((PTR) int_buf); stringsize = parsed_size - (4 * nsymz) - 4; #if 1 @@ -765,64 +791,69 @@ do_slurp_coff_armap (abfd) fault - the i960 little endian coff sometimes has big and sometimes little, because our tools changed. Here's a horrible hack to clean up the crap. */ - - if (stringsize > 0xfffff) { + + if (stringsize > 0xfffff) + { /* This looks dangerous, let's do it the other way around */ - nsymz = bfd_getl32((PTR)int_buf); + nsymz = bfd_getl32 ((PTR) int_buf); stringsize = parsed_size - (4 * nsymz) - 4; swap = bfd_getl32; - } + } #endif - /* The coff armap must be read sequentially. So we construct a bsd-style - one in core all at once, for simplicity. */ - + /* The coff armap must be read sequentially. So we construct a + bsd-style one in core all at once, for simplicity. */ + carsym_size = (nsymz * sizeof (carsym)); ptrsize = (4 * nsymz); - ardata->symdefs = (carsym *) bfd_zalloc(abfd, carsym_size + stringsize + 1); - if (ardata->symdefs == NULL) { + ardata->symdefs = (carsym *) bfd_zalloc (abfd, carsym_size + stringsize + 1); + if (ardata->symdefs == NULL) + { bfd_error = no_memory; return false; - } + } carsyms = ardata->symdefs; stringbase = ((char *) ardata->symdefs) + carsym_size; /* Allocate and read in the raw offsets. */ - raw_armap = (int *) bfd_alloc(abfd, ptrsize); - if (raw_armap == NULL) { + raw_armap = (int *) bfd_alloc (abfd, ptrsize); + if (raw_armap == NULL) + { bfd_error = no_memory; goto release_symdefs; - } - if (bfd_read ((PTR)raw_armap, 1, ptrsize, abfd) != ptrsize - || bfd_read ((PTR)stringbase, 1, stringsize, abfd) != stringsize) { - bfd_error = malformed_archive; - goto release_raw_armap; - } + } + if (bfd_read ((PTR) raw_armap, 1, ptrsize, abfd) != ptrsize + || bfd_read ((PTR) stringbase, 1, stringsize, abfd) != stringsize) + { + bfd_error = malformed_archive; + goto release_raw_armap; + } /* OK, build the carsyms */ - for (i = 0; i < nsymz; i++) { + for (i = 0; i < nsymz; i++) + { rawptr = raw_armap + i; - carsyms->file_offset = swap((PTR)rawptr); + carsyms->file_offset = swap ((PTR) rawptr); carsyms->name = stringbase; stringbase += strlen (stringbase) + 1; carsyms++; - } + } *stringbase = 0; ardata->symdef_count = nsymz; ardata->first_file_filepos = bfd_tell (abfd); /* Pad to an even boundary if you have to */ - ardata->first_file_filepos += (ardata->first_file_filepos) %2; + ardata->first_file_filepos += (ardata->first_file_filepos) % 2; bfd_has_map (abfd) = true; - bfd_release (abfd, (PTR)raw_armap); + bfd_release (abfd, (PTR) raw_armap); return true; - release_raw_armap: - bfd_release (abfd, (PTR)raw_armap); - release_symdefs: - bfd_release (abfd, (PTR)(ardata)->symdefs); +release_raw_armap: + bfd_release (abfd, (PTR) raw_armap); +release_symdefs: + bfd_release (abfd, (PTR) (ardata)->symdefs); return false; } @@ -834,14 +865,14 @@ bfd_slurp_armap (abfd) bfd *abfd; { char nextname[17]; - int i = bfd_read ((PTR)nextname, 1, 16, abfd); - - if (i == 0) - return true; - if (i != 16) - return false; + int i = bfd_read ((PTR) nextname, 1, 16, abfd); - bfd_seek (abfd, (file_ptr) -16, SEEK_CUR); + if (i == 0) + return true; + if (i != 16) + return false; + + bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR); if (!strncmp (nextname, "__.SYMDEF ", 16)) return do_slurp_bsd_armap (abfd); @@ -854,10 +885,10 @@ bfd_slurp_armap (abfd) /* Returns false on error, true otherwise */ /* flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the - header is in a slightly different order and the map name is '/'. + header is in a slightly different order and the map name is '/'. This flavour is used by hp300hpux. */ boolean -bfd_slurp_bsd_armap_f2 (abfd) +bfd_slurp_bsd_armap_f2 (abfd) bfd *abfd; { struct areltdata *mapdata; @@ -867,7 +898,7 @@ bfd_slurp_bsd_armap_f2 (abfd) struct artdata *ardata = bfd_ardata (abfd); char *stringbase; unsigned int stringsize; - int i = bfd_read ((PTR)nextname, 1, 16, abfd); + int i = bfd_read ((PTR) nextname, 1, 16, abfd); if (i == 0) return true; @@ -890,25 +921,25 @@ bfd_slurp_bsd_armap_f2 (abfd) if (mapdata == NULL) return false; - raw_armap = (int *) bfd_zalloc(abfd,mapdata->parsed_size); + raw_armap = (int *) bfd_zalloc (abfd, mapdata->parsed_size); if (raw_armap == NULL) { bfd_error = no_memory; byebye: - bfd_release (abfd, (PTR)mapdata); + bfd_release (abfd, (PTR) mapdata); return false; } - if (bfd_read ((PTR)raw_armap, 1, mapdata->parsed_size, abfd) != + if (bfd_read ((PTR) raw_armap, 1, mapdata->parsed_size, abfd) != mapdata->parsed_size) { bfd_error = malformed_archive; byebyebye: - bfd_release (abfd, (PTR)raw_armap); + bfd_release (abfd, (PTR) raw_armap); goto byebye; } - ardata->symdef_count = bfd_h_get_16(abfd, (PTR)raw_armap); + ardata->symdef_count = bfd_h_get_16 (abfd, (PTR) raw_armap); if (ardata->symdef_count * sizeof (struct symdef) > mapdata->parsed_size - sizeof (*raw_armap)) @@ -920,22 +951,23 @@ bfd_slurp_bsd_armap_f2 (abfd) ardata->cache = 0; - stringsize = bfd_h_get_32(abfd, (PTR)(((char*)raw_armap)+2)); + stringsize = bfd_h_get_32 (abfd, (PTR) (((char *) raw_armap) + 2)); /* skip sym count and string sz */ - rbase = (int*)(((char*)raw_armap) + 6); + rbase = (int *) (((char *) raw_armap) + 6); stringbase = (char *) rbase; - ardata->symdefs = (carsym *)(((char*) rbase) + stringsize); + ardata->symdefs = (carsym *) (((char *) rbase) + stringsize); - for (;counter < ardata->symdef_count; counter++) + for (; counter < ardata->symdef_count; counter++) { struct symdef *sym = ((struct symdef *) ardata->symdefs) + counter; - sym->s.name = bfd_h_get_32(abfd, (PTR)(&(sym->s.string_offset))) + stringbase; - sym->file_offset = bfd_h_get_32(abfd, (PTR)( &(sym->file_offset))); + sym->s.name = (bfd_h_get_32 (abfd, (PTR) (&(sym->s.string_offset))) + + stringbase); + sym->file_offset = bfd_h_get_32 (abfd, (PTR) (&(sym->file_offset))); } ardata->first_file_filepos = bfd_tell (abfd); /* Pad to an even boundary if you have to */ - ardata->first_file_filepos += (ardata-> first_file_filepos) %2; + ardata->first_file_filepos += (ardata->first_file_filepos) % 2; /* FIXME, we should provide some way to free raw_ardata when we are done using the strings from it. For now, it seems to be allocated on an obstack anyway... */ @@ -963,41 +995,45 @@ _bfd_slurp_extended_name_table (abfd) /* FIXME: Formatting sucks here, and in case of failure of BFD_READ, we probably don't want to return true. */ - if (bfd_read ((PTR)nextname, 1, 16, abfd) == 16) { + if (bfd_read ((PTR) nextname, 1, 16, abfd) == 16) + { - bfd_seek (abfd, (file_ptr) -16, SEEK_CUR); + bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR); - if (strncmp (nextname, "ARFILENAMES/ ", 16) != 0 && - strncmp (nextname, "// ", 16) != 0) + if (strncmp (nextname, "ARFILENAMES/ ", 16) != 0 && + strncmp (nextname, "// ", 16) != 0) { - bfd_ardata (abfd)->extended_names = NULL; - return true; - } + bfd_ardata (abfd)->extended_names = NULL; + return true; + } - namedata = _bfd_snarf_ar_hdr (abfd); - if (namedata == NULL) - return false; - - bfd_ardata (abfd)->extended_names = bfd_zalloc(abfd,namedata->parsed_size); - if (bfd_ardata (abfd)->extended_names == NULL) { - bfd_error = no_memory; - byebye: - bfd_release (abfd, (PTR)namedata); - return false; - } + namedata = _bfd_snarf_ar_hdr (abfd); + if (namedata == NULL) + return false; - if (bfd_read ((PTR)bfd_ardata (abfd)->extended_names, 1, - namedata->parsed_size, abfd) != namedata->parsed_size) { - bfd_error = malformed_archive; - bfd_release (abfd, (PTR)(bfd_ardata (abfd)->extended_names)); - bfd_ardata (abfd)->extended_names = NULL; - goto byebye; - } + bfd_ardata (abfd)->extended_names = + bfd_zalloc (abfd, namedata->parsed_size); + if (bfd_ardata (abfd)->extended_names == NULL) + { + bfd_error = no_memory; + byebye: + bfd_release (abfd, (PTR) namedata); + return false; + } - /* Since the archive is supposed to be printable if it contains - text, the entries in the list are newline-padded, not null - padded. In SVR4-style archives, the names also have a - trailing '/'. We'll fix both problems here.. */ + if (bfd_read ((PTR) bfd_ardata (abfd)->extended_names, 1, + namedata->parsed_size, abfd) != namedata->parsed_size) + { + bfd_error = malformed_archive; + bfd_release (abfd, (PTR) (bfd_ardata (abfd)->extended_names)); + bfd_ardata (abfd)->extended_names = NULL; + goto byebye; + } + + /* Since the archive is supposed to be printable if it contains + text, the entries in the list are newline-padded, not null + padded. In SVR4-style archives, the names also have a + trailing '/'. We'll fix both problems here.. */ { char *temp = bfd_ardata (abfd)->extended_names; char *limit = temp + namedata->parsed_size; @@ -1005,16 +1041,16 @@ _bfd_slurp_extended_name_table (abfd) if (*temp == '\n') temp[temp[-1] == '/' ? -1 : 0] = '\0'; } - - /* Pad to an even boundary if you have to */ - bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd); - bfd_ardata (abfd)->first_file_filepos += - (bfd_ardata (abfd)->first_file_filepos) %2; - /* FIXME, we can't release namedata here because it was allocated - below extended_names on the obstack... */ - /* bfd_release (abfd, namedata); */ - } + /* Pad to an even boundary if you have to */ + bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd); + bfd_ardata (abfd)->first_file_filepos += + (bfd_ardata (abfd)->first_file_filepos) % 2; + + /* FIXME, we can't release namedata here because it was allocated + below extended_names on the obstack... */ + /* bfd_release (abfd, namedata); */ + } return true; } @@ -1030,25 +1066,25 @@ normalize (file) CONST char *last; char *copy; - first = file + strlen(file)-1; - last = first+1; + first = file + strlen (file) - 1; + last = first + 1; - while (first != file) - { - if (*first == ';') - last = first; - if (*first == ':' || *first == ']' ||*first == '>') - { - first++; - break; + while (first != file) + { + if (*first == ';') + last = first; + if (*first == ':' || *first == ']' || *first == '>') + { + first++; + break; + } + first--; } - first --; - } - - copy = bfd_xmalloc(last - first + 1); - memcpy(copy, first, last-first); - copy[last-first] = 0; + + copy = bfd_xmalloc (last - first + 1); + memcpy (copy, first, last - first); + copy[last - first] = 0; return copy; } @@ -1058,24 +1094,24 @@ static const char * normalize (file) const char *file; { - CONST char * filename = strrchr(file, '/'); + CONST char *filename = strrchr (file, '/'); - if (filename != (char *)NULL) { - filename ++; - } - else { - filename = file; - } + if (filename != (char *) NULL) + filename++; + else + filename = file; return filename; } #endif -/* Follows archive_head and produces an extended name table if necessary. - Returns (in tabloc) a pointer to an extended name table, and in tablen - the length of the table. If it makes an entry it clobbers the filename - so that the element may be written without further massage. - Returns true if it ran successfully, false if something went wrong. - A successful return may still involve a zero-length tablen! - */ + +/* Follows archive_head and produces an extended name table if + necessary. Returns (in tabloc) a pointer to an extended name + table, and in tablen the length of the table. If it makes an entry + it clobbers the filename so that the element may be written without + further massage. Returns true if it ran successfully, false if + something went wrong. A successful return may still involve a + zero-length tablen! */ + static boolean bfd_construct_extended_name_table (abfd, tabloc, tablen) bfd *abfd; @@ -1088,62 +1124,69 @@ bfd_construct_extended_name_table (abfd, tabloc, tablen) char *strptr; *tablen = 0; - + /* Figure out how long the table should be */ - for (current = abfd->archive_head; current != NULL; current = current->next){ - unsigned int thislen = strlen (normalize(current->filename)); - if (thislen > maxname) total_namelen += thislen + 1; /* leave room for \n */ - } + for (current = abfd->archive_head; current != NULL; current = current->next) + { + unsigned int thislen = strlen (normalize (current->filename)); + if (thislen > maxname) + total_namelen += thislen + 1; /* leave room for \n */ + } - if (total_namelen == 0) return true; + if (total_namelen == 0) + return true; - *tabloc = bfd_zalloc (abfd,total_namelen); - if (*tabloc == NULL) { - bfd_error = no_memory; - return false; - } + *tabloc = bfd_zalloc (abfd, total_namelen); + if (*tabloc == NULL) + { + bfd_error = no_memory; + return false; + } *tablen = total_namelen; strptr = *tabloc; for (current = abfd->archive_head; current != NULL; current = - current->next) { - CONST char *normal =normalize( current->filename); - unsigned int thislen = strlen (normal); - if (thislen > maxname) { - /* Works for now; may need to be re-engineered if we encounter an oddball - archive format and want to generalise this hack. */ - struct ar_hdr *hdr = arch_hdr(current); - strcpy (strptr, normal); - strptr[thislen] = '\n'; - hdr->ar_name[0] = ' '; - /* We know there will always be enough room (one of the few cases - where you may safely use sprintf). */ - sprintf ((hdr->ar_name) + 1, "%-d", (unsigned) (strptr - *tabloc)); - /* Kinda Kludgy. We should just use the returned value of sprintf - but not all implementations get this right */ + current->next) + { + CONST char *normal = normalize (current->filename); + unsigned int thislen = strlen (normal); + if (thislen > maxname) { - char *temp = hdr->ar_name +2; - for (; temp < hdr->ar_name + maxname; temp++) - if (*temp == '\0') *temp = ' '; + /* Works for now; may need to be re-engineered if we + encounter an oddball archive format and want to + generalise this hack. */ + struct ar_hdr *hdr = arch_hdr (current); + strcpy (strptr, normal); + strptr[thislen] = '\n'; + hdr->ar_name[0] = ' '; + /* We know there will always be enough room (one of the few + cases where you may safely use sprintf). */ + sprintf ((hdr->ar_name) + 1, "%-d", (unsigned) (strptr - *tabloc)); + /* Kinda Kludgy. We should just use the returned value of + sprintf but not all implementations get this right */ + { + char *temp = hdr->ar_name + 2; + for (; temp < hdr->ar_name + maxname; temp++) + if (*temp == '\0') + *temp = ' '; + } + strptr += thislen + 1; } - strptr += thislen + 1; } - } return true; } /** A couple of functions for creating ar_hdrs */ -/* Takes a filename, returns an arelt_data for it, or NULL if it can't make one. - The filename must refer to a filename in the filesystem. - The filename field of the ar_hdr will NOT be initialized -*/ +/* Takes a filename, returns an arelt_data for it, or NULL if it can't + make one. The filename must refer to a filename in the filesystem. + The filename field of the ar_hdr will NOT be initialized */ static struct areltdata * -bfd_ar_hdr_from_filesystem (abfd,filename) - bfd* abfd; +bfd_ar_hdr_from_filesystem (abfd, filename) + bfd *abfd; const char *filename; { struct stat status; @@ -1151,24 +1194,26 @@ bfd_ar_hdr_from_filesystem (abfd,filename) struct ar_hdr *hdr; char *temp, *temp1; - if (stat (filename, &status) != 0) { - bfd_error = system_call_error; - return NULL; - } + if (stat (filename, &status) != 0) + { + bfd_error = system_call_error; + return NULL; + } - ared = (struct areltdata *) bfd_zalloc(abfd, sizeof (struct ar_hdr) + - sizeof (struct areltdata)); - if (ared == NULL) { - bfd_error = no_memory; - return NULL; - } + ared = (struct areltdata *) bfd_zalloc (abfd, sizeof (struct ar_hdr) + + sizeof (struct areltdata)); + if (ared == NULL) + { + bfd_error = no_memory; + return NULL; + } hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata)); /* ar headers are space padded, not null padded! */ memset (hdr, ' ', sizeof (struct ar_hdr)); strncpy (hdr->ar_fmag, ARFMAG, 2); - + /* Goddamned sprintf doesn't permit MAXIMUM field lengths */ sprintf ((hdr->ar_date), "%-12ld", status.st_mtime); sprintf ((hdr->ar_uid), "%d", status.st_uid); @@ -1180,9 +1225,11 @@ bfd_ar_hdr_from_filesystem (abfd,filename) IO operations */ temp = (char *) hdr; temp1 = temp + sizeof (struct ar_hdr) - 2; - for (; temp < temp1; temp++) { - if (*temp == '\0') *temp = ' '; - } + for (; temp < temp1; temp++) + { + if (*temp == '\0') + *temp = ' '; + } strncpy (hdr->ar_fmag, ARFMAG, 2); ared->parsed_size = status.st_size; ared->arch_header = (char *) hdr; @@ -1191,10 +1238,9 @@ bfd_ar_hdr_from_filesystem (abfd,filename) } /* This is magic required by the "ar" program. Since it's - undocumented, it's undocumented. You may think that it would - take a strong stomach to write this, and it does, but it takes - even a stronger stomach to try to code around such a thing! -*/ + undocumented, it's undocumented. You may think that it would take + a strong stomach to write this, and it does, but it takes even a + stronger stomach to try to code around such a thing! */ struct ar_hdr * bfd_special_undocumented_glue (abfd, filename) @@ -1203,7 +1249,7 @@ bfd_special_undocumented_glue (abfd, filename) { struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename); if (ar_elt == NULL) - return NULL; + return NULL; return (struct ar_hdr *) ar_elt->arch_header; } @@ -1216,18 +1262,19 @@ bfd_generic_stat_arch_elt (abfd, buf) { struct ar_hdr *hdr; char *aloser; - - if (abfd->arelt_data == NULL) { - bfd_error = invalid_operation; - return -1; - } - + + if (abfd->arelt_data == NULL) + { + bfd_error = invalid_operation; + return -1; + } + hdr = arch_hdr (abfd); #define foo(arelt, stelt, size) \ buf->stelt = strtol (hdr->arelt, &aloser, size); \ if (aloser == hdr->arelt) return -1; - + foo (ar_date, st_mtime, 10); foo (ar_uid, st_uid, 10); foo (ar_gid, st_gid, 10); @@ -1248,10 +1295,10 @@ bfd_dont_truncate_arname (abfd, pathname, arhdr) Fortunately ic960 users will never use that option. Fixing this is very hard; fortunately I know how to do it and will do so once intel's release is out the door. */ - + struct ar_hdr *hdr = (struct ar_hdr *) arhdr; int length; - CONST char *filename = normalize(pathname); + CONST char *filename = normalize (pathname); int maxlen = ar_maxnamelen (abfd); length = strlen (filename); @@ -1259,9 +1306,8 @@ bfd_dont_truncate_arname (abfd, pathname, arhdr) if (length <= maxlen) memcpy (hdr->ar_name, filename, length); - if (length < maxlen) (hdr->ar_name)[length] = ar_padchar (abfd); - return; - + if (length < maxlen) + (hdr->ar_name)[length] = ar_padchar (abfd); } void @@ -1275,7 +1321,6 @@ bfd_bsd_truncate_arname (abfd, pathname, arhdr) CONST char *filename = strrchr (pathname, '/'); int maxlen = ar_maxnamelen (abfd); - if (filename == NULL) filename = pathname; else @@ -1285,11 +1330,12 @@ bfd_bsd_truncate_arname (abfd, pathname, arhdr) if (length <= maxlen) memcpy (hdr->ar_name, filename, length); - else { - /* pathname: meet procrustes */ - memcpy (hdr->ar_name, filename, maxlen); - length = maxlen; - } + else + { + /* pathname: meet procrustes */ + memcpy (hdr->ar_name, filename, maxlen); + length = maxlen; + } if (length < maxlen) (hdr->ar_name)[length] = ar_padchar (abfd); @@ -1299,10 +1345,11 @@ bfd_bsd_truncate_arname (abfd, pathname, arhdr) 1> strip pathname to be just the basename. 2> if it's short enuf to fit, stuff it in. 3> If it doesn't end with .o, truncate it to fit - 4> truncate it before the .o, append .o, stuff THAT in. -*/ + 4> truncate it before the .o, append .o, stuff THAT in. */ + +/* This is what gnu ar does. It's better but incompatible with the + bsd ar. */ -/* This is what gnu ar does. It's better but incompatible with the bsd ar. */ void bfd_gnu_truncate_arname (abfd, pathname, arhdr) bfd *abfd; @@ -1313,7 +1360,7 @@ bfd_gnu_truncate_arname (abfd, pathname, arhdr) int length; CONST char *filename = strrchr (pathname, '/'); int maxlen = ar_maxnamelen (abfd); - + if (filename == NULL) filename = pathname; else @@ -1323,21 +1370,23 @@ bfd_gnu_truncate_arname (abfd, pathname, arhdr) if (length <= maxlen) memcpy (hdr->ar_name, filename, length); - else { /* pathname: meet procrustes */ - memcpy (hdr->ar_name, filename, maxlen); - if ((filename[length - 2] == '.') && (filename[length - 1] == 'o')) { - hdr->ar_name[maxlen - 2] = '.'; - hdr->ar_name[maxlen - 1] = 'o'; + else + { /* pathname: meet procrustes */ + memcpy (hdr->ar_name, filename, maxlen); + if ((filename[length - 2] == '.') && (filename[length - 1] == 'o')) + { + hdr->ar_name[maxlen - 2] = '.'; + hdr->ar_name[maxlen - 1] = 'o'; + } + length = maxlen; } - length = maxlen; - } if (length < 16) (hdr->ar_name)[length] = ar_padchar (abfd); } - /* The BFD is open for write and has its format set to bfd_archive */ + boolean _bfd_write_archive_contents (arch) bfd *arch; @@ -1352,127 +1401,139 @@ _bfd_write_archive_contents (arch) /* Verify the viability of all entries; if any of them live in the filesystem (as opposed to living in an archive open for input) - then construct a fresh ar_hdr for them. - */ - for (current = arch->archive_head; current; current = current->next) { - if (bfd_write_p (current)) { - bfd_error = invalid_operation; - return false; - } - if (!current->arelt_data) { - current->arelt_data = - (PTR) bfd_ar_hdr_from_filesystem (arch, current->filename); - if (!current->arelt_data) return false; + then construct a fresh ar_hdr for them. */ + for (current = arch->archive_head; current; current = current->next) + { + if (bfd_write_p (current)) + { + bfd_error = invalid_operation; + return false; + } + if (!current->arelt_data) + { + current->arelt_data = + (PTR) bfd_ar_hdr_from_filesystem (arch, current->filename); + if (!current->arelt_data) + return false; - /* Put in the file name */ - - BFD_SEND (arch, _bfd_truncate_arname,(arch, - current->filename, - (char *) arch_hdr(current))); + /* Put in the file name */ + BFD_SEND (arch, _bfd_truncate_arname, (arch, + current->filename, + (char *) arch_hdr (current))); + } - - } - - if (makemap) { /* don't bother if we won't make a map! */ - if ((bfd_check_format (current, bfd_object)) + if (makemap) + { /* don't bother if we won't make a map! */ + if ((bfd_check_format (current, bfd_object)) #if 0 /* FIXME -- these are not set correctly */ - && ((bfd_get_file_flags (current) & HAS_SYMS)) + && ((bfd_get_file_flags (current) & HAS_SYMS)) #endif - ) - hasobjects = true; + ) + hasobjects = true; + } } - } if (!bfd_construct_extended_name_table (arch, &etable, &elength)) return false; bfd_seek (arch, (file_ptr) 0, SEEK_SET); #ifdef GNU960 - bfd_write (BFD_GNU960_ARMAG(arch), 1, SARMAG, arch); + bfd_write (BFD_GNU960_ARMAG (arch), 1, SARMAG, arch); #else bfd_write (ARMAG, 1, SARMAG, arch); #endif - if (makemap && hasobjects) { - - if (compute_and_write_armap (arch, elength) != true) { - return false; - } - } - - if (elength != 0) { - struct ar_hdr hdr; - - memset ((char *)(&hdr), 0, sizeof (struct ar_hdr)); - sprintf (&(hdr.ar_name[0]), "ARFILENAMES/"); - sprintf (&(hdr.ar_size[0]), "%-10d", (int) elength); - hdr.ar_fmag[0] = '`'; hdr.ar_fmag[1] = '\n'; - for (i = 0; i < sizeof (struct ar_hdr); i++) - if (((char *)(&hdr))[i] == '\0') (((char *)(&hdr))[i]) = ' '; - bfd_write ((char *)&hdr, 1, sizeof (struct ar_hdr), arch); - bfd_write (etable, 1, elength, arch); - if ((elength % 2) == 1) bfd_write ("\n", 1, 1, arch); - - } - - for (current = arch->archive_head; current; current = current->next) { - char buffer[DEFAULT_BUFFERSIZE]; - unsigned int remaining = arelt_size (current); - struct ar_hdr *hdr = arch_hdr(current); - /* write ar header */ - - if (bfd_write ((char *)hdr, 1, sizeof(*hdr), arch) != sizeof(*hdr)) { - syserr: - bfd_error = system_call_error; + if (makemap && hasobjects) + { + if (compute_and_write_armap (arch, elength) != true) return false; - } - if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0) goto syserr; - while (remaining) + } + + if (elength != 0) + { + struct ar_hdr hdr; + + memset ((char *) (&hdr), 0, sizeof (struct ar_hdr)); + sprintf (&(hdr.ar_name[0]), "ARFILENAMES/"); + sprintf (&(hdr.ar_size[0]), "%-10d", (int) elength); + hdr.ar_fmag[0] = '`'; + hdr.ar_fmag[1] = '\n'; + for (i = 0; i < sizeof (struct ar_hdr); i++) + if (((char *) (&hdr))[i] == '\0') + (((char *) (&hdr))[i]) = ' '; + bfd_write ((char *) &hdr, 1, sizeof (struct ar_hdr), arch); + bfd_write (etable, 1, elength, arch); + if ((elength % 2) == 1) + bfd_write ("\n", 1, 1, arch); + } + + for (current = arch->archive_head; current; current = current->next) + { + char buffer[DEFAULT_BUFFERSIZE]; + unsigned int remaining = arelt_size (current); + struct ar_hdr *hdr = arch_hdr (current); + + /* write ar header */ + if (bfd_write ((char *) hdr, 1, sizeof (*hdr), arch) != sizeof (*hdr)) + { + syserr: + bfd_error = system_call_error; + return false; + } + if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0) + goto syserr; + while (remaining) { unsigned int amt = DEFAULT_BUFFERSIZE; - if (amt > remaining) { + if (amt > remaining) amt = remaining; - } errno = 0; - if (bfd_read (buffer, amt, 1, current) != amt) { - if (errno) goto syserr; + if (bfd_read (buffer, amt, 1, current) != amt) + { + if (errno) + goto syserr; /* Looks like a truncated archive. */ bfd_error = malformed_archive; return false; - } - if (bfd_write (buffer, amt, 1, arch) != amt) goto syserr; + } + if (bfd_write (buffer, amt, 1, arch) != amt) + goto syserr; remaining -= amt; } - if ((arelt_size (current) % 2) == 1) bfd_write ("\n", 1, 1, arch); - } + if ((arelt_size (current) % 2) == 1) + bfd_write ("\n", 1, 1, arch); + } - /* Verify the timestamp in the archive file. If it would - not be accepted by the linker, rewrite it until it would be. - If anything odd happens, break out and just return. - (The Berkeley linker checks the timestamp and refuses to read the + /* Verify the timestamp in the archive file. If it would not be + accepted by the linker, rewrite it until it would be. If + anything odd happens, break out and just return. (The Berkeley + linker checks the timestamp and refuses to read the table-of-contents if it is >60 seconds less than the file's modified-time. That painful hack requires this painful hack. */ tries = 1; - do { - /* FIXME! This kludge is to avoid adding a member to the xvec, - while generating a small patch for Adobe. FIXME! The - update_armap_timestamp function call should be in the xvec, - thus: + do + { + /* FIXME! This kludge is to avoid adding a member to the xvec, + while generating a small patch for Adobe. FIXME! The + update_armap_timestamp function call should be in the xvec, + thus: if (bfd_update_armap_timestamp (arch) == true) break; ^ - Instead, we check whether in a BSD archive, and call directly. */ + Instead, we check whether in a BSD archive, and call + directly. */ - if (arch->xvec->write_armap != bsd_write_armap) + if (arch->xvec->write_armap != bsd_write_armap) break; - if (bsd_update_armap_timestamp(arch) == true) /* FIXME!!! Vector it */ + if (bsd_update_armap_timestamp (arch) == true) /* FIXME!!! Vector it */ break; - if (tries > 0) + if (tries > 0) fprintf (stderr, - "Warning: writing archive was slow: rewriting timestamp\n"); - } while (++tries < 6 ); + "Warning: writing archive was slow: rewriting timestamp\n"); + } + while (++tries < 6); return true; } @@ -1484,94 +1545,98 @@ compute_and_write_armap (arch, elength) bfd *arch; unsigned int elength; { - bfd *current; - file_ptr elt_no = 0; - struct orl *map; - int orl_max = 15000; /* fine initial default */ - int orl_count = 0; - int stridx = 0; /* string index */ + bfd *current; + file_ptr elt_no = 0; + struct orl *map; + int orl_max = 15000; /* fine initial default */ + int orl_count = 0; + int stridx = 0; /* string index */ - /* Dunno if this is the best place for this info... */ - if (elength != 0) elength += sizeof (struct ar_hdr); - elength += elength %2 ; + /* Dunno if this is the best place for this info... */ + if (elength != 0) + elength += sizeof (struct ar_hdr); + elength += elength % 2; - map = (struct orl *) bfd_zalloc (arch,orl_max * sizeof (struct orl)); - if (map == NULL) { - bfd_error = no_memory; - return false; - } - - /* Drop all the files called __.SYMDEF, we're going to make our - own */ - while (arch->archive_head && - strcmp(arch->archive_head->filename,"__.SYMDEF") == 0) + map = (struct orl *) bfd_zalloc (arch, orl_max * sizeof (struct orl)); + if (map == NULL) { - arch->archive_head = arch->archive_head->next; + bfd_error = no_memory; + return false; } - /* Map over each element */ - for (current = arch->archive_head; - current != (bfd *)NULL; - current = current->next, elt_no++) + + /* Drop all the files called __.SYMDEF, we're going to make our + own */ + while (arch->archive_head && + strcmp (arch->archive_head->filename, "__.SYMDEF") == 0) + arch->archive_head = arch->archive_head->next; + + /* Map over each element */ + for (current = arch->archive_head; + current != (bfd *) NULL; + current = current->next, elt_no++) { - if ((bfd_check_format (current, bfd_object) == true) - && ((bfd_get_file_flags (current) & HAS_SYMS))) { - asymbol **syms; - unsigned int storage; - unsigned int symcount; - unsigned int src_count; + if ((bfd_check_format (current, bfd_object) == true) + && ((bfd_get_file_flags (current) & HAS_SYMS))) + { + asymbol **syms; + unsigned int storage; + unsigned int symcount; + unsigned int src_count; - storage = get_symtab_upper_bound (current); - if (storage != 0) { - - syms = (asymbol **) bfd_zalloc (arch,storage); - if (syms == NULL) { - bfd_error = no_memory; /* FIXME -- memory leak */ - return false; - } - symcount = bfd_canonicalize_symtab (current, syms); + storage = get_symtab_upper_bound (current); + if (storage != 0) + { + syms = (asymbol **) bfd_zalloc (arch, storage); + if (syms == NULL) + { + bfd_error = no_memory; /* FIXME -- memory leak */ + return false; + } + symcount = bfd_canonicalize_symtab (current, syms); - /* Now map over all the symbols, picking out the ones we want */ - for (src_count = 0; src_count flags; - asection *sec = - syms[src_count]->section; - - if ((flags & BSF_GLOBAL || - flags & BSF_WEAK || - flags & BSF_INDIRECT || - bfd_is_com_section (sec)) - && (sec != &bfd_und_section)) { + /* Now map over all the symbols, picking out the ones we want */ + for (src_count = 0; src_count < symcount; src_count++) + { + flagword flags = + (syms[src_count])->flags; + asection *sec = + syms[src_count]->section; - /* This symbol will go into the archive header */ - if (orl_count == orl_max) - { - orl_max *= 2; - map = (struct orl *) bfd_realloc (arch, (char *) map, - orl_max * sizeof (struct orl)); - } + if ((flags & BSF_GLOBAL || + flags & BSF_WEAK || + flags & BSF_INDIRECT || + bfd_is_com_section (sec)) + && (sec != &bfd_und_section)) + { + /* This symbol will go into the archive header */ + if (orl_count == orl_max) + { + orl_max *= 2; + map = ((struct orl *) + bfd_realloc (arch, (char *) map, + orl_max * sizeof (struct orl))); + } - (map[orl_count]).name = (char **) &((syms[src_count])->name); - (map[orl_count]).pos = (file_ptr) current; - (map[orl_count]).namidx = stridx; + (map[orl_count]).name = + (char **) &((syms[src_count])->name); + (map[orl_count]).pos = (file_ptr) current; + (map[orl_count]).namidx = stridx; - stridx += strlen ((syms[src_count])->name) + 1; - ++orl_count; - } - } + stridx += strlen ((syms[src_count])->name) + 1; + ++orl_count; } + } } - } - /* OK, now we have collected all the data, let's write them out */ - if (!BFD_SEND (arch, write_armap, - (arch, elength, map, orl_count, stridx))) { - - return false; } + } + /* OK, now we have collected all the data, let's write them out */ + if (!BFD_SEND (arch, write_armap, + (arch, elength, map, orl_count, stridx))) + return false; - return true; + return true; } boolean @@ -1599,58 +1664,63 @@ bsd_write_armap (arch, elength, map, orl_count, stridx) firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG; stat (arch->filename, &statbuf); - memset ((char *)(&hdr), 0, sizeof (struct ar_hdr)); + memset ((char *) (&hdr), 0, sizeof (struct ar_hdr)); sprintf (hdr.ar_name, RANLIBMAG); /* Remember the timestamp, to keep it holy. But fudge it a little. */ - bfd_ardata(arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET; - bfd_ardata(arch)->armap_datepos = SARMAG + - offsetof(struct ar_hdr, ar_date[0]); - sprintf (hdr.ar_date, "%ld", bfd_ardata(arch)->armap_timestamp); - sprintf (hdr.ar_uid, "%d", getuid()); - sprintf (hdr.ar_gid, "%d", getgid()); + bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET; + bfd_ardata (arch)->armap_datepos = (SARMAG + + offsetof (struct ar_hdr, ar_date[0])); + sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp); + sprintf (hdr.ar_uid, "%d", getuid ()); + sprintf (hdr.ar_gid, "%d", getgid ()); sprintf (hdr.ar_size, "%-10d", (int) mapsize); - hdr.ar_fmag[0] = '`'; hdr.ar_fmag[1] = '\n'; + hdr.ar_fmag[0] = '`'; + hdr.ar_fmag[1] = '\n'; for (i = 0; i < sizeof (struct ar_hdr); i++) - if (((char *)(&hdr))[i] == '\0') (((char *)(&hdr))[i]) = ' '; - bfd_write ((char *)&hdr, 1, sizeof (struct ar_hdr), arch); - bfd_h_put_32(arch, (bfd_vma) ranlibsize, (PTR)&temp); + if (((char *) (&hdr))[i] == '\0') + (((char *) (&hdr))[i]) = ' '; + bfd_write ((char *) &hdr, 1, sizeof (struct ar_hdr), arch); + bfd_h_put_32 (arch, (bfd_vma) ranlibsize, (PTR) & temp); bfd_write (&temp, 1, sizeof (temp), arch); - - for (count = 0; count < orl_count; count++) { - struct symdef outs; - struct symdef *outp = &outs; - - if (((bfd *)(map[count]).pos) != last_elt) { - do { - firstreal += arelt_size (current) + sizeof (struct ar_hdr); - firstreal += firstreal % 2; - current = current->next; - } while (current != (bfd *)(map[count]).pos); - } /* if new archive element */ - last_elt = current; - bfd_h_put_32(arch, ((map[count]).namidx),(PTR) &outs.s.string_offset); - bfd_h_put_32(arch, firstreal,(PTR) &outs.file_offset); - bfd_write ((char *)outp, 1, sizeof (outs), arch); - } + for (count = 0; count < orl_count; count++) + { + struct symdef outs; + struct symdef *outp = &outs; + + if (((bfd *) (map[count]).pos) != last_elt) + { + do + { + firstreal += arelt_size (current) + sizeof (struct ar_hdr); + firstreal += firstreal % 2; + current = current->next; + } + while (current != (bfd *) (map[count]).pos); + } /* if new archive element */ + + last_elt = current; + bfd_h_put_32 (arch, ((map[count]).namidx), (PTR) & outs.s.string_offset); + bfd_h_put_32 (arch, firstreal, (PTR) & outs.file_offset); + bfd_write ((char *) outp, 1, sizeof (outs), arch); + } /* now write the strings themselves */ - bfd_h_put_32(arch, stringsize, (PTR)&temp); - bfd_write ((PTR)&temp, 1, sizeof (temp), arch); + bfd_h_put_32 (arch, stringsize, (PTR) & temp); + bfd_write ((PTR) & temp, 1, sizeof (temp), arch); for (count = 0; count < orl_count; count++) - bfd_write (*((map[count]).name), 1, strlen (*((map[count]).name))+1, arch); + bfd_write (*((map[count]).name), 1, strlen (*((map[count]).name)) + 1, arch); /* The spec sez this should be a newline. But in order to be bug-compatible for sun's ar we use a null. */ if (padit) - bfd_write("",1,1,arch); + bfd_write ("", 1, 1, arch); return true; } - /* At the end of archive file handling, update the timestamp in the - file, so the linker will accept it. + file, so the linker will accept it. Return true if the timestamp was OK, or an unusual problem happened. Return false if we updated the timestamp. */ @@ -1666,48 +1736,48 @@ bsd_update_armap_timestamp (arch) /* Flush writes, get last-write timestamp from file, and compare it to the timestamp IN the file. */ bfd_flush (arch); - if (bfd_stat (arch, &archstat) == -1) { - perror ("Reading archive file mod timestamp"); - return true; /* Can't read mod time for some reason */ - } - if (archstat.st_mtime <= bfd_ardata(arch)->armap_timestamp) + if (bfd_stat (arch, &archstat) == -1) + { + perror ("Reading archive file mod timestamp"); + return true; /* Can't read mod time for some reason */ + } + if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp) return true; /* OK by the linker's rules */ /* Update the timestamp. */ - bfd_ardata(arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET; + bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET; /* Prepare an ASCII version suitable for writing. */ memset (hdr.ar_date, 0, sizeof (hdr.ar_date)); - sprintf (hdr.ar_date, "%ld", bfd_ardata(arch)->armap_timestamp); + sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp); for (i = 0; i < sizeof (hdr.ar_date); i++) - if (hdr.ar_date[i] == '\0') - (hdr.ar_date)[i] = ' '; + if (hdr.ar_date[i] == '\0') + (hdr.ar_date)[i] = ' '; /* Write it into the file. */ - bfd_seek (arch, bfd_ardata(arch)->armap_datepos, SEEK_SET); - if (bfd_write (hdr.ar_date, sizeof(hdr.ar_date), 1, arch) - != sizeof(hdr.ar_date)) { - perror ("Writing updated armap timestamp"); - return true; /* Some error while writing */ - } + bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET); + if (bfd_write (hdr.ar_date, sizeof (hdr.ar_date), 1, arch) + != sizeof (hdr.ar_date)) + { + perror ("Writing updated armap timestamp"); + return true; /* Some error while writing */ + } return false; /* We updated the timestamp successfully. */ } - /* A coff armap looks like : - lARMAG - struct ar_hdr with name = '/' - number of symbols - offset of file for symbol 0 - offset of file for symbol 1 + lARMAG + struct ar_hdr with name = '/' + number of symbols + offset of file for symbol 0 + offset of file for symbol 1 - offset of file for symbol n-1 - symbol name 0 - symbol name 1 - - symbol name n-1 + offset of file for symbol n-1 + symbol name 0 + symbol name 1 + symbol name n-1 */ boolean @@ -1718,81 +1788,84 @@ coff_write_armap (arch, elength, map, symbol_count, stridx) unsigned int symbol_count; int stridx; { - /* The size of the ranlib is the number of exported symbols in the - archive * the number of bytes in a int, + an int for the count */ + /* The size of the ranlib is the number of exported symbols in the + archive * the number of bytes in a int, + an int for the count */ + unsigned int ranlibsize = (symbol_count * 4) + 4; + unsigned int stringsize = stridx; + unsigned int mapsize = stringsize + ranlibsize; + file_ptr archive_member_file_ptr; + bfd *current = arch->archive_head; + int count; + struct ar_hdr hdr; + unsigned int i; + int padit = mapsize & 1; - unsigned int ranlibsize = (symbol_count * 4) + 4; - unsigned int stringsize = stridx; - unsigned int mapsize = stringsize + ranlibsize; - file_ptr archive_member_file_ptr; - bfd *current = arch->archive_head; - int count; - struct ar_hdr hdr; - unsigned int i; - int padit = mapsize & 1; - - if (padit) mapsize ++; + if (padit) + mapsize++; - /* work out where the first object file will go in the archive */ - archive_member_file_ptr = mapsize + elength + sizeof (struct ar_hdr) + SARMAG; + /* work out where the first object file will go in the archive */ + archive_member_file_ptr = (mapsize + + elength + + sizeof (struct ar_hdr) + + SARMAG); - memset ((char *)(&hdr), 0, sizeof (struct ar_hdr)); - hdr.ar_name[0] = '/'; - sprintf (hdr.ar_size, "%-10d", (int) mapsize); - sprintf (hdr.ar_date, "%ld", (long)time (NULL)); - /* This, at least, is what Intel coff sets the values to.: */ - sprintf ((hdr.ar_uid), "%d", 0); - sprintf ((hdr.ar_gid), "%d", 0); - sprintf ((hdr.ar_mode), "%-7o",(unsigned ) 0); - hdr.ar_fmag[0] = '`'; hdr.ar_fmag[1] = '\n'; + memset ((char *) (&hdr), 0, sizeof (struct ar_hdr)); + hdr.ar_name[0] = '/'; + sprintf (hdr.ar_size, "%-10d", (int) mapsize); + sprintf (hdr.ar_date, "%ld", (long) time (NULL)); + /* This, at least, is what Intel coff sets the values to.: */ + sprintf ((hdr.ar_uid), "%d", 0); + sprintf ((hdr.ar_gid), "%d", 0); + sprintf ((hdr.ar_mode), "%-7o", (unsigned) 0); + hdr.ar_fmag[0] = '`'; + hdr.ar_fmag[1] = '\n'; - for (i = 0; i < sizeof (struct ar_hdr); i++) - if (((char *)(&hdr))[i] == '\0') (((char *)(&hdr))[i]) = ' '; + for (i = 0; i < sizeof (struct ar_hdr); i++) + if (((char *) (&hdr))[i] == '\0') + (((char *) (&hdr))[i]) = ' '; - /* Write the ar header for this item and the number of symbols */ + /* Write the ar header for this item and the number of symbols */ - - bfd_write ((PTR)&hdr, 1, sizeof (struct ar_hdr), arch); + bfd_write ((PTR) & hdr, 1, sizeof (struct ar_hdr), arch); - bfd_write_bigendian_4byte_int(arch, symbol_count); + bfd_write_bigendian_4byte_int (arch, symbol_count); - /* Two passes, first write the file offsets for each symbol - - remembering that each offset is on a two byte boundary. */ + /* Two passes, first write the file offsets for each symbol - + remembering that each offset is on a two byte boundary. */ - /* Write out the file offset for the file associated with each - symbol, and remember to keep the offsets padded out. */ + /* Write out the file offset for the file associated with each + symbol, and remember to keep the offsets padded out. */ - current = arch->archive_head; - count = 0; - while (current != (bfd *)NULL && count < symbol_count) { - /* For each symbol which is used defined in this object, write out - the object file's address in the archive */ - - while (((bfd *)(map[count]).pos) == current) { - bfd_write_bigendian_4byte_int(arch, archive_member_file_ptr); - count++; + current = arch->archive_head; + count = 0; + while (current != (bfd *) NULL && count < symbol_count) + { + /* For each symbol which is used defined in this object, write out + the object file's address in the archive */ + + while (((bfd *) (map[count]).pos) == current) + { + bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr); + count++; } - /* Add size of this archive entry */ - archive_member_file_ptr += arelt_size (current) + sizeof (struct - ar_hdr); - /* remember aboout the even alignment */ - archive_member_file_ptr += archive_member_file_ptr % 2; - current = current->next; - } - - - - /* now write the strings themselves */ - for (count = 0; count < symbol_count; count++) { - bfd_write ((PTR)*((map[count]).name), - 1, - strlen (*((map[count]).name))+1, arch); - + /* Add size of this archive entry */ + archive_member_file_ptr += arelt_size (current) + sizeof (struct + ar_hdr); + /* remember aboout the even alignment */ + archive_member_file_ptr += archive_member_file_ptr % 2; + current = current->next; } - /* The spec sez this should be a newline. But in order to be - bug-compatible for arc960 we use a null. */ - if (padit) - bfd_write("",1,1,arch); - return true; + /* now write the strings themselves */ + for (count = 0; count < symbol_count; count++) + bfd_write ((PTR) * ((map[count]).name), + 1, + strlen (*((map[count]).name)) + 1, arch); + + /* The spec sez this should be a newline. But in order to be + bug-compatible for arc960 we use a null. */ + if (padit) + bfd_write ("", 1, 1, arch); + + return true; }