Add IP2k support to BFD and LD

1 files changed, 1989 insertions, 0 deletions

diff --git a/bfd/elf32-ip2k.c b/bfd/elf32-ip2k.c
new file mode 100644
index 0000000..42287f3
--- /dev/null
+++ b/bfd/elf32-ip2k.c
@@ -0,0 +1,1989 @@
+/* Scenix IP2xxx specific support for 32-bit ELF
+   Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
+
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "libbfd.h"
+#include "elf-bfd.h"
+#include "elf/ip2k.h"
+
+/* Struct used to pass miscellaneous paramaters which
+   helps to avoid overly long parameter lists.  */
+struct misc
+{
+  Elf_Internal_Shdr *  symtab_hdr;
+  Elf_Internal_Rela *  irelbase;
+  bfd_byte *           contents;
+  bfd_byte *           free_contents;
+  Elf32_External_Sym * extsyms;
+  Elf32_External_Sym * free_extsyms;
+  Elf_Internal_Rela *  free_relocs;
+};
+
+/* Prototypes.  */
+static reloc_howto_type *    ip2k_reloc_type_lookup               PARAMS ((bfd *, bfd_reloc_code_real_type));
+static void                  ip2k_info_to_howto_rela              PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
+static asection *            ip2k_elf_gc_mark_hook                PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, struct elf_link_hash_entry *, Elf_Internal_Sym *));
+static boolean               ip2k_elf_gc_sweep_hook               PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
+static bfd_vma               symbol_value                         PARAMS ((bfd *, Elf_Internal_Shdr *, Elf32_External_Sym *, Elf_Internal_Rela *));
+static void                  adjust_all_relocations               PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, int, int));
+static boolean               ip2k_elf_relax_delete_bytes          PARAMS ((bfd *, asection *, bfd_vma, int));
+static boolean               ip2k_elf_relax_add_bytes             PARAMS ((bfd *, asection *, bfd_vma, const bfd_byte *, int, int));
+static boolean               add_page_insn                        PARAMS ((bfd *, asection *, Elf_Internal_Rela *, struct misc *));
+static boolean               ip2k_elf_relax_section               PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
+static boolean               relax_switch_dispatch_tables_pass1   PARAMS ((bfd *, asection *, bfd_vma, struct misc *));
+static boolean               unrelax_dispatch_table_entries       PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, boolean *, struct misc *));
+static boolean               unrelax_switch_dispatch_tables_passN PARAMS ((bfd *, asection *, bfd_vma, boolean *, struct misc *));
+static boolean               is_switch_128_dispatch_table_p       PARAMS ((bfd *, bfd_vma, boolean, struct misc *));
+static boolean               is_switch_256_dispatch_table_p       PARAMS ((bfd *, bfd_vma, boolean, struct misc *));
+static void                  tidyup_after_error                   PARAMS ((struct misc *));
+static boolean               ip2k_elf_relax_section_pass1         PARAMS ((bfd *, asection *, boolean *, struct misc *));
+static boolean               ip2k_elf_relax_section_passN         PARAMS ((bfd *, asection *, boolean *, boolean *, struct misc *));
+static bfd_reloc_status_type ip2k_final_link_relocate             PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma));
+static boolean               ip2k_elf_relocate_section            PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
+
+#define IS_OPCODE(CODE0,CODE1,OPCODE) \
+  ((CODE0) == (OPCODE)[0] && (CODE1) == (OPCODE)[1])
+
+#define PAGE_INSN_0		0x00
+#define PAGE_INSN_1		0x10
+
+static const bfd_byte page_opcode[] =
+{
+   PAGE_INSN_0, PAGE_INSN_1
+};
+
+#define IS_PAGE_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, page_opcode)
+
+#define JMP_INSN_0		0xE0
+#define JMP_INSN_1		0x00
+
+static const bfd_byte jmp_opcode[] =
+{
+   JMP_INSN_0, JMP_INSN_1
+};
+
+#define IS_JMP_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, jmp_opcode)
+
+#define CALL_INSN_0		0xC0
+#define CALL_INSN_1		0x00
+
+static const bfd_byte call_opcode[] =
+{
+  CALL_INSN_0, CALL_INSN_1
+};
+
+#define IS_CALL_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, call_opcode)
+
+#define ADD_PCL_W_INSN_0	0x1E
+#define ADD_PCL_W_INSN_1	0x09
+
+static const bfd_byte add_pcl_w_opcode[] =
+{
+  ADD_PCL_W_INSN_0, ADD_PCL_W_INSN_1
+};
+
+#define IS_ADD_PCL_W_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, add_pcl_w_opcode)
+
+#define ADD_W_WREG_INSN_0	0x1C
+#define ADD_W_WREG_INSN_1	0x0A
+
+static const bfd_byte add_w_wreg_opcode[] =
+{
+  ADD_W_WREG_INSN_0, ADD_W_WREG_INSN_1
+};
+
+#define IS_ADD_W_WREG_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, add_w_wreg_opcode)
+
+#define SNC_INSN_0		0xA0
+#define SNC_INSN_1		0x0B
+
+static const bfd_byte snc_opcode[] =
+{
+   SNC_INSN_0, SNC_INSN_1
+};
+
+#define IS_SNC_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, snc_opcode)
+
+#define INC_1_SP_INSN_0		0x2B
+#define INC_1_SP_INSN_1		0x81
+
+static const bfd_byte inc_1_sp_opcode[] =
+{
+   INC_1_SP_INSN_0, INC_1_SP_INSN_1
+};
+
+#define IS_INC_1_SP_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, inc_1_sp_opcode)
+
+#define ADD_2_SP_W_INSN_0	0x1F
+#define ADD_2_SP_W_INSN_1	0x82
+
+static const bfd_byte add_2_sp_w_opcode[] =
+{
+   ADD_2_SP_W_INSN_0, ADD_2_SP_W_INSN_1
+};
+
+#define IS_ADD_2_SP_W_OPCODE(CODE0,CODE1) \
+  IS_OPCODE (CODE0, CODE1, add_2_sp_w_opcode)
+
+/* Relocation tables. */
+static reloc_howto_type ip2k_elf_howto_table [] =
+{
+#define IP2K_HOWTO(t,rs,s,bs,pr,bp,name,sm,dm) \
+    HOWTO(t,                    /* type */ \
+          rs,                   /* rightshift */ \
+          s,                    /* size (0 = byte, 1 = short, 2 = long) */ \
+          bs,                   /* bitsize */ \
+          pr,                   /* pc_relative */ \
+          bp,                   /* bitpos */ \
+          complain_overflow_dont,/* complain_on_overflow */ \
+          bfd_elf_generic_reloc,/* special_function */ \
+          name,                 /* name */ \
+          false,                /* partial_inplace */ \
+          sm,                   /* src_mask */ \
+          dm,                   /* dst_mask */ \
+          pr)                   /* pcrel_offset */
+
+  /* This reloc does nothing. */
+  IP2K_HOWTO (R_IP2K_NONE, 0,2,32, false, 0, "R_IP2K_NONE", 0, 0), 
+  /* A 16 bit absolute relocation.  */
+  IP2K_HOWTO (R_IP2K_16, 0,1,16, false, 0, "R_IP2K_16", 0, 0xffff),
+  /* A 32 bit absolute relocation.  */
+  IP2K_HOWTO (R_IP2K_32, 0,2,32, false, 0, "R_IP2K_32", 0, 0xffffffff),
+  /* A 8-bit data relocation for the FR9 field.  Ninth bit is computed specially.  */
+  IP2K_HOWTO (R_IP2K_FR9, 0,1,9, false, 0, "R_IP2K_FR9", 0, 0x00ff),
+  /* A 4-bit data relocation.  */
+  IP2K_HOWTO (R_IP2K_BANK, 8,1,4, false, 0, "R_IP2K_BANK", 0, 0x000f),
+  /* A 13-bit insn relocation - word address => right-shift 1 bit extra.  */
+  IP2K_HOWTO (R_IP2K_ADDR16CJP, 1,1,13, false, 0, "R_IP2K_ADDR16CJP", 0, 0x1fff),
+  /* A 3-bit insn relocation - word address => right-shift 1 bit extra.  */
+  IP2K_HOWTO (R_IP2K_PAGE3, 14,1,3, false, 0, "R_IP2K_PAGE3", 0, 0x0007),
+  /* Two 8-bit data relocations.  */
+  IP2K_HOWTO (R_IP2K_LO8DATA, 0,1,8, false, 0, "R_IP2K_LO8DATA", 0, 0x00ff),
+  IP2K_HOWTO (R_IP2K_HI8DATA, 8,1,8, false, 0, "R_IP2K_HI8DATA", 0, 0x00ff),
+  /* Two 8-bit insn relocations.  word address => right-shift 1 bit extra.  */
+  IP2K_HOWTO (R_IP2K_LO8INSN, 1,1,8, false, 0, "R_IP2K_LO8INSN", 0, 0x00ff),
+  IP2K_HOWTO (R_IP2K_HI8INSN, 9,1,8, false, 0, "R_IP2K_HI8INSN", 0, 0x00ff),
+
+  /* Special 1 bit relocation for SKIP instructions.  */
+  IP2K_HOWTO (R_IP2K_PC_SKIP, 1,1,1, false, 12, "R_IP2K_PC_SKIP", 0xfffe, 0x1000),
+  /* 16 bit word address.  */
+  IP2K_HOWTO (R_IP2K_TEXT, 1,1,16, false, 0, "R_IP2K_TEXT", 0, 0xffff),
+  /* A 7-bit offset relocation for the FR9 field.  Eigth and ninth bit comes from insn.  */
+  IP2K_HOWTO (R_IP2K_FR_OFFSET, 0,1,9, false, 0, "R_IP2K_FR_OFFSET", 0x180, 0x007f),
+  /* Bits 23:16 of an address.  */
+  IP2K_HOWTO (R_IP2K_EX8DATA, 16,1,8, false, 0, "R_IP2K_EX8DATA", 0, 0x00ff),
+};
+
+
+/* Map BFD reloc types to IP2K ELF reloc types. */
+static reloc_howto_type *
+ip2k_reloc_type_lookup (abfd, code)
+     bfd * abfd ATTRIBUTE_UNUSED;
+     bfd_reloc_code_real_type code;
+{
+  /* Note that the ip2k_elf_howto_table is indxed by the R_
+     constants.  Thus, the order that the howto records appear in the
+     table *must* match the order of the relocation types defined in
+     include/elf/ip2k.h. */
+
+  switch (code)
+    {
+    case BFD_RELOC_NONE:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_NONE];
+    case BFD_RELOC_16:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_16];
+    case BFD_RELOC_32:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_32];
+    case BFD_RELOC_IP2K_FR9:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_FR9];
+    case BFD_RELOC_IP2K_BANK:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_BANK];
+    case BFD_RELOC_IP2K_ADDR16CJP:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_ADDR16CJP];
+    case BFD_RELOC_IP2K_PAGE3:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_PAGE3];
+    case BFD_RELOC_IP2K_LO8DATA:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_LO8DATA];
+    case BFD_RELOC_IP2K_HI8DATA:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_HI8DATA];
+    case BFD_RELOC_IP2K_LO8INSN:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_LO8INSN];
+    case BFD_RELOC_IP2K_HI8INSN:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_HI8INSN];
+    case BFD_RELOC_IP2K_PC_SKIP:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_PC_SKIP];
+    case BFD_RELOC_IP2K_TEXT:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
+    case BFD_RELOC_IP2K_FR_OFFSET:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_FR_OFFSET];
+    case BFD_RELOC_IP2K_EX8DATA:
+      return &ip2k_elf_howto_table[ (int) R_IP2K_EX8DATA];
+    default:
+      /* Pacify gcc -Wall. */
+      return NULL;
+    }
+  return NULL;
+}
+
+#define PAGENO(ABSADDR) ((ABSADDR) & 0x1C000)
+#define BASEADDR(SEC)	((SEC)->output_section->vma + (SEC)->output_offset)
+
+#define UNDEFINED_SYMBOL (~(bfd_vma)0)
+
+/* Return the value of the symbol associated with the relocation IREL.  */
+
+static bfd_vma
+symbol_value (abfd, symtab_hdr, extsyms, irel)
+     bfd *abfd;
+     Elf_Internal_Shdr *symtab_hdr;
+     Elf32_External_Sym *extsyms;
+     Elf_Internal_Rela *irel;   
+{
+  if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
+    {
+      Elf_External_Sym_Shndx *sym_shndx;
+      Elf_Internal_Shdr *shndx_hdr;
+      Elf_Internal_Sym isym;
+      asection *sym_sec;
+
+      shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+      sym_shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
+      sym_shndx = sym_shndx ? sym_shndx + ELF32_R_SYM (irel->r_info) : NULL;
+      bfd_elf32_swap_symbol_in (abfd, extsyms + ELF32_R_SYM (irel->r_info),
+				sym_shndx, &isym);
+      if (isym.st_shndx == SHN_UNDEF)
+	sym_sec = bfd_und_section_ptr;
+      else if (isym.st_shndx == SHN_ABS)
+	sym_sec = bfd_abs_section_ptr;
+      else if (isym.st_shndx == SHN_COMMON)
+	sym_sec = bfd_com_section_ptr;
+      else
+	sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
+
+      return isym.st_value + BASEADDR (sym_sec);
+    }
+  else
+    {
+      unsigned long indx;
+      struct elf_link_hash_entry *h;
+
+      indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
+      h = elf_sym_hashes (abfd)[indx];
+      BFD_ASSERT (h != NULL);
+
+      if (h->root.type != bfd_link_hash_defined
+	  && h->root.type != bfd_link_hash_defweak)
+	return UNDEFINED_SYMBOL;
+
+      return (h->root.u.def.value + BASEADDR (h->root.u.def.section));
+    }
+}
+
+/* Determine if the instruction sequence matches that for
+   the prologue of a switch dispatch table with fewer than
+   128 entries.
+ 
+          sc
+          page    $nnn0
+          jmp     $nnn0
+          add     w,wreg
+          add     pcl,w
+  addr=>
+          page    $nnn1
+          jmp     $nnn1
+ 	   page    $nnn2
+ 	   jmp     $nnn2
+ 	   ...
+ 	   page    $nnnN
+ 	   jmp     $nnnN
+ 
+  After relaxation.
+  	   sc
+ 	   page    $nnn0
+  	   jmp     $nnn0
+ 	   add     pcl,w
+  addr=>
+  	   jmp     $nnn1
+ 	   jmp     $nnn2
+ 	   ...
+          jmp     $nnnN  */
+
+static boolean 
+is_switch_128_dispatch_table_p (abfd, addr, relaxed, misc)
+     bfd *abfd ATTRIBUTE_UNUSED;                
+     bfd_vma addr;
+     boolean relaxed;
+     struct misc *misc;
+{
+  bfd_byte code0, code1;
+
+  if (addr < (3 * 2))
+    return false;
+
+  code0 = bfd_get_8 (abfd, misc->contents + addr - 2);
+  code1 = bfd_get_8 (abfd, misc->contents + addr - 1);
+
+  /* Is it ADD PCL,W */
+  if (! IS_ADD_PCL_W_OPCODE (code0, code1))
+    return false;
+
+  code0 = bfd_get_8 (abfd, misc->contents + addr - 4);
+  code1 = bfd_get_8 (abfd, misc->contents + addr - 3);
+
+  if (relaxed)
+    /* Is it ADD W,WREG  */
+    return ! IS_ADD_W_WREG_OPCODE (code0, code1);
+
+  else
+    {
+      /* Is it ADD W,WREG  */
+      if (! IS_ADD_W_WREG_OPCODE (code0, code1))
+	return false;
+
+      code0 = bfd_get_8 (abfd, misc->contents + addr - 6);
+      code1 = bfd_get_8 (abfd, misc->contents + addr - 5);
+
+      /* Is it JMP $nnnn  */
+      if (! IS_JMP_OPCODE (code0, code1))
+        return false;
+    }
+
+  /* It looks like we've found the prologue for
+     a 1-127 entry switch dispatch table.  */
+  return true;
+}
+
+/* Determine if the instruction sequence matches that for
+   the prologue switch dispatch table with fewer than
+   256 entries but more than 127.
+ 
+   Before relaxation.
+          push    %lo8insn(label) ; Push address of table
+          push    %hi8insn(label)
+          add     w,wreg          ; index*2 => offset
+          snc                     ; CARRY SET?
+          inc     1(sp)           ; Propagate MSB into table address
+          add     2(sp),w         ; Add low bits of offset to table address
+          snc                     ; and handle any carry-out
+          inc     1(sp)
+   addr=>
+          page    __indjmp        ; Do an indirect jump to that location
+          jmp     __indjmp
+   label:                         ; case dispatch table starts here
+ 	   page    $nnn1
+ 	   jmp	   $nnn1
+ 	   page	   $nnn2
+ 	   jmp     $nnn2
+ 	   ...
+ 	   page    $nnnN
+ 	   jmp	   $nnnN
+ 
+  After relaxation.
+          push    %lo8insn(label) ; Push address of table
+          push    %hi8insn(label)
+          add     2(sp),w         ; Add low bits of offset to table address
+          snc                     ; and handle any carry-out
+          inc     1(sp)
+  addr=>
+          page    __indjmp        ; Do an indirect jump to that location
+          jmp     __indjmp
+   label:                         ; case dispatch table starts here
+          jmp     $nnn1
+          jmp     $nnn2
+          ...
+          jmp     $nnnN  */
+
+static boolean 
+is_switch_256_dispatch_table_p (abfd, addr, relaxed,  misc)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     bfd_vma addr;
+     boolean relaxed;
+     struct misc *misc;
+{
+  bfd_byte code0, code1;
+
+  if (addr < (8 * 2))
+    return false;
+
+  code0 = bfd_get_8 (abfd, misc->contents + addr - 2);
+  code1 = bfd_get_8 (abfd, misc->contents + addr - 1);
+
+  /* Is it INC 1(SP).  */
+  if (! IS_INC_1_SP_OPCODE (code0, code1))
+    return false;
+
+  code0 = bfd_get_8 (abfd, misc->contents + addr - 4);
+  code1 = bfd_get_8 (abfd, misc->contents + addr - 3);
+
+  /* Is it SNC.  */
+  if (! IS_SNC_OPCODE (code0, code1))
+    return false;
+
+  code0 = bfd_get_8 (abfd, misc->contents + addr - 6);
+  code1 = bfd_get_8 (abfd, misc->contents + addr - 5);
+
+  /* Is it ADD 2(SP),W.  */
+  if (! IS_ADD_2_SP_W_OPCODE (code0, code1))
+    return false;
+
+  code0 = bfd_get_8 (abfd, misc->contents + addr - 8);
+  code1 = bfd_get_8 (abfd, misc->contents + addr - 7);
+
+  if (relaxed)
+    /* Is it INC 1(SP).  */
+    return ! IS_INC_1_SP_OPCODE (code0, code1);
+
+  else
+    {
+      /* Is it INC 1(SP).  */
+      if (! IS_INC_1_SP_OPCODE (code0, code1))
+	return false;
+
+      code0 = bfd_get_8 (abfd, misc->contents + addr - 10);
+      code1 = bfd_get_8 (abfd, misc->contents + addr - 9);
+ 
+      /* Is it SNC.  */
+      if (! IS_SNC_OPCODE (code0, code1))
+        return false;
+
+      code0 = bfd_get_8 (abfd, misc->contents + addr - 12);
+      code1 = bfd_get_8 (abfd, misc->contents + addr - 11);
+
+      /* Is it ADD W,WREG.  */
+      if (! IS_ADD_W_WREG_OPCODE (code0, code1))
+	return false;
+    }
+
+  /* It looks like we've found the prologue for
+     a 128-255 entry switch dispatch table.  */
+  return true;
+}
+
+static boolean
+relax_switch_dispatch_tables_pass1 (abfd, sec, addr, misc)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma addr;
+     struct misc *misc;
+{
+  if (addr + 3 < sec->_cooked_size)
+    {
+      bfd_byte code0 = bfd_get_8 (abfd, misc->contents + addr + 2);
+      bfd_byte code1 = bfd_get_8 (abfd, misc->contents + addr + 3);
+
+      if (IS_JMP_OPCODE (code0, code1)
+	  && is_switch_128_dispatch_table_p (abfd, addr, false, misc))
+	{
+	  /* Delete ADD W,WREG from prologue.  */
+	  ip2k_elf_relax_delete_bytes (abfd, sec, addr - (2 * 2), (1 * 2));
+	  return true;
+	}
+
+      if (IS_JMP_OPCODE (code0, code1)
+	  && is_switch_256_dispatch_table_p (abfd, addr, false, misc))
+	{
+	  /* Delete ADD W,WREG; SNC ; INC 1(SP) from prologue.  */
+	  ip2k_elf_relax_delete_bytes (abfd, sec, addr - 6 * 2, 3 * 2);
+	  return true;
+	}
+    }
+ 
+  return true;
+}
+
+static boolean
+unrelax_dispatch_table_entries (abfd, sec, first, last, changed, misc)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma first;
+     bfd_vma last;
+     boolean *changed;
+     struct misc *misc;
+{
+  bfd_vma addr = first;
+
+  while (addr < last)
+    {
+      bfd_byte code0 = bfd_get_8 (abfd, misc->contents + addr);
+      bfd_byte code1 = bfd_get_8 (abfd, misc->contents + addr + 1);
+
+      /* We are only expecting to find PAGE or JMP insns
+         in the dispatch table. If we find anything else
+         something has gone wrong failed the relaxation
+         which will cause the link to be aborted.  */
+
+      if (IS_PAGE_OPCODE (code0, code1))
+	/* Skip the PAGE and JMP insns.  */
+        addr += 4;
+      else if (IS_JMP_OPCODE (code0, code1))
+         {
+            Elf_Internal_Rela * irelend = misc->irelbase
+					  + sec->reloc_count;
+            Elf_Internal_Rela * irel;
+
+            /* Find the relocation entry.  */
+            for (irel = misc->irelbase; irel < irelend; irel++)
+               {
+                  if (irel->r_offset == addr
+                      && ELF32_R_TYPE (irel->r_info) == R_IP2K_ADDR16CJP)
+                    {
+                      if (! add_page_insn (abfd, sec, irel, misc))
+			/* Something has gone wrong.  */
+                        return false;
+
+		      *changed = true;
+		      break;
+                    }
+               }
+
+	    /* If we fell off the end something has gone wrong.  */
+	    if (irel >= irelend)
+	      /* Something has gone wrong.  */
+	      return false;
+
+	    /* Skip the PAGE and JMP isns.  */
+	    addr += 4;
+	    /* Acount for the new PAGE insn.  */
+            last += 2;
+          }
+       else
+	 /* Something has gone wrong.  */
+	 return false;
+    }
+
+  return true;
+}
+
+static boolean 
+unrelax_switch_dispatch_tables_passN (abfd, sec, addr, changed, misc)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma addr;
+     boolean *changed;
+     struct misc *misc;
+{
+  if (2 <= addr && (addr + 3) < sec->_cooked_size)
+    {
+      bfd_byte code0 = bfd_get_8 (abfd, misc->contents + addr - 2);
+      bfd_byte code1 = bfd_get_8 (abfd, misc->contents + addr - 1);
+
+      if (IS_PAGE_OPCODE (code0, code1))
+	{
+	  addr -= 2;
+	  code0 = bfd_get_8 (abfd, misc->contents + addr + 2);
+          code1 = bfd_get_8 (abfd, misc->contents + addr + 3);
+	}
+      else
+	{
+	  code0 = bfd_get_8 (abfd, misc->contents + addr);
+	  code1 = bfd_get_8 (abfd, misc->contents + addr + 1);
+	}
+
+      if (IS_JMP_OPCODE (code0, code1)
+          && is_switch_128_dispatch_table_p (abfd, addr, true, misc))
+        {
+	  bfd_vma first = addr;
+	  bfd_vma last  = first;
+	  boolean relaxed = true;
+
+	  /* On the final pass we must check if *all* entries in the
+	     dispatch table are relaxed. If *any* are not relaxed
+	     then we must unrelax *all* the entries in the dispach
+	     table and also unrelax the dispatch table prologue.  */
+
+	  /* Find the last entry in the dispach table.  */
+	  while (last < sec->_cooked_size)
+	     {
+	        code0 = bfd_get_8 (abfd, misc->contents + last);
+	        code1 = bfd_get_8 (abfd, misc->contents + last + 1);
+
+		if (IS_PAGE_OPCODE (code0, code1))
+		  relaxed = false;
+		else if (! IS_JMP_OPCODE (code0, code1))
+		    break;
+
+	        last += 2;
+	     }
+
+	  /* We should have found the end of the dispatch table
+	     before reaching the end of the section. If we've have
+	     reached the end then fail the relaxation which will
+	     cause the link to be aborted.  */
+	  if (last >= sec->_cooked_size)
+	    /* Something has gone wrong.  */
+	    return false;
+
+	  /* If we found an unrelaxed entry then
+	     unlrelax all the switch table entries.  */
+	  if (! relaxed )
+	    {
+	      if (! unrelax_dispatch_table_entries (abfd, sec, first,
+						    last, changed, misc))
+		/* Something has gone wrong.  */
+	        return false;
+
+	      if (! is_switch_128_dispatch_table_p (abfd, addr, true, misc))
+		/* Something has gone wrong.  */
+		return false;
+		
+              /* Unrelax the prologue.  */
+
+              /* Insert an ADD W,WREG insnstruction.  */
+              if (! ip2k_elf_relax_add_bytes (abfd, sec,
+					      addr - 2,
+					      add_w_wreg_opcode,
+					      sizeof (add_w_wreg_opcode),
+					      0))
+		/* Something has gone wrong.  */
+                return false;
+	    }
+
+          return true;
+        }
+
+      if (IS_JMP_OPCODE (code0, code1)
+          && is_switch_256_dispatch_table_p (abfd, addr, true, misc))
+        {
+          bfd_vma first = addr;
+          bfd_vma last;
+          boolean relaxed = true;
+
+          /* On the final pass we must check if *all* entries in the
+             dispatch table are relaxed. If *any* are not relaxed
+             then we must unrelax *all* the entries in the dispach
+             table and also unrelax the dispatch table prologue.  */
+
+	  /* Note the 1st PAGE/JMP instructions are part of the
+	     prologue and can safely be relaxed.  */
+
+          code0 = bfd_get_8 (abfd, misc->contents + first);
+          code1 = bfd_get_8 (abfd, misc->contents + first + 1);
+
+	  if (IS_PAGE_OPCODE (code0, code1))
+	    {
+	      first += 2;
+              code0 = bfd_get_8 (abfd, misc->contents + first);
+              code1 = bfd_get_8 (abfd, misc->contents + first + 1);
+	    }
+
+          if (! IS_JMP_OPCODE (code0, code1))
+	    /* Something has gone wrong.  */
+	    return false;
+
+          first += 2;
+	  last = first; 
+
+          /* Find the last entry in the dispach table.  */
+          while (last < sec->_cooked_size)
+             {
+                code0 = bfd_get_8 (abfd, misc->contents + last);
+                code1 = bfd_get_8 (abfd, misc->contents + last + 1);
+
+                if (IS_PAGE_OPCODE (code0, code1))
+                  relaxed = false;
+                else if (! IS_JMP_OPCODE (code0, code1))
+                    break;
+
+                last += 2;
+             }
+
+          /* We should have found the end of the dispatch table
+             before reaching the end of the section. If we have
+             reached the end of the section then fail the
+	     relaxation.  */
+          if (last >= sec->_cooked_size)
+            return false;
+
+          /* If we found an unrelaxed entry then
+              unrelax all the switch table entries.  */
+          if (! relaxed)
+	    {
+	      if (! unrelax_dispatch_table_entries (abfd, sec, first,
+						    last, changed, misc))
+		return false;
+
+              if (! is_switch_256_dispatch_table_p (abfd, addr, true, misc))
+		return false;
+
+              /* Unrelax the prologue.  */
+
+              /* Insert an INC 1(SP) insnstruction.  */
+              if (! ip2k_elf_relax_add_bytes (abfd, sec,
+                                              addr - 6,
+                                              inc_1_sp_opcode,
+                                              sizeof (inc_1_sp_opcode),
+					      0))
+		return false;
+
+              /* Insert an SNC insnstruction.  */
+              if (! ip2k_elf_relax_add_bytes (abfd, sec,
+					      addr - 6,
+					      snc_opcode,
+					      sizeof (snc_opcode),
+					      0))
+		return false;
+
+	      /* Insert an ADD W,WREG insnstruction.  */
+              if (! ip2k_elf_relax_add_bytes (abfd, sec,
+					     addr - 6,
+				 	     add_w_wreg_opcode,
+					     sizeof (add_w_wreg_opcode),
+					     0))
+		return false;
+	    }
+
+          return true;
+        }
+    }
+
+  return true;
+}
+
+/* This function handles relaxing for the ip2k.  */
+
+static boolean
+ip2k_elf_relax_section (abfd, sec, link_info, again)
+     bfd *abfd;
+     asection *sec;
+     struct bfd_link_info *link_info;
+     boolean *again;
+{
+  Elf_External_Sym_Shndx *shndx_buf;
+  Elf_Internal_Shdr *shndx_hdr;
+  static asection * first_section = NULL;
+  static asection * last_section = NULL;
+  static boolean changed = false;
+  static boolean final_pass = false;
+  static unsigned int pass = 0;
+  struct misc misc;
+  asection *stab;
+
+  /* Assume nothing changes.  */
+  *again = false;
+
+  if (first_section == NULL)
+    first_section = sec;
+
+  if (first_section == sec)
+    {
+      changed = false;
+      pass++;
+    }
+
+  /* If we make too many passes then it's a sign that
+     something is wrong and we fail the relaxation.
+     Note if everything is working correctly then the
+     relaxation should converge reasonably quickly.  */
+  if (pass == 4096)
+    return false;
+
+  /* We don't have to do anything for a relocatable link,
+     if this section does not have relocs, or if this is
+     not a code section.  */
+  if (link_info->relocateable
+      || (sec->flags & SEC_RELOC) == 0
+      || sec->reloc_count == 0
+      || (sec->flags & SEC_CODE) == 0)
+    return true;
+
+  if (pass == 1)
+    last_section = sec;
+
+  misc.symtab_hdr = NULL;
+  misc.irelbase = NULL;
+  misc.contents = NULL;
+  misc.free_contents = NULL;
+  misc.extsyms = NULL;
+  misc.free_extsyms = NULL;
+  misc.free_relocs = NULL;
+
+  /* If this is the first time we have been called
+      for this section, initialise the cooked size.  */
+  if (sec->_cooked_size == 0)
+    sec->_cooked_size = sec->_raw_size;
+
+  misc.symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+
+  misc.irelbase = _bfd_elf32_link_read_relocs (abfd, sec, NULL,
+					     (Elf_Internal_Rela *)NULL,
+					     link_info->keep_memory);
+  if (misc.irelbase == NULL)
+    {
+      tidyup_after_error (&misc);
+      return false;
+    }
+
+  if (! link_info->keep_memory)
+    misc.free_relocs = misc.irelbase;
+
+  /* Make sure the stac.rela stuff gets read in.  */
+  stab = bfd_get_section_by_name (abfd, ".stab");
+
+  if (stab)
+    {
+      /* So stab does exits.  */
+      Elf_Internal_Rela * irelbase;
+
+      irelbase = _bfd_elf32_link_read_relocs (abfd, stab, NULL,
+					      (Elf_Internal_Rela *)NULL,
+					      link_info->keep_memory);
+    }
+
+  /* Get section contents cached copy if it exists.  */
+  if (elf_section_data (sec)->this_hdr.contents != NULL)
+    misc.contents = elf_section_data (sec)->this_hdr.contents;
+  else
+    {
+      /* Go get them of disk.  */
+      misc.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
+      if (misc.contents == NULL)
+	{
+	  tidyup_after_error (&misc);
+	  return false;
+	}
+
+      misc.free_contents = misc.contents;
+      if (! bfd_get_section_contents (abfd, sec, misc.contents,
+				      (file_ptr)0,
+				      sec->_raw_size))
+	{
+	  tidyup_after_error (&misc);
+	  return false;
+	}
+    }
+  
+  /* Read this BFD's symbols cached copy if it exists.  */
+  if (misc.symtab_hdr->contents != NULL)
+    misc.extsyms = (Elf32_External_Sym *) misc.symtab_hdr->contents;
+  else
+    {
+      /* Go get them off disk.  */
+      misc.extsyms = ((Elf32_External_Sym *)bfd_malloc (misc.symtab_hdr->sh_size));
+      if (misc.extsyms == NULL)
+	{
+	  tidyup_after_error (&misc);
+	  return false;
+	}
+
+      misc.free_extsyms = misc.extsyms;
+      if (bfd_seek (abfd, misc.symtab_hdr->sh_offset, SEEK_SET) != 0
+          || (bfd_read (misc.extsyms, 1, misc.symtab_hdr->sh_size, abfd)
+          != misc.symtab_hdr->sh_size))
+	{
+	  tidyup_after_error (&misc);
+	  return false;
+	}
+    }
+
+  if (shndx_hdr->sh_size != 0)
+    {
+      bfd_size_type amt;
+
+      amt = misc.symtab_hdr->sh_info * sizeof (Elf_External_Sym_Shndx);
+      shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
+      if (shndx_buf == NULL)
+	{
+	  tidyup_after_error (&misc);
+	  return false;
+	}
+      if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
+	  || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
+	{
+	  tidyup_after_error (&misc);
+	  return false;
+	}
+      shndx_hdr->contents = (PTR) shndx_buf;
+    }
+
+  /* This is where all the relaxation actually get done.  */
+
+  if (pass == 1)
+    {
+      /* On the first pass we remove *all* page instructions and
+         relax the prolog for switch dispatch tables. This gets
+	 us to the starting point for subsequent passes where
+	 we add page instructions back in as needed.  */
+
+      if (! ip2k_elf_relax_section_pass1 (abfd, sec, again, &misc))
+        {
+	  tidyup_after_error (&misc);
+	  return false;
+        }
+
+      changed |= *again;
+    }
+  else
+    {
+      /* Add page instructions back in as needed but we ignore 
+	 the issue with sections (functions) crossing a page
+	 boundary until we have converged to an approximate
+	 solution (i.e. nothing has changed on this relaxation
+	 pass) and we then know roughly where the page boundaries
+	 will end up.
+
+	 After we have have converged to an approximate solution
+	 we set the final pass flag and continue relaxing. On these
+	 final passes if a section (function) cross page boundary
+	 we will add *all* the page instructions back into such
+	 sections.
+
+	 After adding *all* page instructions back into a section
+	 which crosses a page bounbdary we reset the final pass flag
+	 so the we will again interate until we find a new approximate
+	 solution which is closer to the final solution.  */
+
+      if (! ip2k_elf_relax_section_passN (abfd, sec, again,
+					 &final_pass,  &misc))
+	{
+	  tidyup_after_error (&misc);
+	  return false;
+	}
+
+      changed |= *again;
+
+      /* If nothing has changed on this relaxation
+	  pass restart the final relaxaton pass.  */
+      if (! changed && last_section == sec)
+	{
+	  /* If this was the final pass and we didn't reset 
+	     the final pass flag then we are done, otherwise
+	     do another final pass.  */
+	  if (! final_pass)
+	    {
+	      final_pass = true;
+	      *again = true;
+	    }
+	}
+    }
+
+  /* Perform some house keeping after relaxing the section.  */  
+
+  if (misc.free_relocs != NULL)
+    {
+      free (misc.free_relocs);
+      misc.free_relocs = NULL;
+    }
+
+  if (misc.free_contents != NULL)
+    {
+      if (! link_info->keep_memory)
+	free (misc.free_contents);
+      else
+	{
+	  /* Cache the section contents for elf_link_input_bfd.  */
+	  elf_section_data (sec)->this_hdr.contents = misc.contents;
+	}
+
+      misc.free_contents = NULL;
+    }
+
+  if (misc.free_extsyms != NULL)
+    {
+      if (! link_info->keep_memory)
+	free (misc.free_extsyms);
+      else
+	{
+	  /* Cache the symbols for elf_link_input_bfd.  */
+	  misc.symtab_hdr->contents = misc.extsyms;
+	}
+
+      misc.free_extsyms = NULL;
+    }
+
+  return true;
+}
+
+static void
+tidyup_after_error (misc)
+     struct misc *misc;
+{
+  if (misc->free_relocs != NULL)
+    {
+      free (misc->free_relocs);
+      misc->free_relocs = NULL;
+    }
+
+  if (misc->free_contents != NULL)
+    {
+      free (misc->free_contents);
+      misc->free_contents = NULL;
+    }
+
+  if (misc->free_extsyms != NULL)
+    {
+      free (misc->free_extsyms);
+      misc->free_extsyms = NULL;
+    }
+
+  return;
+}
+
+/* This function handles relaxation during the first pass.  */
+
+static boolean
+ip2k_elf_relax_section_pass1 (abfd, sec, again, misc)
+     bfd *abfd;
+     asection *sec;
+     boolean *again;
+     struct misc * misc;
+{
+  Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
+  Elf_Internal_Rela *irel;
+
+  /* Walk thru the section looking for relaxation opertunities.  */
+  for (irel = misc->irelbase; irel < irelend; irel++)
+    {
+      if (ELF32_R_TYPE (irel->r_info) == (int) R_IP2K_PAGE3)
+      {
+	bfd_byte code0 = bfd_get_8 (abfd,
+				    misc->contents + irel->r_offset);
+	bfd_byte code1 = bfd_get_8 (abfd,
+				    misc->contents + irel->r_offset + 1);
+
+        /* Verify that this is the PAGE opcode.  */
+        if (IS_PAGE_OPCODE (code0, code1))
+	  {
+	    /* Note that we've changed the relocs, section contents, etc.  */
+	    elf_section_data (sec)->relocs = misc->irelbase;
+	    misc->free_relocs = NULL;
+
+	    elf_section_data (sec)->this_hdr.contents = misc->contents;
+	    misc->free_contents = NULL;
+
+	    misc->symtab_hdr->contents = (bfd_byte *) misc->extsyms;
+	    misc->free_extsyms = NULL;
+
+	    /* Handle switch dispatch tables/prologues.  */
+	    if (!  relax_switch_dispatch_tables_pass1 (abfd, sec,
+						       irel->r_offset, misc))
+	      return false;
+	    
+	    /* Fix the relocation's type.  */
+	    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+				         R_IP2K_NONE);
+
+	    /* Delete the PAGE insn.  */
+	    if (! ip2k_elf_relax_delete_bytes (abfd, sec,
+					       irel->r_offset,
+					       sizeof (page_opcode)))
+	      return false;
+
+	    /* That will change things, so, we should relax again.
+	       Note that this is not required, and it may be slow.  */
+	    *again = true;
+	  }
+      }
+    }
+
+  return true;
+}
+
+/* This function handles relaxation for 2nd and subsequent passes.  */
+
+static boolean
+ip2k_elf_relax_section_passN (abfd, sec, again, final_pass, misc)
+     bfd *abfd;
+     asection *sec;
+     boolean *again;
+     boolean *final_pass;
+     struct misc * misc;
+{
+  Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
+  Elf_Internal_Rela *irel;
+  boolean add_all;
+
+  /* If we are on the final relaxation pass and the section crosses
+     then set a flag to indicate that *all* page instructions need
+     to be added back into this section.  */
+  if (*final_pass)
+    {
+      add_all = (PAGENO (BASEADDR (sec))
+	         != PAGENO (BASEADDR (sec) + sec->_cooked_size));
+
+      /* If this section crosses a page boundary set the crossed
+	 page boundary flag.  */
+      if (add_all)
+	sec->userdata = sec;
+      else
+	{
+	  /* If the section had previously crossed a page boundary
+	     but on this pass does not then reset crossed page
+	     boundary flag and rerun the 1st relaxation pass on
+	     this section.  */
+	  if (sec->userdata)
+	    {
+	      sec->userdata = NULL;
+	      if (! ip2k_elf_relax_section_pass1 (abfd, sec, again, misc))
+		return false;
+	    }
+	}
+    }
+  else
+    add_all = false;
+
+  /* Walk thru the section looking for call/jmp
+      instructions which need a page instruction.  */
+  for (irel = misc->irelbase; irel < irelend; irel++)
+    {
+      if (ELF32_R_TYPE (irel->r_info) == (int) R_IP2K_ADDR16CJP)
+      {
+        /* Get the value of the symbol referred to by the reloc.  */
+        bfd_vma symval = symbol_value (abfd, misc->symtab_hdr, misc->extsyms,
+				       irel);
+	bfd_byte code0, code1;
+
+        if (symval == UNDEFINED_SYMBOL)
+	  {
+	    /* This appears to be a reference to an undefined
+	       symbol.  Just ignore it--it will be caught by the
+	       regular reloc processing.  */
+	    continue;
+	  }
+
+        /* For simplicity of coding, we are going to modify the section
+	   contents, the section relocs, and the BFD symbol table.  We
+	   must tell the rest of the code not to free up this
+	   information.  It would be possible to instead create a table
+	   of changes which have to be made, as is done in coff-mips.c;
+	   that would be more work, but would require less memory when
+	   the linker is run.  */
+
+	/* Get the opcode.  */
+	code0 = bfd_get_8 (abfd, misc->contents + irel->r_offset);
+	code1 = bfd_get_8 (abfd, misc->contents + irel->r_offset + 1);
+
+	if (IS_JMP_OPCODE (code0, code1) || IS_CALL_OPCODE (code0, code1))
+	  {
+	    if (*final_pass)
+	      {
+		if (! unrelax_switch_dispatch_tables_passN (abfd, sec,
+						            irel->r_offset,
+                                                            again, misc))
+		  return false;
+
+                if (*again)
+		  add_all = false;
+	      }
+
+	    code0 = bfd_get_8 (abfd, misc->contents + irel->r_offset - 2);
+	    code1 = bfd_get_8 (abfd, misc->contents + irel->r_offset - 1);
+
+	    if (! IS_PAGE_OPCODE (code0, code1))
+	      {
+		bfd_vma value = symval + irel->r_addend;
+		bfd_vma addr  = BASEADDR (sec) + irel->r_offset;
+
+		if (add_all || PAGENO (addr) != PAGENO (value))
+		  {
+		    if (! add_page_insn (abfd, sec, irel, misc))
+		      return false;
+
+		    /* That will have changed things, so,  we must relax again.  */
+		    *again = true;
+		  }
+	       }
+	   }
+        }
+    }
+      
+  /* If anything changed reset the final pass flag.  */
+  if (*again)
+    *final_pass = false;
+
+  return true;
+}
+
+/* Parts of a Stabs entry.  */
+
+#define STRDXOFF  (0)
+#define TYPEOFF   (4)
+#define OTHEROFF  (5)
+#define DESCOFF   (6)
+#define VALOFF    (8)
+#define STABSIZE  (12)
+
+/* Adjust all the relocations entries after adding or inserting instructions.  */
+
+static void
+adjust_all_relocations (abfd, sec, addr, endaddr, count, noadj)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma addr;
+     bfd_vma endaddr;
+     int count;
+     int noadj;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  Elf32_External_Sym *extsyms;
+  int shndx, index;
+  bfd_byte *contents;
+  Elf_Internal_Rela *irel, *irelend, *irelbase;
+  Elf32_External_Sym *esym, *esymend;
+  asection *stab;
+  bfd_byte *stabp, *stabend, *stabcontents;
+  Elf_Internal_Shdr *shndx_hdr;
+  Elf_External_Sym_Shndx *sym_shndx;
+    
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
+
+  shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
+
+  contents = elf_section_data (sec)->this_hdr.contents;
+
+  irelbase = elf_section_data (sec)->relocs;
+  irelend = irelbase + sec->reloc_count;
+
+  for (irel = irelbase; irel < irelend; irel++)
+    {
+      if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
+        {
+          /* Get the value of the symbol referred to by the reloc.  */
+          if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
+            {
+              Elf_Internal_Sym isym;
+              asection *sym_sec;
+	      Elf_External_Sym_Shndx *sym_shndx;
+	      Elf_Internal_Shdr *shndx_hdr;
+
+              /* A local symbol.  */
+	      
+	      shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+	      sym_shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
+	      sym_shndx = (sym_shndx
+			   ? sym_shndx + ELF32_R_SYM (irel->r_info) : NULL);
+              bfd_elf32_swap_symbol_in (abfd,
+					extsyms + ELF32_R_SYM (irel->r_info),
+					sym_shndx, &isym);
+
+	      if (isym.st_shndx == SHN_UNDEF)
+		sym_sec = bfd_und_section_ptr;
+	      else if (isym.st_shndx == SHN_ABS)
+		sym_sec = bfd_abs_section_ptr;
+	      else if (isym.st_shndx == SHN_COMMON)
+		sym_sec = bfd_com_section_ptr;
+	      else
+		sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
+
+              if (sym_sec == sec)
+                {
+                  bfd_vma baseaddr = BASEADDR (sec);
+                  bfd_vma symval = BASEADDR (sym_sec) + isym.st_value
+                                   + irel->r_addend;
+
+                  if ((baseaddr + addr + noadj) <= symval
+                      && symval < (baseaddr + endaddr))
+                    irel->r_addend += count;
+                }
+            }
+        }
+
+      /* Do this only for PC space relocations.  */
+      if (addr <= irel->r_offset && irel->r_offset < endaddr)
+        irel->r_offset += count;
+    }
+
+  /* Now fix the stab relocations.  */
+  stab = bfd_get_section_by_name (abfd, ".stab");
+  if (stab)
+    {
+      irelbase = elf_section_data (stab)->relocs;
+      irelend = irelbase + stab->reloc_count;
+
+      /* Pull out the contents of the stab section.  */
+      if (elf_section_data (stab)->this_hdr.contents != NULL)
+	stabcontents = elf_section_data (stab)->this_hdr.contents;
+      else
+	{
+	  stabcontents = (bfd_byte *) bfd_alloc (abfd, stab->_raw_size);
+	  if (stabcontents == NULL)
+	    return;
+	  if (! bfd_get_section_contents (abfd, stab, stabcontents,
+					  (file_ptr) 0, stab->_raw_size))
+	    return;
+
+	  /* We need to remember this.  */
+	  elf_section_data (stab)->this_hdr.contents = stabcontents;
+	}
+
+      stabend = stabcontents + stab->_raw_size;
+
+      for (irel = irelbase; irel < irelend; irel++)
+	{
+	  if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
+	    {
+	      /* Get the value of the symbol referred to by the reloc.  */
+	      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
+		{
+		  Elf_Internal_Sym isym;
+		  asection *sym_sec;
+		  Elf_External_Sym_Shndx *sym_shndx;
+		  Elf_Internal_Shdr *shndx_hdr;
+		  
+		  /* A local symbol.  */
+		  shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+		  sym_shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
+		  sym_shndx = (sym_shndx
+			       ? sym_shndx + ELF32_R_SYM (irel->r_info)
+			       : NULL);
+		  
+		  bfd_elf32_swap_symbol_in (abfd,
+					    (extsyms
+					     + ELF32_R_SYM (irel->r_info)),
+					    sym_shndx, &isym);
+		  
+		  if (isym.st_shndx == SHN_UNDEF)
+		    sym_sec = bfd_und_section_ptr;
+		  else if (isym.st_shndx == SHN_ABS)
+		    sym_sec = bfd_abs_section_ptr;
+		  else if (isym.st_shndx == SHN_COMMON)
+		    sym_sec = bfd_com_section_ptr;
+		  else
+		    sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
+		  
+		  if (sym_sec == sec)
+		    {
+		      const char *name;
+		      unsigned long strx;
+		      unsigned char type, other;
+		      unsigned short desc;
+		      bfd_vma value;
+		      bfd_vma baseaddr = BASEADDR (sec);
+		      bfd_vma symval = BASEADDR (sym_sec) + isym.st_value
+			+ irel->r_addend;
+		      
+		      if ((baseaddr + addr) <= symval
+			  && symval <= (baseaddr + endaddr))
+			irel->r_addend += count;
+
+		      /* Go hunt up a function and fix its line info if needed.  */
+		      stabp = stabcontents + irel->r_offset - 8; 
+
+		      /* Go pullout the stab entry.  */
+		      strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
+		      type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
+		      other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
+		      desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
+		      value = bfd_h_get_32 (abfd, stabp + VALOFF);
+		      
+		      name = bfd_get_stab_name (type);
+		      
+		      if (strcmp (name, "FUN") == 0)
+			{
+			  int function_adjusted = 0;
+
+			  if (symval > (baseaddr + addr))
+			    /* Not in this function.  */
+			    continue;
+
+			  /* Hey we got a function hit.  */
+			  stabp += STABSIZE;
+			  for (;stabp < stabend; stabp += STABSIZE)
+			    {
+			      /* Go pullout the stab entry.  */
+			      strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
+			      type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
+			      other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
+			      desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
+			      value = bfd_h_get_32 (abfd, stabp + VALOFF);
+			      name = bfd_get_stab_name (type);
+
+			      if (strcmp (name, "FUN") == 0)
+				{
+				  /* Hit another function entry.  */
+				  if (function_adjusted)
+				    {
+				      /* Adjust the value.  */
+				      value += count;
+				  
+				      /* We need to put it back.  */
+				      bfd_h_put_32 (abfd, value,stabp + VALOFF);
+				    }
+
+				  /* And then bale out.  */
+				  break;
+				}
+
+			      if (strcmp (name, "SLINE") == 0)
+				{
+				  /* Got a line entry.  */
+				  if ((baseaddr + addr) <= (symval + value))
+				    {
+				      /* Adjust the line entry.  */
+				      value += count;
+
+				      /* We need to put it back.  */
+				      bfd_h_put_32 (abfd, value,stabp + VALOFF);
+				      function_adjusted = 1;
+				    }
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
+    }
+
+  /* When adding an instruction back it is sometimes necessary to move any
+     global or local symbol that was referencing the first instruction of
+     the moved block to refer to the first instruction of the inserted block.
+
+     For example adding a PAGE instruction before a CALL or JMP requires
+     that any label on the CALL or JMP is moved to the PAGE insn.  */
+  addr += noadj;
+
+  /* Adjust the local symbols defined in this section.  */
+  shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+  sym_shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
+  esym = extsyms;
+  esymend = esym + symtab_hdr->sh_info;
+  for (; esym < esymend; esym++, sym_shndx = (sym_shndx ? sym_shndx + 1: NULL))
+    {
+      Elf_Internal_Sym isym;
+      Elf_External_Sym_Shndx dummy;
+
+      bfd_elf32_swap_symbol_in (abfd, esym, sym_shndx, &isym);
+
+      if (isym.st_shndx == shndx)
+        {
+          if (addr <= isym.st_value && isym.st_value < endaddr)
+            {
+              isym.st_value += count;
+              bfd_elf32_swap_symbol_out (abfd, &isym, esym, &dummy);
+            }
+        }
+    }
+
+  /* Now adjust the global symbols defined in this section.  */
+  shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+  sym_shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
+  esym = extsyms + symtab_hdr->sh_info;
+  esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
+  for (index = 0; esym < esymend;
+       esym++, index++, sym_shndx = (sym_shndx ? sym_shndx + 1: NULL))
+    {
+      Elf_Internal_Sym isym;
+      struct elf_link_hash_entry *sym_hash;
+
+      bfd_elf32_swap_symbol_in (abfd, esym, sym_shndx, &isym);
+      sym_hash = elf_sym_hashes (abfd)[index];
+
+      if (isym.st_shndx == shndx
+          && (sym_hash->root.type == bfd_link_hash_defined
+              || sym_hash->root.type == bfd_link_hash_defweak)
+          && sym_hash->root.u.def.section == sec)
+        {
+          if (addr <= sym_hash->root.u.def.value
+              && sym_hash->root.u.def.value < endaddr)
+            {
+	      Elf_External_Sym_Shndx dummy;
+
+	      sym_hash->root.u.def.value += count;
+              bfd_elf32_swap_symbol_out (abfd, &isym, esym, &dummy);
+            }
+        }
+    }
+
+  return;
+}
+
+static boolean
+add_page_insn (abfd, sec, irel, misc)
+      bfd *abfd;
+      asection *sec;
+      Elf_Internal_Rela *irel;
+      struct misc *misc;
+{
+  /* Note that we've changed the relocs, section contents, etc.  */
+  elf_section_data (sec)->relocs = misc->irelbase;
+  misc->free_relocs = NULL;
+
+  elf_section_data (sec)->this_hdr.contents = misc->contents;
+  misc->free_contents = NULL;
+
+  misc->symtab_hdr->contents = (bfd_byte *) misc->extsyms;
+  misc->free_extsyms = NULL;
+
+  /* Add the PAGE insn.  */
+  if (! ip2k_elf_relax_add_bytes (abfd, sec, irel->r_offset,
+                                  page_opcode,
+                                  sizeof (page_opcode),
+				  sizeof (page_opcode)))
+    return false;
+  else
+    {
+       Elf32_Internal_Rela * jrel = irel - 1;
+
+       /* Add relocation for PAGE insn added.  */
+       if (ELF32_R_TYPE (jrel->r_info) != R_IP2K_NONE)
+	 {
+	   bfd_byte code0, code1;
+	   char *msg = NULL;
+	   
+	   /* Get the opcode.  */
+	   code0 = bfd_get_8 (abfd, misc->contents + irel->r_offset);
+	   code1 = bfd_get_8 (abfd, misc->contents + irel->r_offset + 1);
+
+	   if (IS_JMP_OPCODE (code0, code1))
+	     msg = "\tJMP instruction missing a preceeding PAGE instruction in %s\n\n";
+
+	   else if (IS_CALL_OPCODE (code0, code1))
+	     msg = "\tCALL instruction missing a preceeding PAGE instruction in %s\n\n";
+
+	   if (msg)
+	     {
+	       fprintf (stderr, "\n\t *** LINKER RELAXATION failure ***\n");
+	       fprintf (stderr, msg, sec->owner->filename);
+	     }
+
+	   return false;
+	 }
+
+       jrel->r_addend = irel->r_addend;
+       jrel->r_offset = irel->r_offset - sizeof (page_opcode);
+       jrel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                    R_IP2K_PAGE3);
+     }
+
+   return true;
+}
+
+/* Insert bytes into a section while relaxing.  */
+
+static boolean
+ip2k_elf_relax_add_bytes (abfd, sec, addr, bytes, count, noadj)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma addr;
+     const bfd_byte *bytes;
+     int count;
+     int noadj;
+{
+  bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
+  bfd_vma endaddr = sec->_cooked_size;
+
+  /* Make room to insert the bytes.  */
+  memmove (contents + addr + count, contents + addr, endaddr - addr);
+
+  /* Insert the bytes into the section.  */
+  memcpy  (contents + addr, bytes, count);
+  
+  sec->_cooked_size += count;
+
+  adjust_all_relocations (abfd, sec, addr, endaddr, count, noadj);
+  return true;
+}
+
+/* Delete some bytes from a section while relaxing.  */
+
+static boolean
+ip2k_elf_relax_delete_bytes (abfd, sec, addr, count)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma addr;
+     int count;
+{
+  bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
+  bfd_vma endaddr = sec->_cooked_size;
+
+  /* Actually delete the bytes.  */
+  memmove (contents + addr, contents + addr + count,
+	   endaddr - addr - count);
+
+  sec->_cooked_size -= count;
+
+  adjust_all_relocations (abfd, sec, addr + count, endaddr, -count, 0);
+  return true;
+}
+
+/* -------------------------------------------------------------------- */
+
+/* XXX: The following code is the result of a cut&paste.  This unfortunate
+   practice is very widespread in the various target back-end files.  */
+
+/* Set the howto pointer for a IP2K ELF reloc.  */
+
+static void
+ip2k_info_to_howto_rela (abfd, cache_ptr, dst)
+     bfd * abfd ATTRIBUTE_UNUSED;
+     arelent * cache_ptr;
+     Elf32_Internal_Rela * dst;
+{
+  unsigned int r_type;
+
+  r_type = ELF32_R_TYPE (dst->r_info);
+  switch (r_type)
+    {
+    default:
+      cache_ptr->howto = & ip2k_elf_howto_table [r_type];
+      break;
+    }
+}
+
+/* Perform a single relocation.
+   By default we use the standard BFD routines.  */
+
+static bfd_reloc_status_type
+ip2k_final_link_relocate (howto, input_bfd, input_section, contents, rel,
+			  relocation)
+     reloc_howto_type *  howto;
+     bfd *               input_bfd;
+     asection *          input_section;
+     bfd_byte *          contents;
+     Elf_Internal_Rela * rel;
+     bfd_vma             relocation;
+{
+  bfd_reloc_status_type r = bfd_reloc_ok;
+
+  switch (howto->type)
+    {
+      /* Handle data space relocations.  */
+    case R_IP2K_FR9:
+    case R_IP2K_BANK:
+      if ((relocation & IP2K_DATA_MASK) == IP2K_DATA_VALUE)
+	relocation &= ~IP2K_DATA_MASK;
+      else
+	r = bfd_reloc_notsupported;
+      break;
+
+    case R_IP2K_LO8DATA:
+    case R_IP2K_HI8DATA:
+    case R_IP2K_EX8DATA:
+      break;
+
+      /* Handle insn space relocations.  */
+    case R_IP2K_ADDR16CJP:
+    case R_IP2K_PAGE3:
+    case R_IP2K_LO8INSN:
+    case R_IP2K_HI8INSN:
+    case R_IP2K_PC_SKIP:
+      if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
+	relocation &= ~IP2K_INSN_MASK;
+      else
+	r = bfd_reloc_notsupported;
+      break;
+
+    case R_IP2K_16:
+      /* If this is a relocation involving a TEXT
+	 symbol, reduce it to a word address.  */
+      if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
+	howto = &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
+      break;
+
+      /* Pass others through.  */
+    default:
+      break;
+    }
+
+  /* Only install relocation if above tests did not disqualify it.  */
+  if (r == bfd_reloc_ok)
+    r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+				  contents, rel->r_offset,
+				  relocation, rel->r_addend);
+
+  return r;
+}
+
+/* Relocate a IP2K ELF section.
+   There is some attempt to make this function usable for many architectures,
+   both USE_REL and USE_RELA ['twould be nice if such a critter existed],
+   if only to serve as a learning tool.
+
+   The RELOCATE_SECTION function is called by the new ELF backend linker
+   to handle the relocations for a section.
+
+   The relocs are always passed as Rela structures; if the section
+   actually uses Rel structures, the r_addend field will always be
+   zero.
+
+   This function is responsible for adjusting the section contents as
+   necessary, and (if using Rela relocs and generating a relocateable
+   output file) adjusting the reloc addend as necessary.
+
+   This function does not have to worry about setting the reloc
+   address or the reloc symbol index.
+
+   LOCAL_SYMS is a pointer to the swapped in local symbols.
+
+   LOCAL_SECTIONS is an array giving the section in the input file
+   corresponding to the st_shndx field of each local symbol.
+
+   The global hash table entry for the global symbols can be found
+   via elf_sym_hashes (input_bfd).
+
+   When generating relocateable output, this function must handle
+   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
+   going to be the section symbol corresponding to the output
+   section, which means that the addend must be adjusted
+   accordingly.  */
+
+static boolean
+ip2k_elf_relocate_section (output_bfd, info, input_bfd, input_section,
+			   contents, relocs, local_syms, local_sections)
+     bfd *                   output_bfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *  info;
+     bfd *                   input_bfd;
+     asection *              input_section;
+     bfd_byte *              contents;
+     Elf_Internal_Rela *     relocs;
+     Elf_Internal_Sym *      local_syms;
+     asection **             local_sections;
+{
+  Elf_Internal_Shdr *           symtab_hdr;
+  struct elf_link_hash_entry ** sym_hashes;
+  Elf_Internal_Rela *           rel;
+  Elf_Internal_Rela *           relend;
+
+  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (input_bfd);
+  relend     = relocs + input_section->reloc_count;
+
+  for (rel = relocs; rel < relend; rel ++)
+    {
+      reloc_howto_type *           howto;
+      unsigned long                r_symndx;
+      Elf_Internal_Sym *           sym;
+      asection *                   sec;
+      struct elf_link_hash_entry * h;
+      bfd_vma                      relocation;
+      bfd_reloc_status_type        r;
+      const char *                 name = NULL;
+      int                          r_type;
+      
+      r_type = ELF32_R_TYPE (rel->r_info);
+
+      r_symndx = ELF32_R_SYM (rel->r_info);
+
+      if (info->relocateable)
+	{
+	  /* This is a relocateable link.  We don't have to change
+             anything, unless the reloc is against a section symbol,
+             in which case we have to adjust according to where the
+             section symbol winds up in the output section.  */
+	  if (r_symndx < symtab_hdr->sh_info)
+	    {
+	      sym = local_syms + r_symndx;
+	      
+	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+		{
+		  sec = local_sections [r_symndx];
+		  rel->r_addend += sec->output_offset + sym->st_value;
+		}
+	    }
+
+	  continue;
+	}
+
+      /* This is a final link.  */
+      howto  = ip2k_elf_howto_table + ELF32_R_TYPE (rel->r_info);
+      h      = NULL;
+      sym    = NULL;
+      sec    = NULL;
+      
+      if (r_symndx < symtab_hdr->sh_info)
+	{
+	  sym = local_syms + r_symndx;
+	  sec = local_sections [r_symndx];
+	  relocation = BASEADDR (sec) + sym->st_value;
+	  
+	  name = bfd_elf_string_from_elf_section
+	    (input_bfd, symtab_hdr->sh_link, sym->st_name);
+	  name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
+	}
+      else
+	{
+	  h = sym_hashes [r_symndx - symtab_hdr->sh_info];
+	  
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+	  name = h->root.root.string;
+	  
+	  if (h->root.type == bfd_link_hash_defined
+	      || h->root.type == bfd_link_hash_defweak)
+	    {
+	      sec = h->root.u.def.section;
+	      relocation = h->root.u.def.value + BASEADDR (sec);
+	    }
+	  else if (h->root.type == bfd_link_hash_undefweak)
+	    {
+	      relocation = 0;
+	    }
+	  else
+	    {
+	      if (! ((*info->callbacks->undefined_symbol)
+		     (info, h->root.root.string, input_bfd,
+		      input_section, rel->r_offset,
+		     (! info->shared || info->no_undefined))))
+		return false;
+	      relocation = 0;
+	    }
+	}
+
+      /* Finally, the sole IP2K-specific part.  */
+      r = ip2k_final_link_relocate (howto, input_bfd, input_section,
+				     contents, rel, relocation);
+
+      if (r != bfd_reloc_ok)
+	{
+	  const char * msg = (const char *) NULL;
+
+	  switch (r)
+	    {
+	    case bfd_reloc_overflow:
+	      r = info->callbacks->reloc_overflow
+		(info, name, howto->name, (bfd_vma) 0,
+		 input_bfd, input_section, rel->r_offset);
+	      break;
+	      
+	    case bfd_reloc_undefined:
+	      r = info->callbacks->undefined_symbol
+		(info, name, input_bfd, input_section, rel->r_offset, true);
+	      break;
+	      
+	    case bfd_reloc_outofrange:
+	      msg = _("internal error: out of range error");
+	      break;
+
+	      /* This is how ip2k_final_link_relocate tells us of a non-kosher
+                 reference between insn & data address spaces.  */
+	    case bfd_reloc_notsupported:
+              if (sym != NULL) /* Only if it's not an unresolved symbol.  */
+	         msg = _("unsupported relocation between data/insn address spaces");
+	      break;
+
+	    case bfd_reloc_dangerous:
+	      msg = _("internal error: dangerous relocation");
+	      break;
+
+	    default:
+	      msg = _("internal error: unknown error");
+	      break;
+	    }
+
+	  if (msg)
+	    r = info->callbacks->warning
+	      (info, msg, name, input_bfd, input_section, rel->r_offset);
+
+	  if (! r)
+	    return false;
+	}
+    }
+
+  return true;
+}
+
+static asection *
+ip2k_elf_gc_mark_hook (sec, info, rel, h, sym)
+     asection *sec;
+     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     Elf_Internal_Rela *rel;
+     struct elf_link_hash_entry *h;
+     Elf_Internal_Sym *sym;
+{
+  if (h != NULL)
+    {
+      switch (ELF32_R_TYPE (rel->r_info))
+      {
+#if 0 
+      case R_IP2K_GNU_VTINHERIT:
+      case R_IP2K_GNU_VTENTRY:
+        break;
+#endif
+
+      default:
+        switch (h->root.type)
+          {
+          case bfd_link_hash_defined:
+          case bfd_link_hash_defweak:
+            return h->root.u.def.section;
+
+          case bfd_link_hash_common:
+            return h->root.u.c.p->section;
+
+          default:
+            break;
+          }
+       }
+     }
+   else
+     {
+       if (!(elf_bad_symtab (sec->owner)
+	     && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
+	   && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
+		 && sym->st_shndx != SHN_COMMON))
+          {
+            return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
+          }
+      }
+  return NULL;
+}
+
+static boolean
+ip2k_elf_gc_sweep_hook (abfd, info, sec, relocs)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     asection *sec ATTRIBUTE_UNUSED;
+     const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
+{
+  /* we don't use got and plt entries for ip2k */
+  return true;
+}
+
+
+/* -------------------------------------------------------------------- */
+
+
+#define TARGET_BIG_SYM	 bfd_elf32_ip2k_vec
+#define TARGET_BIG_NAME  "elf32-ip2k"
+
+#define ELF_ARCH	 bfd_arch_ip2k
+#define ELF_MACHINE_CODE EM_IP2K
+#define ELF_MAXPAGESIZE  1 /* No pages on the IP2K */
+
+#undef USE_REL
+#define USE_RELA
+
+#define elf_info_to_howto_rel			NULL
+#define elf_info_to_howto			ip2k_info_to_howto_rela
+
+#define elf_backend_can_gc_sections     	1
+#define elf_backend_gc_mark_hook                ip2k_elf_gc_mark_hook
+#define elf_backend_gc_sweep_hook               ip2k_elf_gc_sweep_hook
+
+#define elf_backend_relocate_section		ip2k_elf_relocate_section
+
+#define elf_symbol_leading_char			'_'
+#define bfd_elf32_bfd_reloc_type_lookup		ip2k_reloc_type_lookup
+#define bfd_elf32_bfd_relax_section		ip2k_elf_relax_section
+
+
+#include "elf32-target.h"
+