Edit
IABSD.fr/src/usr.bin/ctfconv/generate.c
claudio
- usr.bin/ctfconv/generate.c
-
/* $OpenBSD: generate.c,v 1.8 2024/10/02 12:31:33 claudio Exp $ */ /* * Copyright (c) 2017 Martin Pieuchot * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include <sys/types.h> #include <sys/queue.h> #include <sys/tree.h> #include <sys/ctf.h> #include <assert.h> #include <err.h> #include <fcntl.h> #include <string.h> #include <stdlib.h> #include <stddef.h> #include <stdint.h> #include <unistd.h> #ifdef ZLIB #include <zlib.h> #endif /* ZLIB */ #include "itype.h" #include "xmalloc.h" #include "hash.h" #define ROUNDUP(x, y) ((((x) + (y) - 1) / (y)) * (y)) /* * Dynamic buffer, used for content & string table. */ struct dbuf { char *data; /* start data buffer */ size_t size; /* size of the buffer */ char *cptr; /* position in [data, data + size] */ size_t coff; /* number of written bytes */ }; #define DBUF_CHUNKSZ (64 * 1024) /* In-memory representation of a CTF section. */ struct imcs { struct dbuf body; struct dbuf stab; /* corresponding string table */ struct hash *htab; /* hash table of known strings */ }; struct strentry { struct hash_entry se_key; /* Must be first */ #define se_str se_key.hkey size_t se_off; }; #ifdef ZLIB char *data_compress(const char *, size_t, size_t, size_t *); #endif /* ZLIB */ void dbuf_realloc(struct dbuf *dbuf, size_t len) { assert(dbuf != NULL); assert(len != 0); dbuf->data = xrealloc(dbuf->data, dbuf->size + len); dbuf->size += len; dbuf->cptr = dbuf->data + dbuf->coff; } void dbuf_copy(struct dbuf *dbuf, void const *data, size_t len) { size_t left; assert(dbuf->cptr != NULL); assert(dbuf->data != NULL); assert(dbuf->size != 0); if (len == 0) return; left = dbuf->size - dbuf->coff; if (left < len) dbuf_realloc(dbuf, ROUNDUP((len - left), DBUF_CHUNKSZ)); memcpy(dbuf->cptr, data, len); dbuf->cptr += len; dbuf->coff += len; } size_t dbuf_pad(struct dbuf *dbuf, int align) { int i = (align - (dbuf->coff % align)) % align; while (i-- > 0) dbuf_copy(dbuf, "", 1); return dbuf->coff; } size_t imcs_add_string(struct imcs *imcs, const char *str) { struct strentry *se; unsigned int slot; if (str == NULL || *str == '\0') return 0; se = (struct strentry *)hash_find(imcs->htab, str, &slot); if (se == NULL) { se = xmalloc(sizeof(*se)); hash_insert(imcs->htab, slot, &se->se_key, str); se->se_off = imcs->stab.coff; dbuf_copy(&imcs->stab, str, strlen(str) + 1); } return se->se_off; } void imcs_add_func(struct imcs *imcs, struct itype *it) { uint16_t func, arg; struct imember *im; int kind, root, vlen; vlen = it->it_nelems; kind = it->it_type; root = 0; func = (kind << 11) | (root << 10) | (vlen & CTF_MAX_VLEN); dbuf_copy(&imcs->body, &func, sizeof(func)); if (kind == CTF_K_UNKNOWN) return; func = it->it_refp->it_idx; dbuf_copy(&imcs->body, &func, sizeof(func)); TAILQ_FOREACH(im, &it->it_members, im_next) { arg = im->im_refp->it_idx; dbuf_copy(&imcs->body, &arg, sizeof(arg)); } } void imcs_add_obj(struct imcs *imcs, struct itype *it) { uint16_t type; type = it->it_refp->it_idx; dbuf_copy(&imcs->body, &type, sizeof(type)); } void imcs_add_type(struct imcs *imcs, struct itype *it) { struct imember *im; struct ctf_type ctt; struct ctf_array cta; unsigned int eob; uint32_t size; uint16_t arg; size_t ctsz; int kind, root, vlen; assert(it->it_type != CTF_K_UNKNOWN && it->it_type != CTF_K_FORWARD); vlen = it->it_nelems; size = it->it_size; kind = it->it_type; root = 0; ctt.ctt_name = imcs_add_string(imcs, it_name(it)); ctt.ctt_info = (kind << 11) | (root << 10) | (vlen & CTF_MAX_VLEN); /* Base types don't have reference, typedef & pointer don't have size */ if (it->it_refp != NULL && kind != CTF_K_ARRAY) { ctt.ctt_type = it->it_refp->it_idx; ctsz = sizeof(struct ctf_stype); } else if (size <= CTF_MAX_SIZE) { if (kind == CTF_K_INTEGER || kind == CTF_K_FLOAT) { assert(size <= 128); if (size == 0) ctt.ctt_size = 0; else if (size <= 8) ctt.ctt_size = 1; else if (size <= 16) ctt.ctt_size = 2; else if (size <= 32) ctt.ctt_size = 4; else if (size <= 64) ctt.ctt_size = 8; else if (size <= 96) ctt.ctt_size = 12; else ctt.ctt_size = 16; } else ctt.ctt_size = size; ctsz = sizeof(struct ctf_stype); } else { ctt.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size); ctt.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size); ctt.ctt_size = CTF_LSIZE_SENT; ctsz = sizeof(struct ctf_type); } dbuf_copy(&imcs->body, &ctt, ctsz); switch (kind) { assert(1 == 0); break; case CTF_K_INTEGER: case CTF_K_FLOAT: eob = CTF_INT_DATA(it->it_enc, 0, size); dbuf_copy(&imcs->body, &eob, sizeof(eob)); break; case CTF_K_ARRAY: memset(&cta, 0, sizeof(cta)); cta.cta_contents = it->it_refp->it_idx; cta.cta_index = long_tidx; cta.cta_nelems = it->it_nelems; dbuf_copy(&imcs->body, &cta, sizeof(cta)); break; case CTF_K_STRUCT: case CTF_K_UNION: if (size < CTF_LSTRUCT_THRESH) { struct ctf_member ctm; memset(&ctm, 0, sizeof(ctm)); TAILQ_FOREACH(im, &it->it_members, im_next) { ctm.ctm_name = imcs_add_string(imcs, im_name(im)); ctm.ctm_type = im->im_refp->it_idx; ctm.ctm_offset = im->im_off; dbuf_copy(&imcs->body, &ctm, sizeof(ctm)); } } else { struct ctf_lmember ctlm; memset(&ctlm, 0, sizeof(ctlm)); TAILQ_FOREACH(im, &it->it_members, im_next) { ctlm.ctlm_name = imcs_add_string(imcs, im_name(im)); ctlm.ctlm_type = im->im_refp->it_idx; ctlm.ctlm_offsethi = CTF_OFFSET_TO_LMEMHI(im->im_off); ctlm.ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO(im->im_off); dbuf_copy(&imcs->body, &ctlm, sizeof(ctlm)); } } break; case CTF_K_FUNCTION: TAILQ_FOREACH(im, &it->it_members, im_next) { arg = im->im_refp->it_idx; dbuf_copy(&imcs->body, &arg, sizeof(arg)); } if (vlen & 1) { arg = 0; dbuf_copy(&imcs->body, &arg, sizeof(arg)); } break; case CTF_K_ENUM: TAILQ_FOREACH(im, &it->it_members, im_next) { struct ctf_enum cte; cte.cte_name = imcs_add_string(imcs, im_name(im)); cte.cte_value = im->im_ref; dbuf_copy(&imcs->body, &cte, sizeof(cte)); } break; case CTF_K_POINTER: case CTF_K_TYPEDEF: case CTF_K_VOLATILE: case CTF_K_CONST: case CTF_K_RESTRICT: default: break; } } void imcs_generate(struct imcs *imcs, struct ctf_header *cth, const char *label) { struct itype *it; struct ctf_lblent lbl; memset(imcs, 0, sizeof(*imcs)); dbuf_realloc(&imcs->body, DBUF_CHUNKSZ); dbuf_realloc(&imcs->stab, DBUF_CHUNKSZ); imcs->htab = hash_init(10); if (imcs->htab == NULL) err(1, "hash_init"); /* Add empty string */ dbuf_copy(&imcs->stab, "", 1); /* We don't use parent label */ cth->cth_parlabel = 0; cth->cth_parname = 0; /* Insert a single label for all types. */ cth->cth_lbloff = 0; lbl.ctl_label = imcs_add_string(imcs, label); lbl.ctl_typeidx = tidx; dbuf_copy(&imcs->body, &lbl, sizeof(lbl)); /* Insert objects */ cth->cth_objtoff = dbuf_pad(&imcs->body, 2); TAILQ_FOREACH(it, &iobjq, it_symb) imcs_add_obj(imcs, it); /* Insert functions */ cth->cth_funcoff = dbuf_pad(&imcs->body, 2); TAILQ_FOREACH(it, &ifuncq, it_symb) imcs_add_func(imcs, it); /* Insert types */ cth->cth_typeoff = dbuf_pad(&imcs->body, 4); TAILQ_FOREACH(it, &itypeq, it_next) { if (it->it_flags & (ITF_FUNC|ITF_OBJ)) continue; imcs_add_type(imcs, it); } /* String table is written from its own buffer. */ cth->cth_stroff = imcs->body.coff; cth->cth_strlen = imcs->stab.coff; } /* * Generate a CTF buffer from the internal type representation. */ int generate(const char *path, const char *label, int compress) { char *p, *ctfdata = NULL; ssize_t ctflen; struct ctf_header cth; struct imcs imcs; int error = 0, fd; memset(&cth, 0, sizeof(cth)); cth.cth_magic = CTF_MAGIC; cth.cth_version = CTF_VERSION; #ifdef ZLIB if (compress) cth.cth_flags = CTF_F_COMPRESS; #endif /* ZLIB */ imcs_generate(&imcs, &cth, label); ctflen = sizeof(cth) + imcs.body.coff + imcs.stab.coff; p = ctfdata = xmalloc(ctflen); memcpy(p, &cth, sizeof(cth)); p += sizeof(cth); memcpy(p, imcs.body.data, imcs.body.coff); p += imcs.body.coff; memcpy(p, imcs.stab.data, imcs.stab.coff); p += imcs.stab.coff; assert((p - ctfdata) == ctflen); #ifdef ZLIB if (compress) { char *cdata; size_t clen; cdata = data_compress(ctfdata + sizeof(cth), ctflen - sizeof(cth), ctflen - sizeof(cth), &clen); if (cdata == NULL) { warnx("compressing CTF data"); free(ctfdata); return -1; } memcpy(ctfdata + sizeof(cth), cdata, clen); ctflen = clen + sizeof(cth); free(cdata); } #endif /* ZLIB */ fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644); if (fd == -1) { warn("open %s", path); free(ctfdata); return -1; } if (write(fd, ctfdata, ctflen) != ctflen) { warn("unable to write %zd bytes for %s", ctflen, path); error = -1; } close(fd); free(ctfdata); return error; } #ifdef ZLIB char * data_compress(const char *buf, size_t size, size_t len, size_t *pclen) { z_stream stream; char *data; int error; data = malloc(len); if (data == NULL) { warn(NULL); return NULL; } memset(&stream, 0, sizeof(stream)); stream.zalloc = Z_NULL; stream.zfree = Z_NULL; stream.opaque = Z_NULL; if ((error = deflateInit(&stream, Z_BEST_COMPRESSION)) != Z_OK) { warnx("zlib deflateInit failed: %s", zError(error)); goto exit; } stream.next_in = (void *)buf; stream.avail_in = size; stream.next_out = (unsigned char *)data; stream.avail_out = len; if ((error = deflate(&stream, Z_FINISH)) != Z_STREAM_END) { warnx("zlib deflate failed: %s", zError(error)); deflateEnd(&stream); goto exit; } if ((error = deflateEnd(&stream)) != Z_OK) { warnx("zlib deflateEnd failed: %s", zError(error)); goto exit; } if (pclen != NULL) *pclen = stream.total_out; return data; exit: free(data); return NULL; } #endif /* ZLIB */