-/* CTF file creation.
- Copyright (C) 2019-2021 Free Software Foundation, Inc.
+/* CTF dict creation.
+ Copyright (C) 2019-2023 Free Software Foundation, Inc.
This file is part of libctf.
#include <ctf-impl.h>
#include <sys/param.h>
-#include <assert.h>
#include <string.h>
#include <unistd.h>
-#include <zlib.h>
-
-#include <elf.h>
-#include "elf-bfd.h"
#ifndef EOVERFLOW
#define EOVERFLOW ERANGE
#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
#endif
+/* The initial size of a dynamic type's vlen in members. Arbitrary: the bigger
+ this is, the less allocation needs to be done for small structure
+ initialization, and the more memory is wasted for small structures during CTF
+ construction. No effect on generated CTF or ctf_open()ed CTF. */
+#define INITIAL_VLEN 16
+
/* Make sure the ptrtab has enough space for at least one more type.
We start with 4KiB of ptrtab, enough for a thousand types, then grow it 25%
return 0;
}
+/* Make sure a vlen has enough space: expand it otherwise. Unlike the ptrtab,
+ which grows quite slowly, the vlen grows in big jumps because it is quite
+ expensive to expand: the caller has to scan the old vlen for string refs
+ first and remove them, then re-add them afterwards. The initial size is
+ more or less arbitrary. */
+static int
+ctf_grow_vlen (ctf_dict_t *fp, ctf_dtdef_t *dtd, size_t vlen)
+{
+ unsigned char *old = dtd->dtd_vlen;
+
+ if (dtd->dtd_vlen_alloc > vlen)
+ return 0;
+
+ if ((dtd->dtd_vlen = realloc (dtd->dtd_vlen,
+ dtd->dtd_vlen_alloc * 2)) == NULL)
+ {
+ dtd->dtd_vlen = old;
+ return (ctf_set_errno (fp, ENOMEM));
+ }
+ memset (dtd->dtd_vlen + dtd->dtd_vlen_alloc, 0, dtd->dtd_vlen_alloc);
+ dtd->dtd_vlen_alloc *= 2;
+ return 0;
+}
+
/* To create an empty CTF dict, we just declare a zeroed header and call
ctf_bufopen() on it. If ctf_bufopen succeeds, we mark the new dict r/w and
initialize the dynamic members. We start assigning type IDs at 1 because
fp->ctf_funchash = funchash;
fp->ctf_dthash = dthash;
fp->ctf_dvhash = dvhash;
- fp->ctf_dtoldid = 0;
- fp->ctf_snapshots = 1;
- fp->ctf_snapshot_lu = 0;
- fp->ctf_flags |= LCTF_DIRTY;
-
- ctf_set_ctl_hashes (fp);
- ctf_setmodel (fp, CTF_MODEL_NATIVE);
- if (ctf_grow_ptrtab (fp) < 0)
- {
- ctf_set_open_errno (errp, ctf_errno (fp));
- ctf_dict_close (fp);
- return NULL;
- }
-
- return fp;
-
- err_dv:
- ctf_dynhash_destroy (structs);
- ctf_dynhash_destroy (unions);
- ctf_dynhash_destroy (enums);
- ctf_dynhash_destroy (names);
- ctf_dynhash_destroy (objthash);
- ctf_dynhash_destroy (funchash);
- ctf_dynhash_destroy (dvhash);
- err_dt:
- ctf_dynhash_destroy (dthash);
- err:
- return NULL;
-}
-
-/* Delete data symbols that have been assigned names from the variable section.
- Must be called from within ctf_serialize, because that is the only place
- you can safely delete variables without messing up ctf_rollback. */
-
-static int
-symtypetab_delete_nonstatic_vars (ctf_dict_t *fp, ctf_dict_t *symfp)
-{
- ctf_dvdef_t *dvd, *nvd;
- ctf_id_t type;
-
- for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd)
- {
- nvd = ctf_list_next (dvd);
-
- if (((type = (ctf_id_t) (uintptr_t)
- ctf_dynhash_lookup (fp->ctf_objthash, dvd->dvd_name)) > 0)
- && ctf_dynhash_lookup (symfp->ctf_dynsyms, dvd->dvd_name) != NULL
- && type == dvd->dvd_type)
- ctf_dvd_delete (fp, dvd);
- }
-
- return 0;
-}
-
-/* Determine if a symbol is "skippable" and should never appear in the
- symtypetab sections. */
-
-int
-ctf_symtab_skippable (ctf_link_sym_t *sym)
-{
- /* Never skip symbols whose name is not yet known. */
- if (sym->st_nameidx_set)
- return 0;
-
- return (sym->st_name == NULL || sym->st_name[0] == 0
- || sym->st_shndx == SHN_UNDEF
- || strcmp (sym->st_name, "_START_") == 0
- || strcmp (sym->st_name, "_END_") == 0
- || (sym->st_type == STT_OBJECT && sym->st_shndx == SHN_EXTABS
- && sym->st_value == 0));
-}
-
-/* Symtypetab emission flags. */
-
-#define CTF_SYMTYPETAB_EMIT_FUNCTION 0x1
-#define CTF_SYMTYPETAB_EMIT_PAD 0x2
-#define CTF_SYMTYPETAB_FORCE_INDEXED 0x4
-
-/* Get the number of symbols in a symbol hash, the count of symbols, the maximum
- seen, the eventual size, without any padding elements, of the func/data and
- (if generated) index sections, and the size of accumulated padding elements.
- The linker-reported set of symbols is found in SYMFP: it may be NULL if
- symbol filtering is not desired, in which case CTF_SYMTYPETAB_FORCE_INDEXED
- will always be set in the flags.
-
- Also figure out if any symbols need to be moved to the variable section, and
- add them (if not already present). */
-
-_libctf_nonnull_ ((1,3,4,5,6,7,8))
-static int
-symtypetab_density (ctf_dict_t *fp, ctf_dict_t *symfp, ctf_dynhash_t *symhash,
- size_t *count, size_t *max, size_t *unpadsize,
- size_t *padsize, size_t *idxsize, int flags)
-{
- ctf_next_t *i = NULL;
- const void *name;
- const void *ctf_sym;
- ctf_dynhash_t *linker_known = NULL;
- int err;
- int beyond_max = 0;
-
- *count = 0;
- *max = 0;
- *unpadsize = 0;
- *idxsize = 0;
- *padsize = 0;
-
- if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
- {
- /* Make a dynhash citing only symbols reported by the linker of the
- appropriate type, then traverse all potential-symbols we know the types
- of, removing them from linker_known as we go. Once this is done, the
- only symbols remaining in linker_known are symbols we don't know the
- types of: we must emit pads for those symbols that are below the
- maximum symbol we will emit (any beyond that are simply skipped).
-
- If there are none, this symtypetab will be empty: just report that. */
-
- if (!symfp->ctf_dynsyms)
- return 0;
-
- if ((linker_known = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
- NULL, NULL)) == NULL)
- return (ctf_set_errno (fp, ENOMEM));
-
- while ((err = ctf_dynhash_cnext (symfp->ctf_dynsyms, &i,
- &name, &ctf_sym)) == 0)
- {
- ctf_link_sym_t *sym = (ctf_link_sym_t *) ctf_sym;
-
- if (((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && sym->st_type != STT_FUNC)
- || (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && sym->st_type != STT_OBJECT))
- continue;
-
- if (ctf_symtab_skippable (sym))
- continue;
-
- /* This should only be true briefly before all the names are
- finalized, long before we get this far. */
- if (!ctf_assert (fp, !sym->st_nameidx_set))
- return -1; /* errno is set for us. */
-
- if (ctf_dynhash_cinsert (linker_known, name, ctf_sym) < 0)
- {
- ctf_dynhash_destroy (linker_known);
- return (ctf_set_errno (fp, ENOMEM));
- }
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_err_warn (fp, 0, err, _("iterating over linker-known symbols during "
- "serialization"));
- ctf_dynhash_destroy (linker_known);
- return (ctf_set_errno (fp, err));
- }
- }
-
- while ((err = ctf_dynhash_cnext (symhash, &i, &name, NULL)) == 0)
- {
- ctf_link_sym_t *sym;
-
- if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
- {
- /* Linker did not report symbol in symtab. Remove it from the
- set of known data symbols and continue. */
- if ((sym = ctf_dynhash_lookup (symfp->ctf_dynsyms, name)) == NULL)
- {
- ctf_dynhash_remove (symhash, name);
- continue;
- }
-
- /* We don't remove skippable symbols from the symhash because we don't
- want them to be migrated into variables. */
- if (ctf_symtab_skippable (sym))
- continue;
-
- if ((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && sym->st_type != STT_FUNC)
- {
- ctf_err_warn (fp, 1, 0, _("Symbol %x added to CTF as a function "
- "but is of type %x\n"),
- sym->st_symidx, sym->st_type);
- ctf_dynhash_remove (symhash, name);
- continue;
- }
- else if (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && sym->st_type != STT_OBJECT)
- {
- ctf_err_warn (fp, 1, 0, _("Symbol %x added to CTF as a data "
- "object but is of type %x\n"),
- sym->st_symidx, sym->st_type);
- ctf_dynhash_remove (symhash, name);
- continue;
- }
-
- ctf_dynhash_remove (linker_known, name);
- }
- *unpadsize += sizeof (uint32_t);
- (*count)++;
-
- if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
- {
- if (*max < sym->st_symidx)
- *max = sym->st_symidx;
- }
- else
- (*max)++;
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_err_warn (fp, 0, err, _("iterating over CTF symtypetab during "
- "serialization"));
- ctf_dynhash_destroy (linker_known);
- return (ctf_set_errno (fp, err));
- }
-
- if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
- {
- while ((err = ctf_dynhash_cnext (linker_known, &i, NULL, &ctf_sym)) == 0)
- {
- ctf_link_sym_t *sym = (ctf_link_sym_t *) ctf_sym;
-
- if (sym->st_symidx > *max)
- beyond_max++;
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_err_warn (fp, 0, err, _("iterating over linker-known symbols "
- "during CTF serialization"));
- ctf_dynhash_destroy (linker_known);
- return (ctf_set_errno (fp, err));
- }
- }
-
- *idxsize = *count * sizeof (uint32_t);
- if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
- *padsize = (ctf_dynhash_elements (linker_known) - beyond_max) * sizeof (uint32_t);
-
- ctf_dynhash_destroy (linker_known);
- return 0;
-}
-
-/* Emit an objt or func symtypetab into DP in a particular order defined by an
- array of ctf_link_sym_t or symbol names passed in. The index has NIDX
- elements in it: unindexed output would terminate at symbol OUTMAX and is in
- any case no larger than SIZE bytes. Some index elements are expected to be
- skipped: see symtypetab_density. The linker-reported set of symbols (if any)
- is found in SYMFP. */
-static int
-emit_symtypetab (ctf_dict_t *fp, ctf_dict_t *symfp, uint32_t *dp,
- ctf_link_sym_t **idx, const char **nameidx, uint32_t nidx,
- uint32_t outmax, int size, int flags)
-{
- uint32_t i;
- uint32_t *dpp = dp;
- ctf_dynhash_t *symhash;
-
- ctf_dprintf ("Emitting table of size %i, outmax %u, %u symtypetab entries, "
- "flags %i\n", size, outmax, nidx, flags);
-
- /* Empty table? Nothing to do. */
- if (size == 0)
- return 0;
-
- if (flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- symhash = fp->ctf_funchash;
- else
- symhash = fp->ctf_objthash;
-
- for (i = 0; i < nidx; i++)
- {
- const char *sym_name;
- void *type;
-
- /* If we have a linker-reported set of symbols, we may be given that set
- to work from, or a set of symbol names. In both cases we want to look
- at the corresponding linker-reported symbol (if any). */
- if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
- {
- ctf_link_sym_t *this_link_sym;
-
- if (idx)
- this_link_sym = idx[i];
- else
- this_link_sym = ctf_dynhash_lookup (symfp->ctf_dynsyms, nameidx[i]);
-
- /* Unreported symbol number. No pad, no nothing. */
- if (!this_link_sym)
- continue;
-
- /* Symbol of the wrong type, or skippable? This symbol is not in this
- table. */
- if (((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && this_link_sym->st_type != STT_FUNC)
- || (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && this_link_sym->st_type != STT_OBJECT))
- continue;
-
- if (ctf_symtab_skippable (this_link_sym))
- continue;
-
- sym_name = this_link_sym->st_name;
-
- /* Linker reports symbol of a different type to the symbol we actually
- added? Skip the symbol. No pad, since the symbol doesn't actually
- belong in this table at all. (Warned about in
- symtypetab_density.) */
- if ((this_link_sym->st_type == STT_FUNC)
- && (ctf_dynhash_lookup (fp->ctf_objthash, sym_name)))
- continue;
-
- if ((this_link_sym->st_type == STT_OBJECT)
- && (ctf_dynhash_lookup (fp->ctf_funchash, sym_name)))
- continue;
- }
- else
- sym_name = nameidx[i];
-
- /* Symbol in index but no type set? Silently skip and (optionally)
- pad. (In force-indexed mode, this is also where we track symbols of
- the wrong type for this round of insertion.) */
- if ((type = ctf_dynhash_lookup (symhash, sym_name)) == NULL)
- {
- if (flags & CTF_SYMTYPETAB_EMIT_PAD)
- *dpp++ = 0;
- continue;
- }
-
- if (!ctf_assert (fp, (((char *) dpp) - (char *) dp) < size))
- return -1; /* errno is set for us. */
-
- *dpp++ = (ctf_id_t) (uintptr_t) type;
-
- /* When emitting unindexed output, all later symbols are pads: stop
- early. */
- if ((flags & CTF_SYMTYPETAB_EMIT_PAD) && idx[i]->st_symidx == outmax)
- break;
- }
-
- return 0;
-}
-
-/* Emit an objt or func symtypetab index into DP in a paticular order defined by
- an array of symbol names passed in. Stop at NIDX. The linker-reported set
- of symbols (if any) is found in SYMFP. */
-static int
-emit_symtypetab_index (ctf_dict_t *fp, ctf_dict_t *symfp, uint32_t *dp,
- const char **idx, uint32_t nidx, int size, int flags)
-{
- uint32_t i;
- uint32_t *dpp = dp;
- ctf_dynhash_t *symhash;
-
- ctf_dprintf ("Emitting index of size %i, %u entries reported by linker, "
- "flags %i\n", size, nidx, flags);
-
- /* Empty table? Nothing to do. */
- if (size == 0)
- return 0;
-
- if (flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- symhash = fp->ctf_funchash;
- else
- symhash = fp->ctf_objthash;
-
- /* Indexes should always be unpadded. */
- if (!ctf_assert (fp, !(flags & CTF_SYMTYPETAB_EMIT_PAD)))
- return -1; /* errno is set for us. */
-
- for (i = 0; i < nidx; i++)
- {
- const char *sym_name;
- void *type;
-
- if (!(flags & CTF_SYMTYPETAB_FORCE_INDEXED))
- {
- ctf_link_sym_t *this_link_sym;
-
- this_link_sym = ctf_dynhash_lookup (symfp->ctf_dynsyms, idx[i]);
-
- /* This is an index: unreported symbols should never appear in it. */
- if (!ctf_assert (fp, this_link_sym != NULL))
- return -1; /* errno is set for us. */
-
- /* Symbol of the wrong type, or skippable? This symbol is not in this
- table. */
- if (((flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && this_link_sym->st_type != STT_FUNC)
- || (!(flags & CTF_SYMTYPETAB_EMIT_FUNCTION)
- && this_link_sym->st_type != STT_OBJECT))
- continue;
-
- if (ctf_symtab_skippable (this_link_sym))
- continue;
-
- sym_name = this_link_sym->st_name;
-
- /* Linker reports symbol of a different type to the symbol we actually
- added? Skip the symbol. */
- if ((this_link_sym->st_type == STT_FUNC)
- && (ctf_dynhash_lookup (fp->ctf_objthash, sym_name)))
- continue;
-
- if ((this_link_sym->st_type == STT_OBJECT)
- && (ctf_dynhash_lookup (fp->ctf_funchash, sym_name)))
- continue;
- }
- else
- sym_name = idx[i];
-
- /* Symbol in index and reported by linker, but no type set? Silently skip
- and (optionally) pad. (In force-indexed mode, this is also where we
- track symbols of the wrong type for this round of insertion.) */
- if ((type = ctf_dynhash_lookup (symhash, sym_name)) == NULL)
- continue;
-
- ctf_str_add_ref (fp, sym_name, dpp++);
-
- if (!ctf_assert (fp, (((char *) dpp) - (char *) dp) <= size))
- return -1; /* errno is set for us. */
- }
-
- return 0;
-}
-
-static unsigned char *
-ctf_copy_smembers (ctf_dict_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
-{
- ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- ctf_member_t ctm;
-
- for (; dmd != NULL; dmd = ctf_list_next (dmd))
- {
- ctf_member_t *copied;
-
- ctm.ctm_name = 0;
- ctm.ctm_type = (uint32_t) dmd->dmd_type;
- ctm.ctm_offset = (uint32_t) dmd->dmd_offset;
-
- memcpy (t, &ctm, sizeof (ctm));
- copied = (ctf_member_t *) t;
- if (dmd->dmd_name)
- ctf_str_add_ref (fp, dmd->dmd_name, &copied->ctm_name);
-
- t += sizeof (ctm);
- }
-
- return t;
-}
-
-static unsigned char *
-ctf_copy_lmembers (ctf_dict_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
-{
- ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- ctf_lmember_t ctlm;
-
- for (; dmd != NULL; dmd = ctf_list_next (dmd))
- {
- ctf_lmember_t *copied;
-
- ctlm.ctlm_name = 0;
- ctlm.ctlm_type = (uint32_t) dmd->dmd_type;
- ctlm.ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset);
- ctlm.ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset);
-
- memcpy (t, &ctlm, sizeof (ctlm));
- copied = (ctf_lmember_t *) t;
- if (dmd->dmd_name)
- ctf_str_add_ref (fp, dmd->dmd_name, &copied->ctlm_name);
-
- t += sizeof (ctlm);
- }
-
- return t;
-}
-
-static unsigned char *
-ctf_copy_emembers (ctf_dict_t *fp, ctf_dtdef_t *dtd, unsigned char *t)
-{
- ctf_dmdef_t *dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- ctf_enum_t cte;
-
- for (; dmd != NULL; dmd = ctf_list_next (dmd))
- {
- ctf_enum_t *copied;
-
- cte.cte_value = dmd->dmd_value;
- memcpy (t, &cte, sizeof (cte));
- copied = (ctf_enum_t *) t;
- ctf_str_add_ref (fp, dmd->dmd_name, &copied->cte_name);
- t += sizeof (cte);
- }
-
- return t;
-}
-
-/* Sort a newly-constructed static variable array. */
-
-typedef struct ctf_sort_var_arg_cb
-{
- ctf_dict_t *fp;
- ctf_strs_t *strtab;
-} ctf_sort_var_arg_cb_t;
-
-static int
-ctf_sort_var (const void *one_, const void *two_, void *arg_)
-{
- const ctf_varent_t *one = one_;
- const ctf_varent_t *two = two_;
- ctf_sort_var_arg_cb_t *arg = arg_;
-
- return (strcmp (ctf_strraw_explicit (arg->fp, one->ctv_name, arg->strtab),
- ctf_strraw_explicit (arg->fp, two->ctv_name, arg->strtab)));
-}
-
-/* Compatibility: just update the threshold for ctf_discard. */
-int
-ctf_update (ctf_dict_t *fp)
-{
- if (!(fp->ctf_flags & LCTF_RDWR))
- return (ctf_set_errno (fp, ECTF_RDONLY));
-
- fp->ctf_dtoldid = fp->ctf_typemax;
- return 0;
-}
-
-/* If the specified CTF dict is writable and has been modified, reload this dict
- with the updated type definitions, ready for serialization. In order to make
- this code and the rest of libctf as simple as possible, we perform updates by
- taking the dynamic type definitions and creating an in-memory CTF dict
- containing the definitions, and then call ctf_simple_open_internal() on it.
- We perform one extra trick here for the benefit of callers and to keep our
- code simple: ctf_simple_open_internal() will return a new ctf_dict_t, but we
- want to keep the fp constant for the caller, so after
- ctf_simple_open_internal() returns, we use memcpy to swap the interior of the
- old and new ctf_dict_t's, and then free the old. */
-int
-ctf_serialize (ctf_dict_t *fp)
-{
- ctf_dict_t ofp, *nfp;
- ctf_header_t hdr, *hdrp;
- ctf_dtdef_t *dtd;
- ctf_dvdef_t *dvd;
- ctf_varent_t *dvarents;
- ctf_strs_writable_t strtab;
-
- unsigned char *t;
- unsigned long i;
- size_t buf_size, type_size, objt_size, func_size;
- size_t objt_unpadsize, func_unpadsize, objt_padsize, func_padsize;
- size_t funcidx_size, objtidx_size;
- size_t nvars, nfuncs, nobjts, maxobjt, maxfunc;
- size_t nsymtypes = 0;
- const char **sym_name_order = NULL;
- unsigned char *buf = NULL, *newbuf;
- int err;
-
- /* Symtab filtering. If filter_syms is true, symfp is set: otherwise,
- CTF_SYMTYPETAB_FORCE_INDEXED is set in symflags. */
- int filter_syms = 0;
- int sort_syms = 1;
- int symflags = 0;
- ctf_dict_t *symfp = NULL;
-
- if (!(fp->ctf_flags & LCTF_RDWR))
- return (ctf_set_errno (fp, ECTF_RDONLY));
-
- /* Update required? */
- if (!(fp->ctf_flags & LCTF_DIRTY))
- return 0;
-
- /* If doing a writeout as part of linking, and the link flags request it,
- filter out reported symbols from the variable section, and filter out all
- other symbols from the symtypetab sections. (If we are not linking, the
- symbols are sorted; if we are linking, don't bother sorting if we are not
- filtering out reported symbols: this is almost certaily an ld -r and only
- the linker is likely to consume these symtypetabs again. The linker
- doesn't care what order the symtypetab entries is in, since it only
- iterates over symbols and does not use the ctf_lookup_by_symbol* API.) */
-
- if (fp->ctf_flags & LCTF_LINKING)
- {
- filter_syms = !(fp->ctf_link_flags & CTF_LINK_NO_FILTER_REPORTED_SYMS);
- if (!filter_syms)
- sort_syms = 0;
- }
-
- /* Fill in an initial CTF header. We will leave the label, object,
- and function sections empty and only output a header, type section,
- and string table. The type section begins at a 4-byte aligned
- boundary past the CTF header itself (at relative offset zero). The flag
- indicating a new-style function info section (an array of CTF_K_FUNCTION
- type IDs in the types section) is flipped on. */
-
- memset (&hdr, 0, sizeof (hdr));
- hdr.cth_magic = CTF_MAGIC;
- hdr.cth_version = CTF_VERSION;
-
- /* This is a new-format func info section, and the symtab and strtab come out
- of the dynsym and dynstr these days. */
- hdr.cth_flags = (CTF_F_NEWFUNCINFO | CTF_F_DYNSTR);
-
- /* Iterate through the dynamic type definition list and compute the
- size of the CTF type section we will need to generate. */
-
- for (type_size = 0, dtd = ctf_list_next (&fp->ctf_dtdefs);
- dtd != NULL; dtd = ctf_list_next (dtd))
- {
- uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
- uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
-
- if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
- type_size += sizeof (ctf_stype_t);
- else
- type_size += sizeof (ctf_type_t);
-
- switch (kind)
- {
- case CTF_K_INTEGER:
- case CTF_K_FLOAT:
- type_size += sizeof (uint32_t);
- break;
- case CTF_K_ARRAY:
- type_size += sizeof (ctf_array_t);
- break;
- case CTF_K_SLICE:
- type_size += sizeof (ctf_slice_t);
- break;
- case CTF_K_FUNCTION:
- type_size += sizeof (uint32_t) * (vlen + (vlen & 1));
- break;
- case CTF_K_STRUCT:
- case CTF_K_UNION:
- if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
- type_size += sizeof (ctf_member_t) * vlen;
- else
- type_size += sizeof (ctf_lmember_t) * vlen;
- break;
- case CTF_K_ENUM:
- type_size += sizeof (ctf_enum_t) * vlen;
- break;
- }
- }
-
- /* Find the dict to which the linker has reported symbols, if any. */
-
- if (filter_syms)
- {
- if (!fp->ctf_dynsyms && fp->ctf_parent && fp->ctf_parent->ctf_dynsyms)
- symfp = fp->ctf_parent;
- else
- symfp = fp;
- }
-
- /* If not filtering, keep all potential symbols in an unsorted, indexed
- dict. */
- if (!filter_syms)
- symflags = CTF_SYMTYPETAB_FORCE_INDEXED;
- else
- hdr.cth_flags |= CTF_F_IDXSORTED;
-
- if (!ctf_assert (fp, (filter_syms && symfp)
- || (!filter_syms && !symfp
- && ((symflags & CTF_SYMTYPETAB_FORCE_INDEXED) != 0))))
- return -1;
-
- /* Work out the sizes of the object and function sections, and work out the
- number of pad (unassigned) symbols in each, and the overall size of the
- sections. */
-
- if (symtypetab_density (fp, symfp, fp->ctf_objthash, &nobjts, &maxobjt,
- &objt_unpadsize, &objt_padsize, &objtidx_size,
- symflags) < 0)
- return -1; /* errno is set for us. */
-
- ctf_dprintf ("Object symtypetab: %i objects, max %i, unpadded size %i, "
- "%i bytes of pads, index size %i\n", (int) nobjts, (int) maxobjt,
- (int) objt_unpadsize, (int) objt_padsize, (int) objtidx_size);
-
- if (symtypetab_density (fp, symfp, fp->ctf_funchash, &nfuncs, &maxfunc,
- &func_unpadsize, &func_padsize, &funcidx_size,
- symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
- return -1; /* errno is set for us. */
-
- ctf_dprintf ("Function symtypetab: %i functions, max %i, unpadded size %i, "
- "%i bytes of pads, index size %i\n", (int) nfuncs, (int) maxfunc,
- (int) func_unpadsize, (int) func_padsize, (int) funcidx_size);
-
- /* If we are filtering symbols out, those symbols that the linker has not
- reported have now been removed from the ctf_objthash and ctf_funchash.
- Delete entries from the variable section that duplicate newly-added data
- symbols. There's no need to migrate new ones in, because the compiler
- always emits both a variable and a data symbol simultaneously, and
- filtering only happens at final link time. */
-
- if (filter_syms && symfp->ctf_dynsyms &&
- symtypetab_delete_nonstatic_vars (fp, symfp) < 0)
- return -1;
-
- /* It is worth indexing each section if it would save space to do so, due to
- reducing the number of pads sufficiently. A pad is the same size as a
- single index entry: but index sections compress relatively poorly compared
- to constant pads, so it takes a lot of contiguous padding to equal one
- index section entry. It would be nice to be able to *verify* whether we
- would save space after compression rather than guessing, but this seems
- difficult, since it would require complete reserialization. Regardless, if
- the linker has not reported any symbols (e.g. if this is not a final link
- but just an ld -r), we must emit things in indexed fashion just as the
- compiler does. */
-
- objt_size = objt_unpadsize;
- if (!(symflags & CTF_SYMTYPETAB_FORCE_INDEXED)
- && ((objt_padsize + objt_unpadsize) * CTF_INDEX_PAD_THRESHOLD
- > objt_padsize))
- {
- objt_size += objt_padsize;
- objtidx_size = 0;
- }
-
- func_size = func_unpadsize;
- if (!(symflags & CTF_SYMTYPETAB_FORCE_INDEXED)
- && ((func_padsize + func_unpadsize) * CTF_INDEX_PAD_THRESHOLD
- > func_padsize))
- {
- func_size += func_padsize;
- funcidx_size = 0;
- }
-
- /* Computing the number of entries in the CTF variable section is much
- simpler. */
-
- for (nvars = 0, dvd = ctf_list_next (&fp->ctf_dvdefs);
- dvd != NULL; dvd = ctf_list_next (dvd), nvars++);
-
- /* Compute the size of the CTF buffer we need, sans only the string table,
- then allocate a new buffer and memcpy the finished header to the start of
- the buffer. (We will adjust this later with strtab length info.) */
-
- hdr.cth_lbloff = hdr.cth_objtoff = 0;
- hdr.cth_funcoff = hdr.cth_objtoff + objt_size;
- hdr.cth_objtidxoff = hdr.cth_funcoff + func_size;
- hdr.cth_funcidxoff = hdr.cth_objtidxoff + objtidx_size;
- hdr.cth_varoff = hdr.cth_funcidxoff + funcidx_size;
- hdr.cth_typeoff = hdr.cth_varoff + (nvars * sizeof (ctf_varent_t));
- hdr.cth_stroff = hdr.cth_typeoff + type_size;
- hdr.cth_strlen = 0;
-
- buf_size = sizeof (ctf_header_t) + hdr.cth_stroff + hdr.cth_strlen;
-
- if ((buf = malloc (buf_size)) == NULL)
- return (ctf_set_errno (fp, EAGAIN));
-
- memcpy (buf, &hdr, sizeof (ctf_header_t));
- t = (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_objtoff;
-
- hdrp = (ctf_header_t *) buf;
- if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parname != NULL))
- ctf_str_add_ref (fp, fp->ctf_parname, &hdrp->cth_parname);
- if (fp->ctf_cuname != NULL)
- ctf_str_add_ref (fp, fp->ctf_cuname, &hdrp->cth_cuname);
-
- /* Sort the linker's symbols into name order if need be. */
-
- if ((objtidx_size != 0) || (funcidx_size != 0))
- {
- ctf_next_t *i = NULL;
- void *symname;
- const char **walk;
-
- if (filter_syms)
- {
- if (symfp->ctf_dynsyms)
- nsymtypes = ctf_dynhash_elements (symfp->ctf_dynsyms);
- else
- nsymtypes = 0;
- }
- else
- nsymtypes = ctf_dynhash_elements (fp->ctf_objthash)
- + ctf_dynhash_elements (fp->ctf_funchash);
-
- if ((sym_name_order = calloc (nsymtypes, sizeof (const char *))) == NULL)
- goto oom;
-
- walk = sym_name_order;
-
- if (filter_syms)
- {
- if (symfp->ctf_dynsyms)
- {
- while ((err = ctf_dynhash_next_sorted (symfp->ctf_dynsyms, &i,
- &symname, NULL,
- ctf_dynhash_sort_by_name,
- NULL)) == 0)
- *walk++ = (const char *) symname;
- if (err != ECTF_NEXT_END)
- goto symerr;
- }
- }
- else
- {
- ctf_hash_sort_f sort_fun = NULL;
-
- /* Since we partition the set of symbols back into objt and func,
- we can sort the two independently without harm. */
- if (sort_syms)
- sort_fun = ctf_dynhash_sort_by_name;
-
- while ((err = ctf_dynhash_next_sorted (fp->ctf_objthash, &i, &symname,
- NULL, sort_fun, NULL)) == 0)
- *walk++ = (const char *) symname;
- if (err != ECTF_NEXT_END)
- goto symerr;
-
- while ((err = ctf_dynhash_next_sorted (fp->ctf_funchash, &i, &symname,
- NULL, sort_fun, NULL)) == 0)
- *walk++ = (const char *) symname;
- if (err != ECTF_NEXT_END)
- goto symerr;
- }
- }
-
- /* Emit the object and function sections, and if necessary their indexes.
- Emission is done in symtab order if there is no index, and in index
- (name) order otherwise. */
-
- if ((objtidx_size == 0) && symfp && symfp->ctf_dynsymidx)
- {
- ctf_dprintf ("Emitting unindexed objt symtypetab\n");
- if (emit_symtypetab (fp, symfp, (uint32_t *) t, symfp->ctf_dynsymidx,
- NULL, symfp->ctf_dynsymmax + 1, maxobjt, objt_size,
- symflags | CTF_SYMTYPETAB_EMIT_PAD) < 0)
- goto err; /* errno is set for us. */
- }
- else
- {
- ctf_dprintf ("Emitting indexed objt symtypetab\n");
- if (emit_symtypetab (fp, symfp, (uint32_t *) t, NULL, sym_name_order,
- nsymtypes, maxobjt, objt_size, symflags) < 0)
- goto err; /* errno is set for us. */
- }
-
- t += objt_size;
-
- if ((funcidx_size == 0) && symfp && symfp->ctf_dynsymidx)
- {
- ctf_dprintf ("Emitting unindexed func symtypetab\n");
- if (emit_symtypetab (fp, symfp, (uint32_t *) t, symfp->ctf_dynsymidx,
- NULL, symfp->ctf_dynsymmax + 1, maxfunc,
- func_size, symflags | CTF_SYMTYPETAB_EMIT_FUNCTION
- | CTF_SYMTYPETAB_EMIT_PAD) < 0)
- goto err; /* errno is set for us. */
- }
- else
- {
- ctf_dprintf ("Emitting indexed func symtypetab\n");
- if (emit_symtypetab (fp, symfp, (uint32_t *) t, NULL, sym_name_order,
- nsymtypes, maxfunc, func_size,
- symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
- goto err; /* errno is set for us. */
- }
-
- t += func_size;
-
- if (objtidx_size > 0)
- if (emit_symtypetab_index (fp, symfp, (uint32_t *) t, sym_name_order,
- nsymtypes, objtidx_size, symflags) < 0)
- goto err;
-
- t += objtidx_size;
-
- if (funcidx_size > 0)
- if (emit_symtypetab_index (fp, symfp, (uint32_t *) t, sym_name_order,
- nsymtypes, funcidx_size,
- symflags | CTF_SYMTYPETAB_EMIT_FUNCTION) < 0)
- goto err;
-
- t += funcidx_size;
- free (sym_name_order);
- sym_name_order = NULL;
-
- /* Work over the variable list, translating everything into ctf_varent_t's and
- prepping the string table. */
-
- dvarents = (ctf_varent_t *) t;
- for (i = 0, dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
- dvd = ctf_list_next (dvd), i++)
- {
- ctf_varent_t *var = &dvarents[i];
-
- ctf_str_add_ref (fp, dvd->dvd_name, &var->ctv_name);
- var->ctv_type = (uint32_t) dvd->dvd_type;
- }
- assert (i == nvars);
-
- t += sizeof (ctf_varent_t) * nvars;
-
- assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_typeoff);
-
- /* We now take a final lap through the dynamic type definition list and copy
- the appropriate type records to the output buffer, noting down the
- strings as we go. */
-
- for (dtd = ctf_list_next (&fp->ctf_dtdefs);
- dtd != NULL; dtd = ctf_list_next (dtd))
- {
- uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
- uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
-
- ctf_array_t cta;
- uint32_t encoding;
- size_t len;
- ctf_stype_t *copied;
- const char *name;
-
- if (dtd->dtd_data.ctt_size != CTF_LSIZE_SENT)
- len = sizeof (ctf_stype_t);
- else
- len = sizeof (ctf_type_t);
-
- memcpy (t, &dtd->dtd_data, len);
- copied = (ctf_stype_t *) t; /* name is at the start: constant offset. */
- if (copied->ctt_name
- && (name = ctf_strraw (fp, copied->ctt_name)) != NULL)
- ctf_str_add_ref (fp, name, &copied->ctt_name);
- t += len;
-
- switch (kind)
- {
- case CTF_K_INTEGER:
- case CTF_K_FLOAT:
- if (kind == CTF_K_INTEGER)
- {
- encoding = CTF_INT_DATA (dtd->dtd_u.dtu_enc.cte_format,
- dtd->dtd_u.dtu_enc.cte_offset,
- dtd->dtd_u.dtu_enc.cte_bits);
- }
- else
- {
- encoding = CTF_FP_DATA (dtd->dtd_u.dtu_enc.cte_format,
- dtd->dtd_u.dtu_enc.cte_offset,
- dtd->dtd_u.dtu_enc.cte_bits);
- }
- memcpy (t, &encoding, sizeof (encoding));
- t += sizeof (encoding);
- break;
-
- case CTF_K_SLICE:
- memcpy (t, &dtd->dtd_u.dtu_slice, sizeof (struct ctf_slice));
- t += sizeof (struct ctf_slice);
- break;
-
- case CTF_K_ARRAY:
- cta.cta_contents = (uint32_t) dtd->dtd_u.dtu_arr.ctr_contents;
- cta.cta_index = (uint32_t) dtd->dtd_u.dtu_arr.ctr_index;
- cta.cta_nelems = dtd->dtd_u.dtu_arr.ctr_nelems;
- memcpy (t, &cta, sizeof (cta));
- t += sizeof (cta);
- break;
-
- case CTF_K_FUNCTION:
- {
- uint32_t *argv = (uint32_t *) (uintptr_t) t;
- uint32_t argc;
-
- for (argc = 0; argc < vlen; argc++)
- *argv++ = dtd->dtd_u.dtu_argv[argc];
-
- if (vlen & 1)
- *argv++ = 0; /* Pad to 4-byte boundary. */
-
- t = (unsigned char *) argv;
- break;
- }
-
- case CTF_K_STRUCT:
- case CTF_K_UNION:
- if (dtd->dtd_data.ctt_size < CTF_LSTRUCT_THRESH)
- t = ctf_copy_smembers (fp, dtd, t);
- else
- t = ctf_copy_lmembers (fp, dtd, t);
- break;
+ fp->ctf_dtoldid = 0;
+ fp->ctf_snapshots = 1;
+ fp->ctf_snapshot_lu = 0;
+ fp->ctf_flags |= LCTF_DIRTY;
- case CTF_K_ENUM:
- t = ctf_copy_emembers (fp, dtd, t);
- break;
- }
+ ctf_set_ctl_hashes (fp);
+ ctf_setmodel (fp, CTF_MODEL_NATIVE);
+ if (ctf_grow_ptrtab (fp) < 0)
+ {
+ ctf_set_open_errno (errp, ctf_errno (fp));
+ ctf_dict_close (fp);
+ return NULL;
}
- assert (t == (unsigned char *) buf + sizeof (ctf_header_t) + hdr.cth_stroff);
- /* Construct the final string table and fill out all the string refs with the
- final offsets. Then purge the refs list, because we're about to move this
- strtab onto the end of the buf, invalidating all the offsets. */
- strtab = ctf_str_write_strtab (fp);
- ctf_str_purge_refs (fp);
-
- if (strtab.cts_strs == NULL)
- goto oom;
-
- /* Now the string table is constructed, we can sort the buffer of
- ctf_varent_t's. */
- ctf_sort_var_arg_cb_t sort_var_arg = { fp, (ctf_strs_t *) &strtab };
- ctf_qsort_r (dvarents, nvars, sizeof (ctf_varent_t), ctf_sort_var,
- &sort_var_arg);
+ return fp;
- if ((newbuf = ctf_realloc (fp, buf, buf_size + strtab.cts_len)) == NULL)
- {
- free (strtab.cts_strs);
- goto oom;
- }
- buf = newbuf;
- memcpy (buf + buf_size, strtab.cts_strs, strtab.cts_len);
- hdrp = (ctf_header_t *) buf;
- hdrp->cth_strlen = strtab.cts_len;
- buf_size += hdrp->cth_strlen;
- free (strtab.cts_strs);
-
- /* Finally, we are ready to ctf_simple_open() the new dict. If this is
- successful, we then switch nfp and fp and free the old dict. */
-
- if ((nfp = ctf_simple_open_internal ((char *) buf, buf_size, NULL, 0,
- 0, NULL, 0, fp->ctf_syn_ext_strtab,
- 1, &err)) == NULL)
- {
- free (buf);
- return (ctf_set_errno (fp, err));
- }
+ err_dv:
+ ctf_dynhash_destroy (structs);
+ ctf_dynhash_destroy (unions);
+ ctf_dynhash_destroy (enums);
+ ctf_dynhash_destroy (names);
+ ctf_dynhash_destroy (objthash);
+ ctf_dynhash_destroy (funchash);
+ ctf_dynhash_destroy (dvhash);
+ err_dt:
+ ctf_dynhash_destroy (dthash);
+ err:
+ return NULL;
+}
- (void) ctf_setmodel (nfp, ctf_getmodel (fp));
-
- nfp->ctf_parent = fp->ctf_parent;
- nfp->ctf_parent_unreffed = fp->ctf_parent_unreffed;
- nfp->ctf_refcnt = fp->ctf_refcnt;
- nfp->ctf_flags |= fp->ctf_flags & ~LCTF_DIRTY;
- if (nfp->ctf_dynbase == NULL)
- nfp->ctf_dynbase = buf; /* Make sure buf is freed on close. */
- nfp->ctf_dthash = fp->ctf_dthash;
- nfp->ctf_dtdefs = fp->ctf_dtdefs;
- nfp->ctf_dvhash = fp->ctf_dvhash;
- nfp->ctf_dvdefs = fp->ctf_dvdefs;
- nfp->ctf_dtoldid = fp->ctf_dtoldid;
- nfp->ctf_add_processing = fp->ctf_add_processing;
- nfp->ctf_snapshots = fp->ctf_snapshots + 1;
- nfp->ctf_specific = fp->ctf_specific;
- nfp->ctf_nfuncidx = fp->ctf_nfuncidx;
- nfp->ctf_nobjtidx = fp->ctf_nobjtidx;
- nfp->ctf_objthash = fp->ctf_objthash;
- nfp->ctf_funchash = fp->ctf_funchash;
- nfp->ctf_dynsyms = fp->ctf_dynsyms;
- nfp->ctf_ptrtab = fp->ctf_ptrtab;
- nfp->ctf_pptrtab = fp->ctf_pptrtab;
- nfp->ctf_dynsymidx = fp->ctf_dynsymidx;
- nfp->ctf_dynsymmax = fp->ctf_dynsymmax;
- nfp->ctf_ptrtab_len = fp->ctf_ptrtab_len;
- nfp->ctf_pptrtab_len = fp->ctf_pptrtab_len;
- nfp->ctf_link_inputs = fp->ctf_link_inputs;
- nfp->ctf_link_outputs = fp->ctf_link_outputs;
- nfp->ctf_errs_warnings = fp->ctf_errs_warnings;
- nfp->ctf_funcidx_names = fp->ctf_funcidx_names;
- nfp->ctf_objtidx_names = fp->ctf_objtidx_names;
- nfp->ctf_funcidx_sxlate = fp->ctf_funcidx_sxlate;
- nfp->ctf_objtidx_sxlate = fp->ctf_objtidx_sxlate;
- nfp->ctf_str_prov_offset = fp->ctf_str_prov_offset;
- nfp->ctf_syn_ext_strtab = fp->ctf_syn_ext_strtab;
- nfp->ctf_pptrtab_typemax = fp->ctf_pptrtab_typemax;
- nfp->ctf_in_flight_dynsyms = fp->ctf_in_flight_dynsyms;
- nfp->ctf_link_in_cu_mapping = fp->ctf_link_in_cu_mapping;
- nfp->ctf_link_out_cu_mapping = fp->ctf_link_out_cu_mapping;
- nfp->ctf_link_type_mapping = fp->ctf_link_type_mapping;
- nfp->ctf_link_memb_name_changer = fp->ctf_link_memb_name_changer;
- nfp->ctf_link_memb_name_changer_arg = fp->ctf_link_memb_name_changer_arg;
- nfp->ctf_link_variable_filter = fp->ctf_link_variable_filter;
- nfp->ctf_link_variable_filter_arg = fp->ctf_link_variable_filter_arg;
- nfp->ctf_symsect_little_endian = fp->ctf_symsect_little_endian;
- nfp->ctf_link_flags = fp->ctf_link_flags;
- nfp->ctf_dedup_atoms = fp->ctf_dedup_atoms;
- nfp->ctf_dedup_atoms_alloc = fp->ctf_dedup_atoms_alloc;
- memcpy (&nfp->ctf_dedup, &fp->ctf_dedup, sizeof (fp->ctf_dedup));
-
- nfp->ctf_snapshot_lu = fp->ctf_snapshots;
-
- memcpy (&nfp->ctf_lookups, fp->ctf_lookups, sizeof (fp->ctf_lookups));
- nfp->ctf_structs = fp->ctf_structs;
- nfp->ctf_unions = fp->ctf_unions;
- nfp->ctf_enums = fp->ctf_enums;
- nfp->ctf_names = fp->ctf_names;
-
- fp->ctf_dthash = NULL;
- ctf_str_free_atoms (nfp);
- nfp->ctf_str_atoms = fp->ctf_str_atoms;
- nfp->ctf_prov_strtab = fp->ctf_prov_strtab;
- fp->ctf_str_atoms = NULL;
- fp->ctf_prov_strtab = NULL;
- memset (&fp->ctf_dtdefs, 0, sizeof (ctf_list_t));
- memset (&fp->ctf_errs_warnings, 0, sizeof (ctf_list_t));
- fp->ctf_add_processing = NULL;
- fp->ctf_ptrtab = NULL;
- fp->ctf_pptrtab = NULL;
- fp->ctf_funcidx_names = NULL;
- fp->ctf_objtidx_names = NULL;
- fp->ctf_funcidx_sxlate = NULL;
- fp->ctf_objtidx_sxlate = NULL;
- fp->ctf_objthash = NULL;
- fp->ctf_funchash = NULL;
- fp->ctf_dynsyms = NULL;
- fp->ctf_dynsymidx = NULL;
- fp->ctf_link_inputs = NULL;
- fp->ctf_link_outputs = NULL;
- fp->ctf_syn_ext_strtab = NULL;
- fp->ctf_link_in_cu_mapping = NULL;
- fp->ctf_link_out_cu_mapping = NULL;
- fp->ctf_link_type_mapping = NULL;
- fp->ctf_dedup_atoms = NULL;
- fp->ctf_dedup_atoms_alloc = NULL;
- fp->ctf_parent_unreffed = 1;
-
- fp->ctf_dvhash = NULL;
- memset (&fp->ctf_dvdefs, 0, sizeof (ctf_list_t));
- memset (fp->ctf_lookups, 0, sizeof (fp->ctf_lookups));
- memset (&fp->ctf_in_flight_dynsyms, 0, sizeof (fp->ctf_in_flight_dynsyms));
- memset (&fp->ctf_dedup, 0, sizeof (fp->ctf_dedup));
- fp->ctf_structs.ctn_writable = NULL;
- fp->ctf_unions.ctn_writable = NULL;
- fp->ctf_enums.ctn_writable = NULL;
- fp->ctf_names.ctn_writable = NULL;
-
- memcpy (&ofp, fp, sizeof (ctf_dict_t));
- memcpy (fp, nfp, sizeof (ctf_dict_t));
- memcpy (nfp, &ofp, sizeof (ctf_dict_t));
-
- nfp->ctf_refcnt = 1; /* Force nfp to be freed. */
- ctf_dict_close (nfp);
+/* Compatibility: just update the threshold for ctf_discard. */
+int
+ctf_update (ctf_dict_t *fp)
+{
+ if (!(fp->ctf_flags & LCTF_RDWR))
+ return (ctf_set_errno (fp, ECTF_RDONLY));
+ fp->ctf_dtoldid = fp->ctf_typemax;
return 0;
-
-symerr:
- ctf_err_warn (fp, 0, err, _("error serializing symtypetabs"));
- goto err;
-oom:
- free (buf);
- free (sym_name_order);
- return (ctf_set_errno (fp, EAGAIN));
-err:
- free (buf);
- free (sym_name_order);
- return -1; /* errno is set for us. */
}
ctf_names_t *
void
ctf_dtd_delete (ctf_dict_t *fp, ctf_dtdef_t *dtd)
{
- ctf_dmdef_t *dmd, *nmd;
int kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
+ size_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
int name_kind = kind;
const char *name;
{
case CTF_K_STRUCT:
case CTF_K_UNION:
- case CTF_K_ENUM:
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = nmd)
- {
- if (dmd->dmd_name != NULL)
- free (dmd->dmd_name);
- nmd = ctf_list_next (dmd);
- free (dmd);
- }
+ {
+ ctf_lmember_t *memb = (ctf_lmember_t *) dtd->dtd_vlen;
+ size_t i;
+
+ for (i = 0; i < vlen; i++)
+ ctf_str_remove_ref (fp, ctf_strraw (fp, memb[i].ctlm_name),
+ &memb[i].ctlm_name);
+ }
break;
- case CTF_K_FUNCTION:
- free (dtd->dtd_u.dtu_argv);
+ case CTF_K_ENUM:
+ {
+ ctf_enum_t *en = (ctf_enum_t *) dtd->dtd_vlen;
+ size_t i;
+
+ for (i = 0; i < vlen; i++)
+ ctf_str_remove_ref (fp, ctf_strraw (fp, en[i].cte_name),
+ &en[i].cte_name);
+ }
break;
case CTF_K_FORWARD:
name_kind = dtd->dtd_data.ctt_type;
break;
}
+ free (dtd->dtd_vlen);
+ dtd->dtd_vlen_alloc = 0;
if (dtd->dtd_data.ctt_name
&& (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL
return 0;
}
+/* Note: vlen is the amount of space *allocated* for the vlen. It may well not
+ be the amount of space used (yet): the space used is declared in per-kind
+ fashion in the dtd_data's info word. */
static ctf_id_t
ctf_add_generic (ctf_dict_t *fp, uint32_t flag, const char *name, int kind,
- ctf_dtdef_t **rp)
+ size_t vlen, ctf_dtdef_t **rp)
{
ctf_dtdef_t *dtd;
ctf_id_t type;
/* Make sure ptrtab always grows to be big enough for all types. */
if (ctf_grow_ptrtab (fp) < 0)
- return CTF_ERR; /* errno is set for us. */
+ return CTF_ERR; /* errno is set for us. */
- if ((dtd = malloc (sizeof (ctf_dtdef_t))) == NULL)
+ if ((dtd = calloc (1, sizeof (ctf_dtdef_t))) == NULL)
return (ctf_set_errno (fp, EAGAIN));
+ dtd->dtd_vlen_alloc = vlen;
+ if (vlen > 0)
+ {
+ if ((dtd->dtd_vlen = calloc (1, vlen)) == NULL)
+ goto oom;
+ }
+ else
+ dtd->dtd_vlen = NULL;
+
type = ++fp->ctf_typemax;
type = LCTF_INDEX_TO_TYPE (fp, type, (fp->ctf_flags & LCTF_CHILD));
- memset (dtd, 0, sizeof (ctf_dtdef_t));
- dtd->dtd_data.ctt_name = ctf_str_add_ref (fp, name, &dtd->dtd_data.ctt_name);
+ dtd->dtd_data.ctt_name = ctf_str_add_pending (fp, name,
+ &dtd->dtd_data.ctt_name);
dtd->dtd_type = type;
if (dtd->dtd_data.ctt_name == 0 && name != NULL && name[0] != '\0')
- {
- free (dtd);
- return (ctf_set_errno (fp, EAGAIN));
- }
+ goto oom;
if (ctf_dtd_insert (fp, dtd, flag, kind) < 0)
- {
- free (dtd);
- return CTF_ERR; /* errno is set for us. */
- }
+ goto err; /* errno is set for us. */
+
fp->ctf_flags |= LCTF_DIRTY;
*rp = dtd;
return type;
+
+ oom:
+ ctf_set_errno (fp, EAGAIN);
+ err:
+ free (dtd->dtd_vlen);
+ free (dtd);
+ return CTF_ERR;
}
/* When encoding integer sizes, we want to convert a byte count in the range
{
ctf_dtdef_t *dtd;
ctf_id_t type;
+ uint32_t encoding;
if (ep == NULL)
return (ctf_set_errno (fp, EINVAL));
if (name == NULL || name[0] == '\0')
return (ctf_set_errno (fp, ECTF_NONAME));
- if ((type = ctf_add_generic (fp, flag, name, kind, &dtd)) == CTF_ERR)
+ if (!ctf_assert (fp, kind == CTF_K_INTEGER || kind == CTF_K_FLOAT))
+ return -1; /* errno is set for us. */
+
+ if ((type = ctf_add_generic (fp, flag, name, kind, sizeof (uint32_t),
+ &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, CHAR_BIT)
/ CHAR_BIT);
- dtd->dtd_u.dtu_enc = *ep;
+ switch (kind)
+ {
+ case CTF_K_INTEGER:
+ encoding = CTF_INT_DATA (ep->cte_format, ep->cte_offset, ep->cte_bits);
+ break;
+ case CTF_K_FLOAT:
+ encoding = CTF_FP_DATA (ep->cte_format, ep->cte_offset, ep->cte_bits);
+ break;
+ }
+ memcpy (dtd->dtd_vlen, &encoding, sizeof (encoding));
return type;
}
if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
return CTF_ERR; /* errno is set for us. */
- if ((type = ctf_add_generic (fp, flag, NULL, kind, &dtd)) == CTF_ERR)
+ if ((type = ctf_add_generic (fp, flag, NULL, kind, 0, &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, 0);
const ctf_encoding_t *ep)
{
ctf_dtdef_t *dtd;
+ ctf_slice_t slice;
ctf_id_t resolved_ref = ref;
ctf_id_t type;
int kind;
&& (ref != 0))
return (ctf_set_errno (fp, ECTF_NOTINTFP));
- if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_SLICE, &dtd)) == CTF_ERR)
+ if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_SLICE,
+ sizeof (ctf_slice_t), &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
+ memset (&slice, 0, sizeof (ctf_slice_t));
+
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0);
dtd->dtd_data.ctt_size = clp2 (P2ROUNDUP (ep->cte_bits, CHAR_BIT)
/ CHAR_BIT);
- dtd->dtd_u.dtu_slice.cts_type = (uint32_t) ref;
- dtd->dtd_u.dtu_slice.cts_bits = ep->cte_bits;
- dtd->dtd_u.dtu_slice.cts_offset = ep->cte_offset;
+ slice.cts_type = (uint32_t) ref;
+ slice.cts_bits = ep->cte_bits;
+ slice.cts_offset = ep->cte_offset;
+ memcpy (dtd->dtd_vlen, &slice, sizeof (ctf_slice_t));
return type;
}
ctf_add_array (ctf_dict_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
{
ctf_dtdef_t *dtd;
+ ctf_array_t cta;
ctf_id_t type;
ctf_dict_t *tmp = fp;
return (ctf_set_errno (fp, ECTF_INCOMPLETE));
}
- if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY, &dtd)) == CTF_ERR)
+ if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY,
+ sizeof (ctf_array_t), &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
+ memset (&cta, 0, sizeof (ctf_array_t));
+
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
dtd->dtd_data.ctt_size = 0;
- dtd->dtd_u.dtu_arr = *arp;
+ cta.cta_contents = (uint32_t) arp->ctr_contents;
+ cta.cta_index = (uint32_t) arp->ctr_index;
+ cta.cta_nelems = arp->ctr_nelems;
+ memcpy (dtd->dtd_vlen, &cta, sizeof (ctf_array_t));
return type;
}
ctf_set_array (ctf_dict_t *fp, ctf_id_t type, const ctf_arinfo_t *arp)
{
ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
+ ctf_array_t *vlen;
if (!(fp->ctf_flags & LCTF_RDWR))
return (ctf_set_errno (fp, ECTF_RDONLY));
|| LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
return (ctf_set_errno (fp, ECTF_BADID));
+ vlen = (ctf_array_t *) dtd->dtd_vlen;
fp->ctf_flags |= LCTF_DIRTY;
- dtd->dtd_u.dtu_arr = *arp;
+ vlen->cta_contents = (uint32_t) arp->ctr_contents;
+ vlen->cta_index = (uint32_t) arp->ctr_index;
+ vlen->cta_nelems = arp->ctr_nelems;
return 0;
}
ctf_dtdef_t *dtd;
ctf_id_t type;
uint32_t vlen;
- uint32_t *vdat = NULL;
+ uint32_t *vdat;
ctf_dict_t *tmp = fp;
+ size_t initial_vlen;
size_t i;
if (!(fp->ctf_flags & LCTF_RDWR))
if (ctc->ctc_return != 0
&& ctf_lookup_by_id (&tmp, ctc->ctc_return) == NULL)
- return CTF_ERR; /* errno is set for us. */
+ return CTF_ERR; /* errno is set for us. */
if (vlen > CTF_MAX_VLEN)
return (ctf_set_errno (fp, EOVERFLOW));
- if (vlen != 0 && (vdat = malloc (sizeof (ctf_id_t) * vlen)) == NULL)
- return (ctf_set_errno (fp, EAGAIN));
+ /* One word extra allocated for padding for 4-byte alignment if need be.
+ Not reflected in vlen: we don't want to copy anything into it, and
+ it's in addition to (e.g.) the trailing 0 indicating varargs. */
+
+ initial_vlen = (sizeof (uint32_t) * (vlen + (vlen & 1)));
+ if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
+ initial_vlen, &dtd)) == CTF_ERR)
+ return CTF_ERR; /* errno is set for us. */
+
+ vdat = (uint32_t *) dtd->dtd_vlen;
for (i = 0; i < ctc->ctc_argc; i++)
{
tmp = fp;
if (argv[i] != 0 && ctf_lookup_by_id (&tmp, argv[i]) == NULL)
- {
- free (vdat);
- return CTF_ERR; /* errno is set for us. */
- }
+ return CTF_ERR; /* errno is set for us. */
vdat[i] = (uint32_t) argv[i];
}
- if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
- &dtd)) == CTF_ERR)
- {
- free (vdat);
- return CTF_ERR; /* errno is set for us. */
- }
-
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen);
dtd->dtd_data.ctt_type = (uint32_t) ctc->ctc_return;
if (ctc->ctc_flags & CTF_FUNC_VARARG)
vdat[vlen - 1] = 0; /* Add trailing zero to indicate varargs. */
- dtd->dtd_u.dtu_argv = vdat;
return type;
}
{
ctf_dtdef_t *dtd;
ctf_id_t type = 0;
+ size_t initial_vlen = sizeof (ctf_lmember_t) * INITIAL_VLEN;
/* Promote root-visible forwards to structs. */
if (name != NULL)
if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
dtd = ctf_dtd_lookup (fp, type);
else if ((type = ctf_add_generic (fp, flag, name, CTF_K_STRUCT,
- &dtd)) == CTF_ERR)
+ initial_vlen, &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
- dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_STRUCT, flag, 0);
-
- if (size > CTF_MAX_SIZE)
+ /* Forwards won't have any vlen yet. */
+ if (dtd->dtd_vlen_alloc == 0)
{
- dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
- dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
- dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
+ if ((dtd->dtd_vlen = calloc (1, initial_vlen)) == NULL)
+ return (ctf_set_errno (fp, ENOMEM));
+ dtd->dtd_vlen_alloc = initial_vlen;
}
- else
- dtd->dtd_data.ctt_size = (uint32_t) size;
+
+ dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_STRUCT, flag, 0);
+ dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
+ dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
+ dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
return type;
}
{
ctf_dtdef_t *dtd;
ctf_id_t type = 0;
+ size_t initial_vlen = sizeof (ctf_lmember_t) * INITIAL_VLEN;
/* Promote root-visible forwards to unions. */
if (name != NULL)
if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
dtd = ctf_dtd_lookup (fp, type);
else if ((type = ctf_add_generic (fp, flag, name, CTF_K_UNION,
- &dtd)) == CTF_ERR)
+ initial_vlen, &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us */
- dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_UNION, flag, 0);
-
- if (size > CTF_MAX_SIZE)
+ /* Forwards won't have any vlen yet. */
+ if (dtd->dtd_vlen_alloc == 0)
{
- dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
- dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
- dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
+ if ((dtd->dtd_vlen = calloc (1, initial_vlen)) == NULL)
+ return (ctf_set_errno (fp, ENOMEM));
+ dtd->dtd_vlen_alloc = initial_vlen;
}
- else
- dtd->dtd_data.ctt_size = (uint32_t) size;
+
+ dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_UNION, flag, 0);
+ dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
+ dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
+ dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
return type;
}
{
ctf_dtdef_t *dtd;
ctf_id_t type = 0;
+ size_t initial_vlen = sizeof (ctf_enum_t) * INITIAL_VLEN;
/* Promote root-visible forwards to enums. */
if (name != NULL)
if (type != 0 && ctf_type_kind (fp, type) == CTF_K_FORWARD)
dtd = ctf_dtd_lookup (fp, type);
else if ((type = ctf_add_generic (fp, flag, name, CTF_K_ENUM,
- &dtd)) == CTF_ERR)
+ initial_vlen, &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
+ /* Forwards won't have any vlen yet. */
+ if (dtd->dtd_vlen_alloc == 0)
+ {
+ if ((dtd->dtd_vlen = calloc (1, initial_vlen)) == NULL)
+ return (ctf_set_errno (fp, ENOMEM));
+ dtd->dtd_vlen_alloc = initial_vlen;
+ }
+
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0);
dtd->dtd_data.ctt_size = fp->ctf_dmodel->ctd_int;
if (type)
return type;
- if ((type = ctf_add_generic (fp, flag, name, kind, &dtd)) == CTF_ERR)
+ if ((type = ctf_add_generic (fp, flag, name, kind, 0, &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0);
return type;
}
+ctf_id_t
+ctf_add_unknown (ctf_dict_t *fp, uint32_t flag, const char *name)
+{
+ ctf_dtdef_t *dtd;
+ ctf_id_t type = 0;
+
+ /* If a type is already defined with this name, error (if not CTF_K_UNKNOWN)
+ or just return it. */
+
+ if (name != NULL && name[0] != '\0' && flag == CTF_ADD_ROOT
+ && (type = ctf_lookup_by_rawname (fp, CTF_K_UNKNOWN, name)))
+ {
+ if (ctf_type_kind (fp, type) == CTF_K_UNKNOWN)
+ return type;
+ else
+ {
+ ctf_err_warn (fp, 1, ECTF_CONFLICT,
+ _("ctf_add_unknown: cannot add unknown type "
+ "named %s: type of this name already defined"),
+ name ? name : _("(unnamed type)"));
+ return (ctf_set_errno (fp, ECTF_CONFLICT));
+ }
+ }
+
+ if ((type = ctf_add_generic (fp, flag, name, CTF_K_UNKNOWN, 0, &dtd)) == CTF_ERR)
+ return CTF_ERR; /* errno is set for us. */
+
+ dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_UNKNOWN, flag, 0);
+ dtd->dtd_data.ctt_type = 0;
+
+ return type;
+}
+
ctf_id_t
ctf_add_typedef (ctf_dict_t *fp, uint32_t flag, const char *name,
ctf_id_t ref)
if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
return CTF_ERR; /* errno is set for us. */
- if ((type = ctf_add_generic (fp, flag, name, CTF_K_TYPEDEF,
+ if ((type = ctf_add_generic (fp, flag, name, CTF_K_TYPEDEF, 0,
&dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
int value)
{
ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, enid);
- ctf_dmdef_t *dmd;
+ unsigned char *old_vlen;
+ ctf_enum_t *en;
+ size_t i;
uint32_t kind, vlen, root;
- char *s;
if (name == NULL)
return (ctf_set_errno (fp, EINVAL));
if (vlen == CTF_MAX_VLEN)
return (ctf_set_errno (fp, ECTF_DTFULL));
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
+ old_vlen = dtd->dtd_vlen;
+ if (ctf_grow_vlen (fp, dtd, sizeof (ctf_enum_t) * (vlen + 1)) < 0)
+ return -1; /* errno is set for us. */
+ en = (ctf_enum_t *) dtd->dtd_vlen;
+
+ if (dtd->dtd_vlen != old_vlen)
{
- if (strcmp (dmd->dmd_name, name) == 0)
- return (ctf_set_errno (fp, ECTF_DUPLICATE));
- }
+ ptrdiff_t move = (signed char *) dtd->dtd_vlen - (signed char *) old_vlen;
- if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
- return (ctf_set_errno (fp, EAGAIN));
+ /* Remove pending refs in the old vlen region and reapply them. */
- if ((s = strdup (name)) == NULL)
- {
- free (dmd);
- return (ctf_set_errno (fp, EAGAIN));
+ for (i = 0; i < vlen; i++)
+ ctf_str_move_pending (fp, &en[i].cte_name, move);
}
- dmd->dmd_name = s;
- dmd->dmd_type = CTF_ERR;
- dmd->dmd_offset = 0;
- dmd->dmd_value = value;
+ for (i = 0; i < vlen; i++)
+ if (strcmp (ctf_strptr (fp, en[i].cte_name), name) == 0)
+ return (ctf_set_errno (fp, ECTF_DUPLICATE));
+
+ en[i].cte_name = ctf_str_add_pending (fp, name, &en[i].cte_name);
+ en[i].cte_value = value;
+
+ if (en[i].cte_name == 0 && name != NULL && name[0] != '\0')
+ return -1; /* errno is set for us. */
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
- ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
fp->ctf_flags |= LCTF_DIRTY;
ctf_id_t type, unsigned long bit_offset)
{
ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, souid);
- ctf_dmdef_t *dmd;
ssize_t msize, malign, ssize;
uint32_t kind, vlen, root;
- char *s = NULL;
+ size_t i;
int is_incomplete = 0;
+ unsigned char *old_vlen;
+ ctf_lmember_t *memb;
if (!(fp->ctf_flags & LCTF_RDWR))
return (ctf_set_errno (fp, ECTF_RDONLY));
if (vlen == CTF_MAX_VLEN)
return (ctf_set_errno (fp, ECTF_DTFULL));
+ old_vlen = dtd->dtd_vlen;
+ if (ctf_grow_vlen (fp, dtd, sizeof (ctf_lmember_t) * (vlen + 1)) < 0)
+ return -1; /* errno is set for us. */
+ memb = (ctf_lmember_t *) dtd->dtd_vlen;
+
+ if (dtd->dtd_vlen != old_vlen)
+ {
+ ptrdiff_t move = (signed char *) dtd->dtd_vlen - (signed char *) old_vlen;
+
+ /* Remove pending refs in the old vlen region and reapply them. */
+
+ for (i = 0; i < vlen; i++)
+ ctf_str_move_pending (fp, &memb[i].ctlm_name, move);
+ }
+
if (name != NULL)
{
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
- {
- if (dmd->dmd_name != NULL && strcmp (dmd->dmd_name, name) == 0)
- return (ctf_set_errno (fp, ECTF_DUPLICATE));
- }
+ for (i = 0; i < vlen; i++)
+ if (strcmp (ctf_strptr (fp, memb[i].ctlm_name), name) == 0)
+ return (ctf_set_errno (fp, ECTF_DUPLICATE));
}
if ((msize = ctf_type_size (fp, type)) < 0 ||
return -1; /* errno is set for us. */
}
- if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
- return (ctf_set_errno (fp, EAGAIN));
-
- if (name != NULL && (s = strdup (name)) == NULL)
- {
- free (dmd);
- return (ctf_set_errno (fp, EAGAIN));
- }
-
- dmd->dmd_name = s;
- dmd->dmd_type = type;
- dmd->dmd_value = -1;
+ memb[vlen].ctlm_name = ctf_str_add_pending (fp, name, &memb[vlen].ctlm_name);
+ memb[vlen].ctlm_type = type;
+ if (memb[vlen].ctlm_name == 0 && name != NULL && name[0] != '\0')
+ return -1; /* errno is set for us. */
if (kind == CTF_K_STRUCT && vlen != 0)
{
{
/* Natural alignment. */
- ctf_dmdef_t *lmd = ctf_list_prev (&dtd->dtd_u.dtu_members);
- ctf_id_t ltype = ctf_type_resolve (fp, lmd->dmd_type);
- size_t off = lmd->dmd_offset;
+ ctf_id_t ltype = ctf_type_resolve (fp, memb[vlen - 1].ctlm_type);
+ size_t off = CTF_LMEM_OFFSET(&memb[vlen - 1]);
ctf_encoding_t linfo;
ssize_t lsize;
cannot insert right after such a member without explicit offset
specification, because its alignment and size is not known. */
if (ltype == CTF_ERR)
- {
- free (dmd);
- return -1; /* errno is set for us. */
- }
+ return -1; /* errno is set for us. */
if (is_incomplete)
{
off += lsize * CHAR_BIT;
else if (lsize == -1 && ctf_errno (fp) == ECTF_INCOMPLETE)
{
+ const char *lname = ctf_strraw (fp, memb[vlen - 1].ctlm_name);
+
ctf_err_warn (fp, 1, ECTF_INCOMPLETE,
_("ctf_add_member_offset: cannot add member %s of "
"type %lx to struct %lx without specifying "
"explicit offset after member %s of type %lx, "
"which is an incomplete type\n"),
name ? name : _("(unnamed member)"), type, souid,
- lmd->dmd_name ? lmd->dmd_name
- : _("(unnamed member)"), ltype);
+ lname ? lname : _("(unnamed member)"), ltype);
return -1; /* errno is set for us. */
}
off = roundup (off, CHAR_BIT) / CHAR_BIT;
off = roundup (off, MAX (malign, 1));
- dmd->dmd_offset = off * CHAR_BIT;
+ memb[vlen].ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (off * CHAR_BIT);
+ memb[vlen].ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (off * CHAR_BIT);
ssize = off + msize;
}
else
{
/* Specified offset in bits. */
- dmd->dmd_offset = bit_offset;
+ memb[vlen].ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (bit_offset);
+ memb[vlen].ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (bit_offset);
ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
ssize = MAX (ssize, ((signed) bit_offset / CHAR_BIT) + msize);
}
}
else
{
- dmd->dmd_offset = 0;
+ memb[vlen].ctlm_offsethi = 0;
+ memb[vlen].ctlm_offsetlo = 0;
ssize = ctf_get_ctt_size (fp, &dtd->dtd_data, NULL, NULL);
ssize = MAX (ssize, msize);
}
- if ((size_t) ssize > CTF_MAX_SIZE)
- {
- dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
- dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (ssize);
- dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (ssize);
- }
- else
- dtd->dtd_data.ctt_size = (uint32_t) ssize;
-
+ dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
+ dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (ssize);
+ dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (ssize);
dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, root, vlen + 1);
- ctf_list_append (&dtd->dtd_u.dtu_members, dmd);
fp->ctf_flags |= LCTF_DIRTY;
return 0;
return 0;
}
-static int
-membadd (const char *name, ctf_id_t type, unsigned long offset, void *arg)
-{
- ctf_bundle_t *ctb = arg;
- ctf_dmdef_t *dmd;
- char *s = NULL;
-
- if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
- return (ctf_set_errno (ctb->ctb_dict, EAGAIN));
-
- /* Unnamed members in non-dynamic dicts have a name of "", while dynamic dicts
- use NULL. Adapt. */
-
- if (name[0] == 0)
- name = NULL;
-
- if (name != NULL && (s = strdup (name)) == NULL)
- {
- free (dmd);
- return (ctf_set_errno (ctb->ctb_dict, EAGAIN));
- }
-
- /* For now, dmd_type is copied as the src_fp's type; it is reset to an
- equivalent dst_fp type by a final loop in ctf_add_type(), below. */
- dmd->dmd_name = s;
- dmd->dmd_type = type;
- dmd->dmd_offset = offset;
- dmd->dmd_value = -1;
-
- ctf_list_append (&ctb->ctb_dtd->dtd_u.dtu_members, dmd);
-
- ctb->ctb_dict->ctf_flags |= LCTF_DIRTY;
- return 0;
-}
-
/* Record the correspondence between a source and ctf_add_type()-added
destination type: both types are translated into parent type IDs if need be,
so they relate to the actual dictionary they are in. Outside controlled
case CTF_K_STRUCT:
case CTF_K_UNION:
{
- ctf_dmdef_t *dmd;
- int errs = 0;
- size_t size;
- ssize_t ssize;
- ctf_dtdef_t *dtd;
+ ctf_next_t *i = NULL;
+ ssize_t offset;
+ const char *membname;
+ ctf_id_t src_membtype;
/* Technically to match a struct or union we need to check both
ways (src members vs. dst, dst members vs. src) but we make
break;
}
- /* Unlike the other cases, copying structs and unions is done
- manually so as to avoid repeated lookups in ctf_add_member
- and to ensure the exact same member offsets as in src_type. */
-
- dst_type = ctf_add_generic (dst_fp, flag, name, kind, &dtd);
+ dst_type = ctf_add_struct_sized (dst_fp, flag, name,
+ ctf_type_size (src_fp, src_type));
if (dst_type == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
- dst.ctb_type = dst_type;
- dst.ctb_dtd = dtd;
-
/* Pre-emptively add this struct to the type mapping so that
structures that refer to themselves work. */
ctf_add_type_mapping (src_fp, src_type, dst_fp, dst_type);
- if (ctf_member_iter (src_fp, src_type, membadd, &dst) != 0)
- errs++; /* Increment errs and fail at bottom of case. */
-
- if ((ssize = ctf_type_size (src_fp, src_type)) < 0)
- return CTF_ERR; /* errno is set for us. */
-
- size = (size_t) ssize;
- if (size > CTF_MAX_SIZE)
- {
- dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
- dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size);
- dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size);
- }
- else
- dtd->dtd_data.ctt_size = (uint32_t) size;
-
- dtd->dtd_data.ctt_info = CTF_TYPE_INFO (kind, flag, vlen);
-
- /* Make a final pass through the members changing each dmd_type (a
- src_fp type) to an equivalent type in dst_fp. We pass through all
- members, leaving any that fail set to CTF_ERR, unless they fail
- because they are marking a member of type not representable in this
- version of CTF, in which case we just want to silently omit them:
- no consumer can do anything with them anyway. */
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
+ while ((offset = ctf_member_next (src_fp, src_type, &i, &membname,
+ &src_membtype, 0)) >= 0)
{
ctf_dict_t *dst = dst_fp;
- ctf_id_t memb_type;
+ ctf_id_t dst_membtype = ctf_type_mapping (src_fp, src_membtype, &dst);
- memb_type = ctf_type_mapping (src_fp, dmd->dmd_type, &dst);
- if (memb_type == 0)
+ if (dst_membtype == 0)
{
- if ((dmd->dmd_type =
- ctf_add_type_internal (dst_fp, src_fp, dmd->dmd_type,
- proc_tracking_fp)) == CTF_ERR)
+ dst_membtype = ctf_add_type_internal (dst_fp, src_fp,
+ src_membtype,
+ proc_tracking_fp);
+ if (dst_membtype == CTF_ERR)
{
if (ctf_errno (dst_fp) != ECTF_NONREPRESENTABLE)
- errs++;
+ {
+ ctf_next_destroy (i);
+ break;
+ }
}
}
- else
- dmd->dmd_type = memb_type;
- }
- if (errs)
+ if (ctf_add_member_offset (dst_fp, dst_type, membname,
+ dst_membtype, offset) < 0)
+ {
+ ctf_next_destroy (i);
+ break;
+ }
+ }
+ if (ctf_errno (src_fp) != ECTF_NEXT_END)
return CTF_ERR; /* errno is set for us. */
break;
}
return id;
}
-
-/* Write the compressed CTF data stream to the specified gzFile descriptor. */
-int
-ctf_gzwrite (ctf_dict_t *fp, gzFile fd)
-{
- const unsigned char *buf;
- ssize_t resid;
- ssize_t len;
-
- resid = sizeof (ctf_header_t);
- buf = (unsigned char *) fp->ctf_header;
- while (resid != 0)
- {
- if ((len = gzwrite (fd, buf, resid)) <= 0)
- return (ctf_set_errno (fp, errno));
- resid -= len;
- buf += len;
- }
-
- resid = fp->ctf_size;
- buf = fp->ctf_buf;
- while (resid != 0)
- {
- if ((len = gzwrite (fd, buf, resid)) <= 0)
- return (ctf_set_errno (fp, errno));
- resid -= len;
- buf += len;
- }
-
- 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. */
-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;
- ssize_t header_len = sizeof (ctf_header_t);
- ssize_t compress_len;
- int rc;
-
- if (ctf_serialize (fp) < 0)
- return NULL; /* errno is set for us. */
-
- compress_len = compressBound (fp->ctf_size);
- if (fp->ctf_size < threshold)
- compress_len = fp->ctf_size;
- if ((buf = malloc (compress_len
- + sizeof (struct ctf_header))) == NULL)
- {
- ctf_set_errno (fp, ENOMEM);
- ctf_err_warn (fp, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
- (unsigned long) (compress_len + sizeof (struct ctf_header)));
- return NULL;
- }
-
- hp = (ctf_header_t *) buf;
- memcpy (hp, fp->ctf_header, header_len);
- bp = buf + sizeof (struct ctf_header);
- *size = sizeof (struct ctf_header);
-
- if (fp->ctf_size < threshold)
- {
- hp->cth_flags &= ~CTF_F_COMPRESS;
- memcpy (bp, fp->ctf_buf, 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)
- {
- ctf_set_errno (fp, ECTF_COMPRESS);
- ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
- free (buf);
- return NULL;
- }
- *size += compress_len;
- }
- return buf;
-}
-
-/* Write the uncompressed CTF data stream to the specified file descriptor. */
-int
-ctf_write (ctf_dict_t *fp, int fd)
-{
- const unsigned char *buf;
- ssize_t resid;
- ssize_t len;
-
- if (ctf_serialize (fp) < 0)
- return -1; /* errno is set for us. */
-
- resid = sizeof (ctf_header_t);
- buf = (unsigned char *) fp->ctf_header;
- while (resid != 0)
- {
- if ((len = write (fd, buf, resid)) <= 0)
- {
- ctf_err_warn (fp, 0, errno, _("ctf_write: error writing header"));
- return (ctf_set_errno (fp, errno));
- }
- resid -= len;
- buf += len;
- }
-
- resid = fp->ctf_size;
- buf = fp->ctf_buf;
- while (resid != 0)
- {
- if ((len = write (fd, buf, resid)) <= 0)
- {
- ctf_err_warn (fp, 0, errno, _("ctf_write: error writing"));
- return (ctf_set_errno (fp, errno));
- }
- resid -= len;
- buf += len;
- }
-
- return 0;
-}
projects / thirdparty / binutils-gdb.git / blobdiff