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
29 /*
30 * Processing of relocatable objects and shared objects.
31 */
32
33 /*
34 * ld -- link/editor main program
35 */
36 #include <sys/types.h>
37 #include <sys/time.h>
38 #include <sys/mman.h>
39 #include <string.h>
40 #include <stdio.h>
41 #include <locale.h>
42 #include <stdarg.h>
43 #include <debug.h>
44 #include "msg.h"
45 #include "_libld.h"
46
47 /*
48 * All target specific code is referenced via this global variable, which
49 * is initialized in ld_main(). This allows the linker to function as
50 * a cross linker, by vectoring to the target-specific code for the
51 * current target machine.
52 */
53 Target ld_targ;
54
55 /*
56 * A default library search path is used if one was not supplied on the command
57 * line. Note: these strings can not use MSG_ORIG() since they are modified as
58 * part of the path processing.
59 */
60 #if defined(_ELF64)
61 static char def_Plibpath[] = "/lib/64:/usr/lib/64";
62 #else
63 static char def_Plibpath[] = "/usr/ccs/lib:/lib:/usr/lib";
64 #endif
65
66 /*
67 * A default elf header provides for simplifying diagnostic processing.
68 */
69 static Ehdr def_ehdr = { { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3,
70 ELFCLASSNONE, ELFDATANONE }, 0, EM_NONE,
71 EV_CURRENT };
72
73 /*
74 * ld-centric wrapper on top of veprintf():
75 * - Accepts output descriptor rather than linkmap list
76 * - Sets the FLG_OF_FATAL/FLG_OF_WARN flags as necessary
77 */
78 void
79 ld_eprintf(Ofl_desc *ofl, Error error, const char *format, ...)
80 {
81 va_list args;
82
83 /* Set flag indicating type of error being issued */
84 switch (error) {
85 case ERR_NONE:
86 case ERR_WARNING_NF:
87 break;
88 case ERR_WARNING:
89 ofl->ofl_flags |= FLG_OF_WARN;
90 break;
91 case ERR_GUIDANCE:
92 if ((ofl->ofl_guideflags & FLG_OFG_ENABLE) == 0)
93 return;
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
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
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))) == 0)
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 = (char *)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 if (ofl->ofl_flags & FLG_OF_FATAL) {
198 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_FLAGS));
199 /* If any ERR_GUIDANCE messages were issued, add a summary */
200 if (ofl->ofl_guideflags & FLG_OFG_ISSUED)
201 ld_eprintf(ofl, ERR_GUIDANCE,
202 MSG_INTL(MSG_GUIDE_SUMMARY));
203 return (1);
204 }
205
206 /*
207 * At this point a call such as ld -V is considered complete.
208 */
209 if (ofl->ofl_flags1 & FLG_OF1_DONE)
210 return (0);
211
212 /* Initialize signal handler */
213 ld_init_sighandler(ofl);
214
215 /*
216 * Determine whether any support libraries should be loaded,
217 * (either through the SGS_SUPPORT environment variable and/or
218 * through the -S option).
219 */
220 #if defined(_LP64)
221 if ((sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT_64))) == NULL)
222 #else
223 if ((sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT_32))) == NULL)
224 #endif
225 sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT));
226
227 if (sgs_support && sgs_support[0]) {
228 const char *sep = MSG_ORIG(MSG_STR_COLON);
229 char *lib;
230 char *lasts;
231
232 DBG_CALL(Dbg_support_req(ofl->ofl_lml, sgs_support,
233 DBG_SUP_ENVIRON));
234 if ((lib = strtok_r(sgs_support, sep, &lasts)) != NULL) {
235 do {
236 if (ld_sup_loadso(ofl, lib) == S_ERROR)
237 return (ld_exit(ofl));
238 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
239
240 } while ((lib = strtok_r(NULL, sep, &lasts)) != NULL);
241 }
242 }
243 if (lib_support) {
244 Aliste idx;
245 char *lib;
246
247 for (APLIST_TRAVERSE(lib_support, idx, lib)) {
248 DBG_CALL(Dbg_support_req(ofl->ofl_lml, lib,
249 DBG_SUP_CMDLINE));
250 if (ld_sup_loadso(ofl, lib) == S_ERROR)
251 return (ld_exit(ofl));
252 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
253 }
254 }
255
256 DBG_CALL(Dbg_ent_print(ofl->ofl_lml,
257 ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
258 ofl->ofl_ents));
259 DBG_CALL(Dbg_seg_list(ofl->ofl_lml,
260 ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
261 ofl->ofl_segs));
262
263 /*
264 * The objscnt and soscnt variables were used to estimate the expected
265 * input files, and size the symbol hash buckets accordingly. Reset
266 * these values now, so as to gain an accurate count from pass two, for
267 * later statistics diagnostics.
268 */
269 ofl->ofl_objscnt = ofl->ofl_soscnt = 0;
270
271 /*
272 * Determine whether we can create the file before going any further.
273 */
274 if (ld_open_outfile(ofl) == S_ERROR)
275 return (ld_exit(ofl));
276
277 /*
278 * If the user didn't supply a library path supply a default. And, if
279 * no run-path has been specified (-R), see if the environment variable
280 * is in use (historic).
281 */
282 if (Plibpath == NULL)
283 Plibpath = def_Plibpath;
284
285 if (ofl->ofl_rpath == NULL) {
286 char *rpath;
287
288 if (((rpath = getenv(MSG_ORIG(MSG_LD_RUN_PATH))) != NULL) &&
289 rpath[0])
290 ofl->ofl_rpath = rpath;
291 }
292
293 /*
294 * Argument pass two. Input all libraries and objects.
295 */
296 if (ld_lib_setup(ofl) == S_ERROR)
297 return (ld_exit(ofl));
298
299 /*
300 * Call ld_start() with the etype of our output file and the
301 * output file name.
302 */
303 if (ofl->ofl_flags & FLG_OF_SHAROBJ)
304 etype = ET_DYN;
305 else if (ofl->ofl_flags & FLG_OF_RELOBJ)
306 etype = ET_REL;
307 else
308 etype = ET_EXEC;
309
310 ld_sup_start(ofl, etype, argv[0]);
311
312 /*
313 * Process all input files.
314 */
315 if (ld_process_files(ofl, argc, argv) == S_ERROR)
316 return (ld_exit(ofl));
317 if (ofl->ofl_flags & FLG_OF_FATAL) {
318 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_FILES),
319 ofl->ofl_name);
320 return (ld_exit(ofl));
321 }
322
323 ld_sup_input_done(ofl);
324
325 /*
326 * Now that all input section processing is complete, validate and
327 * process any SHT_SUNW_move sections.
328 */
329 if (ofl->ofl_ismove && (ld_process_move(ofl) == S_ERROR))
330 return (ld_exit(ofl));
331
332 /*
333 * Before validating all symbols count the number of relocation entries.
334 * If copy relocations exist, COMMON symbols must be generated which are
335 * assigned to the executables .bss. During sym_validate() the actual
336 * size and alignment of the .bss is calculated. Doing things in this
337 * order reduces the number of symbol table traversals required (however
338 * it does take a little longer for the user to be told of any undefined
339 * symbol errors).
340 */
341 if (ld_reloc_init(ofl) == S_ERROR)
342 return (ld_exit(ofl));
343
344 /*
345 * We need to know if FLG_OF_WARN is currently set, in case
346 * we need to honor a -z fatal-warnings request. However, we also
347 * need to know if a warning due to symbol validation results from
348 * the upcoming call to ld_sym_validate() in order to issue the
349 * appropriate message for it. So we save the current value,
350 * and clear the main flag.
351 */
352 save_flg_of_warn = ofl->ofl_flags & FLG_OF_WARN;
353 ofl->ofl_flags &= ~FLG_OF_WARN;
354
355 if (ld_sym_validate(ofl) == S_ERROR)
356 return (ld_exit(ofl));
357
358 /*
359 * Now that all symbol processing is complete see if any undefined
360 * references still remain. If we observed undefined symbols the
361 * FLG_OF_FATAL bit will be set: If creating a static executable, or a
362 * dynamic executable or shared object with the -zdefs flag set, this
363 * condition is fatal. If creating a shared object with the -Bsymbolic
364 * flag set, this condition is simply a warning.
365 */
366 if (ofl->ofl_flags & FLG_OF_FATAL)
367 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_SYM_FATAL),
368 ofl->ofl_name);
369 else if (ofl->ofl_flags & FLG_OF_WARN)
370 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_ARG_SYM_WARN));
371
372 /*
373 * Guidance: Use -z defs|nodefs when building shared objects.
374 *
375 * ld_sym_validate() will mask this guidance message out unless we are
376 * intended to send it here, so all we need to do is use OFL_GUIDANCE()
377 * to decide whether to issue it or not.
378 */
379 if (OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
380 ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_DEFS));
381
382 /*
383 * Symbol processing was the final step before we start producing the
384 * output object. At this time, if we've seen warnings and the
385 * -z fatal-warnings option is specified, promote them to fatal, which
386 * will cause us to exit without creating an object.
387 *
388 * We didn't do this as the warnings were reported in order to
389 * maximize the number of problems a given link-editor invocation
390 * can diagnose. This is safe, since warnings are by definition events
391 * one can choose to ignore.
392 */
393 if (((ofl->ofl_flags | save_flg_of_warn) &
394 (FLG_OF_WARN | FLG_OF_FATWARN)) ==
395 (FLG_OF_WARN | FLG_OF_FATWARN))
396 ofl->ofl_flags |= FLG_OF_FATAL;
397
398 /*
399 * If fatal errors occurred in symbol processing, or due to warnings
400 * promoted by -z fatal-warnings, this is the end of the line.
401 */
402 if (ofl->ofl_flags & FLG_OF_FATAL)
403 return (ld_exit(ofl));
404
405 /*
406 * Generate any necessary sections.
407 */
408 if (ld_make_sections(ofl) == S_ERROR)
409 return (ld_exit(ofl));
410
411 /*
412 * Now that all sections have been added to the output file, determine
413 * whether any mapfile section ordering was specified, and verify that
414 * all mapfile ordering directives have been matched. Issue a warning
415 * for any directives that have not been matched.
416 * Also, if SHF_ORDERED sections exist, set up sort key values.
417 */
418 if (ofl->ofl_flags & (FLG_OF_OS_ORDER | FLG_OF_KEY))
419 ld_sec_validate(ofl);
420
421 /*
422 * Having collected all the input data create the initial output file
423 * image, assign virtual addresses to the image, and generate a load
424 * map if the user requested one.
425 */
426 if (ld_create_outfile(ofl) == S_ERROR)
427 return (ld_exit(ofl));
428
429 if (ld_update_outfile(ofl) == S_ERROR)
430 return (ld_exit(ofl));
431 if (ofl->ofl_flags & FLG_OF_GENMAP)
432 ld_map_out(ofl);
433
434 /*
435 * Build relocation sections and perform any relocation updates.
436 */
437 if (ld_reloc_process(ofl) == S_ERROR)
438 return (ld_exit(ofl));
439
440 /*
441 * Fill in contents for unwind header (.eh_frame_hdr)
442 */
443 if (ld_unwind_populate_hdr(ofl) == S_ERROR)
444 return (ld_exit(ofl));
445
446 /*
447 * Finally create the files elf checksum.
448 */
449 if (ofl->ofl_checksum)
450 *ofl->ofl_checksum = (Xword)elf_checksum(ofl->ofl_elf);
451
452 /*
453 * If this is a cross link to a target with a different byte
454 * order than the linker, swap the data to the target byte order.
455 */
456 if (((ofl->ofl_flags1 & FLG_OF1_ENCDIFF) != 0) &&
457 (_elf_swap_wrimage(ofl->ofl_elf) != 0)) {
458 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_SWAP_WRIMAGE),
459 ofl->ofl_name);
460 return (ld_exit(ofl));
461 }
462
463 /*
464 * We're done, so make sure the updates are flushed to the output file.
465 */
466 if ((ofl->ofl_size = elf_update(ofl->ofl_welf, ELF_C_WRITE)) == 0) {
467 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_UPDATE),
468 ofl->ofl_name);
469 return (ld_exit(ofl));
470 }
471
472 ld_sup_atexit(ofl, 0);
473
474 DBG_CALL(Dbg_statistics_ld(ofl));
475 DBG_CALL(Dbg_basic_finish(ofl->ofl_lml));
476
477 /*
478 * Wrap up debug output file if one is open
479 */
480 dbg_cleanup();
481
482 /* If any ERR_GUIDANCE messages were issued, add a summary */
483 if (ofl->ofl_guideflags & FLG_OFG_ISSUED)
484 ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_SUMMARY));
485
486 /*
487 * For performance reasons we don't actually free up the memory we've
488 * allocated, it will be freed when we exit.
489 *
490 * But the below line can be uncommented if/when we want to measure how
491 * our memory consumption and freeing are doing. We should be able to
492 * free all the memory that has been allocated as part of the link-edit
493 * process.
494 */
495 /* ld_ofl_cleanup(ofl); */
496 return (0);
497 }
498
499 /*
500 * Cleanup an Ifl_desc.
501 */
502 static void
503 ifl_list_cleanup(APlist *apl)
504 {
505 Aliste idx;
506 Ifl_desc *ifl;
507
508 for (APLIST_TRAVERSE(apl, idx, ifl)) {
509 if (ifl->ifl_elf)
510 (void) elf_end(ifl->ifl_elf);
511 }
512 }
513
514 /*
515 * Cleanup all memory that has been dynamically allocated during libld
516 * processing and elf_end() all Elf descriptors that are still open.
517 */
518 void
519 ld_ofl_cleanup(Ofl_desc *ofl)
520 {
521 Ld_heap *chp, *php;
522 Ar_desc *adp;
523 Aliste idx;
524
525 ifl_list_cleanup(ofl->ofl_objs);
526 ofl->ofl_objs = NULL;
527 ifl_list_cleanup(ofl->ofl_sos);
528 ofl->ofl_sos = NULL;
529
530 for (APLIST_TRAVERSE(ofl->ofl_ars, idx, adp)) {
531 Ar_aux *aup;
532 Elf_Arsym *arsym;
533
534 for (arsym = adp->ad_start, aup = adp->ad_aux;
535 arsym->as_name; ++arsym, ++aup) {
536 if ((aup->au_mem) && (aup->au_mem != FLG_ARMEM_PROC)) {
537 (void) elf_end(aup->au_mem->am_elf);
538
539 /*
540 * Null out all entries to this member so
541 * that we don't attempt to elf_end() it again.
542 */
543 ld_ar_member(adp, arsym, aup, 0);
544 }
545 }
546 (void) elf_end(adp->ad_elf);
547 }
548 ofl->ofl_ars = NULL;
549
550 (void) elf_end(ofl->ofl_elf);
551 (void) elf_end(ofl->ofl_welf);
552
553 for (chp = ld_heap, php = NULL; chp; php = chp, chp = chp->lh_next) {
554 if (php)
555 (void) munmap((void *)php,
556 (size_t)php->lh_end - (size_t)php);
557 }
558 if (php)
559 (void) munmap((void *)php, (size_t)php->lh_end - (size_t)php);
560
561 ld_heap = NULL;
562 }