1 /* BFD support for the ns32k architecture.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Almost totally rewritten by Ian Dall from initial work
4 by Andrew Cagney.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "libbfd.h"
26 #include "ns32k.h"
27
28 #define N(machine, printable, d, next) \
29 { 32, 32, 8, bfd_arch_ns32k, machine, "ns32k",printable,3,d, \
30 bfd_default_compatible,bfd_default_scan,bfd_arch_default_fill,next, }
31
32 static const bfd_arch_info_type arch_info_struct[] =
33 {
34 N(32532,"ns32k:32532",TRUE, 0), /* The word ns32k will match this too. */
35 };
36
37 const bfd_arch_info_type bfd_ns32k_arch =
38 N(32032,"ns32k:32032",FALSE, &arch_info_struct[0]);
39
40 bfd_vma
_bfd_ns32k_get_displacement(bfd_byte * buffer,int size)41 _bfd_ns32k_get_displacement (bfd_byte *buffer, int size)
42 {
43 bfd_signed_vma value;
44
45 switch (size)
46 {
47 case 1:
48 value = ((*buffer & 0x7f) ^ 0x40) - 0x40;
49 break;
50
51 case 2:
52 value = ((*buffer++ & 0x3f) ^ 0x20) - 0x20;
53 value = (value << 8) | (0xff & *buffer);
54 break;
55
56 case 4:
57 value = ((*buffer++ & 0x3f) ^ 0x20) - 0x20;
58 value = (value << 8) | (0xff & *buffer++);
59 value = (value << 8) | (0xff & *buffer++);
60 value = (value << 8) | (0xff & *buffer);
61 break;
62
63 default:
64 abort ();
65 return 0;
66 }
67
68 return value;
69 }
70
71 void
_bfd_ns32k_put_displacement(bfd_vma value,bfd_byte * buffer,int size)72 _bfd_ns32k_put_displacement (bfd_vma value, bfd_byte *buffer, int size)
73 {
74 switch (size)
75 {
76 case 1:
77 value &= 0x7f;
78 *buffer++ = value;
79 break;
80
81 case 2:
82 value &= 0x3fff;
83 value |= 0x8000;
84 *buffer++ = (value >> 8);
85 *buffer++ = value;
86 break;
87
88 case 4:
89 value |= (bfd_vma) 0xc0000000;
90 *buffer++ = (value >> 24);
91 *buffer++ = (value >> 16);
92 *buffer++ = (value >> 8);
93 *buffer++ = value;
94 break;
95 }
96 return;
97 }
98
99 bfd_vma
_bfd_ns32k_get_immediate(bfd_byte * buffer,int size)100 _bfd_ns32k_get_immediate (bfd_byte *buffer, int size)
101 {
102 bfd_vma value = 0;
103
104 switch (size)
105 {
106 case 4:
107 value = (value << 8) | (*buffer++ & 0xff);
108 value = (value << 8) | (*buffer++ & 0xff);
109 case 2:
110 value = (value << 8) | (*buffer++ & 0xff);
111 case 1:
112 value = (value << 8) | (*buffer++ & 0xff);
113 break;
114 default:
115 abort ();
116 }
117 return value;
118 }
119
120 void
_bfd_ns32k_put_immediate(bfd_vma value,bfd_byte * buffer,int size)121 _bfd_ns32k_put_immediate (bfd_vma value, bfd_byte *buffer, int size)
122 {
123 buffer += size - 1;
124 switch (size)
125 {
126 case 4:
127 *buffer-- = (value & 0xff); value >>= 8;
128 *buffer-- = (value & 0xff); value >>= 8;
129 case 2:
130 *buffer-- = (value & 0xff); value >>= 8;
131 case 1:
132 *buffer-- = (value & 0xff); value >>= 8;
133 }
134 }
135
136 /* This is just like the standard perform_relocation except we
137 use get_data and put_data which know about the ns32k storage
138 methods. This is probably a lot more complicated than it
139 needs to be! */
140
141 static bfd_reloc_status_type
do_ns32k_reloc(bfd * abfd,arelent * reloc_entry,struct bfd_symbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED,bfd_vma (* get_data)(bfd_byte *,int),void (* put_data)(bfd_vma,bfd_byte *,int))142 do_ns32k_reloc (bfd * abfd,
143 arelent * reloc_entry,
144 struct bfd_symbol * symbol,
145 void * data,
146 asection * input_section,
147 bfd * output_bfd,
148 char ** error_message ATTRIBUTE_UNUSED,
149 bfd_vma (* get_data) (bfd_byte *, int),
150 void (* put_data) (bfd_vma, bfd_byte *, int))
151 {
152 int overflow = 0;
153 bfd_vma relocation;
154 bfd_reloc_status_type flag = bfd_reloc_ok;
155 bfd_size_type addr = reloc_entry->address;
156 bfd_vma output_base = 0;
157 reloc_howto_type *howto = reloc_entry->howto;
158 asection *reloc_target_output_section;
159 bfd_byte *location;
160
161 if (bfd_is_abs_section (symbol->section)
162 && output_bfd != (bfd *) NULL)
163 {
164 reloc_entry->address += input_section->output_offset;
165 return bfd_reloc_ok;
166 }
167
168 /* If we are not producing relocatable output, return an error if
169 the symbol is not defined. An undefined weak symbol is
170 considered to have a value of zero (SVR4 ABI, p. 4-27). */
171 if (bfd_is_und_section (symbol->section)
172 && (symbol->flags & BSF_WEAK) == 0
173 && output_bfd == (bfd *) NULL)
174 flag = bfd_reloc_undefined;
175
176 /* Is the address of the relocation really within the section? */
177 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
178 return bfd_reloc_outofrange;
179
180 /* Work out which section the relocation is targeted at and the
181 initial relocation command value. */
182
183 /* Get symbol value. (Common symbols are special.) */
184 if (bfd_is_com_section (symbol->section))
185 relocation = 0;
186 else
187 relocation = symbol->value;
188
189 reloc_target_output_section = symbol->section->output_section;
190
191 /* Convert input-section-relative symbol value to absolute. */
192 if (output_bfd != NULL && ! howto->partial_inplace)
193 output_base = 0;
194 else
195 output_base = reloc_target_output_section->vma;
196
197 relocation += output_base + symbol->section->output_offset;
198
199 /* Add in supplied addend. */
200 relocation += reloc_entry->addend;
201
202 /* Here the variable relocation holds the final address of the
203 symbol we are relocating against, plus any addend. */
204
205 if (howto->pc_relative)
206 {
207 /* This is a PC relative relocation. We want to set RELOCATION
208 to the distance between the address of the symbol and the
209 location. RELOCATION is already the address of the symbol.
210
211 We start by subtracting the address of the section containing
212 the location.
213
214 If pcrel_offset is set, we must further subtract the position
215 of the location within the section. Some targets arrange for
216 the addend to be the negative of the position of the location
217 within the section; for example, i386-aout does this. For
218 i386-aout, pcrel_offset is FALSE. Some other targets do not
219 include the position of the location; for example, m88kbcs,
220 or ELF. For those targets, pcrel_offset is TRUE.
221
222 If we are producing relocatable output, then we must ensure
223 that this reloc will be correctly computed when the final
224 relocation is done. If pcrel_offset is FALSE we want to wind
225 up with the negative of the location within the section,
226 which means we must adjust the existing addend by the change
227 in the location within the section. If pcrel_offset is TRUE
228 we do not want to adjust the existing addend at all.
229
230 FIXME: This seems logical to me, but for the case of
231 producing relocatable output it is not what the code
232 actually does. I don't want to change it, because it seems
233 far too likely that something will break. */
234 relocation -=
235 input_section->output_section->vma + input_section->output_offset;
236
237 if (howto->pcrel_offset)
238 relocation -= reloc_entry->address;
239 }
240
241 if (output_bfd != (bfd *) NULL)
242 {
243 if (! howto->partial_inplace)
244 {
245 /* This is a partial relocation, and we want to apply the relocation
246 to the reloc entry rather than the raw data. Modify the reloc
247 inplace to reflect what we now know. */
248 reloc_entry->addend = relocation;
249 reloc_entry->address += input_section->output_offset;
250 return flag;
251 }
252 else
253 {
254 /* This is a partial relocation, but inplace, so modify the
255 reloc record a bit.
256
257 If we've relocated with a symbol with a section, change
258 into a ref to the section belonging to the symbol. */
259
260 reloc_entry->address += input_section->output_offset;
261
262 /* WTF?? */
263 if (abfd->xvec->flavour == bfd_target_coff_flavour)
264 {
265 /* For m68k-coff, the addend was being subtracted twice during
266 relocation with -r. Removing the line below this comment
267 fixes that problem; see PR 2953.
268
269 However, Ian wrote the following, regarding removing the line
270 below, which explains why it is still enabled: --djm
271
272 If you put a patch like that into BFD you need to check all
273 the COFF linkers. I am fairly certain that patch will break
274 coff-i386 (e.g., SCO); see coff_i386_reloc in coff-i386.c
275 where I worked around the problem in a different way. There
276 may very well be a reason that the code works as it does.
277
278 Hmmm. The first obvious point is that bfd_perform_relocation
279 should not have any tests that depend upon the flavour. It's
280 seem like entirely the wrong place for such a thing. The
281 second obvious point is that the current code ignores the
282 reloc addend when producing relocatable output for COFF.
283 That's peculiar. In fact, I really have no idea what the
284 point of the line you want to remove is.
285
286 A typical COFF reloc subtracts the old value of the symbol
287 and adds in the new value to the location in the object file
288 (if it's a pc relative reloc it adds the difference between
289 the symbol value and the location). When relocating we need
290 to preserve that property.
291
292 BFD handles this by setting the addend to the negative of the
293 old value of the symbol. Unfortunately it handles common
294 symbols in a non-standard way (it doesn't subtract the old
295 value) but that's a different story (we can't change it
296 without losing backward compatibility with old object files)
297 (coff-i386 does subtract the old value, to be compatible with
298 existing coff-i386 targets, like SCO).
299
300 So everything works fine when not producing relocatable
301 output. When we are producing relocatable output, logically
302 we should do exactly what we do when not producing
303 relocatable output. Therefore, your patch is correct. In
304 fact, it should probably always just set reloc_entry->addend
305 to 0 for all cases, since it is, in fact, going to add the
306 value into the object file. This won't hurt the COFF code,
307 which doesn't use the addend; I'm not sure what it will do
308 to other formats (the thing to check for would be whether
309 any formats both use the addend and set partial_inplace).
310
311 When I wanted to make coff-i386 produce relocatable output,
312 I ran into the problem that you are running into: I wanted
313 to remove that line. Rather than risk it, I made the
314 coff-i386 relocs use a special function; it's coff_i386_reloc
315 in coff-i386.c. The function specifically adds the addend
316 field into the object file, knowing that bfd_perform_relocation
317 is not going to. If you remove that line, then coff-i386.c
318 will wind up adding the addend field in twice. It's trivial
319 to fix; it just needs to be done.
320
321 The problem with removing the line is just that it may break
322 some working code. With BFD it's hard to be sure of anything.
323 The right way to deal with this is simply to build and test at
324 least all the supported COFF targets. It should be
325 straightforward if time and disk space consuming. For each
326 target:
327 1) build the linker
328 2) generate some executable, and link it using -r (I would
329 probably use paranoia.o and link against newlib/libc.a,
330 which for all the supported targets would be available in
331 /usr/cygnus/progressive/H-host/target/lib/libc.a).
332 3) make the change to reloc.c
333 4) rebuild the linker
334 5) repeat step 2
335 6) if the resulting object files are the same, you have at
336 least made it no worse
337 7) if they are different you have to figure out which
338 version is right. */
339 relocation -= reloc_entry->addend;
340 reloc_entry->addend = 0;
341 }
342 else
343 {
344 reloc_entry->addend = relocation;
345 }
346 }
347 }
348 else
349 {
350 reloc_entry->addend = 0;
351 }
352
353 /* FIXME: This overflow checking is incomplete, because the value
354 might have overflowed before we get here. For a correct check we
355 need to compute the value in a size larger than bitsize, but we
356 can't reasonably do that for a reloc the same size as a host
357 machine word.
358 FIXME: We should also do overflow checking on the result after
359 adding in the value contained in the object file. */
360 if (howto->complain_on_overflow != complain_overflow_dont)
361 {
362 bfd_vma check;
363
364 /* Get the value that will be used for the relocation, but
365 starting at bit position zero. */
366 if (howto->rightshift > howto->bitpos)
367 check = relocation >> (howto->rightshift - howto->bitpos);
368 else
369 check = relocation << (howto->bitpos - howto->rightshift);
370 switch (howto->complain_on_overflow)
371 {
372 case complain_overflow_signed:
373 {
374 /* Assumes two's complement. */
375 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
376 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
377
378 /* The above right shift is incorrect for a signed value.
379 Fix it up by forcing on the upper bits. */
380 if (howto->rightshift > howto->bitpos
381 && (bfd_signed_vma) relocation < 0)
382 check |= ((bfd_vma) - 1
383 & ~((bfd_vma) - 1
384 >> (howto->rightshift - howto->bitpos)));
385 if ((bfd_signed_vma) check > reloc_signed_max
386 || (bfd_signed_vma) check < reloc_signed_min)
387 flag = bfd_reloc_overflow;
388 }
389 break;
390 case complain_overflow_unsigned:
391 {
392 /* Assumes two's complement. This expression avoids
393 overflow if howto->bitsize is the number of bits in
394 bfd_vma. */
395 bfd_vma reloc_unsigned_max =
396 (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
397
398 if ((bfd_vma) check > reloc_unsigned_max)
399 flag = bfd_reloc_overflow;
400 }
401 break;
402 case complain_overflow_bitfield:
403 {
404 /* Assumes two's complement. This expression avoids
405 overflow if howto->bitsize is the number of bits in
406 bfd_vma. */
407 bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
408
409 if (((bfd_vma) check & ~reloc_bits) != 0
410 && (((bfd_vma) check & ~reloc_bits)
411 != (-(bfd_vma) 1 & ~reloc_bits)))
412 {
413 /* The above right shift is incorrect for a signed
414 value. See if turning on the upper bits fixes the
415 overflow. */
416 if (howto->rightshift > howto->bitpos
417 && (bfd_signed_vma) relocation < 0)
418 {
419 check |= ((bfd_vma) - 1
420 & ~((bfd_vma) - 1
421 >> (howto->rightshift - howto->bitpos)));
422 if (((bfd_vma) check & ~reloc_bits)
423 != (-(bfd_vma) 1 & ~reloc_bits))
424 flag = bfd_reloc_overflow;
425 }
426 else
427 flag = bfd_reloc_overflow;
428 }
429 }
430 break;
431 default:
432 abort ();
433 }
434 }
435
436 /* Either we are relocating all the way, or we don't want to apply
437 the relocation to the reloc entry (probably because there isn't
438 any room in the output format to describe addends to relocs). */
439
440 /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
441 (OSF version 1.3, compiler version 3.11). It miscompiles the
442 following program:
443
444 struct str
445 {
446 unsigned int i0;
447 } s = { 0 };
448
449 int
450 main ()
451 {
452 unsigned long x;
453
454 x = 0x100000000;
455 x <<= (unsigned long) s.i0;
456 if (x == 0)
457 printf ("failed\n");
458 else
459 printf ("succeeded (%lx)\n", x);
460 }
461 */
462
463 relocation >>= (bfd_vma) howto->rightshift;
464
465 /* Shift everything up to where it's going to be used. */
466 relocation <<= (bfd_vma) howto->bitpos;
467
468 /* Wait for the day when all have the mask in them. */
469
470 /* What we do:
471 i instruction to be left alone
472 o offset within instruction
473 r relocation offset to apply
474 S src mask
475 D dst mask
476 N ~dst mask
477 A part 1
478 B part 2
479 R result
480
481 Do this:
482 i i i i i o o o o o from bfd_get<size>
483 and S S S S S to get the size offset we want
484 + r r r r r r r r r r to get the final value to place
485 and D D D D D to chop to right size
486 -----------------------
487 A A A A A
488 And this:
489 ... i i i i i o o o o o from bfd_get<size>
490 and N N N N N get instruction
491 -----------------------
492 ... B B B B B
493
494 And then:
495 B B B B B
496 or A A A A A
497 -----------------------
498 R R R R R R R R R R put into bfd_put<size>. */
499
500 #define DOIT(x) \
501 x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask))
502
503 location = (bfd_byte *) data + addr;
504 switch (howto->size)
505 {
506 case 0:
507 {
508 bfd_vma x = get_data (location, 1);
509 DOIT (x);
510 put_data ((bfd_vma) x, location, 1);
511 }
512 break;
513
514 case 1:
515 if (relocation)
516 {
517 bfd_vma x = get_data (location, 2);
518 DOIT (x);
519 put_data ((bfd_vma) x, location, 2);
520 }
521 break;
522 case 2:
523 if (relocation)
524 {
525 bfd_vma x = get_data (location, 4);
526 DOIT (x);
527 put_data ((bfd_vma) x, location, 4);
528 }
529 break;
530 case -2:
531 {
532 bfd_vma x = get_data (location, 4);
533 relocation = -relocation;
534 DOIT(x);
535 put_data ((bfd_vma) x, location, 4);
536 }
537 break;
538
539 case 3:
540 /* Do nothing. */
541 break;
542
543 case 4:
544 #ifdef BFD64
545 if (relocation)
546 {
547 bfd_vma x = get_data (location, 8);
548 DOIT (x);
549 put_data (x, location, 8);
550 }
551 #else
552 abort ();
553 #endif
554 break;
555 default:
556 return bfd_reloc_other;
557 }
558 if ((howto->complain_on_overflow != complain_overflow_dont) && overflow)
559 return bfd_reloc_overflow;
560
561 return flag;
562 }
563
564 /* Relocate a given location using a given value and howto. */
565
566 bfd_reloc_status_type
_bfd_do_ns32k_reloc_contents(reloc_howto_type * howto,bfd * input_bfd ATTRIBUTE_UNUSED,bfd_vma relocation,bfd_byte * location,bfd_vma (* get_data)(bfd_byte *,int),void (* put_data)(bfd_vma,bfd_byte *,int))567 _bfd_do_ns32k_reloc_contents (reloc_howto_type *howto,
568 bfd *input_bfd ATTRIBUTE_UNUSED,
569 bfd_vma relocation,
570 bfd_byte *location,
571 bfd_vma (*get_data) (bfd_byte *, int),
572 void (*put_data) (bfd_vma, bfd_byte *, int))
573 {
574 int size;
575 bfd_vma x;
576 bfd_boolean overflow;
577
578 /* If the size is negative, negate RELOCATION. This isn't very
579 general. */
580 if (howto->size < 0)
581 relocation = -relocation;
582
583 /* Get the value we are going to relocate. */
584 size = bfd_get_reloc_size (howto);
585 switch (size)
586 {
587 default:
588 case 0:
589 abort ();
590 case 1:
591 case 2:
592 case 4:
593 #ifdef BFD64
594 case 8:
595 #endif
596 x = get_data (location, size);
597 break;
598 }
599
600 /* Check for overflow. FIXME: We may drop bits during the addition
601 which we don't check for. We must either check at every single
602 operation, which would be tedious, or we must do the computations
603 in a type larger than bfd_vma, which would be inefficient. */
604 overflow = FALSE;
605 if (howto->complain_on_overflow != complain_overflow_dont)
606 {
607 bfd_vma check;
608 bfd_signed_vma signed_check;
609 bfd_vma add;
610 bfd_signed_vma signed_add;
611
612 if (howto->rightshift == 0)
613 {
614 check = relocation;
615 signed_check = (bfd_signed_vma) relocation;
616 }
617 else
618 {
619 /* Drop unwanted bits from the value we are relocating to. */
620 check = relocation >> howto->rightshift;
621
622 /* If this is a signed value, the rightshift just dropped
623 leading 1 bits (assuming twos complement). */
624 if ((bfd_signed_vma) relocation >= 0)
625 signed_check = check;
626 else
627 signed_check = (check
628 | ((bfd_vma) - 1
629 & ~((bfd_vma) - 1 >> howto->rightshift)));
630 }
631
632 /* Get the value from the object file. */
633 add = x & howto->src_mask;
634
635 /* Get the value from the object file with an appropriate sign.
636 The expression involving howto->src_mask isolates the upper
637 bit of src_mask. If that bit is set in the value we are
638 adding, it is negative, and we subtract out that number times
639 two. If src_mask includes the highest possible bit, then we
640 can not get the upper bit, but that does not matter since
641 signed_add needs no adjustment to become negative in that
642 case. */
643 signed_add = add;
644 if ((add & (((~howto->src_mask) >> 1) & howto->src_mask)) != 0)
645 signed_add -= (((~howto->src_mask) >> 1) & howto->src_mask) << 1;
646
647 /* Add the value from the object file, shifted so that it is a
648 straight number. */
649 if (howto->bitpos == 0)
650 {
651 check += add;
652 signed_check += signed_add;
653 }
654 else
655 {
656 check += add >> howto->bitpos;
657
658 /* For the signed case we use ADD, rather than SIGNED_ADD,
659 to avoid warnings from SVR4 cc. This is OK since we
660 explicitly handle the sign bits. */
661 if (signed_add >= 0)
662 signed_check += add >> howto->bitpos;
663 else
664 signed_check += ((add >> howto->bitpos)
665 | ((bfd_vma) - 1
666 & ~((bfd_vma) - 1 >> howto->bitpos)));
667 }
668
669 switch (howto->complain_on_overflow)
670 {
671 case complain_overflow_signed:
672 {
673 /* Assumes two's complement. */
674 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
675 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
676
677 if (signed_check > reloc_signed_max
678 || signed_check < reloc_signed_min)
679 overflow = TRUE;
680 }
681 break;
682 case complain_overflow_unsigned:
683 {
684 /* Assumes two's complement. This expression avoids
685 overflow if howto->bitsize is the number of bits in
686 bfd_vma. */
687 bfd_vma reloc_unsigned_max =
688 (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
689
690 if (check > reloc_unsigned_max)
691 overflow = TRUE;
692 }
693 break;
694 case complain_overflow_bitfield:
695 {
696 /* Assumes two's complement. This expression avoids
697 overflow if howto->bitsize is the number of bits in
698 bfd_vma. */
699 bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
700
701 if ((check & ~reloc_bits) != 0
702 && (((bfd_vma) signed_check & ~reloc_bits)
703 != (-(bfd_vma) 1 & ~reloc_bits)))
704 overflow = TRUE;
705 }
706 break;
707 default:
708 abort ();
709 }
710 }
711
712 /* Put RELOCATION in the right bits. */
713 relocation >>= (bfd_vma) howto->rightshift;
714 relocation <<= (bfd_vma) howto->bitpos;
715
716 /* Add RELOCATION to the right bits of X. */
717 x = ((x & ~howto->dst_mask)
718 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
719
720 /* Put the relocated value back in the object file. */
721 switch (size)
722 {
723 default:
724 case 0:
725 abort ();
726 case 1:
727 case 2:
728 case 4:
729 #ifdef BFD64
730 case 8:
731 #endif
732 put_data (x, location, size);
733 break;
734 }
735
736 return overflow ? bfd_reloc_overflow : bfd_reloc_ok;
737 }
738
739 bfd_reloc_status_type
_bfd_ns32k_reloc_disp(bfd * abfd,arelent * reloc_entry,struct bfd_symbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)740 _bfd_ns32k_reloc_disp (bfd *abfd,
741 arelent *reloc_entry,
742 struct bfd_symbol *symbol,
743 void * data,
744 asection *input_section,
745 bfd *output_bfd,
746 char **error_message)
747 {
748 return do_ns32k_reloc (abfd, reloc_entry, symbol, data, input_section,
749 output_bfd, error_message,
750 _bfd_ns32k_get_displacement,
751 _bfd_ns32k_put_displacement);
752 }
753
754 bfd_reloc_status_type
_bfd_ns32k_reloc_imm(bfd * abfd,arelent * reloc_entry,struct bfd_symbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)755 _bfd_ns32k_reloc_imm (bfd *abfd,
756 arelent *reloc_entry,
757 struct bfd_symbol *symbol,
758 void * data,
759 asection *input_section,
760 bfd *output_bfd,
761 char **error_message)
762 {
763 return do_ns32k_reloc (abfd, reloc_entry, symbol, data, input_section,
764 output_bfd, error_message, _bfd_ns32k_get_immediate,
765 _bfd_ns32k_put_immediate);
766 }
767
768 bfd_reloc_status_type
_bfd_ns32k_final_link_relocate(reloc_howto_type * howto,bfd * input_bfd,asection * input_section,bfd_byte * contents,bfd_vma address,bfd_vma value,bfd_vma addend)769 _bfd_ns32k_final_link_relocate (reloc_howto_type *howto,
770 bfd *input_bfd,
771 asection *input_section,
772 bfd_byte *contents,
773 bfd_vma address,
774 bfd_vma value,
775 bfd_vma addend)
776 {
777 bfd_vma relocation;
778
779 /* Sanity check the address. */
780 if (address > bfd_get_section_limit (input_bfd, input_section))
781 return bfd_reloc_outofrange;
782
783 /* This function assumes that we are dealing with a basic relocation
784 against a symbol. We want to compute the value of the symbol to
785 relocate to. This is just VALUE, the value of the symbol, plus
786 ADDEND, any addend associated with the reloc. */
787 relocation = value + addend;
788
789 /* If the relocation is PC relative, we want to set RELOCATION to
790 the distance between the symbol (currently in RELOCATION) and the
791 location we are relocating. Some targets (e.g., i386-aout)
792 arrange for the contents of the section to be the negative of the
793 offset of the location within the section; for such targets
794 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
795 simply leave the contents of the section as zero; for such
796 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
797 need to subtract out the offset of the location within the
798 section (which is just ADDRESS). */
799 if (howto->pc_relative)
800 {
801 relocation -= (input_section->output_section->vma
802 + input_section->output_offset);
803 if (howto->pcrel_offset)
804 relocation -= address;
805 }
806
807 return _bfd_ns32k_relocate_contents (howto, input_bfd, relocation,
808 contents + address);
809 }
810