bfd/elf32-ip2k.c

   1 /* Ubicom IP2xxx specific support for 32-bit ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24 #include "elf/ip2k.h"
  25
  26 /* Struct used to pass miscellaneous paramaters which
  27    helps to avoid overly long parameter lists.  */
  28 struct misc
  29 {
  30   Elf_Internal_Shdr *  symtab_hdr;
  31   Elf_Internal_Rela *  irelbase;
  32   bfd_byte *           contents;
  33   Elf_Internal_Sym *   isymbuf;
  34 };
  35
  36 struct ip2k_opcode
  37 {
  38   unsigned short opcode;
  39   unsigned short mask;
  40 };
  41
  42 /* Prototypes.  */
  43 static reloc_howto_type *ip2k_reloc_type_lookup
  44   PARAMS ((bfd *, bfd_reloc_code_real_type));
  45 static int ip2k_is_opcode
  46   PARAMS ((bfd_byte *, const struct ip2k_opcode *));
  47 static bfd_vma symbol_value
  48   PARAMS ((bfd *, Elf_Internal_Shdr *, Elf_Internal_Sym *,
  49            Elf_Internal_Rela *));
  50 static void ip2k_get_mem
  51   PARAMS ((bfd *, bfd_byte *, int, bfd_byte *));
  52 static bfd_vma ip2k_nominal_page_bits
  53   PARAMS ((bfd *, asection *, bfd_vma, bfd_byte *));
  54 static bfd_boolean ip2k_test_page_insn
  55   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, struct misc *));
  56 static bfd_boolean ip2k_delete_page_insn
  57   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_boolean *, struct misc *));
  58 static int ip2k_is_switch_table_128
  59   PARAMS ((bfd *, asection *, bfd_vma, bfd_byte *));
  60 static bfd_boolean ip2k_relax_switch_table_128
  61   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_boolean *, struct misc *));
  62 static int ip2k_is_switch_table_256
  63   PARAMS ((bfd *, asection *, bfd_vma, bfd_byte *));
  64 static bfd_boolean ip2k_relax_switch_table_256
  65   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_boolean *, struct misc *));
  66 static bfd_boolean ip2k_elf_relax_section
  67   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  68 static bfd_boolean ip2k_elf_relax_section_page
  69   PARAMS ((bfd *, asection *, bfd_boolean *, struct misc *, unsigned long, unsigned long));
  70 static void adjust_all_relocations
  71   PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, int, int));
  72 static bfd_boolean ip2k_elf_relax_delete_bytes
  73   PARAMS ((bfd *, asection *, bfd_vma, int));
  74 static void ip2k_info_to_howto_rela
  75   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  76 static bfd_reloc_status_type ip2k_final_link_relocate
  77   PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
  78            Elf_Internal_Rela *, bfd_vma));
  79 static bfd_boolean ip2k_elf_relocate_section
  80   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  81            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  82 static asection *ip2k_elf_gc_mark_hook
  83   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  84            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  85 static bfd_boolean ip2k_elf_gc_sweep_hook
  86   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  87            const Elf_Internal_Rela *));
  88
  89 static bfd_boolean ip2k_relaxed = FALSE;
  90
  91 static const struct ip2k_opcode ip2k_page_opcode[] =
  92 {
  93   {0x0010, 0xFFF8},     /* page */
  94   {0x0000, 0x0000},
  95 };
  96
  97 #define IS_PAGE_OPCODE(code) \
  98   ip2k_is_opcode (code, ip2k_page_opcode)
  99
 100 static const struct ip2k_opcode ip2k_jmp_opcode[] =
 101 {
 102   {0xE000, 0xE000},     /* jmp */
 103   {0x0000, 0x0000},
 104 };
 105
 106 #define IS_JMP_OPCODE(code) \
 107   ip2k_is_opcode (code, ip2k_jmp_opcode)
 108
 109 static const struct ip2k_opcode ip2k_call_opcode[] =
 110 {
 111   {0xC000, 0xE000},     /* call */
 112   {0x0000, 0x0000},
 113 };
 114
 115 #define IS_CALL_OPCODE(code) \
 116   ip2k_is_opcode (code, ip2k_call_opcode)
 117
 118 static const struct ip2k_opcode ip2k_snc_opcode[] =
 119 {
 120   {0xA00B, 0xFFFF},     /* snc */
 121   {0x0000, 0x0000},
 122 };
 123
 124 #define IS_SNC_OPCODE(code) \
 125   ip2k_is_opcode (code, ip2k_snc_opcode)
 126
 127 static const struct ip2k_opcode ip2k_inc_1sp_opcode[] =
 128 {
 129   {0x2B81, 0xFFFF},     /* inc 1(SP) */
 130   {0x0000, 0x0000},
 131 };
 132
 133 #define IS_INC_1SP_OPCODE(code) \
 134   ip2k_is_opcode (code, ip2k_inc_1sp_opcode)
 135
 136 static const struct ip2k_opcode ip2k_add_2sp_w_opcode[] =
 137 {
 138   {0x1F82, 0xFFFF},     /* add 2(SP),w */
 139   {0x0000, 0x0000},
 140 };
 141
 142 #define IS_ADD_2SP_W_OPCODE(code) \
 143   ip2k_is_opcode (code, ip2k_add_2sp_w_opcode)
 144
 145 static const struct ip2k_opcode ip2k_add_w_wreg_opcode[] =
 146 {
 147   {0x1C0A, 0xFFFF},     /* add w,wreg */
 148   {0x1E0A, 0xFFFF},     /* add wreg,w */
 149   {0x0000, 0x0000},
 150 };
 151
 152 #define IS_ADD_W_WREG_OPCODE(code) \
 153   ip2k_is_opcode (code, ip2k_add_w_wreg_opcode)
 154
 155 static const struct ip2k_opcode ip2k_add_pcl_w_opcode[] =
 156 {
 157   {0x1E09, 0xFFFF},     /* add pcl,w */
 158   {0x0000, 0x0000},
 159 };
 160
 161 #define IS_ADD_PCL_W_OPCODE(code) \
 162   ip2k_is_opcode (code, ip2k_add_pcl_w_opcode)
 163
 164 static const struct ip2k_opcode ip2k_skip_opcodes[] =
 165 {
 166   {0xB000, 0xF000},     /* sb */
 167   {0xA000, 0xF000},     /* snb */
 168   {0x7600, 0xFE00},     /* cse/csne #lit */
 169   {0x5800, 0xFC00},     /* incsnz */
 170   {0x4C00, 0xFC00},     /* decsnz */
 171   {0x4000, 0xFC00},     /* cse/csne */
 172   {0x3C00, 0xFC00},     /* incsz */
 173   {0x2C00, 0xFC00},     /* decsz */
 174   {0x0000, 0x0000},
 175 };
 176
 177 #define IS_SKIP_OPCODE(code) \
 178   ip2k_is_opcode (code, ip2k_skip_opcodes)
 179
 180 /* Relocation tables.  */
 181 static reloc_howto_type ip2k_elf_howto_table [] =
 182 {
 183 #define IP2K_HOWTO(t,rs,s,bs,pr,bp,name,sm,dm) \
 184     HOWTO(t,                    /* type */ \
 185           rs,                   /* rightshift */ \
 186           s,                    /* size (0 = byte, 1 = short, 2 = long) */ \
 187           bs,                   /* bitsize */ \
 188           pr,                   /* pc_relative */ \
 189           bp,                   /* bitpos */ \
 190           complain_overflow_dont,/* complain_on_overflow */ \
 191           bfd_elf_generic_reloc,/* special_function */ \
 192           name,                 /* name */ \
 193           FALSE,                /* partial_inplace */ \
 194           sm,                   /* src_mask */ \
 195           dm,                   /* dst_mask */ \
 196           pr)                   /* pcrel_offset */
 197
 198   /* This reloc does nothing.  */
 199   IP2K_HOWTO (R_IP2K_NONE, 0,2,32, FALSE, 0, "R_IP2K_NONE", 0, 0),
 200   /* A 16 bit absolute relocation.  */
 201   IP2K_HOWTO (R_IP2K_16, 0,1,16, FALSE, 0, "R_IP2K_16", 0, 0xffff),
 202   /* A 32 bit absolute relocation.  */
 203   IP2K_HOWTO (R_IP2K_32, 0,2,32, FALSE, 0, "R_IP2K_32", 0, 0xffffffff),
 204   /* A 8-bit data relocation for the FR9 field.  Ninth bit is computed specially.  */
 205   IP2K_HOWTO (R_IP2K_FR9, 0,1,9, FALSE, 0, "R_IP2K_FR9", 0, 0x00ff),
 206   /* A 4-bit data relocation.  */
 207   IP2K_HOWTO (R_IP2K_BANK, 8,1,4, FALSE, 0, "R_IP2K_BANK", 0, 0x000f),
 208   /* A 13-bit insn relocation - word address => right-shift 1 bit extra.  */
 209   IP2K_HOWTO (R_IP2K_ADDR16CJP, 1,1,13, FALSE, 0, "R_IP2K_ADDR16CJP", 0, 0x1fff),
 210   /* A 3-bit insn relocation - word address => right-shift 1 bit extra.  */
 211   IP2K_HOWTO (R_IP2K_PAGE3, 14,1,3, FALSE, 0, "R_IP2K_PAGE3", 0, 0x0007),
 212   /* Two 8-bit data relocations.  */
 213   IP2K_HOWTO (R_IP2K_LO8DATA, 0,1,8, FALSE, 0, "R_IP2K_LO8DATA", 0, 0x00ff),
 214   IP2K_HOWTO (R_IP2K_HI8DATA, 8,1,8, FALSE, 0, "R_IP2K_HI8DATA", 0, 0x00ff),
 215   /* Two 8-bit insn relocations.  word address => right-shift 1 bit extra.  */
 216   IP2K_HOWTO (R_IP2K_LO8INSN, 1,1,8, FALSE, 0, "R_IP2K_LO8INSN", 0, 0x00ff),
 217   IP2K_HOWTO (R_IP2K_HI8INSN, 9,1,8, FALSE, 0, "R_IP2K_HI8INSN", 0, 0x00ff),
 218
 219   /* Special 1 bit relocation for SKIP instructions.  */
 220   IP2K_HOWTO (R_IP2K_PC_SKIP, 1,1,1, FALSE, 12, "R_IP2K_PC_SKIP", 0xfffe, 0x1000),
 221   /* 16 bit word address.  */
 222   IP2K_HOWTO (R_IP2K_TEXT, 1,1,16, FALSE, 0, "R_IP2K_TEXT", 0, 0xffff),
 223   /* A 7-bit offset relocation for the FR9 field.  Eigth and ninth bit comes from insn.  */
 224   IP2K_HOWTO (R_IP2K_FR_OFFSET, 0,1,9, FALSE, 0, "R_IP2K_FR_OFFSET", 0x180, 0x007f),
 225   /* Bits 23:16 of an address.  */
 226   IP2K_HOWTO (R_IP2K_EX8DATA, 16,1,8, FALSE, 0, "R_IP2K_EX8DATA", 0, 0x00ff),
 227 };
 228
 229
 230 /* Map BFD reloc types to IP2K ELF reloc types.  */
 231 static reloc_howto_type *
 232 ip2k_reloc_type_lookup (abfd, code)
 233      bfd * abfd ATTRIBUTE_UNUSED;
 234      bfd_reloc_code_real_type code;
 235 {
 236   /* Note that the ip2k_elf_howto_table is indxed by the R_
 237      constants.  Thus, the order that the howto records appear in the
 238      table *must* match the order of the relocation types defined in
 239      include/elf/ip2k.h.  */
 240
 241   switch (code)
 242     {
 243     case BFD_RELOC_NONE:
 244       return &ip2k_elf_howto_table[ (int) R_IP2K_NONE];
 245     case BFD_RELOC_16:
 246       return &ip2k_elf_howto_table[ (int) R_IP2K_16];
 247     case BFD_RELOC_32:
 248       return &ip2k_elf_howto_table[ (int) R_IP2K_32];
 249     case BFD_RELOC_IP2K_FR9:
 250       return &ip2k_elf_howto_table[ (int) R_IP2K_FR9];
 251     case BFD_RELOC_IP2K_BANK:
 252       return &ip2k_elf_howto_table[ (int) R_IP2K_BANK];
 253     case BFD_RELOC_IP2K_ADDR16CJP:
 254       return &ip2k_elf_howto_table[ (int) R_IP2K_ADDR16CJP];
 255     case BFD_RELOC_IP2K_PAGE3:
 256       return &ip2k_elf_howto_table[ (int) R_IP2K_PAGE3];
 257     case BFD_RELOC_IP2K_LO8DATA:
 258       return &ip2k_elf_howto_table[ (int) R_IP2K_LO8DATA];
 259     case BFD_RELOC_IP2K_HI8DATA:
 260       return &ip2k_elf_howto_table[ (int) R_IP2K_HI8DATA];
 261     case BFD_RELOC_IP2K_LO8INSN:
 262       return &ip2k_elf_howto_table[ (int) R_IP2K_LO8INSN];
 263     case BFD_RELOC_IP2K_HI8INSN:
 264       return &ip2k_elf_howto_table[ (int) R_IP2K_HI8INSN];
 265     case BFD_RELOC_IP2K_PC_SKIP:
 266       return &ip2k_elf_howto_table[ (int) R_IP2K_PC_SKIP];
 267     case BFD_RELOC_IP2K_TEXT:
 268       return &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
 269     case BFD_RELOC_IP2K_FR_OFFSET:
 270       return &ip2k_elf_howto_table[ (int) R_IP2K_FR_OFFSET];
 271     case BFD_RELOC_IP2K_EX8DATA:
 272       return &ip2k_elf_howto_table[ (int) R_IP2K_EX8DATA];
 273     default:
 274       /* Pacify gcc -Wall.  */
 275       return NULL;
 276     }
 277   return NULL;
 278 }
 279
 280 static void
 281 ip2k_get_mem (abfd, addr, length, ptr)
 282      bfd *abfd ATTRIBUTE_UNUSED;
 283      bfd_byte *addr;
 284      int length;
 285      bfd_byte *ptr;
 286 {
 287   while (length --)
 288     * ptr ++ = bfd_get_8 (abfd, addr ++);
 289 }
 290
 291 static bfd_boolean
 292 ip2k_is_opcode (code, opcodes)
 293      bfd_byte *code;
 294      const struct ip2k_opcode *opcodes;
 295 {
 296   unsigned short insn = (code[0] << 8) | code[1];
 297
 298   while (opcodes->mask != 0)
 299     {
 300       if ((insn & opcodes->mask) == opcodes->opcode)
 301         return TRUE;
 302
 303       opcodes ++;
 304     }
 305
 306   return FALSE;
 307 }
 308
 309 #define PAGENO(ABSADDR) ((ABSADDR) & 0xFFFFC000)
 310 #define BASEADDR(SEC)   ((SEC)->output_section->vma + (SEC)->output_offset)
 311
 312 #define UNDEFINED_SYMBOL (~(bfd_vma)0)
 313
 314 /* Return the value of the symbol associated with the relocation IREL.  */
 315
 316 static bfd_vma
 317 symbol_value (abfd, symtab_hdr, isymbuf, irel)
 318      bfd *abfd;
 319      Elf_Internal_Shdr *symtab_hdr;
 320      Elf_Internal_Sym *isymbuf;
 321      Elf_Internal_Rela *irel;
 322 {
 323   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 324     {
 325       Elf_Internal_Sym *isym;
 326       asection *sym_sec;
 327
 328       isym = isymbuf + ELF32_R_SYM (irel->r_info);
 329       if (isym->st_shndx == SHN_UNDEF)
 330         sym_sec = bfd_und_section_ptr;
 331       else if (isym->st_shndx == SHN_ABS)
 332         sym_sec = bfd_abs_section_ptr;
 333       else if (isym->st_shndx == SHN_COMMON)
 334         sym_sec = bfd_com_section_ptr;
 335       else
 336         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 337
 338       return isym->st_value + BASEADDR (sym_sec);
 339     }
 340   else
 341     {
 342       unsigned long indx;
 343       struct elf_link_hash_entry *h;
 344
 345       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 346       h = elf_sym_hashes (abfd)[indx];
 347       BFD_ASSERT (h != NULL);
 348
 349       if (h->root.type != bfd_link_hash_defined
 350           && h->root.type != bfd_link_hash_defweak)
 351         return UNDEFINED_SYMBOL;
 352
 353       return (h->root.u.def.value + BASEADDR (h->root.u.def.section));
 354     }
 355 }
 356
 357 /* Returns the expected page state for the given instruction not including
 358    the effect of page instructions.  */
 359
 360 static bfd_vma
 361 ip2k_nominal_page_bits (abfd, sec, addr, contents)
 362      bfd *abfd ATTRIBUTE_UNUSED;
 363      asection *sec;
 364      bfd_vma addr;
 365      bfd_byte *contents;
 366 {
 367   bfd_vma page = PAGENO (BASEADDR (sec) + addr);
 368
 369   /* Check if section flows into this page. If not then the page
 370      bits are assumed to match the PC. This will be true unless
 371      the user has a page instruction without a call/jump, in which
 372      case they are on their own.  */
 373   if (PAGENO (BASEADDR (sec)) == page)
 374     return page;
 375
 376   /* Section flows across page boundary. The page bits should match
 377      the PC unless there is a possible flow from the previous page,
 378      in which case it is not possible to determine the value of the
 379      page bits.  */
 380   while (PAGENO (BASEADDR (sec) + addr - 2) == page)
 381     {
 382       bfd_byte code[2];
 383
 384       addr -= 2;
 385       ip2k_get_mem (abfd, contents + addr, 2, code);
 386       if (!IS_PAGE_OPCODE (code))
 387         continue;
 388
 389       /* Found a page instruction, check if jump table.  */
 390       if (ip2k_is_switch_table_128 (abfd, sec, addr, contents) != -1)
 391         /* Jump table => page is conditional.  */
 392         continue;
 393
 394       if (ip2k_is_switch_table_256 (abfd, sec, addr, contents) != -1)
 395         /* Jump table => page is conditional.  */
 396         continue;
 397
 398       /* Found a page instruction, check if conditional.  */
 399       if (addr >= 2)
 400         {
 401           ip2k_get_mem (abfd, contents + addr - 2, 2, code);
 402           if (IS_SKIP_OPCODE (code))
 403             /* Page is conditional.  */
 404             continue;
 405         }
 406
 407       /* Unconditional page instruction => page bits should be correct.  */
 408       return page;
 409     }
 410
 411   /* Flow from previous page => page bits are impossible to determine.  */
 412   return 0;
 413 }
 414
 415 static bfd_boolean
 416 ip2k_test_page_insn (abfd, sec, irel, misc)
 417      bfd *abfd ATTRIBUTE_UNUSED;
 418      asection *sec;
 419      Elf_Internal_Rela *irel;
 420      struct misc *misc;
 421 {
 422   bfd_vma symval;
 423
 424   /* Get the value of the symbol referred to by the reloc.  */
 425   symval = symbol_value (abfd, misc->symtab_hdr, misc->isymbuf, irel);
 426   if (symval == UNDEFINED_SYMBOL)
 427     /* This appears to be a reference to an undefined
 428        symbol.  Just ignore it--it will be caught by the
 429        regular reloc processing.  */
 430     return FALSE;
 431
 432   /* Test if we can delete this page instruction.  */
 433   if (PAGENO (symval + irel->r_addend) !=
 434       ip2k_nominal_page_bits (abfd, sec, irel->r_offset, misc->contents))
 435     return FALSE;
 436
 437   return TRUE;
 438 }
 439
 440 static bfd_boolean
 441 ip2k_delete_page_insn (abfd, sec, irel, again, misc)
 442      bfd *abfd ATTRIBUTE_UNUSED;
 443      asection *sec;
 444      Elf_Internal_Rela *irel;
 445      bfd_boolean *again;
 446      struct misc *misc;
 447 {
 448   /* Note that we've changed the relocs, section contents, etc.  */
 449   elf_section_data (sec)->relocs = misc->irelbase;
 450   elf_section_data (sec)->this_hdr.contents = misc->contents;
 451   misc->symtab_hdr->contents = (bfd_byte *) misc->isymbuf;
 452
 453   /* Fix the relocation's type.  */
 454   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_IP2K_NONE);
 455
 456   /* Delete the PAGE insn.  */
 457   if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
 458     return FALSE;
 459
 460   /* Modified => will need to iterate relaxation again.  */
 461   *again = TRUE;
 462
 463   return TRUE;
 464 }
 465
 466 /* Determine if the instruction sequence matches that for
 467    the prologue of a switch dispatch table with fewer than
 468    128 entries.
 469
 470           sc
 471           page    $nnn0
 472           jmp     $nnn0
 473           add     w,wreg
 474           add     pcl,w
 475   addr=>
 476           page    $nnn1
 477           jmp     $nnn1
 478            page    $nnn2
 479            jmp     $nnn2
 480            ...
 481            page    $nnnN
 482            jmp     $nnnN
 483
 484   After relaxation.
 485            sc
 486            page    $nnn0
 487            jmp     $nnn0
 488            add     pcl,w
 489   addr=>
 490            jmp     $nnn1
 491            jmp     $nnn2
 492            ...
 493           jmp     $nnnN  */
 494
 495 static int
 496 ip2k_is_switch_table_128 (abfd, sec, addr, contents)
 497      bfd *abfd ATTRIBUTE_UNUSED;
 498      asection *sec;
 499      bfd_vma addr;
 500      bfd_byte *contents;
 501 {
 502   bfd_byte code[4];
 503   int index = 0;
 504
 505   /* Check current page-jmp.  */
 506   if (addr + 4 > sec->_cooked_size)
 507     return -1;
 508
 509   ip2k_get_mem (abfd, contents + addr, 4, code);
 510
 511   if ((! IS_PAGE_OPCODE (code + 0))
 512       || (! IS_JMP_OPCODE (code + 2)))
 513     return -1;
 514
 515   /* Search back.  */
 516   while (1)
 517     {
 518       if (addr < 4)
 519         return -1;
 520
 521       /* Check previous 2 instructions.  */
 522       ip2k_get_mem (abfd, contents + addr - 4, 4, code);
 523       if ((IS_ADD_W_WREG_OPCODE (code + 0))
 524           && (IS_ADD_PCL_W_OPCODE (code + 2)))
 525         return index;
 526
 527       if ((! IS_PAGE_OPCODE (code + 0))
 528           || (! IS_JMP_OPCODE (code + 2)))
 529         return -1;
 530
 531       index++;
 532       addr -= 4;
 533     }
 534 }
 535
 536 static bfd_boolean
 537 ip2k_relax_switch_table_128 (abfd, sec, irel, again, misc)
 538      bfd *abfd ATTRIBUTE_UNUSED;
 539      asection *sec;
 540      Elf_Internal_Rela *irel;
 541      bfd_boolean *again;
 542      struct misc *misc;
 543 {
 544   Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
 545   Elf_Internal_Rela *ireltest = irel;
 546   bfd_byte code[4];
 547   bfd_vma addr;
 548
 549   /* Test all page instructions.  */
 550   addr = irel->r_offset;
 551   while (1)
 552     {
 553       if (addr + 4 > sec->_cooked_size)
 554         break;
 555
 556       ip2k_get_mem (abfd, misc->contents + addr, 4, code);
 557       if ((! IS_PAGE_OPCODE (code + 0))
 558           || (! IS_JMP_OPCODE (code + 2)))
 559         break;
 560
 561       /* Validate relocation entry (every entry should have a matching
 562           relocation entry).  */
 563       if (ireltest >= irelend)
 564         {
 565           _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
 566           return FALSE;
 567         }
 568
 569       if (ireltest->r_offset != addr)
 570         {
 571           _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
 572           return FALSE;
 573         }
 574
 575       if (! ip2k_test_page_insn (abfd, sec, ireltest, misc))
 576         /* Un-removable page insn => nothing can be done.  */
 577         return TRUE;
 578
 579       addr += 4;
 580       ireltest += 2;
 581     }
 582
 583   /* Relaxable. Adjust table header.  */
 584   ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 4, code);
 585   if ((! IS_ADD_W_WREG_OPCODE (code + 0))
 586       || (! IS_ADD_PCL_W_OPCODE (code + 2)))
 587     {
 588       _bfd_error_handler (_("ip2k relaxer: switch table header corrupt."));
 589       return FALSE;
 590     }
 591
 592   if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset - 4, 2))
 593     return FALSE;
 594
 595   *again = TRUE;
 596
 597   /* Delete all page instructions in table.  */
 598   while (irel < ireltest)
 599     {
 600       if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
 601         return FALSE;
 602       irel += 2;
 603     }
 604
 605   return TRUE;
 606 }
 607
 608 /* Determine if the instruction sequence matches that for
 609    the prologue switch dispatch table with fewer than
 610    256 entries but more than 127.
 611
 612    Before relaxation.
 613           push    %lo8insn(label) ; Push address of table
 614           push    %hi8insn(label)
 615           add     w,wreg          ; index*2 => offset
 616           snc                     ; CARRY SET?
 617           inc     1(sp)           ; Propagate MSB into table address
 618           add     2(sp),w         ; Add low bits of offset to table address
 619           snc                     ; and handle any carry-out
 620           inc     1(sp)
 621    addr=>
 622           page    __indjmp        ; Do an indirect jump to that location
 623           jmp     __indjmp
 624    label:                         ; case dispatch table starts here
 625            page    $nnn1
 626            jmp     $nnn1
 627            page    $nnn2
 628            jmp     $nnn2
 629            ...
 630            page    $nnnN
 631            jmp     $nnnN
 632
 633   After relaxation.
 634           push    %lo8insn(label) ; Push address of table
 635           push    %hi8insn(label)
 636           add     2(sp),w         ; Add low bits of offset to table address
 637           snc                     ; and handle any carry-out
 638           inc     1(sp)
 639   addr=>
 640           page    __indjmp        ; Do an indirect jump to that location
 641           jmp     __indjmp
 642    label:                         ; case dispatch table starts here
 643           jmp     $nnn1
 644           jmp     $nnn2
 645           ...
 646           jmp     $nnnN  */
 647
 648 static int
 649 ip2k_is_switch_table_256 (abfd, sec, addr, contents)
 650      bfd *abfd ATTRIBUTE_UNUSED;
 651      asection *sec;
 652      bfd_vma addr;
 653      bfd_byte *contents;
 654 {
 655   bfd_byte code[16];
 656   int index = 0;
 657
 658   /* Check current page-jmp.  */
 659   if (addr + 4 > sec->_cooked_size)
 660     return -1;
 661
 662   ip2k_get_mem (abfd, contents + addr, 4, code);
 663   if ((! IS_PAGE_OPCODE (code + 0))
 664       || (! IS_JMP_OPCODE (code + 2)))
 665     return -1;
 666
 667   /* Search back.  */
 668   while (1)
 669     {
 670       if (addr < 16)
 671         return -1;
 672
 673       /* Check previous 8 instructions.  */
 674       ip2k_get_mem (abfd, contents + addr - 16, 16, code);
 675       if ((IS_ADD_W_WREG_OPCODE (code + 0))
 676           && (IS_SNC_OPCODE (code + 2))
 677           && (IS_INC_1SP_OPCODE (code + 4))
 678           && (IS_ADD_2SP_W_OPCODE (code + 6))
 679           && (IS_SNC_OPCODE (code + 8))
 680           && (IS_INC_1SP_OPCODE (code + 10))
 681           && (IS_PAGE_OPCODE (code + 12))
 682           && (IS_JMP_OPCODE (code + 14)))
 683         return index;
 684
 685       if ((IS_ADD_W_WREG_OPCODE (code + 2))
 686           && (IS_SNC_OPCODE (code + 4))
 687           && (IS_INC_1SP_OPCODE (code + 6))
 688           && (IS_ADD_2SP_W_OPCODE (code + 8))
 689           && (IS_SNC_OPCODE (code + 10))
 690           && (IS_INC_1SP_OPCODE (code + 12))
 691           && (IS_JMP_OPCODE (code + 14)))
 692         return index;
 693
 694       if ((! IS_PAGE_OPCODE (code + 0))
 695           || (! IS_JMP_OPCODE (code + 2)))
 696         return -1;
 697
 698       index++;
 699       addr -= 4;
 700     }
 701 }
 702
 703 static bfd_boolean
 704 ip2k_relax_switch_table_256 (abfd, sec, irel, again, misc)
 705      bfd *abfd ATTRIBUTE_UNUSED;
 706      asection *sec;
 707      Elf_Internal_Rela *irel;
 708      bfd_boolean *again;
 709      struct misc *misc;
 710 {
 711   Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
 712   Elf_Internal_Rela *ireltest = irel;
 713   bfd_byte code[12];
 714   bfd_vma addr;
 715
 716   /* Test all page instructions.  */
 717   addr = irel->r_offset;
 718
 719   while (1)
 720     {
 721       if (addr + 4 > sec->_cooked_size)
 722         break;
 723
 724       ip2k_get_mem (abfd, misc->contents + addr, 4, code);
 725
 726       if ((! IS_PAGE_OPCODE (code + 0))
 727           || (! IS_JMP_OPCODE (code + 2)))
 728         break;
 729
 730       /* Validate relocation entry (every entry should have a matching
 731           relocation entry).  */
 732       if (ireltest >= irelend)
 733         {
 734           _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
 735           return FALSE;
 736         }
 737
 738       if (ireltest->r_offset != addr)
 739         {
 740           _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
 741           return FALSE;
 742         }
 743
 744       if (!ip2k_test_page_insn (abfd, sec, ireltest, misc))
 745         /* Un-removable page insn => nothing can be done.  */
 746         return TRUE;
 747
 748       addr += 4;
 749       ireltest += 2;
 750     }
 751
 752   /* Relaxable. Adjust table header.  */
 753   ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 2, code);
 754   if (IS_PAGE_OPCODE (code))
 755     addr = irel->r_offset - 16;
 756   else
 757     addr = irel->r_offset - 14;
 758
 759   ip2k_get_mem (abfd, misc->contents + addr, 12, code);
 760   if ((!IS_ADD_W_WREG_OPCODE (code + 0))
 761       || (!IS_SNC_OPCODE (code + 2))
 762       || (!IS_INC_1SP_OPCODE (code + 4))
 763       || (!IS_ADD_2SP_W_OPCODE (code + 6))
 764       || (!IS_SNC_OPCODE (code + 8))
 765       || (!IS_INC_1SP_OPCODE (code + 10)))
 766     {
 767       _bfd_error_handler (_("ip2k relaxer: switch table header corrupt."));
 768       return FALSE;
 769     }
 770
 771   /* Delete first 3 opcodes.  */
 772   if (!ip2k_elf_relax_delete_bytes (abfd, sec, addr + 0, 6))
 773     return FALSE;
 774
 775   *again = TRUE;
 776
 777   /* Delete all page instructions in table.  */
 778   while (irel < ireltest)
 779     {
 780       if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
 781         return FALSE;
 782       irel += 2;
 783     }
 784
 785   return TRUE;
 786 }
 787
 788 /* This function handles relaxing for the ip2k.
 789
 790    Principle: Start with the first page and remove page instructions that
 791    are not require on this first page. By removing page instructions more
 792    code will fit into this page - repeat until nothing more can be achieved
 793    for this page. Move on to the next page.
 794
 795    Processing the pages one at a time from the lowest page allows a removal
 796    only policy to be used - pages can be removed but are never reinserted.  */
 797
 798 static bfd_boolean
 799 ip2k_elf_relax_section (abfd, sec, link_info, again)
 800      bfd *abfd;
 801      asection *sec;
 802      struct bfd_link_info *link_info;
 803      bfd_boolean *again;
 804 {
 805   Elf_Internal_Shdr *symtab_hdr;
 806   Elf_Internal_Rela *internal_relocs;
 807   bfd_byte *contents = NULL;
 808   Elf_Internal_Sym *isymbuf = NULL;
 809   static asection * first_section = NULL;
 810   static unsigned long search_addr;
 811   static unsigned long page_start = 0;
 812   static unsigned long page_end = 0;
 813   static unsigned int pass = 0;
 814   static bfd_boolean new_pass = FALSE;
 815   static bfd_boolean changed = FALSE;
 816   struct misc misc;
 817   asection *stab;
 818
 819   /* Assume nothing changes.  */
 820   *again = FALSE;
 821
 822   if (first_section == NULL)
 823     {
 824       ip2k_relaxed = TRUE;
 825       first_section = sec;
 826     }
 827
 828   if (first_section == sec)
 829     {
 830       pass++;
 831       new_pass = TRUE;
 832     }
 833
 834   /* We don't have to do anything for a relocatable link,
 835      if this section does not have relocs, or if this is
 836      not a code section.  */
 837   if (link_info->relocatable
 838       || (sec->flags & SEC_RELOC) == 0
 839       || sec->reloc_count == 0
 840       || (sec->flags & SEC_CODE) == 0)
 841     return TRUE;
 842
 843   /* If this is the first time we have been called
 844       for this section, initialise the cooked size.  */
 845   if (sec->_cooked_size == 0)
 846     sec->_cooked_size = sec->_raw_size;
 847
 848   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 849
 850   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL,
 851                                                (Elf_Internal_Rela *)NULL,
 852                                                link_info->keep_memory);
 853   if (internal_relocs == NULL)
 854     goto error_return;
 855
 856   /* Make sure the stac.rela stuff gets read in.  */
 857   stab = bfd_get_section_by_name (abfd, ".stab");
 858
 859   if (stab)
 860     {
 861       /* So stab does exits.  */
 862       Elf_Internal_Rela * irelbase;
 863
 864       irelbase = _bfd_elf_link_read_relocs (abfd, stab, NULL,
 865                                             (Elf_Internal_Rela *)NULL,
 866                                             link_info->keep_memory);
 867     }
 868
 869   /* Get section contents cached copy if it exists.  */
 870   if (contents == NULL)
 871     {
 872       /* Get cached copy if it exists.  */
 873       if (elf_section_data (sec)->this_hdr.contents != NULL)
 874         contents = elf_section_data (sec)->this_hdr.contents;
 875       else
 876         {
 877           /* Go get them off disk.  */
 878           contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 879           if (contents == NULL)
 880             goto error_return;
 881
 882           if (! bfd_get_section_contents (abfd, sec, contents,
 883                                           (file_ptr) 0, sec->_raw_size))
 884             goto error_return;
 885         }
 886     }
 887
 888   /* Read this BFD's symbols cached copy if it exists.  */
 889   if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 890     {
 891       isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 892       if (isymbuf == NULL)
 893         isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 894                                         symtab_hdr->sh_info, 0,
 895                                         NULL, NULL, NULL);
 896       if (isymbuf == NULL)
 897         goto error_return;
 898     }
 899
 900   misc.symtab_hdr = symtab_hdr;
 901   misc.isymbuf = isymbuf;
 902   misc.irelbase = internal_relocs;
 903   misc.contents = contents;
 904
 905   /* This is where all the relaxation actually get done.  */
 906   if ((pass == 1) || (new_pass && !changed))
 907     {
 908       /* On the first pass we simply search for the lowest page that
 909          we havn't relaxed yet. Note that the pass count is reset
 910          each time a page is complete in order to move on to the next page.
 911          If we can't find any more pages then we are finished.  */
 912       if (new_pass)
 913         {
 914           pass = 1;
 915           new_pass = FALSE;
 916           changed = TRUE; /* Pre-initialize to break out of pass 1.  */
 917           search_addr = 0xFFFFFFFF;
 918         }
 919
 920       if ((BASEADDR (sec) + sec->_cooked_size < search_addr)
 921           && (BASEADDR (sec) + sec->_cooked_size > page_end))
 922         {
 923           if (BASEADDR (sec) <= page_end)
 924             search_addr = page_end + 1;
 925           else
 926             search_addr = BASEADDR (sec);
 927
 928           /* Found a page => more work to do.  */
 929           *again = TRUE;
 930         }
 931     }
 932   else
 933     {
 934       if (new_pass)
 935         {
 936           new_pass = FALSE;
 937           changed = FALSE;
 938           page_start = PAGENO (search_addr);
 939           page_end = page_start | 0x00003FFF;
 940         }
 941
 942       /* Only process sections in range.  */
 943       if ((BASEADDR (sec) + sec->_cooked_size >= page_start)
 944           && (BASEADDR (sec) <= page_end))
 945         {
 946           if (!ip2k_elf_relax_section_page (abfd, sec, &changed, &misc, page_start, page_end))
 947             return FALSE;
 948         }
 949       *again = TRUE;
 950     }
 951
 952   /* Perform some house keeping after relaxing the section.  */
 953
 954   if (isymbuf != NULL
 955       && symtab_hdr->contents != (unsigned char *) isymbuf)
 956     {
 957       if (! link_info->keep_memory)
 958         free (isymbuf);
 959       else
 960         symtab_hdr->contents = (unsigned char *) isymbuf;
 961     }
 962
 963   if (contents != NULL
 964       && elf_section_data (sec)->this_hdr.contents != contents)
 965     {
 966       if (! link_info->keep_memory)
 967         free (contents);
 968       else
 969         {
 970           /* Cache the section contents for elf_link_input_bfd.  */
 971           elf_section_data (sec)->this_hdr.contents = contents;
 972         }
 973     }
 974
 975   if (internal_relocs != NULL
 976       && elf_section_data (sec)->relocs != internal_relocs)
 977     free (internal_relocs);
 978
 979   return TRUE;
 980
 981  error_return:
 982   if (isymbuf != NULL
 983       && symtab_hdr->contents != (unsigned char *) isymbuf)
 984     free (isymbuf);
 985   if (contents != NULL
 986       && elf_section_data (sec)->this_hdr.contents != contents)
 987     free (contents);
 988   if (internal_relocs != NULL
 989       && elf_section_data (sec)->relocs != internal_relocs)
 990     free (internal_relocs);
 991   return FALSE;
 992 }
 993
 994 /* This function handles relaxation of a section in a specific page.  */
 995
 996 static bfd_boolean
 997 ip2k_elf_relax_section_page (abfd, sec, again, misc, page_start, page_end)
 998      bfd *abfd;
 999      asection *sec;
1000      bfd_boolean *again;
1001      struct misc *misc;
1002      unsigned long page_start;
1003      unsigned long page_end;
1004 {
1005   Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
1006   Elf_Internal_Rela *irel;
1007   int switch_table_128;
1008   int switch_table_256;
1009
1010   /* Walk thru the section looking for relaxation opportunities.  */
1011   for (irel = misc->irelbase; irel < irelend; irel++)
1012     {
1013       if (ELF32_R_TYPE (irel->r_info) != (int) R_IP2K_PAGE3)
1014         /* Ignore non page instructions.  */
1015         continue;
1016
1017       if (BASEADDR (sec) + irel->r_offset < page_start)
1018         /* Ignore page instructions on earlier page - they have
1019            already been processed. Remember that there is code flow
1020            that crosses a page boundary.  */
1021         continue;
1022
1023       if (BASEADDR (sec) + irel->r_offset > page_end)
1024         /* Flow beyond end of page => nothing more to do for this page.  */
1025         return TRUE;
1026
1027       /* Detect switch tables.  */
1028       switch_table_128 = ip2k_is_switch_table_128 (abfd, sec, irel->r_offset, misc->contents);
1029       switch_table_256 = ip2k_is_switch_table_256 (abfd, sec, irel->r_offset, misc->contents);
1030
1031       if ((switch_table_128 > 0) || (switch_table_256 > 0))
1032         /* If the index is greater than 0 then it has already been processed.  */
1033         continue;
1034
1035       if (switch_table_128 == 0)
1036         {
1037           if (!ip2k_relax_switch_table_128 (abfd, sec, irel, again, misc))
1038             return FALSE;
1039
1040           continue;
1041         }
1042
1043       if (switch_table_256 == 0)
1044         {
1045           if (!ip2k_relax_switch_table_256 (abfd, sec, irel, again, misc))
1046             return FALSE;
1047
1048           continue;
1049         }
1050
1051       /* Simple relax.  */
1052       if (ip2k_test_page_insn (abfd, sec, irel, misc))
1053         {
1054           if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
1055             return FALSE;
1056
1057           continue;
1058         }
1059     }
1060
1061   return TRUE;
1062 }
1063
1064 /* Parts of a Stabs entry.  */
1065
1066 #define STRDXOFF  (0)
1067 #define TYPEOFF   (4)
1068 #define OTHEROFF  (5)
1069 #define DESCOFF   (6)
1070 #define VALOFF    (8)
1071 #define STABSIZE  (12)
1072
1073 /* Adjust all the relocations entries after adding or inserting instructions.  */
1074
1075 static void
1076 adjust_all_relocations (abfd, sec, addr, endaddr, count, noadj)
1077      bfd *abfd;
1078      asection *sec;
1079      bfd_vma addr;
1080      bfd_vma endaddr;
1081      int count;
1082      int noadj;
1083 {
1084   Elf_Internal_Shdr *symtab_hdr;
1085   Elf_Internal_Sym *isymbuf, *isym, *isymend;
1086   unsigned int shndx;
1087   bfd_byte *contents;
1088   Elf_Internal_Rela *irel, *irelend, *irelbase;
1089   struct elf_link_hash_entry **sym_hashes;
1090   struct elf_link_hash_entry **end_hashes;
1091   unsigned int symcount;
1092   asection *stab;
1093
1094   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1095   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1096
1097   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1098
1099   contents = elf_section_data (sec)->this_hdr.contents;
1100
1101   irelbase = elf_section_data (sec)->relocs;
1102   irelend = irelbase + sec->reloc_count;
1103
1104   for (irel = irelbase; irel < irelend; irel++)
1105     {
1106       if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
1107         {
1108           /* Get the value of the symbol referred to by the reloc.  */
1109           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1110             {
1111               asection *sym_sec;
1112
1113               /* A local symbol.  */
1114               isym = isymbuf + ELF32_R_SYM (irel->r_info);
1115               sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1116
1117               if (isym->st_shndx == shndx)
1118                 {
1119                   bfd_vma baseaddr = BASEADDR (sec);
1120                   bfd_vma symval = BASEADDR (sym_sec) + isym->st_value
1121                                    + irel->r_addend;
1122
1123                   if ((baseaddr + addr + noadj) <= symval
1124                       && symval < (baseaddr + endaddr))
1125                     irel->r_addend += count;
1126                 }
1127             }
1128         }
1129
1130       /* Do this only for PC space relocations.  */
1131       if (addr <= irel->r_offset && irel->r_offset < endaddr)
1132         irel->r_offset += count;
1133     }
1134
1135   /* Now fix the stab relocations.  */
1136   stab = bfd_get_section_by_name (abfd, ".stab");
1137   if (stab)
1138     {
1139       bfd_byte *stabcontents, *stabend, *stabp;
1140
1141       irelbase = elf_section_data (stab)->relocs;
1142       irelend = irelbase + stab->reloc_count;
1143
1144       /* Pull out the contents of the stab section.  */
1145       if (elf_section_data (stab)->this_hdr.contents != NULL)
1146         stabcontents = elf_section_data (stab)->this_hdr.contents;
1147       else
1148         {
1149           stabcontents = (bfd_byte *) bfd_alloc (abfd, stab->_raw_size);
1150           if (stabcontents == NULL)
1151             return;
1152
1153           if (! bfd_get_section_contents (abfd, stab, stabcontents,
1154                                           (file_ptr) 0, stab->_raw_size))
1155             return;
1156
1157           /* We need to remember this.  */
1158           elf_section_data (stab)->this_hdr.contents = stabcontents;
1159         }
1160
1161       stabend = stabcontents + stab->_raw_size;
1162
1163       for (irel = irelbase; irel < irelend; irel++)
1164         {
1165           if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
1166             {
1167               /* Get the value of the symbol referred to by the reloc.  */
1168               if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1169                 {
1170                   asection *sym_sec;
1171
1172                   /* A local symbol.  */
1173                   isym = isymbuf + ELF32_R_SYM (irel->r_info);
1174                   sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1175
1176                   if (sym_sec == sec)
1177                     {
1178                       const char *name;
1179                       unsigned long strx;
1180                       unsigned char type, other;
1181                       unsigned short desc;
1182                       bfd_vma value;
1183                       bfd_vma baseaddr = BASEADDR (sec);
1184                       bfd_vma symval = BASEADDR (sym_sec) + isym->st_value
1185                         + irel->r_addend;
1186
1187                       if ((baseaddr + addr) <= symval
1188                           && symval <= (baseaddr + endaddr))
1189                         irel->r_addend += count;
1190
1191                       /* Go hunt up a function and fix its line info if needed.  */
1192                       stabp = stabcontents + irel->r_offset - 8;
1193
1194                       /* Go pullout the stab entry.  */
1195                       strx  = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1196                       type  = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1197                       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1198                       desc  = bfd_h_get_16 (abfd, stabp + DESCOFF);
1199                       value = bfd_h_get_32 (abfd, stabp + VALOFF);
1200
1201                       name = bfd_get_stab_name (type);
1202
1203                       if (strcmp (name, "FUN") == 0)
1204                         {
1205                           int function_adjusted = 0;
1206
1207                           if (symval > (baseaddr + addr))
1208                             /* Not in this function.  */
1209                             continue;
1210
1211                           /* Hey we got a function hit.  */
1212                           stabp += STABSIZE;
1213                           for (;stabp < stabend; stabp += STABSIZE)
1214                             {
1215                               /* Go pullout the stab entry.  */
1216                               strx  = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1217                               type  = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1218                               other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1219                               desc  = bfd_h_get_16 (abfd, stabp + DESCOFF);
1220                               value = bfd_h_get_32 (abfd, stabp + VALOFF);
1221
1222                               name = bfd_get_stab_name (type);
1223
1224                               if (strcmp (name, "FUN") == 0)
1225                                 {
1226                                   /* Hit another function entry.  */
1227                                   if (function_adjusted)
1228                                     {
1229                                       /* Adjust the value.  */
1230                                       value += count;
1231
1232                                       /* We need to put it back.  */
1233                                       bfd_h_put_32 (abfd, value,stabp + VALOFF);
1234                                     }
1235
1236                                   /* And then bale out.  */
1237                                   break;
1238                                 }
1239
1240                               if (strcmp (name, "SLINE") == 0)
1241                                 {
1242                                   /* Got a line entry.  */
1243                                   if ((baseaddr + addr) <= (symval + value))
1244                                     {
1245                                       /* Adjust the line entry.  */
1246                                       value += count;
1247
1248                                       /* We need to put it back.  */
1249                                       bfd_h_put_32 (abfd, value,stabp + VALOFF);
1250                                       function_adjusted = 1;
1251                                     }
1252                                 }
1253                             }
1254                         }
1255                     }
1256                 }
1257             }
1258         }
1259     }
1260
1261   /* When adding an instruction back it is sometimes necessary to move any
1262      global or local symbol that was referencing the first instruction of
1263      the moved block to refer to the first instruction of the inserted block.
1264
1265      For example adding a PAGE instruction before a CALL or JMP requires
1266      that any label on the CALL or JMP is moved to the PAGE insn.  */
1267   addr += noadj;
1268
1269   /* Adjust the local symbols defined in this section.  */
1270   isymend = isymbuf + symtab_hdr->sh_info;
1271   for (isym = isymbuf; isym < isymend; isym++)
1272     {
1273       if (isym->st_shndx == shndx
1274           && addr <= isym->st_value
1275           && isym->st_value < endaddr)
1276         isym->st_value += count;
1277     }
1278
1279     /* Now adjust the global symbols defined in this section.  */
1280   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1281               - symtab_hdr->sh_info);
1282   sym_hashes = elf_sym_hashes (abfd);
1283   end_hashes = sym_hashes + symcount;
1284   for (; sym_hashes < end_hashes; sym_hashes++)
1285     {
1286       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1287
1288       if ((sym_hash->root.type == bfd_link_hash_defined
1289            || sym_hash->root.type == bfd_link_hash_defweak)
1290           && sym_hash->root.u.def.section == sec)
1291         {
1292           if (addr <= sym_hash->root.u.def.value
1293               && sym_hash->root.u.def.value < endaddr)
1294             sym_hash->root.u.def.value += count;
1295         }
1296     }
1297
1298   return;
1299 }
1300
1301 /* Delete some bytes from a section while relaxing.  */
1302
1303 static bfd_boolean
1304 ip2k_elf_relax_delete_bytes (abfd, sec, addr, count)
1305      bfd *abfd;
1306      asection *sec;
1307      bfd_vma addr;
1308      int count;
1309 {
1310   bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
1311   bfd_vma endaddr = sec->_cooked_size;
1312
1313   /* Actually delete the bytes.  */
1314   memmove (contents + addr, contents + addr + count,
1315            endaddr - addr - count);
1316
1317   sec->_cooked_size -= count;
1318
1319   adjust_all_relocations (abfd, sec, addr + count, endaddr, -count, 0);
1320   return TRUE;
1321 }
1322
1323 /* -------------------------------------------------------------------- */
1324
1325 /* XXX: The following code is the result of a cut&paste.  This unfortunate
1326    practice is very widespread in the various target back-end files.  */
1327
1328 /* Set the howto pointer for a IP2K ELF reloc.  */
1329
1330 static void
1331 ip2k_info_to_howto_rela (abfd, cache_ptr, dst)
1332      bfd * abfd ATTRIBUTE_UNUSED;
1333      arelent * cache_ptr;
1334      Elf_Internal_Rela * dst;
1335 {
1336   unsigned int r_type;
1337
1338   r_type = ELF32_R_TYPE (dst->r_info);
1339   switch (r_type)
1340     {
1341     default:
1342       cache_ptr->howto = & ip2k_elf_howto_table [r_type];
1343       break;
1344     }
1345 }
1346
1347 /* Perform a single relocation.
1348    By default we use the standard BFD routines.  */
1349
1350 static bfd_reloc_status_type
1351 ip2k_final_link_relocate (howto, input_bfd, input_section, contents, rel,
1352                           relocation)
1353      reloc_howto_type *  howto;
1354      bfd *               input_bfd;
1355      asection *          input_section;
1356      bfd_byte *          contents;
1357      Elf_Internal_Rela * rel;
1358      bfd_vma             relocation;
1359 {
1360   static bfd_vma page_addr = 0;
1361
1362   bfd_reloc_status_type r = bfd_reloc_ok;
1363   switch (howto->type)
1364     {
1365       /* Handle data space relocations.  */
1366     case R_IP2K_FR9:
1367     case R_IP2K_BANK:
1368       if ((relocation & IP2K_DATA_MASK) == IP2K_DATA_VALUE)
1369         relocation &= ~IP2K_DATA_MASK;
1370       else
1371         r = bfd_reloc_notsupported;
1372       break;
1373
1374     case R_IP2K_LO8DATA:
1375     case R_IP2K_HI8DATA:
1376     case R_IP2K_EX8DATA:
1377       break;
1378
1379       /* Handle insn space relocations.  */
1380     case R_IP2K_PAGE3:
1381       page_addr = BASEADDR (input_section) + rel->r_offset;
1382       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1383         relocation &= ~IP2K_INSN_MASK;
1384       else
1385         r = bfd_reloc_notsupported;
1386       break;
1387
1388     case R_IP2K_ADDR16CJP:
1389       if (BASEADDR (input_section) + rel->r_offset != page_addr + 2)
1390         {
1391           /* No preceding page instruction, verify that it isn't needed.  */
1392           if (PAGENO (relocation + rel->r_addend) !=
1393               ip2k_nominal_page_bits (input_bfd, input_section,
1394                                       rel->r_offset, contents))
1395             _bfd_error_handler (_("ip2k linker: missing page instruction at 0x%08lx (dest = 0x%08lx)."),
1396                                 BASEADDR (input_section) + rel->r_offset,
1397                                 relocation + rel->r_addend);
1398         }
1399       else if (ip2k_relaxed)
1400         {
1401           /* Preceding page instruction. Verify that the page instruction is
1402              really needed. One reason for the relaxation to miss a page is if
1403              the section is not marked as executable.  */
1404           if (!ip2k_is_switch_table_128 (input_bfd, input_section, rel->r_offset - 2, contents) &&
1405               !ip2k_is_switch_table_256 (input_bfd, input_section, rel->r_offset - 2, contents) &&
1406               (PAGENO (relocation + rel->r_addend) ==
1407                ip2k_nominal_page_bits (input_bfd, input_section,
1408                                       rel->r_offset - 2, contents)))
1409             _bfd_error_handler (_("ip2k linker: redundant page instruction at 0x%08lx (dest = 0x%08lx)."),
1410                                 page_addr,
1411                                 relocation + rel->r_addend);
1412         }
1413       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1414         relocation &= ~IP2K_INSN_MASK;
1415       else
1416         r = bfd_reloc_notsupported;
1417       break;
1418
1419     case R_IP2K_LO8INSN:
1420     case R_IP2K_HI8INSN:
1421     case R_IP2K_PC_SKIP:
1422       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1423         relocation &= ~IP2K_INSN_MASK;
1424       else
1425         r = bfd_reloc_notsupported;
1426       break;
1427
1428     case R_IP2K_16:
1429       /* If this is a relocation involving a TEXT
1430          symbol, reduce it to a word address.  */
1431       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1432         howto = &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
1433       break;
1434
1435       /* Pass others through.  */
1436     default:
1437       break;
1438     }
1439
1440   /* Only install relocation if above tests did not disqualify it.  */
1441   if (r == bfd_reloc_ok)
1442     r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1443                                   contents, rel->r_offset,
1444                                   relocation, rel->r_addend);
1445
1446   return r;
1447 }
1448
1449 /* Relocate a IP2K ELF section.
1450
1451    The RELOCATE_SECTION function is called by the new ELF backend linker
1452    to handle the relocations for a section.
1453
1454    The relocs are always passed as Rela structures; if the section
1455    actually uses Rel structures, the r_addend field will always be
1456    zero.
1457
1458    This function is responsible for adjusting the section contents as
1459    necessary, and (if using Rela relocs and generating a relocatable
1460    output file) adjusting the reloc addend as necessary.
1461
1462    This function does not have to worry about setting the reloc
1463    address or the reloc symbol index.
1464
1465    LOCAL_SYMS is a pointer to the swapped in local symbols.
1466
1467    LOCAL_SECTIONS is an array giving the section in the input file
1468    corresponding to the st_shndx field of each local symbol.
1469
1470    The global hash table entry for the global symbols can be found
1471    via elf_sym_hashes (input_bfd).
1472
1473    When generating relocatable output, this function must handle
1474    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1475    going to be the section symbol corresponding to the output
1476    section, which means that the addend must be adjusted
1477    accordingly.  */
1478
1479 static bfd_boolean
1480 ip2k_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1481                            contents, relocs, local_syms, local_sections)
1482      bfd *output_bfd ATTRIBUTE_UNUSED;
1483      struct bfd_link_info *info;
1484      bfd *input_bfd;
1485      asection *input_section;
1486      bfd_byte *contents;
1487      Elf_Internal_Rela *relocs;
1488      Elf_Internal_Sym *local_syms;
1489      asection **local_sections;
1490 {
1491   Elf_Internal_Shdr *symtab_hdr;
1492   struct elf_link_hash_entry **sym_hashes;
1493   Elf_Internal_Rela *rel;
1494   Elf_Internal_Rela *relend;
1495
1496   if (info->relocatable)
1497     return TRUE;
1498
1499   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1500   sym_hashes = elf_sym_hashes (input_bfd);
1501   relend     = relocs + input_section->reloc_count;
1502
1503   for (rel = relocs; rel < relend; rel ++)
1504     {
1505       reloc_howto_type *           howto;
1506       unsigned long                r_symndx;
1507       Elf_Internal_Sym *           sym;
1508       asection *                   sec;
1509       struct elf_link_hash_entry * h;
1510       bfd_vma                      relocation;
1511       bfd_reloc_status_type        r;
1512       const char *                 name = NULL;
1513       int                          r_type;
1514
1515       /* This is a final link.  */
1516       r_type = ELF32_R_TYPE (rel->r_info);
1517       r_symndx = ELF32_R_SYM (rel->r_info);
1518       howto  = ip2k_elf_howto_table + ELF32_R_TYPE (rel->r_info);
1519       h      = NULL;
1520       sym    = NULL;
1521       sec    = NULL;
1522
1523       if (r_symndx < symtab_hdr->sh_info)
1524         {
1525           sym = local_syms + r_symndx;
1526           sec = local_sections [r_symndx];
1527           relocation = BASEADDR (sec) + sym->st_value;
1528
1529           name = bfd_elf_string_from_elf_section
1530             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1531           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1532         }
1533       else
1534         {
1535           bfd_boolean warned;
1536           bfd_boolean unresolved_reloc;
1537
1538           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1539                                    r_symndx, symtab_hdr, sym_hashes,
1540                                    h, sec, relocation,
1541                                    unresolved_reloc, warned);
1542
1543           name = h->root.root.string;
1544         }
1545
1546       /* Finally, the sole IP2K-specific part.  */
1547       r = ip2k_final_link_relocate (howto, input_bfd, input_section,
1548                                      contents, rel, relocation);
1549
1550       if (r != bfd_reloc_ok)
1551         {
1552           const char * msg = (const char *) NULL;
1553
1554           switch (r)
1555             {
1556             case bfd_reloc_overflow:
1557               r = info->callbacks->reloc_overflow
1558                 (info, name, howto->name, (bfd_vma) 0,
1559                  input_bfd, input_section, rel->r_offset);
1560               break;
1561
1562             case bfd_reloc_undefined:
1563               r = info->callbacks->undefined_symbol
1564                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1565               break;
1566
1567             case bfd_reloc_outofrange:
1568               msg = _("internal error: out of range error");
1569               break;
1570
1571               /* This is how ip2k_final_link_relocate tells us of a non-kosher
1572                  reference between insn & data address spaces.  */
1573             case bfd_reloc_notsupported:
1574               if (sym != NULL) /* Only if it's not an unresolved symbol.  */
1575                  msg = _("unsupported relocation between data/insn address spaces");
1576               break;
1577
1578             case bfd_reloc_dangerous:
1579               msg = _("internal error: dangerous relocation");
1580               break;
1581
1582             default:
1583               msg = _("internal error: unknown error");
1584               break;
1585             }
1586
1587           if (msg)
1588             r = info->callbacks->warning
1589               (info, msg, name, input_bfd, input_section, rel->r_offset);
1590
1591           if (! r)
1592             return FALSE;
1593         }
1594     }
1595
1596   return TRUE;
1597 }
1598
1599 static asection *
1600 ip2k_elf_gc_mark_hook (sec, info, rel, h, sym)
1601      asection *sec;
1602      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1603      Elf_Internal_Rela *rel;
1604      struct elf_link_hash_entry *h;
1605      Elf_Internal_Sym *sym;
1606 {
1607   if (h != NULL)
1608     {
1609       switch (ELF32_R_TYPE (rel->r_info))
1610       {
1611 #if 0
1612       case R_IP2K_GNU_VTINHERIT:
1613       case R_IP2K_GNU_VTENTRY:
1614         break;
1615 #endif
1616
1617       default:
1618         switch (h->root.type)
1619           {
1620           case bfd_link_hash_defined:
1621           case bfd_link_hash_defweak:
1622             return h->root.u.def.section;
1623
1624           case bfd_link_hash_common:
1625             return h->root.u.c.p->section;
1626
1627           default:
1628             break;
1629           }
1630        }
1631      }
1632    else
1633      {
1634        if (!(elf_bad_symtab (sec->owner)
1635              && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1636            && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1637                  && sym->st_shndx != SHN_COMMON))
1638          return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1639       }
1640   return NULL;
1641 }
1642
1643 static bfd_boolean
1644 ip2k_elf_gc_sweep_hook (abfd, info, sec, relocs)
1645      bfd *abfd ATTRIBUTE_UNUSED;
1646      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1647      asection *sec ATTRIBUTE_UNUSED;
1648      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1649 {
1650   /* We don't use got and plt entries for ip2k.  */
1651   return TRUE;
1652 }
1653
1654 #define TARGET_BIG_SYM   bfd_elf32_ip2k_vec
1655 #define TARGET_BIG_NAME  "elf32-ip2k"
1656
1657 #define ELF_ARCH         bfd_arch_ip2k
1658 #define ELF_MACHINE_CODE EM_IP2K
1659 #define ELF_MACHINE_ALT1 EM_IP2K_OLD
1660 #define ELF_MAXPAGESIZE  1 /* No pages on the IP2K.  */
1661
1662 #define elf_info_to_howto_rel                   NULL
1663 #define elf_info_to_howto                       ip2k_info_to_howto_rela
1664
1665 #define elf_backend_can_gc_sections             1
1666 #define elf_backend_rela_normal                 1
1667 #define elf_backend_gc_mark_hook                ip2k_elf_gc_mark_hook
1668 #define elf_backend_gc_sweep_hook               ip2k_elf_gc_sweep_hook
1669 #define elf_backend_relocate_section            ip2k_elf_relocate_section
1670
1671 #define elf_symbol_leading_char                 '_'
1672 #define bfd_elf32_bfd_reloc_type_lookup         ip2k_reloc_type_lookup
1673 #define bfd_elf32_bfd_relax_section             ip2k_elf_relax_section
1674
1675 #include "elf32-target.h"