path: root/drivers/staging/tidspbridge/dynload/reloc.c

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