bfd/coff-tic80.c

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