daily update
[binutils.git] / bfd / elf32-ip2k.c
blob0a251b8458913880211149e13d57d65fa00ed9cd
1 /* Ubicom IP2xxx specific support for 32-bit ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
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 table_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 table_index;
374 if ((! IS_PAGE_OPCODE (code + 0))
375 || (! IS_JMP_OPCODE (code + 2)))
376 return -1;
378 table_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 table_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 table_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 table_index;
468 if ((! IS_PAGE_OPCODE (code + 0))
469 || (! IS_JMP_OPCODE (code + 2)))
470 return -1;
472 table_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 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;
586 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
587 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
589 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
591 irelbase = elf_section_data (sec)->relocs;
592 irelend = irelbase + sec->reloc_count;
594 for (irel = irelbase; irel < irelend; irel++)
596 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
598 /* Get the value of the symbol referred to by the reloc. */
599 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
601 asection *sym_sec;
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);
607 if (isym->st_shndx == shndx)
609 bfd_vma baseaddr = BASEADDR (sec);
610 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value
611 + irel->r_addend;
613 if ((baseaddr + addr + noadj) <= symval
614 && symval < (baseaddr + endaddr))
615 irel->r_addend += count;
620 /* Do this only for PC space relocations. */
621 if (addr <= irel->r_offset && irel->r_offset < endaddr)
622 irel->r_offset += count;
625 /* Now fix the stab relocations. */
626 stab = bfd_get_section_by_name (abfd, ".stab");
627 if (stab)
629 bfd_byte *stabcontents, *stabend, *stabp;
630 bfd_size_type stab_size = stab->rawsize ? stab->rawsize : stab->size;
632 irelbase = elf_section_data (stab)->relocs;
633 irelend = irelbase + stab->reloc_count;
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
640 if (!bfd_malloc_and_get_section (abfd, stab, &stabcontents))
642 if (stabcontents != NULL)
643 free (stabcontents);
644 return;
647 /* We need to remember this. */
648 elf_section_data (stab)->this_hdr.contents = stabcontents;
651 stabend = stabcontents + stab_size;
653 for (irel = irelbase; irel < irelend; irel++)
655 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
657 /* Get the value of the symbol referred to by the reloc. */
658 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
660 asection *sym_sec;
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);
666 if (sym_sec == sec)
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;
675 if ((baseaddr + addr) <= symval
676 && symval <= (baseaddr + endaddr))
677 irel->r_addend += count;
679 /* Go hunt up a function and fix its line info if needed. */
680 stabp = stabcontents + irel->r_offset - 8;
682 /* Go pullout the stab entry. */
683 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
684 value = bfd_h_get_32 (abfd, stabp + VALOFF);
686 name = bfd_get_stab_name (type);
688 if (strcmp (name, "FUN") == 0)
690 int function_adjusted = 0;
692 if (symval > (baseaddr + addr))
693 /* Not in this function. */
694 continue;
696 /* Hey we got a function hit. */
697 stabp += STABSIZE;
698 for (;stabp < stabend; stabp += STABSIZE)
700 /* Go pullout the stab entry. */
701 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
702 value = bfd_h_get_32 (abfd, stabp + VALOFF);
704 name = bfd_get_stab_name (type);
706 if (strcmp (name, "FUN") == 0)
708 /* Hit another function entry. */
709 if (function_adjusted)
711 /* Adjust the value. */
712 value += count;
714 /* We need to put it back. */
715 bfd_h_put_32 (abfd, value,stabp + VALOFF);
718 /* And then bale out. */
719 break;
722 if (strcmp (name, "SLINE") == 0)
724 /* Got a line entry. */
725 if ((baseaddr + addr) <= (symval + value))
727 /* Adjust the line entry. */
728 value += count;
730 /* We need to put it back. */
731 bfd_h_put_32 (abfd, value,stabp + VALOFF);
732 function_adjusted = 1;
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.
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;
751 /* Adjust the local symbols defined in this section. */
752 isymend = isymbuf + symtab_hdr->sh_info;
753 for (isym = isymbuf; isym < isymend; isym++)
755 if (isym->st_shndx == shndx
756 && addr <= isym->st_value
757 && isym->st_value < endaddr)
758 isym->st_value += count;
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++)
768 struct elf_link_hash_entry *sym_hash = *sym_hashes;
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)
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;
780 return;
783 /* Delete some bytes from a section while relaxing. */
785 static bfd_boolean
786 ip2k_elf_relax_delete_bytes (bfd *abfd,
787 asection *sec,
788 bfd_vma addr,
789 int count)
791 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
792 bfd_vma endaddr = sec->size;
794 /* Actually delete the bytes. */
795 memmove (contents + addr, contents + addr + count,
796 endaddr - addr - count);
798 sec->size -= count;
800 adjust_all_relocations (abfd, sec, addr + count, endaddr, -count, 0);
801 return TRUE;
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)
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;
816 /* Fix the relocation's type. */
817 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_IP2K_NONE);
819 /* Delete the PAGE insn. */
820 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
821 return FALSE;
823 /* Modified => will need to iterate relaxation again. */
824 *again = TRUE;
826 return TRUE;
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)
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;
841 /* Test all page instructions. */
842 addr = irel->r_offset;
843 while (1)
845 if (addr + 4 > sec->size)
846 break;
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;
853 /* Validate relocation entry (every entry should have a matching
854 relocation entry). */
855 if (ireltest >= irelend)
857 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
858 return FALSE;
861 if (ireltest->r_offset != addr)
863 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
864 return FALSE;
867 if (! ip2k_test_page_insn (abfd, sec, ireltest, misc))
868 /* Un-removable page insn => nothing can be done. */
869 return TRUE;
871 addr += 4;
872 ireltest += 2;
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)))
880 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt."));
881 return FALSE;
884 if (!ip2k_elf_relax_delete_bytes (abfd, sec, irel->r_offset - 4, 2))
885 return FALSE;
887 *again = TRUE;
889 /* Delete all page instructions in table. */
890 while (irel < ireltest)
892 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
893 return FALSE;
894 irel += 2;
897 return TRUE;
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)
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;
912 /* Test all page instructions. */
913 addr = irel->r_offset;
915 while (1)
917 if (addr + 4 > sec->size)
918 break;
920 ip2k_get_mem (abfd, misc->contents + addr, 4, code);
922 if ((! IS_PAGE_OPCODE (code + 0))
923 || (! IS_JMP_OPCODE (code + 2)))
924 break;
926 /* Validate relocation entry (every entry should have a matching
927 relocation entry). */
928 if (ireltest >= irelend)
930 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
931 return FALSE;
934 if (ireltest->r_offset != addr)
936 _bfd_error_handler (_("ip2k relaxer: switch table without complete matching relocation information."));
937 return FALSE;
940 if (!ip2k_test_page_insn (abfd, sec, ireltest, misc))
941 /* Un-removable page insn => nothing can be done. */
942 return TRUE;
944 addr += 4;
945 ireltest += 2;
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;
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)))
963 _bfd_error_handler (_("ip2k relaxer: switch table header corrupt."));
964 return FALSE;
967 /* Delete first 3 opcodes. */
968 if (!ip2k_elf_relax_delete_bytes (abfd, sec, addr + 0, 6))
969 return FALSE;
971 *again = TRUE;
973 /* Delete all page instructions in table. */
974 while (irel < ireltest)
976 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
977 return FALSE;
978 irel += 2;
981 return TRUE;
984 /* This function handles relaxation of a section in a specific page. */
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)
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;
999 /* Walk thru the section looking for relaxation opportunities. */
1000 for (irel = misc->irelbase; irel < irelend; irel++)
1002 if (ELF32_R_TYPE (irel->r_info) != (int) R_IP2K_PAGE3)
1003 /* Ignore non page instructions. */
1004 continue;
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;
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;
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);
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;
1024 if (switch_table_128 == 0)
1026 if (!ip2k_relax_switch_table_128 (abfd, sec, irel, again, misc))
1027 return FALSE;
1029 continue;
1032 if (switch_table_256 == 0)
1034 if (!ip2k_relax_switch_table_256 (abfd, sec, irel, again, misc))
1035 return FALSE;
1037 continue;
1040 /* Simple relax. */
1041 if (ip2k_test_page_insn (abfd, sec, irel, misc))
1043 if (!ip2k_delete_page_insn (abfd, sec, irel, again, misc))
1044 return FALSE;
1046 continue;
1050 return TRUE;
1053 /* This function handles relaxing for the ip2k.
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.
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. */
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)
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;
1082 /* Assume nothing changes. */
1083 *again = FALSE;
1085 if (first_section == NULL)
1087 ip2k_relaxed = TRUE;
1088 first_section = sec;
1091 if (first_section == sec)
1093 pass++;
1094 new_pass = TRUE;
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;
1106 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
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;
1113 /* Get section contents cached copy if it exists. */
1114 if (contents == NULL)
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
1121 /* Go get them off disk. */
1122 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1123 goto error_return;
1127 /* Read this BFD's symbols cached copy if it exists. */
1128 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
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;
1139 misc.symtab_hdr = symtab_hdr;
1140 misc.isymbuf = isymbuf;
1141 misc.irelbase = internal_relocs;
1142 misc.contents = contents;
1144 /* This is where all the relaxation actually get done. */
1145 if ((pass == 1) || (new_pass && !changed))
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)
1153 pass = 1;
1154 new_pass = FALSE;
1155 changed = TRUE; /* Pre-initialize to break out of pass 1. */
1156 search_addr = 0xFFFFFFFF;
1159 if ((BASEADDR (sec) + sec->size < search_addr)
1160 && (BASEADDR (sec) + sec->size > page_end))
1162 if (BASEADDR (sec) <= page_end)
1163 search_addr = page_end + 1;
1164 else
1165 search_addr = BASEADDR (sec);
1167 /* Found a page => more work to do. */
1168 *again = TRUE;
1171 else
1173 if (new_pass)
1175 new_pass = FALSE;
1176 changed = FALSE;
1177 page_start = PAGENO (search_addr);
1178 page_end = page_start | 0x00003FFF;
1181 /* Only process sections in range. */
1182 if ((BASEADDR (sec) + sec->size >= page_start)
1183 && (BASEADDR (sec) <= page_end))
1185 if (!ip2k_elf_relax_section_page (abfd, sec, &changed, &misc, page_start, page_end))
1186 return FALSE;
1188 *again = TRUE;
1191 /* Perform some house keeping after relaxing the section. */
1193 if (isymbuf != NULL
1194 && symtab_hdr->contents != (unsigned char *) isymbuf)
1196 if (! link_info->keep_memory)
1197 free (isymbuf);
1198 else
1199 symtab_hdr->contents = (unsigned char *) isymbuf;
1202 if (contents != NULL
1203 && elf_section_data (sec)->this_hdr.contents != contents)
1205 if (! link_info->keep_memory)
1206 free (contents);
1207 else
1209 /* Cache the section contents for elf_link_input_bfd. */
1210 elf_section_data (sec)->this_hdr.contents = contents;
1214 if (internal_relocs != NULL
1215 && elf_section_data (sec)->relocs != internal_relocs)
1216 free (internal_relocs);
1218 return TRUE;
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;
1233 /* Set the howto pointer for a IP2K ELF reloc. */
1235 static void
1236 ip2k_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
1237 arelent * cache_ptr,
1238 Elf_Internal_Rela * dst)
1240 unsigned int r_type;
1242 r_type = ELF32_R_TYPE (dst->r_info);
1243 cache_ptr->howto = & ip2k_elf_howto_table [r_type];
1246 /* Perform a single relocation.
1247 By default we use the standard BFD routines. */
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)
1257 static bfd_vma page_addr = 0;
1259 bfd_reloc_status_type r = bfd_reloc_ok;
1260 switch (howto->type)
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;
1271 case R_IP2K_LO8DATA:
1272 case R_IP2K_HI8DATA:
1273 case R_IP2K_EX8DATA:
1274 break;
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;
1285 case R_IP2K_ADDR16CJP:
1286 if (BASEADDR (input_section) + rel->r_offset != page_addr + 2)
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);
1296 else if (ip2k_relaxed)
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);
1312 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1313 relocation &= ~IP2K_INSN_MASK;
1314 else
1315 r = bfd_reloc_notsupported;
1316 break;
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;
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;
1334 /* Pass others through. */
1335 default:
1336 break;
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);
1345 return r;
1348 /* Relocate a IP2K ELF section.
1350 The RELOCATE_SECTION function is called by the new ELF backend linker
1351 to handle the relocations for a section.
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.
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.
1361 This function does not have to worry about setting the reloc
1362 address or the reloc symbol index.
1364 LOCAL_SYMS is a pointer to the swapped in local symbols.
1366 LOCAL_SECTIONS is an array giving the section in the input file
1367 corresponding to the st_shndx field of each local symbol.
1369 The global hash table entry for the global symbols can be found
1370 via elf_sym_hashes (input_bfd).
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. */
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)
1388 Elf_Internal_Shdr *symtab_hdr;
1389 struct elf_link_hash_entry **sym_hashes;
1390 Elf_Internal_Rela *rel;
1391 Elf_Internal_Rela *relend;
1393 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1394 sym_hashes = elf_sym_hashes (input_bfd);
1395 relend = relocs + input_section->reloc_count;
1397 for (rel = relocs; rel < relend; rel ++)
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;
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;
1416 if (r_symndx < symtab_hdr->sh_info)
1418 sym = local_syms + r_symndx;
1419 sec = local_sections [r_symndx];
1420 relocation = BASEADDR (sec) + sym->st_value;
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;
1426 else
1428 bfd_boolean warned;
1429 bfd_boolean unresolved_reloc;
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);
1436 name = h->root.root.string;
1439 if (sec != NULL && elf_discarded_section (sec))
1440 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1441 rel, relend, howto, contents);
1443 if (info->relocatable)
1444 continue;
1446 /* Finally, the sole IP2K-specific part. */
1447 r = ip2k_final_link_relocate (howto, input_bfd, input_section,
1448 contents, rel, relocation);
1450 if (r != bfd_reloc_ok)
1452 const char * msg = NULL;
1454 switch (r)
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;
1462 case bfd_reloc_undefined:
1463 r = info->callbacks->undefined_symbol
1464 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1465 break;
1467 case bfd_reloc_outofrange:
1468 msg = _("internal error: out of range error");
1469 break;
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;
1478 case bfd_reloc_dangerous:
1479 msg = _("internal error: dangerous relocation");
1480 break;
1482 default:
1483 msg = _("internal error: unknown error");
1484 break;
1487 if (msg)
1488 r = info->callbacks->warning
1489 (info, msg, name, input_bfd, input_section, rel->r_offset);
1491 if (! r)
1492 return FALSE;
1496 return TRUE;
1499 #define TARGET_BIG_SYM bfd_elf32_ip2k_vec
1500 #define TARGET_BIG_NAME "elf32-ip2k"
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. */
1507 #define elf_info_to_howto_rel NULL
1508 #define elf_info_to_howto ip2k_info_to_howto_rela
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
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
1519 #include "elf32-target.h"