path: root/usr/src/cmd/sgs/libld/common/ldmain.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 *	Copyright (c) 1988 AT&T
 *	  All Rights Reserved
 *
 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 *
 * Copyright 2020 Joyent, Inc.
 */

/*
 * Processing of relocatable objects and shared objects.
 */

/*
 * ld -- link/editor main program
 */
#include	<sys/types.h>
#include	<sys/time.h>
#include	<sys/mman.h>
#include	<string.h>
#include	<stdio.h>
#include	<locale.h>
#include	<stdarg.h>
#include	<debug.h>
#include	"msg.h"
#include	"_libld.h"

/*
 * All target specific code is referenced via this global variable, which
 * is initialized in ld_main(). This allows the linker to function as
 * a cross linker, by vectoring to the target-specific code for the
 * current target machine.
 */
Target		ld_targ;

/*
 * A default library search path is used if one was not supplied on the command
 * line.  Note: these strings can not use MSG_ORIG() since they are modified as
 * part of the path processing.
 */
#if	defined(_ELF64)
static char	def_Plibpath[] = "/lib/64:/usr/lib/64";
#else
static char	def_Plibpath[] = "/usr/ccs/lib:/lib:/usr/lib";
#endif

/*
 * A default elf header provides for simplifying diagnostic processing.
 */
static Ehdr	def_ehdr = { { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3,
			    ELFCLASSNONE, ELFDATANONE }, 0, EM_NONE,
			    EV_CURRENT };

/*
 * ld-centric wrapper on top of veprintf():
 * - Accepts output descriptor rather than linkmap list
 * - Sets the FLG_OF_FATAL/FLG_OF_WARN flags as necessary
 */
void
ld_eprintf(Ofl_desc *ofl, Error error, const char *format, ...)
{
	va_list	args;

	/* Set flag indicating type of error being issued */
	switch (error) {
	case ERR_NONE:
	case ERR_WARNING_NF:
		break;
	case ERR_WARNING:
		ofl->ofl_flags |= FLG_OF_WARN;
		break;
	case ERR_GUIDANCE:
		ofl->ofl_guideflags |= FLG_OFG_ISSUED;
		ofl->ofl_flags |= FLG_OF_WARN;
		break;
	default:
		ofl->ofl_flags |= FLG_OF_FATAL;
	}

	/* Issue the error */
	va_start(args, format);
	veprintf(ofl->ofl_lml, error, format, args);
	va_end(args);
}

/*
 * Establish the global state necessary to link the desired machine
 * target, as reflected by the ld_targ global variable.
 */
int
ld_init_target(Lm_list *lml, Half mach)
{
	switch (mach) {
	case EM_386:
	case EM_AMD64:
		ld_targ = *ld_targ_init_x86();
		break;

	case EM_SPARC:
	case EM_SPARC32PLUS:
	case EM_SPARCV9:
		ld_targ = *ld_targ_init_sparc();
		break;

	default:
		{
			Conv_inv_buf_t	inv_buf;

			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_TARG_UNSUPPORTED),
			    conv_ehdr_mach(mach, 0, &inv_buf));
			return (1);
		}
	}

	return (0);
}


/*
 * The main program
 */
int
ld_main(int argc, char **argv, Half mach)
{
	char		*sgs_support;	/* SGS_SUPPORT environment string */
	Half		etype;
	Ofl_desc	*ofl;
	ofl_flag_t	save_flg_of_warn;

	/*
	 * Establish a base time.  Total time diagnostics are relative to
	 * entering the link-editor here.
	 */
	(void) gettimeofday(&DBG_TOTALTIME, NULL);
	DBG_DELTATIME = DBG_TOTALTIME;

	/* Output file descriptor */
	if ((ofl = libld_calloc(1, sizeof (Ofl_desc))) == NULL)
		return (1);

	/* Initialize target state */
	if (ld_init_target(NULL, mach) != 0)
		return (1);

	/*
	 * Set up the default output ELF header to satisfy diagnostic
	 * requirements, and initialize the machine and class details.
	 */
	ofl->ofl_dehdr = &def_ehdr;
	def_ehdr.e_ident[EI_CLASS] = ld_targ.t_m.m_class;
	def_ehdr.e_ident[EI_DATA] = ld_targ.t_m.m_data;
	def_ehdr.e_machine = ld_targ.t_m.m_mach;

	/*
	 * Build up linker version string
	 */
	if ((ofl->ofl_sgsid = libld_calloc(MSG_SGS_ID_SIZE +
	    strlen(link_ver_string) + 1, 1)) == NULL)
		return (1);
	(void) strcpy(ofl->ofl_sgsid, MSG_ORIG(MSG_SGS_ID));
	(void) strcat(ofl->ofl_sgsid, link_ver_string);

	/*
	 * Argument pass one.  Get all the input flags (skip any files) and
	 * check for consistency.  Return from ld_process_flags() marks the
	 * end of mapfile processing.  The entrance criteria and segment
	 * descriptors are complete and in their final form.
	 */
	if (ld_process_flags(ofl, argc, argv) == S_ERROR) {
		/* If any ERR_GUIDANCE messages were issued, add a summary */
		if (ofl->ofl_guideflags & FLG_OFG_ISSUED)
			ld_eprintf(ofl, ERR_GUIDANCE,
			    MSG_INTL(MSG_GUIDE_SUMMARY));
		return (1);
	}

	if (ofl->ofl_flags & FLG_OF_FATAL) {
		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_FLAGS));
		/* If any ERR_GUIDANCE messages were issued, add a summary */
		if (ofl->ofl_guideflags & FLG_OFG_ISSUED)
			ld_eprintf(ofl, ERR_GUIDANCE,
			    MSG_INTL(MSG_GUIDE_SUMMARY));
		return (1);
	}

	/*
	 * At this point a call such as ld -V is considered complete.
	 */
	if (ofl->ofl_flags1 & FLG_OF1_DONE)
		return (0);

	/* Initialize signal handler */
	ld_init_sighandler(ofl);

	/*
	 * Determine whether any support libraries should be loaded,
	 * (either through the SGS_SUPPORT environment variable and/or
	 * through the -S option).
	 */
#if	defined(_LP64)
	if ((sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT_64))) == NULL)
#else
	if ((sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT_32))) == NULL)
#endif
		sgs_support = getenv(MSG_ORIG(MSG_SGS_SUPPORT));

	if (sgs_support && sgs_support[0]) {
		const char	*sep = MSG_ORIG(MSG_STR_COLON);
		char		*lib;
		char		*lasts;

		DBG_CALL(Dbg_support_req(ofl->ofl_lml, sgs_support,
		    DBG_SUP_ENVIRON));
		if ((lib = strtok_r(sgs_support, sep, &lasts)) != NULL) {
			do {
				if (ld_sup_loadso(ofl, lib) == S_ERROR)
					return (ld_exit(ofl));
				DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));

			} while ((lib = strtok_r(NULL, sep, &lasts)) != NULL);
		}
	}
	if (lib_support) {
		Aliste	idx;
		char	*lib;

		for (APLIST_TRAVERSE(lib_support, idx, lib)) {
			DBG_CALL(Dbg_support_req(ofl->ofl_lml, lib,
			    DBG_SUP_CMDLINE));
			if (ld_sup_loadso(ofl, lib) == S_ERROR)
				return (ld_exit(ofl));
			DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
		}
	}

	DBG_CALL(Dbg_ent_print(ofl->ofl_lml,
	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
	    ofl->ofl_ents));
	DBG_CALL(Dbg_seg_list(ofl->ofl_lml,
	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
	    ofl->ofl_segs));

	/*
	 * The objscnt and soscnt variables were used to estimate the expected
	 * input files, and size the symbol hash buckets accordingly.  Reset
	 * these values now, so as to gain an accurate count from pass two, for
	 * later statistics diagnostics.
	 */
	ofl->ofl_objscnt = ofl->ofl_soscnt = 0;

	/*
	 * Determine whether we can create the file before going any further.
	 */
	if (ld_open_outfile(ofl) == S_ERROR)
		return (ld_exit(ofl));

	/*
	 * If the user didn't supply a library path supply a default.  And, if
	 * no run-path has been specified (-R), see if the environment variable
	 * is in use (historic).
	 */
	if (Plibpath == NULL)
		Plibpath = def_Plibpath;

	if (ofl->ofl_rpath == NULL) {
		char	*rpath;

		if (((rpath = getenv(MSG_ORIG(MSG_LD_RUN_PATH))) != NULL) &&
		    rpath[0])
			ofl->ofl_rpath = rpath;
	}

	/*
	 * Argument pass two.  Input all libraries and objects.
	 */
	if (ld_lib_setup(ofl) == S_ERROR)
		return (ld_exit(ofl));

	/*
	 * Call ld_start() with the etype of our output file and the
	 * output file name.
	 */
	if (ofl->ofl_flags & FLG_OF_SHAROBJ)
		etype = ET_DYN;
	else if (ofl->ofl_flags & FLG_OF_RELOBJ)
		etype = ET_REL;
	else
		etype = ET_EXEC;

	ld_sup_start(ofl, etype, argv[0]);

	/*
	 * Process all input files.
	 */
	if (ld_process_files(ofl, argc, argv) == S_ERROR)
		return (ld_exit(ofl));
	if (ofl->ofl_flags & FLG_OF_FATAL) {
		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_FILES),
		    ofl->ofl_name);
		return (ld_exit(ofl));
	}

	ld_sup_input_done(ofl);

	/*
	 * Now that all input section processing is complete, validate and
	 * process any SHT_SUNW_move sections.
	 */
	if (ofl->ofl_ismove && (ld_process_move(ofl) == S_ERROR))
		return (ld_exit(ofl));

	/*
	 * Before validating all symbols count the number of relocation entries.
	 * If copy relocations exist, COMMON symbols must be generated which are
	 * assigned to the executables .bss.  During sym_validate() the actual
	 * size and alignment of the .bss is calculated.  Doing things in this
	 * order reduces the number of symbol table traversals required (however
	 * it does take a little longer for the user to be told of any undefined
	 * symbol errors).
	 */
	if (ld_reloc_init(ofl) == S_ERROR)
		return (ld_exit(ofl));

	/*
	 * We need to know if FLG_OF_WARN is currently set, in case
	 * we need to honor a -z fatal-warnings request. However, we also
	 * need to know if a warning due to symbol validation results from
	 * the upcoming call to ld_sym_validate() in order to issue the
	 * appropriate message for it. So we save the current value,
	 * and clear the main flag.
	 */
	save_flg_of_warn = ofl->ofl_flags & FLG_OF_WARN;
	ofl->ofl_flags &= ~FLG_OF_WARN;

	if (ld_sym_validate(ofl) == S_ERROR)
		return (ld_exit(ofl));

	/*
	 * Now that all symbol processing is complete see if any undefined
	 * references still remain.  If we observed undefined symbols the
	 * FLG_OF_FATAL bit will be set:  If creating a static executable, or a
	 * dynamic executable or shared object with the -zdefs flag set, this
	 * condition is fatal.  If creating a shared object with the -Bsymbolic
	 * flag set, this condition is simply a warning.
	 */
	if (ofl->ofl_flags & FLG_OF_FATAL)
		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_SYM_FATAL),
		    ofl->ofl_name);
	else if (ofl->ofl_flags & FLG_OF_WARN)
		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_ARG_SYM_WARN));

	/*
	 * Guidance: Use -z defs|nodefs when building shared objects.
	 *
	 * ld_sym_validate() will mask this guidance message out unless we are
	 * intended to send it here, so all we need to do is use OFL_GUIDANCE()
	 * to decide whether to issue it or not.
	 */
	if (OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
		ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_DEFS));

	/*
	 * Symbol processing was the final step before we start producing the
	 * output object. At this time, if we've seen warnings and the
	 * -z fatal-warnings option is specified, promote them to fatal, which
	 * will cause us to exit without creating an object.
	 *
	 * We didn't do this as the warnings were reported in order to
	 * maximize the number of problems a given link-editor invocation
	 * can diagnose. This is safe, since warnings are by definition events
	 * one can choose to ignore.
	 */
	if (((ofl->ofl_flags | save_flg_of_warn) &
	    (FLG_OF_WARN | FLG_OF_FATWARN)) ==
	    (FLG_OF_WARN | FLG_OF_FATWARN))
		ofl->ofl_flags |= FLG_OF_FATAL;

	/*
	 * If fatal errors occurred in symbol processing, or due to warnings
	 * promoted by -z fatal-warnings, this is the end of the line.
	 */
	if (ofl->ofl_flags & FLG_OF_FATAL)
		return (ld_exit(ofl));

	/*
	 * Generate any necessary sections.
	 */
	if (ld_make_sections(ofl) == S_ERROR)
		return (ld_exit(ofl));

	/*
	 * Now that all sections have been added to the output file, determine
	 * whether any mapfile section ordering was specified, and verify that
	 * all mapfile ordering directives have been matched.  Issue a warning
	 * for any directives that have not been matched.
	 * Also, if SHF_ORDERED sections exist, set up sort key values.
	 */
	if (ofl->ofl_flags & (FLG_OF_OS_ORDER | FLG_OF_KEY))
		ld_sec_validate(ofl);

	/*
	 * Having collected all the input data create the initial output file
	 * image, assign virtual addresses to the image, and generate a load
	 * map if the user requested one.
	 */
	if (ld_create_outfile(ofl) == S_ERROR)
		return (ld_exit(ofl));

	if (ld_update_outfile(ofl) == S_ERROR)
		return (ld_exit(ofl));
	if (ofl->ofl_flags & FLG_OF_GENMAP)
		ld_map_out(ofl);

	/*
	 * Build relocation sections and perform any relocation updates.
	 */
	if (ld_reloc_process(ofl) == S_ERROR)
		return (ld_exit(ofl));

	/*
	 * Fill in contents for unwind header (.eh_frame_hdr)
	 */
	if (ld_unwind_populate_hdr(ofl) == S_ERROR)
		return (ld_exit(ofl));

	/*
	 * Finally create the files elf checksum.
	 */
	if (ofl->ofl_checksum)
		*ofl->ofl_checksum = (Xword)elf_checksum(ofl->ofl_elf);

	/*
	 * If this is a cross link to a target with a different byte
	 * order than the linker, swap the data to the target byte order.
	 */
	if (((ofl->ofl_flags1 & FLG_OF1_ENCDIFF) != 0) &&
	    (_elf_swap_wrimage(ofl->ofl_elf) != 0)) {
		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_SWAP_WRIMAGE),
		    ofl->ofl_name);
		return (ld_exit(ofl));
	}

	/*
	 * We're done, so make sure the updates are flushed to the output file.
	 */
	if ((ofl->ofl_size = elf_update(ofl->ofl_welf, ELF_C_WRITE)) == 0) {
		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_UPDATE),
		    ofl->ofl_name);
		return (ld_exit(ofl));
	}

	ld_sup_atexit(ofl, 0);

	DBG_CALL(Dbg_statistics_ld(ofl));
	DBG_CALL(Dbg_basic_finish(ofl->ofl_lml));

	/*
	 * Wrap up debug output file if one is open
	 */
	dbg_cleanup();

	/* If any ERR_GUIDANCE messages were issued, add a summary */
	if (ofl->ofl_guideflags & FLG_OFG_ISSUED) {
		ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_SUMMARY));
		ofl->ofl_guideflags &= ~FLG_OFG_ISSUED;
	}

	/*
	 * One final check for any new warnings we found that should fail the
	 * link edit.
	 */
	if ((ofl->ofl_flags & (FLG_OF_WARN | FLG_OF_FATWARN)) ==
	    (FLG_OF_WARN | FLG_OF_FATWARN))
		return (ld_exit(ofl));

	/*
	 * For performance reasons we didn't used to actually free up the
	 * memory we'd allocated, since it'll be freed on exit.
	 *
	 * These calls does not free nearly as much memory as you would think
	 * they do, unfortunately.
	 */
	ld_ofl_cleanup(ofl);
	libld_free(ofl);
	return (0);
}

/*
 * Cleanup an Ifl_desc.
 */
static void
ifl_list_cleanup(APlist *apl)
{
	Aliste		idx;
	Ifl_desc	*ifl;

	for (APLIST_TRAVERSE(apl, idx, ifl)) {
		if (ifl->ifl_elf)
			(void) elf_end(ifl->ifl_elf);
	}
}

/*
 * Cleanup all memory that has been dynamically allocated during libld
 * processing and elf_end() all Elf descriptors that are still open.
 */
void
ld_ofl_cleanup(Ofl_desc *ofl)
{
	Ar_desc		*adp;
	Aliste		idx;

	ifl_list_cleanup(ofl->ofl_objs);
	ofl->ofl_objs = NULL;
	ifl_list_cleanup(ofl->ofl_sos);
	ofl->ofl_sos = NULL;

	for (APLIST_TRAVERSE(ofl->ofl_ars, idx, adp)) {
		Ar_aux		*aup;
		Elf_Arsym	*arsym;

		/*
		 * Free up member information for normally processed archives.
		 * Archives processed under -z allextract have no member
		 * information or symbol table, and members have already been
		 * dealt with as input files.
		 */
		if (adp->ad_allextract == TRUE)
			continue;

		for (arsym = adp->ad_start, aup = adp->ad_aux;
		    (arsym->as_name != NULL); ++arsym, ++aup) {
			if ((aup->au_mem != NULL) &&
			    (aup->au_mem != FLG_ARMEM_PROC)) {
				(void) elf_end(aup->au_mem->am_elf);

				/*
				 * Null out all entries to this member so
				 * that we don't attempt to elf_end() it again.
				 */
				ld_ar_member(adp, arsym, aup, 0);
			}
		}
		(void) elf_end(adp->ad_elf);
	}
	ofl->ofl_ars = NULL;

	(void) elf_end(ofl->ofl_elf);
	(void) elf_end(ofl->ofl_welf);

	/*
	 * Note that we don't free ofl itself here, just its contents.  The
	 * ofl itself belongs to the caller.
	 */
}