bfd/coff-tic80.c

   1 /* BFD back-end for Texas Instruments TMS320C80 Multimedia Video Processor (MVP).
   2    Copyright (C) 1996-2015 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 3 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, 51 Franklin Street - Fifth Floor,
  24    Boston, MA 02110-1301, USA.  */
  25
  26 #include "sysdep.h"
  27 #include "bfd.h"
  28 #include "bfdlink.h"
  29 #include "libbfd.h"
  30 #ifdef _CONST
  31 /* Newlib-based hosts define _CONST as a STDC-safe alias for const,
  32   but to the tic80 toolchain it means something altogether different.
  33   Since sysdep.h will have pulled in stdio.h and hence _ansi.h which
  34   contains this definition, we must undef it before including the
  35   tic80-specific definition. */
  36 #undef _CONST
  37 #endif /* _CONST */
  38 #include "coff/tic80.h"
  39 #include "coff/internal.h"
  40 #include "libcoff.h"
  41
  42 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
  43 #define COFF_ALIGN_IN_SECTION_HEADER 1
  44 #define COFF_ALIGN_IN_SFLAGS 1
  45
  46 #define GET_SCNHDR_FLAGS H_GET_16
  47 #define PUT_SCNHDR_FLAGS H_PUT_16
  48
  49 static bfd_reloc_status_type ppbase_reloc
  50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  51 static bfd_reloc_status_type glob15_reloc
  52   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  53 static bfd_reloc_status_type glob16_reloc
  54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  55 static bfd_reloc_status_type local16_reloc
  56   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  57
  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 (bfd *abfd ATTRIBUTE_UNUSED,
 365               arelent *reloc_entry ATTRIBUTE_UNUSED,
 366               asymbol *symbol_in ATTRIBUTE_UNUSED,
 367               void * data ATTRIBUTE_UNUSED,
 368               asection *input_section ATTRIBUTE_UNUSED,
 369               bfd *output_bfd ATTRIBUTE_UNUSED,
 370               char **error_message ATTRIBUTE_UNUSED)
 371 {
 372   /* FIXME.  */
 373   abort ();
 374 }
 375
 376 /* This special function is used for the global 15 bit relocations.  */
 377
 378 static bfd_reloc_status_type
 379 glob15_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 380               arelent *reloc_entry ATTRIBUTE_UNUSED,
 381               asymbol *symbol_in ATTRIBUTE_UNUSED,
 382               void * data ATTRIBUTE_UNUSED,
 383               asection *input_section ATTRIBUTE_UNUSED,
 384               bfd *output_bfd ATTRIBUTE_UNUSED,
 385               char **error_message ATTRIBUTE_UNUSED)
 386 {
 387   /* FIXME.  */
 388   abort ();
 389 }
 390
 391 /* This special function is used for the global 16 bit relocations.  */
 392
 393 static bfd_reloc_status_type
 394 glob16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 395               arelent *reloc_entry ATTRIBUTE_UNUSED,
 396               asymbol *symbol_in ATTRIBUTE_UNUSED,
 397               void * data ATTRIBUTE_UNUSED,
 398               asection *input_section ATTRIBUTE_UNUSED,
 399               bfd *output_bfd ATTRIBUTE_UNUSED,
 400               char **error_message ATTRIBUTE_UNUSED)
 401 {
 402   /* FIXME.  */
 403   abort ();
 404 }
 405
 406 /* This special function is used for the local 16 bit relocations.  */
 407
 408 static bfd_reloc_status_type
 409 local16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 410                arelent *reloc_entry ATTRIBUTE_UNUSED,
 411                asymbol *symbol_in ATTRIBUTE_UNUSED,
 412                void * data ATTRIBUTE_UNUSED,
 413                asection *input_section ATTRIBUTE_UNUSED,
 414                bfd *output_bfd ATTRIBUTE_UNUSED,
 415                char **error_message ATTRIBUTE_UNUSED)
 416 {
 417   /* FIXME.  */
 418   abort ();
 419 }
 420 \f
 421 /* Code to turn an external r_type into a pointer to an entry in the howto_table.
 422    If passed an r_type we don't recognize the abort rather than silently failing
 423    to generate an output file.  */
 424
 425 static void
 426 rtype2howto (arelent *cache_ptr, struct internal_reloc *dst)
 427 {
 428   unsigned int i;
 429
 430   for (i = 0; i < sizeof tic80_howto_table / sizeof tic80_howto_table[0]; i++)
 431     {
 432       if (tic80_howto_table[i].type == dst->r_type)
 433         {
 434           cache_ptr->howto = tic80_howto_table + i;
 435           return;
 436         }
 437     }
 438
 439   (*_bfd_error_handler) (_("Unrecognized reloc type 0x%x"),
 440                          (unsigned int) dst->r_type);
 441   cache_ptr->howto = tic80_howto_table + 0;
 442 }
 443
 444 #define RTYPE2HOWTO(cache_ptr, dst) rtype2howto (cache_ptr, dst)
 445 #define coff_rtype_to_howto coff_tic80_rtype_to_howto
 446
 447 static reloc_howto_type *
 448 coff_tic80_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 449                            asection *sec,
 450                            struct internal_reloc *rel,
 451                            struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
 452                            struct internal_syment *sym ATTRIBUTE_UNUSED,
 453                            bfd_vma *addendp)
 454 {
 455   arelent genrel;
 456
 457   if (rel -> r_symndx == -1 && addendp != NULL)
 458     {
 459       /* This is a TI "internal relocation", which means that the relocation
 460          amount is the amount by which the current section is being relocated
 461          in the output section.  */
 462       *addendp = (sec -> output_section -> vma + sec -> output_offset) - sec -> vma;
 463     }
 464   RTYPE2HOWTO (&genrel, rel);
 465   return genrel.howto;
 466 }
 467
 468 #ifndef BADMAG
 469 #define BADMAG(x) TIC80BADMAG(x)
 470 #endif
 471 \f
 472 #define coff_relocate_section coff_tic80_relocate_section
 473
 474 /* We need a special relocation routine to handle the PP relocs.  Most
 475    of this is a copy of _bfd_coff_generic_relocate_section.  */
 476
 477 static bfd_boolean
 478 coff_tic80_relocate_section (bfd *output_bfd,
 479                              struct bfd_link_info *info,
 480                              bfd *input_bfd,
 481                              asection *input_section,
 482                              bfd_byte *contents,
 483                              struct internal_reloc *relocs,
 484                              struct internal_syment *syms,
 485                              asection **sections)
 486 {
 487   struct internal_reloc *rel;
 488   struct internal_reloc *relend;
 489
 490   rel = relocs;
 491   relend = rel + input_section->reloc_count;
 492   for (; rel < relend; rel++)
 493     {
 494       long symndx;
 495       struct coff_link_hash_entry *h;
 496       struct internal_syment *sym;
 497       bfd_vma addend;
 498       bfd_vma val;
 499       reloc_howto_type *howto;
 500       bfd_reloc_status_type rstat;
 501       bfd_vma addr;
 502
 503       symndx = rel->r_symndx;
 504
 505       if (symndx == -1)
 506         {
 507           h = NULL;
 508           sym = NULL;
 509         }
 510       else
 511         {
 512           h = obj_coff_sym_hashes (input_bfd)[symndx];
 513           sym = syms + symndx;
 514         }
 515
 516       /* COFF treats common symbols in one of two ways.  Either the
 517          size of the symbol is included in the section contents, or it
 518          is not.  We assume that the size is not included, and force
 519          the rtype_to_howto function to adjust the addend as needed.  */
 520
 521       if (sym != NULL && sym->n_scnum != 0)
 522         addend = - sym->n_value;
 523       else
 524         addend = 0;
 525
 526       howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
 527                                        sym, &addend);
 528       if (howto == NULL)
 529         return FALSE;
 530
 531       val = 0;
 532
 533       if (h == NULL)
 534         {
 535           asection *sec;
 536
 537           if (symndx == -1)
 538             {
 539               sec = bfd_abs_section_ptr;
 540               val = 0;
 541             }
 542           else
 543             {
 544               sec = sections[symndx];
 545               val = (sec->output_section->vma
 546                      + sec->output_offset
 547                      + sym->n_value);
 548               if (! obj_pe (output_bfd))
 549                 val -= sec->vma;
 550             }
 551         }
 552       else
 553         {
 554           if (h->root.type == bfd_link_hash_defined
 555               || h->root.type == bfd_link_hash_defweak)
 556             {
 557               asection *sec;
 558
 559               sec = h->root.u.def.section;
 560               val = (h->root.u.def.value
 561                      + sec->output_section->vma
 562                      + sec->output_offset);
 563               }
 564
 565           else if (! info->relocatable)
 566             {
 567               if (! ((*info->callbacks->undefined_symbol)
 568                      (info, h->root.root.string, input_bfd, input_section,
 569                       rel->r_vaddr - input_section->vma, TRUE)))
 570                 return FALSE;
 571             }
 572         }
 573
 574       addr = rel->r_vaddr - input_section->vma;
 575
 576       /* FIXME: This code assumes little endian, but the PP can
 577          apparently be bi-endian.  I don't know if the bi-endianness
 578          applies to the instruction set or just to the data.  */
 579       switch (howto->type)
 580         {
 581         default:
 582         case R_ABS:
 583         case R_RELLONGX:
 584         case R_PPL15:
 585         case R_PPL15W:
 586         case R_PPL15H:
 587         case R_PPLN15:
 588         case R_PPLN15W:
 589         case R_PPLN15H:
 590           rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
 591                                             contents, addr, val, addend);
 592           break;
 593
 594         case R_PP15:
 595         case R_PP15W:
 596         case R_PP15H:
 597         case R_PPN15:
 598         case R_PPN15W:
 599         case R_PPN15H:
 600           /* Offset the address so that we can use 4 byte relocations.  */
 601           rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
 602                                             contents + 2, addr, val, addend);
 603           break;
 604
 605         case R_PP16B:
 606         case R_PPN16B:
 607           {
 608             /* The most significant bit is stored in bit 6.  */
 609             bfd_byte hold;
 610
 611             hold = contents[addr + 4];
 612             contents[addr + 4] &=~ 0x20;
 613             contents[addr + 4] |= (contents[addr] >> 1) & 0x20;
 614             rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
 615                                               contents + 2, addr,
 616                                               val, addend);
 617             contents[addr] &=~ 0x40;
 618             contents[addr] |= (contents[addr + 4] << 1) & 0x40;
 619             contents[addr + 4] &=~ 0x20;
 620             contents[addr + 4] |= hold & 0x20;
 621             break;
 622           }
 623
 624         case R_PPL16B:
 625         case R_PPLN16B:
 626           {
 627             /* The most significant bit is stored in bit 28.  */
 628             bfd_byte hold;
 629
 630             hold = contents[addr + 1];
 631             contents[addr + 1] &=~ 0x80;
 632             contents[addr + 1] |= (contents[addr + 3] << 3) & 0x80;
 633             rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
 634                                               contents, addr,
 635                                               val, addend);
 636             contents[addr + 3] &= ~0x10;
 637             contents[addr + 3] |= (contents[addr + 1] >> 3) & 0x10;
 638             contents[addr + 1] &=~ 0x80;
 639             contents[addr + 1] |= hold & 0x80;
 640             break;
 641           }
 642
 643         case R_PPBASE:
 644           /* Parameter RAM is from 0x1000000 to 0x1000800.  */
 645           contents[addr] &=~ 0x3;
 646           if (val >= 0x1000000 && val < 0x1000800)
 647             contents[addr] |= 0x3;
 648           else
 649             contents[addr] |= 0x2;
 650           rstat = bfd_reloc_ok;
 651           break;
 652
 653         case R_PPLBASE:
 654           /* Parameter RAM is from 0x1000000 to 0x1000800.  */
 655           contents[addr + 2] &= ~0xc0;
 656           if (val >= 0x1000000 && val < 0x1000800)
 657             contents[addr + 2] |= 0xc0;
 658           else
 659             contents[addr + 2] |= 0x80;
 660           rstat = bfd_reloc_ok;
 661           break;
 662         }
 663
 664       switch (rstat)
 665         {
 666         default:
 667           abort ();
 668         case bfd_reloc_ok:
 669           break;
 670         case bfd_reloc_outofrange:
 671           (*_bfd_error_handler)
 672             (_("%B: bad reloc address 0x%lx in section `%A'"),
 673              input_bfd, input_section, (unsigned long) rel->r_vaddr);
 674           return FALSE;
 675         case bfd_reloc_overflow:
 676           {
 677             const char *name;
 678             char buf[SYMNMLEN + 1];
 679
 680             if (symndx == -1)
 681               name = "*ABS*";
 682             else if (h != NULL)
 683               name = NULL;
 684             else
 685               {
 686                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
 687                 if (name == NULL)
 688                   return FALSE;
 689               }
 690
 691             if (! ((*info->callbacks->reloc_overflow)
 692                    (info, (h ? &h->root : NULL), name, howto->name,
 693                     (bfd_vma) 0, input_bfd, input_section,
 694                     rel->r_vaddr - input_section->vma)))
 695               return FALSE;
 696           }
 697         }
 698     }
 699   return TRUE;
 700 }
 701 \f
 702 #define TIC80COFF 1             /* Customize coffcode.h */
 703 #undef C_AUTOARG                /* Clashes with TIc80's C_UEXT */
 704 #undef C_LASTENT                /* Clashes with TIc80's C_STATLAB */
 705
 706 #ifndef bfd_pe_print_pdata
 707 #define bfd_pe_print_pdata      NULL
 708 #endif
 709
 710 #include "coffcode.h"
 711
 712 CREATE_LITTLE_COFF_TARGET_VEC (tic80_coff_vec, "coff-tic80", D_PAGED, 0, '_', NULL, COFF_SWAP_TABLE)