Update year range in copyright notice of binutils files
[external/binutils.git] / bfd / cpu-ns32k.c
1 /* BFD support for the ns32k architecture.
2    Copyright (C) 1990-2019 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
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
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
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       /* Fall through.  */
110     case 2:
111       value = (value << 8) | (*buffer++ & 0xff);
112       /* Fall through.  */
113     case 1:
114       value = (value << 8) | (*buffer++ & 0xff);
115       break;
116     default:
117       abort ();
118     }
119   return value;
120 }
121
122 void
123 _bfd_ns32k_put_immediate (bfd_vma value, bfd_byte *buffer, int size)
124 {
125   buffer += size - 1;
126   switch (size)
127     {
128     case 4:
129       *buffer-- = (value & 0xff); value >>= 8;
130       *buffer-- = (value & 0xff); value >>= 8;
131       /* Fall through.  */
132     case 2:
133       *buffer-- = (value & 0xff); value >>= 8;
134       /* Fall through.  */
135     case 1:
136       *buffer-- = (value & 0xff); value >>= 8;
137     }
138 }
139
140 /* This is just like the standard perform_relocation except we
141    use get_data and put_data which know about the ns32k storage
142    methods.  This is probably a lot more complicated than it
143    needs to be!  */
144
145 static bfd_reloc_status_type
146 do_ns32k_reloc (bfd *      abfd,
147                 arelent *  reloc_entry,
148                 struct bfd_symbol * symbol,
149                 void *     data,
150                 asection * input_section,
151                 bfd *      output_bfd,
152                 char **    error_message ATTRIBUTE_UNUSED,
153                 bfd_vma (* get_data) (bfd_byte *, int),
154                 void (*    put_data) (bfd_vma, bfd_byte *, int))
155 {
156   int overflow = 0;
157   bfd_vma relocation;
158   bfd_reloc_status_type flag = bfd_reloc_ok;
159   bfd_size_type addr = reloc_entry->address;
160   bfd_vma output_base = 0;
161   reloc_howto_type *howto = reloc_entry->howto;
162   asection *reloc_target_output_section;
163   bfd_byte *location;
164
165   if (bfd_is_abs_section (symbol->section)
166       && output_bfd != (bfd *) NULL)
167     {
168       reloc_entry->address += input_section->output_offset;
169       return bfd_reloc_ok;
170     }
171
172   /* If we are not producing relocatable output, return an error if
173      the symbol is not defined.  An undefined weak symbol is
174      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
175   if (bfd_is_und_section (symbol->section)
176       && (symbol->flags & BSF_WEAK) == 0
177       && output_bfd == (bfd *) NULL)
178     flag = bfd_reloc_undefined;
179
180   /* Is the address of the relocation really within the section?  */
181   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
182     return bfd_reloc_outofrange;
183
184   /* Work out which section the relocation is targeted at and the
185      initial relocation command value.  */
186
187   /* Get symbol value.  (Common symbols are special.)  */
188   if (bfd_is_com_section (symbol->section))
189     relocation = 0;
190   else
191     relocation = symbol->value;
192
193   reloc_target_output_section = symbol->section->output_section;
194
195   /* Convert input-section-relative symbol value to absolute.  */
196   if (output_bfd != NULL && ! howto->partial_inplace)
197     output_base = 0;
198   else
199     output_base = reloc_target_output_section->vma;
200
201   relocation += output_base + symbol->section->output_offset;
202
203   /* Add in supplied addend.  */
204   relocation += reloc_entry->addend;
205
206   /* Here the variable relocation holds the final address of the
207      symbol we are relocating against, plus any addend.  */
208
209   if (howto->pc_relative)
210     {
211       /* This is a PC relative relocation.  We want to set RELOCATION
212          to the distance between the address of the symbol and the
213          location.  RELOCATION is already the address of the symbol.
214
215          We start by subtracting the address of the section containing
216          the location.
217
218          If pcrel_offset is set, we must further subtract the position
219          of the location within the section.  Some targets arrange for
220          the addend to be the negative of the position of the location
221          within the section; for example, i386-aout does this.  For
222          i386-aout, pcrel_offset is FALSE.  Some other targets do not
223          include the position of the location; for example, ELF.
224          For those targets, pcrel_offset is TRUE.
225
226          If we are producing relocatable output, then we must ensure
227          that this reloc will be correctly computed when the final
228          relocation is done.  If pcrel_offset is FALSE we want to wind
229          up with the negative of the location within the section,
230          which means we must adjust the existing addend by the change
231          in the location within the section.  If pcrel_offset is TRUE
232          we do not want to adjust the existing addend at all.
233
234          FIXME: This seems logical to me, but for the case of
235          producing relocatable output it is not what the code
236          actually does.  I don't want to change it, because it seems
237          far too likely that something will break.  */
238       relocation -=
239         input_section->output_section->vma + input_section->output_offset;
240
241       if (howto->pcrel_offset)
242         relocation -= reloc_entry->address;
243     }
244
245   if (output_bfd != (bfd *) NULL)
246     {
247       if (! howto->partial_inplace)
248         {
249           /* This is a partial relocation, and we want to apply the relocation
250              to the reloc entry rather than the raw data. Modify the reloc
251              inplace to reflect what we now know.  */
252           reloc_entry->addend = relocation;
253           reloc_entry->address += input_section->output_offset;
254           return flag;
255         }
256       else
257         {
258           /* This is a partial relocation, but inplace, so modify the
259              reloc record a bit.
260
261              If we've relocated with a symbol with a section, change
262              into a ref to the section belonging to the symbol.  */
263
264           reloc_entry->address += input_section->output_offset;
265
266           /* WTF?? */
267           if (abfd->xvec->flavour == bfd_target_coff_flavour)
268             {
269               /* For m68k-coff, the addend was being subtracted twice during
270                  relocation with -r.  Removing the line below this comment
271                  fixes that problem; see PR 2953.
272
273                  However, Ian wrote the following, regarding removing the line
274                  below, which explains why it is still enabled:  --djm
275
276                  If you put a patch like that into BFD you need to check all
277                  the COFF linkers.  I am fairly certain that patch will break
278                  coff-i386 (e.g., SCO); see coff_i386_reloc in coff-i386.c
279                  where I worked around the problem in a different way.  There
280                  may very well be a reason that the code works as it does.
281
282                  Hmmm.  The first obvious point is that bfd_perform_relocation
283                  should not have any tests that depend upon the flavour.  It's
284                  seem like entirely the wrong place for such a thing.  The
285                  second obvious point is that the current code ignores the
286                  reloc addend when producing relocatable output for COFF.
287                  That's peculiar.  In fact, I really have no idea what the
288                  point of the line you want to remove is.
289
290                  A typical COFF reloc subtracts the old value of the symbol
291                  and adds in the new value to the location in the object file
292                  (if it's a pc relative reloc it adds the difference between
293                  the symbol value and the location).  When relocating we need
294                  to preserve that property.
295
296                  BFD handles this by setting the addend to the negative of the
297                  old value of the symbol.  Unfortunately it handles common
298                  symbols in a non-standard way (it doesn't subtract the old
299                  value) but that's a different story (we can't change it
300                  without losing backward compatibility with old object files)
301                  (coff-i386 does subtract the old value, to be compatible with
302                  existing coff-i386 targets, like SCO).
303
304                  So everything works fine when not producing relocatable
305                  output.  When we are producing relocatable output, logically
306                  we should do exactly what we do when not producing
307                  relocatable output.  Therefore, your patch is correct.  In
308                  fact, it should probably always just set reloc_entry->addend
309                  to 0 for all cases, since it is, in fact, going to add the
310                  value into the object file.  This won't hurt the COFF code,
311                  which doesn't use the addend; I'm not sure what it will do
312                  to other formats (the thing to check for would be whether
313                  any formats both use the addend and set partial_inplace).
314
315                  When I wanted to make coff-i386 produce relocatable output,
316                  I ran into the problem that you are running into: I wanted
317                  to remove that line.  Rather than risk it, I made the
318                  coff-i386 relocs use a special function; it's coff_i386_reloc
319                  in coff-i386.c.  The function specifically adds the addend
320                  field into the object file, knowing that bfd_perform_relocation
321                  is not going to.  If you remove that line, then coff-i386.c
322                  will wind up adding the addend field in twice.  It's trivial
323                  to fix; it just needs to be done.
324
325                  The problem with removing the line is just that it may break
326                  some working code.  With BFD it's hard to be sure of anything.
327                  The right way to deal with this is simply to build and test at
328                  least all the supported COFF targets.  It should be
329                  straightforward if time and disk space consuming.  For each
330                  target:
331                    1) build the linker
332                    2) generate some executable, and link it using -r (I would
333                       probably use paranoia.o and link against newlib/libc.a,
334                       which for all the supported targets would be available in
335                       /usr/cygnus/progressive/H-host/target/lib/libc.a).
336                    3) make the change to reloc.c
337                    4) rebuild the linker
338                    5) repeat step 2
339                    6) if the resulting object files are the same, you have at
340                       least made it no worse
341                    7) if they are different you have to figure out which
342                       version is right.  */
343               relocation -= reloc_entry->addend;
344               reloc_entry->addend = 0;
345             }
346           else
347             {
348               reloc_entry->addend = relocation;
349             }
350         }
351     }
352   else
353     {
354       reloc_entry->addend = 0;
355     }
356
357   /* FIXME: This overflow checking is incomplete, because the value
358      might have overflowed before we get here.  For a correct check we
359      need to compute the value in a size larger than bitsize, but we
360      can't reasonably do that for a reloc the same size as a host
361      machine word.
362      FIXME: We should also do overflow checking on the result after
363      adding in the value contained in the object file.  */
364   if (howto->complain_on_overflow != complain_overflow_dont)
365     {
366       bfd_vma check;
367
368       /* Get the value that will be used for the relocation, but
369          starting at bit position zero.  */
370       if (howto->rightshift > howto->bitpos)
371         check = relocation >> (howto->rightshift - howto->bitpos);
372       else
373         check = relocation << (howto->bitpos - howto->rightshift);
374       switch (howto->complain_on_overflow)
375         {
376         case complain_overflow_signed:
377           {
378             /* Assumes two's complement.  */
379             bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
380             bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
381
382             /* The above right shift is incorrect for a signed value.
383                Fix it up by forcing on the upper bits.  */
384             if (howto->rightshift > howto->bitpos
385                 && (bfd_signed_vma) relocation < 0)
386               check |= ((bfd_vma) - 1
387                         & ~((bfd_vma) - 1
388                             >> (howto->rightshift - howto->bitpos)));
389             if ((bfd_signed_vma) check > reloc_signed_max
390                 || (bfd_signed_vma) check < reloc_signed_min)
391               flag = bfd_reloc_overflow;
392           }
393           break;
394         case complain_overflow_unsigned:
395           {
396             /* Assumes two's complement.  This expression avoids
397                overflow if howto->bitsize is the number of bits in
398                bfd_vma.  */
399             bfd_vma reloc_unsigned_max =
400             (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
401
402             if ((bfd_vma) check > reloc_unsigned_max)
403               flag = bfd_reloc_overflow;
404           }
405           break;
406         case complain_overflow_bitfield:
407           {
408             /* Assumes two's complement.  This expression avoids
409                overflow if howto->bitsize is the number of bits in
410                bfd_vma.  */
411             bfd_vma reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
412
413             if (((bfd_vma) check & ~reloc_bits) != 0
414                 && (((bfd_vma) check & ~reloc_bits)
415                     != (-(bfd_vma) 1 & ~reloc_bits)))
416               {
417                 /* The above right shift is incorrect for a signed
418                    value.  See if turning on the upper bits fixes the
419                    overflow.  */
420                 if (howto->rightshift > howto->bitpos
421                     && (bfd_signed_vma) relocation < 0)
422                   {
423                     check |= ((bfd_vma) - 1
424                               & ~((bfd_vma) - 1
425                                   >> (howto->rightshift - howto->bitpos)));
426                     if (((bfd_vma) check & ~reloc_bits)
427                         != (-(bfd_vma) 1 & ~reloc_bits))
428                       flag = bfd_reloc_overflow;
429                   }
430                 else
431                   flag = bfd_reloc_overflow;
432               }
433           }
434           break;
435         default:
436           abort ();
437         }
438     }
439
440   /* Either we are relocating all the way, or we don't want to apply
441      the relocation to the reloc entry (probably because there isn't
442      any room in the output format to describe addends to relocs).  */
443
444   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
445      (OSF version 1.3, compiler version 3.11).  It miscompiles the
446      following program:
447
448      struct str
449      {
450        unsigned int i0;
451      } s = { 0 };
452
453      int
454      main ()
455      {
456        unsigned long x;
457
458        x = 0x100000000;
459        x <<= (unsigned long) s.i0;
460        if (x == 0)
461          printf ("failed\n");
462        else
463          printf ("succeeded (%lx)\n", x);
464      }
465      */
466
467   relocation >>= (bfd_vma) howto->rightshift;
468
469   /* Shift everything up to where it's going to be used.  */
470   relocation <<= (bfd_vma) howto->bitpos;
471
472   /* Wait for the day when all have the mask in them.  */
473
474   /* What we do:
475      i instruction to be left alone
476      o offset within instruction
477      r relocation offset to apply
478      S src mask
479      D dst mask
480      N ~dst mask
481      A part 1
482      B part 2
483      R result
484
485      Do this:
486      i i i i i o o o o o        from bfd_get<size>
487      and           S S S S S    to get the size offset we want
488      +   r r r r r r r r r r  to get the final value to place
489      and           D D D D D  to chop to right size
490      -----------------------
491      A A A A A
492      And this:
493      ...   i i i i i o o o o o  from bfd_get<size>
494      and   N N N N N            get instruction
495      -----------------------
496      ...   B B B B B
497
498      And then:
499      B B B B B
500      or              A A A A A
501      -----------------------
502      R R R R R R R R R R        put into bfd_put<size>.  */
503
504   if (howto->negate)
505     relocation = -relocation;
506
507 #define DOIT(x) \
508   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
509
510   location = (bfd_byte *) data + addr;
511   switch (howto->size)
512     {
513     case 0:
514       {
515         bfd_vma x = get_data (location, 1);
516         DOIT (x);
517         put_data ((bfd_vma) x, location, 1);
518       }
519       break;
520
521     case 1:
522       if (relocation)
523         {
524           bfd_vma x = get_data (location, 2);
525           DOIT (x);
526           put_data ((bfd_vma) x, location, 2);
527         }
528       break;
529     case 2:
530       if (relocation)
531         {
532           bfd_vma x = get_data (location, 4);
533           DOIT (x);
534           put_data ((bfd_vma) x, location, 4);
535         }
536       break;
537
538     case 3:
539       /* Do nothing.  */
540       break;
541
542     case 4:
543 #ifdef BFD64
544       if (relocation)
545         {
546           bfd_vma x = get_data (location, 8);
547           DOIT (x);
548           put_data (x, location, 8);
549         }
550 #else
551       abort ();
552 #endif
553       break;
554     default:
555       return bfd_reloc_other;
556     }
557   if ((howto->complain_on_overflow != complain_overflow_dont) && overflow)
558     return bfd_reloc_overflow;
559
560   return flag;
561 }
562
563 /* Relocate a given location using a given value and howto.  */
564
565 bfd_reloc_status_type
566 _bfd_do_ns32k_reloc_contents (reloc_howto_type *howto,
567                               bfd *input_bfd ATTRIBUTE_UNUSED,
568                               bfd_vma relocation,
569                               bfd_byte *location,
570                               bfd_vma (*get_data) (bfd_byte *, int),
571                               void (*put_data) (bfd_vma, bfd_byte *, int))
572 {
573   int size;
574   bfd_vma x;
575   bfd_boolean overflow;
576
577   /* If the size is negative, negate RELOCATION.  This isn't very
578      general.  */
579   if (howto->size < 0)
580     relocation = -relocation;
581
582   /* Get the value we are going to relocate.  */
583   size = bfd_get_reloc_size (howto);
584   switch (size)
585     {
586     default:
587       abort ();
588     case 0:
589       return bfd_reloc_ok;
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
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
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
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.  If pcrel_offset is FALSE we do not
792      need to subtract out the offset of the location within the
793      section (which is just ADDRESS).  */
794   if (howto->pc_relative)
795     {
796       relocation -= (input_section->output_section->vma
797                      + input_section->output_offset);
798       if (howto->pcrel_offset)
799         relocation -= address;
800     }
801
802   return _bfd_ns32k_relocate_contents (howto, input_bfd, relocation,
803                                        contents + address);
804 }