/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include	<proc_service.h>
#include	<link.h>
#include	<rtld_db.h>
#include	<_rtld_db.h>
#include	<msg.h>

/*
 * A un-initialized SPARCV9 PLT look like so:
 *
 * .PLT
 *	sethi	(. - .PLT0), %g1
 *	ba,a	%xcc, .PLT1
 *	nop
 *	nop
 *	nop
 *	nop
 *	nop
 *	nop
 *
 * To test to see if this is an uninitialized PLT we check
 * the second instruction and confirm that it's a branch.
 */
/* ARGSUSED 2 */
rd_err_e
plt64_resolution(rd_agent_t *rap, psaddr_t pc, lwpid_t lwpid,
	psaddr_t pltbase, rd_plt_info_t *rpi)
{
	instr_t		instr[8];
	rd_err_e	rerr;
	psaddr_t	destaddr = 0;
	psaddr_t	pltoff;
	int		pltbound = 0;

	if (rtld_db_version >= RD_VERSION3) {
		rpi->pi_flags = 0;
		rpi->pi_baddr = 0;
	}

	pltoff = pc - pltbase;

	if (pltoff >= (M64_PLT_NEARPLTS * M64_PLT_ENTSIZE)) {
		psaddr_t	pltptr, pltptrval;
		psaddr_t	pltaddr;
		psaddr_t	pltblockoff;

		/*
		 * Handle far PLT's
		 *
		 * .PLT#
		 * 0	mov	%o7, %g5
		 * 1	call	. + 8
		 * 2	nop
		 * 3	ldx	[%o7 + (.PLTP# - .PLT#+4)], %g1
		 * 4	jmpl	%o7 + %g1, %g1
		 * 5	mov	%g5, %o7
		 */

		pltblockoff = pltoff - (M64_PLT_NEARPLTS * M64_PLT_ENTSIZE);
		pltblockoff =
			((pltblockoff / M64_PLT_FBLOCKSZ) * M64_PLT_FBLOCKSZ) +
			(((pltblockoff % M64_PLT_FBLOCKSZ) / M64_PLT_FENTSIZE) *
			M64_PLT_FENTSIZE);


		pltaddr = pltbase + (M64_PLT_NEARPLTS * M64_PLT_ENTSIZE) +
			pltblockoff;

		if (ps_pread(rap->rd_psp, pltaddr, (char *)instr,
		    M64_PLT_FENTSIZE) != PS_OK) {
			LOG(ps_plog(MSG_ORIG(MSG_DB_READFAIL_2),
				EC_ADDR(pltaddr)));
			return (RD_ERR);

		}

		if (instr[0] != M_MOVO7TOG5) {
			LOG(ps_plog(MSG_ORIG(MSG_DB_BADFPLT),
				EC_ADDR(pltaddr), EC_ADDR(instr[0])));
			return (RD_ERR);
		}

		/*
		 * the offset is a positive displacement from the
		 * ldx [%o7 + #], %g1 instruction.  So - we don't
		 * need to worry about the sign bit :)
		 */
		pltptr = instr[3] & S_MASK(12);
		pltptr += pltaddr + 4;
		/*
		 * Load the pltptr to determine whether it is
		 * pointing to .PLT0 or to the final
		 * destination.
		 */
		if (ps_pread(rap->rd_psp, pltptr, &pltptrval,
		    sizeof (long long)) != PS_OK) {
			LOG(ps_plog(MSG_ORIG(MSG_DB_READFAIL_2),
				EC_ADDR(pltptr)));
			return (RD_ERR);
		}
		pltptrval += pltaddr + 4;
		if (pltptrval == pltbase) {
			if ((rerr = rd_binder_exit_addr(rap,
			    MSG_ORIG(MSG_SYM_RTBIND),
			    &(rpi->pi_target))) != RD_OK) {
				return (rerr);
			}
			rpi->pi_skip_method = RD_RESOLVE_TARGET_STEP;
			rpi->pi_nstep = 1;
		} else {
			rpi->pi_skip_method = RD_RESOLVE_STEP;
			rpi->pi_nstep = 6;
			rpi->pi_target = 0;
			if (rtld_db_version >= RD_VERSION3) {
				destaddr = pltptrval;
				pltbound++;
			}
		}
	} else  {
		psaddr_t	pltaddr;

		pltaddr = pltbase +
			((pltoff / M64_PLT_ENTSIZE) * M64_PLT_ENTSIZE);

		if (ps_pread(rap->rd_psp, pltaddr, (char *)instr,
		    M64_PLT_ENTSIZE) != PS_OK) {
			LOG(ps_plog(MSG_ORIG(MSG_DB_READFAIL_2),
				EC_ADDR(pltaddr)));
			return (RD_ERR);

		}
		/*
		 * ELF64 NEAR PLT's
		 */
		if ((instr[0] != M_NOP) &&
		    ((instr[1] & (~(S_MASK(19)))) == M_BA_A_XCC)) {
			/*
			 * Unbound PLT
			 */
			if ((rerr = rd_binder_exit_addr(rap,
			    MSG_ORIG(MSG_SYM_RTBIND),
			    &(rpi->pi_target))) != RD_OK) {
				return (rerr);
			}
			rpi->pi_skip_method = RD_RESOLVE_TARGET_STEP;
			rpi->pi_nstep = 1;
		} else  if ((instr[0] == M_NOP) &&
		    ((instr[1] & (~(S_MASK(22)))) == M_BA_A)) {
			/*
			 * Resolved 64-bit PLT entry format (b+-8mb):
			 * .PLT
			 * 0	nop
			 * 1	ba,a	<dest>
			 * 2	nop
			 * 3	nop
			 * 4	nop
			 * 5	nop
			 * 6	nop
			 * 7	nop
			 */
			rpi->pi_skip_method = RD_RESOLVE_STEP;
			rpi->pi_nstep = 2;
			rpi->pi_target = 0;
			if (rtld_db_version >= RD_VERSION3) {
				uint_t	d22;
				d22 = instr[1] & S_MASK(22);
				/* LINTED */
				destaddr = ((long)pltaddr + 4) +
					/* LINTED */
					(((int)d22 << 10) >> 8);
				pltbound++;
			}
		} else if ((instr[0] == M_NOP) &&
		    ((instr[1] & (~(S_MASK(19)))) == M_BA_A_PT)) {
			/*
			 * Resolved 64-bit PLT entry format (b+-2mb):
			 * .PLT
			 * 0	nop
			 * 1	ba,a,pt	%icc, <dest>
			 * 2	nop
			 * 3	nop
			 * 4	nop
			 * 5	nop
			 * 6	nop
			 * 7	nop
			 */
			rpi->pi_skip_method = RD_RESOLVE_STEP;
			rpi->pi_nstep = 2;
			rpi->pi_target = 0;
			if (rtld_db_version >= RD_VERSION3) {
				uint_t	d19;
				d19 = instr[1] & S_MASK(22);
				/* LINTED */
				destaddr = ((long)pltaddr + 4) +
					/* LINTED */
					(((int)d19 << 13) >> 11);
				pltbound++;
			}
		} else if ((instr[6] & (~(S_MASK(13)))) == M_JMPL_G5G0) {
			/*
			 * Resolved 64-bit PLT entry format (abs-64):
			 * .PLT
			 * 0	nop
			 * 1	sethi	%hh(dest), %g1
			 * 2	sethi	%lm(dest), %g5
			 * 3	or	%g1, %hm(dest), %g1
			 * 4	sllx	%g1, 32, %g1
			 * 5	or	%g1, %g5, %g5
			 * 6	jmpl	%g5 + %lo(dest), %g0
			 * 7	nop
			 */
			rpi->pi_skip_method = RD_RESOLVE_STEP;
			rpi->pi_nstep = 8;
			rpi->pi_target = 0;
			if (rtld_db_version >= RD_VERSION3) {
				uintptr_t	hh_bits;
				uintptr_t	hm_bits;
				uintptr_t	lm_bits;
				uintptr_t	lo_bits;
				hh_bits = instr[1] & S_MASK(22); /* 63..42 */
				hm_bits = instr[3] & S_MASK(10); /* 41..32 */
				lm_bits = instr[2] & S_MASK(22); /* 31..10 */
				lo_bits = instr[6] & S_MASK(10); /* 09..00 */
				destaddr = (hh_bits << 42) | (hm_bits << 32) |
					(lm_bits << 10) | lo_bits;
				pltbound++;
			}
		} else if (instr[3] == M_JMPL) {
			/*
			 * Resolved 64-bit PLT entry format (top-32):
			 *
			 * .PLT:
			 * 0	nop
			 * 1	sethi	%hi(~dest), %g5
			 * 2	xnor	%g5, %lo(~dest), %g1
			 * 3	jmpl	%g1, %g0
			 * 4	nop
			 * 5	nop
			 * 6	nop
			 * 7	nop
			 */
			rpi->pi_skip_method = RD_RESOLVE_STEP;
			rpi->pi_nstep = 5;
			rpi->pi_target = 0;
			if (rtld_db_version >= RD_VERSION3) {
				uintptr_t hi_bits;
				uintptr_t lo_bits;
				hi_bits = (instr[1] & S_MASK(22)) << 10;
				lo_bits = (instr[2] & S_MASK(10));
				destaddr = hi_bits ^ ~lo_bits;
				pltbound++;
			}
		} else if ((instr[2] & (~(S_MASK(13)))) == M_XNOR_G5G1) {
			/*
			 * Resolved 64-bit PLT entry format (top-44):
			 *
			 * .PLT:
			 * 0	nop
			 * 1	sethi	%h44(~dest), %g5
			 * 2	xnor	%g5, %m44(~dest), %g1
			 * 3	slxx	%g1, 12, %g1
			 * 4	jmpl %g1 + %l44(dest), %g0
			 * 5	nop
			 * 6	nop
			 * 7	nop
			 */
			rpi->pi_skip_method = RD_RESOLVE_STEP;
			rpi->pi_nstep = 6;
			rpi->pi_target = 0;
			if (rtld_db_version >= RD_VERSION3) {
				uintptr_t h44_bits;
				uintptr_t	m44_bits;
				uintptr_t	l44_bits;
				h44_bits = (((long)instr[1] & S_MASK(22))
					<< 10);
				m44_bits = (((long)instr[2] & S_MASK(13))
					<< 41) >> 41;
				l44_bits = (((long)instr[4] & S_MASK(13))
					<< 41) >> 41;
				destaddr = (~(h44_bits ^ m44_bits) << 12)
					+ l44_bits;
				pltbound++;
			}
		} else
			rpi->pi_skip_method = RD_RESOLVE_NONE;
	}

	if ((rtld_db_version >= RD_VERSION3) && pltbound) {
		rpi->pi_flags |= RD_FLG_PI_PLTBOUND;
		rpi->pi_baddr = destaddr;
	}

	return (RD_OK);
}