* config.sub, config.guess: Update from upstream sources.
[binutils.git] / bfd / elf32-ip2k.c
blob96d0cd5ba900e5514a7448c0565a8014d15cb8b1
1 /* Ubicom IP2xxx specific support for 32-bit ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/ip2k.h"
28 /* Struct used to pass miscellaneous paramaters which
29 helps to avoid overly long parameter lists. */
30 struct misc
32 Elf_Internal_Shdr * symtab_hdr;
33 Elf_Internal_Rela * irelbase;
34 bfd_byte * contents;
35 Elf_Internal_Sym * isymbuf;
38 struct ip2k_opcode
40 unsigned short opcode;
41 unsigned short mask;
44 static bfd_boolean ip2k_relaxed = FALSE;
46 static const struct ip2k_opcode ip2k_page_opcode[] =
48 {0x0010, 0xFFF8}, /* Page. */
49 {0x0000, 0x0000},
52 #define IS_PAGE_OPCODE(code) \
53 ip2k_is_opcode (code, ip2k_page_opcode)
55 static const struct ip2k_opcode ip2k_jmp_opcode[] =
57 {0xE000, 0xE000}, /* Jmp. */
58 {0x0000, 0x0000},
61 #define IS_JMP_OPCODE(code) \
62 ip2k_is_opcode (code, ip2k_jmp_opcode)
64 static const struct ip2k_opcode ip2k_snc_opcode[] =
66 {0xA00B, 0xFFFF}, /* Snc. */
67 {0x0000, 0x0000},
70 #define IS_SNC_OPCODE(code) \
71 ip2k_is_opcode (code, ip2k_snc_opcode)
73 static const struct ip2k_opcode ip2k_inc_1sp_opcode[] =
75 {0x2B81, 0xFFFF}, /* Inc 1(SP). */
76 {0x0000, 0x0000},
79 #define IS_INC_1SP_OPCODE(code) \
80 ip2k_is_opcode (code, ip2k_inc_1sp_opcode)
82 static const struct ip2k_opcode ip2k_add_2sp_w_opcode[] =
84 {0x1F82, 0xFFFF}, /* Add 2(SP),w. */
85 {0x0000, 0x0000},
88 #define IS_ADD_2SP_W_OPCODE(code) \
89 ip2k_is_opcode (code, ip2k_add_2sp_w_opcode)
91 static const struct ip2k_opcode ip2k_add_w_wreg_opcode[] =
93 {0x1C0A, 0xFFFF}, /* Add w,wreg. */
94 {0x1E0A, 0xFFFF}, /* Add wreg,w. */
95 {0x0000, 0x0000},
98 #define IS_ADD_W_WREG_OPCODE(code) \
99 ip2k_is_opcode (code, ip2k_add_w_wreg_opcode)
101 static const struct ip2k_opcode ip2k_add_pcl_w_opcode[] =
103 {0x1E09, 0xFFFF}, /* Add pcl,w. */
104 {0x0000, 0x0000},
107 #define IS_ADD_PCL_W_OPCODE(code) \
108 ip2k_is_opcode (code, ip2k_add_pcl_w_opcode)
110 static const struct ip2k_opcode ip2k_skip_opcodes[] =
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},
123 #define IS_SKIP_OPCODE(code) \
124 ip2k_is_opcode (code, ip2k_skip_opcodes)
126 /* Relocation tables. */
127 static reloc_howto_type ip2k_elf_howto_table [] =
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 */
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),
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),
176 /* Map BFD reloc types to IP2K ELF reloc types. */
178 static reloc_howto_type *
179 ip2k_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
180 bfd_reloc_code_real_type code)
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. */
187 switch (code)
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;
223 return NULL;
226 static reloc_howto_type *
227 ip2k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
229 unsigned int i;
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];
238 return NULL;
241 static void
242 ip2k_get_mem (bfd *abfd ATTRIBUTE_UNUSED,
243 bfd_byte *addr,
244 int length,
245 bfd_byte *ptr)
247 while (length --)
248 * ptr ++ = bfd_get_8 (abfd, addr ++);
251 static bfd_boolean
252 ip2k_is_opcode (bfd_byte *code, const struct ip2k_opcode *opcodes)
254 unsigned short insn = (code[0] << 8) | code[1];
256 while (opcodes->mask != 0)
258 if ((insn & opcodes->mask) == opcodes->opcode)
259 return TRUE;
261 opcodes ++;
264 return FALSE;
267 #define PAGENO(ABSADDR) ((ABSADDR) & 0xFFFFC000)
268 #define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset)
270 #define UNDEFINED_SYMBOL (~(bfd_vma)0)
272 /* Return the value of the symbol associated with the relocation IREL. */
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)
280 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
282 Elf_Internal_Sym *isym;
283 asection *sym_sec;
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);
295 return isym->st_value + BASEADDR (sym_sec);
297 else
299 unsigned long indx;
300 struct elf_link_hash_entry *h;
302 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
303 h = elf_sym_hashes (abfd)[indx];
304 BFD_ASSERT (h != NULL);
306 if (h->root.type != bfd_link_hash_defined
307 && h->root.type != bfd_link_hash_defweak)
308 return UNDEFINED_SYMBOL;
310 return (h->root.u.def.value + BASEADDR (h->root.u.def.section));
314 /* Determine if the instruction sequence matches that for
315 the prologue of a switch dispatch table with fewer than
316 128 entries.
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
329 page $nnnN
330 jmp $nnnN
332 After relaxation.
334 page $nnn0
335 jmp $nnn0
336 add pcl,w
337 addr=>
338 jmp $nnn1
339 jmp $nnn2
341 jmp $nnnN */
343 static int
344 ip2k_is_switch_table_128 (bfd *abfd ATTRIBUTE_UNUSED,
345 asection *sec,
346 bfd_vma addr,
347 bfd_byte *contents)
349 bfd_byte code[4];
350 int index = 0;
352 /* Check current page-jmp. */
353 if (addr + 4 > sec->size)
354 return -1;
356 ip2k_get_mem (abfd, contents + addr, 4, code);
358 if ((! IS_PAGE_OPCODE (code + 0))
359 || (! IS_JMP_OPCODE (code + 2)))
360 return -1;
362 /* Search back. */
363 while (1)
365 if (addr < 4)
366 return -1;
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 index;
374 if ((! IS_PAGE_OPCODE (code + 0))
375 || (! IS_JMP_OPCODE (code + 2)))
376 return -1;
378 index++;
379 addr -= 4;
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.
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
405 page $nnnN
406 jmp $nnnN
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
421 jmp $nnnN */
423 static int
424 ip2k_is_switch_table_256 (bfd *abfd ATTRIBUTE_UNUSED,
425 asection *sec,
426 bfd_vma addr,
427 bfd_byte *contents)
429 bfd_byte code[16];
430 int index = 0;
432 /* Check current page-jmp. */
433 if (addr + 4 > sec->size)
434 return -1;
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;
441 /* Search back. */
442 while (1)
444 if (addr < 16)
445 return -1;
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 index;
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 index;
468 if ((! IS_PAGE_OPCODE (code + 0))
469 || (! IS_JMP_OPCODE (code + 2)))
470 return -1;
472 index++;
473 addr -= 4;
477 /* Returns the expected page state for the given instruction not including
478 the effect of page instructions. */
480 static bfd_vma
481 ip2k_nominal_page_bits (bfd *abfd ATTRIBUTE_UNUSED,
482 asection *sec,
483 bfd_vma addr,
484 bfd_byte *contents)
486 bfd_vma page = PAGENO (BASEADDR (sec) + addr);
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;
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)
501 bfd_byte code[2];
503 addr -= 2;
504 ip2k_get_mem (abfd, contents + addr, 2, code);
505 if (!IS_PAGE_OPCODE (code))
506 continue;
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;
513 if (ip2k_is_switch_table_256 (abfd, sec, addr, contents) != -1)
514 /* Jump table => page is conditional. */
515 continue;
517 /* Found a page instruction, check if conditional. */
518 if (addr >= 2)
520 ip2k_get_mem (abfd, contents + addr - 2, 2, code);
521 if (IS_SKIP_OPCODE (code))
522 /* Page is conditional. */
523 continue;
526 /* Unconditional page instruction => page bits should be correct. */
527 return page;
530 /* Flow from previous page => page bits are impossible to determine. */
531 return 0;
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)
540 bfd_vma symval;
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;
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;
555 return TRUE;
558 /* Parts of a Stabs entry. */
560 #define STRDXOFF 0
561 #define TYPEOFF 4
562 #define OTHEROFF 5
563 #define DESCOFF 6
564 #define VALOFF 8
565 #define STABSIZE 12
567 /* Adjust all the relocations entries after adding or inserting instructions. */
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)
577 Elf_Internal_Shdr *symtab_hdr;
578 Elf_Internal_Sym *isymbuf, *isym, *isymend;
579 unsigned int shndx;
580 bfd_byte *contents;
581 Elf_Internal_Rela *irel, *irelend, *irelbase;
582 struct elf_link_hash_entry **sym_hashes;
583 struct elf_link_hash_entry **end_hashes;
584 unsigned int symcount;
585 asection *stab;
587 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
588 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
590 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
592 contents = elf_section_data (sec)->this_hdr.contents;
594 irelbase = elf_section_data (sec)->relocs;
595 irelend = irelbase + sec->reloc_count;
597 for (irel = irelbase; irel < irelend; irel++)
599 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
601 /* Get the value of the symbol referred to by the reloc. */
602 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
604 asection *sym_sec;
606 /* A local symbol. */
607 isym = isymbuf + ELF32_R_SYM (irel->r_info);
608 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
610 if (isym->st_shndx == shndx)
612 bfd_vma baseaddr = BASEADDR (sec);
613 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value
614 + irel->r_addend;
616 if ((baseaddr + addr + noadj) <= symval
617 && symval < (baseaddr + endaddr))
618 irel->r_addend += count;
623 /* Do this only for PC space relocations. */
624 if (addr <= irel->r_offset && irel->r_offset < endaddr)
625 irel->r_offset += count;
628 /* Now fix the stab relocations. */
629 stab = bfd_get_section_by_name (abfd, ".stab");
630 if (stab)
632 bfd_byte *stabcontents, *stabend, *stabp;
633 bfd_size_type stab_size = stab->rawsize ? stab->rawsize : stab->size;
635 irelbase = elf_section_data (stab)->relocs;
636 irelend = irelbase + stab->reloc_count;
638 /* Pull out the contents of the stab section. */
639 if (elf_section_data (stab)->this_hdr.contents != NULL)
640 stabcontents = elf_section_data (stab)->this_hdr.contents;
641 else
643 if (!bfd_malloc_and_get_section (abfd, stab, &stabcontents))
645 if (stabcontents != NULL)
646 free (stabcontents);
647 return;
650 /* We need to remember this. */
651 elf_section_data (stab)->this_hdr.contents = stabcontents;
654 stabend = stabcontents + stab_size;
656 for (irel = irelbase; irel < irelend; irel++)
658 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
660 /* Get the value of the symbol referred to by the reloc. */
661 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
663 asection *sym_sec;
665 /* A local symbol. */
666 isym = isymbuf + ELF32_R_SYM (irel->r_info);
667 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
669 if (sym_sec == sec)
671 const char *name;
672 unsigned long strx;
673 unsigned char type, other;
674 unsigned short desc;
675 bfd_vma value;
676 bfd_vma baseaddr = BASEADDR (sec);
677 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value
678 + irel->r_addend;
680 if ((baseaddr + addr) <= symval
681 && symval <= (baseaddr + endaddr))
682 irel->r_addend += count;
684 /* Go hunt up a function and fix its line info if needed. */
685 stabp = stabcontents + irel->r_offset - 8;
687 /* Go pullout the stab entry. */
688 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
689 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
690 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
691 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
692 value = bfd_h_get_32 (abfd, stabp + VALOFF);
694 name = bfd_get_stab_name (type);
696 if (strcmp (name, "FUN") == 0)
698 int function_adjusted = 0;
700 if (symval > (baseaddr + addr))
701 /* Not in this function. */
702 continue;
704 /* Hey we got a function hit. */
705 stabp += STABSIZE;
706 for (;stabp < stabend; stabp += STABSIZE)
708 /* Go pullout the stab entry. */
709 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
710 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
711 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
712 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
713 value = bfd_h_get_32 (abfd, stabp + VALOFF);
715 name = bfd_get_stab_name (type);
717 if (strcmp (name, "FUN") == 0)
719 /* Hit another function entry. */
720 if (function_adjusted)
722 /* Adjust the value. */
723 value += count;
725 /* We need to put it back. */
726 bfd_h_put_32 (abfd, value,stabp + VALOFF);
729 /* And then bale out. */
730 break;
733 if (strcmp (name, "SLINE") == 0)
735 /* Got a line entry. */
736 if ((baseaddr + addr) <= (symval + value))
738 /* Adjust the line entry. */
739 value += count;
741 /* We need to put it back. */
742 bfd_h_put_32 (abfd, value,stabp + VALOFF);
743 function_adjusted = 1;
754 /* When adding an instruction back it is sometimes necessary to move any
755 global or local symbol that was referencing the first instruction of
756 the moved block to refer to the first instruction of the inserted block.
758 For example adding a PAGE instruction before a CALL or JMP requires
759 that any label on the CALL or JMP is moved to the PAGE insn. */
760 addr += noadj;
762 /* Adjust the local symbols defined in this section. */
763 isymend = isymbuf + symtab_hdr->sh_info;
764 for (isym = isymbuf; isym < isymend; isym++)
766 if (isym->st_shndx == shndx
767 && addr <= isym->st_value
768 && isym->st_value < endaddr)
769 isym->st_value += count;
772 /* Now adjust the global symbols defined in this section. */
773 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
774 - symtab_hdr->sh_info);
775 sym_hashes = elf_sym_hashes (abfd);
776 end_hashes = sym_hashes + symcount;
777 for (; sym_hashes < end_hashes; sym_hashes++)
779 struct elf_link_hash_entry *sym_hash = *sym_hashes;
781 if ((sym_hash->root.type == bfd_link_hash_defined
782 || sym_hash->root.type == bfd_link_hash_defweak)
783 && sym_hash->root.u.def.section == sec)
785 if (addr <= sym_hash->root.u.def.value
786 && sym_hash->root.u.def.value < endaddr)
787 sym_hash->root.u.def.value += count;
791 return;
794 /* Delete some bytes from a section while relaxing. */
796 static bfd_boolean
797 ip2k_elf_relax_delete_bytes (bfd *abfd,
798 asection *sec,
799 bfd_vma addr,
800 int count)
802 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
803 bfd_vma endaddr = sec->size;
805 /* Actually delete the bytes. */
806 memmove (contents + addr, contents + addr + count,
807 endaddr - addr - count);
809 sec->size -= count;
811 adjust_all_relocations (abfd, sec, addr + count, endaddr, -count, 0);
812 return TRUE;
815 static bfd_boolean
816 ip2k_delete_page_insn (bfd *abfd ATTRIBUTE_UNUSED,
817 asection *sec,
818 Elf_Internal_Rela *irel,
819 bfd_boolean *again,
820 struct misc *misc)
822 /* Note that we've changed the relocs, section contents, etc. */
823 elf_section_data (sec)->relocs = misc->irelbase;
824 elf_section_data (sec)->this_hdr.contents = misc->contents;
825 misc->symtab_hdr->contents = (bfd_byte *) misc->isymbuf;
827 /* Fix the relocation's type. */
828 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_IP2K_NONE);
830 /* Delete the PAGE insn. */
831 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
832 return FALSE;
834 /* Modified => will need to iterate relaxation again. */
835 *again = TRUE;
837 return TRUE;
840 static bfd_boolean
841 ip2k_relax_switch_table_128 (bfd *abfd ATTRIBUTE_UNUSED,
842 asection *sec,
843 Elf_Internal_Rela *irel,
844 bfd_boolean *again,
845 struct misc *misc)
847 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
848 Elf_Internal_Rela *ireltest = irel;
849 bfd_byte code[4];
850 bfd_vma addr;
852 /* Test all page instructions. */
853 addr = irel->r_offset;
854 while (1)
856 if (addr + 4 > sec->size)
857 break;
859 ip2k_get_mem (abfd, misc->contents + addr, 4, code);
860 if ((! IS_PAGE_OPCODE (code + 0))
861 || (! IS_JMP_OPCODE (code + 2)))
862 break;
864 /* Validate relocation entry (every entry should have a matching
865 relocation entry). */
866 if (ireltest >= irelend)
868 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
869 return FALSE;
872 if (ireltest->r_offset != addr)
874 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
875 return FALSE;
878 if (! ip2k_test_page_insn (abfd, sec, ireltest, misc))
879 /* Un-removable page insn => nothing can be done. */
880 return TRUE;
882 addr += 4;
883 ireltest += 2;
886 /* Relaxable. Adjust table header. */
887 ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 4, code);
888 if ((! IS_ADD_W_WREG_OPCODE (code + 0))
889 || (! IS_ADD_PCL_W_OPCODE (code + 2)))
891 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt."));
892 return FALSE;
895 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset - 4, 2))
896 return FALSE;
898 *again = TRUE;
900 /* Delete all page instructions in table. */
901 while (irel < ireltest)
903 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
904 return FALSE;
905 irel += 2;
908 return TRUE;
911 static bfd_boolean
912 ip2k_relax_switch_table_256 (bfd *abfd ATTRIBUTE_UNUSED,
913 asection *sec,
914 Elf_Internal_Rela *irel,
915 bfd_boolean *again,
916 struct misc *misc)
918 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
919 Elf_Internal_Rela *ireltest = irel;
920 bfd_byte code[12];
921 bfd_vma addr;
923 /* Test all page instructions. */
924 addr = irel->r_offset;
926 while (1)
928 if (addr + 4 > sec->size)
929 break;
931 ip2k_get_mem (abfd, misc->contents + addr, 4, code);
933 if ((! IS_PAGE_OPCODE (code + 0))
934 || (! IS_JMP_OPCODE (code + 2)))
935 break;
937 /* Validate relocation entry (every entry should have a matching
938 relocation entry). */
939 if (ireltest >= irelend)
941 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
942 return FALSE;
945 if (ireltest->r_offset != addr)
947 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
948 return FALSE;
951 if (!ip2k_test_page_insn (abfd, sec, ireltest, misc))
952 /* Un-removable page insn => nothing can be done. */
953 return TRUE;
955 addr += 4;
956 ireltest += 2;
959 /* Relaxable. Adjust table header. */
960 ip2k_get_mem (abfd, misc->contents + irel->r_offset - 4, 2, code);
961 if (IS_PAGE_OPCODE (code))
962 addr = irel->r_offset - 16;
963 else
964 addr = irel->r_offset - 14;
966 ip2k_get_mem (abfd, misc->contents + addr, 12, code);
967 if ((!IS_ADD_W_WREG_OPCODE (code + 0))
968 || (!IS_SNC_OPCODE (code + 2))
969 || (!IS_INC_1SP_OPCODE (code + 4))
970 || (!IS_ADD_2SP_W_OPCODE (code + 6))
971 || (!IS_SNC_OPCODE (code + 8))
972 || (!IS_INC_1SP_OPCODE (code + 10)))
974 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt."));
975 return FALSE;
978 /* Delete first 3 opcodes. */
979 if (!ip2k_elf_relax_delete_bytes (abfd, sec, addr + 0, 6))
980 return FALSE;
982 *again = TRUE;
984 /* Delete all page instructions in table. */
985 while (irel < ireltest)
987 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
988 return FALSE;
989 irel += 2;
992 return TRUE;
995 /* This function handles relaxation of a section in a specific page. */
997 static bfd_boolean
998 ip2k_elf_relax_section_page (bfd *abfd,
999 asection *sec,
1000 bfd_boolean *again,
1001 struct misc *misc,
1002 unsigned long page_start,
1003 unsigned long page_end)
1005 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
1006 Elf_Internal_Rela *irel;
1007 int switch_table_128;
1008 int switch_table_256;
1010 /* Walk thru the section looking for relaxation opportunities. */
1011 for (irel = misc->irelbase; irel < irelend; irel++)
1013 if (ELF32_R_TYPE (irel->r_info) != (int) R_IP2K_PAGE3)
1014 /* Ignore non page instructions. */
1015 continue;
1017 if (BASEADDR (sec) + irel->r_offset < page_start)
1018 /* Ignore page instructions on earlier page - they have
1019 already been processed. Remember that there is code flow
1020 that crosses a page boundary. */
1021 continue;
1023 if (BASEADDR (sec) + irel->r_offset > page_end)
1024 /* Flow beyond end of page => nothing more to do for this page. */
1025 return TRUE;
1027 /* Detect switch tables. */
1028 switch_table_128 = ip2k_is_switch_table_128 (abfd, sec, irel->r_offset, misc->contents);
1029 switch_table_256 = ip2k_is_switch_table_256 (abfd, sec, irel->r_offset, misc->contents);
1031 if ((switch_table_128 > 0) || (switch_table_256 > 0))
1032 /* If the index is greater than 0 then it has already been processed. */
1033 continue;
1035 if (switch_table_128 == 0)
1037 if (!ip2k_relax_switch_table_128 (abfd, sec, irel, again, misc))
1038 return FALSE;
1040 continue;
1043 if (switch_table_256 == 0)
1045 if (!ip2k_relax_switch_table_256 (abfd, sec, irel, again, misc))
1046 return FALSE;
1048 continue;
1051 /* Simple relax. */
1052 if (ip2k_test_page_insn (abfd, sec, irel, misc))
1054 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
1055 return FALSE;
1057 continue;
1061 return TRUE;
1064 /* This function handles relaxing for the ip2k.
1066 Principle: Start with the first page and remove page instructions that
1067 are not require on this first page. By removing page instructions more
1068 code will fit into this page - repeat until nothing more can be achieved
1069 for this page. Move on to the next page.
1071 Processing the pages one at a time from the lowest page allows a removal
1072 only policy to be used - pages can be removed but are never reinserted. */
1074 static bfd_boolean
1075 ip2k_elf_relax_section (bfd *abfd,
1076 asection *sec,
1077 struct bfd_link_info *link_info,
1078 bfd_boolean *again)
1080 Elf_Internal_Shdr *symtab_hdr;
1081 Elf_Internal_Rela *internal_relocs;
1082 bfd_byte *contents = NULL;
1083 Elf_Internal_Sym *isymbuf = NULL;
1084 static asection * first_section = NULL;
1085 static unsigned long search_addr;
1086 static unsigned long page_start = 0;
1087 static unsigned long page_end = 0;
1088 static unsigned int pass = 0;
1089 static bfd_boolean new_pass = FALSE;
1090 static bfd_boolean changed = FALSE;
1091 struct misc misc;
1092 asection *stab;
1094 /* Assume nothing changes. */
1095 *again = FALSE;
1097 if (first_section == NULL)
1099 ip2k_relaxed = TRUE;
1100 first_section = sec;
1103 if (first_section == sec)
1105 pass++;
1106 new_pass = TRUE;
1109 /* We don't have to do anything for a relocatable link,
1110 if this section does not have relocs, or if this is
1111 not a code section. */
1112 if (link_info->relocatable
1113 || (sec->flags & SEC_RELOC) == 0
1114 || sec->reloc_count == 0
1115 || (sec->flags & SEC_CODE) == 0)
1116 return TRUE;
1118 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1120 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
1121 link_info->keep_memory);
1122 if (internal_relocs == NULL)
1123 goto error_return;
1125 /* Make sure the stac.rela stuff gets read in. */
1126 stab = bfd_get_section_by_name (abfd, ".stab");
1128 if (stab)
1130 /* So stab does exits. */
1131 Elf_Internal_Rela * irelbase;
1133 irelbase = _bfd_elf_link_read_relocs (abfd, stab, NULL, NULL,
1134 link_info->keep_memory);
1137 /* Get section contents cached copy if it exists. */
1138 if (contents == NULL)
1140 /* Get cached copy if it exists. */
1141 if (elf_section_data (sec)->this_hdr.contents != NULL)
1142 contents = elf_section_data (sec)->this_hdr.contents;
1143 else
1145 /* Go get them off disk. */
1146 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1147 goto error_return;
1151 /* Read this BFD's symbols cached copy if it exists. */
1152 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1154 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1155 if (isymbuf == NULL)
1156 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1157 symtab_hdr->sh_info, 0,
1158 NULL, NULL, NULL);
1159 if (isymbuf == NULL)
1160 goto error_return;
1163 misc.symtab_hdr = symtab_hdr;
1164 misc.isymbuf = isymbuf;
1165 misc.irelbase = internal_relocs;
1166 misc.contents = contents;
1168 /* This is where all the relaxation actually get done. */
1169 if ((pass == 1) || (new_pass && !changed))
1171 /* On the first pass we simply search for the lowest page that
1172 we havn't relaxed yet. Note that the pass count is reset
1173 each time a page is complete in order to move on to the next page.
1174 If we can't find any more pages then we are finished. */
1175 if (new_pass)
1177 pass = 1;
1178 new_pass = FALSE;
1179 changed = TRUE; /* Pre-initialize to break out of pass 1. */
1180 search_addr = 0xFFFFFFFF;
1183 if ((BASEADDR (sec) + sec->size < search_addr)
1184 && (BASEADDR (sec) + sec->size > page_end))
1186 if (BASEADDR (sec) <= page_end)
1187 search_addr = page_end + 1;
1188 else
1189 search_addr = BASEADDR (sec);
1191 /* Found a page => more work to do. */
1192 *again = TRUE;
1195 else
1197 if (new_pass)
1199 new_pass = FALSE;
1200 changed = FALSE;
1201 page_start = PAGENO (search_addr);
1202 page_end = page_start | 0x00003FFF;
1205 /* Only process sections in range. */
1206 if ((BASEADDR (sec) + sec->size >= page_start)
1207 && (BASEADDR (sec) <= page_end))
1209 if (!ip2k_elf_relax_section_page (abfd, sec, &changed, &misc, page_start, page_end))
1210 return FALSE;
1212 *again = TRUE;
1215 /* Perform some house keeping after relaxing the section. */
1217 if (isymbuf != NULL
1218 && symtab_hdr->contents != (unsigned char *) isymbuf)
1220 if (! link_info->keep_memory)
1221 free (isymbuf);
1222 else
1223 symtab_hdr->contents = (unsigned char *) isymbuf;
1226 if (contents != NULL
1227 && elf_section_data (sec)->this_hdr.contents != contents)
1229 if (! link_info->keep_memory)
1230 free (contents);
1231 else
1233 /* Cache the section contents for elf_link_input_bfd. */
1234 elf_section_data (sec)->this_hdr.contents = contents;
1238 if (internal_relocs != NULL
1239 && elf_section_data (sec)->relocs != internal_relocs)
1240 free (internal_relocs);
1242 return TRUE;
1244 error_return:
1245 if (isymbuf != NULL
1246 && symtab_hdr->contents != (unsigned char *) isymbuf)
1247 free (isymbuf);
1248 if (contents != NULL
1249 && elf_section_data (sec)->this_hdr.contents != contents)
1250 free (contents);
1251 if (internal_relocs != NULL
1252 && elf_section_data (sec)->relocs != internal_relocs)
1253 free (internal_relocs);
1254 return FALSE;
1257 /* Set the howto pointer for a IP2K ELF reloc. */
1259 static void
1260 ip2k_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
1261 arelent * cache_ptr,
1262 Elf_Internal_Rela * dst)
1264 unsigned int r_type;
1266 r_type = ELF32_R_TYPE (dst->r_info);
1267 cache_ptr->howto = & ip2k_elf_howto_table [r_type];
1270 /* Perform a single relocation.
1271 By default we use the standard BFD routines. */
1273 static bfd_reloc_status_type
1274 ip2k_final_link_relocate (reloc_howto_type * howto,
1275 bfd * input_bfd,
1276 asection * input_section,
1277 bfd_byte * contents,
1278 Elf_Internal_Rela * rel,
1279 bfd_vma relocation)
1281 static bfd_vma page_addr = 0;
1283 bfd_reloc_status_type r = bfd_reloc_ok;
1284 switch (howto->type)
1286 /* Handle data space relocations. */
1287 case R_IP2K_FR9:
1288 case R_IP2K_BANK:
1289 if ((relocation & IP2K_DATA_MASK) == IP2K_DATA_VALUE)
1290 relocation &= ~IP2K_DATA_MASK;
1291 else
1292 r = bfd_reloc_notsupported;
1293 break;
1295 case R_IP2K_LO8DATA:
1296 case R_IP2K_HI8DATA:
1297 case R_IP2K_EX8DATA:
1298 break;
1300 /* Handle insn space relocations. */
1301 case R_IP2K_PAGE3:
1302 page_addr = BASEADDR (input_section) + rel->r_offset;
1303 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1304 relocation &= ~IP2K_INSN_MASK;
1305 else
1306 r = bfd_reloc_notsupported;
1307 break;
1309 case R_IP2K_ADDR16CJP:
1310 if (BASEADDR (input_section) + rel->r_offset != page_addr + 2)
1312 /* No preceding page instruction, verify that it isn't needed. */
1313 if (PAGENO (relocation + rel->r_addend) !=
1314 ip2k_nominal_page_bits (input_bfd, input_section,
1315 rel->r_offset, contents))
1316 _bfd_error_handler (_("ip2k linker: missing page instruction at 0x%08lx (dest = 0x%08lx)."),
1317 BASEADDR (input_section) + rel->r_offset,
1318 relocation + rel->r_addend);
1320 else if (ip2k_relaxed)
1322 /* Preceding page instruction. Verify that the page instruction is
1323 really needed. One reason for the relaxation to miss a page is if
1324 the section is not marked as executable. */
1325 if (!ip2k_is_switch_table_128 (input_bfd, input_section,
1326 rel->r_offset - 2, contents)
1327 && !ip2k_is_switch_table_256 (input_bfd, input_section,
1328 rel->r_offset - 2, contents)
1329 && (PAGENO (relocation + rel->r_addend) ==
1330 ip2k_nominal_page_bits (input_bfd, input_section,
1331 rel->r_offset - 2, contents)))
1332 _bfd_error_handler (_("ip2k linker: redundant page instruction at 0x%08lx (dest = 0x%08lx)."),
1333 page_addr,
1334 relocation + rel->r_addend);
1336 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1337 relocation &= ~IP2K_INSN_MASK;
1338 else
1339 r = bfd_reloc_notsupported;
1340 break;
1342 case R_IP2K_LO8INSN:
1343 case R_IP2K_HI8INSN:
1344 case R_IP2K_PC_SKIP:
1345 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1346 relocation &= ~IP2K_INSN_MASK;
1347 else
1348 r = bfd_reloc_notsupported;
1349 break;
1351 case R_IP2K_16:
1352 /* If this is a relocation involving a TEXT
1353 symbol, reduce it to a word address. */
1354 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1355 howto = &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
1356 break;
1358 /* Pass others through. */
1359 default:
1360 break;
1363 /* Only install relocation if above tests did not disqualify it. */
1364 if (r == bfd_reloc_ok)
1365 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1366 contents, rel->r_offset,
1367 relocation, rel->r_addend);
1369 return r;
1372 /* Relocate a IP2K ELF section.
1374 The RELOCATE_SECTION function is called by the new ELF backend linker
1375 to handle the relocations for a section.
1377 The relocs are always passed as Rela structures; if the section
1378 actually uses Rel structures, the r_addend field will always be
1379 zero.
1381 This function is responsible for adjusting the section contents as
1382 necessary, and (if using Rela relocs and generating a relocatable
1383 output file) adjusting the reloc addend as necessary.
1385 This function does not have to worry about setting the reloc
1386 address or the reloc symbol index.
1388 LOCAL_SYMS is a pointer to the swapped in local symbols.
1390 LOCAL_SECTIONS is an array giving the section in the input file
1391 corresponding to the st_shndx field of each local symbol.
1393 The global hash table entry for the global symbols can be found
1394 via elf_sym_hashes (input_bfd).
1396 When generating relocatable output, this function must handle
1397 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1398 going to be the section symbol corresponding to the output
1399 section, which means that the addend must be adjusted
1400 accordingly. */
1402 static bfd_boolean
1403 ip2k_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1404 struct bfd_link_info *info,
1405 bfd *input_bfd,
1406 asection *input_section,
1407 bfd_byte *contents,
1408 Elf_Internal_Rela *relocs,
1409 Elf_Internal_Sym *local_syms,
1410 asection **local_sections)
1412 Elf_Internal_Shdr *symtab_hdr;
1413 struct elf_link_hash_entry **sym_hashes;
1414 Elf_Internal_Rela *rel;
1415 Elf_Internal_Rela *relend;
1417 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1418 sym_hashes = elf_sym_hashes (input_bfd);
1419 relend = relocs + input_section->reloc_count;
1421 for (rel = relocs; rel < relend; rel ++)
1423 reloc_howto_type * howto;
1424 unsigned long r_symndx;
1425 Elf_Internal_Sym * sym;
1426 asection * sec;
1427 struct elf_link_hash_entry * h;
1428 bfd_vma relocation;
1429 bfd_reloc_status_type r;
1430 const char * name = NULL;
1431 int r_type;
1433 r_type = ELF32_R_TYPE (rel->r_info);
1434 r_symndx = ELF32_R_SYM (rel->r_info);
1435 howto = ip2k_elf_howto_table + ELF32_R_TYPE (rel->r_info);
1436 h = NULL;
1437 sym = NULL;
1438 sec = NULL;
1440 if (r_symndx < symtab_hdr->sh_info)
1442 sym = local_syms + r_symndx;
1443 sec = local_sections [r_symndx];
1444 relocation = BASEADDR (sec) + sym->st_value;
1446 name = bfd_elf_string_from_elf_section
1447 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1448 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1450 else
1452 bfd_boolean warned;
1453 bfd_boolean unresolved_reloc;
1455 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1456 r_symndx, symtab_hdr, sym_hashes,
1457 h, sec, relocation,
1458 unresolved_reloc, warned);
1460 name = h->root.root.string;
1463 if (sec != NULL && elf_discarded_section (sec))
1465 /* For relocs against symbols from removed linkonce sections,
1466 or sections discarded by a linker script, we just want the
1467 section contents zeroed. Avoid any special processing. */
1468 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1469 rel->r_info = 0;
1470 rel->r_addend = 0;
1471 continue;
1474 if (info->relocatable)
1475 continue;
1477 /* Finally, the sole IP2K-specific part. */
1478 r = ip2k_final_link_relocate (howto, input_bfd, input_section,
1479 contents, rel, relocation);
1481 if (r != bfd_reloc_ok)
1483 const char * msg = NULL;
1485 switch (r)
1487 case bfd_reloc_overflow:
1488 r = info->callbacks->reloc_overflow
1489 (info, (h ? &h->root : NULL), name, howto->name,
1490 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1491 break;
1493 case bfd_reloc_undefined:
1494 r = info->callbacks->undefined_symbol
1495 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1496 break;
1498 case bfd_reloc_outofrange:
1499 msg = _("internal error: out of range error");
1500 break;
1502 /* This is how ip2k_final_link_relocate tells us of a non-kosher
1503 reference between insn & data address spaces. */
1504 case bfd_reloc_notsupported:
1505 if (sym != NULL) /* Only if it's not an unresolved symbol. */
1506 msg = _("unsupported relocation between data/insn address spaces");
1507 break;
1509 case bfd_reloc_dangerous:
1510 msg = _("internal error: dangerous relocation");
1511 break;
1513 default:
1514 msg = _("internal error: unknown error");
1515 break;
1518 if (msg)
1519 r = info->callbacks->warning
1520 (info, msg, name, input_bfd, input_section, rel->r_offset);
1522 if (! r)
1523 return FALSE;
1527 return TRUE;
1530 #define TARGET_BIG_SYM bfd_elf32_ip2k_vec
1531 #define TARGET_BIG_NAME "elf32-ip2k"
1533 #define ELF_ARCH bfd_arch_ip2k
1534 #define ELF_MACHINE_CODE EM_IP2K
1535 #define ELF_MACHINE_ALT1 EM_IP2K_OLD
1536 #define ELF_MAXPAGESIZE 1 /* No pages on the IP2K. */
1538 #define elf_info_to_howto_rel NULL
1539 #define elf_info_to_howto ip2k_info_to_howto_rela
1541 #define elf_backend_can_gc_sections 1
1542 #define elf_backend_rela_normal 1
1543 #define elf_backend_relocate_section ip2k_elf_relocate_section
1545 #define elf_symbol_leading_char '_'
1546 #define bfd_elf32_bfd_reloc_type_lookup ip2k_reloc_type_lookup
1547 #define bfd_elf32_bfd_reloc_name_lookup ip2k_reloc_name_lookup
1548 #define bfd_elf32_bfd_relax_section ip2k_elf_relax_section
1550 #include "elf32-target.h"