[deliverable/binutils-gdb.git] / bfd / coff-a29k.c

/* AMD 29000 COFF back-end for BFD.
   Copyright (C) 1990-1991 Free Software Foundation, Inc.
   Contributed by David Wood at New York University 7/8/91.

This file is part of BFD, the Binary File Descriptor library.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* $Id$ */

#define A29K 1

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "obstack.h"
#include "amdcoff.h"
#include "internalcoff.h"
#include "libcoff.h"

#define INSERT_HWORD(WORD,HWORD)	\
	(((WORD) & 0xff00ff00) | (((HWORD) & 0xff00) << 8) | ((HWORD)& 0xff))
#define EXTRACT_HWORD(WORD) 	(((WORD) & 0x00ff0000) >> 8) | ((WORD) & 0xff)

/* Provided the symbol, returns the value reffed */
static  long
get_symbol_value(symbol)       
asymbol *symbol;
{                                             
  long relocation = 0;

  if (symbol != (asymbol *)NULL) {              
    if (symbol->flags & BSF_FORT_COMM) {        
      relocation = 0;                           
    } else {                                      
      relocation = symbol->value;               
    }                                           
    if (symbol->section != (asection *)NULL) {    
      relocation += symbol->section->output_section->vma +
        	symbol->section->output_offset;           
    }                                             
  }
  return(relocation);
}

static bfd_reloc_status_type
a29k_reloc(abfd, reloc_entry, symbol_in, data, input_section)
bfd *abfd;
arelent *reloc_entry;
asymbol *symbol_in;
unsigned char *data;
asection *input_section;
{
	static unsigned long part1_consth_active=0;
	static unsigned long part1_consth_value;
	unsigned long insn, value, sym_value; 
	unsigned short r_type;
/*  	bfd_reloc_status_type result;*/
/*  	coff_symbol_type *cs = coffsymbol(symbol_in);*/
	
	r_type = reloc_entry->howto->type;

        /* FIXME: Do we need to check for partial linking here */
        if (symbol_in && (symbol_in->flags & BSF_UNDEFINED)) {
		/* Keep the state machine happy in case we're called again */
		if (r_type == R_IHIHALF) {
			part1_consth_active = 1;
			part1_consth_value  = 0;
		}
                return(bfd_reloc_undefined);
	}

	if ((part1_consth_active) && (r_type != R_IHCONST)) {
		fprintf(stderr,"Relocation problem : ");
		fprintf(stderr,"Missing IHCONST in module %s\n",abfd->filename);
		part1_consth_active = 0;
		return(bfd_reloc_dangerous);
	}

	insn = bfd_get_32(abfd, data + reloc_entry->address); 
	sym_value = get_symbol_value(symbol_in);

	switch (r_type) {
	case R_IREL: 	
		value = EXTRACT_HWORD(insn) << 2;
		value +=  sym_value + reloc_entry->addend;
		if (value <= 0x3ffff) {		/* Absolute jmp/call */
			insn |= 0x01000000;	/* Make it absolute */
			/* FIXME: Should we change r_type to R_IABS */
		} else {			/* Relative jmp/call */
			value -= reloc_entry->address;
			if (value > 0x3ffff) {
				fprintf(stderr,"Relocation problem : ");
				fprintf(stderr,"Jmp/call too far; to %s from %s\n",
					symbol_in->name,abfd->filename); 
				return(bfd_reloc_outofrange);
			}
		}
		value >>= 2;
		insn = INSERT_HWORD(insn,value);
		break;
	case R_ILOHALF: 
		value = EXTRACT_HWORD(insn);
		value +=  sym_value + reloc_entry->addend;
		insn = INSERT_HWORD(insn,value);
		break;
	case R_IHIHALF: 	/* consth, part 1 */
		/* Just get the symbol value that is referenced */
		part1_consth_active = 1;
		part1_consth_value = sym_value + reloc_entry->addend;
		return(bfd_reloc_ok);	/* Don't modify insn until R_IHCONST */
		break;
	case R_IHCONST: 	/* consth, part 2 */
		/* Now relocate the reference */
		if (!part1_consth_active) {
			fprintf(stderr,"Relocation problem : ");
			fprintf(stderr,"IHIHALF missing in module %s\n",
				abfd->filename); 
			part1_consth_active = 0;
			return(bfd_reloc_dangerous);
		}
		/* sym_ptr_ptr = r_symndx, in coff_slurp_reloc_table() */
		value = (unsigned int)reloc_entry->addend; /* r_symndx */
		value += part1_consth_value;
		value >>= 16;
		insn = INSERT_HWORD(insn,value);
		part1_consth_active = 0;
		break;
	case R_BYTE:
		value = (insn >> 24) + sym_value + reloc_entry->addend;	
		if (value & 0xffffff00) {
			fprintf(stderr,"Relocation problem : ");
			fprintf(stderr,"byte value too large in module %s\n",
				abfd->filename); 
			return(bfd_reloc_overflow);
		}
		insn = (insn & 0x00ffffff) | (value << 24);
		break;
	case R_HWORD:
		value = (insn >> 16) + sym_value + reloc_entry->addend;	
		if (value & 0xffff0000) {
			fprintf(stderr,"Relocation problem : ");
			fprintf(stderr,"hword value too large in module %s\n",
				abfd->filename); 
			return(bfd_reloc_overflow);
		}
		insn = (insn & 0x0000ffff) | (value<<16); 
		break;
	case R_WORD:
		insn += sym_value + reloc_entry->addend;  
		break;
	default:
		fprintf(stderr,"Relocation problem : ");
		fprintf(stderr,"Unrecognized reloc type %d, in module %s\n",
				r_type,abfd->filename); 
		return (bfd_reloc_dangerous);
	}

	bfd_put_32(abfd, insn, data+reloc_entry->address);
	return(bfd_reloc_ok);	
}

/*      type	   rightshift
		       size
			  bitsize
			       pc-relative
				     bitpos
					 absolute
					     complain_on_overflow
						  special_function
						    relocation name
							       partial_inplace 
								      src_mask
*/

/*FIXME: I'm not real sure about this table */
#define NA	0	/* Obsolete fields, via the documentation */
static reloc_howto_type howto_table[] = 
{
  {R_ABS,     0, 3, NA, false, NA, NA, true,a29k_reloc,"ABS",     true, 0xffffffff,0xffffffff, false},
  {1},  {2},  {3},   {4},  {5},  {6},  {7},  {8},  {9}, {10},
  {11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}, {19}, {20},
  {21}, {22}, {23},
  {R_IREL,    0, 3, NA, true,  NA, NA, true,a29k_reloc,"IREL",    true, 0xffffffff,0xffffffff, false},
  {R_IABS,    0, 3, NA, false, NA, NA, true,a29k_reloc,"IABS",    true, 0xffffffff,0xffffffff, false},
  {R_ILOHALF, 0, 3, NA, true,  NA, NA, true,a29k_reloc,"ILOHALF", true, 0x0000ffff,0x0000ffff, false},
  {R_IHIHALF, 0, 3, NA, true,  NA, NA, true,a29k_reloc,"IHIHALF", true, 0xffff0000,0xffff0000, false},
  {R_IHCONST, 0, 3, NA, true,  NA, NA, true,a29k_reloc,"IHCONST", true, 0xffff0000,0xffff0000, false},
  {R_BYTE,    0, 0, NA, false, NA, NA, true,a29k_reloc,"BYTE",    true, 0x000000ff,0x000000ff, false},
  {R_HWORD,   0, 1, NA, false, NA, NA, true,a29k_reloc,"HWORD",   true, 0x0000ffff,0x0000ffff, false},
  {R_WORD,    0, 2, NA, false, NA, NA, true,a29k_reloc,"WORD",    true, 0xffffffff,0xffffffff, false},
};
#undef NA

#define BADMAG(x) A29KBADMAG(x)

#include "coffcode.h"

bfd_target a29kcoff_big_vec =
{
  "coff-a29k-big",		/* name */
  bfd_target_coff_flavour,
  true,				/* data byte order is big */
  true,				/* header byte order is big */

  (HAS_RELOC | EXEC_P |		/* object flags */
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT),

  (SEC_HAS_CONTENTS | SEC_ALLOC /* section flags */
	| SEC_LOAD | SEC_RELOC  
	| SEC_READONLY ),
  '/',				/* ar_pad_char */
  15,				/* ar_max_namelen */

     3,				/* minimum section alignment */
_do_getb64, _do_putb64,  _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
_do_getb64, _do_putb64,  _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */


  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
     bfd_generic_archive_p, _bfd_dummy_target},
  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
     bfd_false},
  {bfd_false, coff_write_object_contents,	/* bfd_write_contents */
     _bfd_write_archive_contents, bfd_false},

     JUMP_TABLE(coff),
     COFF_SWAP_TABLE
  };
Commit	Line	Data
3c8a3c56 JG	1	/* AMD 29000 COFF back-end for BFD.
	2	Copyright (C) 1990-1991 Free Software Foundation, Inc.
	3	Contributed by David Wood at New York University 7/8/91.
2013f9b4	4
3c8a3c56	5	This file is part of BFD, the Binary File Descriptor library.
2013f9b4	6
3c8a3c56	7	This program is free software; you can redistribute it and/or modify
2013f9b4	8	it under the terms of the GNU General Public License as published by
3c8a3c56 JG	9	the Free Software Foundation; either version 2 of the License, or
3c8a3c56 JG	10	(at your option) any later version.
2013f9b4	11
3c8a3c56	12	This program is distributed in the hope that it will be useful,
2013f9b4 SC	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
3c8a3c56 JG	18	along with this program; if not, write to the Free Software
3c8a3c56 JG	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
2013f9b4 SC	20
	21	/* $Id$ */
	22
	23	#define A29K 1
	24
2013f9b4	25	#include "bfd.h"
bbc8d484	26	#include "sysdep.h"
2013f9b4 SC	27	#include "libbfd.h"
	28	#include "obstack.h"
	29	#include "amdcoff.h"
	30	#include "internalcoff.h"
	31	#include "libcoff.h"
	32
	33	#define INSERT_HWORD(WORD,HWORD) \
	34	(((WORD) & 0xff00ff00) \| (((HWORD) & 0xff00) << 8) \| ((HWORD)& 0xff))
	35	#define EXTRACT_HWORD(WORD) (((WORD) & 0x00ff0000) >> 8) \| ((WORD) & 0xff)
	36
	37	/* Provided the symbol, returns the value reffed */
	38	static long
	39	get_symbol_value(symbol)
	40	asymbol *symbol;
	41	{
	42	long relocation = 0;
	43
	44	if (symbol != (asymbol *)NULL) {
	45	if (symbol->flags & BSF_FORT_COMM) {
	46	relocation = 0;
	47	} else {
	48	relocation = symbol->value;
	49	}
	50	if (symbol->section != (asection *)NULL) {
	51	relocation += symbol->section->output_section->vma +
	52	symbol->section->output_offset;
	53	}
	54	}
	55	return(relocation);
	56	}
	57
9e2dad8e	58	static bfd_reloc_status_type
2013f9b4 SC	59	a29k_reloc(abfd, reloc_entry, symbol_in, data, input_section)
	60	bfd *abfd;
	61	arelent *reloc_entry;
	62	asymbol *symbol_in;
	63	unsigned char *data;
	64	asection *input_section;
	65	{
	66	static unsigned long part1_consth_active=0;
	67	static unsigned long part1_consth_value;
	68	unsigned long insn, value, sym_value;
	69	unsigned short r_type;
9e2dad8e	70	/* bfd_reloc_status_type result;*/
2013f9b4 SC	71	/* coff_symbol_type cs = coffsymbol(symbol_in);/
	72
	73	r_type = reloc_entry->howto->type;
	74
	75	/* FIXME: Do we need to check for partial linking here */
	76	if (symbol_in && (symbol_in->flags & BSF_UNDEFINED)) {
	77	/* Keep the state machine happy in case we're called again */
	78	if (r_type == R_IHIHALF) {
	79	part1_consth_active = 1;
	80	part1_consth_value = 0;
	81	}
	82	return(bfd_reloc_undefined);
	83	}
	84
	85	if ((part1_consth_active) && (r_type != R_IHCONST)) {
	86	fprintf(stderr,"Relocation problem : ");
	87	fprintf(stderr,"Missing IHCONST in module %s\n",abfd->filename);
	88	part1_consth_active = 0;
	89	return(bfd_reloc_dangerous);
	90	}
	91
	92	insn = bfd_get_32(abfd, data + reloc_entry->address);
	93	sym_value = get_symbol_value(symbol_in);
	94
	95	switch (r_type) {
	96	case R_IREL:
	97	value = EXTRACT_HWORD(insn) << 2;
	98	value += sym_value + reloc_entry->addend;
	99	if (value <= 0x3ffff) { /* Absolute jmp/call */
	100	insn \|= 0x01000000; /* Make it absolute */
	101	/* FIXME: Should we change r_type to R_IABS */
	102	} else { /* Relative jmp/call */
	103	value -= reloc_entry->address;
	104	if (value > 0x3ffff) {
	105	fprintf(stderr,"Relocation problem : ");
63ffe5ef	106	fprintf(stderr,"Jmp/call too far; to %s from %s\n",
2013f9b4 SC	107	symbol_in->name,abfd->filename);
	108	return(bfd_reloc_outofrange);
	109	}
	110	}
	111	value >>= 2;
	112	insn = INSERT_HWORD(insn,value);
	113	break;
	114	case R_ILOHALF:
	115	value = EXTRACT_HWORD(insn);
	116	value += sym_value + reloc_entry->addend;
	117	insn = INSERT_HWORD(insn,value);
	118	break;
	119	case R_IHIHALF: /* consth, part 1 */
	120	/* Just get the symbol value that is referenced */
	121	part1_consth_active = 1;
	122	part1_consth_value = sym_value + reloc_entry->addend;
	123	return(bfd_reloc_ok); /* Don't modify insn until R_IHCONST */
	124	break;
	125	case R_IHCONST: /* consth, part 2 */
	126	/* Now relocate the reference */
	127	if (!part1_consth_active) {
	128	fprintf(stderr,"Relocation problem : ");
	129	fprintf(stderr,"IHIHALF missing in module %s\n",
	130	abfd->filename);
	131	part1_consth_active = 0;
	132	return(bfd_reloc_dangerous);
	133	}
	134	/* sym_ptr_ptr = r_symndx, in coff_slurp_reloc_table() */
	135	value = (unsigned int)reloc_entry->addend; /* r_symndx */
	136	value += part1_consth_value;
	137	value >>= 16;
	138	insn = INSERT_HWORD(insn,value);
	139	part1_consth_active = 0;
	140	break;
	141	case R_BYTE:
	142	value = (insn >> 24) + sym_value + reloc_entry->addend;
	143	if (value & 0xffffff00) {
	144	fprintf(stderr,"Relocation problem : ");
	145	fprintf(stderr,"byte value too large in module %s\n",
	146	abfd->filename);
	147	return(bfd_reloc_overflow);
	148	}
	149	insn = (insn & 0x00ffffff) \| (value << 24);
	150	break;
	151	case R_HWORD:
	152	value = (insn >> 16) + sym_value + reloc_entry->addend;
	153	if (value & 0xffff0000) {
	154	fprintf(stderr,"Relocation problem : ");
	155	fprintf(stderr,"hword value too large in module %s\n",
	156	abfd->filename);
	157	return(bfd_reloc_overflow);
	158	}
	159	insn = (insn & 0x0000ffff) \| (value<<16);
	160	break;
	161	case R_WORD:
	162	insn += sym_value + reloc_entry->addend;
	163	break;
	164	default:
	165	fprintf(stderr,"Relocation problem : ");
	166	fprintf(stderr,"Unrecognized reloc type %d, in module %s\n",
	167	r_type,abfd->filename);
	168	return (bfd_reloc_dangerous);
	169	}
	170
171	bfd_put_32(abfd, insn, data+reloc_entry->address);
172	return(bfd_reloc_ok);
173	}
174
175	/* type rightshift
176	size
177	bitsize
178	pc-relative
179	bitpos
180	absolute
181	complain_on_overflow
182	special_function
183	relocation name
184	partial_inplace
185	src_mask
186	*/
187
188	/FIXME: I'm not real sure about this table /
189	#define NA 0 /* Obsolete fields, via the documentation */
190	static reloc_howto_type howto_table[] =
191	{
192	{R_ABS, 0, 3, NA, false, NA, NA, true,a29k_reloc,"ABS", true, 0xffffffff,0xffffffff, false},
193	{1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10},
194	{11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}, {19}, {20},
195	{21}, {22}, {23},
196	{R_IREL, 0, 3, NA, true, NA, NA, true,a29k_reloc,"IREL", true, 0xffffffff,0xffffffff, false},
197	{R_IABS, 0, 3, NA, false, NA, NA, true,a29k_reloc,"IABS", true, 0xffffffff,0xffffffff, false},
198	{R_ILOHALF, 0, 3, NA, true, NA, NA, true,a29k_reloc,"ILOHALF", true, 0x0000ffff,0x0000ffff, false},
199	{R_IHIHALF, 0, 3, NA, true, NA, NA, true,a29k_reloc,"IHIHALF", true, 0xffff0000,0xffff0000, false},
200	{R_IHCONST, 0, 3, NA, true, NA, NA, true,a29k_reloc,"IHCONST", true, 0xffff0000,0xffff0000, false},
201	{R_BYTE, 0, 0, NA, false, NA, NA, true,a29k_reloc,"BYTE", true, 0x000000ff,0x000000ff, false},
202	{R_HWORD, 0, 1, NA, false, NA, NA, true,a29k_reloc,"HWORD", true, 0x0000ffff,0x0000ffff, false},
203	{R_WORD, 0, 2, NA, false, NA, NA, true,a29k_reloc,"WORD", true, 0xffffffff,0xffffffff, false},
204	};
205	#undef NA
206
207	#define BADMAG(x) A29KBADMAG(x)
208
209	#include "coffcode.h"
210
211	bfd_target a29kcoff_big_vec =
212	{
213	"coff-a29k-big", /* name */
9e2dad8e	214	bfd_target_coff_flavour,
2013f9b4 SC	215	true, /* data byte order is big */
	216	true, /* header byte order is big */
	217
	218	(HAS_RELOC \| EXEC_P \| /* object flags */
	219	HAS_LINENO \| HAS_DEBUG \|
	220	HAS_SYMS \| HAS_LOCALS \| DYNAMIC \| WP_TEXT),
	221
	222	(SEC_HAS_CONTENTS \| SEC_ALLOC /* section flags */
	223	\| SEC_LOAD \| SEC_RELOC
	224	\| SEC_READONLY ),
	225	'/', /* ar_pad_char */
	226	15, /* ar_max_namelen */
	227
	228	3, /* minimum section alignment */
	229	_do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
	230	_do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
	231
	232
	233	{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
	234	bfd_generic_archive_p, _bfd_dummy_target},
	235	{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
	236	bfd_false},
	237	{bfd_false, coff_write_object_contents, /* bfd_write_contents */
	238	_bfd_write_archive_contents, bfd_false},
	239
	240	JUMP_TABLE(coff),
	241	COFF_SWAP_TABLE
	242	};
	243