1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1988 AT&T 24 * All Rights Reserved 25 * 26 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved. 27 * 28 * Copyright 2020 Joyent, Inc. 29 */ 30 31 /* 32 * Processing of relocatable objects and shared objects. 33 */ 34 35 /* 36 * ld -- link/editor main program 37 */ 38 #include <sys/types.h> 39 #include <sys/time.h> 40 #include <sys/mman.h> 41 #include <string.h> 42 #include <stdio.h> 43 #include <locale.h> 44 #include <stdarg.h> 45 #include <debug.h> 46 #include "msg.h" 47 #include "_libld.h" 48 49 /* 50 * All target specific code is referenced via this global variable, which 51 * is initialized in ld_main(). This allows the linker to function as 52 * a cross linker, by vectoring to the target-specific code for the 53 * current target machine. 54 */ 55 Target ld_targ; 56 57 /* 58 * A default library search path is used if one was not supplied on the command 59 * line. Note: these strings can not use MSG_ORIG() since they are modified as 60 * part of the path processing. 61 */ 62 #if defined(_ELF64) 63 static char def_Plibpath[] = "/lib/64:/usr/lib/64"; 64 #else 65 static char def_Plibpath[] = "/usr/ccs/lib:/lib:/usr/lib"; 66 #endif 67 68 /* 69 * A default elf header provides for simplifying diagnostic processing. 70 */ 71 static Ehdr def_ehdr = { { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, 72 ELFCLASSNONE, ELFDATANONE }, 0, EM_NONE, 73 EV_CURRENT }; 74 75 /* 76 * ld-centric wrapper on top of veprintf(): 77 * - Accepts output descriptor rather than linkmap list 78 * - Sets the FLG_OF_FATAL/FLG_OF_WARN flags as necessary 79 */ 80 void 81 ld_eprintf(Ofl_desc *ofl, Error error, const char *format, ...) 82 { 83 va_list args; 84 85 /* Set flag indicating type of error being issued */ 86 switch (error) { 87 case ERR_NONE: 88 case ERR_WARNING_NF: 89 break; 90 case ERR_WARNING: 91 ofl->ofl_flags |= FLG_OF_WARN; 92 break; 93 case ERR_GUIDANCE: 94 if ((ofl->ofl_guideflags & FLG_OFG_ENABLE) == 0) 95 return; 96 ofl->ofl_guideflags |= FLG_OFG_ISSUED; 97 ofl->ofl_flags |= FLG_OF_WARN; 98 break; 99 default: 100 ofl->ofl_flags |= FLG_OF_FATAL; 101 } 102 103 /* Issue the error */ 104 va_start(args, format); 105 veprintf(ofl->ofl_lml, error, format, args); 106 va_end(args); 107 } 108 109 /* 110 * Establish the global state necessary to link the desired machine 111 * target, as reflected by the ld_targ global variable. 112 */ 113 int 114 ld_init_target(Lm_list *lml, Half mach) 115 { 116 switch (mach) { 117 case EM_386: 118 case EM_AMD64: 119 ld_targ = *ld_targ_init_x86(); 120 break; 121 122 case EM_SPARC: 123 case EM_SPARC32PLUS: 124 case EM_SPARCV9: 125 ld_targ = *ld_targ_init_sparc(); 126 break; 127 128 default: 129 { 130 Conv_inv_buf_t inv_buf; 131 132 eprintf(lml, ERR_FATAL, MSG_INTL(MSG_TARG_UNSUPPORTED), 133 conv_ehdr_mach(mach, 0, &inv_buf)); 134 return (1); 135 } 136 } 137 138 return (0); 139 } 140 141 142 /* 143 * The main program 144 */ 145 int 146 ld_main(int argc, char **argv, Half mach) 147 { 148 char *sgs_support; /* SGS_SUPPORT environment string */ 149 Half etype; 150 Ofl_desc *ofl; 151 ofl_flag_t save_flg_of_warn; 152 153 /* 154 * Establish a base time. Total time diagnostics are relative to 155 * entering the link-editor here. 156 */ 157 (void) gettimeofday(&DBG_TOTALTIME, NULL); 158 DBG_DELTATIME = DBG_TOTALTIME; 159 160 /* Output file descriptor */ 161 if ((ofl = libld_calloc(1, sizeof (Ofl_desc))) == 0) 162 return (1); 163 164 /* Initialize target state */ 165 if (ld_init_target(NULL, mach) != 0) 166 return (1); 167 168 /* 169 * Set up the default output ELF header to satisfy diagnostic 170 * requirements, and initialize the machine and class details. 171 */ 172 ofl->ofl_dehdr = &def_ehdr; 173 def_ehdr.e_ident[EI_CLASS] = ld_targ.t_m.m_class; 174 def_ehdr.e_ident[EI_DATA] = ld_targ.t_m.m_data; 175 def_ehdr.e_machine = ld_targ.t_m.m_mach; 176 177 /* 178 * Build up linker version string 179 */ 180 if ((ofl->ofl_sgsid = (char *)libld_calloc(MSG_SGS_ID_SIZE + 181 strlen(link_ver_string) + 1, 1)) == NULL) 182 return (1); 183 (void) strcpy(ofl->ofl_sgsid, MSG_ORIG(MSG_SGS_ID)); 184 (void) strcat(ofl->ofl_sgsid, link_ver_string); 185 186 /* 187 * Argument pass one. Get all the input flags (skip any files) and 188 * check for consistency. Return from ld_process_flags() marks the 189 * end of mapfile processing. The entrance criteria and segment 190 * descriptors are complete and in their final form. 191 */ 192 if (ld_process_flags(ofl, argc, argv) == S_ERROR) { 193 /* If any ERR_GUIDANCE messages were issued, add a summary */ 194 if (ofl->ofl_guideflags & FLG_OFG_ISSUED) 195 ld_eprintf(ofl, ERR_GUIDANCE, 196 MSG_INTL(MSG_GUIDE_SUMMARY)); 197 return (1); 198 } 199 if (ofl->ofl_flags & FLG_OF_FATAL) { 200 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_FLAGS)); 201 /* If any ERR_GUIDANCE messages were issued, add a summary */ 202 if (ofl->ofl_guideflags & FLG_OFG_ISSUED) 203 ld_eprintf(ofl, ERR_GUIDANCE, 204 MSG_INTL(MSG_GUIDE_SUMMARY)); 205 return (1); 206 } 207 208 /* 209 * At this point a call such as ld -V is considered complete. 210 */ 211 if (ofl->ofl_flags1 & FLG_OF1_DONE) 212 return (0); 213 214 /* Initialize signal handler */ 215 ld_init_sighandler(ofl); 216 217 /* 218 * Determine whether any support libraries should be loaded, 219 * (either through the SGS_SUPPORT environment variable and/or 220 * through the -S option). 221 */ 222 #if defined(_LP64) 223 if ((sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT_64))) == NULL) 224 #else 225 if ((sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT_32))) == NULL) 226 #endif 227 sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT)); 228 229 if (sgs_support && sgs_support[0]) { 230 const char *sep = MSG_ORIG(MSG_STR_COLON); 231 char *lib; 232 char *lasts; 233 234 DBG_CALL(Dbg_support_req(ofl->ofl_lml, sgs_support, 235 DBG_SUP_ENVIRON)); 236 if ((lib = strtok_r(sgs_support, sep, &lasts)) != NULL) { 237 do { 238 if (ld_sup_loadso(ofl, lib) == S_ERROR) 239 return (ld_exit(ofl)); 240 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD)); 241 242 } while ((lib = strtok_r(NULL, sep, &lasts)) != NULL); 243 } 244 } 245 if (lib_support) { 246 Aliste idx; 247 char *lib; 248 249 for (APLIST_TRAVERSE(lib_support, idx, lib)) { 250 DBG_CALL(Dbg_support_req(ofl->ofl_lml, lib, 251 DBG_SUP_CMDLINE)); 252 if (ld_sup_loadso(ofl, lib) == S_ERROR) 253 return (ld_exit(ofl)); 254 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD)); 255 } 256 } 257 258 DBG_CALL(Dbg_ent_print(ofl->ofl_lml, 259 ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine, 260 ofl->ofl_ents)); 261 DBG_CALL(Dbg_seg_list(ofl->ofl_lml, 262 ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine, 263 ofl->ofl_segs)); 264 265 /* 266 * The objscnt and soscnt variables were used to estimate the expected 267 * input files, and size the symbol hash buckets accordingly. Reset 268 * these values now, so as to gain an accurate count from pass two, for 269 * later statistics diagnostics. 270 */ 271 ofl->ofl_objscnt = ofl->ofl_soscnt = 0; 272 273 /* 274 * Determine whether we can create the file before going any further. 275 */ 276 if (ld_open_outfile(ofl) == S_ERROR) 277 return (ld_exit(ofl)); 278 279 /* 280 * If the user didn't supply a library path supply a default. And, if 281 * no run-path has been specified (-R), see if the environment variable 282 * is in use (historic). 283 */ 284 if (Plibpath == NULL) 285 Plibpath = def_Plibpath; 286 287 if (ofl->ofl_rpath == NULL) { 288 char *rpath; 289 290 if (((rpath = getenv(MSG_ORIG(MSG_LD_RUN_PATH))) != NULL) && 291 rpath[0]) 292 ofl->ofl_rpath = rpath; 293 } 294 295 /* 296 * Argument pass two. Input all libraries and objects. 297 */ 298 if (ld_lib_setup(ofl) == S_ERROR) 299 return (ld_exit(ofl)); 300 301 /* 302 * Call ld_start() with the etype of our output file and the 303 * output file name. 304 */ 305 if (ofl->ofl_flags & FLG_OF_SHAROBJ) 306 etype = ET_DYN; 307 else if (ofl->ofl_flags & FLG_OF_RELOBJ) 308 etype = ET_REL; 309 else 310 etype = ET_EXEC; 311 312 ld_sup_start(ofl, etype, argv[0]); 313 314 /* 315 * Process all input files. 316 */ 317 if (ld_process_files(ofl, argc, argv) == S_ERROR) 318 return (ld_exit(ofl)); 319 if (ofl->ofl_flags & FLG_OF_FATAL) { 320 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_FILES), 321 ofl->ofl_name); 322 return (ld_exit(ofl)); 323 } 324 325 ld_sup_input_done(ofl); 326 327 /* 328 * Now that all input section processing is complete, validate and 329 * process any SHT_SUNW_move sections. 330 */ 331 if (ofl->ofl_ismove && (ld_process_move(ofl) == S_ERROR)) 332 return (ld_exit(ofl)); 333 334 /* 335 * Before validating all symbols count the number of relocation entries. 336 * If copy relocations exist, COMMON symbols must be generated which are 337 * assigned to the executables .bss. During sym_validate() the actual 338 * size and alignment of the .bss is calculated. Doing things in this 339 * order reduces the number of symbol table traversals required (however 340 * it does take a little longer for the user to be told of any undefined 341 * symbol errors). 342 */ 343 if (ld_reloc_init(ofl) == S_ERROR) 344 return (ld_exit(ofl)); 345 346 /* 347 * We need to know if FLG_OF_WARN is currently set, in case 348 * we need to honor a -z fatal-warnings request. However, we also 349 * need to know if a warning due to symbol validation results from 350 * the upcoming call to ld_sym_validate() in order to issue the 351 * appropriate message for it. So we save the current value, 352 * and clear the main flag. 353 */ 354 save_flg_of_warn = ofl->ofl_flags & FLG_OF_WARN; 355 ofl->ofl_flags &= ~FLG_OF_WARN; 356 357 if (ld_sym_validate(ofl) == S_ERROR) 358 return (ld_exit(ofl)); 359 360 /* 361 * Now that all symbol processing is complete see if any undefined 362 * references still remain. If we observed undefined symbols the 363 * FLG_OF_FATAL bit will be set: If creating a static executable, or a 364 * dynamic executable or shared object with the -zdefs flag set, this 365 * condition is fatal. If creating a shared object with the -Bsymbolic 366 * flag set, this condition is simply a warning. 367 */ 368 if (ofl->ofl_flags & FLG_OF_FATAL) 369 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_SYM_FATAL), 370 ofl->ofl_name); 371 else if (ofl->ofl_flags & FLG_OF_WARN) 372 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_ARG_SYM_WARN)); 373 374 /* 375 * Guidance: Use -z defs|nodefs when building shared objects. 376 * 377 * ld_sym_validate() will mask this guidance message out unless we are 378 * intended to send it here, so all we need to do is use OFL_GUIDANCE() 379 * to decide whether to issue it or not. 380 */ 381 if (OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS)) 382 ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_DEFS)); 383 384 /* 385 * Symbol processing was the final step before we start producing the 386 * output object. At this time, if we've seen warnings and the 387 * -z fatal-warnings option is specified, promote them to fatal, which 388 * will cause us to exit without creating an object. 389 * 390 * We didn't do this as the warnings were reported in order to 391 * maximize the number of problems a given link-editor invocation 392 * can diagnose. This is safe, since warnings are by definition events 393 * one can choose to ignore. 394 */ 395 if (((ofl->ofl_flags | save_flg_of_warn) & 396 (FLG_OF_WARN | FLG_OF_FATWARN)) == 397 (FLG_OF_WARN | FLG_OF_FATWARN)) 398 ofl->ofl_flags |= FLG_OF_FATAL; 399 400 /* 401 * If fatal errors occurred in symbol processing, or due to warnings 402 * promoted by -z fatal-warnings, this is the end of the line. 403 */ 404 if (ofl->ofl_flags & FLG_OF_FATAL) 405 return (ld_exit(ofl)); 406 407 /* 408 * Generate any necessary sections. 409 */ 410 if (ld_make_sections(ofl) == S_ERROR) 411 return (ld_exit(ofl)); 412 413 /* 414 * Now that all sections have been added to the output file, determine 415 * whether any mapfile section ordering was specified, and verify that 416 * all mapfile ordering directives have been matched. Issue a warning 417 * for any directives that have not been matched. 418 * Also, if SHF_ORDERED sections exist, set up sort key values. 419 */ 420 if (ofl->ofl_flags & (FLG_OF_OS_ORDER | FLG_OF_KEY)) 421 ld_sec_validate(ofl); 422 423 /* 424 * Having collected all the input data create the initial output file 425 * image, assign virtual addresses to the image, and generate a load 426 * map if the user requested one. 427 */ 428 if (ld_create_outfile(ofl) == S_ERROR) 429 return (ld_exit(ofl)); 430 431 if (ld_update_outfile(ofl) == S_ERROR) 432 return (ld_exit(ofl)); 433 if (ofl->ofl_flags & FLG_OF_GENMAP) 434 ld_map_out(ofl); 435 436 /* 437 * Build relocation sections and perform any relocation updates. 438 */ 439 if (ld_reloc_process(ofl) == S_ERROR) 440 return (ld_exit(ofl)); 441 442 /* 443 * Fill in contents for unwind header (.eh_frame_hdr) 444 */ 445 if (ld_unwind_populate_hdr(ofl) == S_ERROR) 446 return (ld_exit(ofl)); 447 448 /* 449 * Finally create the files elf checksum. 450 */ 451 if (ofl->ofl_checksum) 452 *ofl->ofl_checksum = (Xword)elf_checksum(ofl->ofl_elf); 453 454 /* 455 * If this is a cross link to a target with a different byte 456 * order than the linker, swap the data to the target byte order. 457 */ 458 if (((ofl->ofl_flags1 & FLG_OF1_ENCDIFF) != 0) && 459 (_elf_swap_wrimage(ofl->ofl_elf) != 0)) { 460 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_SWAP_WRIMAGE), 461 ofl->ofl_name); 462 return (ld_exit(ofl)); 463 } 464 465 /* 466 * We're done, so make sure the updates are flushed to the output file. 467 */ 468 if ((ofl->ofl_size = elf_update(ofl->ofl_welf, ELF_C_WRITE)) == 0) { 469 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_UPDATE), 470 ofl->ofl_name); 471 return (ld_exit(ofl)); 472 } 473 474 ld_sup_atexit(ofl, 0); 475 476 DBG_CALL(Dbg_statistics_ld(ofl)); 477 DBG_CALL(Dbg_basic_finish(ofl->ofl_lml)); 478 479 /* 480 * Wrap up debug output file if one is open 481 */ 482 dbg_cleanup(); 483 484 /* If any ERR_GUIDANCE messages were issued, add a summary */ 485 if (ofl->ofl_guideflags & FLG_OFG_ISSUED) { 486 ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_SUMMARY)); 487 ofl->ofl_guideflags &= ~FLG_OFG_ISSUED; 488 } 489 490 /* 491 * One final check for any new warnings we found that should fail the 492 * link edit. 493 */ 494 if ((ofl->ofl_flags & (FLG_OF_WARN | FLG_OF_FATWARN)) == 495 (FLG_OF_WARN | FLG_OF_FATWARN)) 496 return (ld_exit(ofl)); 497 498 /* 499 * For performance reasons we don't actually free up the memory we've 500 * allocated, it will be freed when we exit. 501 * 502 * But the below line can be uncommented if/when we want to measure how 503 * our memory consumption and freeing are doing. We should be able to 504 * free all the memory that has been allocated as part of the link-edit 505 * process. 506 */ 507 /* ld_ofl_cleanup(ofl); */ 508 return (0); 509 } 510 511 /* 512 * Cleanup an Ifl_desc. 513 */ 514 static void 515 ifl_list_cleanup(APlist *apl) 516 { 517 Aliste idx; 518 Ifl_desc *ifl; 519 520 for (APLIST_TRAVERSE(apl, idx, ifl)) { 521 if (ifl->ifl_elf) 522 (void) elf_end(ifl->ifl_elf); 523 } 524 } 525 526 /* 527 * Cleanup all memory that has been dynamically allocated during libld 528 * processing and elf_end() all Elf descriptors that are still open. 529 */ 530 void 531 ld_ofl_cleanup(Ofl_desc *ofl) 532 { 533 Ld_heap *chp, *php; 534 Ar_desc *adp; 535 Aliste idx; 536 537 ifl_list_cleanup(ofl->ofl_objs); 538 ofl->ofl_objs = NULL; 539 ifl_list_cleanup(ofl->ofl_sos); 540 ofl->ofl_sos = NULL; 541 542 for (APLIST_TRAVERSE(ofl->ofl_ars, idx, adp)) { 543 Ar_aux *aup; 544 Elf_Arsym *arsym; 545 546 for (arsym = adp->ad_start, aup = adp->ad_aux; 547 arsym->as_name; ++arsym, ++aup) { 548 if ((aup->au_mem) && (aup->au_mem != FLG_ARMEM_PROC)) { 549 (void) elf_end(aup->au_mem->am_elf); 550 551 /* 552 * Null out all entries to this member so 553 * that we don't attempt to elf_end() it again. 554 */ 555 ld_ar_member(adp, arsym, aup, 0); 556 } 557 } 558 (void) elf_end(adp->ad_elf); 559 } 560 ofl->ofl_ars = NULL; 561 562 (void) elf_end(ofl->ofl_elf); 563 (void) elf_end(ofl->ofl_welf); 564 565 for (chp = ld_heap, php = NULL; chp; php = chp, chp = chp->lh_next) { 566 if (php) 567 (void) munmap((void *)php, 568 (size_t)php->lh_end - (size_t)php); 569 } 570 if (php) 571 (void) munmap((void *)php, (size_t)php->lh_end - (size_t)php); 572 573 ld_heap = NULL; 574 } 575