diff options
Diffstat (limited to 'libctf')
| -rw-r--r-- | libctf/ChangeLog | 24 | ||||
| -rw-r--r-- | libctf/Makefile.am | 4 | ||||
| -rw-r--r-- | libctf/Makefile.in | 44 | ||||
| -rw-r--r-- | libctf/ctf-create.c | 1311 | ||||
| -rw-r--r-- | libctf/ctf-serialize.c | 1332 |
5 files changed, 1391 insertions, 1324 deletions
diff --git a/libctf/ChangeLog b/libctf/ChangeLog index cf78d8c..bd2563d 100644 --- a/libctf/ChangeLog +++ b/libctf/ChangeLog @@ -1,5 +1,29 @@ 2021-03-18 Nick Alcock <nick.alcock@oracle.com> + * ctf-create.c (symtypetab_delete_nonstatic_vars): Move + into ctf-serialize.c. + (ctf_symtab_skippable): Likewise. + (CTF_SYMTYPETAB_EMIT_FUNCTION): Likewise. + (CTF_SYMTYPETAB_EMIT_PAD): Likewise. + (CTF_SYMTYPETAB_FORCE_INDEXED): Likewise. + (symtypetab_density): Likewise. + (emit_symtypetab): Likewise. + (emit_symtypetab_index): Likewise. + (ctf_copy_smembers): Likewise. + (ctf_copy_lmembers): Likewise. + (ctf_copy_emembers): Likewise. + (ctf_sort_var): Likewise. + (ctf_serialize): Likewise. + (ctf_gzwrite): Likewise. + (ctf_compress_write): Likewise. + (ctf_write_mem): Likewise. + (ctf_write): Likewise. + * ctf-serialize.c: New file. + * Makefile.am (libctf_nobfd_la_SOURCES): Add it. + * Makefile.in: Regenerate. + +2021-03-18 Nick Alcock <nick.alcock@oracle.com> + * ctf-link.c (ctf_link_lazy_open): Move up in the file, to near ctf_link_add_ctf. * ctf-lookup.c (ctf_lookup_symbol_idx): Repair tabdamage. diff --git a/libctf/Makefile.am b/libctf/Makefile.am index 03fd6cc..e586d25 100644 --- a/libctf/Makefile.am +++ b/libctf/Makefile.am @@ -46,8 +46,8 @@ libctf_nobfd_la_LDFLAGS = -version-info 0:0:0 @SHARED_LDFLAGS@ @VERSION_FLAGS@ libctf_nobfd_la_CPPFLAGS = $(AM_CPPFLAGS) -DNOBFD=1 libctf_nobfd_la_SOURCES = ctf-archive.c ctf-dump.c ctf-create.c ctf-decl.c ctf-error.c \ ctf-hash.c ctf-labels.c ctf-dedup.c ctf-link.c ctf-lookup.c \ - ctf-open.c ctf-sha1.c ctf-string.c ctf-subr.c ctf-types.c \ - ctf-util.c + ctf-open.c ctf-serialize.c ctf-sha1.c ctf-string.c ctf-subr.c \ + ctf-types.c ctf-util.c if NEED_CTF_QSORT_R libctf_nobfd_la_SOURCES += ctf-qsort_r.c endif diff --git a/libctf/Makefile.in b/libctf/Makefile.in index e3ee895..5cfa100 100644 --- a/libctf/Makefile.in +++ b/libctf/Makefile.in @@ -168,8 +168,9 @@ am__DEPENDENCIES_1 = libctf_nobfd_la_DEPENDENCIES = $(am__DEPENDENCIES_1) am__libctf_nobfd_la_SOURCES_DIST = ctf-archive.c ctf-dump.c \ ctf-create.c ctf-decl.c ctf-error.c ctf-hash.c ctf-labels.c \ - ctf-dedup.c ctf-link.c ctf-lookup.c ctf-open.c ctf-sha1.c \ - ctf-string.c ctf-subr.c ctf-types.c ctf-util.c ctf-qsort_r.c + ctf-dedup.c ctf-link.c ctf-lookup.c ctf-open.c ctf-serialize.c \ + ctf-sha1.c ctf-string.c ctf-subr.c ctf-types.c ctf-util.c \ + ctf-qsort_r.c @NEED_CTF_QSORT_R_TRUE@am__objects_1 = libctf_nobfd_la-ctf-qsort_r.lo am_libctf_nobfd_la_OBJECTS = libctf_nobfd_la-ctf-archive.lo \ libctf_nobfd_la-ctf-dump.lo libctf_nobfd_la-ctf-create.lo \ @@ -177,9 +178,10 @@ am_libctf_nobfd_la_OBJECTS = libctf_nobfd_la-ctf-archive.lo \ libctf_nobfd_la-ctf-hash.lo libctf_nobfd_la-ctf-labels.lo \ libctf_nobfd_la-ctf-dedup.lo libctf_nobfd_la-ctf-link.lo \ libctf_nobfd_la-ctf-lookup.lo libctf_nobfd_la-ctf-open.lo \ - libctf_nobfd_la-ctf-sha1.lo libctf_nobfd_la-ctf-string.lo \ - libctf_nobfd_la-ctf-subr.lo libctf_nobfd_la-ctf-types.lo \ - libctf_nobfd_la-ctf-util.lo $(am__objects_1) + libctf_nobfd_la-ctf-serialize.lo libctf_nobfd_la-ctf-sha1.lo \ + libctf_nobfd_la-ctf-string.lo libctf_nobfd_la-ctf-subr.lo \ + libctf_nobfd_la-ctf-types.lo libctf_nobfd_la-ctf-util.lo \ + $(am__objects_1) libctf_nobfd_la_OBJECTS = $(am_libctf_nobfd_la_OBJECTS) AM_V_lt = $(am__v_lt_@AM_V@) am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) @@ -195,17 +197,19 @@ am__DEPENDENCIES_2 = $(am__DEPENDENCIES_1) libctf_la_DEPENDENCIES = ../bfd/libbfd.la $(am__DEPENDENCIES_2) am__libctf_la_SOURCES_DIST = ctf-archive.c ctf-dump.c ctf-create.c \ ctf-decl.c ctf-error.c ctf-hash.c ctf-labels.c ctf-dedup.c \ - ctf-link.c ctf-lookup.c ctf-open.c ctf-sha1.c ctf-string.c \ - ctf-subr.c ctf-types.c ctf-util.c ctf-qsort_r.c ctf-open-bfd.c + ctf-link.c ctf-lookup.c ctf-open.c ctf-serialize.c ctf-sha1.c \ + ctf-string.c ctf-subr.c ctf-types.c ctf-util.c ctf-qsort_r.c \ + ctf-open-bfd.c @NEED_CTF_QSORT_R_TRUE@am__objects_2 = libctf_la-ctf-qsort_r.lo am__objects_3 = libctf_la-ctf-archive.lo libctf_la-ctf-dump.lo \ libctf_la-ctf-create.lo libctf_la-ctf-decl.lo \ libctf_la-ctf-error.lo libctf_la-ctf-hash.lo \ libctf_la-ctf-labels.lo libctf_la-ctf-dedup.lo \ libctf_la-ctf-link.lo libctf_la-ctf-lookup.lo \ - libctf_la-ctf-open.lo libctf_la-ctf-sha1.lo \ - libctf_la-ctf-string.lo libctf_la-ctf-subr.lo \ - libctf_la-ctf-types.lo libctf_la-ctf-util.lo $(am__objects_2) + libctf_la-ctf-open.lo libctf_la-ctf-serialize.lo \ + libctf_la-ctf-sha1.lo libctf_la-ctf-string.lo \ + libctf_la-ctf-subr.lo libctf_la-ctf-types.lo \ + libctf_la-ctf-util.lo $(am__objects_2) am_libctf_la_OBJECTS = $(am__objects_3) libctf_la-ctf-open-bfd.lo libctf_la_OBJECTS = $(am_libctf_la_OBJECTS) libctf_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ @@ -470,8 +474,8 @@ libctf_nobfd_la_LDFLAGS = -version-info 0:0:0 @SHARED_LDFLAGS@ @VERSION_FLAGS@ libctf_nobfd_la_CPPFLAGS = $(AM_CPPFLAGS) -DNOBFD=1 libctf_nobfd_la_SOURCES = ctf-archive.c ctf-dump.c ctf-create.c \ ctf-decl.c ctf-error.c ctf-hash.c ctf-labels.c ctf-dedup.c \ - ctf-link.c ctf-lookup.c ctf-open.c ctf-sha1.c ctf-string.c \ - ctf-subr.c ctf-types.c ctf-util.c $(am__append_1) + ctf-link.c ctf-lookup.c ctf-open.c ctf-serialize.c ctf-sha1.c \ + ctf-string.c ctf-subr.c ctf-types.c ctf-util.c $(am__append_1) libctf_la_LIBADD = ../bfd/libbfd.la $(libctf_nobfd_la_LIBADD) libctf_la_CPPFLAGS = $(AM_CPPFLAGS) -DNOBFD=0 libctf_la_LDFLAGS = $(libctf_nobfd_la_LDFLAGS) @@ -623,6 +627,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_la-ctf-open-bfd.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_la-ctf-open.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_la-ctf-qsort_r.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_la-ctf-serialize.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_la-ctf-sha1.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_la-ctf-string.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_la-ctf-subr.Plo@am__quote@ @@ -640,6 +645,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_nobfd_la-ctf-lookup.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_nobfd_la-ctf-open.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_nobfd_la-ctf-qsort_r.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_nobfd_la-ctf-serialize.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_nobfd_la-ctf-sha1.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_nobfd_la-ctf-string.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libctf_nobfd_la-ctf-subr.Plo@am__quote@ @@ -744,6 +750,13 @@ libctf_nobfd_la-ctf-open.lo: ctf-open.c @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_nobfd_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libctf_nobfd_la-ctf-open.lo `test -f 'ctf-open.c' || echo '$(srcdir)/'`ctf-open.c +libctf_nobfd_la-ctf-serialize.lo: ctf-serialize.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_nobfd_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libctf_nobfd_la-ctf-serialize.lo -MD -MP -MF $(DEPDIR)/libctf_nobfd_la-ctf-serialize.Tpo -c -o libctf_nobfd_la-ctf-serialize.lo `test -f 'ctf-serialize.c' || echo '$(srcdir)/'`ctf-serialize.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libctf_nobfd_la-ctf-serialize.Tpo $(DEPDIR)/libctf_nobfd_la-ctf-serialize.Plo +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='ctf-serialize.c' object='libctf_nobfd_la-ctf-serialize.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_nobfd_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libctf_nobfd_la-ctf-serialize.lo `test -f 'ctf-serialize.c' || echo '$(srcdir)/'`ctf-serialize.c + libctf_nobfd_la-ctf-sha1.lo: ctf-sha1.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_nobfd_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libctf_nobfd_la-ctf-sha1.lo -MD -MP -MF $(DEPDIR)/libctf_nobfd_la-ctf-sha1.Tpo -c -o libctf_nobfd_la-ctf-sha1.lo `test -f 'ctf-sha1.c' || echo '$(srcdir)/'`ctf-sha1.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libctf_nobfd_la-ctf-sha1.Tpo $(DEPDIR)/libctf_nobfd_la-ctf-sha1.Plo @@ -863,6 +876,13 @@ libctf_la-ctf-open.lo: ctf-open.c @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libctf_la-ctf-open.lo `test -f 'ctf-open.c' || echo '$(srcdir)/'`ctf-open.c +libctf_la-ctf-serialize.lo: ctf-serialize.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libctf_la-ctf-serialize.lo -MD -MP -MF $(DEPDIR)/libctf_la-ctf-serialize.Tpo -c -o libctf_la-ctf-serialize.lo `test -f 'ctf-serialize.c' || echo '$(srcdir)/'`ctf-serialize.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libctf_la-ctf-serialize.Tpo $(DEPDIR)/libctf_la-ctf-serialize.Plo +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='ctf-serialize.c' object='libctf_la-ctf-serialize.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libctf_la-ctf-serialize.lo `test -f 'ctf-serialize.c' || echo '$(srcdir)/'`ctf-serialize.c + libctf_la-ctf-sha1.lo: ctf-sha1.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libctf_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libctf_la-ctf-sha1.lo -MD -MP -MF $(DEPDIR)/libctf_la-ctf-sha1.Tpo -c -o libctf_la-ctf-sha1.lo `test -f 'ctf-sha1.c' || echo '$(srcdir)/'`ctf-sha1.c @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libctf_la-ctf-sha1.Tpo $(DEPDIR)/libctf_la-ctf-sha1.Plo diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c index 3f2c5da..b2e0862 100644 --- a/libctf/ctf-create.c +++ b/libctf/ctf-create.c @@ -1,4 +1,4 @@ -/* CTF file creation. +/* CTF dict creation. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of libctf. @@ -19,13 +19,8 @@ #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 @@ -167,497 +162,6 @@ ctf_create (int *errp) 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 %s (%x) added to CTF as a " - "function but is of type %x. " - "The symbol type lookup tables " - "are probably corrupted"), - sym->st_name, 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 %s (%x) added to CTF as a " - "data object but is of type %x. " - "The symbol type lookup tables " - "are probably corrupted"), - sym->st_name, 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) @@ -669,627 +173,6 @@ ctf_update (ctf_dict_t *fp) 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; - - case CTF_K_ENUM: - t = ctf_copy_emembers (fp, dtd, t); - break; - } - } - 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); - - 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)); - } - - (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); - - 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 * ctf_name_table (ctf_dict_t *fp, int kind) { @@ -3038,195 +1921,3 @@ ctf_add_type (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type) 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; -} diff --git a/libctf/ctf-serialize.c b/libctf/ctf-serialize.c new file mode 100644 index 0000000..e0bd98c --- /dev/null +++ b/libctf/ctf-serialize.c @@ -0,0 +1,1332 @@ +/* CTF dict creation. + Copyright (C) 2019-2021 Free Software Foundation, Inc. + + This file is part of libctf. + + libctf 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 3, 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; see the file COPYING. If not see + <http://www.gnu.org/licenses/>. */ + +#include <ctf-impl.h> +#include <assert.h> +#include <string.h> +#include <unistd.h> +#include <zlib.h> + +#include <elf.h> +#include "elf-bfd.h" + +/* 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 %s (%x) added to CTF as a " + "function but is of type %x. " + "The symbol type lookup tables " + "are probably corrupted"), + sym->st_name, 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 %s (%x) added to CTF as a " + "data object but is of type %x. " + "The symbol type lookup tables " + "are probably corrupted"), + sym->st_name, 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))); +} + +/* 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; + + case CTF_K_ENUM: + t = ctf_copy_emembers (fp, dtd, t); + break; + } + } + 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); + + 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)); + } + + (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); + + 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. */ +} + + +/* 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; +} |