diff options
Diffstat (limited to 'libctf/ctf-dedup.c')
| -rw-r--r-- | libctf/ctf-dedup.c | 174 |
1 files changed, 87 insertions, 87 deletions
diff --git a/libctf/ctf-dedup.c b/libctf/ctf-dedup.c index b58b815..3e95af0 100644 --- a/libctf/ctf-dedup.c +++ b/libctf/ctf-dedup.c @@ -55,7 +55,7 @@ *global type ID* or 'GID', a pair of an array offset and a ctf_id_t. Since both are already 32 bits or less or can easily be constrained to that range, we can pack them both into a single 64-bit hash word for easy lookups, which - would be much more annoying to do with a ctf_file_t * and a ctf_id_t. (On + would be much more annoying to do with a ctf_dict_t * and a ctf_id_t. (On 32-bit platforms, we must do that anyway, since pointers, and thus hash keys and values, are only 32 bits wide). We track which inputs are parents of which other inputs so that we can correctly recognize that types we have @@ -294,23 +294,23 @@ approach, but with a smaller key, this is all we can do. */ static void * -id_to_packed_id (ctf_file_t *fp, int input_num, ctf_id_t type) +id_to_packed_id (ctf_dict_t *fp, int input_num, ctf_id_t type) { const void *lookup; ctf_type_id_key_t *dynkey = NULL; ctf_type_id_key_t key = { input_num, type }; - if (!ctf_dynhash_lookup_kv (fp->ctf_dedup.cd_id_to_file_t, + if (!ctf_dynhash_lookup_kv (fp->ctf_dedup.cd_id_to_dict_t, &key, &lookup, NULL)) { if ((dynkey = malloc (sizeof (ctf_type_id_key_t))) == NULL) goto oom; memcpy (dynkey, &key, sizeof (ctf_type_id_key_t)); - if (ctf_dynhash_insert (fp->ctf_dedup.cd_id_to_file_t, dynkey, NULL) < 0) + if (ctf_dynhash_insert (fp->ctf_dedup.cd_id_to_dict_t, dynkey, NULL) < 0) goto oom; - ctf_dynhash_lookup_kv (fp->ctf_dedup.cd_id_to_file_t, + ctf_dynhash_lookup_kv (fp->ctf_dedup.cd_id_to_dict_t, dynkey, &lookup, NULL); } /* We use a raw assert() here because there isn't really a way to get any sort @@ -368,7 +368,7 @@ make_set_element (ctf_dynhash_t *set, const void *key) /* Initialize the dedup atoms table. */ int -ctf_dedup_atoms_init (ctf_file_t *fp) +ctf_dedup_atoms_init (ctf_dict_t *fp) { if (fp->ctf_dedup_atoms) return 0; @@ -387,7 +387,7 @@ ctf_dedup_atoms_init (ctf_file_t *fp) /* Intern things in the dedup atoms table. */ static const char * -intern (ctf_file_t *fp, char *atom) +intern (ctf_dict_t *fp, char *atom) { const void *foo; @@ -414,7 +414,7 @@ intern (ctf_file_t *fp, char *atom) while allowing for the four C namespaces (normal, struct, union, enum). Return a new dynamically-allocated string. */ static const char * -ctf_decorate_type_name (ctf_file_t *fp, const char *name, int kind) +ctf_decorate_type_name (ctf_dict_t *fp, const char *name, int kind) { ctf_dedup_t *d = &fp->ctf_dedup; const char *ret; @@ -484,13 +484,13 @@ ctf_dedup_sha1_add (ctf_sha1_t *sha1, const void *buf, size_t len, } static const char * -ctf_dedup_hash_type (ctf_file_t *fp, ctf_file_t *input, - ctf_file_t **inputs, uint32_t *parents, +ctf_dedup_hash_type (ctf_dict_t *fp, ctf_dict_t *input, + ctf_dict_t **inputs, uint32_t *parents, int input_num, ctf_id_t type, int flags, unsigned long depth, - int (*populate_fun) (ctf_file_t *fp, - ctf_file_t *input, - ctf_file_t **inputs, + int (*populate_fun) (ctf_dict_t *fp, + ctf_dict_t *input, + ctf_dict_t **inputs, int input_num, ctf_id_t type, void *id, @@ -519,7 +519,7 @@ ctf_dedup_is_stub (const char *name, int kind, int fwdkind, int flags) Only called for forwards or forwardable types with names, when the link mode is CTF_LINK_SHARE_DUPLICATED. */ static int -ctf_dedup_record_origin (ctf_file_t *fp, int input_num, const char *decorated, +ctf_dedup_record_origin (ctf_dict_t *fp, int input_num, const char *decorated, void *id) { ctf_dedup_t *d = &fp->ctf_dedup; @@ -551,14 +551,14 @@ ctf_dedup_record_origin (ctf_file_t *fp, int input_num, const char *decorated, calls, recursively). */ static const char * -ctf_dedup_rhash_type (ctf_file_t *fp, ctf_file_t *input, ctf_file_t **inputs, +ctf_dedup_rhash_type (ctf_dict_t *fp, ctf_dict_t *input, ctf_dict_t **inputs, uint32_t *parents, int input_num, ctf_id_t type, void *type_id, const ctf_type_t *tp, const char *name, const char *decorated, int kind, int flags, unsigned long depth, - int (*populate_fun) (ctf_file_t *fp, - ctf_file_t *input, - ctf_file_t **inputs, + int (*populate_fun) (ctf_dict_t *fp, + ctf_dict_t *input, + ctf_dict_t **inputs, int input_num, ctf_id_t type, void *id, @@ -990,13 +990,13 @@ ctf_dedup_rhash_type (ctf_file_t *fp, ctf_file_t *input, ctf_file_t **inputs, Returns a hash value (an atom), or NULL on error. */ static const char * -ctf_dedup_hash_type (ctf_file_t *fp, ctf_file_t *input, - ctf_file_t **inputs, uint32_t *parents, +ctf_dedup_hash_type (ctf_dict_t *fp, ctf_dict_t *input, + ctf_dict_t **inputs, uint32_t *parents, int input_num, ctf_id_t type, int flags, unsigned long depth, - int (*populate_fun) (ctf_file_t *fp, - ctf_file_t *input, - ctf_file_t **inputs, + int (*populate_fun) (ctf_dict_t *fp, + ctf_dict_t *input, + ctf_dict_t **inputs, int input_num, ctf_id_t type, void *id, @@ -1139,8 +1139,8 @@ ctf_dedup_hash_type (ctf_file_t *fp, ctf_file_t *input, cd_output_first_tu mapping. */ static int -ctf_dedup_populate_mappings (ctf_file_t *fp, ctf_file_t *input _libctf_unused_, - ctf_file_t **inputs _libctf_unused_, +ctf_dedup_populate_mappings (ctf_dict_t *fp, ctf_dict_t *input _libctf_unused_, + ctf_dict_t **inputs _libctf_unused_, int input_num _libctf_unused_, ctf_id_t type _libctf_unused_, void *id, const char *decorated_name, @@ -1212,7 +1212,7 @@ ctf_dedup_populate_mappings (ctf_file_t *fp, ctf_file_t *input _libctf_unused_, while ((err = ctf_dynset_cnext (type_ids, &i, &one_id)) == 0) { - ctf_file_t *foo = inputs[CTF_DEDUP_GID_TO_INPUT (one_id)]; + ctf_dict_t *foo = inputs[CTF_DEDUP_GID_TO_INPUT (one_id)]; ctf_id_t bar = CTF_DEDUP_GID_TO_TYPE (one_id); if (ctf_type_kind_unsliced (foo, bar) != orig_kind) { @@ -1285,7 +1285,7 @@ ctf_dedup_populate_mappings (ctf_file_t *fp, ctf_file_t *input _libctf_unused_, ctf_dedup_maybe_synthesize_forward.) */ static int -ctf_dedup_mark_conflicting_hash (ctf_file_t *fp, const char *hval) +ctf_dedup_mark_conflicting_hash (ctf_dict_t *fp, const char *hval) { ctf_dedup_t *d = &fp->ctf_dedup; ctf_next_t *i = NULL; @@ -1331,7 +1331,7 @@ ctf_dedup_mark_conflicting_hash (ctf_file_t *fp, const char *hval) /* Look up a type kind from the output mapping, given a type hash value. */ static int -ctf_dedup_hash_kind (ctf_file_t *fp, ctf_file_t **inputs, const char *hash) +ctf_dedup_hash_kind (ctf_dict_t *fp, ctf_dict_t **inputs, const char *hash) { ctf_dedup_t *d = &fp->ctf_dedup; void *id; @@ -1363,8 +1363,8 @@ ctf_dedup_hash_kind (ctf_file_t *fp, ctf_file_t **inputs, const char *hash) /* Used to keep a count of types: i.e. distinct type hash values. */ typedef struct ctf_dedup_type_counter { - ctf_file_t *fp; - ctf_file_t **inputs; + ctf_dict_t *fp; + ctf_dict_t **inputs; int num_non_forwards; } ctf_dedup_type_counter_t; @@ -1401,7 +1401,7 @@ ctf_dedup_count_types (void *key_, void *value _libctf_unused_, void *arg_) /* Detect name ambiguity and mark ambiguous names as conflicting, other than the most common. */ static int -ctf_dedup_detect_name_ambiguity (ctf_file_t *fp, ctf_file_t **inputs) +ctf_dedup_detect_name_ambiguity (ctf_dict_t *fp, ctf_dict_t **inputs) { ctf_dedup_t *d = &fp->ctf_dedup; ctf_next_t *i = NULL; @@ -1560,7 +1560,7 @@ ctf_dedup_detect_name_ambiguity (ctf_file_t *fp, ctf_file_t **inputs) /* Initialize the deduplication machinery. */ static int -ctf_dedup_init (ctf_file_t *fp) +ctf_dedup_init (ctf_dict_t *fp) { ctf_dedup_t *d = &fp->ctf_dedup; size_t i; @@ -1569,7 +1569,7 @@ ctf_dedup_init (ctf_file_t *fp) goto oom; #if IDS_NEED_ALLOCATION - if ((d->cd_id_to_file_t = ctf_dynhash_create (ctf_hash_type_id_key, + if ((d->cd_id_to_dict_t = ctf_dynhash_create (ctf_hash_type_id_key, ctf_hash_eq_type_id_key, free, NULL)) == NULL) goto oom; @@ -1646,14 +1646,14 @@ ctf_dedup_init (ctf_file_t *fp) } void -ctf_dedup_fini (ctf_file_t *fp, ctf_file_t **outputs, uint32_t noutputs) +ctf_dedup_fini (ctf_dict_t *fp, ctf_dict_t **outputs, uint32_t noutputs) { ctf_dedup_t *d = &fp->ctf_dedup; size_t i; /* ctf_dedup_atoms is kept across links. */ #if IDS_NEED_ALLOCATION - ctf_dynhash_destroy (d->cd_id_to_file_t); + ctf_dynhash_destroy (d->cd_id_to_dict_t); #endif for (i = 0; i < 4; i++) ctf_dynhash_destroy (d->cd_decorated_names[i]); @@ -1677,7 +1677,7 @@ ctf_dedup_fini (ctf_file_t *fp, ctf_file_t **outputs, uint32_t noutputs) ctf_dedup_t *od = &outputs[i]->ctf_dedup; ctf_dynhash_destroy (od->cd_output_emission_hashes); ctf_dynhash_destroy (od->cd_output_emission_conflicted_forwards); - ctf_file_close (od->cd_output); + ctf_dict_close (od->cd_output); } } memset (d, 0, sizeof (ctf_dedup_t)); @@ -1686,16 +1686,16 @@ ctf_dedup_fini (ctf_file_t *fp, ctf_file_t **outputs, uint32_t noutputs) /* Return 1 if this type is cited by multiple input dictionaries. */ static int -ctf_dedup_multiple_input_dicts (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_multiple_input_dicts (ctf_dict_t *output, ctf_dict_t **inputs, const char *hval) { ctf_dedup_t *d = &output->ctf_dedup; ctf_dynset_t *type_ids; ctf_next_t *i = NULL; void *id; - ctf_file_t *found = NULL, *relative_found = NULL; + ctf_dict_t *found = NULL, *relative_found = NULL; const char *type_id; - ctf_file_t *input_fp; + ctf_dict_t *input_fp; ctf_id_t input_id; const char *name; const char *decorated; @@ -1714,7 +1714,7 @@ ctf_dedup_multiple_input_dicts (ctf_file_t *output, ctf_file_t **inputs, while ((err = ctf_dynset_next (type_ids, &i, &id)) == 0) { - ctf_file_t *fp = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; + ctf_dict_t *fp = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; if (fp == found || fp == relative_found) continue; @@ -1781,7 +1781,7 @@ ctf_dedup_multiple_input_dicts (ctf_file_t *output, ctf_file_t **inputs, types. Only used if the link mode is CTF_LINK_SHARE_DUPLICATED. */ static int -ctf_dedup_conflictify_unshared (ctf_file_t *output, ctf_file_t **inputs) +ctf_dedup_conflictify_unshared (ctf_dict_t *output, ctf_dict_t **inputs) { ctf_dedup_t *d = &output->ctf_dedup; ctf_next_t *i = NULL; @@ -1853,7 +1853,7 @@ ctf_dedup_conflictify_unshared (ctf_file_t *output, ctf_file_t **inputs) ctf_dedup_emit afterwards to do that. */ int -ctf_dedup (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, +ctf_dedup (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int cu_mapped) { ctf_dedup_t *d = &output->ctf_dedup; @@ -1924,17 +1924,17 @@ ctf_dedup (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, } static int -ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_rwalk_output_mapping (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, ctf_dynset_t *already_visited, const char *hval, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -1944,19 +1944,19 @@ ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, /* Like ctf_dedup_rwalk_output_mapping (which see), only takes a single target type and visits it. */ static int -ctf_dedup_rwalk_one_output_mapping (ctf_file_t *output, - ctf_file_t **inputs, uint32_t ninputs, +ctf_dedup_rwalk_one_output_mapping (ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, ctf_dynset_t *already_visited, int visited, void *type_id, const char *hval, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -1964,7 +1964,7 @@ ctf_dedup_rwalk_one_output_mapping (ctf_file_t *output, void *arg, unsigned long depth) { ctf_dedup_t *d = &output->ctf_dedup; - ctf_file_t *fp; + ctf_dict_t *fp; int input_num; ctf_id_t type; int ret; @@ -2128,17 +2128,17 @@ ctf_dedup_rwalk_one_output_mapping (ctf_file_t *output, once, but are not recursed through repeatedly: ALREADY_VISITED tracks whether types have already been visited. */ static int -ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_rwalk_output_mapping (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, ctf_dynset_t *already_visited, const char *hval, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -2222,7 +2222,7 @@ ctf_dedup_rwalk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, typedef struct ctf_sort_om_cb_arg { - ctf_file_t **inputs; + ctf_dict_t **inputs; uint32_t ninputs; ctf_dedup_t *d; } ctf_sort_om_cb_arg_t; @@ -2241,8 +2241,8 @@ sort_output_mapping (const ctf_next_hkv_t *one, const ctf_next_hkv_t *two, void *one_gid, *two_gid; uint32_t one_ninput; uint32_t two_ninput; - ctf_file_t *one_fp; - ctf_file_t *two_fp; + ctf_dict_t *one_fp; + ctf_dict_t *two_fp; ctf_id_t one_type; ctf_id_t two_type; @@ -2288,15 +2288,15 @@ sort_output_mapping (const ctf_next_hkv_t *one, const ctf_next_hkv_t *two, /* The public entry point to ctf_dedup_rwalk_output_mapping, above. */ static int -ctf_dedup_walk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_walk_output_mapping (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int (*visit_fun) (const char *hval, - ctf_file_t *output, - ctf_file_t **inputs, + ctf_dict_t *output, + ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, @@ -2351,8 +2351,8 @@ ctf_dedup_walk_output_mapping (ctf_file_t *output, ctf_file_t **inputs, conflicted per-TU type ID in INPUT with hash HVAL. Return its CTF ID, or 0 if none was needed. */ static ctf_id_t -ctf_dedup_maybe_synthesize_forward (ctf_file_t *output, ctf_file_t *target, - ctf_file_t *input, ctf_id_t id, +ctf_dedup_maybe_synthesize_forward (ctf_dict_t *output, ctf_dict_t *target, + ctf_dict_t *input, ctf_id_t id, const char *hval) { ctf_dedup_t *od = &output->ctf_dedup; @@ -2430,14 +2430,14 @@ ctf_dedup_maybe_synthesize_forward (ctf_file_t *output, ctf_file_t *target, make usability a bit better. */ static ctf_id_t -ctf_dedup_id_to_target (ctf_file_t *output, ctf_file_t *target, - ctf_file_t **inputs, uint32_t ninputs, - uint32_t *parents, ctf_file_t *input, int input_num, +ctf_dedup_id_to_target (ctf_dict_t *output, ctf_dict_t *target, + ctf_dict_t **inputs, uint32_t ninputs, + uint32_t *parents, ctf_dict_t *input, int input_num, ctf_id_t id) { ctf_dedup_t *od = &output->ctf_dedup; ctf_dedup_t *td = &target->ctf_dedup; - ctf_file_t *err_fp = input; + ctf_dict_t *err_fp = input; const char *hval; void *target_id; ctf_id_t emitted_forward; @@ -2535,7 +2535,7 @@ ctf_dedup_id_to_target (ctf_file_t *output, ctf_file_t *target, have already been emitted. (This type itself may also have been emitted.) If the ARG is 1, this is a CU-mapped deduplication round mapping many - ctf_file_t's into precisely one: conflicting types should be marked + ctf_dict_t's into precisely one: conflicting types should be marked non-root-visible. If the ARG is 0, conflicting types go into per-CU dictionaries stored in the input's ctf_dedup.cd_output: otherwise, everything is emitted directly into the output. No struct/union members are emitted. @@ -2546,16 +2546,16 @@ ctf_dedup_id_to_target (ctf_file_t *output, ctf_file_t *target, data object section, backtrace section etc). */ static int -ctf_dedup_emit_type (const char *hval, ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_emit_type (const char *hval, ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, int already_visited, - ctf_file_t *input, ctf_id_t type, void *id, int depth, + ctf_dict_t *input, ctf_id_t type, void *id, int depth, void *arg) { ctf_dedup_t *d = &output->ctf_dedup; int kind = ctf_type_kind_unsliced (input, type); const char *name; - ctf_file_t *target = output; - ctf_file_t *real_input; + ctf_dict_t *target = output; + ctf_dict_t *real_input; const ctf_type_t *tp; int input_num = CTF_DEDUP_GID_TO_INPUT (id); int output_num = (uint32_t) -1; /* 'shared' */ @@ -2896,14 +2896,14 @@ ctf_dedup_emit_type (const char *hval, ctf_file_t *output, ctf_file_t **inputs, point. */ static int -ctf_dedup_emit_struct_members (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_emit_struct_members (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents) { ctf_dedup_t *d = &output->ctf_dedup; ctf_next_t *i = NULL; void *input_id, *target_id; int err; - ctf_file_t *err_fp, *input_fp; + ctf_dict_t *err_fp, *input_fp; int input_num; ctf_id_t err_type; @@ -2911,7 +2911,7 @@ ctf_dedup_emit_struct_members (ctf_file_t *output, ctf_file_t **inputs, &input_id, &target_id)) == 0) { ctf_next_t *j = NULL; - ctf_file_t *target; + ctf_dict_t *target; uint32_t target_num; ctf_id_t input_type, target_type; ssize_t offset; @@ -2992,11 +2992,11 @@ ctf_dedup_emit_struct_members (ctf_file_t *output, ctf_file_t **inputs, dict containing a non-null cd_output resulting from a ctf_dedup_emit_type walk). */ static int -ctf_dedup_populate_type_mapping (ctf_file_t *shared, ctf_file_t *fp, - ctf_file_t **inputs) +ctf_dedup_populate_type_mapping (ctf_dict_t *shared, ctf_dict_t *fp, + ctf_dict_t **inputs) { ctf_dedup_t *d = &shared->ctf_dedup; - ctf_file_t *output = fp->ctf_dedup.cd_output; + ctf_dict_t *output = fp->ctf_dedup.cd_output; const void *k, *v; ctf_next_t *i = NULL; int err; @@ -3029,7 +3029,7 @@ ctf_dedup_populate_type_mapping (ctf_file_t *shared, ctf_file_t *fp, while ((err = ctf_dynset_cnext (type_ids, &j, &id)) == 0) { - ctf_file_t *input = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; + ctf_dict_t *input = inputs[CTF_DEDUP_GID_TO_INPUT (id)]; ctf_id_t id_in = CTF_DEDUP_GID_TO_TYPE (id); #ifdef ENABLE_LIBCTF_HASH_DEBUGGING @@ -3057,7 +3057,7 @@ ctf_dedup_populate_type_mapping (ctf_file_t *shared, ctf_file_t *fp, /* Populate the type mapping machinery used by the rest of the linker, by ctf_add_type, etc. */ static int -ctf_dedup_populate_type_mappings (ctf_file_t *output, ctf_file_t **inputs, +ctf_dedup_populate_type_mappings (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs) { size_t i; @@ -3094,13 +3094,13 @@ ctf_dedup_populate_type_mappings (ctf_file_t *output, ctf_file_t **inputs, If CU_MAPPED is set, this is a first pass for a link with a non-empty CU mapping: only one output will result. */ -ctf_file_t ** -ctf_dedup_emit (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, +ctf_dict_t ** +ctf_dedup_emit (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, uint32_t *parents, uint32_t *noutputs, int cu_mapped) { size_t num_outputs = 1; /* Always at least one output: us. */ - ctf_file_t **outputs; - ctf_file_t **walk; + ctf_dict_t **outputs; + ctf_dict_t **walk; size_t i; ctf_dprintf ("Triggering emission.\n"); @@ -3124,7 +3124,7 @@ ctf_dedup_emit (ctf_file_t *output, ctf_file_t **inputs, uint32_t ninputs, if (!ctf_assert (output, !cu_mapped || (cu_mapped && num_outputs == 1))) return NULL; - if ((outputs = calloc (num_outputs, sizeof (ctf_file_t *))) == NULL) + if ((outputs = calloc (num_outputs, sizeof (ctf_dict_t *))) == NULL) { ctf_err_warn (output, 0, ENOMEM, _("out of memory allocating link outputs array")); |