?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
daily update
[binutils/dougsmingw.git] / bfd / coff-tic80.c
blob6455e492334c9c5aea02328861b13db89959ac77
1 /* BFD back-end for Texas Instruments TMS320C80 Multimedia Video Processor (MVP).
2 Copyright 1996, 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
3 Free Software Foundation, Inc.
4
5 Written by Fred Fish (fnf@cygnus.com)
6
7 There is nothing new under the sun. This file draws a lot on other
8 coff files.
9
10 This file is part of BFD, the Binary File Descriptor library.
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, 51 Franklin Street - Fifth Floor,
25 Boston, MA 02110-1301, USA. */
26
27 #include "sysdep.h"
28 #include "bfd.h"
29 #include "bfdlink.h"
30 #include "libbfd.h"
31 #ifdef _CONST
32 /* Newlib-based hosts define _CONST as a STDC-safe alias for const,
33 but to the tic80 toolchain it means something altogether different.
34 Since sysdep.h will have pulled in stdio.h and hence _ansi.h which
35 contains this definition, we must undef it before including the
36 tic80-specific definition. */
37 #undef _CONST
38 #endif /* _CONST */
39 #include "coff/tic80.h"
40 #include "coff/internal.h"
41 #include "libcoff.h"
42
43 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
44 #define COFF_ALIGN_IN_SECTION_HEADER 1
45 #define COFF_ALIGN_IN_SFLAGS 1
46
47 #define GET_SCNHDR_FLAGS H_GET_16
48 #define PUT_SCNHDR_FLAGS H_PUT_16
49
50 static void rtype2howto
51 PARAMS ((arelent *cache_ptr, struct internal_reloc *dst));
52 static bfd_reloc_status_type ppbase_reloc
53 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
54 static bfd_reloc_status_type glob15_reloc
55 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
56 static bfd_reloc_status_type glob16_reloc
57 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
58 static bfd_reloc_status_type local16_reloc
59 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
60 static bfd_boolean coff_tic80_relocate_section
61 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
62 struct internal_reloc *, struct internal_syment *, asection **));
63 static reloc_howto_type * coff_tic80_rtype_to_howto
64 PARAMS ((bfd *, asection *, struct internal_reloc *,
65 struct coff_link_hash_entry *, struct internal_syment *,
66 bfd_vma *));
67
68 static reloc_howto_type tic80_howto_table[] =
69 {
70
71 HOWTO (R_RELLONG, /* type */
72 0, /* rightshift */
73 2, /* size (0 = byte, 1 = short, 2 = long) */
74 32, /* bitsize */
75 FALSE, /* pc_relative */
76 0, /* bitpos */
77 complain_overflow_bitfield, /* complain_on_overflow */
78 NULL, /* special_function */
79 "RELLONG", /* name */
80 TRUE, /* partial_inplace */
81 0xffffffff, /* src_mask */
82 0xffffffff, /* dst_mask */
83 FALSE), /* pcrel_offset */
84
85 HOWTO (R_MPPCR, /* type */
86 2, /* rightshift */
87 2, /* size (0 = byte, 1 = short, 2 = long) */
88 32, /* bitsize */
89 TRUE, /* pc_relative */
90 0, /* bitpos */
91 complain_overflow_signed, /* complain_on_overflow */
92 NULL, /* special_function */
93 "MPPCR", /* name */
94 TRUE, /* partial_inplace */
95 0xffffffff, /* src_mask */
96 0xffffffff, /* dst_mask */
97 TRUE), /* pcrel_offset */
98
99 HOWTO (R_ABS, /* type */
100 0, /* rightshift */
101 2, /* size (0 = byte, 1 = short, 2 = long) */
102 32, /* bitsize */
103 FALSE, /* pc_relative */
104 0, /* bitpos */
105 complain_overflow_bitfield, /* complain_on_overflow */
106 NULL, /* special_function */
107 "ABS", /* name */
108 TRUE, /* partial_inplace */
109 0xffffffff, /* src_mask */
110 0xffffffff, /* dst_mask */
111 FALSE), /* pcrel_offset */
112
113 HOWTO (R_PPBASE, /* type */
114 0, /* rightshift */
115 2, /* size (0 = byte, 1 = short, 2 = long) */
116 32, /* bitsize */
117 FALSE, /* pc_relative */
118 0, /* bitpos */
119 complain_overflow_dont, /* complain_on_overflow */
120 ppbase_reloc, /* special_function */
121 "PPBASE", /* name */
122 TRUE, /* partial_inplace */
123 0xffffffff, /* src_mask */
124 0xffffffff, /* dst_mask */
125 FALSE), /* pcrel_offset */
126
127 HOWTO (R_PPLBASE, /* type */
128 0, /* rightshift */
129 2, /* size (0 = byte, 1 = short, 2 = long) */
130 32, /* bitsize */
131 FALSE, /* pc_relative */
132 0, /* bitpos */
133 complain_overflow_dont, /* complain_on_overflow */
134 ppbase_reloc, /* special_function */
135 "PPLBASE", /* name */
136 TRUE, /* partial_inplace */
137 0xffffffff, /* src_mask */
138 0xffffffff, /* dst_mask */
139 FALSE), /* pcrel_offset */
140
141 HOWTO (R_PP15, /* type */
142 0, /* rightshift */
143 2, /* size (0 = byte, 1 = short, 2 = long) */
144 15, /* bitsize */
145 FALSE, /* pc_relative */
146 6, /* bitpos */
147 complain_overflow_dont, /* complain_on_overflow */
148 glob15_reloc, /* special_function */
149 "PP15", /* name */
150 TRUE, /* partial_inplace */
151 0x1ffc0, /* src_mask */
152 0x1ffc0, /* dst_mask */
153 FALSE), /* pcrel_offset */
154
155 HOWTO (R_PP15W, /* type */
156 2, /* rightshift */
157 2, /* size (0 = byte, 1 = short, 2 = long) */
158 15, /* bitsize */
159 FALSE, /* pc_relative */
160 6, /* bitpos */
161 complain_overflow_dont, /* complain_on_overflow */
162 glob15_reloc, /* special_function */
163 "PP15W", /* name */
164 TRUE, /* partial_inplace */
165 0x1ffc0, /* src_mask */
166 0x1ffc0, /* dst_mask */
167 FALSE), /* pcrel_offset */
168
169 HOWTO (R_PP15H, /* type */
170 1, /* rightshift */
171 2, /* size (0 = byte, 1 = short, 2 = long) */
172 15, /* bitsize */
173 FALSE, /* pc_relative */
174 6, /* bitpos */
175 complain_overflow_dont, /* complain_on_overflow */
176 glob15_reloc, /* special_function */
177 "PP15H", /* name */
178 TRUE, /* partial_inplace */
179 0x1ffc0, /* src_mask */
180 0x1ffc0, /* dst_mask */
181 FALSE), /* pcrel_offset */
182
183 HOWTO (R_PP16B, /* type */
184 0, /* rightshift */
185 2, /* size (0 = byte, 1 = short, 2 = long) */
186 16, /* bitsize */
187 FALSE, /* pc_relative */
188 6, /* bitpos */
189 complain_overflow_dont, /* complain_on_overflow */
190 glob16_reloc, /* special_function */
191 "PP16B", /* name */
192 TRUE, /* partial_inplace */
193 0x3ffc0, /* src_mask */
194 0x3ffc0, /* dst_mask */
195 FALSE), /* pcrel_offset */
196
197 HOWTO (R_PPL15, /* type */
198 0, /* rightshift */
199 2, /* size (0 = byte, 1 = short, 2 = long) */
200 15, /* bitsize */
201 FALSE, /* pc_relative */
202 0, /* bitpos */
203 complain_overflow_dont, /* complain_on_overflow */
204 NULL, /* special_function */
205 "PPL15", /* name */
206 TRUE, /* partial_inplace */
207 0x7fff, /* src_mask */
208 0x7fff, /* dst_mask */
209 FALSE), /* pcrel_offset */
210
211 HOWTO (R_PPL15W, /* type */
212 2, /* rightshift */
213 2, /* size (0 = byte, 1 = short, 2 = long) */
214 15, /* bitsize */
215 FALSE, /* pc_relative */
216 0, /* bitpos */
217 complain_overflow_dont, /* complain_on_overflow */
218 NULL, /* special_function */
219 "PPL15W", /* name */
220 TRUE, /* partial_inplace */
221 0x7fff, /* src_mask */
222 0x7fff, /* dst_mask */
223 FALSE), /* pcrel_offset */
224
225 HOWTO (R_PPL15H, /* type */
226 1, /* rightshift */
227 2, /* size (0 = byte, 1 = short, 2 = long) */
228 15, /* bitsize */
229 FALSE, /* pc_relative */
230 0, /* bitpos */
231 complain_overflow_dont, /* complain_on_overflow */
232 NULL, /* special_function */
233 "PPL15H", /* name */
234 TRUE, /* partial_inplace */
235 0x7fff, /* src_mask */
236 0x7fff, /* dst_mask */
237 FALSE), /* pcrel_offset */
238
239 HOWTO (R_PPL16B, /* type */
240 0, /* rightshift */
241 2, /* size (0 = byte, 1 = short, 2 = long) */
242 16, /* bitsize */
243 FALSE, /* pc_relative */
244 0, /* bitpos */
245 complain_overflow_dont, /* complain_on_overflow */
246 local16_reloc, /* special_function */
247 "PPL16B", /* name */
248 TRUE, /* partial_inplace */
249 0xffff, /* src_mask */
250 0xffff, /* dst_mask */
251 FALSE), /* pcrel_offset */
252
253 HOWTO (R_PPN15, /* type */
254 0, /* rightshift */
255 -2, /* size (0 = byte, 1 = short, 2 = long) */
256 15, /* bitsize */
257 FALSE, /* pc_relative */
258 6, /* bitpos */
259 complain_overflow_dont, /* complain_on_overflow */
260 glob15_reloc, /* special_function */
261 "PPN15", /* name */
262 TRUE, /* partial_inplace */
263 0x1ffc0, /* src_mask */
264 0x1ffc0, /* dst_mask */
265 FALSE), /* pcrel_offset */
266
267 HOWTO (R_PPN15W, /* type */
268 2, /* rightshift */
269 -2, /* size (0 = byte, 1 = short, 2 = long) */
270 15, /* bitsize */
271 FALSE, /* pc_relative */
272 6, /* bitpos */
273 complain_overflow_dont, /* complain_on_overflow */
274 glob15_reloc, /* special_function */
275 "PPN15W", /* name */
276 TRUE, /* partial_inplace */
277 0x1ffc0, /* src_mask */
278 0x1ffc0, /* dst_mask */
279 FALSE), /* pcrel_offset */
280
281 HOWTO (R_PPN15H, /* type */
282 1, /* rightshift */
283 -2, /* size (0 = byte, 1 = short, 2 = long) */
284 15, /* bitsize */
285 FALSE, /* pc_relative */
286 6, /* bitpos */
287 complain_overflow_dont, /* complain_on_overflow */
288 glob15_reloc, /* special_function */
289 "PPN15H", /* name */
290 TRUE, /* partial_inplace */
291 0x1ffc0, /* src_mask */
292 0x1ffc0, /* dst_mask */
293 FALSE), /* pcrel_offset */
294
295 HOWTO (R_PPN16B, /* type */
296 0, /* rightshift */
297 -2, /* size (0 = byte, 1 = short, 2 = long) */
298 16, /* bitsize */
299 FALSE, /* pc_relative */
300 6, /* bitpos */
301 complain_overflow_dont, /* complain_on_overflow */
302 glob16_reloc, /* special_function */
303 "PPN16B", /* name */
304 TRUE, /* partial_inplace */
305 0x3ffc0, /* src_mask */
306 0x3ffc0, /* dst_mask */
307 FALSE), /* pcrel_offset */
308
309 HOWTO (R_PPLN15, /* type */
310 0, /* rightshift */
311 -2, /* size (0 = byte, 1 = short, 2 = long) */
312 15, /* bitsize */
313 FALSE, /* pc_relative */
314 0, /* bitpos */
315 complain_overflow_dont, /* complain_on_overflow */
316 NULL, /* special_function */
317 "PPLN15", /* name */
318 TRUE, /* partial_inplace */
319 0x7fff, /* src_mask */
320 0x7fff, /* dst_mask */
321 FALSE), /* pcrel_offset */
322
323 HOWTO (R_PPLN15W, /* type */
324 2, /* rightshift */
325 -2, /* size (0 = byte, 1 = short, 2 = long) */
326 15, /* bitsize */
327 FALSE, /* pc_relative */
328 0, /* bitpos */
329 complain_overflow_dont, /* complain_on_overflow */
330 NULL, /* special_function */
331 "PPLN15W", /* name */
332 TRUE, /* partial_inplace */
333 0x7fff, /* src_mask */
334 0x7fff, /* dst_mask */
335 FALSE), /* pcrel_offset */
336
337 HOWTO (R_PPLN15H, /* type */
338 1, /* rightshift */
339 -2, /* size (0 = byte, 1 = short, 2 = long) */
340 15, /* bitsize */
341 FALSE, /* pc_relative */
342 0, /* bitpos */
343 complain_overflow_dont, /* complain_on_overflow */
344 NULL, /* special_function */
345 "PPLN15H", /* name */
346 TRUE, /* partial_inplace */
347 0x7fff, /* src_mask */
348 0x7fff, /* dst_mask */
349 FALSE), /* pcrel_offset */
350
351 HOWTO (R_PPLN16B, /* type */
352 0, /* rightshift */
353 -2, /* size (0 = byte, 1 = short, 2 = long) */
354 15, /* bitsize */
355 FALSE, /* pc_relative */
356 0, /* bitpos */
357 complain_overflow_dont, /* complain_on_overflow */
358 local16_reloc, /* special_function */
359 "PPLN16B", /* name */
360 TRUE, /* partial_inplace */
361 0xffff, /* src_mask */
362 0xffff, /* dst_mask */
363 FALSE) /* pcrel_offset */
364 };
365 \f
366 /* Special relocation functions, used when the output file is not
367 itself a COFF TIc80 file. */
368
369 /* This special function is used for the base address type
370 relocations. */
371
372 static bfd_reloc_status_type
373 ppbase_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
374 error_message)
375 bfd *abfd ATTRIBUTE_UNUSED;
376 arelent *reloc_entry ATTRIBUTE_UNUSED;
377 asymbol *symbol_in ATTRIBUTE_UNUSED;
378 PTR data ATTRIBUTE_UNUSED;
379 asection *input_section ATTRIBUTE_UNUSED;
380 bfd *output_bfd ATTRIBUTE_UNUSED;
381 char **error_message ATTRIBUTE_UNUSED;
382 {
383 /* FIXME. */
384 abort ();
385 }
386
387 /* This special function is used for the global 15 bit relocations. */
388
389 static bfd_reloc_status_type
390 glob15_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
391 error_message)
392 bfd *abfd ATTRIBUTE_UNUSED;
393 arelent *reloc_entry ATTRIBUTE_UNUSED;
394 asymbol *symbol_in ATTRIBUTE_UNUSED;
395 PTR data ATTRIBUTE_UNUSED;
396 asection *input_section ATTRIBUTE_UNUSED;
397 bfd *output_bfd ATTRIBUTE_UNUSED;
398 char **error_message ATTRIBUTE_UNUSED;
399 {
400 /* FIXME. */
401 abort ();
402 }
403
404 /* This special function is used for the global 16 bit relocations. */
405
406 static bfd_reloc_status_type
407 glob16_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
408 error_message)
409 bfd *abfd ATTRIBUTE_UNUSED;
410 arelent *reloc_entry ATTRIBUTE_UNUSED;
411 asymbol *symbol_in ATTRIBUTE_UNUSED;
412 PTR data ATTRIBUTE_UNUSED;
413 asection *input_section ATTRIBUTE_UNUSED;
414 bfd *output_bfd ATTRIBUTE_UNUSED;
415 char **error_message ATTRIBUTE_UNUSED;
416 {
417 /* FIXME. */
418 abort ();
419 }
420
421 /* This special function is used for the local 16 bit relocations. */
422
423 static bfd_reloc_status_type
424 local16_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
425 error_message)
426 bfd *abfd ATTRIBUTE_UNUSED;
427 arelent *reloc_entry ATTRIBUTE_UNUSED;
428 asymbol *symbol_in ATTRIBUTE_UNUSED;
429 PTR data ATTRIBUTE_UNUSED;
430 asection *input_section ATTRIBUTE_UNUSED;
431 bfd *output_bfd ATTRIBUTE_UNUSED;
432 char **error_message ATTRIBUTE_UNUSED;
433 {
434 /* FIXME. */
435 abort ();
436 }
437 \f
438 /* Code to turn an external r_type into a pointer to an entry in the howto_table.
439 If passed an r_type we don't recognize the abort rather than silently failing
440 to generate an output file. */
441
442 static void
443 rtype2howto (cache_ptr, dst)
444 arelent *cache_ptr;
445 struct internal_reloc *dst;
446 {
447 unsigned int i;
448
449 for (i = 0; i < sizeof tic80_howto_table / sizeof tic80_howto_table[0]; i++)
450 {
451 if (tic80_howto_table[i].type == dst->r_type)
452 {
453 cache_ptr->howto = tic80_howto_table + i;
454 return;
455 }
456 }
457
458 (*_bfd_error_handler) (_("Unrecognized reloc type 0x%x"),
459 (unsigned int) dst->r_type);
460 cache_ptr->howto = tic80_howto_table + 0;
461 }
462
463 #define RTYPE2HOWTO(cache_ptr, dst) rtype2howto (cache_ptr, dst)
464 #define coff_rtype_to_howto coff_tic80_rtype_to_howto
465
466 static reloc_howto_type *
467 coff_tic80_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
468 bfd *abfd ATTRIBUTE_UNUSED;
469 asection *sec;
470 struct internal_reloc *rel;
471 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
472 struct internal_syment *sym ATTRIBUTE_UNUSED;
473 bfd_vma *addendp;
474 {
475 arelent genrel;
476
477 if (rel -> r_symndx == -1 && addendp != NULL)
478 {
479 /* This is a TI "internal relocation", which means that the relocation
480 amount is the amount by which the current section is being relocated
481 in the output section. */
482 *addendp = (sec -> output_section -> vma + sec -> output_offset) - sec -> vma;
483 }
484 RTYPE2HOWTO (&genrel, rel);
485 return genrel.howto;
486 }
487
488 #ifndef BADMAG
489 #define BADMAG(x) TIC80BADMAG(x)
490 #endif
491 \f
492 #define coff_relocate_section coff_tic80_relocate_section
493
494 /* We need a special relocation routine to handle the PP relocs. Most
495 of this is a copy of _bfd_coff_generic_relocate_section. */
496
497 static bfd_boolean
498 coff_tic80_relocate_section (output_bfd, info, input_bfd,
499 input_section, contents, relocs, syms,
500 sections)
501 bfd *output_bfd;
502 struct bfd_link_info *info;
503 bfd *input_bfd;
504 asection *input_section;
505 bfd_byte *contents;
506 struct internal_reloc *relocs;
507 struct internal_syment *syms;
508 asection **sections;
509 {
510 struct internal_reloc *rel;
511 struct internal_reloc *relend;
512
513 rel = relocs;
514 relend = rel + input_section->reloc_count;
515 for (; rel < relend; rel++)
516 {
517 long symndx;
518 struct coff_link_hash_entry *h;
519 struct internal_syment *sym;
520 bfd_vma addend;
521 bfd_vma val;
522 reloc_howto_type *howto;
523 bfd_reloc_status_type rstat;
524 bfd_vma addr;
525
526 symndx = rel->r_symndx;
527
528 if (symndx == -1)
529 {
530 h = NULL;
531 sym = NULL;
532 }
533 else
534 {
535 h = obj_coff_sym_hashes (input_bfd)[symndx];
536 sym = syms + symndx;
537 }
538
539 /* COFF treats common symbols in one of two ways. Either the
540 size of the symbol is included in the section contents, or it
541 is not. We assume that the size is not included, and force
542 the rtype_to_howto function to adjust the addend as needed. */
543
544 if (sym != NULL && sym->n_scnum != 0)
545 addend = - sym->n_value;
546 else
547 addend = 0;
548
549 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
550 sym, &addend);
551 if (howto == NULL)
552 return FALSE;
553
554 val = 0;
555
556 if (h == NULL)
557 {
558 asection *sec;
559
560 if (symndx == -1)
561 {
562 sec = bfd_abs_section_ptr;
563 val = 0;
564 }
565 else
566 {
567 sec = sections[symndx];
568 val = (sec->output_section->vma
569 + sec->output_offset
570 + sym->n_value);
571 if (! obj_pe (output_bfd))
572 val -= sec->vma;
573 }
574 }
575 else
576 {
577 if (h->root.type == bfd_link_hash_defined
578 || h->root.type == bfd_link_hash_defweak)
579 {
580 asection *sec;
581
582 sec = h->root.u.def.section;
583 val = (h->root.u.def.value
584 + sec->output_section->vma
585 + sec->output_offset);
586 }
587
588 else if (! info->relocatable)
589 {
590 if (! ((*info->callbacks->undefined_symbol)
591 (info, h->root.root.string, input_bfd, input_section,
592 rel->r_vaddr - input_section->vma, TRUE)))
593 return FALSE;
594 }
595 }
596
597 addr = rel->r_vaddr - input_section->vma;
598
599 /* FIXME: This code assumes little endian, but the PP can
600 apparently be bi-endian. I don't know if the bi-endianness
601 applies to the instruction set or just to the data. */
602 switch (howto->type)
603 {
604 default:
605 case R_ABS:
606 case R_RELLONGX:
607 case R_PPL15:
608 case R_PPL15W:
609 case R_PPL15H:
610 case R_PPLN15:
611 case R_PPLN15W:
612 case R_PPLN15H:
613 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
614 contents, addr, val, addend);
615 break;
616
617 case R_PP15:
618 case R_PP15W:
619 case R_PP15H:
620 case R_PPN15:
621 case R_PPN15W:
622 case R_PPN15H:
623 /* Offset the address so that we can use 4 byte relocations. */
624 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
625 contents + 2, addr, val, addend);
626 break;
627
628 case R_PP16B:
629 case R_PPN16B:
630 {
631 /* The most significant bit is stored in bit 6. */
632 bfd_byte hold;
633
634 hold = contents[addr + 4];
635 contents[addr + 4] &=~ 0x20;
636 contents[addr + 4] |= (contents[addr] >> 1) & 0x20;
637 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
638 contents + 2, addr,
639 val, addend);
640 contents[addr] &=~ 0x40;
641 contents[addr] |= (contents[addr + 4] << 1) & 0x40;
642 contents[addr + 4] &=~ 0x20;
643 contents[addr + 4] |= hold & 0x20;
644 break;
645 }
646
647 case R_PPL16B:
648 case R_PPLN16B:
649 {
650 /* The most significant bit is stored in bit 28. */
651 bfd_byte hold;
652
653 hold = contents[addr + 1];
654 contents[addr + 1] &=~ 0x80;
655 contents[addr + 1] |= (contents[addr + 3] << 3) & 0x80;
656 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
657 contents, addr,
658 val, addend);
659 contents[addr + 3] &= ~0x10;
660 contents[addr + 3] |= (contents[addr + 1] >> 3) & 0x10;
661 contents[addr + 1] &=~ 0x80;
662 contents[addr + 1] |= hold & 0x80;
663 break;
664 }
665
666 case R_PPBASE:
667 /* Parameter RAM is from 0x1000000 to 0x1000800. */
668 contents[addr] &=~ 0x3;
669 if (val >= 0x1000000 && val < 0x1000800)
670 contents[addr] |= 0x3;
671 else
672 contents[addr] |= 0x2;
673 rstat = bfd_reloc_ok;
674 break;
675
676 case R_PPLBASE:
677 /* Parameter RAM is from 0x1000000 to 0x1000800. */
678 contents[addr + 2] &= ~0xc0;
679 if (val >= 0x1000000 && val < 0x1000800)
680 contents[addr + 2] |= 0xc0;
681 else
682 contents[addr + 2] |= 0x80;
683 rstat = bfd_reloc_ok;
684 break;
685 }
686
687 switch (rstat)
688 {
689 default:
690 abort ();
691 case bfd_reloc_ok:
692 break;
693 case bfd_reloc_outofrange:
694 (*_bfd_error_handler)
695 (_("%B: bad reloc address 0x%lx in section `%A'"),
696 input_bfd, input_section, (unsigned long) rel->r_vaddr);
697 return FALSE;
698 case bfd_reloc_overflow:
699 {
700 const char *name;
701 char buf[SYMNMLEN + 1];
702
703 if (symndx == -1)
704 name = "*ABS*";
705 else if (h != NULL)
706 name = NULL;
707 else
708 {
709 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
710 if (name == NULL)
711 return FALSE;
712 }
713
714 if (! ((*info->callbacks->reloc_overflow)
715 (info, (h ? &h->root : NULL), name, howto->name,
716 (bfd_vma) 0, input_bfd, input_section,
717 rel->r_vaddr - input_section->vma)))
718 return FALSE;
719 }
720 }
721 }
722 return TRUE;
723 }
724 \f
725 /* Clear the r_reserved field in relocs. */
726 #define SWAP_OUT_RELOC_EXTRA(abfd,src,dst) \
727 do \
728 { \
729 dst->r_reserved[0] = 0; \
730 dst->r_reserved[1] = 0; \
731 } \
732 while (0)
733
734 #define TIC80COFF 1 /* Customize coffcode.h */
735 #undef C_AUTOARG /* Clashes with TIc80's C_UEXT */
736 #undef C_LASTENT /* Clashes with TIc80's C_STATLAB */
737
738 #ifndef bfd_pe_print_pdata
739 #define bfd_pe_print_pdata NULL
740 #endif
741
742 #include "coffcode.h"
743
744 CREATE_LITTLE_COFF_TARGET_VEC (tic80coff_vec, "coff-tic80", D_PAGED, 0, '_', NULL, COFF_SWAP_TABLE)
Patches to binutils for mingw-w64