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