bfd/cpu-ns32k.c

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