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