/* Flip the endianness of the CTF header. */
-static void
-flip_header (ctf_header_t *cth)
+void
+ctf_flip_header (ctf_header_t *cth)
{
swap_thing (cth->cth_preamble.ctp_magic);
swap_thing (cth->cth_preamble.ctp_version);
ctf_stype followed by variable data. */
static int
-flip_types (ctf_dict_t *fp, void *start, size_t len)
+flip_types (ctf_dict_t *fp, void *start, size_t len, int to_foreign)
{
ctf_type_t *t = start;
while ((uintptr_t) t < ((uintptr_t) start) + len)
{
+ uint32_t kind;
+ size_t size;
+ uint32_t vlen;
+ size_t vbytes;
+
+ if (to_foreign)
+ {
+ kind = CTF_V2_INFO_KIND (t->ctt_info);
+ size = t->ctt_size;
+ vlen = CTF_V2_INFO_VLEN (t->ctt_info);
+ vbytes = get_vbytes_v2 (fp, kind, size, vlen);
+ }
+
swap_thing (t->ctt_name);
swap_thing (t->ctt_info);
swap_thing (t->ctt_size);
- uint32_t kind = CTF_V2_INFO_KIND (t->ctt_info);
- size_t size = t->ctt_size;
- uint32_t vlen = CTF_V2_INFO_VLEN (t->ctt_info);
- size_t vbytes = get_vbytes_v2 (fp, kind, size, vlen);
+ if (!to_foreign)
+ {
+ kind = CTF_V2_INFO_KIND (t->ctt_info);
+ size = t->ctt_size;
+ vlen = CTF_V2_INFO_VLEN (t->ctt_info);
+ vbytes = get_vbytes_v2 (fp, kind, size, vlen);
+ }
if (_libctf_unlikely_ (size == CTF_LSIZE_SENT))
{
+ if (to_foreign)
+ size = CTF_TYPE_LSIZE (t);
+
swap_thing (t->ctt_lsizehi);
swap_thing (t->ctt_lsizelo);
- size = CTF_TYPE_LSIZE (t);
+
+ if (!to_foreign)
+ size = CTF_TYPE_LSIZE (t);
+
t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_type_t));
}
else
}
/* Flip the endianness of BUF, given the offsets in the (already endian-
- converted) CTH.
+ converted) CTH. If TO_FOREIGN is set, flip to foreign-endianness; if not,
+ flip away.
All of this stuff happens before the header is fully initialized, so the
LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
data, this is no real loss. */
-static int
-flip_ctf (ctf_dict_t *fp, ctf_header_t *cth, unsigned char *buf)
+int
+ctf_flip (ctf_dict_t *fp, ctf_header_t *cth, unsigned char *buf,
+ int to_foreign)
{
+ ctf_dprintf("flipping endianness\n");
+
flip_lbls (buf + cth->cth_lbloff, cth->cth_objtoff - cth->cth_lbloff);
flip_objts (buf + cth->cth_objtoff, cth->cth_funcoff - cth->cth_objtoff);
flip_objts (buf + cth->cth_funcoff, cth->cth_objtidxoff - cth->cth_funcoff);
flip_objts (buf + cth->cth_objtidxoff, cth->cth_funcidxoff - cth->cth_objtidxoff);
flip_objts (buf + cth->cth_funcidxoff, cth->cth_varoff - cth->cth_funcidxoff);
flip_vars (buf + cth->cth_varoff, cth->cth_typeoff - cth->cth_varoff);
- return flip_types (fp, buf + cth->cth_typeoff, cth->cth_stroff - cth->cth_typeoff);
+ return flip_types (fp, buf + cth->cth_typeoff,
+ cth->cth_stroff - cth->cth_typeoff, to_foreign);
}
/* Set up the ctl hashes in a ctf_dict_t. Called by both writable and
upgrade_header (hp);
if (foreign_endian)
- flip_header (hp);
+ ctf_flip_header (hp);
fp->ctf_openflags = hp->cth_flags;
fp->ctf_size = hp->cth_stroff + hp->cth_strlen;
fp->ctf_syn_ext_strtab = syn_strtab;
if (foreign_endian &&
- (err = flip_ctf (fp, hp, fp->ctf_buf)) != 0)
+ (err = ctf_flip (fp, hp, fp->ctf_buf, 0)) != 0)
{
- /* We can be certain that flip_ctf() will have endian-flipped everything
+ /* We can be certain that ctf_flip() will have endian-flipped everything
other than the types table when we return. In particular the header
is fine, so set it, to allow freeing to use the usual code path. */
/* File writing. */
-/* Write the compressed CTF data stream to the specified gzFile descriptor. */
+/* Write the compressed CTF data stream to the specified gzFile descriptor. The
+ whole stream is compressed, and cannot be read by CTF opening functions in
+ this library until it is decompressed. (The functions below this one leave
+ the header uncompressed, and the CTF opening functions work on them without
+ manual decompression.)
+
+ No support for (testing-only) endian-flipping. */
int
ctf_gzwrite (ctf_dict_t *fp, gzFile fd)
{
return 0;
}
-/* Compress the specified CTF data stream and write it to the specified file
- descriptor. */
-int
-ctf_compress_write (ctf_dict_t *fp, int fd)
-{
- unsigned char *buf;
- unsigned char *bp;
- ctf_header_t h;
- ctf_header_t *hp = &h;
- ssize_t header_len = sizeof (ctf_header_t);
- ssize_t compress_len;
- ssize_t len;
- int rc;
- int err = 0;
-
- if (ctf_serialize (fp) < 0)
- return -1; /* errno is set for us. */
-
- memcpy (hp, fp->ctf_header, header_len);
- hp->cth_flags |= CTF_F_COMPRESS;
- compress_len = compressBound (fp->ctf_size);
-
- if ((buf = malloc (compress_len)) == NULL)
- {
- ctf_err_warn (fp, 0, 0, _("ctf_compress_write: cannot allocate %li bytes"),
- (unsigned long) compress_len);
- return (ctf_set_errno (fp, ECTF_ZALLOC));
- }
-
- if ((rc = compress (buf, (uLongf *) &compress_len,
- fp->ctf_buf, fp->ctf_size)) != Z_OK)
- {
- err = ctf_set_errno (fp, ECTF_COMPRESS);
- ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
- goto ret;
- }
-
- while (header_len > 0)
- {
- if ((len = write (fd, hp, header_len)) < 0)
- {
- err = ctf_set_errno (fp, errno);
- ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing header"));
- goto ret;
- }
- header_len -= len;
- hp += len;
- }
-
- bp = buf;
- while (compress_len > 0)
- {
- if ((len = write (fd, bp, compress_len)) < 0)
- {
- err = ctf_set_errno (fp, errno);
- ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing"));
- goto ret;
- }
- compress_len -= len;
- bp += len;
- }
-
-ret:
- free (buf);
- return err;
-}
-
/* Optionally compress the specified CTF data stream and return it as a new
- dynamically-allocated string. */
+ dynamically-allocated string. Possibly write it with reversed
+ endianness. */
unsigned char *
ctf_write_mem (ctf_dict_t *fp, size_t *size, size_t threshold)
{
unsigned char *buf;
unsigned char *bp;
ctf_header_t *hp;
+ unsigned char *flipped, *src;
ssize_t header_len = sizeof (ctf_header_t);
ssize_t compress_len;
+ int flip_endian;
+ int uncompressed;
int rc;
+ flip_endian = getenv ("LIBCTF_WRITE_FOREIGN_ENDIAN") != NULL;
+ uncompressed = (fp->ctf_size < threshold);
+
if (ctf_serialize (fp) < 0)
return NULL; /* errno is set for us. */
bp = buf + sizeof (struct ctf_header);
*size = sizeof (struct ctf_header);
- if (fp->ctf_size < threshold)
+ if (uncompressed)
+ hp->cth_flags &= ~CTF_F_COMPRESS;
+ else
+ hp->cth_flags |= CTF_F_COMPRESS;
+
+ src = fp->ctf_buf;
+ flipped = NULL;
+
+ if (flip_endian)
{
- hp->cth_flags &= ~CTF_F_COMPRESS;
- memcpy (bp, fp->ctf_buf, fp->ctf_size);
+ if ((flipped = malloc (fp->ctf_size)) == NULL)
+ {
+ ctf_set_errno (fp, ENOMEM);
+ ctf_err_warn (fp, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
+ (unsigned long) fp->ctf_size + sizeof (struct ctf_header));
+ return NULL;
+ }
+ ctf_flip_header (hp);
+ memcpy (flipped, fp->ctf_buf, fp->ctf_size);
+ if (ctf_flip (fp, fp->ctf_header, flipped, 1) < 0)
+ {
+ free (buf);
+ free (flipped);
+ return NULL; /* errno is set for us. */
+ }
+ src = flipped;
+ }
+
+ if (uncompressed)
+ {
+ memcpy (bp, src, fp->ctf_size);
*size += fp->ctf_size;
}
else
{
- hp->cth_flags |= CTF_F_COMPRESS;
if ((rc = compress (bp, (uLongf *) &compress_len,
- fp->ctf_buf, fp->ctf_size)) != Z_OK)
+ src, fp->ctf_size)) != Z_OK)
{
ctf_set_errno (fp, ECTF_COMPRESS);
ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
}
*size += compress_len;
}
+
+ free (flipped);
+
return buf;
}
-/* Write the uncompressed CTF data stream to the specified file descriptor. */
+/* Compress the specified CTF data stream and write it to the specified file
+ descriptor. */
int
-ctf_write (ctf_dict_t *fp, int fd)
+ctf_compress_write (ctf_dict_t *fp, int fd)
{
- const unsigned char *buf;
- ssize_t resid;
+ unsigned char *buf;
+ unsigned char *bp;
+ size_t tmp;
+ ssize_t buf_len;
ssize_t len;
+ int err = 0;
- if (ctf_serialize (fp) < 0)
+ if ((buf = ctf_write_mem (fp, &tmp, 0)) == NULL)
return -1; /* errno is set for us. */
- resid = sizeof (ctf_header_t);
- buf = (unsigned char *) fp->ctf_header;
- while (resid != 0)
+ buf_len = tmp;
+ bp = buf;
+
+ while (buf_len > 0)
{
- if ((len = write (fd, buf, resid)) <= 0)
+ if ((len = write (fd, bp, buf_len)) < 0)
{
- ctf_err_warn (fp, 0, errno, _("ctf_write: error writing header"));
- return (ctf_set_errno (fp, errno));
+ err = ctf_set_errno (fp, errno);
+ ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing"));
+ goto ret;
}
- resid -= len;
- buf += len;
+ buf_len -= len;
+ bp += len;
}
- resid = fp->ctf_size;
- buf = fp->ctf_buf;
- while (resid != 0)
+ret:
+ free (buf);
+ return err;
+}
+
+/* Write the uncompressed CTF data stream to the specified file descriptor. */
+int
+ctf_write (ctf_dict_t *fp, int fd)
+{
+ unsigned char *buf;
+ unsigned char *bp;
+ size_t tmp;
+ ssize_t buf_len;
+ ssize_t len;
+ int err = 0;
+
+ if ((buf = ctf_write_mem (fp, &tmp, (size_t) -1)) == NULL)
+ return -1; /* errno is set for us. */
+
+ buf_len = tmp;
+ bp = buf;
+
+ while (buf_len > 0)
{
- if ((len = write (fd, buf, resid)) <= 0)
+ if ((len = write (fd, bp, buf_len)) < 0)
{
- ctf_err_warn (fp, 0, errno, _("ctf_write: error writing"));
- return (ctf_set_errno (fp, errno));
+ err = ctf_set_errno (fp, errno);
+ ctf_err_warn (fp, 0, 0, _("ctf_compress_write: error writing"));
+ goto ret;
}
- resid -= len;
- buf += len;
+ buf_len -= len;
+ bp += len;
}
- return 0;
+ret:
+ free (buf);
+ return err;
}
projects / binutils-gdb.git / commitdiff