projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
s/boolean/bfd_boolean/ s/true/TRUE/ s/false/FALSE/. Simplify
[deliverable/binutils-gdb.git] / bfd / elf32-ip2k.c
1 /* Ubicom IP2xxx specific support for 32-bit ELF
2 Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "libbfd.h"
23 #include "elf-bfd.h"
24 #include "elf/ip2k.h"
25
26 /* Struct used to pass miscellaneous paramaters which
27 helps to avoid overly long parameter lists. */
28 struct misc
29 {
30 Elf_Internal_Shdr * symtab_hdr;
31 Elf_Internal_Rela * irelbase;
32 bfd_byte * contents;
33 Elf_Internal_Sym * isymbuf;
34 };
35
36 /* Prototypes. */
37 static reloc_howto_type *ip2k_reloc_type_lookup
38 PARAMS ((bfd *, bfd_reloc_code_real_type));
39 static void ip2k_info_to_howto_rela
40 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
41 static asection * ip2k_elf_gc_mark_hook
42 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
43 struct elf_link_hash_entry *, Elf_Internal_Sym *));
44 static bfd_boolean ip2k_elf_gc_sweep_hook
45 PARAMS ((bfd *, struct bfd_link_info *, asection *,
46 const Elf_Internal_Rela *));
47 static bfd_vma symbol_value
48 PARAMS ((bfd *, Elf_Internal_Shdr *, Elf_Internal_Sym *,
49 Elf_Internal_Rela *));
50 static void adjust_all_relocations
51 PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, int, int));
52 static bfd_boolean ip2k_elf_relax_delete_bytes
53 PARAMS ((bfd *, asection *, bfd_vma, int));
54 static bfd_boolean ip2k_elf_relax_add_bytes
55 PARAMS ((bfd *, asection *, bfd_vma, const bfd_byte *, int, int));
56 static bfd_boolean add_page_insn
57 PARAMS ((bfd *, asection *, Elf_Internal_Rela *, struct misc *));
58 static bfd_boolean ip2k_elf_relax_section
59 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
60 static bfd_boolean relax_switch_dispatch_tables_pass1
61 PARAMS ((bfd *, asection *, bfd_vma, struct misc *));
62 static bfd_boolean unrelax_dispatch_table_entries
63 PARAMS ((bfd *, asection *, bfd_vma, bfd_vma, bfd_boolean *, struct misc *));
64 static bfd_boolean unrelax_switch_dispatch_tables_passN
65 PARAMS ((bfd *, asection *, bfd_vma, bfd_boolean *, struct misc *));
66 static bfd_boolean is_switch_128_dispatch_table_p
67 PARAMS ((bfd *, bfd_vma, bfd_boolean, struct misc *));
68 static bfd_boolean is_switch_256_dispatch_table_p
69 PARAMS ((bfd *, bfd_vma, bfd_boolean, struct misc *));
70 static bfd_boolean ip2k_elf_relax_section_pass1
71 PARAMS ((bfd *, asection *, bfd_boolean *, struct misc *));
72 static bfd_boolean ip2k_elf_relax_section_passN
73 PARAMS ((bfd *, asection *, bfd_boolean *, bfd_boolean *, struct misc *));
74 static bfd_reloc_status_type ip2k_final_link_relocate
75 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
76 Elf_Internal_Rela *, bfd_vma));
77 static bfd_boolean ip2k_elf_relocate_section
78 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
79 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
80
81 #define IS_OPCODE(CODE0,CODE1,OPCODE) \
82 ((CODE0) == (OPCODE)[0] && (CODE1) == (OPCODE)[1])
83
84 #define PAGE_INSN_0 0x00
85 #define PAGE_INSN_1 0x10
86
87 static const bfd_byte page_opcode[] =
88 {
89 PAGE_INSN_0, PAGE_INSN_1
90 };
91
92 #define IS_PAGE_OPCODE(CODE0,CODE1) \
93 IS_OPCODE (CODE0, CODE1, page_opcode)
94
95 #define JMP_INSN_0 0xE0
96 #define JMP_INSN_1 0x00
97
98 static const bfd_byte jmp_opcode[] =
99 {
100 JMP_INSN_0, JMP_INSN_1
101 };
102
103 #define IS_JMP_OPCODE(CODE0,CODE1) \
104 IS_OPCODE (CODE0, CODE1, jmp_opcode)
105
106 #define CALL_INSN_0 0xC0
107 #define CALL_INSN_1 0x00
108
109 static const bfd_byte call_opcode[] =
110 {
111 CALL_INSN_0, CALL_INSN_1
112 };
113
114 #define IS_CALL_OPCODE(CODE0,CODE1) \
115 IS_OPCODE (CODE0, CODE1, call_opcode)
116
117 #define ADD_PCL_W_INSN_0 0x1E
118 #define ADD_PCL_W_INSN_1 0x09
119
120 static const bfd_byte add_pcl_w_opcode[] =
121 {
122 ADD_PCL_W_INSN_0, ADD_PCL_W_INSN_1
123 };
124
125 #define IS_ADD_PCL_W_OPCODE(CODE0,CODE1) \
126 IS_OPCODE (CODE0, CODE1, add_pcl_w_opcode)
127
128 #define ADD_W_WREG_INSN_0 0x1C
129 #define ADD_W_WREG_INSN_1 0x0A
130
131 static const bfd_byte add_w_wreg_opcode[] =
132 {
133 ADD_W_WREG_INSN_0, ADD_W_WREG_INSN_1
134 };
135
136 #define IS_ADD_W_WREG_OPCODE(CODE0,CODE1) \
137 IS_OPCODE (CODE0, CODE1, add_w_wreg_opcode)
138
139 #define SNC_INSN_0 0xA0
140 #define SNC_INSN_1 0x0B
141
142 static const bfd_byte snc_opcode[] =
143 {
144 SNC_INSN_0, SNC_INSN_1
145 };
146
147 #define IS_SNC_OPCODE(CODE0,CODE1) \
148 IS_OPCODE (CODE0, CODE1, snc_opcode)
149
150 #define INC_1_SP_INSN_0 0x2B
151 #define INC_1_SP_INSN_1 0x81
152
153 static const bfd_byte inc_1_sp_opcode[] =
154 {
155 INC_1_SP_INSN_0, INC_1_SP_INSN_1
156 };
157
158 #define IS_INC_1_SP_OPCODE(CODE0,CODE1) \
159 IS_OPCODE (CODE0, CODE1, inc_1_sp_opcode)
160
161 #define ADD_2_SP_W_INSN_0 0x1F
162 #define ADD_2_SP_W_INSN_1 0x82
163
164 static const bfd_byte add_2_sp_w_opcode[] =
165 {
166 ADD_2_SP_W_INSN_0, ADD_2_SP_W_INSN_1
167 };
168
169 #define IS_ADD_2_SP_W_OPCODE(CODE0,CODE1) \
170 IS_OPCODE (CODE0, CODE1, add_2_sp_w_opcode)
171
172 /* Relocation tables. */
173 static reloc_howto_type ip2k_elf_howto_table [] =
174 {
175 #define IP2K_HOWTO(t,rs,s,bs,pr,bp,name,sm,dm) \
176 HOWTO(t, /* type */ \
177 rs, /* rightshift */ \
178 s, /* size (0 = byte, 1 = short, 2 = long) */ \
179 bs, /* bitsize */ \
180 pr, /* pc_relative */ \
181 bp, /* bitpos */ \
182 complain_overflow_dont,/* complain_on_overflow */ \
183 bfd_elf_generic_reloc,/* special_function */ \
184 name, /* name */ \
185 FALSE, /* partial_inplace */ \
186 sm, /* src_mask */ \
187 dm, /* dst_mask */ \
188 pr) /* pcrel_offset */
189
190 /* This reloc does nothing. */
191 IP2K_HOWTO (R_IP2K_NONE, 0,2,32, FALSE, 0, "R_IP2K_NONE", 0, 0),
192 /* A 16 bit absolute relocation. */
193 IP2K_HOWTO (R_IP2K_16, 0,1,16, FALSE, 0, "R_IP2K_16", 0, 0xffff),
194 /* A 32 bit absolute relocation. */
195 IP2K_HOWTO (R_IP2K_32, 0,2,32, FALSE, 0, "R_IP2K_32", 0, 0xffffffff),
196 /* A 8-bit data relocation for the FR9 field. Ninth bit is computed specially. */
197 IP2K_HOWTO (R_IP2K_FR9, 0,1,9, FALSE, 0, "R_IP2K_FR9", 0, 0x00ff),
198 /* A 4-bit data relocation. */
199 IP2K_HOWTO (R_IP2K_BANK, 8,1,4, FALSE, 0, "R_IP2K_BANK", 0, 0x000f),
200 /* A 13-bit insn relocation - word address => right-shift 1 bit extra. */
201 IP2K_HOWTO (R_IP2K_ADDR16CJP, 1,1,13, FALSE, 0, "R_IP2K_ADDR16CJP", 0, 0x1fff),
202 /* A 3-bit insn relocation - word address => right-shift 1 bit extra. */
203 IP2K_HOWTO (R_IP2K_PAGE3, 14,1,3, FALSE, 0, "R_IP2K_PAGE3", 0, 0x0007),
204 /* Two 8-bit data relocations. */
205 IP2K_HOWTO (R_IP2K_LO8DATA, 0,1,8, FALSE, 0, "R_IP2K_LO8DATA", 0, 0x00ff),
206 IP2K_HOWTO (R_IP2K_HI8DATA, 8,1,8, FALSE, 0, "R_IP2K_HI8DATA", 0, 0x00ff),
207 /* Two 8-bit insn relocations. word address => right-shift 1 bit extra. */
208 IP2K_HOWTO (R_IP2K_LO8INSN, 1,1,8, FALSE, 0, "R_IP2K_LO8INSN", 0, 0x00ff),
209 IP2K_HOWTO (R_IP2K_HI8INSN, 9,1,8, FALSE, 0, "R_IP2K_HI8INSN", 0, 0x00ff),
210
211 /* Special 1 bit relocation for SKIP instructions. */
212 IP2K_HOWTO (R_IP2K_PC_SKIP, 1,1,1, FALSE, 12, "R_IP2K_PC_SKIP", 0xfffe, 0x1000),
213 /* 16 bit word address. */
214 IP2K_HOWTO (R_IP2K_TEXT, 1,1,16, FALSE, 0, "R_IP2K_TEXT", 0, 0xffff),
215 /* A 7-bit offset relocation for the FR9 field. Eigth and ninth bit comes from insn. */
216 IP2K_HOWTO (R_IP2K_FR_OFFSET, 0,1,9, FALSE, 0, "R_IP2K_FR_OFFSET", 0x180, 0x007f),
217 /* Bits 23:16 of an address. */
218 IP2K_HOWTO (R_IP2K_EX8DATA, 16,1,8, FALSE, 0, "R_IP2K_EX8DATA", 0, 0x00ff),
219 };
220
221
222 /* Map BFD reloc types to IP2K ELF reloc types. */
223 static reloc_howto_type *
224 ip2k_reloc_type_lookup (abfd, code)
225 bfd * abfd ATTRIBUTE_UNUSED;
226 bfd_reloc_code_real_type code;
227 {
228 /* Note that the ip2k_elf_howto_table is indxed by the R_
229 constants. Thus, the order that the howto records appear in the
230 table *must* match the order of the relocation types defined in
231 include/elf/ip2k.h. */
232
233 switch (code)
234 {
235 case BFD_RELOC_NONE:
236 return &ip2k_elf_howto_table[ (int) R_IP2K_NONE];
237 case BFD_RELOC_16:
238 return &ip2k_elf_howto_table[ (int) R_IP2K_16];
239 case BFD_RELOC_32:
240 return &ip2k_elf_howto_table[ (int) R_IP2K_32];
241 case BFD_RELOC_IP2K_FR9:
242 return &ip2k_elf_howto_table[ (int) R_IP2K_FR9];
243 case BFD_RELOC_IP2K_BANK:
244 return &ip2k_elf_howto_table[ (int) R_IP2K_BANK];
245 case BFD_RELOC_IP2K_ADDR16CJP:
246 return &ip2k_elf_howto_table[ (int) R_IP2K_ADDR16CJP];
247 case BFD_RELOC_IP2K_PAGE3:
248 return &ip2k_elf_howto_table[ (int) R_IP2K_PAGE3];
249 case BFD_RELOC_IP2K_LO8DATA:
250 return &ip2k_elf_howto_table[ (int) R_IP2K_LO8DATA];
251 case BFD_RELOC_IP2K_HI8DATA:
252 return &ip2k_elf_howto_table[ (int) R_IP2K_HI8DATA];
253 case BFD_RELOC_IP2K_LO8INSN:
254 return &ip2k_elf_howto_table[ (int) R_IP2K_LO8INSN];
255 case BFD_RELOC_IP2K_HI8INSN:
256 return &ip2k_elf_howto_table[ (int) R_IP2K_HI8INSN];
257 case BFD_RELOC_IP2K_PC_SKIP:
258 return &ip2k_elf_howto_table[ (int) R_IP2K_PC_SKIP];
259 case BFD_RELOC_IP2K_TEXT:
260 return &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
261 case BFD_RELOC_IP2K_FR_OFFSET:
262 return &ip2k_elf_howto_table[ (int) R_IP2K_FR_OFFSET];
263 case BFD_RELOC_IP2K_EX8DATA:
264 return &ip2k_elf_howto_table[ (int) R_IP2K_EX8DATA];
265 default:
266 /* Pacify gcc -Wall. */
267 return NULL;
268 }
269 return NULL;
270 }
271
272 #define PAGENO(ABSADDR) ((ABSADDR) & 0x1C000)
273 #define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset)
274
275 #define UNDEFINED_SYMBOL (~(bfd_vma)0)
276
277 /* Return the value of the symbol associated with the relocation IREL. */
278
279 static bfd_vma
280 symbol_value (abfd, symtab_hdr, isymbuf, irel)
281 bfd *abfd;
282 Elf_Internal_Shdr *symtab_hdr;
283 Elf_Internal_Sym *isymbuf;
284 Elf_Internal_Rela *irel;
285 {
286 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
287 {
288 Elf_Internal_Sym *isym;
289 asection *sym_sec;
290
291 isym = isymbuf + ELF32_R_SYM (irel->r_info);
292 if (isym->st_shndx == SHN_UNDEF)
293 sym_sec = bfd_und_section_ptr;
294 else if (isym->st_shndx == SHN_ABS)
295 sym_sec = bfd_abs_section_ptr;
296 else if (isym->st_shndx == SHN_COMMON)
297 sym_sec = bfd_com_section_ptr;
298 else
299 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
300
301 return isym->st_value + BASEADDR (sym_sec);
302 }
303 else
304 {
305 unsigned long indx;
306 struct elf_link_hash_entry *h;
307
308 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
309 h = elf_sym_hashes (abfd)[indx];
310 BFD_ASSERT (h != NULL);
311
312 if (h->root.type != bfd_link_hash_defined
313 && h->root.type != bfd_link_hash_defweak)
314 return UNDEFINED_SYMBOL;
315
316 return (h->root.u.def.value + BASEADDR (h->root.u.def.section));
317 }
318 }
319
320 /* Determine if the instruction sequence matches that for
321 the prologue of a switch dispatch table with fewer than
322 128 entries.
323
324 sc
325 page $nnn0
326 jmp $nnn0
327 add w,wreg
328 add pcl,w
329 addr=>
330 page $nnn1
331 jmp $nnn1
332 page $nnn2
333 jmp $nnn2
334 ...
335 page $nnnN
336 jmp $nnnN
337
338 After relaxation.
339 sc
340 page $nnn0
341 jmp $nnn0
342 add pcl,w
343 addr=>
344 jmp $nnn1
345 jmp $nnn2
346 ...
347 jmp $nnnN */
348
349 static bfd_boolean
350 is_switch_128_dispatch_table_p (abfd, addr, relaxed, misc)
351 bfd *abfd ATTRIBUTE_UNUSED;
352 bfd_vma addr;
353 bfd_boolean relaxed;
354 struct misc *misc;
355 {
356 bfd_byte code0, code1;
357
358 if (addr < (3 * 2))
359 return FALSE;
360
361 code0 = bfd_get_8 (abfd, misc->contents + addr - 2);
362 code1 = bfd_get_8 (abfd, misc->contents + addr - 1);
363
364 /* Is it ADD PCL,W */
365 if (! IS_ADD_PCL_W_OPCODE (code0, code1))
366 return FALSE;
367
368 code0 = bfd_get_8 (abfd, misc->contents + addr - 4);
369 code1 = bfd_get_8 (abfd, misc->contents + addr - 3);
370
371 if (relaxed)
372 /* Is it ADD W,WREG */
373 return ! IS_ADD_W_WREG_OPCODE (code0, code1);
374
375 else
376 {
377 /* Is it ADD W,WREG */
378 if (! IS_ADD_W_WREG_OPCODE (code0, code1))
379 return FALSE;
380
381 code0 = bfd_get_8 (abfd, misc->contents + addr - 6);
382 code1 = bfd_get_8 (abfd, misc->contents + addr - 5);
383
384 /* Is it JMP $nnnn */
385 if (! IS_JMP_OPCODE (code0, code1))
386 return FALSE;
387 }
388
389 /* It looks like we've found the prologue for
390 a 1-127 entry switch dispatch table. */
391 return TRUE;
392 }
393
394 /* Determine if the instruction sequence matches that for
395 the prologue switch dispatch table with fewer than
396 256 entries but more than 127.
397
398 Before relaxation.
399 push %lo8insn(label) ; Push address of table
400 push %hi8insn(label)
401 add w,wreg ; index*2 => offset
402 snc ; CARRY SET?
403 inc 1(sp) ; Propagate MSB into table address
404 add 2(sp),w ; Add low bits of offset to table address
405 snc ; and handle any carry-out
406 inc 1(sp)
407 addr=>
408 page __indjmp ; Do an indirect jump to that location
409 jmp __indjmp
410 label: ; case dispatch table starts here
411 page $nnn1
412 jmp $nnn1
413 page $nnn2
414 jmp $nnn2
415 ...
416 page $nnnN
417 jmp $nnnN
418
419 After relaxation.
420 push %lo8insn(label) ; Push address of table
421 push %hi8insn(label)
422 add 2(sp),w ; Add low bits of offset to table address
423 snc ; and handle any carry-out
424 inc 1(sp)
425 addr=>
426 page __indjmp ; Do an indirect jump to that location
427 jmp __indjmp
428 label: ; case dispatch table starts here
429 jmp $nnn1
430 jmp $nnn2
431 ...
432 jmp $nnnN */
433
434 static bfd_boolean
435 is_switch_256_dispatch_table_p (abfd, addr, relaxed, misc)
436 bfd *abfd ATTRIBUTE_UNUSED;
437 bfd_vma addr;
438 bfd_boolean relaxed;
439 struct misc *misc;
440 {
441 bfd_byte code0, code1;
442
443 if (addr < (8 * 2))
444 return FALSE;
445
446 code0 = bfd_get_8 (abfd, misc->contents + addr - 2);
447 code1 = bfd_get_8 (abfd, misc->contents + addr - 1);
448
449 /* Is it INC 1(SP). */
450 if (! IS_INC_1_SP_OPCODE (code0, code1))
451 return FALSE;
452
453 code0 = bfd_get_8 (abfd, misc->contents + addr - 4);
454 code1 = bfd_get_8 (abfd, misc->contents + addr - 3);
455
456 /* Is it SNC. */
457 if (! IS_SNC_OPCODE (code0, code1))
458 return FALSE;
459
460 code0 = bfd_get_8 (abfd, misc->contents + addr - 6);
461 code1 = bfd_get_8 (abfd, misc->contents + addr - 5);
462
463 /* Is it ADD 2(SP),W. */
464 if (! IS_ADD_2_SP_W_OPCODE (code0, code1))
465 return FALSE;
466
467 code0 = bfd_get_8 (abfd, misc->contents + addr - 8);
468 code1 = bfd_get_8 (abfd, misc->contents + addr - 7);
469
470 if (relaxed)
471 /* Is it INC 1(SP). */
472 return ! IS_INC_1_SP_OPCODE (code0, code1);
473
474 else
475 {
476 /* Is it INC 1(SP). */
477 if (! IS_INC_1_SP_OPCODE (code0, code1))
478 return FALSE;
479
480 code0 = bfd_get_8 (abfd, misc->contents + addr - 10);
481 code1 = bfd_get_8 (abfd, misc->contents + addr - 9);
482
483 /* Is it SNC. */
484 if (! IS_SNC_OPCODE (code0, code1))
485 return FALSE;
486
487 code0 = bfd_get_8 (abfd, misc->contents + addr - 12);
488 code1 = bfd_get_8 (abfd, misc->contents + addr - 11);
489
490 /* Is it ADD W,WREG. */
491 if (! IS_ADD_W_WREG_OPCODE (code0, code1))
492 return FALSE;
493 }
494
495 /* It looks like we've found the prologue for
496 a 128-255 entry switch dispatch table. */
497 return TRUE;
498 }
499
500 static bfd_boolean
501 relax_switch_dispatch_tables_pass1 (abfd, sec, addr, misc)
502 bfd *abfd;
503 asection *sec;
504 bfd_vma addr;
505 struct misc *misc;
506 {
507 if (addr + 3 < sec->_cooked_size)
508 {
509 bfd_byte code0 = bfd_get_8 (abfd, misc->contents + addr + 2);
510 bfd_byte code1 = bfd_get_8 (abfd, misc->contents + addr + 3);
511
512 if (IS_JMP_OPCODE (code0, code1)
513 && is_switch_128_dispatch_table_p (abfd, addr, FALSE, misc))
514 {
515 /* Delete ADD W,WREG from prologue. */
516 ip2k_elf_relax_delete_bytes (abfd, sec, addr - (2 * 2), (1 * 2));
517 return TRUE;
518 }
519
520 if (IS_JMP_OPCODE (code0, code1)
521 && is_switch_256_dispatch_table_p (abfd, addr, FALSE, misc))
522 {
523 /* Delete ADD W,WREG; SNC ; INC 1(SP) from prologue. */
524 ip2k_elf_relax_delete_bytes (abfd, sec, addr - 6 * 2, 3 * 2);
525 return TRUE;
526 }
527 }
528
529 return TRUE;
530 }
531
532 static bfd_boolean
533 unrelax_dispatch_table_entries (abfd, sec, first, last, changed, misc)
534 bfd *abfd;
535 asection *sec;
536 bfd_vma first;
537 bfd_vma last;
538 bfd_boolean *changed;
539 struct misc *misc;
540 {
541 bfd_vma addr = first;
542
543 while (addr < last)
544 {
545 bfd_byte code0 = bfd_get_8 (abfd, misc->contents + addr);
546 bfd_byte code1 = bfd_get_8 (abfd, misc->contents + addr + 1);
547
548 /* We are only expecting to find PAGE or JMP insns
549 in the dispatch table. If we find anything else
550 something has gone wrong failed the relaxation
551 which will cause the link to be aborted. */
552
553 if (IS_PAGE_OPCODE (code0, code1))
554 /* Skip the PAGE and JMP insns. */
555 addr += 4;
556 else if (IS_JMP_OPCODE (code0, code1))
557 {
558 Elf_Internal_Rela * irelend = misc->irelbase
559 + sec->reloc_count;
560 Elf_Internal_Rela * irel;
561
562 /* Find the relocation entry. */
563 for (irel = misc->irelbase; irel < irelend; irel++)
564 {
565 if (irel->r_offset == addr
566 && ELF32_R_TYPE (irel->r_info) == R_IP2K_ADDR16CJP)
567 {
568 if (! add_page_insn (abfd, sec, irel, misc))
569 /* Something has gone wrong. */
570 return FALSE;
571
572 *changed = TRUE;
573 break;
574 }
575 }
576
577 /* If we fell off the end something has gone wrong. */
578 if (irel >= irelend)
579 /* Something has gone wrong. */
580 return FALSE;
581
582 /* Skip the PAGE and JMP isns. */
583 addr += 4;
584 /* Acount for the new PAGE insn. */
585 last += 2;
586 }
587 else
588 /* Something has gone wrong. */
589 return FALSE;
590 }
591
592 return TRUE;
593 }
594
595 static bfd_boolean
596 unrelax_switch_dispatch_tables_passN (abfd, sec, addr, changed, misc)
597 bfd *abfd;
598 asection *sec;
599 bfd_vma addr;
600 bfd_boolean *changed;
601 struct misc *misc;
602 {
603 if (2 <= addr && (addr + 3) < sec->_cooked_size)
604 {
605 bfd_byte code0 = bfd_get_8 (abfd, misc->contents + addr - 2);
606 bfd_byte code1 = bfd_get_8 (abfd, misc->contents + addr - 1);
607
608 if (IS_PAGE_OPCODE (code0, code1))
609 {
610 addr -= 2;
611 code0 = bfd_get_8 (abfd, misc->contents + addr + 2);
612 code1 = bfd_get_8 (abfd, misc->contents + addr + 3);
613 }
614 else
615 {
616 code0 = bfd_get_8 (abfd, misc->contents + addr);
617 code1 = bfd_get_8 (abfd, misc->contents + addr + 1);
618 }
619
620 if (IS_JMP_OPCODE (code0, code1)
621 && is_switch_128_dispatch_table_p (abfd, addr, TRUE, misc))
622 {
623 bfd_vma first = addr;
624 bfd_vma last = first;
625 bfd_boolean relaxed = TRUE;
626
627 /* On the final pass we must check if *all* entries in the
628 dispatch table are relaxed. If *any* are not relaxed
629 then we must unrelax *all* the entries in the dispach
630 table and also unrelax the dispatch table prologue. */
631
632 /* Find the last entry in the dispach table. */
633 while (last < sec->_cooked_size)
634 {
635 code0 = bfd_get_8 (abfd, misc->contents + last);
636 code1 = bfd_get_8 (abfd, misc->contents + last + 1);
637
638 if (IS_PAGE_OPCODE (code0, code1))
639 relaxed = FALSE;
640 else if (! IS_JMP_OPCODE (code0, code1))
641 break;
642
643 last += 2;
644 }
645
646 /* We should have found the end of the dispatch table
647 before reaching the end of the section. If we've have
648 reached the end then fail the relaxation which will
649 cause the link to be aborted. */
650 if (last >= sec->_cooked_size)
651 /* Something has gone wrong. */
652 return FALSE;
653
654 /* If we found an unrelaxed entry then
655 unlrelax all the switch table entries. */
656 if (! relaxed )
657 {
658 if (! unrelax_dispatch_table_entries (abfd, sec, first,
659 last, changed, misc))
660 /* Something has gone wrong. */
661 return FALSE;
662
663 if (! is_switch_128_dispatch_table_p (abfd, addr, TRUE, misc))
664 /* Something has gone wrong. */
665 return FALSE;
666
667 /* Unrelax the prologue. */
668
669 /* Insert an ADD W,WREG insnstruction. */
670 if (! ip2k_elf_relax_add_bytes (abfd, sec,
671 addr - 2,
672 add_w_wreg_opcode,
673 sizeof (add_w_wreg_opcode),
674 0))
675 /* Something has gone wrong. */
676 return FALSE;
677 }
678
679 return TRUE;
680 }
681
682 if (IS_JMP_OPCODE (code0, code1)
683 && is_switch_256_dispatch_table_p (abfd, addr, TRUE, misc))
684 {
685 bfd_vma first = addr;
686 bfd_vma last;
687 bfd_boolean relaxed = TRUE;
688
689 /* On the final pass we must check if *all* entries in the
690 dispatch table are relaxed. If *any* are not relaxed
691 then we must unrelax *all* the entries in the dispach
692 table and also unrelax the dispatch table prologue. */
693
694 /* Note the 1st PAGE/JMP instructions are part of the
695 prologue and can safely be relaxed. */
696
697 code0 = bfd_get_8 (abfd, misc->contents + first);
698 code1 = bfd_get_8 (abfd, misc->contents + first + 1);
699
700 if (IS_PAGE_OPCODE (code0, code1))
701 {
702 first += 2;
703 code0 = bfd_get_8 (abfd, misc->contents + first);
704 code1 = bfd_get_8 (abfd, misc->contents + first + 1);
705 }
706
707 if (! IS_JMP_OPCODE (code0, code1))
708 /* Something has gone wrong. */
709 return FALSE;
710
711 first += 2;
712 last = first;
713
714 /* Find the last entry in the dispach table. */
715 while (last < sec->_cooked_size)
716 {
717 code0 = bfd_get_8 (abfd, misc->contents + last);
718 code1 = bfd_get_8 (abfd, misc->contents + last + 1);
719
720 if (IS_PAGE_OPCODE (code0, code1))
721 relaxed = FALSE;
722 else if (! IS_JMP_OPCODE (code0, code1))
723 break;
724
725 last += 2;
726 }
727
728 /* We should have found the end of the dispatch table
729 before reaching the end of the section. If we have
730 reached the end of the section then fail the
731 relaxation. */
732 if (last >= sec->_cooked_size)
733 return FALSE;
734
735 /* If we found an unrelaxed entry then
736 unrelax all the switch table entries. */
737 if (! relaxed)
738 {
739 if (! unrelax_dispatch_table_entries (abfd, sec, first,
740 last, changed, misc))
741 return FALSE;
742
743 if (! is_switch_256_dispatch_table_p (abfd, addr, TRUE, misc))
744 return FALSE;
745
746 /* Unrelax the prologue. */
747
748 /* Insert an INC 1(SP) insnstruction. */
749 if (! ip2k_elf_relax_add_bytes (abfd, sec,
750 addr - 6,
751 inc_1_sp_opcode,
752 sizeof (inc_1_sp_opcode),
753 0))
754 return FALSE;
755
756 /* Insert an SNC insnstruction. */
757 if (! ip2k_elf_relax_add_bytes (abfd, sec,
758 addr - 6,
759 snc_opcode,
760 sizeof (snc_opcode),
761 0))
762 return FALSE;
763
764 /* Insert an ADD W,WREG insnstruction. */
765 if (! ip2k_elf_relax_add_bytes (abfd, sec,
766 addr - 6,
767 add_w_wreg_opcode,
768 sizeof (add_w_wreg_opcode),
769 0))
770 return FALSE;
771 }
772
773 return TRUE;
774 }
775 }
776
777 return TRUE;
778 }
779
780 /* This function handles relaxing for the ip2k. */
781
782 static bfd_boolean
783 ip2k_elf_relax_section (abfd, sec, link_info, again)
784 bfd *abfd;
785 asection *sec;
786 struct bfd_link_info *link_info;
787 bfd_boolean *again;
788 {
789 Elf_Internal_Shdr *symtab_hdr;
790 Elf_Internal_Rela *internal_relocs;
791 bfd_byte *contents = NULL;
792 Elf_Internal_Sym *isymbuf = NULL;
793 static asection * first_section = NULL;
794 static asection * last_section = NULL;
795 static bfd_boolean changed = FALSE;
796 static bfd_boolean final_pass = FALSE;
797 static unsigned int pass = 0;
798 struct misc misc;
799 asection *stab;
800
801 /* Assume nothing changes. */
802 *again = FALSE;
803
804 if (first_section == NULL)
805 first_section = sec;
806
807 if (first_section == sec)
808 {
809 changed = FALSE;
810 pass++;
811 }
812
813 /* If we make too many passes then it's a sign that
814 something is wrong and we fail the relaxation.
815 Note if everything is working correctly then the
816 relaxation should converge reasonably quickly. */
817 if (pass == 4096)
818 return FALSE;
819
820 /* We don't have to do anything for a relocatable link,
821 if this section does not have relocs, or if this is
822 not a code section. */
823 if (link_info->relocateable
824 || (sec->flags & SEC_RELOC) == 0
825 || sec->reloc_count == 0
826 || (sec->flags & SEC_CODE) == 0)
827 return TRUE;
828
829 if (pass == 1)
830 last_section = sec;
831
832 /* If this is the first time we have been called
833 for this section, initialise the cooked size. */
834 if (sec->_cooked_size == 0)
835 sec->_cooked_size = sec->_raw_size;
836
837 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
838
839 internal_relocs = _bfd_elf32_link_read_relocs (abfd, sec, NULL,
840 (Elf_Internal_Rela *)NULL,
841 link_info->keep_memory);
842 if (internal_relocs == NULL)
843 goto error_return;
844
845 /* Make sure the stac.rela stuff gets read in. */
846 stab = bfd_get_section_by_name (abfd, ".stab");
847
848 if (stab)
849 {
850 /* So stab does exits. */
851 Elf_Internal_Rela * irelbase;
852
853 irelbase = _bfd_elf32_link_read_relocs (abfd, stab, NULL,
854 (Elf_Internal_Rela *)NULL,
855 link_info->keep_memory);
856 }
857
858 /* Get section contents cached copy if it exists. */
859 if (contents == NULL)
860 {
861 /* Get cached copy if it exists. */
862 if (elf_section_data (sec)->this_hdr.contents != NULL)
863 contents = elf_section_data (sec)->this_hdr.contents;
864 else
865 {
866 /* Go get them off disk. */
867 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
868 if (contents == NULL)
869 goto error_return;
870
871 if (! bfd_get_section_contents (abfd, sec, contents,
872 (file_ptr) 0, sec->_raw_size))
873 goto error_return;
874 }
875 }
876
877 /* Read this BFD's symbols cached copy if it exists. */
878 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
879 {
880 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
881 if (isymbuf == NULL)
882 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
883 symtab_hdr->sh_info, 0,
884 NULL, NULL, NULL);
885 if (isymbuf == NULL)
886 goto error_return;
887 }
888
889 misc.symtab_hdr = symtab_hdr;
890 misc.isymbuf = isymbuf;
891 misc.irelbase = internal_relocs;
892 misc.contents = contents;
893
894 /* This is where all the relaxation actually get done. */
895
896 if (pass == 1)
897 {
898 /* On the first pass we remove *all* page instructions and
899 relax the prolog for switch dispatch tables. This gets
900 us to the starting point for subsequent passes where
901 we add page instructions back in as needed. */
902
903 if (! ip2k_elf_relax_section_pass1 (abfd, sec, again, &misc))
904 goto error_return;
905
906 changed |= *again;
907 }
908 else
909 {
910 /* Add page instructions back in as needed but we ignore
911 the issue with sections (functions) crossing a page
912 boundary until we have converged to an approximate
913 solution (i.e. nothing has changed on this relaxation
914 pass) and we then know roughly where the page boundaries
915 will end up.
916
917 After we have have converged to an approximate solution
918 we set the final pass flag and continue relaxing. On these
919 final passes if a section (function) cross page boundary
920 we will add *all* the page instructions back into such
921 sections.
922
923 After adding *all* page instructions back into a section
924 which crosses a page bounbdary we reset the final pass flag
925 so the we will again interate until we find a new approximate
926 solution which is closer to the final solution. */
927
928 if (! ip2k_elf_relax_section_passN (abfd, sec, again, &final_pass,
929 &misc))
930 goto error_return;
931
932 changed |= *again;
933
934 /* If nothing has changed on this relaxation
935 pass restart the final relaxaton pass. */
936 if (! changed && last_section == sec)
937 {
938 /* If this was the final pass and we didn't reset
939 the final pass flag then we are done, otherwise
940 do another final pass. */
941 if (! final_pass)
942 {
943 final_pass = TRUE;
944 *again = TRUE;
945 }
946 }
947 }
948
949 /* Perform some house keeping after relaxing the section. */
950
951 if (isymbuf != NULL
952 && symtab_hdr->contents != (unsigned char *) isymbuf)
953 {
954 if (! link_info->keep_memory)
955 free (isymbuf);
956 else
957 symtab_hdr->contents = (unsigned char *) isymbuf;
958 }
959
960 if (contents != NULL
961 && elf_section_data (sec)->this_hdr.contents != contents)
962 {
963 if (! link_info->keep_memory)
964 free (contents);
965 else
966 {
967 /* Cache the section contents for elf_link_input_bfd. */
968 elf_section_data (sec)->this_hdr.contents = contents;
969 }
970 }
971
972 if (internal_relocs != NULL
973 && elf_section_data (sec)->relocs != internal_relocs)
974 free (internal_relocs);
975
976 return TRUE;
977
978 error_return:
979 if (isymbuf != NULL
980 && symtab_hdr->contents != (unsigned char *) isymbuf)
981 free (isymbuf);
982 if (contents != NULL
983 && elf_section_data (sec)->this_hdr.contents != contents)
984 free (contents);
985 if (internal_relocs != NULL
986 && elf_section_data (sec)->relocs != internal_relocs)
987 free (internal_relocs);
988 return FALSE;
989 }
990
991 /* This function handles relaxation during the first pass. */
992
993 static bfd_boolean
994 ip2k_elf_relax_section_pass1 (abfd, sec, again, misc)
995 bfd *abfd;
996 asection *sec;
997 bfd_boolean *again;
998 struct misc * misc;
999 {
1000 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
1001 Elf_Internal_Rela *irel;
1002
1003 /* Walk thru the section looking for relaxation opertunities. */
1004 for (irel = misc->irelbase; irel < irelend; irel++)
1005 {
1006 if (ELF32_R_TYPE (irel->r_info) == (int) R_IP2K_PAGE3)
1007 {
1008 bfd_byte code0 = bfd_get_8 (abfd,
1009 misc->contents + irel->r_offset);
1010 bfd_byte code1 = bfd_get_8 (abfd,
1011 misc->contents + irel->r_offset + 1);
1012
1013 /* Verify that this is the PAGE opcode. */
1014 if (IS_PAGE_OPCODE (code0, code1))
1015 {
1016 /* Note that we've changed the relocs, section contents, etc. */
1017 elf_section_data (sec)->relocs = misc->irelbase;
1018 elf_section_data (sec)->this_hdr.contents = misc->contents;
1019 misc->symtab_hdr->contents = (bfd_byte *) misc->isymbuf;
1020
1021 /* Handle switch dispatch tables/prologues. */
1022 if (! relax_switch_dispatch_tables_pass1 (abfd, sec,
1023 irel->r_offset, misc))
1024 return FALSE;
1025
1026 /* Fix the relocation's type. */
1027 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1028 R_IP2K_NONE);
1029
1030 /* Delete the PAGE insn. */
1031 if (! ip2k_elf_relax_delete_bytes (abfd, sec,
1032 irel->r_offset,
1033 sizeof (page_opcode)))
1034 return FALSE;
1035
1036 /* That will change things, so, we should relax again.
1037 Note that this is not required, and it may be slow. */
1038 *again = TRUE;
1039 }
1040 }
1041 }
1042
1043 return TRUE;
1044 }
1045
1046 /* This function handles relaxation for 2nd and subsequent passes. */
1047
1048 static bfd_boolean
1049 ip2k_elf_relax_section_passN (abfd, sec, again, final_pass, misc)
1050 bfd *abfd;
1051 asection *sec;
1052 bfd_boolean *again;
1053 bfd_boolean *final_pass;
1054 struct misc * misc;
1055 {
1056 Elf_Internal_Rela *irelend = misc->irelbase + sec->reloc_count;
1057 Elf_Internal_Rela *irel;
1058 bfd_boolean add_all;
1059
1060 /* If we are on the final relaxation pass and the section crosses
1061 then set a flag to indicate that *all* page instructions need
1062 to be added back into this section. */
1063 if (*final_pass)
1064 {
1065 add_all = (PAGENO (BASEADDR (sec))
1066 != PAGENO (BASEADDR (sec) + sec->_cooked_size));
1067
1068 /* If this section crosses a page boundary set the crossed
1069 page boundary flag. */
1070 if (add_all)
1071 sec->userdata = sec;
1072 else
1073 {
1074 /* If the section had previously crossed a page boundary
1075 but on this pass does not then reset crossed page
1076 boundary flag and rerun the 1st relaxation pass on
1077 this section. */
1078 if (sec->userdata)
1079 {
1080 sec->userdata = NULL;
1081 if (! ip2k_elf_relax_section_pass1 (abfd, sec, again, misc))
1082 return FALSE;
1083 }
1084 }
1085 }
1086 else
1087 add_all = FALSE;
1088
1089 /* Walk thru the section looking for call/jmp
1090 instructions which need a page instruction. */
1091 for (irel = misc->irelbase; irel < irelend; irel++)
1092 {
1093 if (ELF32_R_TYPE (irel->r_info) == (int) R_IP2K_ADDR16CJP)
1094 {
1095 /* Get the value of the symbol referred to by the reloc. */
1096 bfd_vma symval = symbol_value (abfd, misc->symtab_hdr, misc->isymbuf,
1097 irel);
1098 bfd_byte code0, code1;
1099
1100 if (symval == UNDEFINED_SYMBOL)
1101 {
1102 /* This appears to be a reference to an undefined
1103 symbol. Just ignore it--it will be caught by the
1104 regular reloc processing. */
1105 continue;
1106 }
1107
1108 /* For simplicity of coding, we are going to modify the section
1109 contents, the section relocs, and the BFD symbol table. We
1110 must tell the rest of the code not to free up this
1111 information. It would be possible to instead create a table
1112 of changes which have to be made, as is done in coff-mips.c;
1113 that would be more work, but would require less memory when
1114 the linker is run. */
1115
1116 /* Get the opcode. */
1117 code0 = bfd_get_8 (abfd, misc->contents + irel->r_offset);
1118 code1 = bfd_get_8 (abfd, misc->contents + irel->r_offset + 1);
1119
1120 if (IS_JMP_OPCODE (code0, code1) || IS_CALL_OPCODE (code0, code1))
1121 {
1122 if (*final_pass)
1123 {
1124 if (! unrelax_switch_dispatch_tables_passN (abfd, sec,
1125 irel->r_offset,
1126 again, misc))
1127 return FALSE;
1128
1129 if (*again)
1130 add_all = FALSE;
1131 }
1132
1133 code0 = bfd_get_8 (abfd, misc->contents + irel->r_offset - 2);
1134 code1 = bfd_get_8 (abfd, misc->contents + irel->r_offset - 1);
1135
1136 if (! IS_PAGE_OPCODE (code0, code1))
1137 {
1138 bfd_vma value = symval + irel->r_addend;
1139 bfd_vma addr = BASEADDR (sec) + irel->r_offset;
1140
1141 if (add_all || PAGENO (addr) != PAGENO (value))
1142 {
1143 if (! add_page_insn (abfd, sec, irel, misc))
1144 return FALSE;
1145
1146 /* That will have changed things, so, we must relax again. */
1147 *again = TRUE;
1148 }
1149 }
1150 }
1151 }
1152 }
1153
1154 /* If anything changed reset the final pass flag. */
1155 if (*again)
1156 *final_pass = FALSE;
1157
1158 return TRUE;
1159 }
1160
1161 /* Parts of a Stabs entry. */
1162
1163 #define STRDXOFF (0)
1164 #define TYPEOFF (4)
1165 #define OTHEROFF (5)
1166 #define DESCOFF (6)
1167 #define VALOFF (8)
1168 #define STABSIZE (12)
1169
1170 /* Adjust all the relocations entries after adding or inserting instructions. */
1171
1172 static void
1173 adjust_all_relocations (abfd, sec, addr, endaddr, count, noadj)
1174 bfd *abfd;
1175 asection *sec;
1176 bfd_vma addr;
1177 bfd_vma endaddr;
1178 int count;
1179 int noadj;
1180 {
1181 Elf_Internal_Shdr *symtab_hdr;
1182 Elf_Internal_Sym *isymbuf, *isym, *isymend;
1183 unsigned int shndx;
1184 bfd_byte *contents;
1185 Elf_Internal_Rela *irel, *irelend, *irelbase;
1186 struct elf_link_hash_entry **sym_hashes;
1187 struct elf_link_hash_entry **end_hashes;
1188 unsigned int symcount;
1189
1190 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1191 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1192
1193 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1194
1195 contents = elf_section_data (sec)->this_hdr.contents;
1196
1197 irelbase = elf_section_data (sec)->relocs;
1198 irelend = irelbase + sec->reloc_count;
1199
1200 for (irel = irelbase; irel < irelend; irel++)
1201 {
1202 if (ELF32_R_TYPE (irel->r_info) != R_IP2K_NONE)
1203 {
1204 /* Get the value of the symbol referred to by the reloc. */
1205 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1206 {
1207 asection *sym_sec;
1208
1209 /* A local symbol. */
1210 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1211 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1212
1213 if (isym->st_shndx == shndx)
1214 {
1215 bfd_vma baseaddr = BASEADDR (sec);
1216 bfd_vma symval = BASEADDR (sym_sec) + isym->st_value
1217 + irel->r_addend;
1218
1219 if ((baseaddr + addr + noadj) <= symval
1220 && symval < (baseaddr + endaddr))
1221 irel->r_addend += count;
1222 }
1223 }
1224 }
1225
1226 /* Do this only for PC space relocations. */
1227 if (addr <= irel->r_offset && irel->r_offset < endaddr)
1228 irel->r_offset += count;
1229 }
1230
1231 /* When adding an instruction back it is sometimes necessary to move any
1232 global or local symbol that was referencing the first instruction of
1233 the moved block to refer to the first instruction of the inserted block.
1234
1235 For example adding a PAGE instruction before a CALL or JMP requires
1236 that any label on the CALL or JMP is moved to the PAGE insn. */
1237 addr += noadj;
1238
1239 /* Adjust the local symbols defined in this section. */
1240 isymend = isymbuf + symtab_hdr->sh_info;
1241 for (isym = isymbuf; isym < isymend; isym++)
1242 {
1243 if (isym->st_shndx == shndx
1244 && addr <= isym->st_value
1245 && isym->st_value < endaddr)
1246 isym->st_value += count;
1247 }
1248
1249 /* Now adjust the global symbols defined in this section. */
1250 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1251 - symtab_hdr->sh_info);
1252 sym_hashes = elf_sym_hashes (abfd);
1253 end_hashes = sym_hashes + symcount;
1254 for (; sym_hashes < end_hashes; sym_hashes++)
1255 {
1256 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1257 if ((sym_hash->root.type == bfd_link_hash_defined
1258 || sym_hash->root.type == bfd_link_hash_defweak)
1259 && sym_hash->root.u.def.section == sec)
1260 {
1261 if (addr <= sym_hash->root.u.def.value
1262 && sym_hash->root.u.def.value < endaddr)
1263 {
1264 sym_hash->root.u.def.value += count;
1265 }
1266 }
1267 }
1268
1269 return;
1270 }
1271
1272 static bfd_boolean
1273 add_page_insn (abfd, sec, irel, misc)
1274 bfd *abfd;
1275 asection *sec;
1276 Elf_Internal_Rela *irel;
1277 struct misc *misc;
1278 {
1279 /* Note that we've changed the relocs, section contents, etc. */
1280 elf_section_data (sec)->relocs = misc->irelbase;
1281 elf_section_data (sec)->this_hdr.contents = misc->contents;
1282 misc->symtab_hdr->contents = (bfd_byte *) misc->isymbuf;
1283
1284 /* Add the PAGE insn. */
1285 if (! ip2k_elf_relax_add_bytes (abfd, sec, irel->r_offset,
1286 page_opcode,
1287 sizeof (page_opcode),
1288 sizeof (page_opcode)))
1289 return FALSE;
1290 else
1291 {
1292 Elf_Internal_Rela * jrel = irel - 1;
1293
1294 /* Add relocation for PAGE insn added. */
1295 if (ELF32_R_TYPE (jrel->r_info) != R_IP2K_NONE)
1296 {
1297 bfd_byte code0, code1;
1298 char *msg = NULL;
1299
1300 /* Get the opcode. */
1301 code0 = bfd_get_8 (abfd, misc->contents + irel->r_offset);
1302 code1 = bfd_get_8 (abfd, misc->contents + irel->r_offset + 1);
1303
1304 if (IS_JMP_OPCODE (code0, code1))
1305 msg = "\tJMP instruction missing a preceeding PAGE instruction in %s\n\n";
1306
1307 else if (IS_CALL_OPCODE (code0, code1))
1308 msg = "\tCALL instruction missing a preceeding PAGE instruction in %s\n\n";
1309
1310 if (msg)
1311 {
1312 fprintf (stderr, "\n\t *** LINKER RELAXATION failure ***\n");
1313 fprintf (stderr, msg, sec->owner->filename);
1314 }
1315
1316 return FALSE;
1317 }
1318
1319 jrel->r_addend = irel->r_addend;
1320 jrel->r_offset = irel->r_offset - sizeof (page_opcode);
1321 jrel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1322 R_IP2K_PAGE3);
1323 }
1324
1325 return TRUE;
1326 }
1327
1328 /* Insert bytes into a section while relaxing. */
1329
1330 static bfd_boolean
1331 ip2k_elf_relax_add_bytes (abfd, sec, addr, bytes, count, noadj)
1332 bfd *abfd;
1333 asection *sec;
1334 bfd_vma addr;
1335 const bfd_byte *bytes;
1336 int count;
1337 int noadj;
1338 {
1339 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
1340 bfd_vma endaddr = sec->_cooked_size;
1341
1342 /* Make room to insert the bytes. */
1343 memmove (contents + addr + count, contents + addr, endaddr - addr);
1344
1345 /* Insert the bytes into the section. */
1346 memcpy (contents + addr, bytes, count);
1347
1348 sec->_cooked_size += count;
1349
1350 adjust_all_relocations (abfd, sec, addr, endaddr, count, noadj);
1351 return TRUE;
1352 }
1353
1354 /* Delete some bytes from a section while relaxing. */
1355
1356 static bfd_boolean
1357 ip2k_elf_relax_delete_bytes (abfd, sec, addr, count)
1358 bfd *abfd;
1359 asection *sec;
1360 bfd_vma addr;
1361 int count;
1362 {
1363 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
1364 bfd_vma endaddr = sec->_cooked_size;
1365
1366 /* Actually delete the bytes. */
1367 memmove (contents + addr, contents + addr + count,
1368 endaddr - addr - count);
1369
1370 sec->_cooked_size -= count;
1371
1372 adjust_all_relocations (abfd, sec, addr + count, endaddr, -count, 0);
1373 return TRUE;
1374 }
1375
1376 /* -------------------------------------------------------------------- */
1377
1378 /* XXX: The following code is the result of a cut&paste. This unfortunate
1379 practice is very widespread in the various target back-end files. */
1380
1381 /* Set the howto pointer for a IP2K ELF reloc. */
1382
1383 static void
1384 ip2k_info_to_howto_rela (abfd, cache_ptr, dst)
1385 bfd * abfd ATTRIBUTE_UNUSED;
1386 arelent * cache_ptr;
1387 Elf_Internal_Rela * dst;
1388 {
1389 unsigned int r_type;
1390
1391 r_type = ELF32_R_TYPE (dst->r_info);
1392 switch (r_type)
1393 {
1394 default:
1395 cache_ptr->howto = & ip2k_elf_howto_table [r_type];
1396 break;
1397 }
1398 }
1399
1400 /* Perform a single relocation.
1401 By default we use the standard BFD routines. */
1402
1403 static bfd_reloc_status_type
1404 ip2k_final_link_relocate (howto, input_bfd, input_section, contents, rel,
1405 relocation)
1406 reloc_howto_type * howto;
1407 bfd * input_bfd;
1408 asection * input_section;
1409 bfd_byte * contents;
1410 Elf_Internal_Rela * rel;
1411 bfd_vma relocation;
1412 {
1413 bfd_reloc_status_type r = bfd_reloc_ok;
1414
1415 switch (howto->type)
1416 {
1417 /* Handle data space relocations. */
1418 case R_IP2K_FR9:
1419 case R_IP2K_BANK:
1420 if ((relocation & IP2K_DATA_MASK) == IP2K_DATA_VALUE)
1421 relocation &= ~IP2K_DATA_MASK;
1422 else
1423 r = bfd_reloc_notsupported;
1424 break;
1425
1426 case R_IP2K_LO8DATA:
1427 case R_IP2K_HI8DATA:
1428 case R_IP2K_EX8DATA:
1429 break;
1430
1431 /* Handle insn space relocations. */
1432 case R_IP2K_ADDR16CJP:
1433 case R_IP2K_PAGE3:
1434 case R_IP2K_LO8INSN:
1435 case R_IP2K_HI8INSN:
1436 case R_IP2K_PC_SKIP:
1437 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1438 relocation &= ~IP2K_INSN_MASK;
1439 else
1440 r = bfd_reloc_notsupported;
1441 break;
1442
1443 case R_IP2K_16:
1444 /* If this is a relocation involving a TEXT
1445 symbol, reduce it to a word address. */
1446 if ((relocation & IP2K_INSN_MASK) == IP2K_INSN_VALUE)
1447 howto = &ip2k_elf_howto_table[ (int) R_IP2K_TEXT];
1448 break;
1449
1450 /* Pass others through. */
1451 default:
1452 break;
1453 }
1454
1455 /* Only install relocation if above tests did not disqualify it. */
1456 if (r == bfd_reloc_ok)
1457 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1458 contents, rel->r_offset,
1459 relocation, rel->r_addend);
1460
1461 return r;
1462 }
1463
1464 /* Relocate a IP2K ELF section.
1465
1466 The RELOCATE_SECTION function is called by the new ELF backend linker
1467 to handle the relocations for a section.
1468
1469 The relocs are always passed as Rela structures; if the section
1470 actually uses Rel structures, the r_addend field will always be
1471 zero.
1472
1473 This function is responsible for adjusting the section contents as
1474 necessary, and (if using Rela relocs and generating a relocateable
1475 output file) adjusting the reloc addend as necessary.
1476
1477 This function does not have to worry about setting the reloc
1478 address or the reloc symbol index.
1479
1480 LOCAL_SYMS is a pointer to the swapped in local symbols.
1481
1482 LOCAL_SECTIONS is an array giving the section in the input file
1483 corresponding to the st_shndx field of each local symbol.
1484
1485 The global hash table entry for the global symbols can be found
1486 via elf_sym_hashes (input_bfd).
1487
1488 When generating relocateable output, this function must handle
1489 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1490 going to be the section symbol corresponding to the output
1491 section, which means that the addend must be adjusted
1492 accordingly. */
1493
1494 static bfd_boolean
1495 ip2k_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1496 contents, relocs, local_syms, local_sections)
1497 bfd *output_bfd ATTRIBUTE_UNUSED;
1498 struct bfd_link_info *info;
1499 bfd *input_bfd;
1500 asection *input_section;
1501 bfd_byte *contents;
1502 Elf_Internal_Rela *relocs;
1503 Elf_Internal_Sym *local_syms;
1504 asection **local_sections;
1505 {
1506 Elf_Internal_Shdr *symtab_hdr;
1507 struct elf_link_hash_entry **sym_hashes;
1508 Elf_Internal_Rela *rel;
1509 Elf_Internal_Rela *relend;
1510
1511 if (info->relocateable)
1512 return TRUE;
1513
1514 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1515 sym_hashes = elf_sym_hashes (input_bfd);
1516 relend = relocs + input_section->reloc_count;
1517
1518 for (rel = relocs; rel < relend; rel ++)
1519 {
1520 reloc_howto_type * howto;
1521 unsigned long r_symndx;
1522 Elf_Internal_Sym * sym;
1523 asection * sec;
1524 struct elf_link_hash_entry * h;
1525 bfd_vma relocation;
1526 bfd_reloc_status_type r;
1527 const char * name = NULL;
1528 int r_type;
1529
1530 /* This is a final link. */
1531 r_type = ELF32_R_TYPE (rel->r_info);
1532 r_symndx = ELF32_R_SYM (rel->r_info);
1533 howto = ip2k_elf_howto_table + ELF32_R_TYPE (rel->r_info);
1534 h = NULL;
1535 sym = NULL;
1536 sec = NULL;
1537
1538 if (r_symndx < symtab_hdr->sh_info)
1539 {
1540 sym = local_syms + r_symndx;
1541 sec = local_sections [r_symndx];
1542 relocation = BASEADDR (sec) + sym->st_value;
1543
1544 name = bfd_elf_string_from_elf_section
1545 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1546 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1547 }
1548 else
1549 {
1550 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
1551
1552 while (h->root.type == bfd_link_hash_indirect
1553 || h->root.type == bfd_link_hash_warning)
1554 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1555
1556 name = h->root.root.string;
1557
1558 if (h->root.type == bfd_link_hash_defined
1559 || h->root.type == bfd_link_hash_defweak)
1560 {
1561 sec = h->root.u.def.section;
1562 relocation = h->root.u.def.value + BASEADDR (sec);
1563 }
1564 else if (h->root.type == bfd_link_hash_undefweak)
1565 {
1566 relocation = 0;
1567 }
1568 else
1569 {
1570 if (! ((*info->callbacks->undefined_symbol)
1571 (info, h->root.root.string, input_bfd,
1572 input_section, rel->r_offset,
1573 (! info->shared || info->no_undefined))))
1574 return FALSE;
1575 relocation = 0;
1576 }
1577 }
1578
1579 /* Finally, the sole IP2K-specific part. */
1580 r = ip2k_final_link_relocate (howto, input_bfd, input_section,
1581 contents, rel, relocation);
1582
1583 if (r != bfd_reloc_ok)
1584 {
1585 const char * msg = (const char *) NULL;
1586
1587 switch (r)
1588 {
1589 case bfd_reloc_overflow:
1590 r = info->callbacks->reloc_overflow
1591 (info, name, howto->name, (bfd_vma) 0,
1592 input_bfd, input_section, rel->r_offset);
1593 break;
1594
1595 case bfd_reloc_undefined:
1596 r = info->callbacks->undefined_symbol
1597 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1598 break;
1599
1600 case bfd_reloc_outofrange:
1601 msg = _("internal error: out of range error");
1602 break;
1603
1604 /* This is how ip2k_final_link_relocate tells us of a non-kosher
1605 reference between insn & data address spaces. */
1606 case bfd_reloc_notsupported:
1607 if (sym != NULL) /* Only if it's not an unresolved symbol. */
1608 msg = _("unsupported relocation between data/insn address spaces");
1609 break;
1610
1611 case bfd_reloc_dangerous:
1612 msg = _("internal error: dangerous relocation");
1613 break;
1614
1615 default:
1616 msg = _("internal error: unknown error");
1617 break;
1618 }
1619
1620 if (msg)
1621 r = info->callbacks->warning
1622 (info, msg, name, input_bfd, input_section, rel->r_offset);
1623
1624 if (! r)
1625 return FALSE;
1626 }
1627 }
1628
1629 return TRUE;
1630 }
1631
1632 static asection *
1633 ip2k_elf_gc_mark_hook (sec, info, rel, h, sym)
1634 asection *sec;
1635 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1636 Elf_Internal_Rela *rel;
1637 struct elf_link_hash_entry *h;
1638 Elf_Internal_Sym *sym;
1639 {
1640 if (h != NULL)
1641 {
1642 switch (ELF32_R_TYPE (rel->r_info))
1643 {
1644 #if 0
1645 case R_IP2K_GNU_VTINHERIT:
1646 case R_IP2K_GNU_VTENTRY:
1647 break;
1648 #endif
1649
1650 default:
1651 switch (h->root.type)
1652 {
1653 case bfd_link_hash_defined:
1654 case bfd_link_hash_defweak:
1655 return h->root.u.def.section;
1656
1657 case bfd_link_hash_common:
1658 return h->root.u.c.p->section;
1659
1660 default:
1661 break;
1662 }
1663 }
1664 }
1665 else
1666 {
1667 if (!(elf_bad_symtab (sec->owner)
1668 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1669 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1670 && sym->st_shndx != SHN_COMMON))
1671 {
1672 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1673 }
1674 }
1675 return NULL;
1676 }
1677
1678 static bfd_boolean
1679 ip2k_elf_gc_sweep_hook (abfd, info, sec, relocs)
1680 bfd *abfd ATTRIBUTE_UNUSED;
1681 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1682 asection *sec ATTRIBUTE_UNUSED;
1683 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
1684 {
1685 /* we don't use got and plt entries for ip2k */
1686 return TRUE;
1687 }
1688
1689
1690 /* -------------------------------------------------------------------- */
1691
1692
1693 #define TARGET_BIG_SYM bfd_elf32_ip2k_vec
1694 #define TARGET_BIG_NAME "elf32-ip2k"
1695
1696 #define ELF_ARCH bfd_arch_ip2k
1697 #define ELF_MACHINE_CODE EM_IP2K
1698 #define ELF_MACHINE_ALT1 EM_IP2K_OLD
1699 #define ELF_MAXPAGESIZE 1 /* No pages on the IP2K */
1700
1701 #define elf_info_to_howto_rel NULL
1702 #define elf_info_to_howto ip2k_info_to_howto_rela
1703
1704 #define elf_backend_can_gc_sections 1
1705 #define elf_backend_rela_normal 1
1706 #define elf_backend_gc_mark_hook ip2k_elf_gc_mark_hook
1707 #define elf_backend_gc_sweep_hook ip2k_elf_gc_sweep_hook
1708
1709 #define elf_backend_relocate_section ip2k_elf_relocate_section
1710
1711 #define elf_symbol_leading_char '_'
1712 #define bfd_elf32_bfd_reloc_type_lookup ip2k_reloc_type_lookup
1713 #define bfd_elf32_bfd_relax_section ip2k_elf_relax_section
1714
1715
1716 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.089997 seconds and 5 git commands to generate.