+ return (PTR) ret;
+}
+
+/* Open the next element in an XCOFF archive. */
+
+bfd *
+_bfd_xcoff_openr_next_archived_file (archive, last_file)
+ bfd *archive;
+ bfd *last_file;
+{
+ file_ptr filestart;
+
+ if (xcoff_ardata (archive) == NULL)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return NULL;
+ }
+
+ if (! xcoff_big_format_p (archive))
+ {
+ if (last_file == NULL)
+ filestart = bfd_ardata (archive)->first_file_filepos;
+ else
+ filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
+ 10);
+
+ if (filestart == 0
+ || filestart == strtol (xcoff_ardata (archive)->memoff,
+ (char **) NULL, 10)
+ || filestart == strtol (xcoff_ardata (archive)->symoff,
+ (char **) NULL, 10))
+ {
+ bfd_set_error (bfd_error_no_more_archived_files);
+ return NULL;
+ }
+ }
+ else
+ {
+ if (last_file == NULL)
+ filestart = bfd_ardata (archive)->first_file_filepos;
+ else
+ /* XXX These actually have to be a calls to strtoll (at least
+ on 32-bit machines) since the fields's width is 20 and
+ there numbers with more than 32 bits can be represented. */
+ filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
+ 10);
+
+ /* XXX These actually have to be calls to strtoll (at least on 32-bit
+ machines) since the fields's width is 20 and there numbers with more
+ than 32 bits can be represented. */
+ if (filestart == 0
+ || filestart == strtol (xcoff_ardata_big (archive)->memoff,
+ (char **) NULL, 10)
+ || filestart == strtol (xcoff_ardata_big (archive)->symoff,
+ (char **) NULL, 10))
+ {
+ bfd_set_error (bfd_error_no_more_archived_files);
+ return NULL;
+ }
+ }
+
+ return _bfd_get_elt_at_filepos (archive, filestart);
+}
+
+/* Stat an element in an XCOFF archive. */
+
+int
+_bfd_xcoff_stat_arch_elt (abfd, s)
+ bfd *abfd;
+ struct stat *s;
+{
+ if (abfd->arelt_data == NULL)
+ {
+ bfd_set_error (bfd_error_invalid_operation);
+ return -1;
+ }
+
+ if (! xcoff_big_format_p (abfd->my_archive))
+ {
+ struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
+
+ s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
+ s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
+ s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
+ s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
+ s->st_size = arch_eltdata (abfd)->parsed_size;
+ }
+ else
+ {
+ struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
+
+ s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
+ s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
+ s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
+ s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
+ s->st_size = arch_eltdata (abfd)->parsed_size;
+ }
+
+ return 0;
+}
+
+/* Normalize a file name for inclusion in an archive. */
+
+static const char *
+normalize_filename (abfd)
+ bfd *abfd;
+{
+ const char *file;
+ const char *filename;
+
+ file = bfd_get_filename (abfd);
+ filename = strrchr (file, '/');
+ if (filename != NULL)
+ filename++;
+ else
+ filename = file;
+ return filename;
+}
+
+/* Write out an XCOFF armap. */
+
+/*ARGSUSED*/
+static boolean
+xcoff_write_armap_old (abfd, elength, map, orl_count, stridx)
+ bfd *abfd;
+ unsigned int elength ATTRIBUTE_UNUSED;
+ struct orl *map;
+ unsigned int orl_count;
+ int stridx;
+{
+ struct xcoff_ar_hdr hdr;
+ char *p;
+ unsigned char buf[4];
+ bfd *sub;
+ file_ptr fileoff;
+ unsigned int i;
+
+ memset (&hdr, 0, sizeof hdr);
+ sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
+ sprintf (hdr.nextoff, "%d", 0);
+ memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE);
+ sprintf (hdr.date, "%d", 0);
+ sprintf (hdr.uid, "%d", 0);
+ sprintf (hdr.gid, "%d", 0);
+ sprintf (hdr.mode, "%d", 0);
+ sprintf (hdr.namlen, "%d", 0);
+
+ /* We need spaces, not null bytes, in the header. */
+ for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
+ if (*p == '\0')
+ *p = ' ';
+
+ if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
+ != SIZEOF_AR_HDR
+ || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
+ != SXCOFFARFMAG))
+ return false;
+
+ H_PUT_32 (abfd, orl_count, buf);
+ if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
+ return false;
+
+ sub = abfd->archive_head;
+ fileoff = SIZEOF_AR_FILE_HDR;
+ i = 0;
+ while (sub != NULL && i < orl_count)
+ {
+ size_t namlen;
+
+ while (map[i].u.abfd == sub)
+ {
+ H_PUT_32 (abfd, fileoff, buf);
+ if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
+ return false;
+ ++i;
+ }
+ namlen = strlen (normalize_filename (sub));
+ namlen = (namlen + 1) &~ (size_t) 1;
+ fileoff += (SIZEOF_AR_HDR
+ + namlen
+ + SXCOFFARFMAG
+ + arelt_size (sub));
+ fileoff = (fileoff + 1) &~ 1;
+ sub = sub->next;
+ }
+
+ for (i = 0; i < orl_count; i++)
+ {
+ const char *name;
+ size_t namlen;
+
+ name = *map[i].name;
+ namlen = strlen (name);
+ if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1)
+ return false;
+ }
+
+ if ((stridx & 1) != 0)
+ {
+ char b;
+
+ b = '\0';
+ if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
+ return false;
+ }
+
+ return true;
+}
+
+static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1];
+#define FMT20 "%-20lld"
+#define FMT12 "%-12d"
+#define FMT12_OCTAL "%-12o"
+#define FMT4 "%-4d"
+#define PRINT20(d, v) \
+ sprintf (buff20, FMT20, (long long)(v)), \
+ memcpy ((void *) (d), buff20, 20)
+
+#define PRINT12(d, v) \
+ sprintf (buff20, FMT12, (int)(v)), \
+ memcpy ((void *) (d), buff20, 12)
+
+#define PRINT12_OCTAL(d, v) \
+ sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \
+ memcpy ((void *) (d), buff20, 12)
+
+#define PRINT4(d, v) \
+ sprintf (buff20, FMT4, (int)(v)), \
+ memcpy ((void *) (d), buff20, 4)
+
+#define READ20(d, v) \
+ buff20[20] = 0, \
+ memcpy (buff20, (d), 20), \
+ (v) = bfd_scan_vma (buff20, (const char **) NULL, 10)
+
+static boolean
+do_pad (abfd, number)
+ bfd *abfd;
+ unsigned int number;
+{
+ bfd_byte b = 0;
+
+ /* Limit pad to <= 4096. */
+ if (number > 4096)
+ return false;
+
+ while (number--)
+ if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
+ return false;
+
+ return true;
+}
+
+static boolean
+do_copy (out_bfd, in_bfd)
+ bfd *out_bfd;
+ bfd *in_bfd;
+{
+ bfd_size_type remaining;
+ bfd_byte buffer[DEFAULT_BUFFERSIZE];
+
+ if (bfd_seek (in_bfd, (file_ptr) 0, SEEK_SET) != 0)
+ return false;
+
+ remaining = arelt_size (in_bfd);
+
+ while (remaining >= DEFAULT_BUFFERSIZE)
+ {
+ if (bfd_bread (buffer, DEFAULT_BUFFERSIZE, in_bfd) != DEFAULT_BUFFERSIZE
+ || bfd_bwrite (buffer, DEFAULT_BUFFERSIZE, out_bfd) != DEFAULT_BUFFERSIZE)
+ return false;
+
+ remaining -= DEFAULT_BUFFERSIZE;
+ }
+
+ if (remaining)
+ {
+ if (bfd_bread (buffer, remaining, in_bfd) != remaining
+ || bfd_bwrite (buffer, remaining, out_bfd) != remaining)
+ return false;
+ }
+
+ return true;
+}
+
+static boolean
+do_shared_object_padding (out_bfd, in_bfd, offset, ar_header_size)
+ bfd *out_bfd;
+ bfd *in_bfd;
+ ufile_ptr *offset;
+ int ar_header_size;
+{
+ if (bfd_check_format (in_bfd, bfd_object)
+ && bfd_get_flavour (in_bfd) == bfd_target_xcoff_flavour
+ && (in_bfd->flags & DYNAMIC) != 0)
+ {
+ bfd_size_type pad = 0;
+ int text_align_power;
+
+ text_align_power = bfd_xcoff_text_align_power (in_bfd);
+ BFD_ASSERT (2 < text_align_power);
+
+ pad = 1 << text_align_power;
+ pad -= (*offset + ar_header_size) & (pad - 1);
+
+ if (! do_pad (out_bfd, pad))
+ return false;
+
+ *offset += pad;
+ }
+
+ return true;
+}
+
+static boolean
+xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
+ bfd *abfd;
+ unsigned int elength ATTRIBUTE_UNUSED;
+ struct orl *map;
+ unsigned int orl_count;
+ int stridx;
+{
+ struct xcoff_ar_file_hdr_big *fhdr;
+ bfd_vma i, sym_32, sym_64, str_32, str_64;
+ const bfd_arch_info_type *arch_info = NULL;
+ bfd *current_bfd;
+ size_t string_length;
+ ufile_ptr nextoff, prevoff;
+
+ /* First, we look through the symbols and work out which are
+ from 32-bit objects and which from 64-bit ones. */
+ sym_32 = sym_64 = str_32 = str_64 = 0;
+
+ current_bfd = abfd->archive_head;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ i = 0;
+ while (current_bfd != NULL && i < orl_count)
+ {
+ while (map[i].u.abfd == current_bfd)
+ {
+ string_length = strlen (*map[i].name) + 1;
+
+ if (arch_info->bits_per_address == 64)
+ {
+ sym_64++;
+ str_64 += string_length;
+ }
+ else
+ {
+ sym_32++;
+ str_32 += string_length;
+ }
+ i++;
+ }
+ current_bfd = current_bfd->next;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ }
+
+ /* A quick sanity check... */
+ BFD_ASSERT (sym_64 + sym_32 == orl_count);
+ /* Explicit cast to int for compiler. */
+ BFD_ASSERT ((int)(str_64 + str_32) == stridx);
+
+ fhdr = xcoff_ardata_big (abfd);
+
+ /* xcoff_write_archive_contents_big passes nextoff in symoff. */
+ READ20 (fhdr->memoff, prevoff);
+ READ20 (fhdr->symoff, nextoff);
+
+ BFD_ASSERT (nextoff == bfd_tell (abfd));
+
+ /* Write out the symbol table.
+ Layout :
+
+ standard big archive header
+ 0x0000 ar_size [0x14]
+ 0x0014 ar_nxtmem [0x14]
+ 0x0028 ar_prvmem [0x14]
+ 0x003C ar_date [0x0C]
+ 0x0048 ar_uid [0x0C]
+ 0x0054 ar_gid [0x0C]
+ 0x0060 ar_mod [0x0C]
+ 0x006C ar_namelen[0x04]
+ 0x0070 ar_fmag [SXCOFFARFMAG]
+
+ Symbol table
+ 0x0072 num_syms [0x08], binary
+ 0x0078 offsets [0x08 * num_syms], binary
+ 0x0086 + 0x08 * num_syms names [??]
+ ?? pad to even bytes.
+ */
+
+ if (sym_32)
+ {
+ struct xcoff_ar_hdr_big *hdr;
+ bfd_byte *symbol_table;
+ bfd_byte *st;
+ file_ptr fileoff;
+
+ bfd_vma symbol_table_size =
+ SIZEOF_AR_HDR_BIG
+ + SXCOFFARFMAG
+ + 8
+ + 8 * sym_32
+ + str_32 + (str_32 & 1);
+
+ symbol_table = NULL;
+ symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
+ if (symbol_table == NULL)
+ return false;
+ memset (symbol_table, 0, symbol_table_size);
+
+ hdr = (struct xcoff_ar_hdr_big *) symbol_table;
+
+ PRINT20 (hdr->size, 8 + 8 * sym_32 + str_32 + (str_32 & 1));
+
+ if (sym_64)
+ PRINT20 (hdr->nextoff, nextoff + symbol_table_size);
+ else
+ PRINT20 (hdr->nextoff, 0);
+
+ PRINT20 (hdr->prevoff, prevoff);
+ PRINT12 (hdr->date, 0);
+ PRINT12 (hdr->uid, 0);
+ PRINT12 (hdr->gid, 0);
+ PRINT12 (hdr->mode, 0);
+ PRINT4 (hdr->namlen, 0) ;
+
+ st = symbol_table + SIZEOF_AR_HDR_BIG;
+ memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
+ st += SXCOFFARFMAG;
+
+ bfd_h_put_64 (abfd, sym_32, st);
+ st += 8;
+
+ /* loop over the 32 bit offsets */
+ current_bfd = abfd->archive_head;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ fileoff = SIZEOF_AR_FILE_HDR_BIG;
+ i = 0;
+ while (current_bfd != NULL && i < orl_count)
+ {
+ while (map[i].u.abfd == current_bfd)
+ {
+ if (arch_info->bits_per_address == 32)
+ {
+ bfd_h_put_64 (abfd, fileoff, st);
+ st += 8;
+ }
+ i++;
+ }
+ string_length = strlen (normalize_filename (current_bfd));
+ string_length += string_length & 1;
+ fileoff += (SIZEOF_AR_HDR_BIG
+ + string_length
+ + SXCOFFARFMAG
+ + arelt_size (current_bfd));
+ fileoff += fileoff & 1;
+ current_bfd = current_bfd->next;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ }
+
+ /* loop over the 32 bit symbol names */
+ current_bfd = abfd->archive_head;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ i = 0;
+ while (current_bfd != NULL && i < orl_count)
+ {
+ while (map[i].u.abfd == current_bfd)
+ {
+ if (arch_info->bits_per_address == 32)
+ {
+ string_length = sprintf (st, "%s", *map[i].name);
+ st += string_length + 1;
+ }
+ i++;
+ }
+ current_bfd = current_bfd->next;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ }
+
+ bfd_bwrite (symbol_table, symbol_table_size, abfd);
+
+ free (symbol_table);
+ symbol_table = NULL;
+
+ prevoff = nextoff;
+ nextoff = nextoff + symbol_table_size;
+ }
+ else
+ PRINT20 (fhdr->symoff, 0);
+
+ if (sym_64)
+ {
+ struct xcoff_ar_hdr_big *hdr;
+ bfd_byte *symbol_table;
+ bfd_byte *st;
+ file_ptr fileoff;
+
+ bfd_vma symbol_table_size =
+ SIZEOF_AR_HDR_BIG
+ + SXCOFFARFMAG
+ + 8
+ + 8 * sym_64
+ + str_64 + (str_64 & 1);
+
+ symbol_table = NULL;
+ symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
+ if (symbol_table == NULL)
+ return false;
+ memset (symbol_table, 0, symbol_table_size);
+
+ hdr = (struct xcoff_ar_hdr_big *) symbol_table;
+
+ PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1));
+ PRINT20 (hdr->nextoff, 0);
+ PRINT20 (hdr->prevoff, prevoff);
+ PRINT12 (hdr->date, 0);
+ PRINT12 (hdr->uid, 0);
+ PRINT12 (hdr->gid, 0);
+ PRINT12 (hdr->mode, 0);
+ PRINT4 (hdr->namlen, 0);
+
+ st = symbol_table + SIZEOF_AR_HDR_BIG;
+ memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
+ st += SXCOFFARFMAG;
+
+ bfd_h_put_64 (abfd, sym_64, st);
+ st += 8;
+
+ /* loop over the 64 bit offsets */
+ current_bfd = abfd->archive_head;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ fileoff = SIZEOF_AR_FILE_HDR_BIG;
+ i = 0;
+ while (current_bfd != NULL && i < orl_count)
+ {
+ while (map[i].u.abfd == current_bfd)
+ {
+ if (arch_info->bits_per_address == 64)
+ {
+ bfd_h_put_64 (abfd, fileoff, st);
+ st += 8;
+ }
+ i++;
+ }
+ string_length = strlen (normalize_filename (current_bfd));
+ string_length += string_length & 1;
+ fileoff += (SIZEOF_AR_HDR_BIG
+ + string_length
+ + SXCOFFARFMAG
+ + arelt_size (current_bfd));
+ fileoff += fileoff & 1;
+ current_bfd = current_bfd->next;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ }
+
+ /* loop over the 64 bit symbol names */
+ current_bfd = abfd->archive_head;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ i = 0;
+ while (current_bfd != NULL && i < orl_count)
+ {
+ while (map[i].u.abfd == current_bfd)
+ {
+ if (arch_info->bits_per_address == 64)
+ {
+ string_length = sprintf (st, "%s", *map[i].name);
+ st += string_length + 1;
+ }
+ i++;
+ }
+ current_bfd = current_bfd->next;
+ if (current_bfd != NULL)
+ arch_info = bfd_get_arch_info (current_bfd);
+ }
+
+ bfd_bwrite (symbol_table, symbol_table_size, abfd);
+
+ free (symbol_table);
+ symbol_table = NULL;
+
+ PRINT20 (fhdr->symoff64, nextoff);
+ }
+ else
+ PRINT20 (fhdr->symoff64, 0);
+
+ return true;
+}
+
+boolean
+_bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx)
+ bfd *abfd;
+ unsigned int elength ATTRIBUTE_UNUSED;
+ struct orl *map;
+ unsigned int orl_count;
+ int stridx;
+{
+ if (! xcoff_big_format_p (abfd))
+ return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
+ else
+ return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
+}
+
+/* Write out an XCOFF archive. We always write an entire archive,
+ rather than fussing with the freelist and so forth. */
+
+static boolean
+xcoff_write_archive_contents_old (abfd)
+ bfd *abfd;
+{
+ struct xcoff_ar_file_hdr fhdr;
+ bfd_size_type count;
+ bfd_size_type total_namlen;
+ file_ptr *offsets;
+ boolean makemap;
+ boolean hasobjects;
+ ufile_ptr prevoff, nextoff;
+ bfd *sub;
+ size_t i;
+ struct xcoff_ar_hdr ahdr;
+ bfd_size_type size;
+ char *p;
+ char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1];
+
+ memset (&fhdr, 0, sizeof fhdr);
+ strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
+ sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
+ sprintf (fhdr.freeoff, "%d", 0);
+
+ count = 0;
+ total_namlen = 0;
+ for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
+ {
+ ++count;
+ total_namlen += strlen (normalize_filename (sub)) + 1;
+ }
+ offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
+ if (offsets == NULL)
+ return false;
+
+ if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
+ return false;
+
+ makemap = bfd_has_map (abfd);
+ hasobjects = false;
+ prevoff = 0;
+ nextoff = SIZEOF_AR_FILE_HDR;
+ for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
+ {
+ const char *name;
+ bfd_size_type namlen;
+ struct xcoff_ar_hdr *ahdrp;
+ bfd_size_type remaining;
+
+ if (makemap && ! hasobjects)
+ {
+ if (bfd_check_format (sub, bfd_object))
+ hasobjects = true;
+ }
+
+ name = normalize_filename (sub);
+ namlen = strlen (name);
+
+ if (sub->arelt_data != NULL)
+ ahdrp = arch_xhdr (sub);
+ else
+ ahdrp = NULL;
+
+ if (ahdrp == NULL)
+ {
+ struct stat s;
+
+ memset (&ahdr, 0, sizeof ahdr);
+ ahdrp = &ahdr;
+ if (stat (bfd_get_filename (sub), &s) != 0)
+ {
+ bfd_set_error (bfd_error_system_call);
+ return false;
+ }
+
+ sprintf (ahdrp->size, "%ld", (long) s.st_size);
+ sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
+ sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
+ sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
+ sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
+
+ if (sub->arelt_data == NULL)
+ {
+ size = sizeof (struct areltdata);
+ sub->arelt_data = bfd_alloc (sub, size);
+ if (sub->arelt_data == NULL)
+ return false;
+ }
+
+ arch_eltdata (sub)->parsed_size = s.st_size;
+ }
+
+ sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
+ sprintf (ahdrp->namlen, "%ld", (long) namlen);
+
+ /* If the length of the name is odd, we write out the null byte
+ after the name as well. */
+ namlen = (namlen + 1) &~ (bfd_size_type) 1;
+
+ remaining = arelt_size (sub);
+ size = (SIZEOF_AR_HDR
+ + namlen
+ + SXCOFFARFMAG
+ + remaining);
+
+ BFD_ASSERT (nextoff == bfd_tell (abfd));
+
+ offsets[i] = nextoff;
+
+ prevoff = nextoff;
+ nextoff += size + (size & 1);
+
+ sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
+
+ /* We need spaces, not null bytes, in the header. */
+ for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
+ if (*p == '\0')
+ *p = ' ';
+
+ if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR, abfd)
+ != SIZEOF_AR_HDR)
+ || (bfd_bwrite ((PTR) name, namlen, abfd) != namlen)
+ || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
+ != SXCOFFARFMAG))
+ return false;
+
+ if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
+ return false;
+
+ if (! do_copy (abfd, sub))
+ return false;
+
+ if (! do_pad (abfd, size & 1))
+ return false;
+ }
+
+ sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
+
+ /* Write out the member table. */
+
+ BFD_ASSERT (nextoff == bfd_tell (abfd));
+ sprintf (fhdr.memoff, "%ld", (long) nextoff);
+
+ memset (&ahdr, 0, sizeof ahdr);
+ sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE +
+ count * XCOFFARMAG_ELEMENT_SIZE +
+ total_namlen));
+ sprintf (ahdr.prevoff, "%ld", (long) prevoff);
+ sprintf (ahdr.date, "%d", 0);
+ sprintf (ahdr.uid, "%d", 0);
+ sprintf (ahdr.gid, "%d", 0);
+ sprintf (ahdr.mode, "%d", 0);
+ sprintf (ahdr.namlen, "%d", 0);
+
+ size = (SIZEOF_AR_HDR
+ + XCOFFARMAG_ELEMENT_SIZE
+ + count * XCOFFARMAG_ELEMENT_SIZE
+ + total_namlen
+ + SXCOFFARFMAG);
+
+ prevoff = nextoff;
+ nextoff += size + (size & 1);
+
+ if (makemap && hasobjects)
+ sprintf (ahdr.nextoff, "%ld", (long) nextoff);
+ else
+ sprintf (ahdr.nextoff, "%d", 0);
+
+ /* We need spaces, not null bytes, in the header. */
+ for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
+ if (*p == '\0')
+ *p = ' ';
+
+ if ((bfd_bwrite ((PTR) &ahdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
+ != SIZEOF_AR_HDR)
+ || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
+ != SXCOFFARFMAG))
+ return false;
+
+ sprintf (decbuf, "%-12ld", (long) count);
+ if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd)
+ != XCOFFARMAG_ELEMENT_SIZE)
+ return false;
+ for (i = 0; i < (size_t) count; i++)
+ {
+ sprintf (decbuf, "%-12ld", (long) offsets[i]);
+ if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE,
+ abfd) != XCOFFARMAG_ELEMENT_SIZE)
+ return false;
+ }
+ for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
+ {
+ const char *name;
+ bfd_size_type namlen;
+
+ name = normalize_filename (sub);
+ namlen = strlen (name);
+ if (bfd_bwrite ((PTR) name, namlen + 1, abfd) != namlen + 1)
+ return false;
+ }
+
+ if (! do_pad (abfd, size & 1))
+ return false;
+
+ /* Write out the armap, if appropriate. */
+ if (! makemap || ! hasobjects)
+ sprintf (fhdr.symoff, "%d", 0);
+ else
+ {
+ BFD_ASSERT (nextoff == bfd_tell (abfd));
+ sprintf (fhdr.symoff, "%ld", (long) nextoff);
+ bfd_ardata (abfd)->tdata = (PTR) &fhdr;
+ if (! _bfd_compute_and_write_armap (abfd, 0))
+ return false;
+ }
+
+ /* Write out the archive file header. */
+
+ /* We need spaces, not null bytes, in the header. */
+ for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
+ if (*p == '\0')
+ *p = ' ';
+
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
+ || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR, abfd)
+ != SIZEOF_AR_FILE_HDR))
+ return false;
+
+ return true;
+}
+
+static boolean
+xcoff_write_archive_contents_big (abfd)
+ bfd *abfd;
+{
+ struct xcoff_ar_file_hdr_big fhdr;
+ bfd_size_type count;
+ bfd_size_type total_namlen;
+ file_ptr *offsets;
+ boolean makemap;
+ boolean hasobjects;
+ ufile_ptr prevoff, nextoff;
+ bfd *current_bfd;
+ size_t i;
+ struct xcoff_ar_hdr_big *hdr, ahdr;
+ bfd_size_type size;
+ bfd_byte *member_table, *mt;
+ bfd_vma member_table_size;
+
+ memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG);
+ memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
+
+ if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
+ return false;
+
+ /* Calculate count and total_namlen. */
+ makemap = bfd_has_map (abfd);
+ hasobjects = false;
+ for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0;
+ current_bfd != NULL;
+ current_bfd = current_bfd->next, count++)
+ {
+ total_namlen += strlen (normalize_filename (current_bfd)) + 1;
+
+ if (makemap
+ && ! hasobjects
+ && bfd_check_format (current_bfd, bfd_object))
+ hasobjects = true;
+ }
+
+ offsets = NULL;
+ if (count)
+ {
+ offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
+ if (offsets == NULL)
+ return false;
+ }
+
+ prevoff = 0;
+ nextoff = SIZEOF_AR_FILE_HDR_BIG;
+ for (current_bfd = abfd->archive_head, i = 0;
+ current_bfd != NULL;
+ current_bfd = current_bfd->next, i++)
+ {
+ const char *name;
+ bfd_size_type namlen;
+ struct xcoff_ar_hdr_big *ahdrp;
+ bfd_size_type remaining;
+
+ name = normalize_filename (current_bfd);
+ namlen = strlen (name);
+
+ if (current_bfd->arelt_data != NULL)
+ ahdrp = arch_xhdr_big (current_bfd);
+ else
+ ahdrp = NULL;
+
+ if (ahdrp == NULL)
+ {
+ struct stat s;
+
+ ahdrp = &ahdr;
+ /* XXX This should actually be a call to stat64 (at least on
+ 32-bit machines).
+ XXX This call will fail if the original object is not found. */
+ if (stat (bfd_get_filename (current_bfd), &s) != 0)
+ {
+ bfd_set_error (bfd_error_system_call);
+ return false;
+ }
+
+ PRINT20 (ahdrp->size, s.st_size);
+ PRINT12 (ahdrp->date, s.st_mtime);
+ PRINT12 (ahdrp->uid, s.st_uid);
+ PRINT12 (ahdrp->gid, s.st_gid);
+ PRINT12_OCTAL (ahdrp->mode, s.st_mode);
+
+ if (current_bfd->arelt_data == NULL)
+ {
+ size = sizeof (struct areltdata);
+ current_bfd->arelt_data = bfd_alloc (current_bfd, size);
+ if (current_bfd->arelt_data == NULL)
+ return false;
+ }
+
+ arch_eltdata (current_bfd)->parsed_size = s.st_size;
+ }
+
+ PRINT20 (ahdrp->prevoff, prevoff);
+ PRINT4 (ahdrp->namlen, namlen);
+
+ /* If the length of the name is odd, we write out the null byte
+ after the name as well. */
+ namlen = (namlen + 1) &~ (bfd_size_type) 1;
+
+ remaining = arelt_size (current_bfd);
+ size = (SIZEOF_AR_HDR_BIG
+ + namlen
+ + SXCOFFARFMAG
+ + remaining);
+
+ BFD_ASSERT (nextoff == bfd_tell (abfd));
+
+ /* Check for xcoff shared objects.
+ Their text section needs to be aligned wrt the archive file position.
+ This requires extra padding before the archive header. */
+ if (! do_shared_object_padding (abfd, current_bfd, & nextoff,
+ SIZEOF_AR_HDR_BIG + namlen
+ + SXCOFFARFMAG))
+ return false;
+
+ offsets[i] = nextoff;
+
+ prevoff = nextoff;
+ nextoff += size + (size & 1);
+
+ PRINT20 (ahdrp->nextoff, nextoff);
+
+ if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
+ != SIZEOF_AR_HDR_BIG)
+ || bfd_bwrite ((PTR) name, (bfd_size_type) namlen, abfd) != namlen
+ || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
+ abfd) != SXCOFFARFMAG))
+ return false;
+
+ if (bfd_seek (current_bfd, (file_ptr) 0, SEEK_SET) != 0)
+ return false;
+
+ if (! do_copy (abfd, current_bfd))
+ return false;
+
+ if (! do_pad (abfd, size & 1))
+ return false;
+ }
+
+ if (count)
+ {
+ PRINT20 (fhdr.firstmemoff, offsets[0]);
+ PRINT20 (fhdr.lastmemoff, prevoff);
+ }
+
+ /* Write out the member table.
+ Layout :
+
+ standard big archive header
+ 0x0000 ar_size [0x14]
+ 0x0014 ar_nxtmem [0x14]
+ 0x0028 ar_prvmem [0x14]
+ 0x003C ar_date [0x0C]
+ 0x0048 ar_uid [0x0C]
+ 0x0054 ar_gid [0x0C]
+ 0x0060 ar_mod [0x0C]
+ 0x006C ar_namelen[0x04]
+ 0x0070 ar_fmag [0x02]
+
+ Member table
+ 0x0072 count [0x14]
+ 0x0086 offsets [0x14 * counts]
+ 0x0086 + 0x14 * counts names [??]
+ ?? pad to even bytes.
+ */
+
+ BFD_ASSERT (nextoff == bfd_tell (abfd));
+
+ member_table_size = (SIZEOF_AR_HDR_BIG
+ + SXCOFFARFMAG
+ + XCOFFARMAGBIG_ELEMENT_SIZE
+ + count * XCOFFARMAGBIG_ELEMENT_SIZE
+ + total_namlen);
+
+ member_table_size += member_table_size & 1;
+ member_table = NULL;
+ member_table = (bfd_byte *) bfd_malloc (member_table_size);
+ if (member_table == NULL)
+ return false;
+ memset (member_table, 0, member_table_size);
+
+ hdr = (struct xcoff_ar_hdr_big *) member_table;
+
+ PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE +
+ count * XCOFFARMAGBIG_ELEMENT_SIZE +
+ total_namlen + (total_namlen & 1)));
+ if (makemap && hasobjects)
+ PRINT20 (hdr->nextoff, nextoff + member_table_size);
+ else
+ PRINT20 (hdr->nextoff, 0);
+ PRINT20 (hdr->prevoff, prevoff);
+ PRINT12 (hdr->date, 0);
+ PRINT12 (hdr->uid, 0);
+ PRINT12 (hdr->gid, 0);
+ PRINT12 (hdr->mode, 0);
+ PRINT4 (hdr->namlen, 0);
+
+ mt = member_table + SIZEOF_AR_HDR_BIG;
+ memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG);
+ mt += SXCOFFARFMAG;
+
+ PRINT20 (mt, count);
+ mt += XCOFFARMAGBIG_ELEMENT_SIZE;
+ for (i = 0; i < (size_t) count; i++)
+ {
+ PRINT20 (mt, offsets[i]);
+ mt += XCOFFARMAGBIG_ELEMENT_SIZE;
+ }
+
+ if (count)
+ {
+ free (offsets);
+ offsets = NULL;
+ }
+
+ for (current_bfd = abfd->archive_head; current_bfd != NULL;
+ current_bfd = current_bfd->next)
+ {
+ const char *name;
+ size_t namlen;
+
+ name = normalize_filename (current_bfd);
+ namlen = sprintf(mt, "%s", name);
+ mt += namlen + 1;
+ }
+
+ if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size)
+ return false;
+
+ free (member_table);
+ member_table = NULL;
+
+ PRINT20 (fhdr.memoff, nextoff);
+
+ prevoff = nextoff;
+ nextoff += member_table_size;
+
+ /* Write out the armap, if appropriate. */
+
+ if (! makemap || ! hasobjects)
+ PRINT20 (fhdr.symoff, 0);
+ else
+ {
+ BFD_ASSERT (nextoff == bfd_tell (abfd));
+
+ /* Save nextoff in fhdr.symoff so the armap routine can use it. */
+ PRINT20 (fhdr.symoff, nextoff);
+
+ bfd_ardata (abfd)->tdata = (PTR) &fhdr;
+ if (! _bfd_compute_and_write_armap (abfd, 0))
+ return false;
+ }
+
+ /* Write out the archive file header. */
+
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
+ || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG,
+ abfd) != SIZEOF_AR_FILE_HDR_BIG))
+ return false;
+
+ return true;
+}
+
+boolean
+_bfd_xcoff_write_archive_contents (abfd)
+ bfd *abfd;
+{
+ if (! xcoff_big_format_p (abfd))
+ return xcoff_write_archive_contents_old (abfd);
+ else
+ return xcoff_write_archive_contents_big (abfd);
+}
+\f
+/* We can't use the usual coff_sizeof_headers routine, because AIX
+ always uses an a.out header. */
+
+int
+_bfd_xcoff_sizeof_headers (abfd, reloc)
+ bfd *abfd;
+ boolean reloc ATTRIBUTE_UNUSED;
+{
+ int size;
+
+ size = FILHSZ;
+ if (xcoff_data (abfd)->full_aouthdr)
+ size += AOUTSZ;
+ else
+ size += SMALL_AOUTSZ;
+ size += abfd->section_count * SCNHSZ;
+ return size;
+}
+\f
+/* Routines to swap information in the XCOFF .loader section. If we
+ ever need to write an XCOFF loader, this stuff will need to be
+ moved to another file shared by the linker (which XCOFF calls the
+ ``binder'') and the loader. */
+
+/* Swap in the ldhdr structure. */
+
+static void
+xcoff_swap_ldhdr_in (abfd, s, dst)
+ bfd *abfd;
+ const PTR s;
+ struct internal_ldhdr *dst;
+{
+ const struct external_ldhdr *src = (const struct external_ldhdr *) s;
+
+ dst->l_version = bfd_get_32 (abfd, src->l_version);
+ dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
+ dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
+ dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
+ dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
+ dst->l_impoff = bfd_get_32 (abfd, src->l_impoff);
+ dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
+ dst->l_stoff = bfd_get_32 (abfd, src->l_stoff);
+}
+
+/* Swap out the ldhdr structure. */
+
+static void
+xcoff_swap_ldhdr_out (abfd, src, d)
+ bfd *abfd;
+ const struct internal_ldhdr *src;
+ PTR d;
+{
+ struct external_ldhdr *dst = (struct external_ldhdr *) d;
+
+ bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
+ bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
+ bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
+ bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
+ bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
+ bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
+ bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
+ bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
+}
+
+/* Swap in the ldsym structure. */
+
+static void
+xcoff_swap_ldsym_in (abfd, s, dst)
+ bfd *abfd;
+ const PTR s;
+ struct internal_ldsym *dst;
+{
+ const struct external_ldsym *src = (const struct external_ldsym *) s;
+
+ if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0) {
+ memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
+ } else {
+ dst->_l._l_l._l_zeroes = 0;
+ dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset);
+ }
+ dst->l_value = bfd_get_32 (abfd, src->l_value);
+ dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
+ dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
+ dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
+ dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
+ dst->l_parm = bfd_get_32 (abfd, src->l_parm);
+}
+
+/* Swap out the ldsym structure. */
+
+static void
+xcoff_swap_ldsym_out (abfd, src, d)
+ bfd *abfd;
+ const struct internal_ldsym *src;
+ PTR d;
+{
+ struct external_ldsym *dst = (struct external_ldsym *) d;
+
+ if (src->_l._l_l._l_zeroes != 0)
+ memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
+ else
+ {
+ bfd_put_32 (abfd, (bfd_vma) 0, dst->_l._l_l._l_zeroes);
+ bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset,
+ dst->_l._l_l._l_offset);
+ }
+ bfd_put_32 (abfd, src->l_value, dst->l_value);
+ bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
+ bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
+ bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
+ bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
+ bfd_put_32 (abfd, src->l_parm, dst->l_parm);
+}
+
+static void
+xcoff_swap_reloc_in (abfd, s, d)
+ bfd *abfd;
+ PTR s;
+ PTR d;
+{
+ struct external_reloc *src = (struct external_reloc *) s;
+ struct internal_reloc *dst = (struct internal_reloc *) d;
+
+ memset (dst, 0, sizeof (struct internal_reloc));
+
+ dst->r_vaddr = bfd_get_32 (abfd, src->r_vaddr);
+ dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
+ dst->r_size = bfd_get_8 (abfd, src->r_size);
+ dst->r_type = bfd_get_8 (abfd, src->r_type);
+}
+
+static unsigned int
+xcoff_swap_reloc_out (abfd, s, d)
+ bfd *abfd;
+ PTR s;
+ PTR d;
+{
+ struct internal_reloc *src = (struct internal_reloc *) s;
+ struct external_reloc *dst = (struct external_reloc *) d;
+
+ bfd_put_32 (abfd, src->r_vaddr, dst->r_vaddr);
+ bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
+ bfd_put_8 (abfd, src->r_type, dst->r_type);
+ bfd_put_8 (abfd, src->r_size, dst->r_size);
+
+ return bfd_coff_relsz (abfd);
+}
+
+/* Swap in the ldrel structure. */
+
+static void
+xcoff_swap_ldrel_in (abfd, s, dst)
+ bfd *abfd;
+ const PTR s;
+ struct internal_ldrel *dst;
+{
+ const struct external_ldrel *src = (const struct external_ldrel *) s;
+
+ dst->l_vaddr = bfd_get_32 (abfd, src->l_vaddr);
+ dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
+ dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
+ dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
+}
+
+/* Swap out the ldrel structure. */
+
+static void
+xcoff_swap_ldrel_out (abfd, src, d)
+ bfd *abfd;
+ const struct internal_ldrel *src;
+ PTR d;
+{
+ struct external_ldrel *dst = (struct external_ldrel *) d;
+
+ bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
+ bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
+ bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
+ bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
+}
+\f
+
+boolean
+xcoff_reloc_type_noop (input_bfd, input_section, output_bfd, rel, sym, howto,
+ val, addend, relocation, contents)
+ bfd *input_bfd ATTRIBUTE_UNUSED;
+ asection *input_section ATTRIBUTE_UNUSED;
+ bfd *output_bfd ATTRIBUTE_UNUSED;
+ struct internal_reloc *rel ATTRIBUTE_UNUSED;
+ struct internal_syment *sym ATTRIBUTE_UNUSED;
+ struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
+ bfd_vma val ATTRIBUTE_UNUSED;
+ bfd_vma addend ATTRIBUTE_UNUSED;
+ bfd_vma *relocation ATTRIBUTE_UNUSED;
+ bfd_byte *contents ATTRIBUTE_UNUSED;
+{
+ return true;
+}
+
+boolean
+xcoff_reloc_type_fail (input_bfd, input_section, output_bfd, rel, sym, howto,
+ val, addend, relocation, contents)
+ bfd *input_bfd;
+ asection *input_section ATTRIBUTE_UNUSED;
+ bfd *output_bfd ATTRIBUTE_UNUSED;
+ struct internal_reloc *rel;
+ struct internal_syment *sym ATTRIBUTE_UNUSED;
+ struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
+ bfd_vma val ATTRIBUTE_UNUSED;
+ bfd_vma addend ATTRIBUTE_UNUSED;
+ bfd_vma *relocation ATTRIBUTE_UNUSED;
+ bfd_byte *contents ATTRIBUTE_UNUSED;
+{
+ (*_bfd_error_handler)
+ (_("%s: unsupported relocation type 0x%02x"),
+ bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+}
+
+boolean
+xcoff_reloc_type_pos (input_bfd, input_section, output_bfd, rel, sym, howto,
+ val, addend, relocation, contents)
+ bfd *input_bfd ATTRIBUTE_UNUSED;
+ asection *input_section ATTRIBUTE_UNUSED;
+ bfd *output_bfd ATTRIBUTE_UNUSED;
+ struct internal_reloc *rel ATTRIBUTE_UNUSED;
+ struct internal_syment *sym ATTRIBUTE_UNUSED;
+ struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
+ bfd_vma val;
+ bfd_vma addend;
+ bfd_vma *relocation;
+ bfd_byte *contents ATTRIBUTE_UNUSED;
+{
+ *relocation = val + addend;
+ return true;
+}
+
+boolean
+xcoff_reloc_type_neg (input_bfd, input_section, output_bfd, rel, sym, howto,
+ val, addend, relocation, contents)
+ bfd *input_bfd ATTRIBUTE_UNUSED;
+ asection *input_section ATTRIBUTE_UNUSED;
+ bfd *output_bfd ATTRIBUTE_UNUSED;
+ struct internal_reloc *rel ATTRIBUTE_UNUSED;
+ struct internal_syment *sym ATTRIBUTE_UNUSED;
+ struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
+ bfd_vma val;
+ bfd_vma addend;
+ bfd_vma *relocation;
+ bfd_byte *contents ATTRIBUTE_UNUSED;
+{
+ *relocation = addend - val;
+ return true;
+}
+
+boolean
+xcoff_reloc_type_rel (input_bfd, input_section, output_bfd, rel, sym, howto,
+ val, addend, relocation, contents)
+ bfd *input_bfd ATTRIBUTE_UNUSED;
+ asection *input_section;
+ bfd *output_bfd ATTRIBUTE_UNUSED;
+ struct internal_reloc *rel ATTRIBUTE_UNUSED;
+ struct internal_syment *sym ATTRIBUTE_UNUSED;
+ struct reloc_howto_struct *howto;
+ bfd_vma val;
+ bfd_vma addend;
+ bfd_vma *relocation;
+ bfd_byte *contents ATTRIBUTE_UNUSED;
+{
+ howto->pc_relative = true;
+
+ /* A PC relative reloc includes the section address. */
+ addend += input_section->vma;
+
+ *relocation = val + addend;
+ *relocation -= (input_section->output_section->vma +
+ input_section->output_offset);
+ return true;
+}
+
+boolean
+xcoff_reloc_type_toc (input_bfd, input_section, output_bfd, rel, sym, howto,
+ val, addend, relocation, contents)
+ bfd *input_bfd;
+ asection *input_section ATTRIBUTE_UNUSED;
+ bfd *output_bfd;
+ struct internal_reloc *rel;
+ struct internal_syment *sym;
+ struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
+ bfd_vma val;
+ bfd_vma addend ATTRIBUTE_UNUSED;
+ bfd_vma *relocation;
+ bfd_byte *contents ATTRIBUTE_UNUSED;
+{
+ struct xcoff_link_hash_entry *h;
+
+ if (0 > rel->r_symndx)
+ return false;
+
+ h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
+
+ if (h != NULL && h->smclas != XMC_TD)
+ {
+ if (h->toc_section == NULL)
+ {
+ (*_bfd_error_handler)
+ (_("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"),
+ bfd_get_filename (input_bfd), rel->r_vaddr,
+ h->root.root.string);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+
+ BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
+ val = (h->toc_section->output_section->vma
+ + h->toc_section->output_offset);
+ }
projects / deliverable / binutils-gdb.git / blobdiff