bfd/elf32-ip2k.c

   1 /* Ubicom IP2xxx specific support for 32-bit ELF
   2    Copyright (C) 2000-2014 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,2,32, 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 (link_info->relocatable
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   cache_ptr->howto = & ip2k_elf_howto_table [r_type];
1243 }
1244
1245 /* Perform a single relocation.
1246    By default we use the standard BFD routines.  */
1247
1248 static bfd_reloc_status_type
1249 ip2k_final_link_relocate (reloc_howto_type *  howto,
1250                           bfd *               input_bfd,
1251                           asection *          input_section,
1252                           bfd_byte *          contents,
1253                           Elf_Internal_Rela * rel,
1254                           bfd_vma             relocation)
1255 {
1256   static bfd_vma page_addr = 0;
1257
1258   bfd_reloc_status_type r = bfd_reloc_ok;
1259   switch (howto->type)
1260     {
1261       /* Handle data space relocations.  */
1262     case R_IP2K_FR9:
1263     case R_IP2K_BANK:
1264       if ((relocation & IP2K_DATA_MASK) == IP2K_DATA_VALUE)
1265         relocation &= ~IP2K_DATA_MASK;
1266       else
1267         r = bfd_reloc_notsupported;
1268       break;
1269
1270     case R_IP2K_LO8DATA:
1271     case R_IP2K_HI8DATA:
1272     case R_IP2K_EX8DATA:
1273       break;
1274
1275       /* Handle insn space relocations.  */
1276     case R_IP2K_PAGE3:
1277       page_addr = BASEADDR (input_section) + rel->r_offset;
1278       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1279         relocation &= ~IP2K_INSN_MASK;
1280       else
1281         r = bfd_reloc_notsupported;
1282       break;
1283
1284     case R_IP2K_ADDR16CJP:
1285       if (BASEADDR (input_section) + rel->r_offset != page_addr + 2)
1286         {
1287           /* No preceding page instruction, verify that it isn't needed.  */
1288           if (PAGENO (relocation + rel->r_addend) !=
1289               ip2k_nominal_page_bits (input_bfd, input_section,
1290                                       rel->r_offset, contents))
1291             _bfd_error_handler (_("ip2k linker: missing page instruction at 0x%08lx (dest = 0x%08lx)."),
1292                                 BASEADDR (input_section) + rel->r_offset,
1293                                 relocation + rel->r_addend);
1294         }
1295       else if (ip2k_relaxed)
1296         {
1297           /* Preceding page instruction. Verify that the page instruction is
1298              really needed. One reason for the relaxation to miss a page is if
1299              the section is not marked as executable.  */
1300           if (!ip2k_is_switch_table_128 (input_bfd, input_section,
1301                                          rel->r_offset - 2, contents)
1302               && !ip2k_is_switch_table_256 (input_bfd, input_section,
1303                                             rel->r_offset - 2, contents)
1304               && (PAGENO (relocation + rel->r_addend) ==
1305                   ip2k_nominal_page_bits (input_bfd, input_section,
1306                                           rel->r_offset - 2, contents)))
1307             _bfd_error_handler (_("ip2k linker: redundant page instruction at 0x%08lx (dest = 0x%08lx)."),
1308                                 page_addr,
1309                                 relocation + rel->r_addend);
1310         }
1311       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1312         relocation &= ~IP2K_INSN_MASK;
1313       else
1314         r = bfd_reloc_notsupported;
1315       break;
1316
1317     case R_IP2K_LO8INSN:
1318     case R_IP2K_HI8INSN:
1319     case R_IP2K_PC_SKIP:
1320       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1321         relocation &= ~IP2K_INSN_MASK;
1322       else
1323         r = bfd_reloc_notsupported;
1324       break;
1325
1326     case R_IP2K_16:
1327       /* If this is a relocation involving a TEXT
1328          symbol, reduce it to a word address.  */
1329       if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1330         howto = &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
1331       break;
1332
1333       /* Pass others through.  */
1334     default:
1335       break;
1336     }
1337
1338   /* Only install relocation if above tests did not disqualify it.  */
1339   if (r == bfd_reloc_ok)
1340     r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1341                                   contents, rel->r_offset,
1342                                   relocation, rel->r_addend);
1343
1344   return r;
1345 }
1346
1347 /* Relocate a IP2K ELF section.
1348
1349    The RELOCATE_SECTION function is called by the new ELF backend linker
1350    to handle the relocations for a section.
1351
1352    The relocs are always passed as Rela structures; if the section
1353    actually uses Rel structures, the r_addend field will always be
1354    zero.
1355
1356    This function is responsible for adjusting the section contents as
1357    necessary, and (if using Rela relocs and generating a relocatable
1358    output file) adjusting the reloc addend as necessary.
1359
1360    This function does not have to worry about setting the reloc
1361    address or the reloc symbol index.
1362
1363    LOCAL_SYMS is a pointer to the swapped in local symbols.
1364
1365    LOCAL_SECTIONS is an array giving the section in the input file
1366    corresponding to the st_shndx field of each local symbol.
1367
1368    The global hash table entry for the global symbols can be found
1369    via elf_sym_hashes (input_bfd).
1370
1371    When generating relocatable output, this function must handle
1372    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1373    going to be the section symbol corresponding to the output
1374    section, which means that the addend must be adjusted
1375    accordingly.  */
1376
1377 static bfd_boolean
1378 ip2k_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1379                            struct bfd_link_info *info,
1380                            bfd *input_bfd,
1381                            asection *input_section,
1382                            bfd_byte *contents,
1383                            Elf_Internal_Rela *relocs,
1384                            Elf_Internal_Sym *local_syms,
1385                            asection **local_sections)
1386 {
1387   Elf_Internal_Shdr *symtab_hdr;
1388   struct elf_link_hash_entry **sym_hashes;
1389   Elf_Internal_Rela *rel;
1390   Elf_Internal_Rela *relend;
1391
1392   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1393   sym_hashes = elf_sym_hashes (input_bfd);
1394   relend     = relocs + input_section->reloc_count;
1395
1396   for (rel = relocs; rel < relend; rel ++)
1397     {
1398       reloc_howto_type *           howto;
1399       unsigned long                r_symndx;
1400       Elf_Internal_Sym *           sym;
1401       asection *                   sec;
1402       struct elf_link_hash_entry * h;
1403       bfd_vma                      relocation;
1404       bfd_reloc_status_type        r;
1405       const char *                 name = NULL;
1406       int                          r_type;
1407
1408       r_type = ELF32_R_TYPE (rel->r_info);
1409       r_symndx = ELF32_R_SYM (rel->r_info);
1410       howto  = ip2k_elf_howto_table + r_type;
1411       h      = NULL;
1412       sym    = NULL;
1413       sec    = NULL;
1414
1415       if (r_symndx < symtab_hdr->sh_info)
1416         {
1417           sym = local_syms + r_symndx;
1418           sec = local_sections [r_symndx];
1419           relocation = BASEADDR (sec) + sym->st_value;
1420
1421           name = bfd_elf_string_from_elf_section
1422             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1423           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1424         }
1425       else
1426         {
1427           bfd_boolean warned, ignored;
1428           bfd_boolean unresolved_reloc;
1429
1430           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1431                                    r_symndx, symtab_hdr, sym_hashes,
1432                                    h, sec, relocation,
1433                                    unresolved_reloc, warned, ignored);
1434
1435           name = h->root.root.string;
1436         }
1437
1438       if (sec != NULL && discarded_section (sec))
1439         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1440                                          rel, 1, relend, howto, 0, contents);
1441
1442       if (info->relocatable)
1443         continue;
1444
1445       /* Finally, the sole IP2K-specific part.  */
1446       r = ip2k_final_link_relocate (howto, input_bfd, input_section,
1447                                      contents, rel, relocation);
1448
1449       if (r != bfd_reloc_ok)
1450         {
1451           const char * msg = NULL;
1452
1453           switch (r)
1454             {
1455             case bfd_reloc_overflow:
1456               r = info->callbacks->reloc_overflow
1457                 (info, (h ? &h->root : NULL), name, howto->name,
1458                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1459               break;
1460
1461             case bfd_reloc_undefined:
1462               r = info->callbacks->undefined_symbol
1463                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1464               break;
1465
1466             case bfd_reloc_outofrange:
1467               msg = _("internal error: out of range error");
1468               break;
1469
1470               /* This is how ip2k_final_link_relocate tells us of a non-kosher
1471                  reference between insn & data address spaces.  */
1472             case bfd_reloc_notsupported:
1473               if (sym != NULL) /* Only if it's not an unresolved symbol.  */
1474                  msg = _("unsupported relocation between data/insn address spaces");
1475               break;
1476
1477             case bfd_reloc_dangerous:
1478               msg = _("internal error: dangerous relocation");
1479               break;
1480
1481             default:
1482               msg = _("internal error: unknown error");
1483               break;
1484             }
1485
1486           if (msg)
1487             r = info->callbacks->warning
1488               (info, msg, name, input_bfd, input_section, rel->r_offset);
1489
1490           if (! r)
1491             return FALSE;
1492         }
1493     }
1494
1495   return TRUE;
1496 }
1497
1498 #define TARGET_BIG_SYM   ip2k_elf32_vec
1499 #define TARGET_BIG_NAME  "elf32-ip2k"
1500
1501 #define ELF_ARCH         bfd_arch_ip2k
1502 #define ELF_MACHINE_CODE EM_IP2K
1503 #define ELF_MACHINE_ALT1 EM_IP2K_OLD
1504 #define ELF_MAXPAGESIZE  1 /* No pages on the IP2K.  */
1505
1506 #define elf_info_to_howto_rel                   NULL
1507 #define elf_info_to_howto                       ip2k_info_to_howto_rela
1508
1509 #define elf_backend_can_gc_sections             1
1510 #define elf_backend_rela_normal                 1
1511 #define elf_backend_relocate_section            ip2k_elf_relocate_section
1512
1513 #define elf_symbol_leading_char                 '_'
1514 #define bfd_elf32_bfd_reloc_type_lookup         ip2k_reloc_type_lookup
1515 #define bfd_elf32_bfd_reloc_name_lookup ip2k_reloc_name_lookup
1516 #define bfd_elf32_bfd_relax_section             ip2k_elf_relax_section
1517
1518 #include "elf32-target.h"