/*

 * 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

 *

 */

/*

 * Update the new output file image, perform virtual address, offset and

 * displacement calculations on the program headers and sections headers,

 * and generate any new output section information.

 */

#define	ELF_TARGET_AMD64

#include	<stdio.h>

#include	<string.h>

#include	<unistd.h>

#include	<debug.h>

#include	"msg.h"

#include	"_libld.h"

/*

 * Comparison routine used by qsort() for sorting of the global symbol list

 * based off of the hashbuckets the symbol will eventually be deposited in.

 */

static int

sym_hash_compare(Sym_s_list * s1, Sym_s_list * s2)

{

	return (s1->sl_hval - s2->sl_hval);

}

/*

 * Comparison routine used by qsort() for sorting of dyn[sym|tls]sort section

 * indices based on the address of the symbols they reference. The

 * use of the global dynsort_compare_syms variable is needed because

 * we need to examine the symbols the indices reference. It is safe, because

 * the linker is single threaded.

 */

Sym *dynsort_compare_syms;

static int

dynsort_compare(const void *idx1, const void *idx2)

{

	Sym *s1 = dynsort_compare_syms + *((const Word *) idx1);

	Sym *s2 = dynsort_compare_syms + *((const Word *) idx2);

	/*

	 * Note: the logical computation for this is

	 *	(st_value1 - st_value2)

	 * However, that is only correct if the address type is smaller

	 * than a pointer. Writing it this way makes it immune to the

	 * class (32 or 64-bit) of the linker.

	 */

	return ((s1->st_value < s2->st_value) ? -1 :

	    (s1->st_value > s2->st_value));

}

/*

 * Scan the sorted symbols, and issue warnings if there are any duplicate

 * values in the list. We only do this if -zverbose is set, or we are

 * running with LD_DEBUG defined

 *

 * entry:

 *	ofl - Output file descriptor

 *	ldynsym - Pointer to start of .SUNW_ldynsym section that the

 *		sort section indexes reference.

 *	symsort - Pointer to start of .SUNW_dynsymsort or .SUNW_dyntlssort

 *		section.

 *	n - # of indices in symsort array

 *	secname - Name of the symsort section.

 *

 * exit:

 *	If the symsort section contains indexes to more than one

 *	symbol with the same address value, a warning is issued.

 */

static void

dynsort_dupwarn(Ofl_desc *ofl, Sym *ldynsym, const char *str,

    Word *symsort, Word n, const char *secname)

{

	int zverbose = (ofl->ofl_flags & FLG_OF_VERBOSE) != 0;

	Word ndx, cmp_ndx;

	Addr addr, cmp_addr;

	/* Nothing to do if -zverbose or LD_DEBUG are not active */

	if (!(zverbose || DBG_ENABLED))

		return;

	cmp_ndx = 0;

	cmp_addr = ldynsym[symsort[cmp_ndx]].st_value;

	for (ndx = 1; ndx < n; ndx++) {

		addr = ldynsym[symsort[ndx]].st_value;

		if (cmp_addr == addr) {

			if (zverbose)

				eprintf(ofl->ofl_lml, ERR_WARNING,

				    MSG_INTL(MSG_SYM_DUPSORTADDR), secname,

				    str + ldynsym[symsort[cmp_ndx]].st_name,

				    str + ldynsym[symsort[ndx]].st_name,

				    EC_ADDR(addr));

			DBG_CALL(Dbg_syms_dup_sort_addr(ofl->ofl_lml, secname,

			    str + ldynsym[symsort[cmp_ndx]].st_name,

			    str + ldynsym[symsort[ndx]].st_name,

			    EC_ADDR(addr)));

		} else {	/* Not a dup. Move reference up */

			cmp_ndx = ndx;

			cmp_addr = addr;

		}

	}

}

/*

 * Build and update any output symbol tables.  Here we work on all the symbol

 * tables at once to reduce the duplication of symbol and string manipulation.

 * Symbols and their associated strings are copied from the read-only input

 * file images to the output image and their values and index's updated in the

 * output image.

 */

static Addr

update_osym(Ofl_desc *ofl)

{

	/*

	 * There are several places in this function where we wish

	 * to insert a symbol index to the combined .SUNW_ldynsym/.dynsym

	 * symbol table into one of the two sort sections (.SUNW_dynsymsort

	 * or .SUNW_dyntlssort), if that symbol has the right attributes.

	 * This macro is used to generate the necessary code from a single

	 * specification.

	 *

	 * entry:

	 *	_sdp, _sym, _type - As per DYNSORT_COUNT. See _libld.h

	 *	_sym_ndx - Index that _sym will have in the combined

	 *		.SUNW_ldynsym/.dynsym symbol table.

	 */

#define	ADD_TO_DYNSORT(_sdp, _sym, _type, _sym_ndx) \

	{ \

		Word *_dynsort_arr, *_dynsort_ndx; \

		\

		if (dynsymsort_symtype[_type]) { \

			_dynsort_arr = dynsymsort; \

			_dynsort_ndx = &dynsymsort_ndx; \

		} else if (_type == STT_TLS) { \

			_dynsort_arr = dyntlssort; \

			_dynsort_ndx = &dyntlssort_ndx; \

		} else { \

			_dynsort_arr = NULL; \

		} \

		if ((_dynsort_arr != NULL) && DYNSORT_TEST_ATTR(_sdp, _sym)) \

		    _dynsort_arr[(*_dynsort_ndx)++] = _sym_ndx; \

	}

	Sym_desc	*sdp;

	Sym_avlnode	*sav;

	Sg_desc		*sgp, *tsgp = NULL, *dsgp = NULL, *esgp = NULL;

	Os_desc		*osp, *iosp = NULL, *fosp = NULL;

	Is_desc		*isc;

	Ifl_desc	*ifl;

	Word		bssndx, etext_ndx, edata_ndx = 0, end_ndx, start_ndx;

	Word		end_abs = 0, etext_abs = 0, edata_abs;

	Word		tlsbssndx = 0, parexpnndx;

#if	defined(_ELF64)

	Word		lbssndx = 0;

	Addr		lbssaddr = 0;

#endif

	Addr		bssaddr, etext = 0, edata = 0, end = 0, start = 0;

	Addr		tlsbssaddr = 0;

	Addr 		parexpnbase, parexpnaddr;

	int		start_set = 0;

	Sym		_sym = {0}, *sym, *symtab = NULL;

	Sym		*dynsym = NULL, *ldynsym = NULL;

	Word		symtab_ndx = 0;		/* index into .symtab */

	Word		symtab_gbl_bndx;	/* .symtab ndx 1st global */

	Word		ldynsym_ndx = 0;	/* index into .SUNW_ldynsym */

	Word		dynsym_ndx = 0;		/* index into .dynsym */

	Word		scopesym_ndx = 0;	/* index into scoped symbols */

	Word		scopesym_bndx = 0;	/* .symtab ndx 1st scoped sym */

	Word		ldynscopesym_ndx = 0;	/* index to ldynsym scoped */

						/*	symbols */

	Word		*dynsymsort = NULL;	/* SUNW_dynsymsort index */

						/*	vector */

	Word		*dyntlssort = NULL;	/* SUNW_dyntlssort index */

						/*	vector */

	Word		dynsymsort_ndx;		/* index dynsymsort array */

	Word		dyntlssort_ndx;		/* index dyntlssort array */

	Word		*symndx;		/* symbol index (for */

						/*	relocation use) */

	Word		*symshndx = NULL;	/* .symtab_shndx table */

	Word		*dynshndx = NULL;	/* .dynsym_shndx table */

	Word		*ldynshndx = NULL;	/* .SUNW_ldynsym_shndx table */

	Word		ldynsym_cnt = NULL;	/* number of items in */

						/*	.SUNW_ldynsym */

	Str_tbl		*shstrtab;

	Str_tbl		*strtab;

	Str_tbl		*dynstr;

	Word		*hashtab;	/* hash table pointer */

	Word		*hashbkt;	/* hash table bucket pointer */

	Word		*hashchain;	/* hash table chain pointer */

	Wk_desc		*wkp;

	Alist		*weak = NULL;

	ofl_flag_t	flags = ofl->ofl_flags;

	Versym		*versym;

	Gottable	*gottable;	/* used for display got debugging */

					/*	information */

	Syminfo		*syminfo;

	Sym_s_list	*sorted_syms;	/* table to hold sorted symbols */

	Word		ssndx;		/* global index into sorted_syms */

	Word		scndx;		/* scoped index into sorted_syms */

	size_t		stoff;		/* string offset */

	Aliste		idx1;

	/*

	 * Initialize pointers to the symbol table entries and the symbol

	 * table strings.  Skip the first symbol entry and the first string

	 * table byte.  Note that if we are not generating any output symbol

	 * tables we must still generate and update internal copies so

	 * that the relocation phase has the correct information.

	 */

	if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||

	    ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {

		symtab = (Sym *)ofl->ofl_ossymtab->os_outdata->d_buf;

		symtab[symtab_ndx++] = _sym;

		if (ofl->ofl_ossymshndx)

			symshndx =

			    (Word *)ofl->ofl_ossymshndx->os_outdata->d_buf;

	}

	if (OFL_ALLOW_DYNSYM(ofl)) {

		dynsym = (Sym *)ofl->ofl_osdynsym->os_outdata->d_buf;

		dynsym[dynsym_ndx++] = _sym;

		/*

		 * If we are also constructing a .SUNW_ldynsym section

		 * to contain local function symbols, then set it up too.

		 */

		if (ofl->ofl_osldynsym) {

			ldynsym = (Sym *)ofl->ofl_osldynsym->os_outdata->d_buf;

			ldynsym[ldynsym_ndx++] = _sym;

			ldynsym_cnt = 1 + ofl->ofl_dynlocscnt +

			    ofl->ofl_dynscopecnt;

			/*

			 * If there is a SUNW_ldynsym, then there may also

			 * be a .SUNW_dynsymsort and/or .SUNW_dyntlssort

			 * sections, used to collect indices of function

			 * and data symbols sorted by address order.

			 */

			if (ofl->ofl_osdynsymsort) {	/* .SUNW_dynsymsort */

				dynsymsort = (Word *)

				    ofl->ofl_osdynsymsort->os_outdata->d_buf;

				dynsymsort_ndx = 0;

			}

			if (ofl->ofl_osdyntlssort) {	/* .SUNW_dyntlssort */

				dyntlssort = (Word *)

				    ofl->ofl_osdyntlssort->os_outdata->d_buf;

				dyntlssort_ndx = 0;

			}

		}

		/*

		 * Initialize the hash table.

		 */

		hashtab = (Word *)(ofl->ofl_oshash->os_outdata->d_buf);

		hashbkt = &hashtab[2];

		hashchain = &hashtab[2 + ofl->ofl_hashbkts];

		hashtab[0] = ofl->ofl_hashbkts;

		hashtab[1] = DYNSYM_ALL_CNT(ofl);

		if (ofl->ofl_osdynshndx)

			dynshndx =

			    (Word *)ofl->ofl_osdynshndx->os_outdata->d_buf;

		if (ofl->ofl_osldynshndx)

			ldynshndx =

			    (Word *)ofl->ofl_osldynshndx->os_outdata->d_buf;

	}

	/*

	 * symndx is the symbol index to be used for relocation processing.  It

	 * points to the relevant symtab's (.dynsym or .symtab) symbol ndx.

	 */

	if (dynsym)

		symndx = &dynsym_ndx;

	else

		symndx = &symtab_ndx;

	/*

	 * If we have version definitions initialize the version symbol index

	 * table.  There is one entry for each symbol which contains the symbols

	 * version index.

	 */

	if (!(flags & FLG_OF_NOVERSEC) &&

	    (flags & (FLG_OF_VERNEED | FLG_OF_VERDEF))) {

		versym = (Versym *)ofl->ofl_osversym->os_outdata->d_buf;

		versym[0] = NULL;

	} else

		versym = NULL;

	/*

	 * If syminfo section exists be prepared to fill it in.

	 */

	if (ofl->ofl_ossyminfo) {

		syminfo = ofl->ofl_ossyminfo->os_outdata->d_buf;

		syminfo[0].si_flags = SYMINFO_CURRENT;

	} else

		syminfo = NULL;

	/*

	 * Setup our string tables.

	 */

	shstrtab = ofl->ofl_shdrsttab;

	strtab = ofl->ofl_strtab;

	dynstr = ofl->ofl_dynstrtab;

	DBG_CALL(Dbg_syms_sec_title(ofl->ofl_lml));

	/*

	 * Put output file name to the first .symtab and .SUNW_ldynsym symbol.

	 */

	if (symtab) {

		(void) st_setstring(strtab, ofl->ofl_name, &stoff);

		sym = &symtab[symtab_ndx++];

		/* LINTED */

		sym->st_name = stoff;

		sym->st_value = 0;

		sym->st_size = 0;

		sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_FILE);

		sym->st_other = 0;

		sym->st_shndx = SHN_ABS;

		if (versym && !dynsym)

			versym[1] = 0;

	}

	if (ldynsym) {

		(void) st_setstring(dynstr, ofl->ofl_name, &stoff);

		sym = &ldynsym[ldynsym_ndx];

		/* LINTED */

		sym->st_name = stoff;

		sym->st_value = 0;

		sym->st_size = 0;

		sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_FILE);

		sym->st_other = 0;

		sym->st_shndx = SHN_ABS;

		/* Scoped symbols get filled in global loop below */

		ldynscopesym_ndx = ldynsym_ndx + 1;

		ldynsym_ndx += ofl->ofl_dynscopecnt;

	}

	/*

	 * If we are to display GOT summary information, then allocate

	 * the buffer to 'cache' the GOT symbols into now.

	 */

	if (DBG_ENABLED) {

		if ((ofl->ofl_gottable = gottable =

		    libld_calloc(ofl->ofl_gotcnt, sizeof (Gottable))) == NULL)

			return ((Addr)S_ERROR);

	}

	/*

	 * Traverse the program headers.  Determine the last executable segment

	 * and the last data segment so that we can update etext and edata. If

	 * we have empty segments (reservations) record them for setting _end.

	 */

	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {

		Phdr	*phd = &(sgp->sg_phdr);

		Os_desc	*osp;

		Aliste	idx2;

		if (phd->p_type == PT_LOAD) {

			if (sgp->sg_osdescs != NULL) {

				Word	_flags = phd->p_flags & (PF_W | PF_R);

				if (_flags == PF_R)

					tsgp = sgp;

				else if (_flags == (PF_W | PF_R))

					dsgp = sgp;

			} else if (sgp->sg_flags & FLG_SG_EMPTY)

				esgp = sgp;

		}

		/*

		 * Generate a section symbol for each output section.

		 */

		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {

			Word	sectndx;

			sym = &_sym;

			sym->st_value = osp->os_shdr->sh_addr;

			sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_SECTION);

			/* LINTED */

			sectndx = elf_ndxscn(osp->os_scn);

			if (symtab) {

				if (sectndx >= SHN_LORESERVE) {

					symshndx[symtab_ndx] = sectndx;

					sym->st_shndx = SHN_XINDEX;

				} else {

					/* LINTED */

					sym->st_shndx = (Half)sectndx;

				}

				symtab[symtab_ndx++] = *sym;

			}

			if (dynsym && (osp->os_flags & FLG_OS_OUTREL))

				dynsym[dynsym_ndx++] = *sym;

			if ((dynsym == NULL) ||

			    (osp->os_flags & FLG_OS_OUTREL)) {

				if (versym)

					versym[*symndx - 1] = 0;

				osp->os_identndx = *symndx - 1;

				DBG_CALL(Dbg_syms_sec_entry(ofl->ofl_lml,

				    osp->os_identndx, sgp, osp));

			}

			/*

			 * Generate the .shstrtab for this section.

			 */

			(void) st_setstring(shstrtab, osp->os_name, &stoff);

			osp->os_shdr->sh_name = (Word)stoff;

			/*

			 * Find the section index for our special symbols.

			 */

			if (sgp == tsgp) {

				/* LINTED */

				etext_ndx = elf_ndxscn(osp->os_scn);

			} else if (dsgp == sgp) {

				if (osp->os_shdr->sh_type != SHT_NOBITS) {

					/* LINTED */

					edata_ndx = elf_ndxscn(osp->os_scn);

				}

			}

			if (start_set == 0) {

				start = sgp->sg_phdr.p_vaddr;

				/* LINTED */

				start_ndx = elf_ndxscn(osp->os_scn);

				start_set++;

			}

			/*

			 * While we're here, determine whether a .init or .fini

			 * section exist.

			 */

			if ((iosp == NULL) && (strcmp(osp->os_name,

			    MSG_ORIG(MSG_SCN_INIT)) == 0))

				iosp = osp;

			if ((fosp == NULL) && (strcmp(osp->os_name,

			    MSG_ORIG(MSG_SCN_FINI)) == 0))

				fosp = osp;

		}

	}

	/*

	 * Add local register symbols to the .dynsym.  These are required as

	 * DT_REGISTER .dynamic entries must have a symbol to reference.

	 */

	if (ofl->ofl_regsyms && dynsym) {

		int	ndx;

		for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {

			Sym_desc	*rsdp;

			if ((rsdp = ofl->ofl_regsyms[ndx]) == NULL)

				continue;

			if (!SYM_IS_HIDDEN(rsdp) &&

			    (ELF_ST_BIND(rsdp->sd_sym->st_info) != STB_LOCAL))

				continue;

			dynsym[dynsym_ndx] = *(rsdp->sd_sym);

			rsdp->sd_symndx = *symndx;

			if (dynsym[dynsym_ndx].st_name) {

				(void) st_setstring(dynstr, rsdp->sd_name,

				    &stoff);

				dynsym[dynsym_ndx].st_name = stoff;

			}

			dynsym_ndx++;

		}

	}

	/*

	 * Having traversed all the output segments, warn the user if the

	 * traditional text or data segments don't exist.  Otherwise from these

	 * segments establish the values for `etext', `edata', `end', `END',

	 * and `START'.