[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 "coff/a29k.h"
#include "coff/internal.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)
#define SIGN_EXTEND_HWORD(HWORD) \
    ((HWORD) & 0x8000 ? (HWORD)|0xffff0000 : (HWORD))

/* 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);
}

/* this function is in charge of performing all the 29k relocations */

static bfd_reloc_status_type
DEFUN(a29k_reloc,(abfd, reloc_entry, symbol_in, data, input_section),
      bfd *abfd AND
      arelent *reloc_entry AND
      asymbol *symbol_in AND
      unsigned char *data AND
      asection *input_section)
{
    /* the consth relocation comes in two parts, we have to remember
       the state between calls, in these variables */
    static boolean part1_consth_active = false;
    static unsigned long part1_consth_value;

    unsigned long insn;
    unsigned long sym_value;
    unsigned long unsigned_value;
    unsigned short r_type;
    long signed_value;

	
    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 = true;
	    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 = false;
	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: 	
	/* Take the value in the field and sign extend it */
	signed_value = EXTRACT_HWORD(insn) << 2;
	signed_value = SIGN_EXTEND_HWORD(signed_value);
	signed_value +=  sym_value + reloc_entry->addend;
	if ((signed_value&~0x3ffff) == 0) 
	{			/* Absolute jmp/call */
	    insn |= (1<<24);	/* Make it absolute */
	    /* FIXME: Should we change r_type to R_IABS */
	    signed_value /= 2;
	} 
	else 
	{
	    /* Relative jmp/call, so subtract from the value the
	       address of the place we're coming from */
	    signed_value -= reloc_entry->address + 
	     input_section->output_section->vma + 
	      input_section->output_offset;
	    if (signed_value>0x1ffff || signed_value<-0x20000) 
	     return(bfd_reloc_outofrange);

	    signed_value /= 2;
	}
	insn = INSERT_HWORD(insn, signed_value);
	break;
      case R_ILOHALF: 
	unsigned_value = EXTRACT_HWORD(insn);
	unsigned_value +=  sym_value + reloc_entry->addend;
	insn = INSERT_HWORD(insn, unsigned_value);
	break;
      case R_IHIHALF:
	/* consth, part 1 
	  Just get the symbol value that is referenced */
	part1_consth_active = true;
	part1_consth_value = sym_value + reloc_entry->addend;
	/* Don't modify insn until R_IHCONST */
	return(bfd_reloc_ok);
	break;
      case R_IHCONST:	
	/* consth, part 2 
	   Now relocate the reference */
	if (part1_consth_active == false) {
	    fprintf(stderr,"Relocation problem : ");
	    fprintf(stderr,"IHIHALF missing in module %s\n",
		    abfd->filename); 
	    return(bfd_reloc_dangerous);
	}
	/* sym_ptr_ptr = r_symndx, in coff_slurp_reloc_table() */
	unsigned_value = 0;	/*EXTRACT_HWORD(insn) << 16;*/
	unsigned_value += reloc_entry->addend; /* r_symndx */
	unsigned_value += part1_consth_value;
	unsigned_value = unsigned_value >> 16;
	insn = INSERT_HWORD(insn, unsigned_value);
	part1_consth_active = false;
	break;
      case R_BYTE:
	unsigned_value = (insn >> 24) + sym_value + reloc_entry->addend;	
	if (unsigned_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) | (unsigned_value << 24);
	break;
      case R_HWORD:
	unsigned_value = (insn >> 16) + sym_value + reloc_entry->addend;	
	if (unsigned_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) | (unsigned_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)

#define RELOC_PROCESSING(relent, reloc, symbols, abfd, section) \
 reloc_processing(relent, reloc, symbols, abfd, section)

void DEFUN(reloc_processing,(relent,reloc, symbols, abfd, section) ,
	   arelent *relent AND
	   struct internal_reloc *reloc AND
	   asymbol **symbols AND
	   bfd *abfd AND
	   asection *section)
{
    relent->address = reloc->r_vaddr;		
    relent->howto = howto_table + reloc->r_type;
    if (reloc->r_type == R_IHCONST) 
    {		
	relent->addend = reloc->r_symndx;		
	relent->sym_ptr_ptr= 0;
    }
    else 
    {
      asymbol *ptr;
      relent->sym_ptr_ptr = symbols + obj_convert(abfd)[reloc->r_symndx];

      ptr = *(relent->sym_ptr_ptr);

      if (ptr 
	  && ptr->the_bfd == abfd		
	  && ptr->section != (asection *) NULL	
	  && ((ptr->flags & BSF_OLD_COMMON)== 0))	
      {						
	  relent->addend = -(ptr->section->vma + ptr->value);	
      }						
      else
      {					
	  relent->addend = 0;			
      }			
      relent->address-= section->vma;
      relent->section = 0;
  }
}

#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 */
    2,				/* minimum section alignment */
    /* data */
    _do_getb64, _do_putb64, _do_getb32,
    _do_putb32, _do_getb16, _do_putb16,
    /* hdrs */
    _do_getb64, _do_putb64, _do_getb32,
    _do_putb32, _do_getb16, _do_putb16,

  {
	    
      _bfd_dummy_target,
      coff_object_p,
      bfd_generic_archive_p,
      _bfd_dummy_target
   },
  {
      bfd_false,
      coff_mkobject,
      _bfd_generic_mkarchive,
      bfd_false
   },
  {
      bfd_false,
      coff_write_object_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"
2013f9b4 SC	28	#include "obstack.h"
c3eb25fc SC	29	#include "coff/a29k.h"
c3eb25fc SC	30	#include "coff/internal.h"
2013f9b4 SC	31	#include "libcoff.h"
	32
	33	#define INSERT_HWORD(WORD,HWORD) \
c2ce0738 SC	34	(((WORD) & 0xff00ff00) \| (((HWORD) & 0xff00) << 8) \| ((HWORD)& 0xff))
	35	#define EXTRACT_HWORD(WORD) \
	36	(((WORD) & 0x00ff0000) >> 8) \| ((WORD)& 0xff)
	37	#define SIGN_EXTEND_HWORD(HWORD) \
	38	((HWORD) & 0x8000 ? (HWORD)\|0xffff0000 : (HWORD))
2013f9b4 SC	39
	40	/* Provided the symbol, returns the value reffed */
	41	static long
	42	get_symbol_value(symbol)
	43	asymbol *symbol;
	44	{
	45	long relocation = 0;
	46
	47	if (symbol != (asymbol *)NULL) {
	48	if (symbol->flags & BSF_FORT_COMM) {
	49	relocation = 0;
	50	} else {
	51	relocation = symbol->value;
	52	}
	53	if (symbol->section != (asection *)NULL) {
	54	relocation += symbol->section->output_section->vma +
	55	symbol->section->output_offset;
	56	}
	57	}
	58	return(relocation);
	59	}
	60
c2ce0738 SC	61	/* this function is in charge of performing all the 29k relocations */
c2ce0738 SC	62
9e2dad8e	63	static bfd_reloc_status_type
c2ce0738 SC	64	DEFUN(a29k_reloc,(abfd, reloc_entry, symbol_in, data, input_section),
	65	bfd *abfd AND
	66	arelent *reloc_entry AND
	67	asymbol *symbol_in AND
	68	unsigned char *data AND
	69	asection *input_section)
2013f9b4	70	{
c2ce0738 SC	71	/* the consth relocation comes in two parts, we have to remember
	72	the state between calls, in these variables */
	73	static boolean part1_consth_active = false;
f58809fd	74	static unsigned long part1_consth_value;
c2ce0738 SC	75
	76	unsigned long insn;
	77	unsigned long sym_value;
	78	unsigned long unsigned_value;
f58809fd	79	unsigned short r_type;
c2ce0738 SC	80	long signed_value;
c2ce0738 SC	81
2013f9b4	82
f58809fd SC	83	r_type = reloc_entry->howto->type;
	84
	85	/* FIXME: Do we need to check for partial linking here */
c2ce0738 SC	86	if (symbol_in && (symbol_in->flags & BSF_UNDEFINED))
c2ce0738 SC	87	{
f58809fd	88	/* Keep the state machine happy in case we're called again */
c2ce0738 SC	89	if (r_type == R_IHIHALF)
	90	{
	91	part1_consth_active = true;
f58809fd	92	part1_consth_value = 0;
2013f9b4	93	}
f58809fd SC	94	return(bfd_reloc_undefined);
	95	}
	96
c2ce0738 SC	97	if ((part1_consth_active) && (r_type != R_IHCONST))
c2ce0738 SC	98	{
f58809fd SC	99	fprintf(stderr,"Relocation problem : ");
f58809fd SC	100	fprintf(stderr,"Missing IHCONST in module %s\n",abfd->filename);
c2ce0738	101	part1_consth_active = false;
f58809fd SC	102	return(bfd_reloc_dangerous);
	103	}
	104
	105	insn = bfd_get_32(abfd, data + reloc_entry->address);
	106	sym_value = get_symbol_value(symbol_in);
	107
c2ce0738 SC	108	switch (r_type)
	109	{
	110	case R_IREL:
	111	/* Take the value in the field and sign extend it */
	112	signed_value = EXTRACT_HWORD(insn) << 2;
	113	signed_value = SIGN_EXTEND_HWORD(signed_value);
	114	signed_value += sym_value + reloc_entry->addend;
	115	if ((signed_value&~0x3ffff) == 0)
	116	{ /* Absolute jmp/call */
	117	insn \|= (1<<24); /* Make it absolute */
f58809fd	118	/* FIXME: Should we change r_type to R_IABS */
c2ce0738 SC	119	signed_value /= 2;
	120	}
	121	else
	122	{
f58809fd SC	123	/* Relative jmp/call, so subtract from the value the
f58809fd SC	124	address of the place we're coming from */
c2ce0738	125	signed_value -= reloc_entry->address +
f58809fd SC	126	input_section->output_section->vma +
f58809fd SC	127	input_section->output_offset;
c2ce0738 SC	128	if (signed_value>0x1ffff \|\| signed_value<-0x20000)
	129	return(bfd_reloc_outofrange);
	130
	131	signed_value /= 2;
2013f9b4	132	}
c2ce0738	133	insn = INSERT_HWORD(insn, signed_value);
f58809fd	134	break;
c2ce0738 SC	135	case R_ILOHALF:
	136	unsigned_value = EXTRACT_HWORD(insn);
	137	unsigned_value += sym_value + reloc_entry->addend;
	138	insn = INSERT_HWORD(insn, unsigned_value);
f58809fd	139	break;
c2ce0738 SC	140	case R_IHIHALF:
	141	/* consth, part 1
	142	Just get the symbol value that is referenced */
	143	part1_consth_active = true;
f58809fd	144	part1_consth_value = sym_value + reloc_entry->addend;
c2ce0738 SC	145	/* Don't modify insn until R_IHCONST */
c2ce0738 SC	146	return(bfd_reloc_ok);
f58809fd	147	break;
c2ce0738 SC	148	case R_IHCONST:
	149	/* consth, part 2
	150	Now relocate the reference */
	151	if (part1_consth_active == false) {
f58809fd SC	152	fprintf(stderr,"Relocation problem : ");
	153	fprintf(stderr,"IHIHALF missing in module %s\n",
	154	abfd->filename);
f58809fd	155	return(bfd_reloc_dangerous);
2013f9b4	156	}
f58809fd	157	/* sym_ptr_ptr = r_symndx, in coff_slurp_reloc_table() */
c2ce0738 SC	158	unsigned_value = 0; /EXTRACT_HWORD(insn) << 16;/
	159	unsigned_value += reloc_entry->addend; /* r_symndx */
	160	unsigned_value += part1_consth_value;
	161	unsigned_value = unsigned_value >> 16;
	162	insn = INSERT_HWORD(insn, unsigned_value);
	163	part1_consth_active = false;
f58809fd	164	break;
c2ce0738 SC	165	case R_BYTE:
	166	unsigned_value = (insn >> 24) + sym_value + reloc_entry->addend;
	167	if (unsigned_value & 0xffffff00) {
f58809fd SC	168	fprintf(stderr,"Relocation problem : ");
	169	fprintf(stderr,"byte value too large in module %s\n",
	170	abfd->filename);
	171	return(bfd_reloc_overflow);
	172	}
c2ce0738	173	insn = (insn & 0x00ffffff) \| (unsigned_value << 24);
f58809fd	174	break;
c2ce0738 SC	175	case R_HWORD:
	176	unsigned_value = (insn >> 16) + sym_value + reloc_entry->addend;
	177	if (unsigned_value & 0xffff0000) {
f58809fd SC	178	fprintf(stderr,"Relocation problem : ");
	179	fprintf(stderr,"hword value too large in module %s\n",
	180	abfd->filename);
	181	return(bfd_reloc_overflow);
	182	}
c2ce0738	183	insn = (insn & 0x0000ffff) \| (unsigned_value<<16);
f58809fd	184	break;
c2ce0738	185	case R_WORD:
f58809fd SC	186	insn += sym_value + reloc_entry->addend;
f58809fd SC	187	break;
c2ce0738	188	default:
f58809fd SC	189	fprintf(stderr,"Relocation problem : ");
	190	fprintf(stderr,"Unrecognized reloc type %d, in module %s\n",
	191	r_type,abfd->filename);
	192	return (bfd_reloc_dangerous);
	193	}
	194
	195	bfd_put_32(abfd, insn, data+reloc_entry->address);
	196	return(bfd_reloc_ok);
2013f9b4 SC	197	}
	198
	199	/* type rightshift
	200	size
	201	bitsize
	202	pc-relative
	203	bitpos
	204	absolute
	205	complain_on_overflow
	206	special_function
	207	relocation name
	208	partial_inplace
	209	src_mask
	210	*/
	211
	212	/FIXME: I'm not real sure about this table /
	213	#define NA 0 /* Obsolete fields, via the documentation */
	214	static reloc_howto_type howto_table[] =
	215	{
	216	{R_ABS, 0, 3, NA, false, NA, NA, true,a29k_reloc,"ABS", true, 0xffffffff,0xffffffff, false},
	217	{1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10},
	218	{11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}, {19}, {20},
	219	{21}, {22}, {23},
	220	{R_IREL, 0, 3, NA, true, NA, NA, true,a29k_reloc,"IREL", true, 0xffffffff,0xffffffff, false},
	221	{R_IABS, 0, 3, NA, false, NA, NA, true,a29k_reloc,"IABS", true, 0xffffffff,0xffffffff, false},
	222	{R_ILOHALF, 0, 3, NA, true, NA, NA, true,a29k_reloc,"ILOHALF", true, 0x0000ffff,0x0000ffff, false},
	223	{R_IHIHALF, 0, 3, NA, true, NA, NA, true,a29k_reloc,"IHIHALF", true, 0xffff0000,0xffff0000, false},
	224	{R_IHCONST, 0, 3, NA, true, NA, NA, true,a29k_reloc,"IHCONST", true, 0xffff0000,0xffff0000, false},
	225	{R_BYTE, 0, 0, NA, false, NA, NA, true,a29k_reloc,"BYTE", true, 0x000000ff,0x000000ff, false},
	226	{R_HWORD, 0, 1, NA, false, NA, NA, true,a29k_reloc,"HWORD", true, 0x0000ffff,0x0000ffff, false},
	227	{R_WORD, 0, 2, NA, false, NA, NA, true,a29k_reloc,"WORD", true, 0xffffffff,0xffffffff, false},
	228	};
	229	#undef NA
	230
	231	#define BADMAG(x) A29KBADMAG(x)
	232
6cba8f4b SC	233	#define RELOC_PROCESSING(relent, reloc, symbols, abfd, section) \
	234	reloc_processing(relent, reloc, symbols, abfd, section)
	235
	236	void DEFUN(reloc_processing,(relent,reloc, symbols, abfd, section) ,
	237	arelent *relent AND
	238	struct internal_reloc *reloc AND
	239	asymbol **symbols AND
	240	bfd *abfd AND
	241	asection *section)
	242	{
	243	relent->address = reloc->r_vaddr;
	244	relent->howto = howto_table + reloc->r_type;
	245	if (reloc->r_type == R_IHCONST)
	246	{
	247	relent->addend = reloc->r_symndx;
	248	relent->sym_ptr_ptr= 0;
	249	}
	250	else
	251	{
	252	asymbol *ptr;
	253	relent->sym_ptr_ptr = symbols + obj_convert(abfd)[reloc->r_symndx];
	254
	255	ptr = *(relent->sym_ptr_ptr);
	256
	257	if (ptr
	258	&& ptr->the_bfd == abfd
	259	&& ptr->section != (asection *) NULL
	260	&& ((ptr->flags & BSF_OLD_COMMON)== 0))
	261	{
	262	relent->addend = -(ptr->section->vma + ptr->value);
	263	}
	264	else
	265	{
	266	relent->addend = 0;
	267	}
	268	relent->address-= section->vma;
	269	relent->section = 0;
	270	}
	271	}
3b4f1a5d	272
2013f9b4 SC	273	#include "coffcode.h"
	274
	275	bfd_target a29kcoff_big_vec =
	276	{
c2ce0738 SC	277	"coff-a29k-big", /* name */
	278	bfd_target_coff_flavour,
	279	true, /* data byte order is big */
	280	true, /* header byte order is big */
	281
	282	(HAS_RELOC \| EXEC_P \| /* object flags */
	283	HAS_LINENO \| HAS_DEBUG \|
	284	HAS_SYMS \| HAS_LOCALS \| DYNAMIC \| WP_TEXT),
	285
	286	(SEC_HAS_CONTENTS \| SEC_ALLOC /* section flags */
	287	\| SEC_LOAD \| SEC_RELOC
	288	\| SEC_READONLY ),
	289	'/', /* ar_pad_char */
	290	15, /* ar_max_namelen */
	291	2, /* minimum section alignment */
	292	/* data */
	293	_do_getb64, _do_putb64, _do_getb32,
	294	_do_putb32, _do_getb16, _do_putb16,
	295	/* hdrs */
	296	_do_getb64, _do_putb64, _do_getb32,
	297	_do_putb32, _do_getb16, _do_putb16,
	298
	299	{
	300
	301	_bfd_dummy_target,
	302	coff_object_p,
	303	bfd_generic_archive_p,
	304	_bfd_dummy_target
	305	},
	306	{
	307	bfd_false,
	308	coff_mkobject,
	309	_bfd_generic_mkarchive,
	310	bfd_false
	311	},
	312	{
	313	bfd_false,
	314	coff_write_object_contents,
	315	_bfd_write_archive_contents,
	316	bfd_false
	317	},
	318
	319	JUMP_TABLE(coff),
	320	COFF_SWAP_TABLE
	321	};
2013f9b4	322