drivers/staging/tidspbridge/dynload/reloc.c - linux/kernel/git/viro/vfs - Git at Google

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