/*

 * 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.

 */

/*

 * Processing of relocatable objects and shared objects.

 */

#define	ELF_TARGET_AMD64

#define	ELF_TARGET_SPARC

#include	<stdio.h>

#include	<string.h>

#include	<fcntl.h>

#include	<unistd.h>

#include	<link.h>

#include	<limits.h>

#include	<sys/stat.h>

#include	<sys/systeminfo.h>

#include	<debug.h>

#include	<msg.h>

#include	<_libld.h>

/*

 * Decide if we can link against this input file.

 */

static int

ifl_verify(Ehdr *ehdr, Ofl_desc *ofl, Rej_desc *rej)

{

	/*

	 * Check the validity of the elf header information for compatibility

	 * with this machine and our own internal elf library.

	 */

	if ((ehdr->e_machine != ld_targ.t_m.m_mach) &&

	    ((ehdr->e_machine != ld_targ.t_m.m_machplus) &&

	    ((ehdr->e_flags & ld_targ.t_m.m_flagsplus) == 0))) {

		rej->rej_type = SGS_REJ_MACH;

		rej->rej_info = (uint_t)ehdr->e_machine;

		return (0);

	}

	if (ehdr->e_ident[EI_DATA] != ld_targ.t_m.m_data) {

		rej->rej_type = SGS_REJ_DATA;

		rej->rej_info = (uint_t)ehdr->e_ident[EI_DATA];

		return (0);

	}

	if (ehdr->e_version > ofl->ofl_dehdr->e_version) {

		rej->rej_type = SGS_REJ_VERSION;

		rej->rej_info = (uint_t)ehdr->e_version;

		return (0);

	}

	return (1);

}

/*

 * Check sanity of file header and allocate an infile descriptor

 * for the file being processed.

 */

static Ifl_desc *

ifl_setup(const char *name, Ehdr *ehdr, Elf *elf, Word flags, Ofl_desc *ofl,

    Rej_desc *rej)

{

	Ifl_desc	*ifl;

	Rej_desc	_rej = { 0 };

	if (ifl_verify(ehdr, ofl, &_rej) == 0) {

		_rej.rej_name = name;

		DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,

		    ld_targ.t_m.m_mach));

		if (rej->rej_type == 0) {

			*rej = _rej;

			rej->rej_name = strdup(_rej.rej_name);

		}

		return (0);

	}

	if ((ifl = libld_calloc(1, sizeof (Ifl_desc))) == NULL)

		return ((Ifl_desc *)S_ERROR);

	ifl->ifl_name = name;

	ifl->ifl_ehdr = ehdr;

	ifl->ifl_elf = elf;

	ifl->ifl_flags = flags;

	/*

	 * Is this file using 'extended Section Indexes'.  If so, use the

	 * e_shnum & e_shstrndx which can be found at:

	 *

	 *	e_shnum == Shdr[0].sh_size

	 *	e_shstrndx == Shdr[0].sh_link

	 */

	if ((ehdr->e_shnum == 0) && (ehdr->e_shoff != 0)) {

		Elf_Scn	*scn;

		Shdr	*shdr0;

		if ((scn = elf_getscn(elf, 0)) == NULL) {

			eprintf(ofl->ofl_lml, ERR_ELF,

			    MSG_INTL(MSG_ELF_GETSCN), name);

			ofl->ofl_flags |= FLG_OF_FATAL;

			return ((Ifl_desc *)S_ERROR);

		}

		if ((shdr0 = elf_getshdr(scn)) == NULL) {

			eprintf(ofl->ofl_lml, ERR_ELF,

			    MSG_INTL(MSG_ELF_GETSHDR), name);

			ofl->ofl_flags |= FLG_OF_FATAL;

			return ((Ifl_desc *)S_ERROR);

		}

		ifl->ifl_shnum = (Word)shdr0->sh_size;

		if (ehdr->e_shstrndx == SHN_XINDEX)

			ifl->ifl_shstrndx = shdr0->sh_link;

		else

			ifl->ifl_shstrndx = ehdr->e_shstrndx;

	} else {

		ifl->ifl_shnum = ehdr->e_shnum;

		ifl->ifl_shstrndx = ehdr->e_shstrndx;

	}

	if ((ifl->ifl_isdesc = libld_calloc(ifl->ifl_shnum,

	    sizeof (Is_desc *))) == NULL)

		return ((Ifl_desc *)S_ERROR);

	/*

	 * Record this new input file on the shared object or relocatable

	 * object input file list.

	 */

	if (ifl->ifl_ehdr->e_type == ET_DYN) {

		if (aplist_append(&ofl->ofl_sos, ifl, AL_CNT_OFL_LIBS) == NULL)

			return ((Ifl_desc *)S_ERROR);

	} else {

		if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL)

			return ((Ifl_desc *)S_ERROR);

	}

	return (ifl);

}

/*

 * Process a generic section.  The appropriate section information is added

 * to the files input descriptor list.

 */

static uintptr_t

process_section(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,

    Word ndx, int ident, Ofl_desc *ofl)

{

	Is_desc	*isp;

	/*

	 * Create a new input section descriptor.  If this is a NOBITS

	 * section elf_getdata() will still create a data buffer (the buffer

	 * will be null and the size will reflect the actual memory size).

	 */

	if ((isp = libld_calloc(sizeof (Is_desc), 1)) == NULL)

		return (S_ERROR);

	isp->is_shdr = shdr;

	isp->is_file = ifl;

	isp->is_name = name;

	isp->is_scnndx = ndx;

	isp->is_flags = FLG_IS_EXTERNAL;

	isp->is_keyident = ident;

	if ((isp->is_indata = elf_getdata(scn, NULL)) == NULL) {

		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETDATA),

		    ifl->ifl_name);

		ofl->ofl_flags |= FLG_OF_FATAL;

		return (0);

	}

	if ((shdr->sh_flags & SHF_EXCLUDE) &&

	    ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) {

		isp->is_flags |= FLG_IS_DISCARD;

	}

	/*

	 * Add the new input section to the files input section list and

	 * flag whether the section needs placing in an output section.  This

	 * placement is deferred until all input section processing has been

	 * completed, as SHT_GROUP sections can provide information that will

	 * affect how other sections within the file should be placed.

	 */

	ifl->ifl_isdesc[ndx] = isp;

	if (ident) {

		if (shdr->sh_flags & ALL_SHF_ORDER) {

			isp->is_flags |= FLG_IS_ORDERED;

			ifl->ifl_flags |= FLG_IF_ORDERED;

		}

		isp->is_flags |= FLG_IS_PLACE;

	}

	return (1);

}

/*

 * Determine the software capabilities of the object being built from the

 * capabilities of the input relocatable objects.   One software capability

 * is presently recognized, and represented with the following (sys/elf.h):

 *

 *   SF1_SUNW_FPKNWN	use/non-use of frame pointer is known, and

 *   SF1_SUNW_FPUSED    the frame pointer is in use.

 *

 * The resolution of the present fame pointer state, and the capabilities

 * provided by a new input relocatable object are:

 *

 *                              new input relocatable object

 *

 *      present      |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |    <unknown>

 *       state       |  SF1_SUNW_FPUSED  |                   |

 *  ---------------------------------------------------------------------------

 *  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN

 *  SF1_SUNW_FPUSED  |  SF1_SUNW_FPUSED  |                   |  SF1_SUNW_FPUSED

 *  ---------------------------------------------------------------------------

 *  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN

 *                   |                   |                   |

 *  ---------------------------------------------------------------------------

 *     <unknown>     |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |    <unknown>

 *                   |  SF1_SUNW_FPUSED  |                   |

 */

static void

sf1_cap(Ofl_desc *ofl, Xword val, Ifl_desc *ifl, Is_desc *cisp)

{

#define	FP_FLAGS	(SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)

	Xword	badval;

	/*

	 * If a mapfile has established definitions to override any object

	 * capabilities, ignore any new object capabilities.

	 */

	if (ofl->ofl_flags1 & FLG_OF1_OVSFCAP1) {

		DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_IGNORED,

		    CA_SUNW_SF_1, val, ld_targ.t_m.m_mach));

		return;

	}

#if	!defined(_ELF64)

	if (ifl && (ifl->ifl_ehdr->e_type == ET_REL)) {

		/*

		 * The SF1_SUNW_ADDR32 is only meaningful when building a 64-bit

		 * object.  Warn the user, and remove the setting, if we're

		 * building a 32-bit object.

		 */

		if (val & SF1_SUNW_ADDR32) {

			eprintf(ofl->ofl_lml, ERR_WARNING,

			    MSG_INTL(MSG_FIL_INADDR32SF1), ifl->ifl_name,

			    EC_WORD(cisp->is_scnndx), cisp->is_name);

			val &= ~SF1_SUNW_ADDR32;

		}

	}

#endif

	/*

	 * If this object doesn't specify any capabilities, ignore it, and

	 * leave the state as is.

	 */

	if (val == 0)

		return;

	/*

	 * Make sure we only accept known software capabilities.  Note, that

	 * an F1_SUNW_FPUSED by itself is viewed as bad practice.

	 */

	if ((badval = (val & ~SF1_SUNW_MASK)) != 0) {

		eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1),

		    ifl->ifl_name, EC_WORD(cisp->is_scnndx), cisp->is_name,

		    EC_XWORD(badval));

		val &= SF1_SUNW_MASK;

	}

	if ((val & FP_FLAGS) == SF1_SUNW_FPUSED) {

		eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1),

		    ifl->ifl_name, EC_WORD(cisp->is_scnndx), cisp->is_name,

		    EC_XWORD(val));

		return;

	}

	/*

	 * If the input file is not a relocatable object, then we're only here

	 * to warn the user of any questionable capabilities.

	 */

	if (ifl->ifl_ehdr->e_type != ET_REL) {

#if	defined(_ELF64)

		/*

		 * If we're building a 64-bit executable, and we come across a

		 * dependency that requires a restricted address space, then

		 * that dependencies requirement can only be satisfied if the

		 * executable triggers the restricted address space.  This is a

		 * warning rather than a fatal error, as the possibility exists

		 * that an appropriate dependency will be provided at runtime.

		 * The runtime linker will refuse to use this dependency.

		 */

		if ((val & SF1_SUNW_ADDR32) && (ofl->ofl_flags & FLG_OF_EXEC) &&

		    ((ofl->ofl_ocapset.oc_sf_1.cm_val &

		    SF1_SUNW_ADDR32) == 0)) {

			eprintf(ofl->ofl_lml, ERR_WARNING,

			    MSG_INTL(MSG_FIL_EXADDR32SF1), ifl->ifl_name,

			    EC_WORD(cisp->is_scnndx), cisp->is_name);

		}

#endif

		return;

	}

	if (DBG_ENABLED) {

		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_CURRENT, CA_SUNW_SF_1,

		    ofl->ofl_ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach);

		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_NEW, CA_SUNW_SF_1,

		    val, ld_targ.t_m.m_mach);

	}

	/*

	 * Determine the resolution of the present frame pointer and the

	 * new input relocatable objects frame pointer.

	 */

	if ((ofl->ofl_ocapset.oc_sf_1.cm_val & FP_FLAGS) == FP_FLAGS) {

		/*

		 * If the new relocatable object isn't using a frame pointer,

		 * reduce the present state to unused.

		 */

		if ((val & FP_FLAGS) != FP_FLAGS)

			ofl->ofl_ocapset.oc_sf_1.cm_val &= ~SF1_SUNW_FPUSED;

		/*

		 * Having processed the frame pointer bits, remove them from

		 * the value so they don't get OR'd in below.

		 */

		val &= ~FP_FLAGS;

	} else if ((ofl->ofl_ocapset.oc_sf_1.cm_val & SF1_SUNW_FPKNWN) == 0) {

		/*

		 * If the present frame pointer state is unknown, mask it out

		 * and allow the values from the new relocatable object

		 * to overwrite them.

		 */

		ofl->ofl_ocapset.oc_sf_1.cm_val &= ~FP_FLAGS;

	} else {

		/* Do not take the frame pointer flags from the object */

		val &= ~FP_FLAGS;

	}

	ofl->ofl_ocapset.oc_sf_1.cm_val |= val;

	DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_RESOLVED,

	    CA_SUNW_SF_1, ofl->ofl_ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach));

#undef FP_FLAGS

}

/*

 * Determine the hardware capabilities of the object being built from the

 * capabilities of the input relocatable objects.  There's really little to

 * do here, other than to offer diagnostics, hardware capabilities are simply

 * additive.

 */

static void

hw_cap(Ofl_desc *ofl, Xword tag, Xword val)

{

	elfcap_mask_t	*hwcap;

	ofl_flag_t	flags1;

	if (tag == CA_SUNW_HW_1) {

		hwcap = &ofl->ofl_ocapset.oc_hw_1.cm_val;

		flags1 = FLG_OF1_OVHWCAP1;

	} else {

		hwcap = &ofl->ofl_ocapset.oc_hw_2.cm_val;

		flags1 = FLG_OF1_OVHWCAP2;

	}

	/*

	 * If a mapfile has established definitions to override any object

	 * capabilities, ignore any new object capabilities.

	 */

	if (ofl->ofl_flags1 & flags1) {

		DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_IGNORED,

		    tag, val, ld_targ.t_m.m_mach));

		return;

	}

	/*

	 * If this object doesn't specify any capabilities, ignore it, and

	 * leave the state as is.

	 */

	if (val == 0)

		return;

	if (DBG_ENABLED) {

		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_CURRENT, CA_SUNW_HW_1,

		    ofl->ofl_ocapset.oc_hw_1.cm_val, ld_targ.t_m.m_mach);

		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_NEW, CA_SUNW_HW_1,

		    val, ld_targ.t_m.m_mach);

	}

	*hwcap |= val;

	DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_RESOLVED, tag,

	    *hwcap, ld_targ.t_m.m_mach));

}

/*

 * Promote a machine capability or platform capability to the output file.

 * Multiple instances of these names can be defined.

 */

static void

str_cap(Ofl_desc *ofl, char *pstr, ofl_flag_t flags, Xword tag, Caplist *list)

{

	Capstr		*capstr;

	Aliste		idx;

	Boolean		found = FALSE;

	/*

	 * If a mapfile has established definitions to override this capability,

	 * ignore any new capability.

	 */

	if (ofl->ofl_flags1 & flags) {

		DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_IGNORED,

		    tag, pstr));

		return;

	}

	for (ALIST_TRAVERSE(list->cl_val, idx, capstr)) {

		DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,

		    DBG_STATE_CURRENT, tag, capstr->cs_str));

		if (strcmp(capstr->cs_str, pstr) == 0)

			found = TRUE;

	}

	DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_NEW, tag, pstr));

	if (found == FALSE) {

		if ((capstr = alist_append(&list->cl_val, NULL,

		    sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL) {

			ofl->ofl_flags |= FLG_OF_FATAL;

			return;

		}

		capstr->cs_str = pstr;

	}

	if (DBG_ENABLED) {

		for (ALIST_TRAVERSE(list->cl_val, idx, capstr)) {

			DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,

			    DBG_STATE_RESOLVED, tag, capstr->cs_str));

		}

	}

}

/*

 * Promote a capability identifier to the output file.  A capability group can

 * only have one identifier, and thus only the first identifier seen from any

 * input relocatable objects is retained.  An explicit user defined identifier,

 * rather than an an identifier fabricated by ld(1) with -z symbcap processing,

 * takes precedence.  Note, a user may have defined an identifier via a mapfile,

 * in which case the mapfile identifier is retained.

 */

static void

id_cap(Ofl_desc *ofl, char *pstr, oc_flag_t flags)

{

	Objcapset	*ocapset = &ofl->ofl_ocapset;

	if (ocapset->oc_id.cs_str) {

		DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_CURRENT,

		    CA_SUNW_ID, ocapset->oc_id.cs_str));

		if ((ocapset->oc_flags & FLG_OCS_USRDEFID) ||

		    ((flags & FLG_OCS_USRDEFID) == 0)) {

			DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,

			    DBG_STATE_IGNORED, CA_SUNW_ID, pstr));

			return;

		}

	}

	DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_NEW,

	    CA_SUNW_ID, pstr));

	ocapset->oc_id.cs_str = pstr;

	ocapset->oc_flags |= flags;

	DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_RESOLVED,

	    CA_SUNW_ID, pstr));

}

/*

 * Promote a capabilities group to the object capabilities.  This catches a

 * corner case.  An object capabilities file can be converted to symbol

 * capabilities with -z symbolcap.  However, if the user has indicated that all

 * the symbols should be demoted, we'd be left with a symbol capabilities file,

 * with no associated symbols.  Catch this case by promoting the symbol

 * capabilities back to object capabilities.