From 07a8e9f0361a21ecced933a32e98a38e7b04d590 Mon Sep 17 00:00:00 2001 From: DJ Delorie Date: Mon, 7 Jan 2013 20:28:44 +0000 Subject: [PATCH] merge from gcc --- libiberty/ChangeLog | 14 + libiberty/Makefile.in | 11 +- libiberty/simple-object-common.h | 1 + libiberty/simple-object-mach-o.c | 5 +- libiberty/simple-object-xcoff.c | 898 +++++++++++++++++++++++++++++++ libiberty/simple-object.c | 3 +- 6 files changed, 928 insertions(+), 4 deletions(-) create mode 100644 libiberty/simple-object-xcoff.c diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog index 7ecd6da140..4479c77f27 100644 --- a/libiberty/ChangeLog +++ b/libiberty/ChangeLog @@ -1,3 +1,17 @@ +2013-01-04 Ian Lance Taylor + + PR other/54800 + * simple-object-mach-o.c (simple_object_mach_o_segment): Don't + bother to zero out a buffer we are about to set anyhow. + +2013-01-01 David Edelsohn + + * simple-object-xcoff.c: New file. + * Makefile.in: Add it to build machinery. + * simple-object-common.h (simple_object_xcoff_functions): Declare. + * simple-object.c (format_functions): Add + simple_object_xcoff_functions. + 2012-11-10 Jason Merrill * cp-demangle.c (d_unqualified_name): Handle abi tags here. diff --git a/libiberty/Makefile.in b/libiberty/Makefile.in index 1ba8cf1ccb..f6a3ebd6d3 100644 --- a/libiberty/Makefile.in +++ b/libiberty/Makefile.in @@ -146,7 +146,7 @@ CFILES = alloca.c argv.c asprintf.c atexit.c \ random.c regex.c rename.c rindex.c \ safe-ctype.c setenv.c setproctitle.c sha1.c sigsetmask.c \ simple-object.c simple-object-coff.c simple-object-elf.c \ - simple-object-mach-o.c \ + simple-object-mach-o.c simple-object-xcoff.c \ snprintf.c sort.c \ spaces.c splay-tree.c stack-limit.c stpcpy.c stpncpy.c \ strcasecmp.c strchr.c strdup.c strerror.c strncasecmp.c \ @@ -183,6 +183,7 @@ REQUIRED_OFILES = \ ./safe-ctype.$(objext) \ ./simple-object.$(objext) ./simple-object-coff.$(objext) \ ./simple-object-elf.$(objext) ./simple-object-mach-o.$(objext) \ + ./simple-object-xcoff.$(objext) \ ./sort.$(objext) ./spaces.$(objext) \ ./splay-tree.$(objext) ./stack-limit.$(objext) \ ./strerror.$(objext) ./strsignal.$(objext) \ @@ -1009,6 +1010,14 @@ $(CONFIGURED_OFILES): stamp-picdir else true; fi $(COMPILE.c) $(srcdir)/simple-object-mach-o.c $(OUTPUT_OPTION) +./simple-object-xcoff.$(objext): $(srcdir)/simple-object-xcoff.c config.h \ + $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \ + $(srcdir)/simple-object-common.h $(INCDIR)/simple-object.h + if [ x"$(PICFLAG)" != x ]; then \ + $(COMPILE.c) $(PICFLAG) $(srcdir)/simple-object-xcoff.c -o pic/$@; \ + else true; fi + $(COMPILE.c) $(srcdir)/simple-object-xcoff.c $(OUTPUT_OPTION) + ./simple-object.$(objext): $(srcdir)/simple-object.c config.h \ $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \ $(srcdir)/simple-object-common.h $(INCDIR)/simple-object.h diff --git a/libiberty/simple-object-common.h b/libiberty/simple-object-common.h index 264b179955..bef9b08cef 100644 --- a/libiberty/simple-object-common.h +++ b/libiberty/simple-object-common.h @@ -148,6 +148,7 @@ struct simple_object_functions extern const struct simple_object_functions simple_object_coff_functions; extern const struct simple_object_functions simple_object_elf_functions; extern const struct simple_object_functions simple_object_mach_o_functions; +extern const struct simple_object_functions simple_object_xcoff_functions; /* Read SIZE bytes from DESCRIPTOR at file offset OFFSET into BUFFER. Return non-zero on success. On failure return 0 and set *ERRMSG diff --git a/libiberty/simple-object-mach-o.c b/libiberty/simple-object-mach-o.c index af5e4f9ca8..6fde6722be 100644 --- a/libiberty/simple-object-mach-o.c +++ b/libiberty/simple-object-mach-o.c @@ -1,5 +1,5 @@ /* simple-object-mach-o.c -- routines to manipulate Mach-O object files. - Copyright 2010, 2011 Free Software Foundation, Inc. + Copyright 2010, 2011, 2013 Free Software Foundation, Inc. Written by Ian Lance Taylor, Google. This program is free software; you can redistribute it and/or modify it @@ -701,12 +701,13 @@ simple_object_mach_o_segment (simple_object_read *sobj, off_t offset, /* Otherwise, make a name like __segment,__section as per the convention in mach-o asm. */ name = &namebuf[0]; - memset (namebuf, 0, MACH_O_NAME_LEN * 2 + 2); memcpy (namebuf, (char *) sechdr + segname_offset, MACH_O_NAME_LEN); + namebuf[MACH_O_NAME_LEN] = '\0'; l = strlen (namebuf); namebuf[l] = ','; memcpy (namebuf + l + 1, (char *) sechdr + sectname_offset, MACH_O_NAME_LEN); + namebuf[l + 1 + MACH_O_NAME_LEN] = '\0'; } simple_object_mach_o_section_info (omr->is_big_endian, is_32, sechdr, diff --git a/libiberty/simple-object-xcoff.c b/libiberty/simple-object-xcoff.c new file mode 100644 index 0000000000..ff1dc18079 --- /dev/null +++ b/libiberty/simple-object-xcoff.c @@ -0,0 +1,898 @@ +/* simple-object-coff.c -- routines to manipulate XCOFF object files. + Copyright 2013 Free Software Foundation, Inc. + Written by Ian Lance Taylor, Google and David Edelsohn, IBM. + +This program is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, 51 Franklin Street - Fifth Floor, +Boston, MA 02110-1301, USA. */ + +#include "config.h" +#include "libiberty.h" +#include "simple-object.h" + +#include +#include + +#ifdef HAVE_STDLIB_H +#include +#endif + +#ifdef HAVE_STDINT_H +#include +#endif + +#ifdef HAVE_STRING_H +#include +#endif + +#ifdef HAVE_INTTYPES_H +#include +#endif + +#include "simple-object-common.h" + +/* XCOFF structures and constants. */ + +/* XCOFF file header. */ + +struct external_filehdr +{ + unsigned char f_magic[2]; /* magic number */ + unsigned char f_nscns[2]; /* number of sections */ + unsigned char f_timdat[4]; /* time & date stamp */ + union + { + struct + { + unsigned char f_symptr[4]; /* file pointer to symtab */ + unsigned char f_nsyms[4]; /* number of symtab entries */ + unsigned char f_opthdr[2]; /* sizeof(optional hdr) */ + unsigned char f_flags[2]; /* flags */ + } xcoff32; + struct + { + unsigned char f_symptr[8]; /* file pointer to symtab */ + unsigned char f_opthdr[2]; /* sizeof(optional hdr) */ + unsigned char f_flags[2]; /* flags */ + unsigned char f_nsyms[4]; /* number of symtab entries */ + } xcoff64; + } u; +}; + +/* Bits for filehdr f_flags field. */ + +#define F_EXEC (0x0002) + +/* The known values of f_magic in an XCOFF file header. */ + +#define U802WRMAGIC 0730 /* Writeable text segments. */ +#define U802ROMAGIC 0735 /* Readonly sharable text segments. */ +#define U802TOCMAGIC 0737 /* Readonly text segments and TOC. */ +#define U803XTOCMAGIC 0757 /* Aix 4.3 64-bit XCOFF. */ +#define U64_TOCMAGIC 0767 /* AIX 5+ 64-bit XCOFF. */ + +/* XCOFF section header. */ + +struct external_scnhdr +{ + unsigned char s_name[8]; /* section name */ + union + { + struct + { + unsigned char s_paddr[4]; /* physical address, aliased s_nlib */ + unsigned char s_vaddr[4]; /* virtual address */ + unsigned char s_size[4]; /* section size */ + unsigned char s_scnptr[4]; /* file ptr to raw data for section */ + unsigned char s_relptr[4]; /* file ptr to relocation */ + unsigned char s_lnnoptr[4]; /* file ptr to line numbers */ + unsigned char s_nreloc[2]; /* number of relocation entries */ + unsigned char s_nlnno[2]; /* number of line number entries */ + unsigned char s_flags[4]; /* flags */ + } xcoff32; + struct + { + unsigned char s_paddr[8]; /* physical address, aliased s_nlib */ + unsigned char s_vaddr[8]; /* virtual address */ + unsigned char s_size[8]; /* section size */ + unsigned char s_scnptr[8]; /* file ptr to raw data for section */ + unsigned char s_relptr[8]; /* file ptr to relocation */ + unsigned char s_lnnoptr[8]; /* file ptr to line numbers */ + unsigned char s_nreloc[4]; /* number of relocation entries */ + unsigned char s_nlnno[4]; /* number of line number entries */ + unsigned char s_flags[4]; /* flags */ + } xcoff64; + } u; +}; + +#define SCNHSZ32 (40) +#define SCNHSZ64 (68) + +/* The length of the s_name field in struct external_scnhdr. */ + +#define SCNNMLEN (8) + +/* Bits for scnhdr s_flags field. */ + +#define STYP_DATA 0x40 + +/* XCOFF symbol table entry. */ + + +#define N_SYMNMLEN (8) /* # characters in a symbol name */ + +/* The format of an XCOFF symbol-table entry. */ +struct external_syment +{ + union { + struct { + union { + /* The name of the symbol. There is an implicit null character + after the end of the array. */ + char n_name[N_SYMNMLEN]; + struct { + /* If n_zeroes is zero, n_offset is the offset the name from + the start of the string table. */ + unsigned char n_zeroes[4]; + unsigned char n_offset[4]; + } n; + } n; + + /* The symbol's value. */ + unsigned char n_value[4]; + } xcoff32; + struct { + /* The symbol's value. */ + unsigned char n_value[8]; + + /* The offset of the symbol from the start of the string table. */ + unsigned char n_offset[4]; + } xcoff64; + } u; + + /* The number of the section to which this symbol belongs. */ + unsigned char n_scnum[2]; + + /* The type of symbol. (It can be interpreted as an n_lang + and an n_cpu byte, but we don't care about that here.) */ + unsigned char n_type[2]; + + /* The class of symbol (a C_* value). */ + unsigned char n_sclass[1]; + + /* The number of auxiliary symbols attached to this entry. */ + unsigned char n_numaux[1]; +}; + +#define SYMESZ (18) + +/* Length allowed for filename in aux sym format 4. */ + +#define FILNMLEN (14) + +/* Omits x_sym and other unused variants. */ + +union external_auxent +{ + /* Aux sym format 4: file. */ + union + { + char x_fname[FILNMLEN]; + struct + { + unsigned char x_zeroes[4]; + unsigned char x_offset[4]; + unsigned char x_pad[FILNMLEN-8]; + unsigned char x_ftype; + } _x; + } x_file; + /* Aux sym format 5: section. */ + struct + { + unsigned char x_scnlen[4]; /* section length */ + unsigned char x_nreloc[2]; /* # relocation entries */ + unsigned char x_nlinno[2]; /* # line numbers */ + } x_scn; + /* CSECT auxiliary entry. */ + union + { + struct + { + struct + { + unsigned char x_scnlen[4]; /* csect length */ + unsigned char x_parmhash[4]; /* parm type hash index */ + unsigned char x_snhash[2]; /* sect num with parm hash */ + unsigned char x_smtyp; /* symbol align and type */ + unsigned char x_smclas; /* storage mapping class */ + unsigned char x_stab; /* dbx stab info index */ + unsigned char x_snstab[2]; /* sect num with dbx stab */ + } x_csect; + } xcoff32; + struct + { + struct + { + unsigned char x_scnlen_lo[4]; /* csect length */ + unsigned char x_parmhash[4]; /* parm type hash index */ + unsigned char x_snhash[2]; /* sect num with parm hash */ + unsigned char x_smtyp; /* symbol align and type */ + unsigned char x_smclas; /* storage mapping class */ + unsigned char x_scnlen_hi[4]; + unsigned char pad; + unsigned char x_auxtype; + } x_csect; + } xcoff64; + } u; + /* SECTION/DWARF auxiliary entry. */ + struct + { + unsigned char x_scnlen[4]; /* section length */ + unsigned char pad1[4]; + unsigned char x_nreloc[4]; /* number RLDs */ + } x_sect; +}; + +/* Symbol-related constants. */ + +#define N_DEBUG (-2) +#define IMAGE_SYM_TYPE_NULL (0) +#define IMAGE_SYM_DTYPE_NULL (0) +#define IMAGE_SYM_CLASS_STATIC (3) +#define IMAGE_SYM_CLASS_FILE (103) + +#define IMAGE_SYM_TYPE \ + ((IMAGE_SYM_DTYPE_NULL << 4) | IMAGE_SYM_TYPE_NULL) + +#define C_STAT (3) +#define C_FILE (103) + +/* Private data for an simple_object_read. */ + +struct simple_object_xcoff_read +{ + /* Magic number. */ + unsigned short magic; + /* Number of sections. */ + unsigned short nscns; + /* File offset of symbol table. */ + off_t symptr; + /* Number of symbol table entries. */ + unsigned int nsyms; + /* Flags. */ + unsigned short flags; + /* Offset of section headers in file. */ + off_t scnhdr_offset; +}; + +/* Private data for an simple_object_attributes. */ + +struct simple_object_xcoff_attributes +{ + /* Magic number. */ + unsigned short magic; + /* Flags. */ + unsigned short flags; +}; + +/* See if we have a XCOFF file. */ + +static void * +simple_object_xcoff_match (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN], + int descriptor, off_t offset, + const char *segment_name ATTRIBUTE_UNUSED, + const char **errmsg, int *err) +{ + unsigned short magic; + unsigned short (*fetch_16) (const unsigned char *); + unsigned int (*fetch_32) (const unsigned char *); + ulong_type (*fetch_64) (const unsigned char *); + unsigned char hdrbuf[sizeof (struct external_filehdr)]; + struct simple_object_xcoff_read *ocr; + int u64; + + magic = simple_object_fetch_big_16 (header); + + if (magic != U802TOCMAGIC && magic != U64_TOCMAGIC) + { + *errmsg = NULL; + *err = 0; + return NULL; + } + + fetch_16 = simple_object_fetch_big_16; + fetch_32 = simple_object_fetch_big_32; + fetch_64 = simple_object_fetch_big_64; + + if (!simple_object_internal_read (descriptor, offset, hdrbuf, sizeof hdrbuf, + errmsg, err)) + return NULL; + + u64 = magic == U64_TOCMAGIC; + + ocr = XNEW (struct simple_object_xcoff_read); + ocr->magic = magic; + ocr->nscns = fetch_16 (hdrbuf + offsetof (struct external_filehdr, f_nscns)); + if (u64) + { + ocr->symptr = fetch_64 (hdrbuf + + offsetof (struct external_filehdr, + u.xcoff64.f_symptr)); + ocr->nsyms = fetch_32 (hdrbuf + offsetof (struct external_filehdr, + u.xcoff64.f_nsyms)); + ocr->scnhdr_offset = (sizeof (struct external_filehdr) + + fetch_16 (hdrbuf + offsetof (struct external_filehdr, + u.xcoff64.f_opthdr))); + + } + else + { + ocr->symptr = fetch_32 (hdrbuf + + offsetof (struct external_filehdr, + u.xcoff32.f_symptr)); + ocr->nsyms = fetch_32 (hdrbuf + offsetof (struct external_filehdr, + u.xcoff32.f_nsyms)); + ocr->scnhdr_offset = (sizeof (struct external_filehdr) - 4 + + fetch_16 (hdrbuf + offsetof (struct external_filehdr, + u.xcoff32.f_opthdr))); + + } + + return (void *) ocr; +} + +/* Read the string table in a XCOFF file. */ + +static char * +simple_object_xcoff_read_strtab (simple_object_read *sobj, size_t *strtab_size, + const char **errmsg, int *err) +{ + struct simple_object_xcoff_read *ocr = + (struct simple_object_xcoff_read *) sobj->data; + off_t strtab_offset; + unsigned char strsizebuf[4]; + size_t strsize; + char *strtab; + + strtab_offset = sobj->offset + ocr->symptr + + ocr->nsyms * SYMESZ; + if (!simple_object_internal_read (sobj->descriptor, strtab_offset, + strsizebuf, 4, errmsg, err)) + return NULL; + strsize = simple_object_fetch_big_32 (strsizebuf); + strtab = XNEWVEC (char, strsize); + if (!simple_object_internal_read (sobj->descriptor, strtab_offset, + (unsigned char *) strtab, strsize, errmsg, + err)) + { + XDELETEVEC (strtab); + return NULL; + } + *strtab_size = strsize; + return strtab; +} + +/* Find all sections in a XCOFF file. */ + +static const char * +simple_object_xcoff_find_sections (simple_object_read *sobj, + int (*pfn) (void *, const char *, + off_t offset, off_t length), + void *data, + int *err) +{ + struct simple_object_xcoff_read *ocr = + (struct simple_object_xcoff_read *) sobj->data; + int u64 = ocr->magic == U64_TOCMAGIC; + size_t scnhdr_size; + unsigned char *scnbuf; + const char *errmsg; + unsigned int (*fetch_32) (const unsigned char *); + ulong_type (*fetch_64) (const unsigned char *); + unsigned int nscns; + char *strtab; + size_t strtab_size; + unsigned int i; + + scnhdr_size = u64 ? SCNHSZ64 : SCNHSZ32; + scnbuf = XNEWVEC (unsigned char, scnhdr_size * ocr->nscns); + if (!simple_object_internal_read (sobj->descriptor, + sobj->offset + ocr->scnhdr_offset, + scnbuf, scnhdr_size * ocr->nscns, &errmsg, + err)) + { + XDELETEVEC (scnbuf); + return errmsg; + } + + fetch_32 = simple_object_fetch_big_32; + fetch_64 = simple_object_fetch_big_64; + + nscns = ocr->nscns; + strtab = NULL; + strtab_size = 0; + for (i = 0; i < nscns; ++i) + { + unsigned char *scnhdr; + unsigned char *scnname; + char namebuf[SCNNMLEN + 1]; + char *name; + off_t scnptr; + unsigned int size; + + scnhdr = scnbuf + i * scnhdr_size; + scnname = scnhdr + offsetof (struct external_scnhdr, s_name); + memcpy (namebuf, scnname, SCNNMLEN); + namebuf[SCNNMLEN] = '\0'; + name = &namebuf[0]; + if (namebuf[0] == '/') + { + size_t strindex; + char *end; + + strindex = strtol (namebuf + 1, &end, 10); + if (*end == '\0') + { + /* The real section name is found in the string + table. */ + if (strtab == NULL) + { + strtab = simple_object_xcoff_read_strtab (sobj, + &strtab_size, + &errmsg, err); + if (strtab == NULL) + { + XDELETEVEC (scnbuf); + return errmsg; + } + } + + if (strindex < 4 || strindex >= strtab_size) + { + XDELETEVEC (strtab); + XDELETEVEC (scnbuf); + *err = 0; + return "section string index out of range"; + } + + name = strtab + strindex; + } + } + + if (u64) + { + scnptr = fetch_64 (scnhdr + offsetof (struct external_scnhdr, + u.xcoff64.s_scnptr)); + size = fetch_64 (scnhdr + offsetof (struct external_scnhdr, + u.xcoff64.s_size)); + } + else + { + scnptr = fetch_32 (scnhdr + offsetof (struct external_scnhdr, + u.xcoff32.s_scnptr)); + size = fetch_32 (scnhdr + offsetof (struct external_scnhdr, + u.xcoff32.s_size)); + } + + if (!(*pfn) (data, name, scnptr, size)) + break; + } + + if (strtab != NULL) + XDELETEVEC (strtab); + XDELETEVEC (scnbuf); + + return NULL; +} + +/* Fetch the attributes for an simple_object_read. */ + +static void * +simple_object_xcoff_fetch_attributes (simple_object_read *sobj, + const char **errmsg ATTRIBUTE_UNUSED, + int *err ATTRIBUTE_UNUSED) +{ + struct simple_object_xcoff_read *ocr = + (struct simple_object_xcoff_read *) sobj->data; + struct simple_object_xcoff_attributes *ret; + + ret = XNEW (struct simple_object_xcoff_attributes); + ret->magic = ocr->magic; + ret->flags = ocr->flags; + return ret; +} + +/* Release the private data for an simple_object_read. */ + +static void +simple_object_xcoff_release_read (void *data) +{ + XDELETE (data); +} + +/* Compare two attributes structures. */ + +static const char * +simple_object_xcoff_attributes_merge (void *todata, void *fromdata, int *err) +{ + struct simple_object_xcoff_attributes *to = + (struct simple_object_xcoff_attributes *) todata; + struct simple_object_xcoff_attributes *from = + (struct simple_object_xcoff_attributes *) fromdata; + + if (to->magic != from->magic) + { + *err = 0; + return "XCOFF object format mismatch"; + } + return NULL; +} + +/* Release the private data for an attributes structure. */ + +static void +simple_object_xcoff_release_attributes (void *data) +{ + XDELETE (data); +} + +/* Prepare to write out a file. */ + +static void * +simple_object_xcoff_start_write (void *attributes_data, + const char **errmsg ATTRIBUTE_UNUSED, + int *err ATTRIBUTE_UNUSED) +{ + struct simple_object_xcoff_attributes *attrs = + (struct simple_object_xcoff_attributes *) attributes_data; + struct simple_object_xcoff_attributes *ret; + + /* We're just going to record the attributes, but we need to make a + copy because the user may delete them. */ + ret = XNEW (struct simple_object_xcoff_attributes); + *ret = *attrs; + return ret; +} + +/* Write out a XCOFF filehdr. */ + +static int +simple_object_xcoff_write_filehdr (simple_object_write *sobj, int descriptor, + unsigned int nscns, size_t symtab_offset, + unsigned int nsyms, const char **errmsg, + int *err) +{ + struct simple_object_xcoff_attributes *attrs = + (struct simple_object_xcoff_attributes *) sobj->data; + int u64 = attrs->magic == U64_TOCMAGIC; + unsigned char hdrbuf[sizeof (struct external_filehdr)]; + unsigned char *hdr; + void (*set_16) (unsigned char *, unsigned short); + void (*set_32) (unsigned char *, unsigned int); + void (*set_64) (unsigned char *, ulong_type); + + hdr = &hdrbuf[0]; + + set_16 = simple_object_set_big_16; + set_32 = simple_object_set_big_32; + set_64 = simple_object_set_big_64; + + memset (hdr, 0, sizeof (struct external_filehdr)); + + set_16 (hdr + offsetof (struct external_filehdr, f_magic), attrs->magic); + set_16 (hdr + offsetof (struct external_filehdr, f_nscns), nscns); + /* f_timdat left as zero. */ + if (u64) + { + set_64 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_symptr), + symtab_offset); + set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_nsyms), + nsyms); + /* f_opthdr left as zero. */ + set_16 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_flags), + attrs->flags); + } + else + { + set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_symptr), + symtab_offset); + set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_nsyms), + nsyms); + /* f_opthdr left as zero. */ + set_16 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_flags), + attrs->flags); + } + + return simple_object_internal_write (descriptor, 0, hdrbuf, + sizeof (struct external_filehdr), + errmsg, err); +} + +/* Write out a XCOFF section header. */ + +static int +simple_object_xcoff_write_scnhdr (simple_object_write *sobj, + int descriptor, + const char *name, size_t *name_offset, + off_t scnhdr_offset, size_t scnsize, + off_t offset, unsigned int align, + const char **errmsg, int *err) +{ + struct simple_object_xcoff_read *ocr = + (struct simple_object_xcoff_read *) sobj->data; + int u64 = ocr->magic == U64_TOCMAGIC; + void (*set_32) (unsigned char *, unsigned int); + void (*set_64) (unsigned char *, unsigned int); + unsigned char hdrbuf[sizeof (struct external_scnhdr)]; + unsigned char *hdr; + size_t namelen; + unsigned int flags; + + set_32 = simple_object_set_big_32; + set_64 = simple_object_set_big_32; + + memset (hdrbuf, 0, sizeof hdrbuf); + hdr = &hdrbuf[0]; + + namelen = strlen (name); + if (namelen <= SCNNMLEN) + strncpy ((char *) hdr + offsetof (struct external_scnhdr, s_name), + name, SCNNMLEN); + else + { + snprintf ((char *) hdr + offsetof (struct external_scnhdr, s_name), + SCNNMLEN, "/%lu", (unsigned long) *name_offset); + *name_offset += namelen + 1; + } + + /* s_paddr left as zero. */ + /* s_vaddr left as zero. */ + if (u64) + { + set_64 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_size), + scnsize); + set_64 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_scnptr), + offset); + } + else + { + set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_size), + scnsize); + set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_scnptr), + offset); + } + /* s_relptr left as zero. */ + /* s_lnnoptr left as zero. */ + /* s_nreloc left as zero. */ + /* s_nlnno left as zero. */ + flags = STYP_DATA; + if (align > 13) + align = 13; + if (u64) + set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_flags), flags); + else + set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_flags), flags); + + return simple_object_internal_write (descriptor, scnhdr_offset, hdrbuf, + u64 ? SCNHSZ64 : SCNHSZ32, + errmsg, err); +} + +/* Write out a complete XCOFF file. */ + +static const char * +simple_object_xcoff_write_to_file (simple_object_write *sobj, int descriptor, + int *err) +{ + struct simple_object_xcoff_read *ocr = + (struct simple_object_xcoff_read *) sobj->data; + int u64 = ocr->magic == U64_TOCMAGIC; + unsigned int nscns, secnum; + simple_object_write_section *section; + off_t scnhdr_offset; + size_t symtab_offset; + off_t secsym_offset; + unsigned int nsyms; + size_t offset; + size_t name_offset; + const char *errmsg; + unsigned char strsizebuf[4]; + /* The interface doesn't give us access to the name of the input file + yet. We want to use its basename for the FILE symbol. This is + what 'gas' uses when told to assemble from stdin. */ + const char *source_filename = "fake"; + size_t sflen; + union + { + struct external_syment sym; + union external_auxent aux; + } syms[2]; + void (*set_16) (unsigned char *, unsigned short); + void (*set_32) (unsigned char *, unsigned int); + + set_16 = simple_object_set_big_16; + set_32 = simple_object_set_big_32; + + nscns = 0; + for (section = sobj->sections; section != NULL; section = section->next) + ++nscns; + + scnhdr_offset = sizeof (struct external_filehdr) - (u64 ? 4 : 0); + offset = scnhdr_offset + nscns * (u64 ? SCNHSZ64 : SCNHSZ32); + name_offset = 4; + for (section = sobj->sections; section != NULL; section = section->next) + { + size_t mask; + size_t new_offset; + size_t scnsize; + struct simple_object_write_section_buffer *buffer; + + mask = (1U << section->align) - 1; + new_offset = offset & mask; + new_offset &= ~ mask; + while (new_offset > offset) + { + unsigned char zeroes[16]; + size_t write; + + memset (zeroes, 0, sizeof zeroes); + write = new_offset - offset; + if (write > sizeof zeroes) + write = sizeof zeroes; + if (!simple_object_internal_write (descriptor, offset, zeroes, write, + &errmsg, err)) + return errmsg; + } + + scnsize = 0; + for (buffer = section->buffers; buffer != NULL; buffer = buffer->next) + { + if (!simple_object_internal_write (descriptor, offset + scnsize, + ((const unsigned char *) + buffer->buffer), + buffer->size, &errmsg, err)) + return errmsg; + scnsize += buffer->size; + } + + if (!simple_object_xcoff_write_scnhdr (sobj, descriptor, section->name, + &name_offset, scnhdr_offset, + scnsize, offset, section->align, + &errmsg, err)) + return errmsg; + + scnhdr_offset += u64 ? SCNHSZ64 : SCNHSZ32; + offset += scnsize; + } + + /* Symbol table is always half-word aligned. */ + offset += (offset & 1); + /* There is a file symbol and a section symbol per section, + and each of these has a single auxiliary symbol following. */ + nsyms = 2 * (nscns + 1); + symtab_offset = offset; + /* Advance across space reserved for symbol table to locate + start of string table. */ + offset += nsyms * SYMESZ; + + /* Write out file symbol. */ + memset (&syms[0], 0, sizeof (syms)); + if (!u64) + strcpy ((char *)&syms[0].sym.u.xcoff32.n.n_name[0], ".file"); + set_16 (&syms[0].sym.n_scnum[0], N_DEBUG); + set_16 (&syms[0].sym.n_type[0], IMAGE_SYM_TYPE); + syms[0].sym.n_sclass[0] = C_FILE; + syms[0].sym.n_numaux[0] = 1; + /* The name need not be nul-terminated if it fits into the x_fname field + directly, but must be if it has to be placed into the string table. */ + sflen = strlen (source_filename); + if (sflen <= FILNMLEN) + memcpy (&syms[1].aux.x_file.x_fname[0], source_filename, sflen); + else + { + set_32 (&syms[1].aux.x_file._x.x_offset[0], name_offset); + if (!simple_object_internal_write (descriptor, offset + name_offset, + ((const unsigned char *) + source_filename), + sflen + 1, &errmsg, err)) + return errmsg; + name_offset += strlen (source_filename) + 1; + } + if (!simple_object_internal_write (descriptor, symtab_offset, + (const unsigned char *) &syms[0], + sizeof (syms), &errmsg, err)) + return errmsg; + + /* Write the string table length, followed by the strings and section + symbols in step with each other. */ + set_32 (strsizebuf, name_offset); + if (!simple_object_internal_write (descriptor, offset, strsizebuf, 4, + &errmsg, err)) + return errmsg; + + name_offset = 4; + secsym_offset = symtab_offset + sizeof (syms); + memset (&syms[0], 0, sizeof (syms)); + set_16 (&syms[0].sym.n_type[0], IMAGE_SYM_TYPE); + syms[0].sym.n_sclass[0] = C_STAT; + syms[0].sym.n_numaux[0] = 1; + secnum = 1; + + for (section = sobj->sections; section != NULL; section = section->next) + { + size_t namelen; + size_t scnsize; + struct simple_object_write_section_buffer *buffer; + + namelen = strlen (section->name); + set_16 (&syms[0].sym.n_scnum[0], secnum++); + scnsize = 0; + for (buffer = section->buffers; buffer != NULL; buffer = buffer->next) + scnsize += buffer->size; + set_32 (&syms[1].aux.x_scn.x_scnlen[0], scnsize); + if (namelen > SCNNMLEN) + { + set_32 (&syms[0].sym.u.xcoff32.n.n.n_zeroes[0], 0); + set_32 (&syms[0].sym.u.xcoff32.n.n.n_offset[0], name_offset); + if (!simple_object_internal_write (descriptor, offset + name_offset, + ((const unsigned char *) + section->name), + namelen + 1, &errmsg, err)) + return errmsg; + name_offset += namelen + 1; + } + else + { + memcpy (&syms[0].sym.u.xcoff32.n.n_name[0], section->name, + strlen (section->name)); + memset (&syms[0].sym.u.xcoff32.n.n_name[strlen (section->name)], 0, + N_SYMNMLEN - strlen (section->name)); + } + + if (!simple_object_internal_write (descriptor, secsym_offset, + (const unsigned char *) &syms[0], + sizeof (syms), &errmsg, err)) + return errmsg; + secsym_offset += sizeof (syms); + } + + if (!simple_object_xcoff_write_filehdr (sobj, descriptor, nscns, + symtab_offset, nsyms, &errmsg, err)) + return errmsg; + + return NULL; +} + +/* Release the private data for an simple_object_write structure. */ + +static void +simple_object_xcoff_release_write (void *data) +{ + XDELETE (data); +} + +/* The XCOFF functions. */ + +const struct simple_object_functions simple_object_xcoff_functions = +{ + simple_object_xcoff_match, + simple_object_xcoff_find_sections, + simple_object_xcoff_fetch_attributes, + simple_object_xcoff_release_read, + simple_object_xcoff_attributes_merge, + simple_object_xcoff_release_attributes, + simple_object_xcoff_start_write, + simple_object_xcoff_write_to_file, + simple_object_xcoff_release_write +}; diff --git a/libiberty/simple-object.c b/libiberty/simple-object.c index d000cfc080..fde3454dd4 100644 --- a/libiberty/simple-object.c +++ b/libiberty/simple-object.c @@ -51,7 +51,8 @@ static const struct simple_object_functions * const format_functions[] = { &simple_object_elf_functions, &simple_object_mach_o_functions, - &simple_object_coff_functions + &simple_object_coff_functions, + &simple_object_xcoff_functions }; /* Read data from a file using the simple_object error reporting