/*
 * reloc.c
 *
 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
 *
 * Copyright (C) 2005-2006 Texas Instruments, Inc.
 *
 * This package is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "header.h"

#if TMS32060
/* the magic symbol for the start of BSS */
static const char bsssymbol[] = { ".bss" };
#endif

#if TMS32060
#include "reloc_table_c6000.c"
#endif

#if TMS32060
/* From coff.h - ignore these relocation operations */
#define R_C60ALIGN     0x76	/* C60: Alignment info for compressor */
#define R_C60FPHEAD    0x77	/* C60: Explicit assembly directive */
#define R_C60NOCMP    0x100	/* C60: Don't compress this code scn */
#endif

/**************************************************************************
 * Procedure dload_unpack
 *
 * Parameters:
 *	data	pointer to storage unit containing lowest host address of
 *		image data
 *	fieldsz	Size of bit field, 0 < fieldsz <= sizeof(rvalue)*BITS_PER_AU
 *	offset	Offset from LSB, 0 <= offset < BITS_PER_AU
 *	sgn	Signedness of the field (ROP_SGN, ROP_UNS, ROP_MAX, ROP_ANY)
 *
 * Effect:
 *	Extracts the specified field and returns it.
 ************************************************************************* */
rvalue dload_unpack(struct dload_state *dlthis, tgt_au_t * data, int fieldsz,
		    int offset, unsigned sgn)
{
	register rvalue objval;
	register int shift, direction;
	register tgt_au_t *dp = data;

	fieldsz -= 1;	/* avoid nastiness with 32-bit shift of 32-bit value */
	/* * collect up enough bits to contain the desired field */
	if (TARGET_BIG_ENDIAN) {
		dp += (fieldsz + offset) >> LOG_TGTAU_BITS;
		direction = -1;
	} else
		direction = 1;
	objval = *dp >> offset;
	shift = TGTAU_BITS - offset;
	while (shift <= fieldsz) {
		dp += direction;
		objval += (rvalue) *dp << shift;
		shift += TGTAU_BITS;
	}

	/* * sign or zero extend the value appropriately */
	if (sgn == ROP_UNS)
		objval &= (2 << fieldsz) - 1;
	else {
		shift = sizeof(rvalue) * BITS_PER_AU - 1 - fieldsz;
		objval = (objval << shift) >> shift;
	}

	return objval;

}				/* dload_unpack */

/**************************************************************************
 * Procedure dload_repack
 *
 * Parameters:
 *	val		Value to insert
 *	data	Pointer to storage unit containing lowest host address of
 * 		image data
 *	fieldsz	Size of bit field, 0 < fieldsz <= sizeof(rvalue)*BITS_PER_AU
 *	offset	Offset from LSB, 0 <= offset < BITS_PER_AU
 *	sgn	Signedness of the field (ROP_SGN, ROP_UNS, ROP_MAX, ROP_ANY)
 *
 * Effect:
 *	Stuffs the specified value in the specified field.  Returns 0 for
 *	success
 * or 1 if the value will not fit in the specified field according to the
 * specified signedness rule.
 ************************************************************************* */
static const unsigned char ovf_limit[] = { 1, 2, 2 };

int dload_repack(struct dload_state *dlthis, rvalue val, tgt_au_t * data,
		 int fieldsz, int offset, unsigned sgn)
{
	register urvalue objval, mask;
	register int shift, direction;
	register tgt_au_t *dp = data;

	fieldsz -= 1;	/* avoid nastiness with 32-bit shift of 32-bit value */
	/* clip the bits */
	mask = (2UL << fieldsz) - 1;
	objval = (val & mask);
	/* * store the bits through the specified mask */
	if (TARGET_BIG_ENDIAN) {
		dp += (fieldsz + offset) >> LOG_TGTAU_BITS;
		direction = -1;
	} else
		direction = 1;

	/* insert LSBs */
	*dp = (*dp & ~(mask << offset)) + (objval << offset);
	shift = TGTAU_BITS - offset;
	/* align mask and objval with AU boundary */
	objval >>= shift;
	mask >>= shift;

	while (mask) {
		dp += direction;
		*dp = (*dp & ~mask) + objval;
		objval >>= TGTAU_BITS;
		mask >>= TGTAU_BITS;
	}

	/*
	 * check for overflow
	 */
	if (sgn) {
		unsigned tmp = (val >> fieldsz) + (sgn & 0x1);
		if (tmp > ovf_limit[sgn - 1])
			return 1;
	}
	return 0;

}				/* dload_repack */

/* lookup table for the scaling amount in a C6x instruction */
#if TMS32060
#define SCALE_BITS 4		/* there are 4 bits in the scale field */
#define SCALE_MASK 0x7		/* we really only use the bottom 3 bits */
static const u8 c60_scale[SCALE_MASK + 1] = {
	1, 0, 0, 0, 1, 1, 2, 2
};
#endif

/**************************************************************************
 * Procedure dload_relocate
 *
 * Parameters:
 *	data	Pointer to base of image data
 *	rp		Pointer to relocation operation
 *
 * Effect:
 *	Performs the specified relocation operation
 ************************************************************************* */
void dload_relocate(struct dload_state *dlthis, tgt_au_t * data,
		    struct reloc_record_t *rp, bool *tramps_generated,
		    bool second_pass)
{
	rvalue val, reloc_amt, orig_val = 0;
	unsigned int fieldsz = 0;
	unsigned int offset = 0;
	unsigned int reloc_info = 0;
	unsigned int reloc_action = 0;
	register int rx = 0;
	rvalue *stackp = NULL;
	int top;
	struct local_symbol *svp = NULL;
#ifdef RFV_SCALE
	unsigned int scale = 0;
#endif
	struct image_packet_t *img_pkt = NULL;

	/* The image packet data struct is only used during first pass
	 * relocation in the event that a trampoline is needed.  2nd pass
	 * relocation doesn't guarantee that data is coming from an
	 * image_packet_t structure. See cload.c, dload_data for how img_data is
	 * set. If that changes this needs to be updated!!! */
	if (second_pass == false)
		img_pkt = (struct image_packet_t *)((u8 *) data -
						    sizeof(struct
							   image_packet_t));

	rx = HASH_FUNC(rp->TYPE);
	while (rop_map1[rx] != rp->TYPE) {
		rx = HASH_L(rop_map2[rx]);
		if (rx < 0) {
#if TMS32060
			switch (rp->TYPE) {
			case R_C60ALIGN:
			case R_C60NOCMP:
			case R_C60FPHEAD:
				/* Ignore these reloc types and return */
				break;
			default:
				/* Unknown reloc type, print error and return */
				dload_error(dlthis, "Bad coff operator 0x%x",
					    rp->TYPE);
			}
#else
			dload_error(dlthis, "Bad coff operator 0x%x", rp->TYPE);
#endif
			return;
		}
	}
	rx = HASH_I(rop_map2[rx]);
	if ((rx < (sizeof(rop_action) / sizeof(u16)))
	    && (rx < (sizeof(rop_info) / sizeof(u16))) && (rx > 0)) {
		reloc_action = rop_action[rx];
		reloc_info = rop_info[rx];
	} else {
		dload_error(dlthis, "Buffer Overflow - Array Index Out "
			    "of Bounds");
	}

	/* Compute the relocation amount for the referenced symbol, if any */
	reloc_amt = rp->UVAL;
	if (RFV_SYM(reloc_info)) {	/* relocation uses a symbol reference */
		/* If this is first pass, use the module local symbol table,
		 * else use the trampoline symbol table. */
		if (second_pass == false) {
			if ((u32) rp->SYMNDX < dlthis->dfile_hdr.df_no_syms) {
				/* real symbol reference */
				svp = &dlthis->local_symtab[rp->SYMNDX];
				reloc_amt = (RFV_SYM(reloc_info) == ROP_SYMD) ?
				    svp->delta : svp->value;
			}
			/* reloc references current section */
			else if (rp->SYMNDX == -1) {
				reloc_amt = (RFV_SYM(reloc_info) == ROP_SYMD) ?
				    dlthis->delta_runaddr :
				    dlthis->image_secn->run_addr;
			}
		}
	}
	/* relocation uses a symbol reference */
	/* Handle stack adjustment */
	val = 0;
	top = RFV_STK(reloc_info);
	if (top) {
		top += dlthis->relstkidx - RSTK_UOP;
		if (top >= STATIC_EXPR_STK_SIZE) {
			dload_error(dlthis,
				    "Expression stack overflow in %s at offset "
				    FMT_UI32, dlthis->image_secn->name,
				    rp->vaddr + dlthis->image_offset);
			return;
		}
		val = dlthis->relstk[dlthis->relstkidx];
		dlthis->relstkidx = top;
		stackp = &dlthis->relstk[top];
	}
	/* Derive field position and size, if we need them */
	if (reloc_info & ROP_RW) {	/* read or write action in our future */
		fieldsz = RFV_WIDTH(reloc_action);
		if (fieldsz) {	/* field info from table */
			offset = RFV_POSN(reloc_action);
			if (TARGET_BIG_ENDIAN)
				/* make sure vaddr is the lowest target
				 * address containing bits */
				rp->vaddr += RFV_BIGOFF(reloc_info);
		} else {	/* field info from relocation op */
			fieldsz = rp->FIELDSZ;
			offset = rp->OFFSET;
			if (TARGET_BIG_ENDIAN)
				/* make sure vaddr is the lowest target
				   address containing bits */
				rp->vaddr += (rp->WORDSZ - offset - fieldsz)
				    >> LOG_TARGET_AU_BITS;
		}
		data = (tgt_au_t *) ((char *)data + TADDR_TO_HOST(rp->vaddr));
		/* compute lowest host location of referenced data */
#if BITS_PER_AU > TARGET_AU_BITS
		/* conversion from target address to host address may lose
		   address bits; add loss to offset */
		if (TARGET_BIG_ENDIAN) {
			offset += -((rp->vaddr << LOG_TARGET_AU_BITS) +
				    offset + fieldsz) &
			    (BITS_PER_AU - TARGET_AU_BITS);
		} else {
			offset += (rp->vaddr << LOG_TARGET_AU_BITS) &
			    (BITS_PER_AU - 1);
		}
#endif
#ifdef RFV_SCALE
		scale = RFV_SCALE(reloc_info);
#endif
	}
	/* read the object value from the current image, if so ordered */
	if (reloc_info & ROP_R) {
		/* relocation reads current image value */
		val = dload_unpack(dlthis, data, fieldsz, offset,
				   RFV_SIGN(reloc_info));
		/* Save off the original value in case the relo overflows and
		 * we can trampoline it. */
		orig_val = val;

#ifdef RFV_SCALE
		val <<= scale;
#endif
	}
	/* perform the necessary arithmetic */
	switch (RFV_ACTION(reloc_action)) {	/* relocation actions */
	case RACT_VAL:
		break;
	case RACT_ASGN:
		val = reloc_amt;
		break;
	case RACT_ADD:
		val += reloc_amt;
		break;
	case RACT_PCR:
		/*-----------------------------------------------------------
		 * Handle special cases of jumping from absolute sections
		 * (special reloc type) or to absolute destination
		 * (symndx == -1).  In either case, set the appropriate
		 * relocation amount to 0.
		 *----------------------------------------------------------- */
		if (rp->SYMNDX == -1)
			reloc_amt = 0;
		val += reloc_amt - dlthis->delta_runaddr;
		break;
	case RACT_ADDISP:
		val += rp->R_DISP + reloc_amt;
		break;
	case RACT_ASGPC:
		val = dlthis->image_secn->run_addr + reloc_amt;
		break;
	case RACT_PLUS:
		if (stackp != NULL)
			val += *stackp;
		break;
	case RACT_SUB:
		if (stackp != NULL)
			val = *stackp - val;
		break;
	case RACT_NEG:
		val = -val;
		break;
	case RACT_MPY:
		if (stackp != NULL)
			val *= *stackp;
		break;
	case RACT_DIV:
		if (stackp != NULL)
			val = *stackp / val;
		break;
	case RACT_MOD:
		if (stackp != NULL)
			val = *stackp % val;
		break;
	case RACT_SR:
		if (val >= sizeof(rvalue) * BITS_PER_AU)
			val = 0;
		else if (stackp != NULL)
			val = (urvalue) *stackp >> val;
		break;
	case RACT_ASR:
		if (val >= sizeof(rvalue) * BITS_PER_AU)
			val = sizeof(rvalue) * BITS_PER_AU - 1;
		else if (stackp != NULL)
			val = *stackp >> val;
		break;
	case RACT_SL:
		if (val >= sizeof(rvalue) * BITS_PER_AU)
			val = 0;
		else if (stackp != NULL)
			val = *stackp << val;
		break;
	case RACT_AND:
		if (stackp != NULL)
			val &= *stackp;
		break;
	case RACT_OR:
		if (stackp != NULL)
			val |= *stackp;
		break;
	case RACT_XOR:
		if (stackp != NULL)
			val ^= *stackp;
		break;
	case RACT_NOT:
		val = ~val;
		break;
#if TMS32060
	case RACT_C6SECT:
		/* actually needed address of secn containing symbol */
		if (svp != NULL) {
			if (rp->SYMNDX >= 0)
				if (svp->secnn > 0)
					reloc_amt = dlthis->ldr_sections
					    [svp->secnn - 1].run_addr;
		}
		/* !!! FALL THRU !!! */
	case RACT_C6BASE:
		if (dlthis->bss_run_base == 0) {
			struct dynload_symbol *symp;
			symp = dlthis->mysym->find_matching_symbol
			    (dlthis->mysym, bsssymbol);
			/* lookup value of global BSS base */
			if (symp)
				dlthis->bss_run_base = symp->value;
			else
				dload_error(dlthis,
					    "Global BSS base referenced in %s "
					    "offset" FMT_UI32 " but not "
					    "defined",
					    dlthis->image_secn->name,
					    rp->vaddr + dlthis->image_offset);
		}
		reloc_amt -= dlthis->bss_run_base;
		/* !!! FALL THRU !!! */
	case RACT_C6DSPL:
		/* scale factor determined by 3 LSBs of field */
		scale = c60_scale[val & SCALE_MASK];
		offset += SCALE_BITS;
		fieldsz -= SCALE_BITS;
		val >>= SCALE_BITS;	/* ignore the scale field hereafter */
		val <<= scale;
		val += reloc_amt;	/* do the usual relocation */
		if (((1 << scale) - 1) & val)
			dload_error(dlthis,
				    "Unaligned reference in %s offset "
				    FMT_UI32, dlthis->image_secn->name,
				    rp->vaddr + dlthis->image_offset);
		break;
#endif
	}			/* relocation actions */
	/* * Put back result as required */
	if (reloc_info & ROP_W) {	/* relocation writes image value */
#ifdef RFV_SCALE
		val >>= scale;
#endif
		if (dload_repack(dlthis, val, data, fieldsz, offset,
				 RFV_SIGN(reloc_info))) {
			/* Check to see if this relo can be trampolined,
			 * but only in first phase relocation.  2nd phase
			 * relocation cannot trampoline. */
			if ((second_pass == false) &&
			    (dload_tramp_avail(dlthis, rp) == true)) {

				/* Before generating the trampoline, restore
				 * the value to its original so the 2nd pass
				 *  relo will work. */
				dload_repack(dlthis, orig_val, data, fieldsz,
					     offset, RFV_SIGN(reloc_info));
				if (!dload_tramp_generate(dlthis,
							(dlthis->image_secn -
							 dlthis->ldr_sections),
							 dlthis->image_offset,
							 img_pkt, rp)) {
					dload_error(dlthis,
						    "Failed to "
						    "generate trampoline for "
						    "bit overflow");
					dload_error(dlthis,
						    "Relocation val " FMT_UI32
						    " overflows %d bits in %s "
						    "offset " FMT_UI32, val,
						    fieldsz,
						    dlthis->image_secn->name,
						    dlthis->image_offset +
						    rp->vaddr);
				} else
					*tramps_generated = true;
			} else {
				dload_error(dlthis, "Relocation value "
					    FMT_UI32 " overflows %d bits in %s"
					    " offset " FMT_UI32, val, fieldsz,
					    dlthis->image_secn->name,
					    dlthis->image_offset + rp->vaddr);
			}
		}
	} else if (top)
		*stackp = val;
}				/* reloc_value */