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