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 */
53Target		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)
61static char	def_Plibpath[] = "/lib/64:/usr/lib/64";
62#else
63static char	def_Plibpath[] = "/usr/ccs/lib:/lib:/usr/lib";
64#endif
65
66/*
67 * A default elf header provides for simplifying diagnostic processing.
68 */
69static 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 */
78void
79ld_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 */
111int
112ld_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 */
143int
144ld_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 */
502static void
503ifl_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 */
518void
519ld_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}
563