bfd/elf32-ip2k.c

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