123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935 |
- /* CTF linking.
- Copyright (C) 2019-2022 Free Software Foundation, Inc.
- This file is part of libctf.
- libctf is free software; you can redistribute it and/or modify it under
- the terms of the GNU General Public License as published by the Free
- Software Foundation; either version 3, or (at your option) any later
- version.
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- See the GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING. If not see
- <http://www.gnu.org/licenses/>. */
- #include <ctf-impl.h>
- #include <string.h>
- #if defined (PIC)
- #pragma weak ctf_open
- #endif
- /* CTF linking consists of adding CTF archives full of content to be merged into
- this one to the current file (which must be writable) by calling
- ctf_link_add_ctf. Once this is done, a call to ctf_link will merge the type
- tables together, generating new CTF files as needed, with this one as a
- parent, to contain types from the inputs which conflict. ctf_link_add_strtab
- takes a callback which provides string/offset pairs to be added to the
- external symbol table and deduplicated from all CTF string tables in the
- output link; ctf_link_shuffle_syms takes a callback which provides symtab
- entries in ascending order, and shuffles the function and data sections to
- match; and ctf_link_write emits a CTF file (if there are no conflicts
- requiring per-compilation-unit sub-CTF files) or CTF archives (otherwise) and
- returns it, suitable for addition in the .ctf section of the output. */
- /* Return the name of the compilation unit this CTF dict or its parent applies
- to, or a non-null string otherwise: prefer the parent. Used in debugging
- output. Sometimes used for outputs too. */
- const char *
- ctf_link_input_name (ctf_dict_t *fp)
- {
- if (fp->ctf_parent && fp->ctf_parent->ctf_cuname)
- return fp->ctf_parent->ctf_cuname;
- else if (fp->ctf_cuname)
- return fp->ctf_cuname;
- else
- return "(unnamed)";
- }
- /* Return the cuname of a dict, or the string "unnamed-CU" if none. */
- static const char *
- ctf_unnamed_cuname (ctf_dict_t *fp)
- {
- const char *cuname = ctf_cuname (fp);
- if (!cuname)
- cuname = "unnamed-CU";
- return cuname;
- }
- /* The linker inputs look like this. clin_fp is used for short-circuited
- CU-mapped links that can entirely avoid the first link phase in some
- situations in favour of just passing on the contained ctf_dict_t: it is
- always the sole ctf_dict_t inside the corresponding clin_arc. If set, it
- gets assigned directly to the final link inputs and freed from there, so it
- never gets explicitly freed in the ctf_link_input. */
- typedef struct ctf_link_input
- {
- const char *clin_filename;
- ctf_archive_t *clin_arc;
- ctf_dict_t *clin_fp;
- int n;
- } ctf_link_input_t;
- static void
- ctf_link_input_close (void *input)
- {
- ctf_link_input_t *i = (ctf_link_input_t *) input;
- if (i->clin_arc)
- ctf_arc_close (i->clin_arc);
- free (i);
- }
- /* Like ctf_link_add_ctf, below, but with no error-checking, so it can be called
- in the middle of an ongoing link. */
- static int
- ctf_link_add_ctf_internal (ctf_dict_t *fp, ctf_archive_t *ctf,
- ctf_dict_t *fp_input, const char *name)
- {
- ctf_link_input_t *input = NULL;
- char *dupname = NULL;
- if ((input = calloc (1, sizeof (ctf_link_input_t))) == NULL)
- goto oom;
- if ((dupname = strdup (name)) == NULL)
- goto oom;
- input->clin_arc = ctf;
- input->clin_fp = fp_input;
- input->clin_filename = dupname;
- input->n = ctf_dynhash_elements (fp->ctf_link_inputs);
- if (ctf_dynhash_insert (fp->ctf_link_inputs, dupname, input) < 0)
- goto oom;
- return 0;
- oom:
- free (input);
- free (dupname);
- return ctf_set_errno (fp, ENOMEM);
- }
- /* Add a file, memory buffer, or unopened file (by name) to a link.
- You can call this with:
- CTF and NAME: link the passed ctf_archive_t, with the given NAME.
- NAME alone: open NAME as a CTF file when needed.
- BUF and NAME: open the BUF (of length N) as CTF, with the given NAME. (Not
- yet implemented.)
- Passed in CTF args are owned by the dictionary and will be freed by it.
- The BUF arg is *not* owned by the dictionary, and the user should not free
- its referent until the link is done.
- The order of calls to this function influences the order of types in the
- final link output, but otherwise is not important.
- Private for now, but may in time become public once support for BUF is
- implemented. */
- static int
- ctf_link_add (ctf_dict_t *fp, ctf_archive_t *ctf, const char *name,
- void *buf _libctf_unused_, size_t n _libctf_unused_)
- {
- if (buf)
- return (ctf_set_errno (fp, ECTF_NOTYET));
- if (!((ctf && name && !buf)
- || (name && !buf && !ctf)
- || (buf && name && !ctf)))
- return (ctf_set_errno (fp, EINVAL));
- /* We can only lazily open files if libctf.so is in use rather than
- libctf-nobfd.so. This is a little tricky: in shared libraries, we can use
- a weak symbol so that -lctf -lctf-nobfd works, but in static libraries we
- must distinguish between the two libraries explicitly. */
- #if defined (PIC)
- if (!buf && !ctf && name && !ctf_open)
- return (ctf_set_errno (fp, ECTF_NEEDSBFD));
- #elif NOBFD
- if (!buf && !ctf && name)
- return (ctf_set_errno (fp, ECTF_NEEDSBFD));
- #endif
- if (fp->ctf_link_outputs)
- return (ctf_set_errno (fp, ECTF_LINKADDEDLATE));
- if (fp->ctf_link_inputs == NULL)
- fp->ctf_link_inputs = ctf_dynhash_create (ctf_hash_string,
- ctf_hash_eq_string, free,
- ctf_link_input_close);
- if (fp->ctf_link_inputs == NULL)
- return (ctf_set_errno (fp, ENOMEM));
- return ctf_link_add_ctf_internal (fp, ctf, NULL, name);
- }
- /* Add an opened CTF archive or unopened file (by name) to a link.
- If CTF is NULL and NAME is non-null, an unopened file is meant:
- otherwise, the specified archive is assumed to have the given NAME.
- Passed in CTF args are owned by the dictionary and will be freed by it.
- The order of calls to this function influences the order of types in the
- final link output, but otherwise is not important. */
- int
- ctf_link_add_ctf (ctf_dict_t *fp, ctf_archive_t *ctf, const char *name)
- {
- return ctf_link_add (fp, ctf, name, NULL, 0);
- }
- /* Lazily open a CTF archive for linking, if not already open.
- Returns the number of files contained within the opened archive (0 for none),
- or -1 on error, as usual. */
- static ssize_t
- ctf_link_lazy_open (ctf_dict_t *fp, ctf_link_input_t *input)
- {
- size_t count;
- int err;
- if (input->clin_arc)
- return ctf_archive_count (input->clin_arc);
- if (input->clin_fp)
- return 1;
- /* See ctf_link_add_ctf. */
- #if defined (PIC) || !NOBFD
- input->clin_arc = ctf_open (input->clin_filename, NULL, &err);
- #else
- ctf_err_warn (fp, 0, ECTF_NEEDSBFD, _("cannot open %s lazily"),
- input->clin_filename);
- ctf_set_errno (fp, ECTF_NEEDSBFD);
- return -1;
- #endif
- /* Having no CTF sections is not an error. We just don't need to do
- anything. */
- if (!input->clin_arc)
- {
- if (err == ECTF_NOCTFDATA)
- return 0;
- ctf_err_warn (fp, 0, err, _("opening CTF %s failed"),
- input->clin_filename);
- ctf_set_errno (fp, err);
- return -1;
- }
- if ((count = ctf_archive_count (input->clin_arc)) == 0)
- ctf_arc_close (input->clin_arc);
- return (ssize_t) count;
- }
- /* Return a per-CU output CTF dictionary suitable for the given CU, creating and
- interning it if need be. */
- _libctf_nonnull_((1,2))
- static ctf_dict_t *
- ctf_create_per_cu (ctf_dict_t *fp, const char *cu_name)
- {
- ctf_dict_t *cu_fp;
- const char *ctf_name = NULL;
- char *dynname = NULL;
- /* First, check the mapping table and translate the per-CU name we use
- accordingly. */
- if (fp->ctf_link_in_cu_mapping)
- {
- if ((ctf_name = ctf_dynhash_lookup (fp->ctf_link_in_cu_mapping,
- cu_name)) == NULL)
- ctf_name = cu_name;
- }
- if (ctf_name == NULL)
- ctf_name = cu_name;
- if ((cu_fp = ctf_dynhash_lookup (fp->ctf_link_outputs, ctf_name)) == NULL)
- {
- int err;
- if ((cu_fp = ctf_create (&err)) == NULL)
- {
- ctf_err_warn (fp, 0, err, _("cannot create per-CU CTF archive for "
- "input CU %s"), cu_name);
- ctf_set_errno (fp, err);
- return NULL;
- }
- if ((dynname = strdup (ctf_name)) == NULL)
- goto oom;
- if (ctf_dynhash_insert (fp->ctf_link_outputs, dynname, cu_fp) < 0)
- goto oom;
- ctf_import_unref (cu_fp, fp);
- ctf_cuname_set (cu_fp, cu_name);
- ctf_parent_name_set (cu_fp, _CTF_SECTION);
- }
- return cu_fp;
- oom:
- free (dynname);
- ctf_dict_close (cu_fp);
- ctf_set_errno (fp, ENOMEM);
- return NULL;
- }
- /* Add a mapping directing that the CU named FROM should have its
- conflicting/non-duplicate types (depending on link mode) go into a dict
- named TO. Many FROMs can share a TO.
- We forcibly add a dict named TO in every case, even though it may well
- wind up empty, because clients that use this facility usually expect to find
- every TO dict present, even if empty, and malfunction otherwise. */
- int
- ctf_link_add_cu_mapping (ctf_dict_t *fp, const char *from, const char *to)
- {
- int err;
- char *f = NULL, *t = NULL;
- ctf_dynhash_t *one_out;
- if (fp->ctf_link_in_cu_mapping == NULL)
- fp->ctf_link_in_cu_mapping = ctf_dynhash_create (ctf_hash_string,
- ctf_hash_eq_string, free,
- free);
- if (fp->ctf_link_in_cu_mapping == NULL)
- goto oom;
- if (fp->ctf_link_out_cu_mapping == NULL)
- fp->ctf_link_out_cu_mapping = ctf_dynhash_create (ctf_hash_string,
- ctf_hash_eq_string, free,
- (ctf_hash_free_fun)
- ctf_dynhash_destroy);
- if (fp->ctf_link_out_cu_mapping == NULL)
- goto oom;
- f = strdup (from);
- t = strdup (to);
- if (!f || !t)
- goto oom;
- /* Track both in a list from FROM to TO and in a list from TO to a list of
- FROM. The former is used to create TUs with the mapped-to name at need:
- the latter is used in deduplicating links to pull in all input CUs
- corresponding to a single output CU. */
- if ((err = ctf_dynhash_insert (fp->ctf_link_in_cu_mapping, f, t)) < 0)
- {
- ctf_set_errno (fp, err);
- goto oom_noerrno;
- }
- /* f and t are now owned by the in_cu_mapping: reallocate them. */
- f = strdup (from);
- t = strdup (to);
- if (!f || !t)
- goto oom;
- if ((one_out = ctf_dynhash_lookup (fp->ctf_link_out_cu_mapping, t)) == NULL)
- {
- if ((one_out = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
- free, NULL)) == NULL)
- goto oom;
- if ((err = ctf_dynhash_insert (fp->ctf_link_out_cu_mapping,
- t, one_out)) < 0)
- {
- ctf_dynhash_destroy (one_out);
- ctf_set_errno (fp, err);
- goto oom_noerrno;
- }
- }
- else
- free (t);
- if (ctf_dynhash_insert (one_out, f, NULL) < 0)
- {
- ctf_set_errno (fp, err);
- goto oom_noerrno;
- }
- return 0;
- oom:
- ctf_set_errno (fp, errno);
- oom_noerrno:
- free (f);
- free (t);
- return -1;
- }
- /* Set a function which is called to transform the names of archive members.
- This is useful for applying regular transformations to many names, where
- ctf_link_add_cu_mapping applies arbitrarily irregular changes to single
- names. The member name changer is applied at ctf_link_write time, so it
- cannot conflate multiple CUs into one the way ctf_link_add_cu_mapping can.
- The changer function accepts a name and should return a new
- dynamically-allocated name, or NULL if the name should be left unchanged. */
- void
- ctf_link_set_memb_name_changer (ctf_dict_t *fp,
- ctf_link_memb_name_changer_f *changer,
- void *arg)
- {
- fp->ctf_link_memb_name_changer = changer;
- fp->ctf_link_memb_name_changer_arg = arg;
- }
- /* Set a function which is used to filter out unwanted variables from the link. */
- int
- ctf_link_set_variable_filter (ctf_dict_t *fp, ctf_link_variable_filter_f *filter,
- void *arg)
- {
- fp->ctf_link_variable_filter = filter;
- fp->ctf_link_variable_filter_arg = arg;
- return 0;
- }
- /* Check if we can safely add a variable with the given type to this dict. */
- static int
- check_variable (const char *name, ctf_dict_t *fp, ctf_id_t type,
- ctf_dvdef_t **out_dvd)
- {
- ctf_dvdef_t *dvd;
- dvd = ctf_dynhash_lookup (fp->ctf_dvhash, name);
- *out_dvd = dvd;
- if (!dvd)
- return 1;
- if (dvd->dvd_type != type)
- {
- /* Variable here. Wrong type: cannot add. Just skip it, because there is
- no way to express this in CTF. Don't even warn: this case is too
- common. (This might be the parent, in which case we'll try adding in
- the child first, and only then give up.) */
- ctf_dprintf ("Inexpressible duplicate variable %s skipped.\n", name);
- }
- return 0; /* Already exists. */
- }
- /* Link one variable named NAME of type TYPE found in IN_FP into FP. */
- static int
- ctf_link_one_variable (ctf_dict_t *fp, ctf_dict_t *in_fp, const char *name,
- ctf_id_t type, int cu_mapped)
- {
- ctf_dict_t *per_cu_out_fp;
- ctf_id_t dst_type = 0;
- ctf_dvdef_t *dvd;
- /* See if this variable is filtered out. */
- if (fp->ctf_link_variable_filter)
- {
- void *farg = fp->ctf_link_variable_filter_arg;
- if (fp->ctf_link_variable_filter (in_fp, name, type, farg))
- return 0;
- }
- /* If this type is mapped to a type in the parent dict, we want to try to add
- to that first: if it reports a duplicate, or if the type is in a child
- already, add straight to the child. */
- if ((dst_type = ctf_dedup_type_mapping (fp, in_fp, type)) == CTF_ERR)
- return -1; /* errno is set for us. */
- if (dst_type != 0)
- {
- if (!ctf_assert (fp, ctf_type_isparent (fp, dst_type)))
- return -1; /* errno is set for us. */
- if (check_variable (name, fp, dst_type, &dvd))
- {
- /* No variable here: we can add it. */
- if (ctf_add_variable (fp, name, dst_type) < 0)
- return -1; /* errno is set for us. */
- return 0;
- }
- /* Already present? Nothing to do. */
- if (dvd && dvd->dvd_type == dst_type)
- return 0;
- }
- /* Can't add to the parent due to a name clash, or because it references a
- type only present in the child. Try adding to the child, creating if need
- be. If we can't do that, skip it. Don't add to a child if we're doing a
- CU-mapped link, since that has only one output. */
- if (cu_mapped)
- {
- ctf_dprintf ("Variable %s in input file %s depends on a type %lx hidden "
- "due to conflicts: skipped.\n", name,
- ctf_unnamed_cuname (in_fp), type);
- return 0;
- }
- if ((per_cu_out_fp = ctf_create_per_cu (fp, ctf_unnamed_cuname (in_fp))) == NULL)
- return -1; /* errno is set for us. */
- /* If the type was not found, check for it in the child too. */
- if (dst_type == 0)
- {
- if ((dst_type = ctf_dedup_type_mapping (per_cu_out_fp,
- in_fp, type)) == CTF_ERR)
- return -1; /* errno is set for us. */
- if (dst_type == 0)
- {
- ctf_err_warn (fp, 1, 0, _("type %lx for variable %s in input file %s "
- "not found: skipped"), type, name,
- ctf_unnamed_cuname (in_fp));
- /* Do not terminate the link: just skip the variable. */
- return 0;
- }
- }
- if (check_variable (name, per_cu_out_fp, dst_type, &dvd))
- if (ctf_add_variable (per_cu_out_fp, name, dst_type) < 0)
- return (ctf_set_errno (fp, ctf_errno (per_cu_out_fp)));
- return 0;
- }
- typedef struct link_sort_inputs_cb_arg
- {
- int is_cu_mapped;
- ctf_dict_t *fp;
- } link_sort_inputs_cb_arg_t;
- /* Sort the inputs by N (the link order). For CU-mapped links, this is a
- mapping of input to output name, not a mapping of input name to input
- ctf_link_input_t: compensate accordingly. */
- static int
- ctf_link_sort_inputs (const ctf_next_hkv_t *one, const ctf_next_hkv_t *two,
- void *arg)
- {
- ctf_link_input_t *input_1;
- ctf_link_input_t *input_2;
- link_sort_inputs_cb_arg_t *cu_mapped = (link_sort_inputs_cb_arg_t *) arg;
- if (!cu_mapped || !cu_mapped->is_cu_mapped)
- {
- input_1 = (ctf_link_input_t *) one->hkv_value;
- input_2 = (ctf_link_input_t *) two->hkv_value;
- }
- else
- {
- const char *name_1 = (const char *) one->hkv_key;
- const char *name_2 = (const char *) two->hkv_key;
- input_1 = ctf_dynhash_lookup (cu_mapped->fp->ctf_link_inputs, name_1);
- input_2 = ctf_dynhash_lookup (cu_mapped->fp->ctf_link_inputs, name_2);
- /* There is no guarantee that CU-mappings actually have corresponding
- inputs: the relative ordering in that case is unimportant. */
- if (!input_1)
- return -1;
- if (!input_2)
- return 1;
- }
- if (input_1->n < input_2->n)
- return -1;
- else if (input_1->n > input_2->n)
- return 1;
- else
- return 0;
- }
- /* Count the number of input dicts in the ctf_link_inputs, or that subset of the
- ctf_link_inputs given by CU_NAMES if set. Return the number of input dicts,
- and optionally the name and ctf_link_input_t of the single input archive if
- only one exists (no matter how many dicts it contains). */
- static ssize_t
- ctf_link_deduplicating_count_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names,
- ctf_link_input_t **only_one_input)
- {
- ctf_dynhash_t *inputs = fp->ctf_link_inputs;
- ctf_next_t *i = NULL;
- void *name, *input;
- ctf_link_input_t *one_input = NULL;
- const char *one_name = NULL;
- ssize_t count = 0, narcs = 0;
- int err;
- if (cu_names)
- inputs = cu_names;
- while ((err = ctf_dynhash_next (inputs, &i, &name, &input)) == 0)
- {
- ssize_t one_count;
- one_name = (const char *) name;
- /* If we are processing CU names, get the real input. */
- if (cu_names)
- one_input = ctf_dynhash_lookup (fp->ctf_link_inputs, one_name);
- else
- one_input = (ctf_link_input_t *) input;
- if (!one_input)
- continue;
- one_count = ctf_link_lazy_open (fp, one_input);
- if (one_count < 0)
- {
- ctf_next_destroy (i);
- return -1; /* errno is set for us. */
- }
- count += one_count;
- narcs++;
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_err_warn (fp, 0, err, _("iteration error counting deduplicating "
- "CTF link inputs"));
- ctf_set_errno (fp, err);
- return -1;
- }
- if (!count)
- return 0;
- if (narcs == 1)
- {
- if (only_one_input)
- *only_one_input = one_input;
- }
- else if (only_one_input)
- *only_one_input = NULL;
- return count;
- }
- /* Allocate and populate an inputs array big enough for a given set of inputs:
- either a specific set of CU names (those from that set found in the
- ctf_link_inputs), or the entire ctf_link_inputs (if cu_names is not set).
- The number of inputs (from ctf_link_deduplicating_count_inputs, above) is
- passed in NINPUTS: an array of uint32_t containing parent pointers
- (corresponding to those members of the inputs that have parents) is allocated
- and returned in PARENTS.
- The inputs are *archives*, not files: the archive can have multiple members
- if it is the result of a previous incremental link. We want to add every one
- in turn, including the shared parent. (The dedup machinery knows that a type
- used by a single dictionary and its parent should not be shared in
- CTF_LINK_SHARE_DUPLICATED mode.)
- If no inputs exist that correspond to these CUs, return NULL with the errno
- set to ECTF_NOCTFDATA. */
- static ctf_dict_t **
- ctf_link_deduplicating_open_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names,
- ssize_t ninputs, uint32_t **parents)
- {
- ctf_dynhash_t *inputs = fp->ctf_link_inputs;
- ctf_next_t *i = NULL;
- void *name, *input;
- link_sort_inputs_cb_arg_t sort_arg;
- ctf_dict_t **dedup_inputs = NULL;
- ctf_dict_t **walk;
- uint32_t *parents_ = NULL;
- int err;
- if (cu_names)
- inputs = cu_names;
- if ((dedup_inputs = calloc (ninputs, sizeof (ctf_dict_t *))) == NULL)
- goto oom;
- if ((parents_ = calloc (ninputs, sizeof (uint32_t))) == NULL)
- goto oom;
- walk = dedup_inputs;
- /* Counting done: push every input into the array, in the order they were
- passed to ctf_link_add_ctf (and ultimately ld). */
- sort_arg.is_cu_mapped = (cu_names != NULL);
- sort_arg.fp = fp;
- while ((err = ctf_dynhash_next_sorted (inputs, &i, &name, &input,
- ctf_link_sort_inputs, &sort_arg)) == 0)
- {
- const char *one_name = (const char *) name;
- ctf_link_input_t *one_input;
- ctf_dict_t *one_fp;
- ctf_dict_t *parent_fp = NULL;
- uint32_t parent_i;
- ctf_next_t *j = NULL;
- /* If we are processing CU names, get the real input. All the inputs
- will have been opened, if they contained any CTF at all. */
- if (cu_names)
- one_input = ctf_dynhash_lookup (fp->ctf_link_inputs, one_name);
- else
- one_input = (ctf_link_input_t *) input;
- if (!one_input || (!one_input->clin_arc && !one_input->clin_fp))
- continue;
- /* Short-circuit: if clin_fp is set, just use it. */
- if (one_input->clin_fp)
- {
- parents_[walk - dedup_inputs] = walk - dedup_inputs;
- *walk = one_input->clin_fp;
- walk++;
- continue;
- }
- /* Get and insert the parent archive (if any), if this archive has
- multiple members. We assume, as elsewhere, that the parent is named
- _CTF_SECTION. */
- if ((parent_fp = ctf_dict_open (one_input->clin_arc, _CTF_SECTION,
- &err)) == NULL)
- {
- if (err != ECTF_NOMEMBNAM)
- {
- ctf_next_destroy (i);
- ctf_set_errno (fp, err);
- goto err;
- }
- }
- else
- {
- *walk = parent_fp;
- parent_i = walk - dedup_inputs;
- walk++;
- }
- /* We disregard the input archive name: either it is the parent (which we
- already have), or we want to put everything into one TU sharing the
- cuname anyway (if this is a CU-mapped link), or this is the final phase
- of a relink with CU-mapping off (i.e. ld -r) in which case the cuname
- is correctly set regardless. */
- while ((one_fp = ctf_archive_next (one_input->clin_arc, &j, NULL,
- 1, &err)) != NULL)
- {
- if (one_fp->ctf_flags & LCTF_CHILD)
- {
- /* The contents of the parents array for elements not
- corresponding to children is undefined. If there is no parent
- (itself a sign of a likely linker bug or corrupt input), we set
- it to itself. */
- ctf_import (one_fp, parent_fp);
- if (parent_fp)
- parents_[walk - dedup_inputs] = parent_i;
- else
- parents_[walk - dedup_inputs] = walk - dedup_inputs;
- }
- *walk = one_fp;
- walk++;
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_next_destroy (i);
- goto iterr;
- }
- }
- if (err != ECTF_NEXT_END)
- goto iterr;
- *parents = parents_;
- return dedup_inputs;
- oom:
- err = ENOMEM;
- iterr:
- ctf_set_errno (fp, err);
- err:
- free (dedup_inputs);
- free (parents_);
- ctf_err_warn (fp, 0, 0, _("error in deduplicating CTF link "
- "input allocation"));
- return NULL;
- }
- /* Close INPUTS that have already been linked, first the passed array, and then
- that subset of the ctf_link_inputs archives they came from cited by the
- CU_NAMES. If CU_NAMES is not specified, close all the ctf_link_inputs in one
- go, leaving it empty. */
- static int
- ctf_link_deduplicating_close_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names,
- ctf_dict_t **inputs, ssize_t ninputs)
- {
- ctf_next_t *it = NULL;
- void *name;
- int err;
- ssize_t i;
- /* This is the inverse of ctf_link_deduplicating_open_inputs: so first, close
- all the individual input dicts, opened by the archive iterator. */
- for (i = 0; i < ninputs; i++)
- ctf_dict_close (inputs[i]);
- /* Now close the archives they are part of. */
- if (cu_names)
- {
- while ((err = ctf_dynhash_next (cu_names, &it, &name, NULL)) == 0)
- {
- /* Remove the input from the linker inputs, if it exists, which also
- closes it. */
- ctf_dynhash_remove (fp->ctf_link_inputs, (const char *) name);
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_err_warn (fp, 0, err, _("iteration error in deduplicating link "
- "input freeing"));
- ctf_set_errno (fp, err);
- }
- }
- else
- ctf_dynhash_empty (fp->ctf_link_inputs);
- return 0;
- }
- /* Do a deduplicating link of all variables in the inputs.
- Also, if we are not omitting the variable section, integrate all symbols from
- the symtypetabs into the variable section too. (Duplication with the
- symtypetab section in the output will be eliminated at serialization time.) */
- static int
- ctf_link_deduplicating_variables (ctf_dict_t *fp, ctf_dict_t **inputs,
- size_t ninputs, int cu_mapped)
- {
- size_t i;
- for (i = 0; i < ninputs; i++)
- {
- ctf_next_t *it = NULL;
- ctf_id_t type;
- const char *name;
- /* First the variables on the inputs. */
- while ((type = ctf_variable_next (inputs[i], &it, &name)) != CTF_ERR)
- {
- if (ctf_link_one_variable (fp, inputs[i], name, type, cu_mapped) < 0)
- {
- ctf_next_destroy (it);
- return -1; /* errno is set for us. */
- }
- }
- if (ctf_errno (inputs[i]) != ECTF_NEXT_END)
- return ctf_set_errno (fp, ctf_errno (inputs[i]));
- /* Next the symbols. We integrate data symbols even though the compiler
- is currently doing the same, to allow the compiler to stop in
- future. */
- while ((type = ctf_symbol_next (inputs[i], &it, &name, 0)) != CTF_ERR)
- {
- if (ctf_link_one_variable (fp, inputs[i], name, type, 1) < 0)
- {
- ctf_next_destroy (it);
- return -1; /* errno is set for us. */
- }
- }
- if (ctf_errno (inputs[i]) != ECTF_NEXT_END)
- return ctf_set_errno (fp, ctf_errno (inputs[i]));
- /* Finally the function symbols. */
- while ((type = ctf_symbol_next (inputs[i], &it, &name, 1)) != CTF_ERR)
- {
- if (ctf_link_one_variable (fp, inputs[i], name, type, 1) < 0)
- {
- ctf_next_destroy (it);
- return -1; /* errno is set for us. */
- }
- }
- if (ctf_errno (inputs[i]) != ECTF_NEXT_END)
- return ctf_set_errno (fp, ctf_errno (inputs[i]));
- }
- return 0;
- }
- /* Check for symbol conflicts during linking. Three possibilities: already
- exists, conflicting, or nonexistent. We don't have a dvd structure we can
- use as a flag like check_variable does, so we use a tristate return
- value instead: -1: conflicting; 1: nonexistent: 0: already exists. */
- static int
- check_sym (ctf_dict_t *fp, const char *name, ctf_id_t type, int functions)
- {
- ctf_dynhash_t *thishash = functions ? fp->ctf_funchash : fp->ctf_objthash;
- ctf_dynhash_t *thathash = functions ? fp->ctf_objthash : fp->ctf_funchash;
- void *value;
- /* Wrong type (function when object is wanted, etc). */
- if (ctf_dynhash_lookup_kv (thathash, name, NULL, NULL))
- return -1;
- /* Not present at all yet. */
- if (!ctf_dynhash_lookup_kv (thishash, name, NULL, &value))
- return 1;
- /* Already present. */
- if ((ctf_id_t) (uintptr_t) value == type)
- return 0;
- /* Wrong type. */
- return -1;
- }
- /* Do a deduplicating link of one symtypetab (function info or data object) in
- one input dict. */
- static int
- ctf_link_deduplicating_one_symtypetab (ctf_dict_t *fp, ctf_dict_t *input,
- int cu_mapped, int functions)
- {
- ctf_next_t *it = NULL;
- const char *name;
- ctf_id_t type;
- while ((type = ctf_symbol_next (input, &it, &name, functions)) != CTF_ERR)
- {
- ctf_id_t dst_type;
- ctf_dict_t *per_cu_out_fp;
- int sym;
- /* Look in the parent first. */
- if ((dst_type = ctf_dedup_type_mapping (fp, input, type)) == CTF_ERR)
- return -1; /* errno is set for us. */
- if (dst_type != 0)
- {
- if (!ctf_assert (fp, ctf_type_isparent (fp, dst_type)))
- return -1; /* errno is set for us. */
- sym = check_sym (fp, name, dst_type, functions);
- /* Already present: next symbol. */
- if (sym == 0)
- continue;
- /* Not present: add it. */
- else if (sym > 0)
- {
- if (ctf_add_funcobjt_sym (fp, functions,
- name, dst_type) < 0)
- return -1; /* errno is set for us. */
- continue;
- }
- }
- /* Can't add to the parent due to a name clash (most unlikely), or because
- it references a type only present in the child. Try adding to the
- child, creating if need be. If we can't do that, skip it. Don't add
- to a child if we're doing a CU-mapped link, since that has only one
- output. */
- if (cu_mapped)
- {
- ctf_dprintf ("Symbol %s in input file %s depends on a type %lx "
- "hidden due to conflicts: skipped.\n", name,
- ctf_unnamed_cuname (input), type);
- continue;
- }
- if ((per_cu_out_fp = ctf_create_per_cu (fp, ctf_unnamed_cuname (input))) == NULL)
- return -1; /* errno is set for us. */
- /* If the type was not found, check for it in the child too. */
- if (dst_type == 0)
- {
- if ((dst_type = ctf_dedup_type_mapping (per_cu_out_fp,
- input, type)) == CTF_ERR)
- return -1; /* errno is set for us. */
- if (dst_type == 0)
- {
- ctf_err_warn (fp, 1, 0,
- _("type %lx for symbol %s in input file %s "
- "not found: skipped"), type, name,
- ctf_unnamed_cuname (input));
- continue;
- }
- }
- sym = check_sym (per_cu_out_fp, name, dst_type, functions);
- /* Already present: next symbol. */
- if (sym == 0)
- continue;
- /* Not present: add it. */
- else if (sym > 0)
- {
- if (ctf_add_funcobjt_sym (per_cu_out_fp, functions,
- name, dst_type) < 0)
- return -1; /* errno is set for us. */
- }
- else
- {
- /* Perhaps this should be an assertion failure. */
- ctf_err_warn (fp, 0, ECTF_DUPLICATE,
- _("symbol %s in input file %s found conflicting "
- "even when trying in per-CU dict."), name,
- ctf_unnamed_cuname (input));
- return (ctf_set_errno (fp, ECTF_DUPLICATE));
- }
- }
- if (ctf_errno (input) != ECTF_NEXT_END)
- {
- ctf_set_errno (fp, ctf_errno (input));
- ctf_err_warn (fp, 0, ctf_errno (input),
- functions ? _("iterating over function symbols") :
- _("iterating over data symbols"));
- return -1;
- }
- return 0;
- }
- /* Do a deduplicating link of the function info and data objects
- in the inputs. */
- static int
- ctf_link_deduplicating_syms (ctf_dict_t *fp, ctf_dict_t **inputs,
- size_t ninputs, int cu_mapped)
- {
- size_t i;
- for (i = 0; i < ninputs; i++)
- {
- if (ctf_link_deduplicating_one_symtypetab (fp, inputs[i],
- cu_mapped, 0) < 0)
- return -1; /* errno is set for us. */
- if (ctf_link_deduplicating_one_symtypetab (fp, inputs[i],
- cu_mapped, 1) < 0)
- return -1; /* errno is set for us. */
- }
- return 0;
- }
- /* Do the per-CU part of a deduplicating link. */
- static int
- ctf_link_deduplicating_per_cu (ctf_dict_t *fp)
- {
- ctf_next_t *i = NULL;
- int err;
- void *out_cu;
- void *in_cus;
- /* Links with a per-CU mapping in force get a first pass of deduplication,
- dedupping the inputs for a given CU mapping into the output for that
- mapping. The outputs from this process get fed back into the final pass
- that is carried out even for non-CU links. */
- while ((err = ctf_dynhash_next (fp->ctf_link_out_cu_mapping, &i, &out_cu,
- &in_cus)) == 0)
- {
- const char *out_name = (const char *) out_cu;
- ctf_dynhash_t *in = (ctf_dynhash_t *) in_cus;
- ctf_dict_t *out = NULL;
- ctf_dict_t **inputs;
- ctf_dict_t **outputs;
- ctf_archive_t *in_arc;
- ssize_t ninputs;
- ctf_link_input_t *only_input;
- uint32_t noutputs;
- uint32_t *parents;
- if ((ninputs = ctf_link_deduplicating_count_inputs (fp, in,
- &only_input)) == -1)
- goto err_open_inputs;
- /* CU mapping with no inputs? Skip. */
- if (ninputs == 0)
- continue;
- if (labs ((long int) ninputs) > 0xfffffffe)
- {
- ctf_err_warn (fp, 0, EFBIG, _("too many inputs in deduplicating "
- "link: %li"), (long int) ninputs);
- ctf_set_errno (fp, EFBIG);
- goto err_open_inputs;
- }
- /* Short-circuit: a cu-mapped link with only one input archive with
- unconflicting contents is a do-nothing, and we can just leave the input
- in place: we do have to change the cuname, though, so we unwrap it,
- change the cuname, then stuff it back in the linker input again, via
- the clin_fp short-circuit member. ctf_link_deduplicating_open_inputs
- will spot this member and jam it straight into the next link phase,
- ignoring the corresponding archive. */
- if (only_input && ninputs == 1)
- {
- ctf_next_t *ai = NULL;
- int err;
- /* We can abuse an archive iterator to get the only member cheaply, no
- matter what its name. */
- only_input->clin_fp = ctf_archive_next (only_input->clin_arc,
- &ai, NULL, 0, &err);
- if (!only_input->clin_fp)
- {
- ctf_err_warn (fp, 0, err, _("cannot open archive %s in "
- "CU-mapped CTF link"),
- only_input->clin_filename);
- ctf_set_errno (fp, err);
- goto err_open_inputs;
- }
- ctf_next_destroy (ai);
- if (strcmp (only_input->clin_filename, out_name) != 0)
- {
- /* Renaming. We need to add a new input, then null out the
- clin_arc and clin_fp of the old one to stop it being
- auto-closed on removal. The new input needs its cuname changed
- to out_name, which is doable only because the cuname is a
- dynamic property which can be changed even in readonly
- dicts. */
- ctf_cuname_set (only_input->clin_fp, out_name);
- if (ctf_link_add_ctf_internal (fp, only_input->clin_arc,
- only_input->clin_fp,
- out_name) < 0)
- {
- ctf_err_warn (fp, 0, 0, _("cannot add intermediate files "
- "to link"));
- goto err_open_inputs;
- }
- only_input->clin_arc = NULL;
- only_input->clin_fp = NULL;
- ctf_dynhash_remove (fp->ctf_link_inputs,
- only_input->clin_filename);
- }
- continue;
- }
- /* This is a real CU many-to-one mapping: we must dedup the inputs into
- a new output to be used in the final link phase. */
- if ((inputs = ctf_link_deduplicating_open_inputs (fp, in, ninputs,
- &parents)) == NULL)
- {
- ctf_next_destroy (i);
- goto err_inputs;
- }
- if ((out = ctf_create (&err)) == NULL)
- {
- ctf_err_warn (fp, 0, err, _("cannot create per-CU CTF archive "
- "for %s"),
- out_name);
- ctf_set_errno (fp, err);
- goto err_inputs;
- }
- /* Share the atoms table to reduce memory usage. */
- out->ctf_dedup_atoms = fp->ctf_dedup_atoms_alloc;
- /* No ctf_imports at this stage: this per-CU dictionary has no parents.
- Parent/child deduplication happens in the link's final pass. However,
- the cuname *is* important, as it is propagated into the final
- dictionary. */
- ctf_cuname_set (out, out_name);
- if (ctf_dedup (out, inputs, ninputs, parents, 1) < 0)
- {
- ctf_set_errno (fp, ctf_errno (out));
- ctf_err_warn (fp, 0, 0, _("CU-mapped deduplication failed for %s"),
- out_name);
- goto err_inputs;
- }
- if ((outputs = ctf_dedup_emit (out, inputs, ninputs, parents,
- &noutputs, 1)) == NULL)
- {
- ctf_set_errno (fp, ctf_errno (out));
- ctf_err_warn (fp, 0, 0, _("CU-mapped deduplicating link type emission "
- "failed for %s"), out_name);
- goto err_inputs;
- }
- if (!ctf_assert (fp, noutputs == 1))
- {
- size_t j;
- for (j = 1; j < noutputs; j++)
- ctf_dict_close (outputs[j]);
- goto err_inputs_outputs;
- }
- if (!(fp->ctf_link_flags & CTF_LINK_OMIT_VARIABLES_SECTION)
- && ctf_link_deduplicating_variables (out, inputs, ninputs, 1) < 0)
- {
- ctf_set_errno (fp, ctf_errno (out));
- ctf_err_warn (fp, 0, 0, _("CU-mapped deduplicating link variable "
- "emission failed for %s"), out_name);
- goto err_inputs_outputs;
- }
- ctf_dedup_fini (out, outputs, noutputs);
- /* For now, we omit symbol section linking for CU-mapped links, until it
- is clear how to unify the symbol table across such links. (Perhaps we
- should emit an unconditionally indexed symtab, like the compiler
- does.) */
- if (ctf_link_deduplicating_close_inputs (fp, in, inputs, ninputs) < 0)
- {
- free (inputs);
- free (parents);
- goto err_outputs;
- }
- free (inputs);
- free (parents);
- /* Splice any errors or warnings created during this link back into the
- dict that the caller knows about. */
- ctf_list_splice (&fp->ctf_errs_warnings, &outputs[0]->ctf_errs_warnings);
- /* This output now becomes an input to the next link phase, with a name
- equal to the CU name. We have to wrap it in an archive wrapper
- first. */
- if ((in_arc = ctf_new_archive_internal (0, 0, NULL, outputs[0], NULL,
- NULL, &err)) == NULL)
- {
- ctf_set_errno (fp, err);
- goto err_outputs;
- }
- if (ctf_link_add_ctf_internal (fp, in_arc, NULL,
- ctf_cuname (outputs[0])) < 0)
- {
- ctf_err_warn (fp, 0, 0, _("cannot add intermediate files to link"));
- goto err_outputs;
- }
- ctf_dict_close (out);
- free (outputs);
- continue;
- err_inputs_outputs:
- ctf_list_splice (&fp->ctf_errs_warnings, &outputs[0]->ctf_errs_warnings);
- ctf_dict_close (outputs[0]);
- free (outputs);
- err_inputs:
- ctf_link_deduplicating_close_inputs (fp, in, inputs, ninputs);
- ctf_dict_close (out);
- free (inputs);
- free (parents);
- err_open_inputs:
- ctf_next_destroy (i);
- return -1;
- err_outputs:
- ctf_list_splice (&fp->ctf_errs_warnings, &outputs[0]->ctf_errs_warnings);
- ctf_dict_close (outputs[0]);
- free (outputs);
- ctf_next_destroy (i);
- return -1; /* Errno is set for us. */
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_err_warn (fp, 0, err, _("iteration error in CU-mapped deduplicating "
- "link"));
- return ctf_set_errno (fp, err);
- }
- return 0;
- }
- /* Do a deduplicating link using the ctf-dedup machinery. */
- static void
- ctf_link_deduplicating (ctf_dict_t *fp)
- {
- size_t i;
- ctf_dict_t **inputs, **outputs = NULL;
- ssize_t ninputs;
- uint32_t noutputs;
- uint32_t *parents;
- if (ctf_dedup_atoms_init (fp) < 0)
- {
- ctf_err_warn (fp, 0, 0, _("allocating CTF dedup atoms table"));
- return; /* Errno is set for us. */
- }
- if (fp->ctf_link_out_cu_mapping
- && (ctf_link_deduplicating_per_cu (fp) < 0))
- return; /* Errno is set for us. */
- if ((ninputs = ctf_link_deduplicating_count_inputs (fp, NULL, NULL)) < 0)
- return; /* Errno is set for us. */
- if ((inputs = ctf_link_deduplicating_open_inputs (fp, NULL, ninputs,
- &parents)) == NULL)
- return; /* Errno is set for us. */
- if (ninputs == 1 && ctf_cuname (inputs[0]) != NULL)
- ctf_cuname_set (fp, ctf_cuname (inputs[0]));
- if (ctf_dedup (fp, inputs, ninputs, parents, 0) < 0)
- {
- ctf_err_warn (fp, 0, 0, _("deduplication failed for %s"),
- ctf_link_input_name (fp));
- goto err;
- }
- if ((outputs = ctf_dedup_emit (fp, inputs, ninputs, parents, &noutputs,
- 0)) == NULL)
- {
- ctf_err_warn (fp, 0, 0, _("deduplicating link type emission failed "
- "for %s"), ctf_link_input_name (fp));
- goto err;
- }
- if (!ctf_assert (fp, outputs[0] == fp))
- {
- for (i = 1; i < noutputs; i++)
- ctf_dict_close (outputs[i]);
- goto err;
- }
- for (i = 0; i < noutputs; i++)
- {
- char *dynname;
- /* We already have access to this one. Close the duplicate. */
- if (i == 0)
- {
- ctf_dict_close (outputs[0]);
- continue;
- }
- if ((dynname = strdup (ctf_cuname (outputs[i]))) == NULL)
- goto oom_one_output;
- if (ctf_dynhash_insert (fp->ctf_link_outputs, dynname, outputs[i]) < 0)
- goto oom_one_output;
- continue;
- oom_one_output:
- ctf_set_errno (fp, ENOMEM);
- ctf_err_warn (fp, 0, 0, _("out of memory allocating link outputs"));
- free (dynname);
- for (; i < noutputs; i++)
- ctf_dict_close (outputs[i]);
- goto err;
- }
- if (!(fp->ctf_link_flags & CTF_LINK_OMIT_VARIABLES_SECTION)
- && ctf_link_deduplicating_variables (fp, inputs, ninputs, 0) < 0)
- {
- ctf_err_warn (fp, 0, 0, _("deduplicating link variable emission failed for "
- "%s"), ctf_link_input_name (fp));
- goto err_clean_outputs;
- }
- if (ctf_link_deduplicating_syms (fp, inputs, ninputs, 0) < 0)
- {
- ctf_err_warn (fp, 0, 0, _("deduplicating link symbol emission failed for "
- "%s"), ctf_link_input_name (fp));
- goto err_clean_outputs;
- }
- ctf_dedup_fini (fp, outputs, noutputs);
- /* Now close all the inputs, including per-CU intermediates. */
- if (ctf_link_deduplicating_close_inputs (fp, NULL, inputs, ninputs) < 0)
- return; /* errno is set for us. */
- ninputs = 0; /* Prevent double-close. */
- ctf_set_errno (fp, 0);
- /* Fall through. */
- err:
- for (i = 0; i < (size_t) ninputs; i++)
- ctf_dict_close (inputs[i]);
- free (inputs);
- free (parents);
- free (outputs);
- return;
- err_clean_outputs:
- for (i = 1; i < noutputs; i++)
- {
- ctf_dynhash_remove (fp->ctf_link_outputs, ctf_cuname (outputs[i]));
- ctf_dict_close (outputs[i]);
- }
- goto err;
- }
- /* Merge types and variable sections in all dicts added to the link together.
- All the added dicts are closed. */
- int
- ctf_link (ctf_dict_t *fp, int flags)
- {
- ctf_next_t *i = NULL;
- int err;
- fp->ctf_link_flags = flags;
- if (fp->ctf_link_inputs == NULL)
- return 0; /* Nothing to do. */
- if (fp->ctf_link_outputs == NULL)
- fp->ctf_link_outputs = ctf_dynhash_create (ctf_hash_string,
- ctf_hash_eq_string, free,
- (ctf_hash_free_fun)
- ctf_dict_close);
- if (fp->ctf_link_outputs == NULL)
- return ctf_set_errno (fp, ENOMEM);
- /* Create empty CUs if requested. We do not currently claim that multiple
- links in succession with CTF_LINK_EMPTY_CU_MAPPINGS set in some calls and
- not set in others will do anything especially sensible. */
- fp->ctf_flags |= LCTF_LINKING;
- if (fp->ctf_link_out_cu_mapping && (flags & CTF_LINK_EMPTY_CU_MAPPINGS))
- {
- void *v;
- while ((err = ctf_dynhash_next (fp->ctf_link_out_cu_mapping, &i, &v,
- NULL)) == 0)
- {
- const char *to = (const char *) v;
- if (ctf_create_per_cu (fp, to) == NULL)
- {
- fp->ctf_flags &= ~LCTF_LINKING;
- ctf_next_destroy (i);
- return -1; /* Errno is set for us. */
- }
- }
- if (err != ECTF_NEXT_END)
- {
- fp->ctf_flags &= ~LCTF_LINKING;
- ctf_err_warn (fp, 1, err, _("iteration error creating empty CUs"));
- ctf_set_errno (fp, err);
- return -1;
- }
- }
- ctf_link_deduplicating (fp);
- fp->ctf_flags &= ~LCTF_LINKING;
- if ((ctf_errno (fp) != 0) && (ctf_errno (fp) != ECTF_NOCTFDATA))
- return -1;
- return 0;
- }
- typedef struct ctf_link_out_string_cb_arg
- {
- const char *str;
- uint32_t offset;
- int err;
- } ctf_link_out_string_cb_arg_t;
- /* Intern a string in the string table of an output per-CU CTF file. */
- static void
- ctf_link_intern_extern_string (void *key _libctf_unused_, void *value,
- void *arg_)
- {
- ctf_dict_t *fp = (ctf_dict_t *) value;
- ctf_link_out_string_cb_arg_t *arg = (ctf_link_out_string_cb_arg_t *) arg_;
- fp->ctf_flags |= LCTF_DIRTY;
- if (!ctf_str_add_external (fp, arg->str, arg->offset))
- arg->err = ENOMEM;
- }
- /* Repeatedly call ADD_STRING to acquire strings from the external string table,
- adding them to the atoms table for this CU and all subsidiary CUs.
- If ctf_link is also called, it must be called first if you want the new CTF
- files ctf_link can create to get their strings dedupped against the ELF
- strtab properly. */
- int
- ctf_link_add_strtab (ctf_dict_t *fp, ctf_link_strtab_string_f *add_string,
- void *arg)
- {
- const char *str;
- uint32_t offset;
- int err = 0;
- while ((str = add_string (&offset, arg)) != NULL)
- {
- ctf_link_out_string_cb_arg_t iter_arg = { str, offset, 0 };
- fp->ctf_flags |= LCTF_DIRTY;
- if (!ctf_str_add_external (fp, str, offset))
- err = ENOMEM;
- ctf_dynhash_iter (fp->ctf_link_outputs, ctf_link_intern_extern_string,
- &iter_arg);
- if (iter_arg.err)
- err = iter_arg.err;
- }
- if (err)
- ctf_set_errno (fp, err);
- return -err;
- }
- /* Inform the ctf-link machinery of a new symbol in the target symbol table
- (which must be some symtab that is not usually stripped, and which
- is in agreement with ctf_bfdopen_ctfsect). May be called either before or
- after ctf_link_add_strtab. */
- int
- ctf_link_add_linker_symbol (ctf_dict_t *fp, ctf_link_sym_t *sym)
- {
- ctf_in_flight_dynsym_t *cid;
- /* Cheat a little: if there is already an ENOMEM error code recorded against
- this dict, we shouldn't even try to add symbols because there will be no
- memory to do so: probably we failed to add some previous symbol. This
- makes out-of-memory exits 'sticky' across calls to this function, so the
- caller doesn't need to worry about error conditions. */
- if (ctf_errno (fp) == ENOMEM)
- return -ENOMEM; /* errno is set for us. */
- if (ctf_symtab_skippable (sym))
- return 0;
- if (sym->st_type != STT_OBJECT && sym->st_type != STT_FUNC)
- return 0;
- /* Add the symbol to the in-flight list. */
- if ((cid = malloc (sizeof (ctf_in_flight_dynsym_t))) == NULL)
- goto oom;
- cid->cid_sym = *sym;
- ctf_list_append (&fp->ctf_in_flight_dynsyms, cid);
- return 0;
- oom:
- ctf_dynhash_destroy (fp->ctf_dynsyms);
- fp->ctf_dynsyms = NULL;
- ctf_set_errno (fp, ENOMEM);
- return -ENOMEM;
- }
- /* Impose an ordering on symbols. The ordering takes effect immediately, but
- since the ordering info does not include type IDs, lookups may return nothing
- until such IDs are added by calls to ctf_add_*_sym. Must be called after
- ctf_link_add_strtab and ctf_link_add_linker_symbol. */
- int
- ctf_link_shuffle_syms (ctf_dict_t *fp)
- {
- ctf_in_flight_dynsym_t *did, *nid;
- ctf_next_t *i = NULL;
- int err = ENOMEM;
- void *name_, *sym_;
- if (!fp->ctf_dynsyms)
- {
- fp->ctf_dynsyms = ctf_dynhash_create (ctf_hash_string,
- ctf_hash_eq_string,
- NULL, free);
- if (!fp->ctf_dynsyms)
- {
- ctf_set_errno (fp, ENOMEM);
- return -ENOMEM;
- }
- }
- /* Add all the symbols, excluding only those we already know are prohibited
- from appearing in symtypetabs. */
- for (did = ctf_list_next (&fp->ctf_in_flight_dynsyms); did != NULL; did = nid)
- {
- ctf_link_sym_t *new_sym;
- nid = ctf_list_next (did);
- ctf_list_delete (&fp->ctf_in_flight_dynsyms, did);
- /* We might get a name or an external strtab offset. The strtab offset is
- guaranteed resolvable at this point, so turn it into a string. */
- if (did->cid_sym.st_name == NULL)
- {
- uint32_t off = CTF_SET_STID (did->cid_sym.st_nameidx, CTF_STRTAB_1);
- did->cid_sym.st_name = ctf_strraw (fp, off);
- did->cid_sym.st_nameidx_set = 0;
- if (!ctf_assert (fp, did->cid_sym.st_name != NULL))
- return -ECTF_INTERNAL; /* errno is set for us. */
- }
- /* The symbol might have turned out to be nameless, so we have to recheck
- for skippability here. */
- if (!ctf_symtab_skippable (&did->cid_sym))
- {
- ctf_dprintf ("symbol from linker: %s (%x)\n", did->cid_sym.st_name,
- did->cid_sym.st_symidx);
- if ((new_sym = malloc (sizeof (ctf_link_sym_t))) == NULL)
- goto local_oom;
- memcpy (new_sym, &did->cid_sym, sizeof (ctf_link_sym_t));
- if (ctf_dynhash_cinsert (fp->ctf_dynsyms, new_sym->st_name, new_sym) < 0)
- goto local_oom;
- if (fp->ctf_dynsymmax < new_sym->st_symidx)
- fp->ctf_dynsymmax = new_sym->st_symidx;
- }
- free (did);
- continue;
- local_oom:
- free (did);
- free (new_sym);
- goto err;
- }
- /* If no symbols are reported, unwind what we have done and return. This
- makes it a bit easier for the serializer to tell that no symbols have been
- reported and that it should look elsewhere for reported symbols. */
- if (!ctf_dynhash_elements (fp->ctf_dynsyms))
- {
- ctf_dprintf ("No symbols: not a final link.\n");
- ctf_dynhash_destroy (fp->ctf_dynsyms);
- fp->ctf_dynsyms = NULL;
- return 0;
- }
- /* Construct a mapping from shndx to the symbol info. */
- free (fp->ctf_dynsymidx);
- if ((fp->ctf_dynsymidx = calloc (fp->ctf_dynsymmax + 1,
- sizeof (ctf_link_sym_t *))) == NULL)
- goto err;
- while ((err = ctf_dynhash_next (fp->ctf_dynsyms, &i, &name_, &sym_)) == 0)
- {
- const char *name = (const char *) name;
- ctf_link_sym_t *symp = (ctf_link_sym_t *) sym_;
- if (!ctf_assert (fp, symp->st_symidx <= fp->ctf_dynsymmax))
- {
- ctf_next_destroy (i);
- err = ctf_errno (fp);
- goto err;
- }
- fp->ctf_dynsymidx[symp->st_symidx] = symp;
- }
- if (err != ECTF_NEXT_END)
- {
- ctf_err_warn (fp, 0, err, _("error iterating over shuffled symbols"));
- goto err;
- }
- return 0;
- err:
- /* Leave the in-flight symbols around: they'll be freed at
- dict close time regardless. */
- ctf_dynhash_destroy (fp->ctf_dynsyms);
- fp->ctf_dynsyms = NULL;
- free (fp->ctf_dynsymidx);
- fp->ctf_dynsymidx = NULL;
- fp->ctf_dynsymmax = 0;
- ctf_set_errno (fp, err);
- return -err;
- }
- typedef struct ctf_name_list_accum_cb_arg
- {
- char **names;
- ctf_dict_t *fp;
- ctf_dict_t **files;
- size_t i;
- char **dynames;
- size_t ndynames;
- } ctf_name_list_accum_cb_arg_t;
- /* Accumulate the names and a count of the names in the link output hash. */
- static void
- ctf_accumulate_archive_names (void *key, void *value, void *arg_)
- {
- const char *name = (const char *) key;
- ctf_dict_t *fp = (ctf_dict_t *) value;
- char **names;
- ctf_dict_t **files;
- ctf_name_list_accum_cb_arg_t *arg = (ctf_name_list_accum_cb_arg_t *) arg_;
- if ((names = realloc (arg->names, sizeof (char *) * ++(arg->i))) == NULL)
- {
- (arg->i)--;
- ctf_set_errno (arg->fp, ENOMEM);
- return;
- }
- if ((files = realloc (arg->files, sizeof (ctf_dict_t *) * arg->i)) == NULL)
- {
- (arg->i)--;
- ctf_set_errno (arg->fp, ENOMEM);
- return;
- }
- /* Allow the caller to get in and modify the name at the last minute. If the
- caller *does* modify the name, we have to stash away the new name the
- caller returned so we can free it later on. (The original name is the key
- of the ctf_link_outputs hash and is freed by the dynhash machinery.) */
- if (fp->ctf_link_memb_name_changer)
- {
- char **dynames;
- char *dyname;
- void *nc_arg = fp->ctf_link_memb_name_changer_arg;
- dyname = fp->ctf_link_memb_name_changer (fp, name, nc_arg);
- if (dyname != NULL)
- {
- if ((dynames = realloc (arg->dynames,
- sizeof (char *) * ++(arg->ndynames))) == NULL)
- {
- (arg->ndynames)--;
- ctf_set_errno (arg->fp, ENOMEM);
- return;
- }
- arg->dynames = dynames;
- name = (const char *) dyname;
- }
- }
- arg->names = names;
- arg->names[(arg->i) - 1] = (char *) name;
- arg->files = files;
- arg->files[(arg->i) - 1] = fp;
- }
- /* Change the name of the parent CTF section, if the name transformer has got to
- it. */
- static void
- ctf_change_parent_name (void *key _libctf_unused_, void *value, void *arg)
- {
- ctf_dict_t *fp = (ctf_dict_t *) value;
- const char *name = (const char *) arg;
- ctf_parent_name_set (fp, name);
- }
- /* Warn if we may suffer information loss because the CTF input files are too
- old. Usually we provide complete backward compatibility, but compiler
- changes etc which never hit a release may have a flag in the header that
- simply prevents those changes from being used. */
- static void
- ctf_link_warn_outdated_inputs (ctf_dict_t *fp)
- {
- ctf_next_t *i = NULL;
- void *name_;
- void *ifp_;
- int err;
- while ((err = ctf_dynhash_next (fp->ctf_link_inputs, &i, &name_, &ifp_)) == 0)
- {
- const char *name = (const char *) name_;
- ctf_dict_t *ifp = (ctf_dict_t *) ifp_;
- if (!(ifp->ctf_header->cth_flags & CTF_F_NEWFUNCINFO)
- && (ifp->ctf_header->cth_varoff - ifp->ctf_header->cth_funcoff) > 0)
- ctf_err_warn (ifp, 1, 0, _("linker input %s has CTF func info but uses "
- "an old, unreleased func info format: "
- "this func info section will be dropped."),
- name);
- }
- if (err != ECTF_NEXT_END)
- ctf_err_warn (fp, 0, err, _("error checking for outdated inputs"));
- }
- /* Write out a CTF archive (if there are per-CU CTF files) or a CTF file
- (otherwise) into a new dynamically-allocated string, and return it.
- Members with sizes above THRESHOLD are compressed. */
- unsigned char *
- ctf_link_write (ctf_dict_t *fp, size_t *size, size_t threshold)
- {
- ctf_name_list_accum_cb_arg_t arg;
- char **names;
- char *transformed_name = NULL;
- ctf_dict_t **files;
- FILE *f = NULL;
- size_t i;
- int err;
- long fsize;
- const char *errloc;
- unsigned char *buf = NULL;
- memset (&arg, 0, sizeof (ctf_name_list_accum_cb_arg_t));
- arg.fp = fp;
- fp->ctf_flags |= LCTF_LINKING;
- ctf_link_warn_outdated_inputs (fp);
- if (fp->ctf_link_outputs)
- {
- ctf_dynhash_iter (fp->ctf_link_outputs, ctf_accumulate_archive_names, &arg);
- if (ctf_errno (fp) < 0)
- {
- errloc = "hash creation";
- goto err;
- }
- }
- /* No extra outputs? Just write a simple ctf_dict_t. */
- if (arg.i == 0)
- {
- unsigned char *ret = ctf_write_mem (fp, size, threshold);
- fp->ctf_flags &= ~LCTF_LINKING;
- return ret;
- }
- /* Writing an archive. Stick ourselves (the shared repository, parent of all
- other archives) on the front of it with the default name. */
- if ((names = realloc (arg.names, sizeof (char *) * (arg.i + 1))) == NULL)
- {
- errloc = "name reallocation";
- goto err_no;
- }
- arg.names = names;
- memmove (&(arg.names[1]), arg.names, sizeof (char *) * (arg.i));
- arg.names[0] = (char *) _CTF_SECTION;
- if (fp->ctf_link_memb_name_changer)
- {
- void *nc_arg = fp->ctf_link_memb_name_changer_arg;
- transformed_name = fp->ctf_link_memb_name_changer (fp, _CTF_SECTION,
- nc_arg);
- if (transformed_name != NULL)
- {
- arg.names[0] = transformed_name;
- ctf_dynhash_iter (fp->ctf_link_outputs, ctf_change_parent_name,
- transformed_name);
- }
- }
- /* Propagate the link flags to all the dicts in this link. */
- for (i = 0; i < arg.i; i++)
- {
- arg.files[i]->ctf_link_flags = fp->ctf_link_flags;
- arg.files[i]->ctf_flags |= LCTF_LINKING;
- }
- if ((files = realloc (arg.files,
- sizeof (struct ctf_dict *) * (arg.i + 1))) == NULL)
- {
- errloc = "ctf_dict reallocation";
- goto err_no;
- }
- arg.files = files;
- memmove (&(arg.files[1]), arg.files, sizeof (ctf_dict_t *) * (arg.i));
- arg.files[0] = fp;
- if ((f = tmpfile ()) == NULL)
- {
- errloc = "tempfile creation";
- goto err_no;
- }
- if ((err = ctf_arc_write_fd (fileno (f), arg.files, arg.i + 1,
- (const char **) arg.names,
- threshold)) < 0)
- {
- errloc = "archive writing";
- ctf_set_errno (fp, err);
- goto err;
- }
- if (fseek (f, 0, SEEK_END) < 0)
- {
- errloc = "seeking to end";
- goto err_no;
- }
- if ((fsize = ftell (f)) < 0)
- {
- errloc = "filesize determination";
- goto err_no;
- }
- if (fseek (f, 0, SEEK_SET) < 0)
- {
- errloc = "filepos resetting";
- goto err_no;
- }
- if ((buf = malloc (fsize)) == NULL)
- {
- errloc = "CTF archive buffer allocation";
- goto err_no;
- }
- while (!feof (f) && fread (buf, fsize, 1, f) == 0)
- if (ferror (f))
- {
- errloc = "reading archive from temporary file";
- goto err_no;
- }
- *size = fsize;
- free (arg.names);
- free (arg.files);
- free (transformed_name);
- if (arg.ndynames)
- {
- size_t i;
- for (i = 0; i < arg.ndynames; i++)
- free (arg.dynames[i]);
- free (arg.dynames);
- }
- fclose (f);
- return buf;
- err_no:
- ctf_set_errno (fp, errno);
- /* Turn off the is-linking flag on all the dicts in this link. */
- for (i = 0; i < arg.i; i++)
- arg.files[i]->ctf_flags &= ~LCTF_LINKING;
- err:
- free (buf);
- if (f)
- fclose (f);
- free (arg.names);
- free (arg.files);
- free (transformed_name);
- if (arg.ndynames)
- {
- size_t i;
- for (i = 0; i < arg.ndynames; i++)
- free (arg.dynames[i]);
- free (arg.dynames);
- }
- ctf_err_warn (fp, 0, 0, _("cannot write archive in link: %s failure"),
- errloc);
- return NULL;
- }
|