| 1 | /* CTF linking. |
| 2 | Copyright (C) 2019 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 | /* Type tracking machinery. */ |
| 24 | |
| 25 | /* Record the correspondence between a source and ctf_add_type()-added |
| 26 | destination type: both types are translated into parent type IDs if need be, |
| 27 | so they relate to the actual container they are in. Outside controlled |
| 28 | circumstances (like linking) it is probably not useful to do more than |
| 29 | compare these pointers, since there is nothing stopping the user closing the |
| 30 | source container whenever they want to. |
| 31 | |
| 32 | Our OOM handling here is just to not do anything, because this is called deep |
| 33 | enough in the call stack that doing anything useful is painfully difficult: |
| 34 | the worst consequence if we do OOM is a bit of type duplication anyway. */ |
| 35 | |
| 36 | void |
| 37 | ctf_add_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type, |
| 38 | ctf_file_t *dst_fp, ctf_id_t dst_type) |
| 39 | { |
| 40 | if (LCTF_TYPE_ISPARENT (src_fp, src_type) && src_fp->ctf_parent) |
| 41 | src_fp = src_fp->ctf_parent; |
| 42 | |
| 43 | src_type = LCTF_TYPE_TO_INDEX(src_fp, src_type); |
| 44 | |
| 45 | if (LCTF_TYPE_ISPARENT (dst_fp, dst_type) && dst_fp->ctf_parent) |
| 46 | dst_fp = dst_fp->ctf_parent; |
| 47 | |
| 48 | dst_type = LCTF_TYPE_TO_INDEX(dst_fp, dst_type); |
| 49 | |
| 50 | /* This dynhash is a bit tricky: it has a multivalued (structural) key, so we |
| 51 | need to use the sized-hash machinery to generate key hashing and equality |
| 52 | functions. */ |
| 53 | |
| 54 | if (dst_fp->ctf_link_type_mapping == NULL) |
| 55 | { |
| 56 | ctf_hash_fun f = ctf_hash_type_mapping_key; |
| 57 | ctf_hash_eq_fun e = ctf_hash_eq_type_mapping_key; |
| 58 | |
| 59 | if ((dst_fp->ctf_link_type_mapping = ctf_dynhash_create (f, e, free, |
| 60 | NULL)) == NULL) |
| 61 | return; |
| 62 | } |
| 63 | |
| 64 | ctf_link_type_mapping_key_t *key; |
| 65 | key = calloc (1, sizeof (struct ctf_link_type_mapping_key)); |
| 66 | if (!key) |
| 67 | return; |
| 68 | |
| 69 | key->cltm_fp = src_fp; |
| 70 | key->cltm_idx = src_type; |
| 71 | |
| 72 | ctf_dynhash_insert (dst_fp->ctf_link_type_mapping, key, |
| 73 | (void *) (uintptr_t) dst_type); |
| 74 | } |
| 75 | |
| 76 | /* Look up a type mapping: return 0 if none. The DST_FP is modified to point to |
| 77 | the parent if need be. The ID returned is from the dst_fp's perspective. */ |
| 78 | ctf_id_t |
| 79 | ctf_type_mapping (ctf_file_t *src_fp, ctf_id_t src_type, ctf_file_t **dst_fp) |
| 80 | { |
| 81 | ctf_link_type_mapping_key_t key; |
| 82 | ctf_file_t *target_fp = *dst_fp; |
| 83 | ctf_id_t dst_type = 0; |
| 84 | |
| 85 | if (LCTF_TYPE_ISPARENT (src_fp, src_type) && src_fp->ctf_parent) |
| 86 | src_fp = src_fp->ctf_parent; |
| 87 | |
| 88 | src_type = LCTF_TYPE_TO_INDEX(src_fp, src_type); |
| 89 | key.cltm_fp = src_fp; |
| 90 | key.cltm_idx = src_type; |
| 91 | |
| 92 | if (target_fp->ctf_link_type_mapping) |
| 93 | dst_type = (uintptr_t) ctf_dynhash_lookup (target_fp->ctf_link_type_mapping, |
| 94 | &key); |
| 95 | |
| 96 | if (dst_type != 0) |
| 97 | { |
| 98 | dst_type = LCTF_INDEX_TO_TYPE (target_fp, dst_type, |
| 99 | target_fp->ctf_parent != NULL); |
| 100 | *dst_fp = target_fp; |
| 101 | return dst_type; |
| 102 | } |
| 103 | |
| 104 | if (target_fp->ctf_parent) |
| 105 | target_fp = target_fp->ctf_parent; |
| 106 | else |
| 107 | return 0; |
| 108 | |
| 109 | if (target_fp->ctf_link_type_mapping) |
| 110 | dst_type = (uintptr_t) ctf_dynhash_lookup (target_fp->ctf_link_type_mapping, |
| 111 | &key); |
| 112 | |
| 113 | if (dst_type) |
| 114 | dst_type = LCTF_INDEX_TO_TYPE (target_fp, dst_type, |
| 115 | target_fp->ctf_parent != NULL); |
| 116 | |
| 117 | *dst_fp = target_fp; |
| 118 | return dst_type; |
| 119 | } |
| 120 | |
| 121 | /* Linker machinery. |
| 122 | |
| 123 | CTF linking consists of adding CTF archives full of content to be merged into |
| 124 | this one to the current file (which must be writable) by calling |
| 125 | ctf_link_add_ctf(). Once this is done, a call to ctf_link() will merge the |
| 126 | type tables together, generating new CTF files as needed, with this one as a |
| 127 | parent, to contain types from the inputs which conflict. |
| 128 | ctf_link_add_strtab() takes a callback which provides string/offset pairs to |
| 129 | be added to the external symbol table and deduplicated from all CTF string |
| 130 | tables in the output link; ctf_link_shuffle_syms() takes a callback which |
| 131 | provides symtab entries in ascending order, and shuffles the function and |
| 132 | data sections to match; and ctf_link_write() emits a CTF file (if there are |
| 133 | no conflicts requiring per-compilation-unit sub-CTF files) or CTF archives |
| 134 | (otherwise) and returns it, suitable for addition in the .ctf section of the |
| 135 | output. */ |
| 136 | |
| 137 | /* Add a file to a link. */ |
| 138 | |
| 139 | static void ctf_arc_close_thunk (void *arc) |
| 140 | { |
| 141 | ctf_arc_close ((ctf_archive_t *) arc); |
| 142 | } |
| 143 | |
| 144 | static void ctf_file_close_thunk (void *file) |
| 145 | { |
| 146 | ctf_file_close ((ctf_file_t *) file); |
| 147 | } |
| 148 | |
| 149 | int |
| 150 | ctf_link_add_ctf (ctf_file_t *fp, ctf_archive_t *ctf, const char *name) |
| 151 | { |
| 152 | char *dupname = NULL; |
| 153 | |
| 154 | if (fp->ctf_link_outputs) |
| 155 | return (ctf_set_errno (fp, ECTF_LINKADDEDLATE)); |
| 156 | if (fp->ctf_link_inputs == NULL) |
| 157 | fp->ctf_link_inputs = ctf_dynhash_create (ctf_hash_string, |
| 158 | ctf_hash_eq_string, free, |
| 159 | ctf_arc_close_thunk); |
| 160 | |
| 161 | if (fp->ctf_link_inputs == NULL) |
| 162 | goto oom; |
| 163 | |
| 164 | if ((dupname = strdup (name)) == NULL) |
| 165 | goto oom; |
| 166 | |
| 167 | if (ctf_dynhash_insert (fp->ctf_link_inputs, dupname, ctf) < 0) |
| 168 | goto oom; |
| 169 | |
| 170 | return 0; |
| 171 | oom: |
| 172 | free (fp->ctf_link_inputs); |
| 173 | fp->ctf_link_inputs = NULL; |
| 174 | free (dupname); |
| 175 | return (ctf_set_errno (fp, ENOMEM)); |
| 176 | } |
| 177 | |
| 178 | /* Return a per-CU output CTF dictionary suitable for the given CU, creating and |
| 179 | interning it if need be. */ |
| 180 | |
| 181 | static ctf_file_t * |
| 182 | ctf_create_per_cu (ctf_file_t *fp, const char *filename, const char *cuname) |
| 183 | { |
| 184 | ctf_file_t *cu_fp; |
| 185 | const char *ctf_name = NULL; |
| 186 | char *dynname = NULL; |
| 187 | |
| 188 | /* First, check the mapping table and translate the per-CU name we use |
| 189 | accordingly. We check both the input filename and the CU name. Only if |
| 190 | neither are set do we fall back to the input filename as the per-CU |
| 191 | dictionary name. We prefer the filename because this is easier for likely |
| 192 | callers to determine. */ |
| 193 | |
| 194 | if (fp->ctf_link_cu_mapping) |
| 195 | { |
| 196 | if (((ctf_name = ctf_dynhash_lookup (fp->ctf_link_cu_mapping, filename)) == NULL) && |
| 197 | ((ctf_name = ctf_dynhash_lookup (fp->ctf_link_cu_mapping, cuname)) == NULL)) |
| 198 | ctf_name = filename; |
| 199 | } |
| 200 | |
| 201 | if (ctf_name == NULL) |
| 202 | ctf_name = filename; |
| 203 | |
| 204 | if ((cu_fp = ctf_dynhash_lookup (fp->ctf_link_outputs, ctf_name)) == NULL) |
| 205 | { |
| 206 | int err; |
| 207 | |
| 208 | if ((cu_fp = ctf_create (&err)) == NULL) |
| 209 | { |
| 210 | ctf_dprintf ("Cannot create per-CU CTF archive for CU %s from " |
| 211 | "input file %s: %s\n", cuname, filename, |
| 212 | ctf_errmsg (err)); |
| 213 | ctf_set_errno (fp, err); |
| 214 | return NULL; |
| 215 | } |
| 216 | |
| 217 | if ((dynname = strdup (ctf_name)) == NULL) |
| 218 | goto oom; |
| 219 | if (ctf_dynhash_insert (fp->ctf_link_outputs, dynname, cu_fp) < 0) |
| 220 | goto oom; |
| 221 | |
| 222 | ctf_import (cu_fp, fp); |
| 223 | ctf_cuname_set (cu_fp, cuname); |
| 224 | ctf_parent_name_set (cu_fp, _CTF_SECTION); |
| 225 | } |
| 226 | return cu_fp; |
| 227 | |
| 228 | oom: |
| 229 | free (dynname); |
| 230 | ctf_file_close (cu_fp); |
| 231 | ctf_set_errno (fp, ENOMEM); |
| 232 | return NULL; |
| 233 | } |
| 234 | |
| 235 | /* Add a mapping directing that the CU named FROM should have its |
| 236 | conflicting/non-duplicate types (depending on link mode) go into a container |
| 237 | named TO. Many FROMs can share a TO: in this case, the effect on conflicting |
| 238 | types is not yet defined (but in time an auto-renaming algorithm will be |
| 239 | added: ugly, but there is really no right thing one can do in this |
| 240 | situation). |
| 241 | |
| 242 | We forcibly add a container named TO in every case, even though it may well |
| 243 | wind up empty, because clients that use this facility usually expect to find |
| 244 | every TO container present, even if empty, and malfunction otherwise. */ |
| 245 | |
| 246 | int |
| 247 | ctf_link_add_cu_mapping (ctf_file_t *fp, const char *from, const char *to) |
| 248 | { |
| 249 | int err; |
| 250 | char *f, *t; |
| 251 | |
| 252 | if (fp->ctf_link_cu_mapping == NULL) |
| 253 | fp->ctf_link_cu_mapping = ctf_dynhash_create (ctf_hash_string, |
| 254 | ctf_hash_eq_string, free, |
| 255 | free); |
| 256 | if (fp->ctf_link_cu_mapping == NULL) |
| 257 | return ctf_set_errno (fp, ENOMEM); |
| 258 | |
| 259 | if (fp->ctf_link_outputs == NULL) |
| 260 | fp->ctf_link_outputs = ctf_dynhash_create (ctf_hash_string, |
| 261 | ctf_hash_eq_string, free, |
| 262 | ctf_file_close_thunk); |
| 263 | |
| 264 | if (fp->ctf_link_outputs == NULL) |
| 265 | return ctf_set_errno (fp, ENOMEM); |
| 266 | |
| 267 | f = strdup (from); |
| 268 | t = strdup (to); |
| 269 | if (!f || !t) |
| 270 | goto oom; |
| 271 | |
| 272 | if (ctf_create_per_cu (fp, t, t) == NULL) |
| 273 | goto oom_noerrno; /* Errno is set for us. */ |
| 274 | |
| 275 | err = ctf_dynhash_insert (fp->ctf_link_cu_mapping, f, t); |
| 276 | if (err) |
| 277 | { |
| 278 | ctf_set_errno (fp, err); |
| 279 | goto oom_noerrno; |
| 280 | } |
| 281 | |
| 282 | return 0; |
| 283 | |
| 284 | oom: |
| 285 | ctf_set_errno (fp, errno); |
| 286 | oom_noerrno: |
| 287 | free (f); |
| 288 | free (t); |
| 289 | return -1; |
| 290 | } |
| 291 | |
| 292 | /* Set a function which is called to transform the names of archive members. |
| 293 | This is useful for applying regular transformations to many names, where |
| 294 | ctf_link_add_cu_mapping applies arbitrarily irregular changes to single |
| 295 | names. The member name changer is applied at ctf_link_write time, so it |
| 296 | cannot conflate multiple CUs into one the way ctf_link_add_cu_mapping can. |
| 297 | The changer function accepts a name and should return a new |
| 298 | dynamically-allocated name, or NULL if the name should be left unchanged. */ |
| 299 | void |
| 300 | ctf_link_set_memb_name_changer (ctf_file_t *fp, |
| 301 | ctf_link_memb_name_changer_f *changer, |
| 302 | void *arg) |
| 303 | { |
| 304 | fp->ctf_link_memb_name_changer = changer; |
| 305 | fp->ctf_link_memb_name_changer_arg = arg; |
| 306 | } |
| 307 | |
| 308 | typedef struct ctf_link_in_member_cb_arg |
| 309 | { |
| 310 | ctf_file_t *out_fp; |
| 311 | const char *file_name; |
| 312 | ctf_file_t *in_fp; |
| 313 | ctf_file_t *main_input_fp; |
| 314 | const char *cu_name; |
| 315 | char *arcname; |
| 316 | int done_main_member; |
| 317 | int share_mode; |
| 318 | int in_input_cu_file; |
| 319 | } ctf_link_in_member_cb_arg_t; |
| 320 | |
| 321 | /* Link one type into the link. We rely on ctf_add_type() to detect |
| 322 | duplicates. This is not terribly reliable yet (unnmamed types will be |
| 323 | mindlessly duplicated), but will improve shortly. */ |
| 324 | |
| 325 | static int |
| 326 | ctf_link_one_type (ctf_id_t type, int isroot _libctf_unused_, void *arg_) |
| 327 | { |
| 328 | ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_; |
| 329 | ctf_file_t *per_cu_out_fp; |
| 330 | int err; |
| 331 | |
| 332 | if (arg->share_mode != CTF_LINK_SHARE_UNCONFLICTED) |
| 333 | { |
| 334 | ctf_dprintf ("Share-duplicated mode not yet implemented.\n"); |
| 335 | return ctf_set_errno (arg->out_fp, ECTF_NOTYET); |
| 336 | } |
| 337 | |
| 338 | /* Simply call ctf_add_type: if it reports a conflict and we're adding to the |
| 339 | main CTF file, add to the per-CU archive member instead, creating it if |
| 340 | necessary. If we got this type from a per-CU archive member, add it |
| 341 | straight back to the corresponding member in the output. */ |
| 342 | |
| 343 | if (!arg->in_input_cu_file) |
| 344 | { |
| 345 | if (ctf_add_type (arg->out_fp, arg->in_fp, type) != CTF_ERR) |
| 346 | return 0; |
| 347 | |
| 348 | err = ctf_errno (arg->out_fp); |
| 349 | if (err != ECTF_CONFLICT) |
| 350 | { |
| 351 | ctf_dprintf ("Cannot link type %lx from archive member %s, input file %s " |
| 352 | "into output link: %s\n", type, arg->arcname, arg->file_name, |
| 353 | ctf_errmsg (err)); |
| 354 | return -1; |
| 355 | } |
| 356 | ctf_set_errno (arg->out_fp, 0); |
| 357 | } |
| 358 | |
| 359 | if ((per_cu_out_fp = ctf_create_per_cu (arg->out_fp, arg->file_name, |
| 360 | arg->cu_name)) == NULL) |
| 361 | return -1; /* Errno is set for us. */ |
| 362 | |
| 363 | if (ctf_add_type (per_cu_out_fp, arg->in_fp, type) != CTF_ERR) |
| 364 | return 0; |
| 365 | |
| 366 | err = ctf_errno (per_cu_out_fp); |
| 367 | if (err == ECTF_CONFLICT) |
| 368 | /* Conflicts are possible at this stage only if a non-ld user has combined |
| 369 | multiple TUs into a single output dictionary. Even in this case we do not |
| 370 | want to stop the link or propagate the error. */ |
| 371 | ctf_set_errno (arg->out_fp, 0); |
| 372 | |
| 373 | return 0; /* As above: do not lose types. */ |
| 374 | } |
| 375 | |
| 376 | /* Check if we can safely add a variable with the given type to this container. */ |
| 377 | |
| 378 | static int |
| 379 | check_variable (const char *name, ctf_file_t *fp, ctf_id_t type, |
| 380 | ctf_dvdef_t **out_dvd) |
| 381 | { |
| 382 | ctf_dvdef_t *dvd; |
| 383 | |
| 384 | dvd = ctf_dynhash_lookup (fp->ctf_dvhash, name); |
| 385 | *out_dvd = dvd; |
| 386 | if (!dvd) |
| 387 | return 1; |
| 388 | |
| 389 | if (dvd->dvd_type != type) |
| 390 | { |
| 391 | /* Variable here. Wrong type: cannot add. Just skip it, because there is |
| 392 | no way to express this in CTF. (This might be the parent, in which |
| 393 | case we'll try adding in the child first, and only then give up.) */ |
| 394 | ctf_dprintf ("Inexpressible duplicate variable %s skipped.\n", name); |
| 395 | } |
| 396 | |
| 397 | return 0; /* Already exists. */ |
| 398 | } |
| 399 | |
| 400 | /* Link one variable in. */ |
| 401 | |
| 402 | static int |
| 403 | ctf_link_one_variable (const char *name, ctf_id_t type, void *arg_) |
| 404 | { |
| 405 | ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_; |
| 406 | ctf_file_t *per_cu_out_fp; |
| 407 | ctf_id_t dst_type = 0; |
| 408 | ctf_file_t *check_fp; |
| 409 | ctf_dvdef_t *dvd; |
| 410 | |
| 411 | /* In unconflicted link mode, if this type is mapped to a type in the parent |
| 412 | container, we want to try to add to that first: if it reports a duplicate, |
| 413 | or if the type is in a child already, add straight to the child. */ |
| 414 | |
| 415 | check_fp = arg->out_fp; |
| 416 | |
| 417 | dst_type = ctf_type_mapping (arg->in_fp, type, &check_fp); |
| 418 | if (dst_type != 0) |
| 419 | { |
| 420 | if (check_fp == arg->out_fp) |
| 421 | { |
| 422 | if (check_variable (name, check_fp, dst_type, &dvd)) |
| 423 | { |
| 424 | /* No variable here: we can add it. */ |
| 425 | if (ctf_add_variable (check_fp, name, dst_type) < 0) |
| 426 | return (ctf_set_errno (arg->out_fp, ctf_errno (check_fp))); |
| 427 | return 0; |
| 428 | } |
| 429 | |
| 430 | /* Already present? Nothing to do. */ |
| 431 | if (dvd && dvd->dvd_type == type) |
| 432 | return 0; |
| 433 | } |
| 434 | } |
| 435 | |
| 436 | /* Can't add to the parent due to a name clash, or because it references a |
| 437 | type only present in the child. Try adding to the child, creating if need |
| 438 | be. */ |
| 439 | |
| 440 | if ((per_cu_out_fp = ctf_create_per_cu (arg->out_fp, arg->file_name, |
| 441 | arg->cu_name)) == NULL) |
| 442 | return -1; /* Errno is set for us. */ |
| 443 | |
| 444 | /* If the type was not found, check for it in the child too. */ |
| 445 | if (dst_type == 0) |
| 446 | { |
| 447 | check_fp = per_cu_out_fp; |
| 448 | dst_type = ctf_type_mapping (arg->in_fp, type, &check_fp); |
| 449 | |
| 450 | if (dst_type == 0) |
| 451 | { |
| 452 | ctf_dprintf ("Type %lx for variable %s in input file %s not " |
| 453 | "found: skipped.\n", type, name, arg->file_name); |
| 454 | /* Do not terminate the link: just skip the variable. */ |
| 455 | return 0; |
| 456 | } |
| 457 | } |
| 458 | |
| 459 | if (check_variable (name, per_cu_out_fp, dst_type, &dvd)) |
| 460 | if (ctf_add_variable (per_cu_out_fp, name, dst_type) < 0) |
| 461 | return (ctf_set_errno (arg->out_fp, ctf_errno (per_cu_out_fp))); |
| 462 | return 0; |
| 463 | } |
| 464 | |
| 465 | /* Merge every type and variable in this archive member into the link, so we can |
| 466 | relink things that have already had ld run on them. We use the archive |
| 467 | member name, sans any leading '.ctf.', as the CU name for ambiguous types if |
| 468 | there is one and it's not the default: otherwise, we use the name of the |
| 469 | input file. */ |
| 470 | static int |
| 471 | ctf_link_one_input_archive_member (ctf_file_t *in_fp, const char *name, void *arg_) |
| 472 | { |
| 473 | ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_; |
| 474 | int err = 0; |
| 475 | |
| 476 | if (strcmp (name, _CTF_SECTION) == 0) |
| 477 | { |
| 478 | /* This file is the default member of this archive, and has already been |
| 479 | explicitly processed. |
| 480 | |
| 481 | In the default sharing mode of CTF_LINK_SHARE_UNCONFLICTED, it does no |
| 482 | harm to rescan an existing shared repo again: all the types will just |
| 483 | end up in the same place. But in CTF_LINK_SHARE_DUPLICATED mode, this |
| 484 | causes the system to erroneously conclude that all types are duplicated |
| 485 | and should be shared, even if they are not. */ |
| 486 | |
| 487 | if (arg->done_main_member) |
| 488 | return 0; |
| 489 | arg->arcname = strdup (".ctf."); |
| 490 | if (arg->arcname) |
| 491 | { |
| 492 | char *new_name; |
| 493 | |
| 494 | new_name = ctf_str_append (arg->arcname, arg->file_name); |
| 495 | if (new_name) |
| 496 | arg->arcname = new_name; |
| 497 | else |
| 498 | free (arg->arcname); |
| 499 | } |
| 500 | } |
| 501 | else |
| 502 | { |
| 503 | arg->arcname = strdup (name); |
| 504 | |
| 505 | /* Get ambiguous types from our parent. */ |
| 506 | ctf_import (in_fp, arg->main_input_fp); |
| 507 | arg->in_input_cu_file = 1; |
| 508 | } |
| 509 | |
| 510 | if (!arg->arcname) |
| 511 | return ctf_set_errno (in_fp, ENOMEM); |
| 512 | |
| 513 | arg->cu_name = name; |
| 514 | if (strncmp (arg->cu_name, ".ctf.", strlen (".ctf.")) == 0) |
| 515 | arg->cu_name += strlen (".ctf."); |
| 516 | arg->in_fp = in_fp; |
| 517 | |
| 518 | if ((err = ctf_type_iter_all (in_fp, ctf_link_one_type, arg)) > -1) |
| 519 | err = ctf_variable_iter (in_fp, ctf_link_one_variable, arg); |
| 520 | |
| 521 | arg->in_input_cu_file = 0; |
| 522 | free (arg->arcname); |
| 523 | |
| 524 | if (err < 0) |
| 525 | return -1; /* Errno is set for us. */ |
| 526 | |
| 527 | return 0; |
| 528 | } |
| 529 | |
| 530 | /* Dump the unnecessary link type mapping after one input file is processed. */ |
| 531 | static void |
| 532 | empty_link_type_mapping (void *key _libctf_unused_, void *value, |
| 533 | void *arg _libctf_unused_) |
| 534 | { |
| 535 | ctf_file_t *fp = (ctf_file_t *) value; |
| 536 | |
| 537 | if (fp->ctf_link_type_mapping) |
| 538 | ctf_dynhash_empty (fp->ctf_link_type_mapping); |
| 539 | } |
| 540 | |
| 541 | /* Link one input file's types into the output file. */ |
| 542 | static void |
| 543 | ctf_link_one_input_archive (void *key, void *value, void *arg_) |
| 544 | { |
| 545 | const char *file_name = (const char *) key; |
| 546 | ctf_archive_t *arc = (ctf_archive_t *) value; |
| 547 | ctf_link_in_member_cb_arg_t *arg = (ctf_link_in_member_cb_arg_t *) arg_; |
| 548 | int err; |
| 549 | |
| 550 | arg->file_name = file_name; |
| 551 | arg->done_main_member = 0; |
| 552 | if ((arg->main_input_fp = ctf_arc_open_by_name (arc, NULL, &err)) == NULL) |
| 553 | if (err != ECTF_ARNNAME) |
| 554 | { |
| 555 | ctf_dprintf ("Cannot open main archive member in input file %s in the " |
| 556 | "link: skipping: %s.\n", arg->file_name, |
| 557 | ctf_errmsg (err)); |
| 558 | return; |
| 559 | } |
| 560 | |
| 561 | if (ctf_link_one_input_archive_member (arg->main_input_fp, |
| 562 | _CTF_SECTION, arg) < 0) |
| 563 | { |
| 564 | ctf_file_close (arg->main_input_fp); |
| 565 | return; |
| 566 | } |
| 567 | arg->done_main_member = 1; |
| 568 | if (ctf_archive_iter (arc, ctf_link_one_input_archive_member, arg) < 0) |
| 569 | ctf_dprintf ("Cannot traverse archive in input file %s: link " |
| 570 | "cannot continue: %s.\n", arg->file_name, |
| 571 | ctf_errmsg (ctf_errno (arg->out_fp))); |
| 572 | else |
| 573 | { |
| 574 | /* The only error indication to the caller is the errno: so ensure that it |
| 575 | is zero if there was no actual error from the caller. */ |
| 576 | ctf_set_errno (arg->out_fp, 0); |
| 577 | } |
| 578 | ctf_file_close (arg->main_input_fp); |
| 579 | |
| 580 | /* Discard the now-unnecessary mapping table data. */ |
| 581 | if (arg->out_fp->ctf_link_type_mapping) |
| 582 | ctf_dynhash_empty (arg->out_fp->ctf_link_type_mapping); |
| 583 | ctf_dynhash_iter (arg->out_fp->ctf_link_outputs, empty_link_type_mapping, NULL); |
| 584 | } |
| 585 | |
| 586 | /* Merge types and variable sections in all files added to the link |
| 587 | together. */ |
| 588 | int |
| 589 | ctf_link (ctf_file_t *fp, int share_mode) |
| 590 | { |
| 591 | ctf_link_in_member_cb_arg_t arg; |
| 592 | |
| 593 | memset (&arg, 0, sizeof (struct ctf_link_in_member_cb_arg)); |
| 594 | arg.out_fp = fp; |
| 595 | arg.share_mode = share_mode; |
| 596 | |
| 597 | if (fp->ctf_link_inputs == NULL) |
| 598 | return 0; /* Nothing to do. */ |
| 599 | |
| 600 | if (fp->ctf_link_outputs == NULL) |
| 601 | fp->ctf_link_outputs = ctf_dynhash_create (ctf_hash_string, |
| 602 | ctf_hash_eq_string, free, |
| 603 | ctf_file_close_thunk); |
| 604 | |
| 605 | if (fp->ctf_link_outputs == NULL) |
| 606 | return ctf_set_errno (fp, ENOMEM); |
| 607 | |
| 608 | ctf_dynhash_iter (fp->ctf_link_inputs, ctf_link_one_input_archive, |
| 609 | &arg); |
| 610 | |
| 611 | if (ctf_errno (fp) != 0) |
| 612 | return -1; |
| 613 | return 0; |
| 614 | } |
| 615 | |
| 616 | typedef struct ctf_link_out_string_cb_arg |
| 617 | { |
| 618 | const char *str; |
| 619 | uint32_t offset; |
| 620 | int err; |
| 621 | } ctf_link_out_string_cb_arg_t; |
| 622 | |
| 623 | /* Intern a string in the string table of an output per-CU CTF file. */ |
| 624 | static void |
| 625 | ctf_link_intern_extern_string (void *key _libctf_unused_, void *value, |
| 626 | void *arg_) |
| 627 | { |
| 628 | ctf_file_t *fp = (ctf_file_t *) value; |
| 629 | ctf_link_out_string_cb_arg_t *arg = (ctf_link_out_string_cb_arg_t *) arg_; |
| 630 | |
| 631 | fp->ctf_flags |= LCTF_DIRTY; |
| 632 | if (ctf_str_add_external (fp, arg->str, arg->offset) == NULL) |
| 633 | arg->err = ENOMEM; |
| 634 | } |
| 635 | |
| 636 | /* Repeatedly call ADD_STRING to acquire strings from the external string table, |
| 637 | adding them to the atoms table for this CU and all subsidiary CUs. |
| 638 | |
| 639 | If ctf_link() is also called, it must be called first if you want the new CTF |
| 640 | files ctf_link() can create to get their strings dedupped against the ELF |
| 641 | strtab properly. */ |
| 642 | int |
| 643 | ctf_link_add_strtab (ctf_file_t *fp, ctf_link_strtab_string_f *add_string, |
| 644 | void *arg) |
| 645 | { |
| 646 | const char *str; |
| 647 | uint32_t offset; |
| 648 | int err = 0; |
| 649 | |
| 650 | while ((str = add_string (&offset, arg)) != NULL) |
| 651 | { |
| 652 | ctf_link_out_string_cb_arg_t iter_arg = { str, offset, 0 }; |
| 653 | |
| 654 | fp->ctf_flags |= LCTF_DIRTY; |
| 655 | if (ctf_str_add_external (fp, str, offset) == NULL) |
| 656 | err = ENOMEM; |
| 657 | |
| 658 | ctf_dynhash_iter (fp->ctf_link_outputs, ctf_link_intern_extern_string, |
| 659 | &iter_arg); |
| 660 | if (iter_arg.err) |
| 661 | err = iter_arg.err; |
| 662 | } |
| 663 | |
| 664 | return -err; |
| 665 | } |
| 666 | |
| 667 | /* Not yet implemented. */ |
| 668 | int |
| 669 | ctf_link_shuffle_syms (ctf_file_t *fp _libctf_unused_, |
| 670 | ctf_link_iter_symbol_f *add_sym _libctf_unused_, |
| 671 | void *arg _libctf_unused_) |
| 672 | { |
| 673 | return 0; |
| 674 | } |
| 675 | |
| 676 | typedef struct ctf_name_list_accum_cb_arg |
| 677 | { |
| 678 | char **names; |
| 679 | ctf_file_t *fp; |
| 680 | ctf_file_t **files; |
| 681 | size_t i; |
| 682 | char **dynames; |
| 683 | size_t ndynames; |
| 684 | } ctf_name_list_accum_cb_arg_t; |
| 685 | |
| 686 | /* Accumulate the names and a count of the names in the link output hash, |
| 687 | and run ctf_update() on them to generate them. */ |
| 688 | static void |
| 689 | ctf_accumulate_archive_names (void *key, void *value, void *arg_) |
| 690 | { |
| 691 | const char *name = (const char *) key; |
| 692 | ctf_file_t *fp = (ctf_file_t *) value; |
| 693 | char **names; |
| 694 | ctf_file_t **files; |
| 695 | ctf_name_list_accum_cb_arg_t *arg = (ctf_name_list_accum_cb_arg_t *) arg_; |
| 696 | int err; |
| 697 | |
| 698 | if ((err = ctf_update (fp)) < 0) |
| 699 | { |
| 700 | ctf_set_errno (arg->fp, ctf_errno (fp)); |
| 701 | return; |
| 702 | } |
| 703 | |
| 704 | if ((names = realloc (arg->names, sizeof (char *) * ++(arg->i))) == NULL) |
| 705 | { |
| 706 | (arg->i)--; |
| 707 | ctf_set_errno (arg->fp, ENOMEM); |
| 708 | return; |
| 709 | } |
| 710 | |
| 711 | if ((files = realloc (arg->files, sizeof (ctf_file_t *) * arg->i)) == NULL) |
| 712 | { |
| 713 | (arg->i)--; |
| 714 | ctf_set_errno (arg->fp, ENOMEM); |
| 715 | return; |
| 716 | } |
| 717 | |
| 718 | /* Allow the caller to get in and modify the name at the last minute. If the |
| 719 | caller *does* modify the name, we have to stash away the new name the |
| 720 | caller returned so we can free it later on. (The original name is the key |
| 721 | of the ctf_link_outputs hash and is freed by the dynhash machinery.) */ |
| 722 | |
| 723 | if (fp->ctf_link_memb_name_changer) |
| 724 | { |
| 725 | char **dynames; |
| 726 | char *dyname; |
| 727 | void *nc_arg = fp->ctf_link_memb_name_changer_arg; |
| 728 | |
| 729 | dyname = fp->ctf_link_memb_name_changer (fp, name, nc_arg); |
| 730 | |
| 731 | if (dyname != NULL) |
| 732 | { |
| 733 | if ((dynames = realloc (arg->dynames, |
| 734 | sizeof (char *) * ++(arg->ndynames))) == NULL) |
| 735 | { |
| 736 | (arg->ndynames)--; |
| 737 | ctf_set_errno (arg->fp, ENOMEM); |
| 738 | return; |
| 739 | } |
| 740 | arg->dynames = dynames; |
| 741 | name = (const char *) dyname; |
| 742 | } |
| 743 | } |
| 744 | |
| 745 | arg->names = names; |
| 746 | arg->names[(arg->i) - 1] = (char *) name; |
| 747 | arg->files = files; |
| 748 | arg->files[(arg->i) - 1] = fp; |
| 749 | } |
| 750 | |
| 751 | /* Change the name of the parent CTF section, if the name transformer has got to |
| 752 | it. */ |
| 753 | static void |
| 754 | ctf_change_parent_name (void *key _libctf_unused_, void *value, void *arg) |
| 755 | { |
| 756 | ctf_file_t *fp = (ctf_file_t *) value; |
| 757 | const char *name = (const char *) arg; |
| 758 | |
| 759 | ctf_parent_name_set (fp, name); |
| 760 | } |
| 761 | |
| 762 | /* Write out a CTF archive (if there are per-CU CTF files) or a CTF file |
| 763 | (otherwise) into a new dynamically-allocated string, and return it. |
| 764 | Members with sizes above THRESHOLD are compressed. */ |
| 765 | unsigned char * |
| 766 | ctf_link_write (ctf_file_t *fp, size_t *size, size_t threshold) |
| 767 | { |
| 768 | ctf_name_list_accum_cb_arg_t arg; |
| 769 | char **names; |
| 770 | char *transformed_name = NULL; |
| 771 | ctf_file_t **files; |
| 772 | FILE *f = NULL; |
| 773 | int err; |
| 774 | long fsize; |
| 775 | const char *errloc; |
| 776 | unsigned char *buf = NULL; |
| 777 | |
| 778 | memset (&arg, 0, sizeof (ctf_name_list_accum_cb_arg_t)); |
| 779 | arg.fp = fp; |
| 780 | |
| 781 | if (ctf_update (fp) < 0) |
| 782 | { |
| 783 | errloc = "CTF file construction"; |
| 784 | goto err; |
| 785 | } |
| 786 | |
| 787 | if (fp->ctf_link_outputs) |
| 788 | { |
| 789 | ctf_dynhash_iter (fp->ctf_link_outputs, ctf_accumulate_archive_names, &arg); |
| 790 | if (ctf_errno (fp) < 0) |
| 791 | { |
| 792 | errloc = "hash creation"; |
| 793 | goto err; |
| 794 | } |
| 795 | } |
| 796 | |
| 797 | /* No extra outputs? Just write a simple ctf_file_t. */ |
| 798 | if (arg.i == 0) |
| 799 | return ctf_write_mem (fp, size, threshold); |
| 800 | |
| 801 | /* Writing an archive. Stick ourselves (the shared repository, parent of all |
| 802 | other archives) on the front of it with the default name. */ |
| 803 | if ((names = realloc (arg.names, sizeof (char *) * (arg.i + 1))) == NULL) |
| 804 | { |
| 805 | errloc = "name reallocation"; |
| 806 | goto err_no; |
| 807 | } |
| 808 | arg.names = names; |
| 809 | memmove (&(arg.names[1]), arg.names, sizeof (char *) * (arg.i)); |
| 810 | |
| 811 | arg.names[0] = (char *) _CTF_SECTION; |
| 812 | if (fp->ctf_link_memb_name_changer) |
| 813 | { |
| 814 | void *nc_arg = fp->ctf_link_memb_name_changer_arg; |
| 815 | |
| 816 | transformed_name = fp->ctf_link_memb_name_changer (fp, _CTF_SECTION, |
| 817 | nc_arg); |
| 818 | |
| 819 | if (transformed_name != NULL) |
| 820 | { |
| 821 | arg.names[0] = transformed_name; |
| 822 | ctf_dynhash_iter (fp->ctf_link_outputs, ctf_change_parent_name, |
| 823 | transformed_name); |
| 824 | } |
| 825 | } |
| 826 | |
| 827 | if ((files = realloc (arg.files, |
| 828 | sizeof (struct ctf_file *) * (arg.i + 1))) == NULL) |
| 829 | { |
| 830 | errloc = "ctf_file reallocation"; |
| 831 | goto err_no; |
| 832 | } |
| 833 | arg.files = files; |
| 834 | memmove (&(arg.files[1]), arg.files, sizeof (ctf_file_t *) * (arg.i)); |
| 835 | arg.files[0] = fp; |
| 836 | |
| 837 | if ((f = tmpfile ()) == NULL) |
| 838 | { |
| 839 | errloc = "tempfile creation"; |
| 840 | goto err_no; |
| 841 | } |
| 842 | |
| 843 | if ((err = ctf_arc_write_fd (fileno (f), arg.files, arg.i + 1, |
| 844 | (const char **) arg.names, |
| 845 | threshold)) < 0) |
| 846 | { |
| 847 | errloc = "archive writing"; |
| 848 | ctf_set_errno (fp, err); |
| 849 | goto err; |
| 850 | } |
| 851 | |
| 852 | if (fseek (f, 0, SEEK_END) < 0) |
| 853 | { |
| 854 | errloc = "seeking to end"; |
| 855 | goto err_no; |
| 856 | } |
| 857 | |
| 858 | if ((fsize = ftell (f)) < 0) |
| 859 | { |
| 860 | errloc = "filesize determination"; |
| 861 | goto err_no; |
| 862 | } |
| 863 | |
| 864 | if (fseek (f, 0, SEEK_SET) < 0) |
| 865 | { |
| 866 | errloc = "filepos resetting"; |
| 867 | goto err_no; |
| 868 | } |
| 869 | |
| 870 | if ((buf = malloc (fsize)) == NULL) |
| 871 | { |
| 872 | errloc = "CTF archive buffer allocation"; |
| 873 | goto err_no; |
| 874 | } |
| 875 | |
| 876 | while (!feof (f) && fread (buf, fsize, 1, f) == 0) |
| 877 | if (ferror (f)) |
| 878 | { |
| 879 | errloc = "reading archive from temporary file"; |
| 880 | goto err_no; |
| 881 | } |
| 882 | |
| 883 | *size = fsize; |
| 884 | free (arg.names); |
| 885 | free (arg.files); |
| 886 | free (transformed_name); |
| 887 | if (arg.ndynames) |
| 888 | { |
| 889 | size_t i; |
| 890 | for (i = 0; i < arg.ndynames; i++) |
| 891 | free (arg.dynames[i]); |
| 892 | free (arg.dynames); |
| 893 | } |
| 894 | return buf; |
| 895 | |
| 896 | err_no: |
| 897 | ctf_set_errno (fp, errno); |
| 898 | err: |
| 899 | free (buf); |
| 900 | if (f) |
| 901 | fclose (f); |
| 902 | free (arg.names); |
| 903 | free (arg.files); |
| 904 | free (transformed_name); |
| 905 | if (arg.ndynames) |
| 906 | { |
| 907 | size_t i; |
| 908 | for (i = 0; i < arg.ndynames; i++) |
| 909 | free (arg.dynames[i]); |
| 910 | free (arg.dynames); |
| 911 | } |
| 912 | ctf_dprintf ("Cannot write archive in link: %s failure: %s\n", errloc, |
| 913 | ctf_errmsg (ctf_errno (fp))); |
| 914 | return NULL; |
| 915 | } |