2 Copyright (C) 2019-2020 Free Software Foundation, Inc.
4 This file is part of libctf.
6 libctf is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; see the file COPYING. If not see
18 <http://www.gnu.org/licenses/>. */
27 /* Type tracking machinery. */
29 /* Record the correspondence between a source and ctf_add_type()-added
30 destination type: both types are translated into parent type IDs if need be,
31 so they relate to the actual container they are in. Outside controlled
32 circumstances (like linking) it is probably not useful to do more than
33 compare these pointers, since there is nothing stopping the user closing the
34 source container whenever they want to.
36 Our OOM handling here is just to not do anything, because this is called deep
37 enough in the call stack that doing anything useful is painfully difficult:
38 the worst consequence if we do OOM is a bit of type duplication anyway. */
41 ctf_add_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type,
42 ctf_file_t *dst_fp, ctf_id_t dst_type)
44 if (LCTF_TYPE_ISPARENT (src_fp, src_type) && src_fp->ctf_parent)
45 src_fp = src_fp->ctf_parent;
47 src_type = LCTF_TYPE_TO_INDEX(src_fp, src_type);
49 if (LCTF_TYPE_ISPARENT (dst_fp, dst_type) && dst_fp->ctf_parent)
50 dst_fp = dst_fp->ctf_parent;
52 dst_type = LCTF_TYPE_TO_INDEX(dst_fp, dst_type);
54 /* This dynhash is a bit tricky: it has a multivalued (structural) key, so we
55 need to use the sized-hash machinery to generate key hashing and equality
58 if (dst_fp->ctf_link_type_mapping == NULL)
60 ctf_hash_fun f = ctf_hash_type_key;
61 ctf_hash_eq_fun e = ctf_hash_eq_type_key;
63 if ((dst_fp->ctf_link_type_mapping = ctf_dynhash_create (f, e, free,
68 ctf_link_type_key_t *key;
69 key = calloc (1, sizeof (struct ctf_link_type_key));
73 key->cltk_fp = src_fp;
74 key->cltk_idx = src_type;
76 /* No OOM checking needed, because if this doesn't work the worst we'll do is
77 add a few more duplicate types (which will probably run out of memory
79 ctf_dynhash_insert (dst_fp->ctf_link_type_mapping, key,
80 (void *) (uintptr_t) dst_type);
83 /* Look up a type mapping: return 0 if none. The DST_FP is modified to point to
84 the parent if need be. The ID returned is from the dst_fp's perspective. */
86 ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type, ctf_file_t **dst_fp)
88 ctf_link_type_key_t key;
89 ctf_file_t *target_fp = *dst_fp;
90 ctf_id_t dst_type = 0;
92 if (LCTF_TYPE_ISPARENT (src_fp, src_type) && src_fp->ctf_parent)
93 src_fp = src_fp->ctf_parent;
95 src_type = LCTF_TYPE_TO_INDEX(src_fp, src_type);
97 key.cltk_idx = src_type;
99 if (target_fp->ctf_link_type_mapping)
100 dst_type = (uintptr_t) ctf_dynhash_lookup (target_fp->ctf_link_type_mapping,
105 dst_type = LCTF_INDEX_TO_TYPE (target_fp, dst_type,
106 target_fp->ctf_parent != NULL);
111 if (target_fp->ctf_parent)
112 target_fp = target_fp->ctf_parent;
116 if (target_fp->ctf_link_type_mapping)
117 dst_type = (uintptr_t) ctf_dynhash_lookup (target_fp->ctf_link_type_mapping,
121 dst_type = LCTF_INDEX_TO_TYPE (target_fp, dst_type,
122 target_fp->ctf_parent != NULL);
130 CTF linking consists of adding CTF archives full of content to be merged into
131 this one to the current file (which must be writable) by calling
132 ctf_link_add_ctf(). Once this is done, a call to ctf_link() will merge the
133 type tables together, generating new CTF files as needed, with this one as a
134 parent, to contain types from the inputs which conflict.
135 ctf_link_add_strtab() takes a callback which provides string/offset pairs to
136 be added to the external symbol table and deduplicated from all CTF string
137 tables in the output link; ctf_link_shuffle_syms() takes a callback which
138 provides symtab entries in ascending order, and shuffles the function and
139 data sections to match; and ctf_link_write() emits a CTF file (if there are
140 no conflicts requiring per-compilation-unit sub-CTF files) or CTF archives
141 (otherwise) and returns it, suitable for addition in the .ctf section of the
144 /* Return the name of the compilation unit this CTF dict or its parent applies
145 to, or a non-null string otherwise: prefer the parent. Used in debugging
146 output. Sometimes used for outputs too. */
148 ctf_link_input_name (ctf_file_t *fp)
150 if (fp->ctf_parent && fp->ctf_parent->ctf_cuname)
151 return fp->ctf_parent->ctf_cuname;
152 else if (fp->ctf_cuname)
153 return fp->ctf_cuname;
158 /* The linker inputs look like this. clin_fp is used for short-circuited
159 CU-mapped links that can entirely avoid the first link phase in some
160 situations in favour of just passing on the contained ctf_file_t: it is
161 always the sole ctf_file_t inside the corresponding clin_arc. If set, it
162 gets assigned directly to the final link inputs and freed from there, so it
163 never gets explicitly freed in the ctf_link_input. */
164 typedef struct ctf_link_input
166 const char *clin_filename;
167 ctf_archive_t *clin_arc;
173 ctf_link_input_close (void *input)
175 ctf_link_input_t *i = (ctf_link_input_t *) input;
177 ctf_arc_close (i->clin_arc);
181 /* Like ctf_link_add_ctf, below, but with no error-checking, so it can be called
182 in the middle of an ongoing link. */
184 ctf_link_add_ctf_internal (ctf_file_t *fp, ctf_archive_t *ctf,
185 ctf_file_t *fp_input, const char *name)
187 ctf_link_input_t *input = NULL;
188 char *dupname = NULL;
190 if ((input = calloc (1, sizeof (ctf_link_input_t))) == NULL)
193 if ((dupname = strdup (name)) == NULL)
196 input->clin_arc = ctf;
197 input->clin_fp = fp_input;
198 input->clin_filename = dupname;
199 input->n = ctf_dynhash_elements (fp->ctf_link_inputs);
201 if (ctf_dynhash_insert (fp->ctf_link_inputs, dupname, input) < 0)
208 return ctf_set_errno (fp, ENOMEM);
211 /* Add a file, memory buffer, or unopened file (by name) to a link.
213 You can call this with:
215 CTF and NAME: link the passed ctf_archive_t, with the given NAME.
216 NAME alone: open NAME as a CTF file when needed.
217 BUF and NAME: open the BUF (of length N) as CTF, with the given NAME. (Not
220 Passed in CTF args are owned by the dictionary and will be freed by it.
221 The BUF arg is *not* owned by the dictionary, and the user should not free
222 its referent until the link is done.
224 The order of calls to this function influences the order of types in the
225 final link output, but otherwise is not important.
227 Private for now, but may in time become public once support for BUF is
231 ctf_link_add (ctf_file_t *fp, ctf_archive_t *ctf, const char *name,
232 void *buf _libctf_unused_, size_t n _libctf_unused_)
235 return (ctf_set_errno (fp, ECTF_NOTYET));
237 if (!((ctf && name && !buf)
238 || (name && !buf && !ctf)
239 || (buf && name && !ctf)))
240 return (ctf_set_errno (fp, EINVAL));
242 /* We can only lazily open files if libctf.so is in use rather than
243 libctf-nobfd.so. This is a little tricky: in shared libraries, we can use
244 a weak symbol so that -lctf -lctf-nobfd works, but in static libraries we
245 must distinguish between the two libraries explicitly. */
248 if (!buf && !ctf && name && !ctf_open)
249 return (ctf_set_errno (fp, ECTF_NEEDSBFD));
251 if (!buf && !ctf && name)
252 return (ctf_set_errno (fp, ECTF_NEEDSBFD));
255 if (fp->ctf_link_outputs)
256 return (ctf_set_errno (fp, ECTF_LINKADDEDLATE));
257 if (fp->ctf_link_inputs == NULL)
258 fp->ctf_link_inputs = ctf_dynhash_create (ctf_hash_string,
259 ctf_hash_eq_string, free,
260 ctf_link_input_close);
262 if (fp->ctf_link_inputs == NULL)
263 return (ctf_set_errno (fp, ENOMEM));
265 return ctf_link_add_ctf_internal (fp, ctf, NULL, name);
268 /* Add an opened CTF archive or unopened file (by name) to a link.
269 If CTF is NULL and NAME is non-null, an unopened file is meant:
270 otherwise, the specified archive is assumed to have the given NAME.
272 Passed in CTF args are owned by the dictionary and will be freed by it.
274 The order of calls to this function influences the order of types in the
275 final link output, but otherwise is not important. */
278 ctf_link_add_ctf (ctf_file_t *fp, ctf_archive_t *ctf, const char *name)
280 return ctf_link_add (fp, ctf, name, NULL, 0);
283 /* Return a per-CU output CTF dictionary suitable for the given CU, creating and
284 interning it if need be. */
287 ctf_create_per_cu (ctf_file_t *fp, const char *filename, const char *cuname)
290 const char *ctf_name = NULL;
291 char *dynname = NULL;
293 /* First, check the mapping table and translate the per-CU name we use
294 accordingly. We check both the input filename and the CU name. Only if
295 neither are set do we fall back to the input filename as the per-CU
296 dictionary name. We prefer the filename because this is easier for likely
297 callers to determine. */
299 if (fp->ctf_link_in_cu_mapping)
301 if (((ctf_name = ctf_dynhash_lookup (fp->ctf_link_in_cu_mapping,
302 filename)) == NULL) &&
303 ((ctf_name = ctf_dynhash_lookup (fp->ctf_link_in_cu_mapping,
308 if (ctf_name == NULL)
311 if ((cu_fp = ctf_dynhash_lookup (fp->ctf_link_outputs, ctf_name)) == NULL)
315 if ((cu_fp = ctf_create (&err)) == NULL)
317 ctf_err_warn (fp, 0, "Cannot create per-CU CTF archive for "
318 "CU %s from input file %s: %s", cuname, filename,
320 ctf_set_errno (fp, err);
324 if ((dynname = strdup (ctf_name)) == NULL)
326 if (ctf_dynhash_insert (fp->ctf_link_outputs, dynname, cu_fp) < 0)
329 ctf_import_unref (cu_fp, fp);
330 ctf_cuname_set (cu_fp, cuname);
331 ctf_parent_name_set (cu_fp, _CTF_SECTION);
337 ctf_file_close (cu_fp);
338 ctf_set_errno (fp, ENOMEM);
342 /* Add a mapping directing that the CU named FROM should have its
343 conflicting/non-duplicate types (depending on link mode) go into a container
344 named TO. Many FROMs can share a TO.
346 We forcibly add a container named TO in every case, even though it may well
347 wind up empty, because clients that use this facility usually expect to find
348 every TO container present, even if empty, and malfunction otherwise. */
351 ctf_link_add_cu_mapping (ctf_file_t *fp, const char *from, const char *to)
354 char *f = NULL, *t = NULL;
355 ctf_dynhash_t *one_out;
357 if (fp->ctf_link_in_cu_mapping == NULL)
358 fp->ctf_link_in_cu_mapping = ctf_dynhash_create (ctf_hash_string,
359 ctf_hash_eq_string, free,
361 if (fp->ctf_link_in_cu_mapping == NULL)
364 if (fp->ctf_link_out_cu_mapping == NULL)
365 fp->ctf_link_out_cu_mapping = ctf_dynhash_create (ctf_hash_string,
366 ctf_hash_eq_string, free,
368 ctf_dynhash_destroy);
369 if (fp->ctf_link_out_cu_mapping == NULL)
377 /* Track both in a list from FROM to TO and in a list from TO to a list of
378 FROM. The former is used to create TUs with the mapped-to name at need:
379 the latter is used in deduplicating links to pull in all input CUs
380 corresponding to a single output CU. */
382 if ((err = ctf_dynhash_insert (fp->ctf_link_in_cu_mapping, f, t)) < 0)
384 ctf_set_errno (fp, err);
388 /* f and t are now owned by the in_cu_mapping: reallocate them. */
394 if ((one_out = ctf_dynhash_lookup (fp->ctf_link_out_cu_mapping, t)) == NULL)
396 if ((one_out = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
397 free, NULL)) == NULL)
399 if ((err = ctf_dynhash_insert (fp->ctf_link_out_cu_mapping,
402 ctf_dynhash_destroy (one_out);
403 ctf_set_errno (fp, err);
410 if (ctf_dynhash_insert (one_out, f, NULL) < 0)
412 ctf_set_errno (fp, err);
419 ctf_set_errno (fp, errno);
426 /* Set a function which is called to transform the names of archive members.
427 This is useful for applying regular transformations to many names, where
428 ctf_link_add_cu_mapping applies arbitrarily irregular changes to single
429 names. The member name changer is applied at ctf_link_write time, so it
430 cannot conflate multiple CUs into one the way ctf_link_add_cu_mapping can.
431 The changer function accepts a name and should return a new
432 dynamically-allocated name, or NULL if the name should be left unchanged. */
434 ctf_link_set_memb_name_changer (ctf_file_t *fp,
435 ctf_link_memb_name_changer_f *changer,
438 fp->ctf_link_memb_name_changer = changer;
439 fp->ctf_link_memb_name_changer_arg = arg;
442 typedef struct ctf_link_in_member_cb_arg
444 /* The shared output dictionary. */
447 /* The filename of the input file, and an fp to each dictionary in that file
449 const char *in_file_name;
452 /* The CU name of the dict being processed. */
454 int in_input_cu_file;
456 /* The parent dictionary in the input, and whether it's been processed yet.
457 Not needed by ctf_link_one_type / ctf_link_one_variable, only by higher
459 ctf_file_t *in_fp_parent;
462 /* If true, this is the CU-mapped portion of a deduplicating link: no child
463 dictionaries should be created. */
465 } ctf_link_in_member_cb_arg_t;
467 /* Link one type into the link. We rely on ctf_add_type() to detect
468 duplicates. This is not terribly reliable yet (unnmamed types will be
469 mindlessly duplicated), but will improve shortly. */
472 ctf_link_one_type (ctf_id_t type, int isroot _libctf_unused_, void *arg_)
474 ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_;
475 ctf_file_t *per_cu_out_fp;
478 if (arg->in_fp->ctf_link_flags != CTF_LINK_SHARE_UNCONFLICTED)
480 ctf_err_warn (arg->out_fp, 0, "Share-duplicated mode not yet implemented");
481 return ctf_set_errno (arg->out_fp, ECTF_NOTYET);
484 /* Simply call ctf_add_type: if it reports a conflict and we're adding to the
485 main CTF file, add to the per-CU archive member instead, creating it if
486 necessary. If we got this type from a per-CU archive member, add it
487 straight back to the corresponding member in the output. */
489 if (!arg->in_input_cu_file)
491 if (ctf_add_type (arg->out_fp, arg->in_fp, type) != CTF_ERR)
494 err = ctf_errno (arg->out_fp);
495 if (err != ECTF_CONFLICT)
497 if (err != ECTF_NONREPRESENTABLE)
498 ctf_err_warn (arg->out_fp, 1, "Cannot link type %lx from input file %s, "
499 "CU %s into output link: %s", type, arg->cu_name,
500 arg->in_file_name, ctf_errmsg (err));
501 /* We must ignore this problem or we end up losing future types, then
502 trying to link the variables in, then exploding. Better to link as
506 ctf_set_errno (arg->out_fp, 0);
509 if ((per_cu_out_fp = ctf_create_per_cu (arg->out_fp, arg->in_file_name,
510 arg->cu_name)) == NULL)
511 return -1; /* Errno is set for us. */
513 if (ctf_add_type (per_cu_out_fp, arg->in_fp, type) != CTF_ERR)
516 err = ctf_errno (per_cu_out_fp);
517 if (err != ECTF_NONREPRESENTABLE)
518 ctf_err_warn (arg->out_fp, 1, "Cannot link type %lx from input file %s, CU %s "
519 "into output per-CU CTF archive member %s: %s: skipped", type,
520 ctf_link_input_name (arg->in_fp), arg->in_file_name,
521 ctf_link_input_name (per_cu_out_fp), ctf_errmsg (err));
522 if (err == ECTF_CONFLICT)
523 /* Conflicts are possible at this stage only if a non-ld user has combined
524 multiple TUs into a single output dictionary. Even in this case we do not
525 want to stop the link or propagate the error. */
526 ctf_set_errno (arg->out_fp, 0);
528 return 0; /* As above: do not lose types. */
531 /* Set a function which is used to filter out unwanted variables from the link. */
533 ctf_link_set_variable_filter (ctf_file_t *fp, ctf_link_variable_filter_f *filter,
536 fp->ctf_link_variable_filter = filter;
537 fp->ctf_link_variable_filter_arg = arg;
541 /* Check if we can safely add a variable with the given type to this container. */
544 check_variable (const char *name, ctf_file_t *fp, ctf_id_t type,
545 ctf_dvdef_t **out_dvd)
549 dvd = ctf_dynhash_lookup (fp->ctf_dvhash, name);
554 if (dvd->dvd_type != type)
556 /* Variable here. Wrong type: cannot add. Just skip it, because there is
557 no way to express this in CTF. Don't even warn: this case is too
558 common. (This might be the parent, in which case we'll try adding in
559 the child first, and only then give up.) */
560 ctf_dprintf ("Inexpressible duplicate variable %s skipped.\n", name);
563 return 0; /* Already exists. */
566 /* Link one variable in. */
569 ctf_link_one_variable (const char *name, ctf_id_t type, void *arg_)
571 ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_;
572 ctf_file_t *per_cu_out_fp;
573 ctf_id_t dst_type = 0;
574 ctf_file_t *check_fp;
577 /* See if this variable is filtered out. */
579 if (arg->out_fp->ctf_link_variable_filter)
581 void *farg = arg->out_fp->ctf_link_variable_filter_arg;
582 if (arg->out_fp->ctf_link_variable_filter (arg->in_fp, name, type, farg))
586 /* In unconflicted link mode, if this type is mapped to a type in the parent
587 container, we want to try to add to that first: if it reports a duplicate,
588 or if the type is in a child already, add straight to the child. */
590 check_fp = arg->out_fp;
592 dst_type = ctf_type_mapping (arg->in_fp, type, &check_fp);
595 if (check_fp == arg->out_fp)
597 if (check_variable (name, check_fp, dst_type, &dvd))
599 /* No variable here: we can add it. */
600 if (ctf_add_variable (check_fp, name, dst_type) < 0)
601 return (ctf_set_errno (arg->out_fp, ctf_errno (check_fp)));
605 /* Already present? Nothing to do. */
606 if (dvd && dvd->dvd_type == dst_type)
611 /* Can't add to the parent due to a name clash, or because it references a
612 type only present in the child. Try adding to the child, creating if need
613 be. If we can't do that, skip it. Don't add to a child if we're doing a
614 CU-mapped link, since that has only one output. */
618 ctf_dprintf ("Variable %s in input file %s depends on a type %lx hidden "
619 "due to conflicts: skipped.\n", name, arg->in_file_name,
624 if ((per_cu_out_fp = ctf_create_per_cu (arg->out_fp, arg->in_file_name,
625 arg->cu_name)) == NULL)
626 return -1; /* Errno is set for us. */
628 /* If the type was not found, check for it in the child too. */
631 check_fp = per_cu_out_fp;
632 dst_type = ctf_type_mapping (arg->in_fp, type, &check_fp);
636 ctf_err_warn (arg->out_fp, 1, "Type %lx for variable %s in input "
637 "file %s not found: skipped", type, name,
639 /* Do not terminate the link: just skip the variable. */
644 if (check_variable (name, per_cu_out_fp, dst_type, &dvd))
645 if (ctf_add_variable (per_cu_out_fp, name, dst_type) < 0)
646 return (ctf_set_errno (arg->out_fp, ctf_errno (per_cu_out_fp)));
650 /* Merge every type (and optionally, variable) in this archive member into the
651 link, so we can relink things that have already had ld run on them. We use
652 the archive member name, sans any leading '.ctf.', as the CU name for
653 ambiguous types if there is one and it's not the default: otherwise, we use
654 the name of the input file. */
656 ctf_link_one_input_archive_member (ctf_file_t *in_fp, const char *name, void *arg_)
658 ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_;
661 if (strcmp (name, _CTF_SECTION) == 0)
663 /* This file is the default member of this archive, and has already been
664 explicitly processed.
666 In the default sharing mode of CTF_LINK_SHARE_UNCONFLICTED, it does no
667 harm to rescan an existing shared repo again: all the types will just
668 end up in the same place. But in CTF_LINK_SHARE_DUPLICATED mode, this
669 causes the system to erroneously conclude that all types are duplicated
670 and should be shared, even if they are not. */
672 if (arg->done_parent)
677 /* Get ambiguous types from our parent. */
678 ctf_import (in_fp, arg->in_fp_parent);
679 arg->in_input_cu_file = 1;
683 if (strncmp (arg->cu_name, ".ctf.", strlen (".ctf.")) == 0)
684 arg->cu_name += strlen (".ctf.");
687 if ((err = ctf_type_iter_all (in_fp, ctf_link_one_type, arg)) > -1)
688 if (!(in_fp->ctf_link_flags & CTF_LINK_OMIT_VARIABLES_SECTION))
689 err = ctf_variable_iter (in_fp, ctf_link_one_variable, arg);
691 arg->in_input_cu_file = 0;
694 return -1; /* Errno is set for us. */
699 /* Dump the unnecessary link type mapping after one input file is processed. */
701 empty_link_type_mapping (void *key _libctf_unused_, void *value,
702 void *arg _libctf_unused_)
704 ctf_file_t *fp = (ctf_file_t *) value;
706 if (fp->ctf_link_type_mapping)
707 ctf_dynhash_empty (fp->ctf_link_type_mapping);
710 /* Lazily open a CTF archive for linking, if not already open.
712 Returns the number of files contained within the opened archive (0 for none),
713 or -1 on error, as usual. */
715 ctf_link_lazy_open (ctf_file_t *fp, ctf_link_input_t *input)
721 return ctf_archive_count (input->clin_arc);
726 /* See ctf_link_add_ctf. */
727 #if defined (PIC) || !NOBFD
728 input->clin_arc = ctf_open (input->clin_filename, NULL, &err);
730 ctf_err_warn (fp, 0, "Cannot open %s lazily: %s", input->clin_filename,
731 ctf_errmsg (ECTF_NEEDSBFD));
732 ctf_set_errno (fp, ECTF_NEEDSBFD);
736 /* Having no CTF sections is not an error. We just don't need to do
739 if (!input->clin_arc)
741 if (err == ECTF_NOCTFDATA)
744 ctf_err_warn (fp, 0, "Opening CTF %s failed: %s",
745 input->clin_filename, ctf_errmsg (err));
746 ctf_set_errno (fp, err);
750 if ((count = ctf_archive_count (input->clin_arc)) == 0)
751 ctf_arc_close (input->clin_arc);
753 return (ssize_t) count;
756 /* Close an input, as a ctf_dynhash_iter iterator. */
758 ctf_link_close_one_input_archive (void *key _libctf_unused_, void *value,
759 void *arg _libctf_unused_)
761 ctf_link_input_t *input = (ctf_link_input_t *) value;
763 ctf_arc_close (input->clin_arc);
764 input->clin_arc = NULL;
767 /* Link one input file's types into the output file. */
769 ctf_link_one_input_archive (void *key, void *value, void *arg_)
771 const char *file_name = (const char *) key;
772 ctf_link_input_t *input = (ctf_link_input_t *)value;
773 ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_;
776 if (!input->clin_arc)
778 err = ctf_link_lazy_open (arg->out_fp, input);
779 if (err == 0) /* Just no CTF. */
783 return; /* errno is set for us. */
786 arg->in_file_name = file_name;
787 arg->done_parent = 0;
788 if ((arg->in_fp_parent = ctf_arc_open_by_name (input->clin_arc, NULL,
790 if (err != ECTF_ARNNAME)
792 ctf_err_warn (arg->out_fp, 0, "Cannot open main archive member in "
793 "input file %s in the link: skipping: %s",
794 arg->in_file_name, ctf_errmsg (err));
798 if (ctf_link_one_input_archive_member (arg->in_fp_parent,
799 _CTF_SECTION, arg) < 0)
801 ctf_file_close (arg->in_fp_parent);
804 arg->done_parent = 1;
805 if (ctf_archive_iter (input->clin_arc, ctf_link_one_input_archive_member,
807 ctf_err_warn (arg->out_fp, 0, "Cannot traverse archive in input file %s: "
808 "link cannot continue: %s", arg->in_file_name,
809 ctf_errmsg (ctf_errno (arg->out_fp)));
812 /* The only error indication to the caller is the errno: so ensure that it
813 is zero if there was no actual error from the caller. */
814 ctf_set_errno (arg->out_fp, 0);
816 ctf_file_close (arg->in_fp_parent);
819 ctf_link_close_one_input_archive (key, value, NULL);
822 /* Merge types and variable sections in all files added to the link
823 together. All the added files are closed. */
825 ctf_link (ctf_file_t *fp, int flags)
827 ctf_link_in_member_cb_arg_t arg;
828 ctf_next_t *i = NULL;
831 memset (&arg, 0, sizeof (struct ctf_link_in_member_cb_arg));
833 fp->ctf_link_flags = flags;
835 if (fp->ctf_link_inputs == NULL)
836 return 0; /* Nothing to do. */
838 if (fp->ctf_link_outputs == NULL)
839 fp->ctf_link_outputs = ctf_dynhash_create (ctf_hash_string,
840 ctf_hash_eq_string, free,
844 if (fp->ctf_link_outputs == NULL)
845 return ctf_set_errno (fp, ENOMEM);
847 /* Create empty CUs if requested. We do not currently claim that multiple
848 links in succession with CTF_LINK_EMPTY_CU_MAPPINGS set in some calls and
849 not set in others will do anything especially sensible. */
851 if (fp->ctf_link_out_cu_mapping && (flags & CTF_LINK_EMPTY_CU_MAPPINGS))
855 while ((err = ctf_dynhash_next (fp->ctf_link_out_cu_mapping, &i, &v,
858 const char *to = (const char *) v;
859 if (ctf_create_per_cu (fp, to, to) == NULL)
861 ctf_next_destroy (i);
862 return -1; /* Errno is set for us. */
865 if (err != ECTF_NEXT_END)
867 ctf_err_warn (fp, 1, "Iteration error creating empty CUs: %s",
869 ctf_set_errno (fp, err);
874 ctf_dynhash_iter (fp->ctf_link_inputs, ctf_link_one_input_archive,
877 /* Discard the now-unnecessary mapping table data from all the outputs. */
878 if (fp->ctf_link_type_mapping)
879 ctf_dynhash_empty (fp->ctf_link_type_mapping);
880 ctf_dynhash_iter (fp->ctf_link_outputs, empty_link_type_mapping, NULL);
882 if ((ctf_errno (fp) != 0) && (ctf_errno (fp) != ECTF_NOCTFDATA))
887 typedef struct ctf_link_out_string_cb_arg
892 } ctf_link_out_string_cb_arg_t;
894 /* Intern a string in the string table of an output per-CU CTF file. */
896 ctf_link_intern_extern_string (void *key _libctf_unused_, void *value,
899 ctf_file_t *fp = (ctf_file_t *) value;
900 ctf_link_out_string_cb_arg_t *arg = (ctf_link_out_string_cb_arg_t *) arg_;
902 fp->ctf_flags |= LCTF_DIRTY;
903 if (!ctf_str_add_external (fp, arg->str, arg->offset))
907 /* Repeatedly call ADD_STRING to acquire strings from the external string table,
908 adding them to the atoms table for this CU and all subsidiary CUs.
910 If ctf_link() is also called, it must be called first if you want the new CTF
911 files ctf_link() can create to get their strings dedupped against the ELF
914 ctf_link_add_strtab (ctf_file_t *fp, ctf_link_strtab_string_f *add_string,
921 while ((str = add_string (&offset, arg)) != NULL)
923 ctf_link_out_string_cb_arg_t iter_arg = { str, offset, 0 };
925 fp->ctf_flags |= LCTF_DIRTY;
926 if (!ctf_str_add_external (fp, str, offset))
929 ctf_dynhash_iter (fp->ctf_link_outputs, ctf_link_intern_extern_string,
938 /* Not yet implemented. */
940 ctf_link_shuffle_syms (ctf_file_t *fp _libctf_unused_,
941 ctf_link_iter_symbol_f *add_sym _libctf_unused_,
942 void *arg _libctf_unused_)
947 typedef struct ctf_name_list_accum_cb_arg
955 } ctf_name_list_accum_cb_arg_t;
957 /* Accumulate the names and a count of the names in the link output hash. */
959 ctf_accumulate_archive_names (void *key, void *value, void *arg_)
961 const char *name = (const char *) key;
962 ctf_file_t *fp = (ctf_file_t *) value;
965 ctf_name_list_accum_cb_arg_t *arg = (ctf_name_list_accum_cb_arg_t *) arg_;
967 if ((names = realloc (arg->names, sizeof (char *) * ++(arg->i))) == NULL)
970 ctf_set_errno (arg->fp, ENOMEM);
974 if ((files = realloc (arg->files, sizeof (ctf_file_t *) * arg->i)) == NULL)
977 ctf_set_errno (arg->fp, ENOMEM);
981 /* Allow the caller to get in and modify the name at the last minute. If the
982 caller *does* modify the name, we have to stash away the new name the
983 caller returned so we can free it later on. (The original name is the key
984 of the ctf_link_outputs hash and is freed by the dynhash machinery.) */
986 if (fp->ctf_link_memb_name_changer)
990 void *nc_arg = fp->ctf_link_memb_name_changer_arg;
992 dyname = fp->ctf_link_memb_name_changer (fp, name, nc_arg);
996 if ((dynames = realloc (arg->dynames,
997 sizeof (char *) * ++(arg->ndynames))) == NULL)
1000 ctf_set_errno (arg->fp, ENOMEM);
1003 arg->dynames = dynames;
1004 name = (const char *) dyname;
1009 arg->names[(arg->i) - 1] = (char *) name;
1011 arg->files[(arg->i) - 1] = fp;
1014 /* Change the name of the parent CTF section, if the name transformer has got to
1017 ctf_change_parent_name (void *key _libctf_unused_, void *value, void *arg)
1019 ctf_file_t *fp = (ctf_file_t *) value;
1020 const char *name = (const char *) arg;
1022 ctf_parent_name_set (fp, name);
1025 /* Write out a CTF archive (if there are per-CU CTF files) or a CTF file
1026 (otherwise) into a new dynamically-allocated string, and return it.
1027 Members with sizes above THRESHOLD are compressed. */
1029 ctf_link_write (ctf_file_t *fp, size_t *size, size_t threshold)
1031 ctf_name_list_accum_cb_arg_t arg;
1033 char *transformed_name = NULL;
1039 unsigned char *buf = NULL;
1041 memset (&arg, 0, sizeof (ctf_name_list_accum_cb_arg_t));
1044 if (fp->ctf_link_outputs)
1046 ctf_dynhash_iter (fp->ctf_link_outputs, ctf_accumulate_archive_names, &arg);
1047 if (ctf_errno (fp) < 0)
1049 errloc = "hash creation";
1054 /* No extra outputs? Just write a simple ctf_file_t. */
1056 return ctf_write_mem (fp, size, threshold);
1058 /* Writing an archive. Stick ourselves (the shared repository, parent of all
1059 other archives) on the front of it with the default name. */
1060 if ((names = realloc (arg.names, sizeof (char *) * (arg.i + 1))) == NULL)
1062 errloc = "name reallocation";
1066 memmove (&(arg.names[1]), arg.names, sizeof (char *) * (arg.i));
1068 arg.names[0] = (char *) _CTF_SECTION;
1069 if (fp->ctf_link_memb_name_changer)
1071 void *nc_arg = fp->ctf_link_memb_name_changer_arg;
1073 transformed_name = fp->ctf_link_memb_name_changer (fp, _CTF_SECTION,
1076 if (transformed_name != NULL)
1078 arg.names[0] = transformed_name;
1079 ctf_dynhash_iter (fp->ctf_link_outputs, ctf_change_parent_name,
1084 if ((files = realloc (arg.files,
1085 sizeof (struct ctf_file *) * (arg.i + 1))) == NULL)
1087 errloc = "ctf_file reallocation";
1091 memmove (&(arg.files[1]), arg.files, sizeof (ctf_file_t *) * (arg.i));
1094 if ((f = tmpfile ()) == NULL)
1096 errloc = "tempfile creation";
1100 if ((err = ctf_arc_write_fd (fileno (f), arg.files, arg.i + 1,
1101 (const char **) arg.names,
1104 errloc = "archive writing";
1105 ctf_set_errno (fp, err);
1109 if (fseek (f, 0, SEEK_END) < 0)
1111 errloc = "seeking to end";
1115 if ((fsize = ftell (f)) < 0)
1117 errloc = "filesize determination";
1121 if (fseek (f, 0, SEEK_SET) < 0)
1123 errloc = "filepos resetting";
1127 if ((buf = malloc (fsize)) == NULL)
1129 errloc = "CTF archive buffer allocation";
1133 while (!feof (f) && fread (buf, fsize, 1, f) == 0)
1136 errloc = "reading archive from temporary file";
1143 free (transformed_name);
1147 for (i = 0; i < arg.ndynames; i++)
1148 free (arg.dynames[i]);
1155 ctf_set_errno (fp, errno);
1162 free (transformed_name);
1166 for (i = 0; i < arg.ndynames; i++)
1167 free (arg.dynames[i]);
1170 ctf_err_warn (fp, 0, "Cannot write archive in link: %s failure: %s", errloc,
1171 ctf_errmsg (ctf_errno (fp)));