]> Git Repo - binutils.git/blob - libctf/ctf-link.c
libctf, link: add CTF_LINK_OMIT_VARIABLES_SECTION
[binutils.git] / libctf / ctf-link.c
1 /* CTF linking.
2    Copyright (C) 2019-2020 Free Software Foundation, Inc.
3
4    This file is part of libctf.
5
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
9    version.
10
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.
15
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/>.  */
19
20 #include <ctf-impl.h>
21 #include <string.h>
22
23 #if defined (PIC)
24 #pragma weak ctf_open
25 #endif
26
27 /* Type tracking machinery.  */
28
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.
35
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.  */
39
40 void
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)
43 {
44   if (LCTF_TYPE_ISPARENT (src_fp, src_type) && src_fp->ctf_parent)
45     src_fp = src_fp->ctf_parent;
46
47   src_type = LCTF_TYPE_TO_INDEX(src_fp, src_type);
48
49   if (LCTF_TYPE_ISPARENT (dst_fp, dst_type) && dst_fp->ctf_parent)
50     dst_fp = dst_fp->ctf_parent;
51
52   dst_type = LCTF_TYPE_TO_INDEX(dst_fp, dst_type);
53
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
56      functions.  */
57
58   if (dst_fp->ctf_link_type_mapping == NULL)
59     {
60       ctf_hash_fun f = ctf_hash_type_key;
61       ctf_hash_eq_fun e = ctf_hash_eq_type_key;
62
63       if ((dst_fp->ctf_link_type_mapping = ctf_dynhash_create (f, e, free,
64                                                                NULL)) == NULL)
65         return;
66     }
67
68   ctf_link_type_key_t *key;
69   key = calloc (1, sizeof (struct ctf_link_type_key));
70   if (!key)
71     return;
72
73   key->cltk_fp = src_fp;
74   key->cltk_idx = src_type;
75
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
78      anyway).  */
79   ctf_dynhash_insert (dst_fp->ctf_link_type_mapping, key,
80                       (void *) (uintptr_t) dst_type);
81 }
82
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.  */
85 ctf_id_t
86 ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type, ctf_file_t **dst_fp)
87 {
88   ctf_link_type_key_t key;
89   ctf_file_t *target_fp = *dst_fp;
90   ctf_id_t dst_type = 0;
91
92   if (LCTF_TYPE_ISPARENT (src_fp, src_type) && src_fp->ctf_parent)
93     src_fp = src_fp->ctf_parent;
94
95   src_type = LCTF_TYPE_TO_INDEX(src_fp, src_type);
96   key.cltk_fp = src_fp;
97   key.cltk_idx = src_type;
98
99   if (target_fp->ctf_link_type_mapping)
100     dst_type = (uintptr_t) ctf_dynhash_lookup (target_fp->ctf_link_type_mapping,
101                                                &key);
102
103   if (dst_type != 0)
104     {
105       dst_type = LCTF_INDEX_TO_TYPE (target_fp, dst_type,
106                                      target_fp->ctf_parent != NULL);
107       *dst_fp = target_fp;
108       return dst_type;
109     }
110
111   if (target_fp->ctf_parent)
112     target_fp = target_fp->ctf_parent;
113   else
114     return 0;
115
116   if (target_fp->ctf_link_type_mapping)
117     dst_type = (uintptr_t) ctf_dynhash_lookup (target_fp->ctf_link_type_mapping,
118                                                &key);
119
120   if (dst_type)
121     dst_type = LCTF_INDEX_TO_TYPE (target_fp, dst_type,
122                                    target_fp->ctf_parent != NULL);
123
124   *dst_fp = target_fp;
125   return dst_type;
126 }
127
128 /* Linker machinery.
129
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
142    output.  */
143
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.  */
147 const char *
148 ctf_link_input_name (ctf_file_t *fp)
149 {
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;
154   else
155     return "(unnamed)";
156 }
157
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
165 {
166   const char *clin_filename;
167   ctf_archive_t *clin_arc;
168   ctf_file_t *clin_fp;
169   int n;
170 } ctf_link_input_t;
171
172 static void
173 ctf_link_input_close (void *input)
174 {
175   ctf_link_input_t *i = (ctf_link_input_t *) input;
176   if (i->clin_arc)
177     ctf_arc_close (i->clin_arc);
178   free (i);
179 }
180
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.  */
183 static int
184 ctf_link_add_ctf_internal (ctf_file_t *fp, ctf_archive_t *ctf,
185                            ctf_file_t *fp_input, const char *name)
186 {
187   ctf_link_input_t *input = NULL;
188   char *dupname = NULL;
189
190   if ((input = calloc (1, sizeof (ctf_link_input_t))) == NULL)
191     goto oom;
192
193   if ((dupname = strdup (name)) == NULL)
194     goto oom;
195
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);
200
201   if (ctf_dynhash_insert (fp->ctf_link_inputs, dupname, input) < 0)
202     goto oom;
203
204   return 0;
205  oom:
206   free (input);
207   free (dupname);
208   return ctf_set_errno (fp, ENOMEM);
209 }
210
211 /* Add a file, memory buffer, or unopened file (by name) to a link.
212
213    You can call this with:
214
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
218     yet implemented.)
219
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.
223
224     The order of calls to this function influences the order of types in the
225     final link output, but otherwise is not important.
226
227     Private for now, but may in time become public once support for BUF is
228     implemented.  */
229
230 static int
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_)
233 {
234   if (buf)
235     return (ctf_set_errno (fp, ECTF_NOTYET));
236
237   if (!((ctf && name && !buf)
238         || (name && !buf && !ctf)
239         || (buf && name && !ctf)))
240     return (ctf_set_errno (fp, EINVAL));
241
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.  */
246
247 #if defined (PIC)
248   if (!buf && !ctf && name && !ctf_open)
249     return (ctf_set_errno (fp, ECTF_NEEDSBFD));
250 #elif NOBFD
251   if (!buf && !ctf && name)
252     return (ctf_set_errno (fp, ECTF_NEEDSBFD));
253 #endif
254
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);
261
262   if (fp->ctf_link_inputs == NULL)
263     return (ctf_set_errno (fp, ENOMEM));
264
265   return ctf_link_add_ctf_internal (fp, ctf, NULL, name);
266 }
267
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.
271
272     Passed in CTF args are owned by the dictionary and will be freed by it.
273
274     The order of calls to this function influences the order of types in the
275     final link output, but otherwise is not important.  */
276
277 int
278 ctf_link_add_ctf (ctf_file_t *fp, ctf_archive_t *ctf, const char *name)
279 {
280   return ctf_link_add (fp, ctf, name, NULL, 0);
281 }
282
283 /* Return a per-CU output CTF dictionary suitable for the given CU, creating and
284    interning it if need be.  */
285
286 static ctf_file_t *
287 ctf_create_per_cu (ctf_file_t *fp, const char *filename, const char *cuname)
288 {
289   ctf_file_t *cu_fp;
290   const char *ctf_name = NULL;
291   char *dynname = NULL;
292
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.  */
298
299   if (fp->ctf_link_in_cu_mapping)
300     {
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,
304                                            cuname)) == NULL))
305         ctf_name = filename;
306     }
307
308   if (ctf_name == NULL)
309     ctf_name = filename;
310
311   if ((cu_fp = ctf_dynhash_lookup (fp->ctf_link_outputs, ctf_name)) == NULL)
312     {
313       int err;
314
315       if ((cu_fp = ctf_create (&err)) == NULL)
316         {
317           ctf_err_warn (fp, 0, "Cannot create per-CU CTF archive for "
318                         "CU %s from input file %s: %s", cuname, filename,
319                         ctf_errmsg (err));
320           ctf_set_errno (fp, err);
321           return NULL;
322         }
323
324       if ((dynname = strdup (ctf_name)) == NULL)
325         goto oom;
326       if (ctf_dynhash_insert (fp->ctf_link_outputs, dynname, cu_fp) < 0)
327         goto oom;
328
329       ctf_import_unref (cu_fp, fp);
330       ctf_cuname_set (cu_fp, cuname);
331       ctf_parent_name_set (cu_fp, _CTF_SECTION);
332     }
333   return cu_fp;
334
335  oom:
336   free (dynname);
337   ctf_file_close (cu_fp);
338   ctf_set_errno (fp, ENOMEM);
339   return NULL;
340 }
341
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.
345
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.  */
349
350 int
351 ctf_link_add_cu_mapping (ctf_file_t *fp, const char *from, const char *to)
352 {
353   int err;
354   char *f = NULL, *t = NULL;
355   ctf_dynhash_t *one_out;
356
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,
360                                                      free);
361   if (fp->ctf_link_in_cu_mapping == NULL)
362     goto oom;
363
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,
367                                                       (ctf_hash_free_fun)
368                                                       ctf_dynhash_destroy);
369   if (fp->ctf_link_out_cu_mapping == NULL)
370     goto oom;
371
372   f = strdup (from);
373   t = strdup (to);
374   if (!f || !t)
375     goto oom;
376
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.  */
381
382   if ((err = ctf_dynhash_insert (fp->ctf_link_in_cu_mapping, f, t)) < 0)
383     {
384       ctf_set_errno (fp, err);
385       goto oom_noerrno;
386     }
387
388   /* f and t are now owned by the in_cu_mapping: reallocate them.  */
389   f = strdup (from);
390   t = strdup (to);
391   if (!f || !t)
392     goto oom;
393
394   if ((one_out = ctf_dynhash_lookup (fp->ctf_link_out_cu_mapping, t)) == NULL)
395     {
396       if ((one_out = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
397                                          free, NULL)) == NULL)
398         goto oom;
399       if ((err = ctf_dynhash_insert (fp->ctf_link_out_cu_mapping,
400                                      t, one_out)) < 0)
401         {
402           ctf_dynhash_destroy (one_out);
403           ctf_set_errno (fp, err);
404           goto oom_noerrno;
405         }
406     }
407   else
408     free (t);
409
410   if (ctf_dynhash_insert (one_out, f, NULL) < 0)
411     {
412       ctf_set_errno (fp, err);
413       goto oom_noerrno;
414     }
415
416   return 0;
417
418  oom:
419   ctf_set_errno (fp, errno);
420  oom_noerrno:
421   free (f);
422   free (t);
423   return -1;
424 }
425
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.  */
433 void
434 ctf_link_set_memb_name_changer (ctf_file_t *fp,
435                                 ctf_link_memb_name_changer_f *changer,
436                                 void *arg)
437 {
438   fp->ctf_link_memb_name_changer = changer;
439   fp->ctf_link_memb_name_changer_arg = arg;
440 }
441
442 typedef struct ctf_link_in_member_cb_arg
443 {
444   /* The shared output dictionary.  */
445   ctf_file_t *out_fp;
446
447   /* The filename of the input file, and an fp to each dictionary in that file
448      in turn.  */
449   const char *in_file_name;
450   ctf_file_t *in_fp;
451
452   /* The CU name of the dict being processed.  */
453   const char *cu_name;
454   int in_input_cu_file;
455
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
458      layers.  */
459   ctf_file_t *in_fp_parent;
460   int done_parent;
461
462   /* If true, this is the CU-mapped portion of a deduplicating link: no child
463      dictionaries should be created.  */
464   int cu_mapped;
465 } ctf_link_in_member_cb_arg_t;
466
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.  */
470
471 static int
472 ctf_link_one_type (ctf_id_t type, int isroot _libctf_unused_, void *arg_)
473 {
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;
476   int err;
477
478   if (arg->in_fp->ctf_link_flags != CTF_LINK_SHARE_UNCONFLICTED)
479     {
480       ctf_err_warn (arg->out_fp, 0, "Share-duplicated mode not yet implemented");
481       return ctf_set_errno (arg->out_fp, ECTF_NOTYET);
482     }
483
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.  */
488
489   if (!arg->in_input_cu_file)
490     {
491       if (ctf_add_type (arg->out_fp, arg->in_fp, type) != CTF_ERR)
492         return 0;
493
494       err = ctf_errno (arg->out_fp);
495       if (err != ECTF_CONFLICT)
496         {
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
503              much as possible.  */
504           return 0;
505         }
506       ctf_set_errno (arg->out_fp, 0);
507     }
508
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.  */
512
513   if (ctf_add_type (per_cu_out_fp, arg->in_fp, type) != CTF_ERR)
514     return 0;
515
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);
527
528   return 0;                                     /* As above: do not lose types.  */
529 }
530
531 /* Set a function which is used to filter out unwanted variables from the link.  */
532 int
533 ctf_link_set_variable_filter (ctf_file_t *fp, ctf_link_variable_filter_f *filter,
534                               void *arg)
535 {
536   fp->ctf_link_variable_filter = filter;
537   fp->ctf_link_variable_filter_arg = arg;
538   return 0;
539 }
540
541 /* Check if we can safely add a variable with the given type to this container.  */
542
543 static int
544 check_variable (const char *name, ctf_file_t *fp, ctf_id_t type,
545                 ctf_dvdef_t **out_dvd)
546 {
547   ctf_dvdef_t *dvd;
548
549   dvd = ctf_dynhash_lookup (fp->ctf_dvhash, name);
550   *out_dvd = dvd;
551   if (!dvd)
552     return 1;
553
554   if (dvd->dvd_type != type)
555     {
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);
561     }
562
563   return 0;                                   /* Already exists.  */
564 }
565
566 /* Link one variable in.  */
567
568 static int
569 ctf_link_one_variable (const char *name, ctf_id_t type, void *arg_)
570 {
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;
575   ctf_dvdef_t *dvd;
576
577   /* See if this variable is filtered out.  */
578
579   if (arg->out_fp->ctf_link_variable_filter)
580     {
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))
583         return 0;
584     }
585
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.  */
589
590   check_fp = arg->out_fp;
591
592   dst_type = ctf_type_mapping (arg->in_fp, type, &check_fp);
593   if (dst_type != 0)
594     {
595       if (check_fp == arg->out_fp)
596         {
597           if (check_variable (name, check_fp, dst_type, &dvd))
598             {
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)));
602               return 0;
603             }
604
605           /* Already present?  Nothing to do.  */
606           if (dvd && dvd->dvd_type == dst_type)
607             return 0;
608         }
609     }
610
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.  */
615
616   if (arg->cu_mapped)
617     {
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,
620                    type);
621       return 0;
622     }
623
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.  */
627
628   /* If the type was not found, check for it in the child too. */
629   if (dst_type == 0)
630     {
631       check_fp = per_cu_out_fp;
632       dst_type = ctf_type_mapping (arg->in_fp, type, &check_fp);
633
634       if (dst_type == 0)
635         {
636           ctf_err_warn (arg->out_fp, 1, "Type %lx for variable %s in input "
637                         "file %s not found: skipped", type, name,
638                         arg->in_file_name);
639           /* Do not terminate the link: just skip the variable.  */
640           return 0;
641         }
642     }
643
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)));
647   return 0;
648 }
649
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.  */
655 static int
656 ctf_link_one_input_archive_member (ctf_file_t *in_fp, const char *name, void *arg_)
657 {
658   ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_;
659   int err = 0;
660
661   if (strcmp (name, _CTF_SECTION) == 0)
662     {
663       /* This file is the default member of this archive, and has already been
664          explicitly processed.
665
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.  */
671
672       if (arg->done_parent)
673         return 0;
674     }
675   else
676     {
677       /* Get ambiguous types from our parent.  */
678       ctf_import (in_fp, arg->in_fp_parent);
679       arg->in_input_cu_file = 1;
680     }
681
682   arg->cu_name = name;
683   if (strncmp (arg->cu_name, ".ctf.", strlen (".ctf.")) == 0)
684     arg->cu_name += strlen (".ctf.");
685   arg->in_fp = in_fp;
686
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);
690
691   arg->in_input_cu_file = 0;
692
693   if (err < 0)
694       return -1;                                /* Errno is set for us.  */
695
696   return 0;
697 }
698
699 /* Dump the unnecessary link type mapping after one input file is processed.  */
700 static void
701 empty_link_type_mapping (void *key _libctf_unused_, void *value,
702                          void *arg _libctf_unused_)
703 {
704   ctf_file_t *fp = (ctf_file_t *) value;
705
706   if (fp->ctf_link_type_mapping)
707     ctf_dynhash_empty (fp->ctf_link_type_mapping);
708 }
709
710 /* Lazily open a CTF archive for linking, if not already open.
711
712    Returns the number of files contained within the opened archive (0 for none),
713    or -1 on error, as usual.  */
714 static ssize_t
715 ctf_link_lazy_open (ctf_file_t *fp, ctf_link_input_t *input)
716 {
717   size_t count;
718   int err;
719
720   if (input->clin_arc)
721     return ctf_archive_count (input->clin_arc);
722
723   if (input->clin_fp)
724     return 1;
725
726   /* See ctf_link_add_ctf.  */
727 #if defined (PIC) || !NOBFD
728   input->clin_arc = ctf_open (input->clin_filename, NULL, &err);
729 #else
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);
733   return -1;
734 #endif
735
736   /* Having no CTF sections is not an error.  We just don't need to do
737      anything.  */
738
739   if (!input->clin_arc)
740     {
741       if (err == ECTF_NOCTFDATA)
742         return 0;
743
744       ctf_err_warn (fp, 0, "Opening CTF %s failed: %s",
745                     input->clin_filename, ctf_errmsg (err));
746       ctf_set_errno (fp, err);
747       return -1;
748     }
749
750   if ((count = ctf_archive_count (input->clin_arc)) == 0)
751     ctf_arc_close (input->clin_arc);
752
753   return (ssize_t) count;
754 }
755
756 /* Close an input, as a ctf_dynhash_iter iterator.  */
757 static void
758 ctf_link_close_one_input_archive (void *key _libctf_unused_, void *value,
759                                   void *arg _libctf_unused_)
760 {
761   ctf_link_input_t *input = (ctf_link_input_t *) value;
762   if (input->clin_arc)
763     ctf_arc_close (input->clin_arc);
764   input->clin_arc = NULL;
765 }
766
767 /* Link one input file's types into the output file.  */
768 static void
769 ctf_link_one_input_archive (void *key, void *value, void *arg_)
770 {
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_;
774   int err = 0;
775
776   if (!input->clin_arc)
777     {
778       err = ctf_link_lazy_open (arg->out_fp, input);
779       if (err == 0)                             /* Just no CTF.  */
780         return;
781
782       if (err < 0)
783         return;                                 /* errno is set for us.  */
784     }
785
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,
789                                                  &err)) == NULL)
790     if (err != ECTF_ARNNAME)
791       {
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));
795         goto out;
796       }
797
798   if (ctf_link_one_input_archive_member (arg->in_fp_parent,
799                                          _CTF_SECTION, arg) < 0)
800     {
801       ctf_file_close (arg->in_fp_parent);
802       goto out;
803     }
804   arg->done_parent = 1;
805   if (ctf_archive_iter (input->clin_arc, ctf_link_one_input_archive_member,
806                         arg) < 0)
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)));
810   else
811     {
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);
815     }
816   ctf_file_close (arg->in_fp_parent);
817
818  out:
819   ctf_link_close_one_input_archive (key, value, NULL);
820 }
821
822 /* Merge types and variable sections in all files added to the link
823    together.  All the added files are closed.  */
824 int
825 ctf_link (ctf_file_t *fp, int flags)
826 {
827   ctf_link_in_member_cb_arg_t arg;
828   ctf_next_t *i = NULL;
829   int err;
830
831   memset (&arg, 0, sizeof (struct ctf_link_in_member_cb_arg));
832   arg.out_fp = fp;
833   fp->ctf_link_flags = flags;
834
835   if (fp->ctf_link_inputs == NULL)
836     return 0;                                   /* Nothing to do. */
837
838   if (fp->ctf_link_outputs == NULL)
839     fp->ctf_link_outputs = ctf_dynhash_create (ctf_hash_string,
840                                                ctf_hash_eq_string, free,
841                                                (ctf_hash_free_fun)
842                                                ctf_file_close);
843
844   if (fp->ctf_link_outputs == NULL)
845     return ctf_set_errno (fp, ENOMEM);
846
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.  */
850
851   if (fp->ctf_link_out_cu_mapping && (flags & CTF_LINK_EMPTY_CU_MAPPINGS))
852     {
853       void *v;
854
855       while ((err = ctf_dynhash_next (fp->ctf_link_out_cu_mapping, &i, &v,
856                                       NULL)) == 0)
857         {
858           const char *to = (const char *) v;
859           if (ctf_create_per_cu (fp, to, to) == NULL)
860             {
861               ctf_next_destroy (i);
862               return -1;                        /* Errno is set for us.  */
863             }
864         }
865       if (err != ECTF_NEXT_END)
866         {
867           ctf_err_warn (fp, 1, "Iteration error creating empty CUs: %s",
868                         ctf_errmsg (err));
869           ctf_set_errno (fp, err);
870           return -1;
871         }
872     }
873
874   ctf_dynhash_iter (fp->ctf_link_inputs, ctf_link_one_input_archive,
875                     &arg);
876
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);
881
882   if ((ctf_errno (fp) != 0) && (ctf_errno (fp) != ECTF_NOCTFDATA))
883     return -1;
884   return 0;
885 }
886
887 typedef struct ctf_link_out_string_cb_arg
888 {
889   const char *str;
890   uint32_t offset;
891   int err;
892 } ctf_link_out_string_cb_arg_t;
893
894 /* Intern a string in the string table of an output per-CU CTF file.  */
895 static void
896 ctf_link_intern_extern_string (void *key _libctf_unused_, void *value,
897                                void *arg_)
898 {
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_;
901
902   fp->ctf_flags |= LCTF_DIRTY;
903   if (!ctf_str_add_external (fp, arg->str, arg->offset))
904     arg->err = ENOMEM;
905 }
906
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.
909
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
912    strtab properly.  */
913 int
914 ctf_link_add_strtab (ctf_file_t *fp, ctf_link_strtab_string_f *add_string,
915                      void *arg)
916 {
917   const char *str;
918   uint32_t offset;
919   int err = 0;
920
921   while ((str = add_string (&offset, arg)) != NULL)
922     {
923       ctf_link_out_string_cb_arg_t iter_arg = { str, offset, 0 };
924
925       fp->ctf_flags |= LCTF_DIRTY;
926       if (!ctf_str_add_external (fp, str, offset))
927         err = ENOMEM;
928
929       ctf_dynhash_iter (fp->ctf_link_outputs, ctf_link_intern_extern_string,
930                         &iter_arg);
931       if (iter_arg.err)
932         err = iter_arg.err;
933     }
934
935   return -err;
936 }
937
938 /* Not yet implemented.  */
939 int
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_)
943 {
944   return 0;
945 }
946
947 typedef struct ctf_name_list_accum_cb_arg
948 {
949   char **names;
950   ctf_file_t *fp;
951   ctf_file_t **files;
952   size_t i;
953   char **dynames;
954   size_t ndynames;
955 } ctf_name_list_accum_cb_arg_t;
956
957 /* Accumulate the names and a count of the names in the link output hash.  */
958 static void
959 ctf_accumulate_archive_names (void *key, void *value, void *arg_)
960 {
961   const char *name = (const char *) key;
962   ctf_file_t *fp = (ctf_file_t *) value;
963   char **names;
964   ctf_file_t **files;
965   ctf_name_list_accum_cb_arg_t *arg = (ctf_name_list_accum_cb_arg_t *) arg_;
966
967   if ((names = realloc (arg->names, sizeof (char *) * ++(arg->i))) == NULL)
968     {
969       (arg->i)--;
970       ctf_set_errno (arg->fp, ENOMEM);
971       return;
972     }
973
974   if ((files = realloc (arg->files, sizeof (ctf_file_t *) * arg->i)) == NULL)
975     {
976       (arg->i)--;
977       ctf_set_errno (arg->fp, ENOMEM);
978       return;
979     }
980
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.)  */
985
986   if (fp->ctf_link_memb_name_changer)
987     {
988       char **dynames;
989       char *dyname;
990       void *nc_arg = fp->ctf_link_memb_name_changer_arg;
991
992       dyname = fp->ctf_link_memb_name_changer (fp, name, nc_arg);
993
994       if (dyname != NULL)
995         {
996           if ((dynames = realloc (arg->dynames,
997                                   sizeof (char *) * ++(arg->ndynames))) == NULL)
998             {
999               (arg->ndynames)--;
1000               ctf_set_errno (arg->fp, ENOMEM);
1001               return;
1002             }
1003             arg->dynames = dynames;
1004             name = (const char *) dyname;
1005         }
1006     }
1007
1008   arg->names = names;
1009   arg->names[(arg->i) - 1] = (char *) name;
1010   arg->files = files;
1011   arg->files[(arg->i) - 1] = fp;
1012 }
1013
1014 /* Change the name of the parent CTF section, if the name transformer has got to
1015    it.  */
1016 static void
1017 ctf_change_parent_name (void *key _libctf_unused_, void *value, void *arg)
1018 {
1019   ctf_file_t *fp = (ctf_file_t *) value;
1020   const char *name = (const char *) arg;
1021
1022   ctf_parent_name_set (fp, name);
1023 }
1024
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.  */
1028 unsigned char *
1029 ctf_link_write (ctf_file_t *fp, size_t *size, size_t threshold)
1030 {
1031   ctf_name_list_accum_cb_arg_t arg;
1032   char **names;
1033   char *transformed_name = NULL;
1034   ctf_file_t **files;
1035   FILE *f = NULL;
1036   int err;
1037   long fsize;
1038   const char *errloc;
1039   unsigned char *buf = NULL;
1040
1041   memset (&arg, 0, sizeof (ctf_name_list_accum_cb_arg_t));
1042   arg.fp = fp;
1043
1044   if (fp->ctf_link_outputs)
1045     {
1046       ctf_dynhash_iter (fp->ctf_link_outputs, ctf_accumulate_archive_names, &arg);
1047       if (ctf_errno (fp) < 0)
1048         {
1049           errloc = "hash creation";
1050           goto err;
1051         }
1052     }
1053
1054   /* No extra outputs? Just write a simple ctf_file_t.  */
1055   if (arg.i == 0)
1056     return ctf_write_mem (fp, size, threshold);
1057
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)
1061     {
1062       errloc = "name reallocation";
1063       goto err_no;
1064     }
1065   arg.names = names;
1066   memmove (&(arg.names[1]), arg.names, sizeof (char *) * (arg.i));
1067
1068   arg.names[0] = (char *) _CTF_SECTION;
1069   if (fp->ctf_link_memb_name_changer)
1070     {
1071       void *nc_arg = fp->ctf_link_memb_name_changer_arg;
1072
1073       transformed_name = fp->ctf_link_memb_name_changer (fp, _CTF_SECTION,
1074                                                          nc_arg);
1075
1076       if (transformed_name != NULL)
1077         {
1078           arg.names[0] = transformed_name;
1079           ctf_dynhash_iter (fp->ctf_link_outputs, ctf_change_parent_name,
1080                             transformed_name);
1081         }
1082     }
1083
1084   if ((files = realloc (arg.files,
1085                         sizeof (struct ctf_file *) * (arg.i + 1))) == NULL)
1086     {
1087       errloc = "ctf_file reallocation";
1088       goto err_no;
1089     }
1090   arg.files = files;
1091   memmove (&(arg.files[1]), arg.files, sizeof (ctf_file_t *) * (arg.i));
1092   arg.files[0] = fp;
1093
1094   if ((f = tmpfile ()) == NULL)
1095     {
1096       errloc = "tempfile creation";
1097       goto err_no;
1098     }
1099
1100   if ((err = ctf_arc_write_fd (fileno (f), arg.files, arg.i + 1,
1101                                (const char **) arg.names,
1102                                threshold)) < 0)
1103     {
1104       errloc = "archive writing";
1105       ctf_set_errno (fp, err);
1106       goto err;
1107     }
1108
1109   if (fseek (f, 0, SEEK_END) < 0)
1110     {
1111       errloc = "seeking to end";
1112       goto err_no;
1113     }
1114
1115   if ((fsize = ftell (f)) < 0)
1116     {
1117       errloc = "filesize determination";
1118       goto err_no;
1119     }
1120
1121   if (fseek (f, 0, SEEK_SET) < 0)
1122     {
1123       errloc = "filepos resetting";
1124       goto err_no;
1125     }
1126
1127   if ((buf = malloc (fsize)) == NULL)
1128     {
1129       errloc = "CTF archive buffer allocation";
1130       goto err_no;
1131     }
1132
1133   while (!feof (f) && fread (buf, fsize, 1, f) == 0)
1134     if (ferror (f))
1135       {
1136         errloc = "reading archive from temporary file";
1137         goto err_no;
1138       }
1139
1140   *size = fsize;
1141   free (arg.names);
1142   free (arg.files);
1143   free (transformed_name);
1144   if (arg.ndynames)
1145     {
1146       size_t i;
1147       for (i = 0; i < arg.ndynames; i++)
1148         free (arg.dynames[i]);
1149       free (arg.dynames);
1150     }
1151   fclose (f);
1152   return buf;
1153
1154  err_no:
1155   ctf_set_errno (fp, errno);
1156  err:
1157   free (buf);
1158   if (f)
1159     fclose (f);
1160   free (arg.names);
1161   free (arg.files);
1162   free (transformed_name);
1163   if (arg.ndynames)
1164     {
1165       size_t i;
1166       for (i = 0; i < arg.ndynames; i++)
1167         free (arg.dynames[i]);
1168       free (arg.dynames);
1169     }
1170   ctf_err_warn (fp, 0, "Cannot write archive in link: %s failure: %s", errloc,
1171                 ctf_errmsg (ctf_errno (fp)));
1172   return NULL;
1173 }
This page took 0.097335 seconds and 4 git commands to generate.