bfd/elf32-tic6x.c

   1 /* 32-bit ELF support for TI C6X
   2    Copyright 2010, 2011
   3    Free Software Foundation, Inc.
   4    Contributed by Joseph Myers <joseph@codesourcery.com>
   5                   Bernd Schmidt  <bernds@codesourcery.com>
   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 "libiberty.h"
  28 #include "elf-bfd.h"
  29 #include "elf/tic6x.h"
  30 #include "elf32-tic6x.h"
  31
  32 #define ELF_DYNAMIC_INTERPRETER "/lib/ld-uClibc.so.0"
  33
  34 /* DSBT binaries have a default 128K stack.  */
  35 #define DEFAULT_STACK_SIZE 0x20000
  36
  37 /* The size in bytes of an entry in the procedure linkage table.  */
  38 #define PLT_ENTRY_SIZE 24
  39
  40 /* TI C6X ELF linker hash table.  */
  41
  42 struct elf32_tic6x_link_hash_table
  43 {
  44   struct elf_link_hash_table elf;
  45
  46   /* Short-cuts to get to dynamic linker sections.  */
  47   asection *sdynbss;
  48   asection *srelbss;
  49
  50   /* C6X specific command line arguments.  */
  51   struct elf32_tic6x_params params;
  52
  53   /* Small local sym cache.  */
  54   struct sym_cache sym_cache;
  55
  56   /* The output BFD, for convenience.  */
  57   bfd *obfd;
  58
  59   /* The .dsbt section.  */
  60   asection *dsbt;
  61 };
  62
  63 /* Get the TI C6X ELF linker hash table from a link_info structure.  */
  64
  65 #define elf32_tic6x_hash_table(p) \
  66   ((struct elf32_tic6x_link_hash_table *) ((p)->hash))
  67
  68 /* TI C6X ELF linker hash entry.  */
  69
  70 struct elf32_tic6x_link_hash_entry
  71 {
  72   struct elf_link_hash_entry elf;
  73
  74   /* Track dynamic relocs copied for this symbol.  */
  75   struct elf_dyn_relocs *dyn_relocs;
  76 };
  77
  78 struct elf32_tic6x_obj_tdata
  79 {
  80   struct elf_obj_tdata root;
  81
  82   /* Whether to use RELA relocations when generating relocations.
  83      This is a per-object flag to allow the assembler to generate REL
  84      relocations for use in linker testcases.  */
  85   bfd_boolean use_rela_p;
  86 };
  87
  88 #define elf32_tic6x_tdata(abfd) \
  89   ((struct elf32_tic6x_obj_tdata *) (abfd)->tdata.any)
  90
  91 #define is_tic6x_elf(bfd) \
  92   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
  93    && elf_tdata (bfd) != NULL \
  94    && elf_object_id (bfd) == TIC6X_ELF_DATA)
  95
  96 /* C6X ELF uses two common sections.  One is the usual one, and the
  97    other is for small objects.  All the small objects are kept
  98    together, and then referenced via the gp pointer, which yields
  99    faster assembler code.  This is what we use for the small common
 100    section.  This approach is copied from ecoff.c.  */
 101 static asection tic6x_elf_scom_section;
 102 static asymbol  tic6x_elf_scom_symbol;
 103 static asymbol  *tic6x_elf_scom_symbol_ptr;
 104
 105 static reloc_howto_type elf32_tic6x_howto_table[] =
 106 {
 107   HOWTO (R_C6000_NONE,          /* type */
 108          0,                     /* rightshift */
 109          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 110          0,                     /* bitsize */
 111          FALSE,                 /* pc_relative */
 112          0,                     /* bitpos */
 113          complain_overflow_dont,/* complain_on_overflow */
 114          bfd_elf_generic_reloc, /* special_function */
 115          "R_C6000_NONE",        /* name */
 116          FALSE,                 /* partial_inplace */
 117          0,                     /* src_mask */
 118          0,                     /* dst_mask */
 119          FALSE),                /* pcrel_offset */
 120   HOWTO (R_C6000_ABS32,         /* type */
 121          0,                     /* rightshift */
 122          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 123          32,                    /* bitsize */
 124          FALSE,                 /* pc_relative */
 125          0,                     /* bitpos */
 126          complain_overflow_dont,/* complain_on_overflow */
 127          bfd_elf_generic_reloc, /* special_function */
 128          "R_C6000_ABS32",       /* name */
 129          FALSE,                 /* partial_inplace */
 130          0,                     /* src_mask */
 131          0xffffffff,            /* dst_mask */
 132          FALSE),                /* pcrel_offset */
 133   HOWTO (R_C6000_ABS16,         /* type */
 134          0,                     /* rightshift */
 135          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 136          16,                    /* bitsize */
 137          FALSE,                 /* pc_relative */
 138          0,                     /* bitpos */
 139          complain_overflow_bitfield,/* complain_on_overflow */
 140          bfd_elf_generic_reloc, /* special_function */
 141          "R_C6000_ABS16",       /* name */
 142          FALSE,                 /* partial_inplace */
 143          0,                     /* src_mask */
 144          0x0000ffff,            /* dst_mask */
 145          FALSE),                /* pcrel_offset */
 146   HOWTO (R_C6000_ABS8,          /* type */
 147          0,                     /* rightshift */
 148          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 149          8,                     /* bitsize */
 150          FALSE,                 /* pc_relative */
 151          0,                     /* bitpos */
 152          complain_overflow_bitfield,/* complain_on_overflow */
 153          bfd_elf_generic_reloc, /* special_function */
 154          "R_C6000_ABS8",        /* name */
 155          FALSE,                 /* partial_inplace */
 156          0,                     /* src_mask */
 157          0x000000ff,            /* dst_mask */
 158          FALSE),                /* pcrel_offset */
 159   HOWTO (R_C6000_PCR_S21,       /* type */
 160          2,                     /* rightshift */
 161          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 162          21,                    /* bitsize */
 163          TRUE,                  /* pc_relative */
 164          7,                     /* bitpos */
 165          complain_overflow_signed,/* complain_on_overflow */
 166          bfd_elf_generic_reloc, /* special_function */
 167          "R_C6000_PCR_S21",     /* name */
 168          FALSE,                 /* partial_inplace */
 169          0,                     /* src_mask */
 170          0x0fffff80,            /* dst_mask */
 171          TRUE),                 /* pcrel_offset */
 172   HOWTO (R_C6000_PCR_S12,       /* type */
 173          2,                     /* rightshift */
 174          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 175          12,                    /* bitsize */
 176          TRUE,                  /* pc_relative */
 177          16,                    /* bitpos */
 178          complain_overflow_signed,/* complain_on_overflow */
 179          bfd_elf_generic_reloc, /* special_function */
 180          "R_C6000_PCR_S12",     /* name */
 181          FALSE,                 /* partial_inplace */
 182          0,                     /* src_mask */
 183          0x0fff0000,            /* dst_mask */
 184          TRUE),                 /* pcrel_offset */
 185   HOWTO (R_C6000_PCR_S10,       /* type */
 186          2,                     /* rightshift */
 187          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 188          10,                    /* bitsize */
 189          TRUE,                  /* pc_relative */
 190          13,                    /* bitpos */
 191          complain_overflow_signed,/* complain_on_overflow */
 192          bfd_elf_generic_reloc, /* special_function */
 193          "R_C6000_PCR_S10",     /* name */
 194          FALSE,                 /* partial_inplace */
 195          0,                     /* src_mask */
 196          0x007fe000,            /* dst_mask */
 197          TRUE),                 /* pcrel_offset */
 198   HOWTO (R_C6000_PCR_S7,        /* type */
 199          2,                     /* rightshift */
 200          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 201          7,                     /* bitsize */
 202          TRUE,                  /* pc_relative */
 203          16,                    /* bitpos */
 204          complain_overflow_signed,/* complain_on_overflow */
 205          bfd_elf_generic_reloc, /* special_function */
 206          "R_C6000_PCR_S7",      /* name */
 207          FALSE,                 /* partial_inplace */
 208          0,                     /* src_mask */
 209          0x007f0000,            /* dst_mask */
 210          TRUE),                 /* pcrel_offset */
 211   HOWTO (R_C6000_ABS_S16,       /* type */
 212          0,                     /* rightshift */
 213          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 214          16,                    /* bitsize */
 215          FALSE,                 /* pc_relative */
 216          7,                     /* bitpos */
 217          complain_overflow_signed,/* complain_on_overflow */
 218          bfd_elf_generic_reloc, /* special_function */
 219          "R_C6000_ABS_S16",     /* name */
 220          FALSE,                 /* partial_inplace */
 221          0,                     /* src_mask */
 222          0x007fff80,            /* dst_mask */
 223          FALSE),                /* pcrel_offset */
 224   HOWTO (R_C6000_ABS_L16,       /* type */
 225          0,                     /* rightshift */
 226          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 227          16,                    /* bitsize */
 228          FALSE,                 /* pc_relative */
 229          7,                     /* bitpos */
 230          complain_overflow_dont,/* complain_on_overflow */
 231          bfd_elf_generic_reloc, /* special_function */
 232          "R_C6000_ABS_L16",     /* name */
 233          FALSE,                 /* partial_inplace */
 234          0,                     /* src_mask */
 235          0x007fff80,            /* dst_mask */
 236          FALSE),                /* pcrel_offset */
 237   HOWTO (R_C6000_ABS_H16,       /* type */
 238          16,                    /* rightshift */
 239          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 240          16,                    /* bitsize */
 241          FALSE,                 /* pc_relative */
 242          7,                     /* bitpos */
 243          complain_overflow_dont,/* complain_on_overflow */
 244          bfd_elf_generic_reloc, /* special_function */
 245          "R_C6000_ABS_H16",     /* name */
 246          FALSE,                 /* partial_inplace */
 247          0,                     /* src_mask */
 248          0x007fff80,            /* dst_mask */
 249          FALSE),                /* pcrel_offset */
 250   HOWTO (R_C6000_SBR_U15_B,     /* type */
 251          0,                     /* rightshift */
 252          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          15,                    /* bitsize */
 254          FALSE,                 /* pc_relative */
 255          8,                     /* bitpos */
 256          complain_overflow_unsigned,/* complain_on_overflow */
 257          bfd_elf_generic_reloc, /* special_function */
 258          "R_C6000_SBR_U15_B",   /* name */
 259          FALSE,                 /* partial_inplace */
 260          0,                     /* src_mask */
 261          0x007fff00,            /* dst_mask */
 262          FALSE),                /* pcrel_offset */
 263   HOWTO (R_C6000_SBR_U15_H,     /* type */
 264          1,                     /* rightshift */
 265          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 266          15,                    /* bitsize */
 267          FALSE,                 /* pc_relative */
 268          8,                     /* bitpos */
 269          complain_overflow_unsigned,/* complain_on_overflow */
 270          bfd_elf_generic_reloc, /* special_function */
 271          "R_C6000_SBR_U15_H",   /* name */
 272          FALSE,                 /* partial_inplace */
 273          0,                     /* src_mask */
 274          0x007fff00,            /* dst_mask */
 275          FALSE),                /* pcrel_offset */
 276   HOWTO (R_C6000_SBR_U15_W,     /* type */
 277          2,                     /* rightshift */
 278          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          15,                    /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          8,                     /* bitpos */
 282          complain_overflow_unsigned,/* complain_on_overflow */
 283          bfd_elf_generic_reloc, /* special_function */
 284          "R_C6000_SBR_U15_W",   /* name */
 285          FALSE,                 /* partial_inplace */
 286          0,                     /* src_mask */
 287          0x007fff00,            /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289   HOWTO (R_C6000_SBR_S16,       /* type */
 290          0,                     /* rightshift */
 291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 292          16,                    /* bitsize */
 293          FALSE,                 /* pc_relative */
 294          7,                     /* bitpos */
 295          complain_overflow_signed,/* complain_on_overflow */
 296          bfd_elf_generic_reloc, /* special_function */
 297          "R_C6000_SBR_S16",     /* name */
 298          FALSE,                 /* partial_inplace */
 299          0,                     /* src_mask */
 300          0x007fff80,            /* dst_mask */
 301          FALSE),                /* pcrel_offset */
 302   HOWTO (R_C6000_SBR_L16_B,     /* type */
 303          0,                     /* rightshift */
 304          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 305          16,                    /* bitsize */
 306          FALSE,                 /* pc_relative */
 307          7,                     /* bitpos */
 308          complain_overflow_dont,/* complain_on_overflow */
 309          bfd_elf_generic_reloc, /* special_function */
 310          "R_C6000_SBR_L16_B",   /* name */
 311          FALSE,                 /* partial_inplace */
 312          0,                     /* src_mask */
 313          0x007fff80,            /* dst_mask */
 314          FALSE),                /* pcrel_offset */
 315   HOWTO (R_C6000_SBR_L16_H,     /* type */
 316          1,                     /* rightshift */
 317          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          7,                     /* bitpos */
 321          complain_overflow_dont,/* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_C6000_SBR_L16_H",   /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0x007fff80,            /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328   HOWTO (R_C6000_SBR_L16_W,     /* type */
 329          2,                     /* rightshift */
 330          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 331          16,                    /* bitsize */
 332          FALSE,                 /* pc_relative */
 333          7,                     /* bitpos */
 334          complain_overflow_dont,/* complain_on_overflow */
 335          bfd_elf_generic_reloc, /* special_function */
 336          "R_C6000_SBR_L16_W",   /* name */
 337          FALSE,                 /* partial_inplace */
 338          0,                     /* src_mask */
 339          0x007fff80,            /* dst_mask */
 340          FALSE),                /* pcrel_offset */
 341   HOWTO (R_C6000_SBR_H16_B,     /* type */
 342          16,                    /* rightshift */
 343          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 344          16,                    /* bitsize */
 345          FALSE,                 /* pc_relative */
 346          7,                     /* bitpos */
 347          complain_overflow_dont,/* complain_on_overflow */
 348          bfd_elf_generic_reloc, /* special_function */
 349          "R_C6000_SBR_H16_B",   /* name */
 350          FALSE,                 /* partial_inplace */
 351          0,                     /* src_mask */
 352          0x007fff80,            /* dst_mask */
 353          FALSE),                /* pcrel_offset */
 354   HOWTO (R_C6000_SBR_H16_H,     /* type */
 355          17,                    /* rightshift */
 356          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          16,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          7,                     /* bitpos */
 360          complain_overflow_dont,/* complain_on_overflow */
 361          bfd_elf_generic_reloc, /* special_function */
 362          "R_C6000_SBR_H16_H",   /* name */
 363          FALSE,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0x007fff80,            /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367   HOWTO (R_C6000_SBR_H16_W,     /* type */
 368          18,                    /* rightshift */
 369          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 370          16,                    /* bitsize */
 371          FALSE,                 /* pc_relative */
 372          7,                     /* bitpos */
 373          complain_overflow_dont,/* complain_on_overflow */
 374          bfd_elf_generic_reloc, /* special_function */
 375          "R_C6000_SBR_H16_W",   /* name */
 376          FALSE,                 /* partial_inplace */
 377          0,                     /* src_mask */
 378          0x007fff80,            /* dst_mask */
 379          FALSE),                /* pcrel_offset */
 380   HOWTO (R_C6000_SBR_GOT_U15_W, /* type */
 381          2,                     /* rightshift */
 382          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 383          15,                    /* bitsize */
 384          FALSE,                 /* pc_relative */
 385          8,                     /* bitpos */
 386          complain_overflow_unsigned,/* complain_on_overflow */
 387          bfd_elf_generic_reloc, /* special_function */
 388          "R_C6000_SBR_GOT_U15_W",/* name */
 389          FALSE,                 /* partial_inplace */
 390          0,                     /* src_mask */
 391          0x007fff00,            /* dst_mask */
 392          FALSE),                /* pcrel_offset */
 393   HOWTO (R_C6000_SBR_GOT_L16_W, /* type */
 394          2,                     /* rightshift */
 395          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 396          16,                    /* bitsize */
 397          FALSE,                 /* pc_relative */
 398          7,                     /* bitpos */
 399          complain_overflow_dont,/* complain_on_overflow */
 400          bfd_elf_generic_reloc, /* special_function */
 401          "R_C6000_SBR_GOT_L16_W",/* name */
 402          FALSE,                 /* partial_inplace */
 403          0,                     /* src_mask */
 404          0x007fff80,            /* dst_mask */
 405          FALSE),                /* pcrel_offset */
 406   HOWTO (R_C6000_SBR_GOT_H16_W, /* type */
 407          18,                    /* rightshift */
 408          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 409          16,                    /* bitsize */
 410          FALSE,                 /* pc_relative */
 411          7,                     /* bitpos */
 412          complain_overflow_dont,/* complain_on_overflow */
 413          bfd_elf_generic_reloc, /* special_function */
 414          "R_C6000_SBR_GOT_H16_W",/* name */
 415          FALSE,                 /* partial_inplace */
 416          0,                     /* src_mask */
 417          0x007fff80,            /* dst_mask */
 418          FALSE),                /* pcrel_offset */
 419   HOWTO (R_C6000_DSBT_INDEX,    /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          15,                    /* bitsize */
 423          FALSE,                 /* pc_relative */
 424          8,                     /* bitpos */
 425          complain_overflow_unsigned,/* complain_on_overflow */
 426          bfd_elf_generic_reloc, /* special_function */
 427          "R_C6000_DSBT_INDEX",  /* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x007fff00,            /* dst_mask */
 431          FALSE),                /* pcrel_offset */
 432   HOWTO (R_C6000_PREL31,        /* type */
 433          1,                     /* rightshift */
 434          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 435          31,                    /* bitsize */
 436          TRUE,                  /* pc_relative */
 437          0,                     /* bitpos */
 438          complain_overflow_dont,/* complain_on_overflow */
 439          bfd_elf_generic_reloc, /* special_function */
 440          "R_C6000_PREL31",      /* name */
 441          FALSE,                 /* partial_inplace */
 442          0,                     /* src_mask */
 443          0x7fffffff,            /* dst_mask */
 444          TRUE),                 /* pcrel_offset */
 445   HOWTO (R_C6000_COPY,          /* type */
 446          0,                     /* rightshift */
 447          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 448          32,                    /* bitsize */
 449          FALSE,                 /* pc_relative */
 450          0,                     /* bitpos */
 451          complain_overflow_dont,/* complain_on_overflow */
 452          bfd_elf_generic_reloc, /* special_function */
 453          "R_C6000_COPY",        /* name */
 454          FALSE,                 /* partial_inplace */
 455          0,                     /* src_mask */
 456          0xffffffff,            /* dst_mask */
 457          FALSE),                /* pcrel_offset */
 458   HOWTO (R_C6000_JUMP_SLOT,     /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          32,                    /* bitsize */
 462          FALSE,                 /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_dont,/* complain_on_overflow */
 465          bfd_elf_generic_reloc, /* special_function */
 466          "R_C6000_JUMP_SLOT",   /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0xffffffff,            /* dst_mask */
 470          FALSE),                /* pcrel_offset */
 471   HOWTO (R_C6000_EHTYPE,        /* type */
 472          0,                     /* rightshift */
 473          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 474          32,                    /* bitsize */
 475          FALSE,                 /* pc_relative */
 476          0,                     /* bitpos */
 477          complain_overflow_dont,/* complain_on_overflow */
 478          bfd_elf_generic_reloc, /* special_function */
 479          "R_C6000_EHTYPE",      /* name */
 480          FALSE,                 /* partial_inplace */
 481          0,                     /* src_mask */
 482          0xffffffff,            /* dst_mask */
 483          FALSE),                /* pcrel_offset */
 484   EMPTY_HOWTO (29),
 485   EMPTY_HOWTO (30),
 486   EMPTY_HOWTO (31),
 487   EMPTY_HOWTO (32),
 488   EMPTY_HOWTO (33),
 489   EMPTY_HOWTO (34),
 490   EMPTY_HOWTO (35),
 491   EMPTY_HOWTO (36),
 492   EMPTY_HOWTO (37),
 493   EMPTY_HOWTO (38),
 494   EMPTY_HOWTO (39),
 495   EMPTY_HOWTO (40),
 496   EMPTY_HOWTO (41),
 497   EMPTY_HOWTO (42),
 498   EMPTY_HOWTO (43),
 499   EMPTY_HOWTO (44),
 500   EMPTY_HOWTO (45),
 501   EMPTY_HOWTO (46),
 502   EMPTY_HOWTO (47),
 503   EMPTY_HOWTO (48),
 504   EMPTY_HOWTO (49),
 505   EMPTY_HOWTO (50),
 506   EMPTY_HOWTO (51),
 507   EMPTY_HOWTO (52),
 508   EMPTY_HOWTO (53),
 509   EMPTY_HOWTO (54),
 510   EMPTY_HOWTO (55),
 511   EMPTY_HOWTO (56),
 512   EMPTY_HOWTO (57),
 513   EMPTY_HOWTO (58),
 514   EMPTY_HOWTO (59),
 515   EMPTY_HOWTO (60),
 516   EMPTY_HOWTO (61),
 517   EMPTY_HOWTO (62),
 518   EMPTY_HOWTO (63),
 519   EMPTY_HOWTO (64),
 520   EMPTY_HOWTO (65),
 521   EMPTY_HOWTO (66),
 522   EMPTY_HOWTO (67),
 523   EMPTY_HOWTO (68),
 524   EMPTY_HOWTO (69),
 525   EMPTY_HOWTO (70),
 526   EMPTY_HOWTO (71),
 527   EMPTY_HOWTO (72),
 528   EMPTY_HOWTO (73),
 529   EMPTY_HOWTO (74),
 530   EMPTY_HOWTO (75),
 531   EMPTY_HOWTO (76),
 532   EMPTY_HOWTO (77),
 533   EMPTY_HOWTO (78),
 534   EMPTY_HOWTO (79),
 535   EMPTY_HOWTO (80),
 536   EMPTY_HOWTO (81),
 537   EMPTY_HOWTO (82),
 538   EMPTY_HOWTO (83),
 539   EMPTY_HOWTO (84),
 540   EMPTY_HOWTO (85),
 541   EMPTY_HOWTO (86),
 542   EMPTY_HOWTO (87),
 543   EMPTY_HOWTO (88),
 544   EMPTY_HOWTO (89),
 545   EMPTY_HOWTO (90),
 546   EMPTY_HOWTO (91),
 547   EMPTY_HOWTO (92),
 548   EMPTY_HOWTO (93),
 549   EMPTY_HOWTO (94),
 550   EMPTY_HOWTO (95),
 551   EMPTY_HOWTO (96),
 552   EMPTY_HOWTO (97),
 553   EMPTY_HOWTO (98),
 554   EMPTY_HOWTO (99),
 555   EMPTY_HOWTO (100),
 556   EMPTY_HOWTO (101),
 557   EMPTY_HOWTO (102),
 558   EMPTY_HOWTO (103),
 559   EMPTY_HOWTO (104),
 560   EMPTY_HOWTO (105),
 561   EMPTY_HOWTO (106),
 562   EMPTY_HOWTO (107),
 563   EMPTY_HOWTO (108),
 564   EMPTY_HOWTO (109),
 565   EMPTY_HOWTO (110),
 566   EMPTY_HOWTO (111),
 567   EMPTY_HOWTO (112),
 568   EMPTY_HOWTO (113),
 569   EMPTY_HOWTO (114),
 570   EMPTY_HOWTO (115),
 571   EMPTY_HOWTO (116),
 572   EMPTY_HOWTO (117),
 573   EMPTY_HOWTO (118),
 574   EMPTY_HOWTO (119),
 575   EMPTY_HOWTO (120),
 576   EMPTY_HOWTO (121),
 577   EMPTY_HOWTO (122),
 578   EMPTY_HOWTO (123),
 579   EMPTY_HOWTO (124),
 580   EMPTY_HOWTO (125),
 581   EMPTY_HOWTO (126),
 582   EMPTY_HOWTO (127),
 583   EMPTY_HOWTO (128),
 584   EMPTY_HOWTO (129),
 585   EMPTY_HOWTO (130),
 586   EMPTY_HOWTO (131),
 587   EMPTY_HOWTO (132),
 588   EMPTY_HOWTO (133),
 589   EMPTY_HOWTO (134),
 590   EMPTY_HOWTO (135),
 591   EMPTY_HOWTO (136),
 592   EMPTY_HOWTO (137),
 593   EMPTY_HOWTO (138),
 594   EMPTY_HOWTO (139),
 595   EMPTY_HOWTO (140),
 596   EMPTY_HOWTO (141),
 597   EMPTY_HOWTO (142),
 598   EMPTY_HOWTO (143),
 599   EMPTY_HOWTO (144),
 600   EMPTY_HOWTO (145),
 601   EMPTY_HOWTO (146),
 602   EMPTY_HOWTO (147),
 603   EMPTY_HOWTO (148),
 604   EMPTY_HOWTO (149),
 605   EMPTY_HOWTO (150),
 606   EMPTY_HOWTO (151),
 607   EMPTY_HOWTO (152),
 608   EMPTY_HOWTO (153),
 609   EMPTY_HOWTO (154),
 610   EMPTY_HOWTO (155),
 611   EMPTY_HOWTO (156),
 612   EMPTY_HOWTO (157),
 613   EMPTY_HOWTO (158),
 614   EMPTY_HOWTO (159),
 615   EMPTY_HOWTO (160),
 616   EMPTY_HOWTO (161),
 617   EMPTY_HOWTO (162),
 618   EMPTY_HOWTO (163),
 619   EMPTY_HOWTO (164),
 620   EMPTY_HOWTO (165),
 621   EMPTY_HOWTO (166),
 622   EMPTY_HOWTO (167),
 623   EMPTY_HOWTO (168),
 624   EMPTY_HOWTO (169),
 625   EMPTY_HOWTO (170),
 626   EMPTY_HOWTO (171),
 627   EMPTY_HOWTO (172),
 628   EMPTY_HOWTO (173),
 629   EMPTY_HOWTO (174),
 630   EMPTY_HOWTO (175),
 631   EMPTY_HOWTO (176),
 632   EMPTY_HOWTO (177),
 633   EMPTY_HOWTO (178),
 634   EMPTY_HOWTO (179),
 635   EMPTY_HOWTO (180),
 636   EMPTY_HOWTO (181),
 637   EMPTY_HOWTO (182),
 638   EMPTY_HOWTO (183),
 639   EMPTY_HOWTO (184),
 640   EMPTY_HOWTO (185),
 641   EMPTY_HOWTO (186),
 642   EMPTY_HOWTO (187),
 643   EMPTY_HOWTO (188),
 644   EMPTY_HOWTO (189),
 645   EMPTY_HOWTO (190),
 646   EMPTY_HOWTO (191),
 647   EMPTY_HOWTO (192),
 648   EMPTY_HOWTO (193),
 649   EMPTY_HOWTO (194),
 650   EMPTY_HOWTO (195),
 651   EMPTY_HOWTO (196),
 652   EMPTY_HOWTO (197),
 653   EMPTY_HOWTO (198),
 654   EMPTY_HOWTO (199),
 655   EMPTY_HOWTO (200),
 656   EMPTY_HOWTO (201),
 657   EMPTY_HOWTO (202),
 658   EMPTY_HOWTO (203),
 659   EMPTY_HOWTO (204),
 660   EMPTY_HOWTO (205),
 661   EMPTY_HOWTO (206),
 662   EMPTY_HOWTO (207),
 663   EMPTY_HOWTO (208),
 664   EMPTY_HOWTO (209),
 665   EMPTY_HOWTO (210),
 666   EMPTY_HOWTO (211),
 667   EMPTY_HOWTO (212),
 668   EMPTY_HOWTO (213),
 669   EMPTY_HOWTO (214),
 670   EMPTY_HOWTO (215),
 671   EMPTY_HOWTO (216),
 672   EMPTY_HOWTO (217),
 673   EMPTY_HOWTO (218),
 674   EMPTY_HOWTO (219),
 675   EMPTY_HOWTO (220),
 676   EMPTY_HOWTO (221),
 677   EMPTY_HOWTO (222),
 678   EMPTY_HOWTO (223),
 679   EMPTY_HOWTO (224),
 680   EMPTY_HOWTO (225),
 681   EMPTY_HOWTO (226),
 682   EMPTY_HOWTO (227),
 683   EMPTY_HOWTO (228),
 684   EMPTY_HOWTO (229),
 685   EMPTY_HOWTO (230),
 686   EMPTY_HOWTO (231),
 687   EMPTY_HOWTO (232),
 688   EMPTY_HOWTO (233),
 689   EMPTY_HOWTO (234),
 690   EMPTY_HOWTO (235),
 691   EMPTY_HOWTO (236),
 692   EMPTY_HOWTO (237),
 693   EMPTY_HOWTO (238),
 694   EMPTY_HOWTO (239),
 695   EMPTY_HOWTO (240),
 696   EMPTY_HOWTO (241),
 697   EMPTY_HOWTO (242),
 698   EMPTY_HOWTO (243),
 699   EMPTY_HOWTO (244),
 700   EMPTY_HOWTO (245),
 701   EMPTY_HOWTO (246),
 702   EMPTY_HOWTO (247),
 703   EMPTY_HOWTO (248),
 704   EMPTY_HOWTO (249),
 705   EMPTY_HOWTO (250),
 706   EMPTY_HOWTO (251),
 707   EMPTY_HOWTO (252),
 708   HOWTO (R_C6000_ALIGN,         /* type */
 709          0,                     /* rightshift */
 710          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          0,                     /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_dont,/* complain_on_overflow */
 715          bfd_elf_generic_reloc, /* special_function */
 716          "R_C6000_ALIGN",       /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0,                     /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721   HOWTO (R_C6000_FPHEAD,        /* type */
 722          0,                     /* rightshift */
 723          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 724          0,                     /* bitsize */
 725          FALSE,                 /* pc_relative */
 726          0,                     /* bitpos */
 727          complain_overflow_dont,/* complain_on_overflow */
 728          bfd_elf_generic_reloc, /* special_function */
 729          "R_C6000_FPHEAD",      /* name */
 730          FALSE,                 /* partial_inplace */
 731          0,                     /* src_mask */
 732          0,                     /* dst_mask */
 733          FALSE),                /* pcrel_offset */
 734   HOWTO (R_C6000_NOCMP,         /* type */
 735          0,                     /* rightshift */
 736          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 737          0,                     /* bitsize */
 738          FALSE,                 /* pc_relative */
 739          0,                     /* bitpos */
 740          complain_overflow_dont,/* complain_on_overflow */
 741          bfd_elf_generic_reloc, /* special_function */
 742          "R_C6000_NOCMP",       /* name */
 743          FALSE,                 /* partial_inplace */
 744          0,                     /* src_mask */
 745          0,                     /* dst_mask */
 746          FALSE)                 /* pcrel_offset */
 747 };
 748
 749 static reloc_howto_type elf32_tic6x_howto_table_rel[] =
 750 {
 751   HOWTO (R_C6000_NONE,          /* type */
 752          0,                     /* rightshift */
 753          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          0,                     /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_dont,/* complain_on_overflow */
 758          bfd_elf_generic_reloc, /* special_function */
 759          "R_C6000_NONE",        /* name */
 760          TRUE,                  /* partial_inplace */
 761          0,                     /* src_mask */
 762          0,                     /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764   HOWTO (R_C6000_ABS32,         /* type */
 765          0,                     /* rightshift */
 766          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 767          32,                    /* bitsize */
 768          FALSE,                 /* pc_relative */
 769          0,                     /* bitpos */
 770          complain_overflow_dont,/* complain_on_overflow */
 771          bfd_elf_generic_reloc, /* special_function */
 772          "R_C6000_ABS32",       /* name */
 773          TRUE,                  /* partial_inplace */
 774          0xffffffff,            /* src_mask */
 775          0xffffffff,            /* dst_mask */
 776          FALSE),                /* pcrel_offset */
 777   HOWTO (R_C6000_ABS16,         /* type */
 778          0,                     /* rightshift */
 779          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 780          16,                    /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_bitfield,/* complain_on_overflow */
 784          bfd_elf_generic_reloc, /* special_function */
 785          "R_C6000_ABS16",       /* name */
 786          TRUE,                  /* partial_inplace */
 787          0x0000ffff,            /* src_mask */
 788          0x0000ffff,            /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790   HOWTO (R_C6000_ABS8,          /* type */
 791          0,                     /* rightshift */
 792          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 793          8,                     /* bitsize */
 794          FALSE,                 /* pc_relative */
 795          0,                     /* bitpos */
 796          complain_overflow_bitfield,/* complain_on_overflow */
 797          bfd_elf_generic_reloc, /* special_function */
 798          "R_C6000_ABS8",        /* name */
 799          TRUE,                  /* partial_inplace */
 800          0x000000ff,            /* src_mask */
 801          0x000000ff,            /* dst_mask */
 802          FALSE),                /* pcrel_offset */
 803   HOWTO (R_C6000_PCR_S21,       /* type */
 804          2,                     /* rightshift */
 805          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 806          21,                    /* bitsize */
 807          TRUE,                  /* pc_relative */
 808          7,                     /* bitpos */
 809          complain_overflow_signed,/* complain_on_overflow */
 810          bfd_elf_generic_reloc, /* special_function */
 811          "R_C6000_PCR_S21",     /* name */
 812          TRUE,                  /* partial_inplace */
 813          0x0fffff80,            /* src_mask */
 814          0x0fffff80,            /* dst_mask */
 815          TRUE),                 /* pcrel_offset */
 816   HOWTO (R_C6000_PCR_S12,       /* type */
 817          2,                     /* rightshift */
 818          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          12,                    /* bitsize */
 820          TRUE,                  /* pc_relative */
 821          16,                    /* bitpos */
 822          complain_overflow_signed,/* complain_on_overflow */
 823          bfd_elf_generic_reloc, /* special_function */
 824          "R_C6000_PCR_S12",     /* name */
 825          TRUE,                  /* partial_inplace */
 826          0x0fff0000,            /* src_mask */
 827          0x0fff0000,            /* dst_mask */
 828          TRUE),                 /* pcrel_offset */
 829   HOWTO (R_C6000_PCR_S10,       /* type */
 830          2,                     /* rightshift */
 831          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 832          10,                    /* bitsize */
 833          TRUE,                  /* pc_relative */
 834          13,                    /* bitpos */
 835          complain_overflow_signed,/* complain_on_overflow */
 836          bfd_elf_generic_reloc, /* special_function */
 837          "R_C6000_PCR_S10",     /* name */
 838          TRUE,                  /* partial_inplace */
 839          0x007fe000,            /* src_mask */
 840          0x007fe000,            /* dst_mask */
 841          TRUE),                 /* pcrel_offset */
 842   HOWTO (R_C6000_PCR_S7,        /* type */
 843          2,                     /* rightshift */
 844          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 845          7,                     /* bitsize */
 846          TRUE,                  /* pc_relative */
 847          16,                    /* bitpos */
 848          complain_overflow_signed,/* complain_on_overflow */
 849          bfd_elf_generic_reloc, /* special_function */
 850          "R_C6000_PCR_S7",      /* name */
 851          TRUE,                  /* partial_inplace */
 852          0x007f0000,            /* src_mask */
 853          0x007f0000,            /* dst_mask */
 854          TRUE),                 /* pcrel_offset */
 855   HOWTO (R_C6000_ABS_S16,       /* type */
 856          0,                     /* rightshift */
 857          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 858          16,                    /* bitsize */
 859          FALSE,                 /* pc_relative */
 860          7,                     /* bitpos */
 861          complain_overflow_signed,/* complain_on_overflow */
 862          bfd_elf_generic_reloc, /* special_function */
 863          "R_C6000_ABS_S16",     /* name */
 864          TRUE,                  /* partial_inplace */
 865          0x007fff80,            /* src_mask */
 866          0x007fff80,            /* dst_mask */
 867          FALSE),                /* pcrel_offset */
 868   HOWTO (R_C6000_ABS_L16,       /* type */
 869          0,                     /* rightshift */
 870          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 871          16,                    /* bitsize */
 872          FALSE,                 /* pc_relative */
 873          7,                     /* bitpos */
 874          complain_overflow_dont,/* complain_on_overflow */
 875          bfd_elf_generic_reloc, /* special_function */
 876          "R_C6000_ABS_L16",     /* name */
 877          TRUE,                  /* partial_inplace */
 878          0x007fff80,            /* src_mask */
 879          0x007fff80,            /* dst_mask */
 880          FALSE),                /* pcrel_offset */
 881   EMPTY_HOWTO (R_C6000_ABS_H16),
 882   HOWTO (R_C6000_SBR_U15_B,     /* type */
 883          0,                     /* rightshift */
 884          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 885          15,                    /* bitsize */
 886          FALSE,                 /* pc_relative */
 887          8,                     /* bitpos */
 888          complain_overflow_unsigned,/* complain_on_overflow */
 889          bfd_elf_generic_reloc, /* special_function */
 890          "R_C6000_SBR_U15_B",   /* name */
 891          TRUE,                  /* partial_inplace */
 892          0x007fff00,            /* src_mask */
 893          0x007fff00,            /* dst_mask */
 894          FALSE),                /* pcrel_offset */
 895   HOWTO (R_C6000_SBR_U15_H,     /* type */
 896          1,                     /* rightshift */
 897          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 898          15,                    /* bitsize */
 899          FALSE,                 /* pc_relative */
 900          8,                     /* bitpos */
 901          complain_overflow_unsigned,/* complain_on_overflow */
 902          bfd_elf_generic_reloc, /* special_function */
 903          "R_C6000_SBR_U15_H",   /* name */
 904          TRUE,                  /* partial_inplace */
 905          0x007fff00,            /* src_mask */
 906          0x007fff00,            /* dst_mask */
 907          FALSE),                /* pcrel_offset */
 908   HOWTO (R_C6000_SBR_U15_W,     /* type */
 909          2,                     /* rightshift */
 910          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 911          15,                    /* bitsize */
 912          FALSE,                 /* pc_relative */
 913          8,                     /* bitpos */
 914          complain_overflow_unsigned,/* complain_on_overflow */
 915          bfd_elf_generic_reloc, /* special_function */
 916          "R_C6000_SBR_U15_W",   /* name */
 917          TRUE,                  /* partial_inplace */
 918          0x007fff00,            /* src_mask */
 919          0x007fff00,            /* dst_mask */
 920          FALSE),                /* pcrel_offset */
 921   HOWTO (R_C6000_SBR_S16,       /* type */
 922          0,                     /* rightshift */
 923          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 924          16,                    /* bitsize */
 925          FALSE,                 /* pc_relative */
 926          7,                     /* bitpos */
 927          complain_overflow_signed,/* complain_on_overflow */
 928          bfd_elf_generic_reloc, /* special_function */
 929          "R_C6000_SBR_S16",     /* name */
 930          TRUE,                  /* partial_inplace */
 931          0x007fff80,            /* src_mask */
 932          0x007fff80,            /* dst_mask */
 933          FALSE),                /* pcrel_offset */
 934   HOWTO (R_C6000_SBR_L16_B,     /* type */
 935          0,                     /* rightshift */
 936          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 937          16,                    /* bitsize */
 938          FALSE,                 /* pc_relative */
 939          7,                     /* bitpos */
 940          complain_overflow_dont,/* complain_on_overflow */
 941          bfd_elf_generic_reloc, /* special_function */
 942          "R_C6000_SBR_L16_B",   /* name */
 943          TRUE,                  /* partial_inplace */
 944          0x007fff80,            /* src_mask */
 945          0x007fff80,            /* dst_mask */
 946          FALSE),                /* pcrel_offset */
 947   HOWTO (R_C6000_SBR_L16_H,     /* type */
 948          1,                     /* rightshift */
 949          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 950          16,                    /* bitsize */
 951          FALSE,                 /* pc_relative */
 952          7,                     /* bitpos */
 953          complain_overflow_dont,/* complain_on_overflow */
 954          bfd_elf_generic_reloc, /* special_function */
 955          "R_C6000_SBR_L16_H",   /* name */
 956          TRUE,                  /* partial_inplace */
 957          0x007fff80,            /* src_mask */
 958          0x007fff80,            /* dst_mask */
 959          FALSE),                /* pcrel_offset */
 960   HOWTO (R_C6000_SBR_L16_W,     /* type */
 961          2,                     /* rightshift */
 962          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 963          16,                    /* bitsize */
 964          FALSE,                 /* pc_relative */
 965          7,                     /* bitpos */
 966          complain_overflow_dont,/* complain_on_overflow */
 967          bfd_elf_generic_reloc, /* special_function */
 968          "R_C6000_SBR_L16_W",   /* name */
 969          TRUE,                  /* partial_inplace */
 970          0x007fff80,            /* src_mask */
 971          0x007fff80,            /* dst_mask */
 972          FALSE),                /* pcrel_offset */
 973   EMPTY_HOWTO (R_C6000_SBR_H16_B),
 974   EMPTY_HOWTO (R_C6000_SBR_H16_H),
 975   EMPTY_HOWTO (R_C6000_SBR_H16_W),
 976   HOWTO (R_C6000_SBR_GOT_U15_W, /* type */
 977          2,                     /* rightshift */
 978          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 979          15,                    /* bitsize */
 980          FALSE,                 /* pc_relative */
 981          8,                     /* bitpos */
 982          complain_overflow_unsigned,/* complain_on_overflow */
 983          bfd_elf_generic_reloc, /* special_function */
 984          "R_C6000_SBR_GOT_U15_W",/* name */
 985          TRUE,                  /* partial_inplace */
 986          0x007fff00,            /* src_mask */
 987          0x007fff00,            /* dst_mask */
 988          FALSE),                /* pcrel_offset */
 989   HOWTO (R_C6000_SBR_GOT_L16_W, /* type */
 990          2,                     /* rightshift */
 991          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 992          16,                    /* bitsize */
 993          FALSE,                 /* pc_relative */
 994          7,                     /* bitpos */
 995          complain_overflow_dont,/* complain_on_overflow */
 996          bfd_elf_generic_reloc, /* special_function */
 997          "R_C6000_SBR_GOT_L16_W",/* name */
 998          TRUE,                  /* partial_inplace */
 999          0x007fff80,            /* src_mask */
1000          0x007fff80,            /* dst_mask */
1001          FALSE),                /* pcrel_offset */
1002   EMPTY_HOWTO (R_C6000_SBR_GOT_H16_W),
1003   HOWTO (R_C6000_DSBT_INDEX,    /* type */
1004          0,                     /* rightshift */
1005          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1006          15,                    /* bitsize */
1007          FALSE,                 /* pc_relative */
1008          8,                     /* bitpos */
1009          complain_overflow_unsigned,/* complain_on_overflow */
1010          bfd_elf_generic_reloc, /* special_function */
1011          "R_C6000_DSBT_INDEX",  /* name */
1012          TRUE,                  /* partial_inplace */
1013          0,                     /* src_mask */
1014          0x007fff00,            /* dst_mask */
1015          FALSE),                /* pcrel_offset */
1016   HOWTO (R_C6000_PREL31,        /* type */
1017          1,                     /* rightshift */
1018          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1019          31,                    /* bitsize */
1020          TRUE,                  /* pc_relative */
1021          0,                     /* bitpos */
1022          complain_overflow_dont,/* complain_on_overflow */
1023          bfd_elf_generic_reloc, /* special_function */
1024          "R_C6000_PREL31",      /* name */
1025          TRUE,                  /* partial_inplace */
1026          0,                     /* src_mask */
1027          0x7fffffff,            /* dst_mask */
1028          TRUE),                 /* pcrel_offset */
1029   HOWTO (R_C6000_COPY,          /* type */
1030          0,                     /* rightshift */
1031          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1032          32,                    /* bitsize */
1033          FALSE,                 /* pc_relative */
1034          0,                     /* bitpos */
1035          complain_overflow_dont,/* complain_on_overflow */
1036          bfd_elf_generic_reloc, /* special_function */
1037          "R_C6000_COPY",        /* name */
1038          TRUE,                  /* partial_inplace */
1039          0,                     /* src_mask */
1040          0xffffffff,            /* dst_mask */
1041          FALSE),                /* pcrel_offset */
1042   HOWTO (R_C6000_JUMP_SLOT,     /* type */
1043          0,                     /* rightshift */
1044          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1045          32,                    /* bitsize */
1046          FALSE,                 /* pc_relative */
1047          0,                     /* bitpos */
1048          complain_overflow_dont,/* complain_on_overflow */
1049          bfd_elf_generic_reloc, /* special_function */
1050          "R_C6000_JUMP_SLOT",   /* name */
1051          FALSE,                 /* partial_inplace */
1052          0,                     /* src_mask */
1053          0xffffffff,            /* dst_mask */
1054          FALSE),                /* pcrel_offset */
1055   HOWTO (R_C6000_EHTYPE,        /* type */
1056          0,                     /* rightshift */
1057          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1058          32,                    /* bitsize */
1059          FALSE,                 /* pc_relative */
1060          0,                     /* bitpos */
1061          complain_overflow_dont,/* complain_on_overflow */
1062          bfd_elf_generic_reloc, /* special_function */
1063          "R_C6000_EHTYPE",      /* name */
1064          FALSE,                 /* partial_inplace */
1065          0,                     /* src_mask */
1066          0xffffffff,            /* dst_mask */
1067          FALSE),                /* pcrel_offset */
1068   EMPTY_HOWTO (29),
1069   EMPTY_HOWTO (30),
1070   EMPTY_HOWTO (31),
1071   EMPTY_HOWTO (32),
1072   EMPTY_HOWTO (33),
1073   EMPTY_HOWTO (34),
1074   EMPTY_HOWTO (35),
1075   EMPTY_HOWTO (36),
1076   EMPTY_HOWTO (37),
1077   EMPTY_HOWTO (38),
1078   EMPTY_HOWTO (39),
1079   EMPTY_HOWTO (40),
1080   EMPTY_HOWTO (41),
1081   EMPTY_HOWTO (42),
1082   EMPTY_HOWTO (43),
1083   EMPTY_HOWTO (44),
1084   EMPTY_HOWTO (45),
1085   EMPTY_HOWTO (46),
1086   EMPTY_HOWTO (47),
1087   EMPTY_HOWTO (48),
1088   EMPTY_HOWTO (49),
1089   EMPTY_HOWTO (50),
1090   EMPTY_HOWTO (51),
1091   EMPTY_HOWTO (52),
1092   EMPTY_HOWTO (53),
1093   EMPTY_HOWTO (54),
1094   EMPTY_HOWTO (55),
1095   EMPTY_HOWTO (56),
1096   EMPTY_HOWTO (57),
1097   EMPTY_HOWTO (58),
1098   EMPTY_HOWTO (59),
1099   EMPTY_HOWTO (60),
1100   EMPTY_HOWTO (61),
1101   EMPTY_HOWTO (62),
1102   EMPTY_HOWTO (63),
1103   EMPTY_HOWTO (64),
1104   EMPTY_HOWTO (65),
1105   EMPTY_HOWTO (66),
1106   EMPTY_HOWTO (67),
1107   EMPTY_HOWTO (68),
1108   EMPTY_HOWTO (69),
1109   EMPTY_HOWTO (70),
1110   EMPTY_HOWTO (71),
1111   EMPTY_HOWTO (72),
1112   EMPTY_HOWTO (73),
1113   EMPTY_HOWTO (74),
1114   EMPTY_HOWTO (75),
1115   EMPTY_HOWTO (76),
1116   EMPTY_HOWTO (77),
1117   EMPTY_HOWTO (78),
1118   EMPTY_HOWTO (79),
1119   EMPTY_HOWTO (80),
1120   EMPTY_HOWTO (81),
1121   EMPTY_HOWTO (82),
1122   EMPTY_HOWTO (83),
1123   EMPTY_HOWTO (84),
1124   EMPTY_HOWTO (85),
1125   EMPTY_HOWTO (86),
1126   EMPTY_HOWTO (87),
1127   EMPTY_HOWTO (88),
1128   EMPTY_HOWTO (89),
1129   EMPTY_HOWTO (90),
1130   EMPTY_HOWTO (91),
1131   EMPTY_HOWTO (92),
1132   EMPTY_HOWTO (93),
1133   EMPTY_HOWTO (94),
1134   EMPTY_HOWTO (95),
1135   EMPTY_HOWTO (96),
1136   EMPTY_HOWTO (97),
1137   EMPTY_HOWTO (98),
1138   EMPTY_HOWTO (99),
1139   EMPTY_HOWTO (100),
1140   EMPTY_HOWTO (101),
1141   EMPTY_HOWTO (102),
1142   EMPTY_HOWTO (103),
1143   EMPTY_HOWTO (104),
1144   EMPTY_HOWTO (105),
1145   EMPTY_HOWTO (106),
1146   EMPTY_HOWTO (107),
1147   EMPTY_HOWTO (108),
1148   EMPTY_HOWTO (109),
1149   EMPTY_HOWTO (110),
1150   EMPTY_HOWTO (111),
1151   EMPTY_HOWTO (112),
1152   EMPTY_HOWTO (113),
1153   EMPTY_HOWTO (114),
1154   EMPTY_HOWTO (115),
1155   EMPTY_HOWTO (116),
1156   EMPTY_HOWTO (117),
1157   EMPTY_HOWTO (118),
1158   EMPTY_HOWTO (119),
1159   EMPTY_HOWTO (120),
1160   EMPTY_HOWTO (121),
1161   EMPTY_HOWTO (122),
1162   EMPTY_HOWTO (123),
1163   EMPTY_HOWTO (124),
1164   EMPTY_HOWTO (125),
1165   EMPTY_HOWTO (126),
1166   EMPTY_HOWTO (127),
1167   EMPTY_HOWTO (128),
1168   EMPTY_HOWTO (129),
1169   EMPTY_HOWTO (130),
1170   EMPTY_HOWTO (131),
1171   EMPTY_HOWTO (132),
1172   EMPTY_HOWTO (133),
1173   EMPTY_HOWTO (134),
1174   EMPTY_HOWTO (135),
1175   EMPTY_HOWTO (136),
1176   EMPTY_HOWTO (137),
1177   EMPTY_HOWTO (138),
1178   EMPTY_HOWTO (139),
1179   EMPTY_HOWTO (140),
1180   EMPTY_HOWTO (141),
1181   EMPTY_HOWTO (142),
1182   EMPTY_HOWTO (143),
1183   EMPTY_HOWTO (144),
1184   EMPTY_HOWTO (145),
1185   EMPTY_HOWTO (146),
1186   EMPTY_HOWTO (147),
1187   EMPTY_HOWTO (148),
1188   EMPTY_HOWTO (149),
1189   EMPTY_HOWTO (150),
1190   EMPTY_HOWTO (151),
1191   EMPTY_HOWTO (152),
1192   EMPTY_HOWTO (153),
1193   EMPTY_HOWTO (154),
1194   EMPTY_HOWTO (155),
1195   EMPTY_HOWTO (156),
1196   EMPTY_HOWTO (157),
1197   EMPTY_HOWTO (158),
1198   EMPTY_HOWTO (159),
1199   EMPTY_HOWTO (160),
1200   EMPTY_HOWTO (161),
1201   EMPTY_HOWTO (162),
1202   EMPTY_HOWTO (163),
1203   EMPTY_HOWTO (164),
1204   EMPTY_HOWTO (165),
1205   EMPTY_HOWTO (166),
1206   EMPTY_HOWTO (167),
1207   EMPTY_HOWTO (168),
1208   EMPTY_HOWTO (169),
1209   EMPTY_HOWTO (170),
1210   EMPTY_HOWTO (171),
1211   EMPTY_HOWTO (172),
1212   EMPTY_HOWTO (173),
1213   EMPTY_HOWTO (174),
1214   EMPTY_HOWTO (175),
1215   EMPTY_HOWTO (176),
1216   EMPTY_HOWTO (177),
1217   EMPTY_HOWTO (178),
1218   EMPTY_HOWTO (179),
1219   EMPTY_HOWTO (180),
1220   EMPTY_HOWTO (181),
1221   EMPTY_HOWTO (182),
1222   EMPTY_HOWTO (183),
1223   EMPTY_HOWTO (184),
1224   EMPTY_HOWTO (185),
1225   EMPTY_HOWTO (186),
1226   EMPTY_HOWTO (187),
1227   EMPTY_HOWTO (188),
1228   EMPTY_HOWTO (189),
1229   EMPTY_HOWTO (190),
1230   EMPTY_HOWTO (191),
1231   EMPTY_HOWTO (192),
1232   EMPTY_HOWTO (193),
1233   EMPTY_HOWTO (194),
1234   EMPTY_HOWTO (195),
1235   EMPTY_HOWTO (196),
1236   EMPTY_HOWTO (197),
1237   EMPTY_HOWTO (198),
1238   EMPTY_HOWTO (199),
1239   EMPTY_HOWTO (200),
1240   EMPTY_HOWTO (201),
1241   EMPTY_HOWTO (202),
1242   EMPTY_HOWTO (203),
1243   EMPTY_HOWTO (204),
1244   EMPTY_HOWTO (205),
1245   EMPTY_HOWTO (206),
1246   EMPTY_HOWTO (207),
1247   EMPTY_HOWTO (208),
1248   EMPTY_HOWTO (209),
1249   EMPTY_HOWTO (210),
1250   EMPTY_HOWTO (211),
1251   EMPTY_HOWTO (212),
1252   EMPTY_HOWTO (213),
1253   EMPTY_HOWTO (214),
1254   EMPTY_HOWTO (215),
1255   EMPTY_HOWTO (216),
1256   EMPTY_HOWTO (217),
1257   EMPTY_HOWTO (218),
1258   EMPTY_HOWTO (219),
1259   EMPTY_HOWTO (220),
1260   EMPTY_HOWTO (221),
1261   EMPTY_HOWTO (222),
1262   EMPTY_HOWTO (223),
1263   EMPTY_HOWTO (224),
1264   EMPTY_HOWTO (225),
1265   EMPTY_HOWTO (226),
1266   EMPTY_HOWTO (227),
1267   EMPTY_HOWTO (228),
1268   EMPTY_HOWTO (229),
1269   EMPTY_HOWTO (230),
1270   EMPTY_HOWTO (231),
1271   EMPTY_HOWTO (232),
1272   EMPTY_HOWTO (233),
1273   EMPTY_HOWTO (234),
1274   EMPTY_HOWTO (235),
1275   EMPTY_HOWTO (236),
1276   EMPTY_HOWTO (237),
1277   EMPTY_HOWTO (238),
1278   EMPTY_HOWTO (239),
1279   EMPTY_HOWTO (240),
1280   EMPTY_HOWTO (241),
1281   EMPTY_HOWTO (242),
1282   EMPTY_HOWTO (243),
1283   EMPTY_HOWTO (244),
1284   EMPTY_HOWTO (245),
1285   EMPTY_HOWTO (246),
1286   EMPTY_HOWTO (247),
1287   EMPTY_HOWTO (248),
1288   EMPTY_HOWTO (249),
1289   EMPTY_HOWTO (250),
1290   EMPTY_HOWTO (251),
1291   EMPTY_HOWTO (252),
1292   HOWTO (R_C6000_ALIGN,         /* type */
1293          0,                     /* rightshift */
1294          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1295          0,                     /* bitsize */
1296          FALSE,                 /* pc_relative */
1297          0,                     /* bitpos */
1298          complain_overflow_dont,/* complain_on_overflow */
1299          bfd_elf_generic_reloc, /* special_function */
1300          "R_C6000_ALIGN",       /* name */
1301          TRUE,                  /* partial_inplace */
1302          0,                     /* src_mask */
1303          0,                     /* dst_mask */
1304          FALSE),                /* pcrel_offset */
1305   HOWTO (R_C6000_FPHEAD,        /* type */
1306          0,                     /* rightshift */
1307          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1308          0,                     /* bitsize */
1309          FALSE,                 /* pc_relative */
1310          0,                     /* bitpos */
1311          complain_overflow_dont,/* complain_on_overflow */
1312          bfd_elf_generic_reloc, /* special_function */
1313          "R_C6000_FPHEAD",      /* name */
1314          TRUE,                  /* partial_inplace */
1315          0,                     /* src_mask */
1316          0,                     /* dst_mask */
1317          FALSE),                /* pcrel_offset */
1318   HOWTO (R_C6000_NOCMP,         /* type */
1319          0,                     /* rightshift */
1320          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1321          0,                     /* bitsize */
1322          FALSE,                 /* pc_relative */
1323          0,                     /* bitpos */
1324          complain_overflow_dont,/* complain_on_overflow */
1325          bfd_elf_generic_reloc, /* special_function */
1326          "R_C6000_NOCMP",       /* name */
1327          TRUE,                  /* partial_inplace */
1328          0,                     /* src_mask */
1329          0,                     /* dst_mask */
1330          FALSE)                 /* pcrel_offset */
1331 };
1332
1333 /* Map BFD relocations to ELF relocations.  */
1334
1335 typedef struct
1336 {
1337   bfd_reloc_code_real_type bfd_reloc_val;
1338   enum elf_tic6x_reloc_type elf_reloc_val;
1339 } tic6x_reloc_map;
1340
1341 static const tic6x_reloc_map elf32_tic6x_reloc_map[] =
1342   {
1343     { BFD_RELOC_NONE, R_C6000_NONE },
1344     { BFD_RELOC_32, R_C6000_ABS32 },
1345     { BFD_RELOC_16, R_C6000_ABS16 },
1346     { BFD_RELOC_8, R_C6000_ABS8 },
1347     { BFD_RELOC_C6000_PCR_S21, R_C6000_PCR_S21 },
1348     { BFD_RELOC_C6000_PCR_S12, R_C6000_PCR_S12 },
1349     { BFD_RELOC_C6000_PCR_S10, R_C6000_PCR_S10 },
1350     { BFD_RELOC_C6000_PCR_S7, R_C6000_PCR_S7 },
1351     { BFD_RELOC_C6000_ABS_S16, R_C6000_ABS_S16 },
1352     { BFD_RELOC_C6000_ABS_L16, R_C6000_ABS_L16 },
1353     { BFD_RELOC_C6000_ABS_H16, R_C6000_ABS_H16 },
1354     { BFD_RELOC_C6000_SBR_U15_B, R_C6000_SBR_U15_B },
1355     { BFD_RELOC_C6000_SBR_U15_H, R_C6000_SBR_U15_H },
1356     { BFD_RELOC_C6000_SBR_U15_W, R_C6000_SBR_U15_W },
1357     { BFD_RELOC_C6000_SBR_S16, R_C6000_SBR_S16 },
1358     { BFD_RELOC_C6000_SBR_L16_B, R_C6000_SBR_L16_B },
1359     { BFD_RELOC_C6000_SBR_L16_H, R_C6000_SBR_L16_H },
1360     { BFD_RELOC_C6000_SBR_L16_W, R_C6000_SBR_L16_W },
1361     { BFD_RELOC_C6000_SBR_H16_B, R_C6000_SBR_H16_B },
1362     { BFD_RELOC_C6000_SBR_H16_H, R_C6000_SBR_H16_H },
1363     { BFD_RELOC_C6000_SBR_H16_W, R_C6000_SBR_H16_W },
1364     { BFD_RELOC_C6000_SBR_GOT_U15_W, R_C6000_SBR_GOT_U15_W },
1365     { BFD_RELOC_C6000_SBR_GOT_L16_W, R_C6000_SBR_GOT_L16_W },
1366     { BFD_RELOC_C6000_SBR_GOT_H16_W, R_C6000_SBR_GOT_H16_W },
1367     { BFD_RELOC_C6000_DSBT_INDEX, R_C6000_DSBT_INDEX },
1368     { BFD_RELOC_C6000_PREL31, R_C6000_PREL31 },
1369     { BFD_RELOC_C6000_COPY, R_C6000_COPY },
1370     { BFD_RELOC_C6000_JUMP_SLOT, R_C6000_JUMP_SLOT },
1371     { BFD_RELOC_C6000_EHTYPE, R_C6000_EHTYPE },
1372     { BFD_RELOC_C6000_PCR_H16, R_C6000_PCR_H16 },
1373     { BFD_RELOC_C6000_PCR_L16, R_C6000_PCR_L16 },
1374     { BFD_RELOC_C6000_ALIGN, R_C6000_ALIGN },
1375     { BFD_RELOC_C6000_FPHEAD, R_C6000_FPHEAD },
1376     { BFD_RELOC_C6000_NOCMP, R_C6000_NOCMP }
1377   };
1378
1379 static reloc_howto_type *
1380 elf32_tic6x_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
1381 {
1382   unsigned int i;
1383
1384   for (i = 0; i < ARRAY_SIZE (elf32_tic6x_reloc_map); i++)
1385     if (elf32_tic6x_reloc_map[i].bfd_reloc_val == code)
1386       {
1387         enum elf_tic6x_reloc_type elf_reloc_val;
1388         reloc_howto_type *howto;
1389
1390         elf_reloc_val = elf32_tic6x_reloc_map[i].elf_reloc_val;
1391         if (elf32_tic6x_tdata (abfd)->use_rela_p)
1392           howto = &elf32_tic6x_howto_table[elf_reloc_val];
1393         else
1394           howto = &elf32_tic6x_howto_table_rel[elf_reloc_val];
1395
1396         /* Some relocations are RELA-only; do not return them for
1397            REL.  */
1398         if (howto->name == NULL)
1399           howto = NULL;
1400
1401         return howto;
1402       }
1403
1404   return NULL;
1405 }
1406
1407 static reloc_howto_type *
1408 elf32_tic6x_reloc_name_lookup (bfd *abfd, const char *r_name)
1409 {
1410   if (elf32_tic6x_tdata (abfd)->use_rela_p)
1411     {
1412       unsigned int i;
1413
1414       for (i = 0; i < ARRAY_SIZE (elf32_tic6x_howto_table); i++)
1415         if (elf32_tic6x_howto_table[i].name != NULL
1416             && strcasecmp (elf32_tic6x_howto_table[i].name, r_name) == 0)
1417           return &elf32_tic6x_howto_table[i];
1418     }
1419   else
1420     {
1421       unsigned int i;
1422
1423       for (i = 0; i < ARRAY_SIZE (elf32_tic6x_howto_table_rel); i++)
1424         if (elf32_tic6x_howto_table_rel[i].name != NULL
1425             && strcasecmp (elf32_tic6x_howto_table_rel[i].name, r_name) == 0)
1426           return &elf32_tic6x_howto_table_rel[i];
1427     }
1428
1429   return NULL;
1430 }
1431
1432 static void
1433 elf32_tic6x_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
1434                            Elf_Internal_Rela *elf_reloc)
1435 {
1436   unsigned int r_type;
1437
1438   r_type = ELF32_R_TYPE (elf_reloc->r_info);
1439   if (r_type >= ARRAY_SIZE (elf32_tic6x_howto_table))
1440     bfd_reloc->howto = NULL;
1441   else
1442     bfd_reloc->howto = &elf32_tic6x_howto_table[r_type];
1443 }
1444
1445 static void
1446 elf32_tic6x_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
1447                                Elf_Internal_Rela *elf_reloc)
1448 {
1449   unsigned int r_type;
1450
1451   r_type = ELF32_R_TYPE (elf_reloc->r_info);
1452   if (r_type >= ARRAY_SIZE (elf32_tic6x_howto_table_rel))
1453     bfd_reloc->howto = NULL;
1454   else
1455     bfd_reloc->howto = &elf32_tic6x_howto_table_rel[r_type];
1456 }
1457
1458 void
1459 elf32_tic6x_set_use_rela_p (bfd *abfd, bfd_boolean use_rela_p)
1460 {
1461   elf32_tic6x_tdata (abfd)->use_rela_p = use_rela_p;
1462 }
1463
1464 /* Create an entry in a C6X ELF linker hash table.  */
1465
1466 static struct bfd_hash_entry *
1467 elf32_tic6x_link_hash_newfunc (struct bfd_hash_entry *entry,
1468                             struct bfd_hash_table *table,
1469                             const char *string)
1470 {
1471   /* Allocate the structure if it has not already been allocated by a
1472      subclass.  */
1473   if (entry == NULL)
1474     {
1475       entry = bfd_hash_allocate (table,
1476                                  sizeof (struct elf32_tic6x_link_hash_entry));
1477       if (entry == NULL)
1478         return entry;
1479     }
1480
1481   /* Call the allocation method of the superclass.  */
1482   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1483   if (entry != NULL)
1484     {
1485       struct elf32_tic6x_link_hash_entry *eh;
1486
1487       eh = (struct elf32_tic6x_link_hash_entry *) entry;
1488       eh->dyn_relocs = NULL;
1489     }
1490
1491   return entry;
1492 }
1493
1494 /* Create a C6X ELF linker hash table.  */
1495
1496 static struct bfd_link_hash_table *
1497 elf32_tic6x_link_hash_table_create (bfd *abfd)
1498 {
1499   struct elf32_tic6x_link_hash_table *ret;
1500   bfd_size_type amt = sizeof (struct elf32_tic6x_link_hash_table);
1501
1502   ret = bfd_malloc (amt);
1503   if (ret == NULL)
1504     return NULL;
1505
1506   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1507                                       elf32_tic6x_link_hash_newfunc,
1508                                       sizeof (struct elf32_tic6x_link_hash_entry),
1509                                       TIC6X_ELF_DATA))
1510     {
1511       free (ret);
1512       return NULL;
1513     }
1514
1515   ret->sym_cache.abfd = NULL;
1516   ret->obfd = abfd;
1517   ret->elf.is_relocatable_executable = 1;
1518
1519   return &ret->elf.root;
1520 }
1521
1522 /* Destroy a C6X ELF linker hash table.  */
1523
1524 static void
1525 elf32_tic6x_link_hash_table_free (struct bfd_link_hash_table *hash)
1526 {
1527   _bfd_generic_link_hash_table_free (hash);
1528 }
1529
1530 /* Called to pass PARAMS to the backend.  We store them in the hash table
1531    associated with INFO.  */
1532
1533 void
1534 elf32_tic6x_setup (struct bfd_link_info *info,
1535                    struct elf32_tic6x_params *params)
1536 {
1537   struct elf32_tic6x_link_hash_table *htab = elf32_tic6x_hash_table (info);
1538   htab->params = *params;
1539 }
1540
1541 /* Determine if we're dealing with a DSBT object.  */
1542
1543 static bfd_boolean
1544 elf32_tic6x_using_dsbt (bfd *abfd)
1545 {
1546   return bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC,
1547                                    Tag_ABI_DSBT);
1548 }
1549
1550 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got and .dsbt
1551    sections in DYNOBJ, and set up shortcuts to them in our hash
1552    table.  */
1553
1554 static bfd_boolean
1555 elf32_tic6x_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1556 {
1557   struct elf32_tic6x_link_hash_table *htab;
1558   flagword flags;
1559
1560   htab = elf32_tic6x_hash_table (info);
1561   if (htab == NULL)
1562     return FALSE;
1563
1564   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1565     return FALSE;
1566
1567   /* Create .dsbt  */
1568   flags = (SEC_ALLOC | SEC_LOAD
1569            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1570   htab->dsbt = bfd_make_section_anyway_with_flags (dynobj, ".dsbt",
1571                                                    flags);
1572   if (htab->dsbt == NULL
1573       || ! bfd_set_section_alignment (dynobj, htab->dsbt, 2)
1574       || ! bfd_set_section_alignment (dynobj, htab->elf.splt, 5))
1575     return FALSE;
1576
1577   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1578   if (!info->shared)
1579     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1580
1581   if (!htab->sdynbss
1582       || (!info->shared && !htab->srelbss))
1583     abort ();
1584
1585   return TRUE;
1586 }
1587
1588 static bfd_boolean
1589 elf32_tic6x_mkobject (bfd *abfd)
1590 {
1591   bfd_boolean ret;
1592
1593   ret = bfd_elf_allocate_object (abfd, sizeof (struct elf32_tic6x_obj_tdata),
1594                                  TIC6X_ELF_DATA);
1595   if (ret)
1596     elf32_tic6x_set_use_rela_p (abfd, TRUE);
1597   return ret;
1598 }
1599
1600 /* Install relocation RELA into section SRELA, incrementing its
1601    reloc_count.  */
1602
1603 static void
1604 elf32_tic6x_install_rela (bfd *output_bfd, asection *srela,
1605                           Elf_Internal_Rela *rela)
1606 {
1607   bfd_byte *loc;
1608   bfd_vma off = srela->reloc_count++ * sizeof (Elf32_External_Rela);
1609   loc = srela->contents + off;
1610   BFD_ASSERT (off < srela->size);
1611   bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
1612 }
1613
1614 /* Create a dynamic reloc against the GOT at offset OFFSET.  The contents
1615    of the GOT at this offset have been initialized with the relocation.  */
1616
1617 static void
1618 elf32_tic6x_make_got_dynreloc (bfd *output_bfd,
1619                                struct elf32_tic6x_link_hash_table *htab,
1620                                asection *sym_sec, bfd_vma offset)
1621 {
1622   asection *sgot = htab->elf.sgot;
1623   Elf_Internal_Rela outrel;
1624   int dynindx;
1625
1626   outrel.r_offset = sgot->output_section->vma + sgot->output_offset + offset;
1627   outrel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
1628   if (sym_sec && sym_sec->output_section
1629       && ! bfd_is_abs_section (sym_sec->output_section)
1630       && ! bfd_is_und_section (sym_sec->output_section))
1631     {
1632       dynindx = elf_section_data (sym_sec->output_section)->dynindx;
1633       outrel.r_addend -= sym_sec->output_section->vma;
1634     }
1635   else
1636     {
1637       dynindx = 0;
1638     }
1639   outrel.r_info = ELF32_R_INFO (dynindx, R_C6000_ABS32);
1640   elf32_tic6x_install_rela (output_bfd, htab->elf.srelgot, &outrel);
1641 }
1642
1643 /* Finish up dynamic symbol handling.  We set the contents of various
1644    dynamic sections here.  */
1645
1646 static bfd_boolean
1647 elf32_tic6x_finish_dynamic_symbol (bfd * output_bfd,
1648                                    struct bfd_link_info *info,
1649                                    struct elf_link_hash_entry *h,
1650                                    Elf_Internal_Sym * sym)
1651 {
1652   bfd *dynobj;
1653   struct elf32_tic6x_link_hash_table *htab;
1654
1655   htab = elf32_tic6x_hash_table (info);
1656   dynobj = htab->elf.dynobj;
1657
1658   if (h->plt.offset != (bfd_vma) -1)
1659     {
1660       bfd_vma plt_index;
1661       bfd_vma got_section_offset, got_dp_offset, rela_offset;
1662       Elf_Internal_Rela rela;
1663       bfd_byte *loc;
1664       asection *plt, *gotplt, *relplt;
1665       const struct elf_backend_data *bed;
1666
1667       bed = get_elf_backend_data (output_bfd);
1668
1669       BFD_ASSERT (htab->elf.splt != NULL);
1670       plt = htab->elf.splt;
1671       gotplt = htab->elf.sgotplt;
1672       relplt = htab->elf.srelplt;
1673
1674       /* This symbol has an entry in the procedure linkage table.  Set
1675          it up.  */
1676
1677       if ((h->dynindx == -1
1678            && !((h->forced_local || info->executable)
1679                 && h->def_regular
1680                 && h->type == STT_GNU_IFUNC))
1681           || plt == NULL
1682           || gotplt == NULL
1683           || relplt == NULL)
1684         abort ();
1685
1686       /* Get the index in the procedure linkage table which
1687          corresponds to this symbol.  This is the index of this symbol
1688          in all the symbols for which we are making plt entries.  The
1689          first entry in the procedure linkage table is reserved.
1690
1691          Get the offset into the .got table of the entry that
1692          corresponds to this function.  Each .got entry is 4 bytes.
1693          The first three are reserved.
1694
1695          For static executables, we don't reserve anything.  */
1696
1697       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1698       got_section_offset = plt_index + bed->got_header_size / 4;
1699       got_dp_offset = got_section_offset + htab->params.dsbt_size;
1700       rela_offset = plt_index * sizeof (Elf32_External_Rela);
1701
1702       got_section_offset *= 4;
1703
1704       /* Fill in the entry in the procedure linkage table.  */
1705
1706       /* ldw .d2t2 *+B14($GOT(f)), b2 */
1707       bfd_put_32 (output_bfd, got_dp_offset << 8 | 0x0100006e,
1708                   plt->contents + h->plt.offset);
1709       /* mvk .s2 low(rela_offset), b0 */
1710       bfd_put_32 (output_bfd, (rela_offset & 0xffff) << 7 | 0x0000002a,
1711                   plt->contents + h->plt.offset + 4);
1712       /* mvkh .s2 high(rela_offset), b0 */
1713       bfd_put_32 (output_bfd, ((rela_offset >> 16) & 0xffff) << 7 | 0x0000006a,
1714                   plt->contents + h->plt.offset + 8);
1715       /* nop 2 */
1716       bfd_put_32 (output_bfd, 0x00002000,
1717                   plt->contents + h->plt.offset + 12);
1718       /* b .s2 b2 */
1719       bfd_put_32 (output_bfd, 0x00080362,
1720                   plt->contents + h->plt.offset + 16);
1721       /* nop 5 */
1722       bfd_put_32 (output_bfd, 0x00008000,
1723                   plt->contents + h->plt.offset + 20);
1724
1725       /* Fill in the entry in the global offset table.  */
1726       bfd_put_32 (output_bfd,
1727                   (plt->output_section->vma + plt->output_offset),
1728                   gotplt->contents + got_section_offset);
1729
1730       /* Fill in the entry in the .rel.plt section.  */
1731       rela.r_offset = (gotplt->output_section->vma
1732                        + gotplt->output_offset
1733                        + got_section_offset);
1734       rela.r_info = ELF32_R_INFO (h->dynindx, R_C6000_JUMP_SLOT);
1735       rela.r_addend = 0;
1736       loc = relplt->contents + rela_offset;
1737       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1738
1739       if (!h->def_regular)
1740         {
1741           /* Mark the symbol as undefined, rather than as defined in
1742              the .plt section.  */
1743           sym->st_shndx = SHN_UNDEF;
1744           sym->st_value = 0;
1745         }
1746     }
1747
1748   if (h->got.offset != (bfd_vma) -1)
1749     {
1750       asection *sgot;
1751       asection *srela;
1752
1753       /* This symbol has an entry in the global offset table.
1754          Set it up.  */
1755
1756       sgot = bfd_get_section_by_name (dynobj, ".got");
1757       srela = bfd_get_section_by_name (dynobj, ".rela.got");
1758       BFD_ASSERT (sgot != NULL && srela != NULL);
1759
1760       /* If this is a -Bsymbolic link, and the symbol is defined
1761          locally, we just want to emit a RELATIVE reloc.  Likewise if
1762          the symbol was forced to be local because of a version file.
1763          The entry in the global offset table will already have been
1764          initialized in the relocate_section function.  */
1765       if (info->shared
1766           && (info->symbolic
1767               || h->dynindx == -1 || h->forced_local) && h->def_regular)
1768         {
1769           asection *s = h->root.u.def.section;
1770           elf32_tic6x_make_got_dynreloc (output_bfd, htab, s,
1771                              h->got.offset & ~(bfd_vma) 1);
1772         }
1773       else
1774         {
1775           Elf_Internal_Rela outrel;
1776           bfd_put_32 (output_bfd, (bfd_vma) 0,
1777                       sgot->contents + (h->got.offset & ~(bfd_vma) 1));
1778           outrel.r_offset = (sgot->output_section->vma
1779                            + sgot->output_offset
1780                            + (h->got.offset & ~(bfd_vma) 1));
1781           outrel.r_info = ELF32_R_INFO (h->dynindx, R_C6000_ABS32);
1782           outrel.r_addend = 0;
1783
1784           elf32_tic6x_install_rela (output_bfd, srela, &outrel);
1785         }
1786     }
1787
1788   if (h->needs_copy)
1789     {
1790       Elf_Internal_Rela rel;
1791
1792       /* This symbol needs a copy reloc.  Set it up.  */
1793
1794       if (h->dynindx == -1
1795           || (h->root.type != bfd_link_hash_defined
1796               && h->root.type != bfd_link_hash_defweak)
1797           || htab->srelbss == NULL)
1798         abort ();
1799
1800       rel.r_offset = (h->root.u.def.value
1801                       + h->root.u.def.section->output_section->vma
1802                       + h->root.u.def.section->output_offset);
1803       rel.r_info = ELF32_R_INFO (h->dynindx, R_C6000_COPY);
1804       rel.r_addend = 0;
1805
1806       elf32_tic6x_install_rela (output_bfd, htab->srelbss, &rel);
1807     }
1808
1809   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
1810   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1811       || h == elf_hash_table (info)->hgot)
1812     sym->st_shndx = SHN_ABS;
1813
1814   return TRUE;
1815 }
1816
1817 /* Update the got entry reference counts for the section being removed.  */
1818
1819 static bfd_boolean
1820 elf32_tic6x_gc_sweep_hook (bfd *abfd,
1821                            struct bfd_link_info *info,
1822                            asection *sec,
1823                            const Elf_Internal_Rela *relocs)
1824 {
1825   struct elf32_tic6x_link_hash_table *htab;
1826   Elf_Internal_Shdr *symtab_hdr;
1827   struct elf_link_hash_entry **sym_hashes;
1828   bfd_signed_vma *local_got_refcounts;
1829   const Elf_Internal_Rela *rel, *relend;
1830
1831   if (info->relocatable)
1832     return TRUE;
1833
1834   htab = elf32_tic6x_hash_table (info);
1835   if (htab == NULL)
1836     return FALSE;
1837
1838   elf_section_data (sec)->local_dynrel = NULL;
1839
1840   symtab_hdr = &elf_symtab_hdr (abfd);
1841   sym_hashes = elf_sym_hashes (abfd);
1842   local_got_refcounts = elf_local_got_refcounts (abfd);
1843
1844   relend = relocs + sec->reloc_count;
1845   for (rel = relocs; rel < relend; rel++)
1846     {
1847       unsigned long r_symndx;
1848       unsigned int r_type;
1849       struct elf_link_hash_entry *h = NULL;
1850
1851       r_symndx = ELF32_R_SYM (rel->r_info);
1852       if (r_symndx >= symtab_hdr->sh_info)
1853         {
1854           struct elf32_tic6x_link_hash_entry *eh;
1855           struct elf_dyn_relocs **pp;
1856           struct elf_dyn_relocs *p;
1857
1858           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1859           while (h->root.type == bfd_link_hash_indirect
1860                  || h->root.type == bfd_link_hash_warning)
1861             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1862           eh = (struct elf32_tic6x_link_hash_entry *) h;
1863
1864           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1865             if (p->sec == sec)
1866               {
1867                 /* Everything must go for SEC.  */
1868                 *pp = p->next;
1869                 break;
1870               }
1871         }
1872
1873       r_type = ELF32_R_TYPE (rel->r_info);
1874
1875       switch (r_type)
1876         {
1877         case R_C6000_SBR_GOT_U15_W:
1878         case R_C6000_SBR_GOT_L16_W:
1879         case R_C6000_SBR_GOT_H16_W:
1880         case R_C6000_EHTYPE:
1881           if (h != NULL)
1882             {
1883               if (h->got.refcount > 0)
1884                 h->got.refcount -= 1;
1885             }
1886           else if (local_got_refcounts != NULL)
1887             {
1888               if (local_got_refcounts[r_symndx] > 0)
1889                 local_got_refcounts[r_symndx] -= 1;
1890             }
1891           break;
1892
1893         default:
1894           break;
1895         }
1896     }
1897
1898   return TRUE;
1899 }
1900
1901 /* Adjust a symbol defined by a dynamic object and referenced by a
1902    regular object.  The current definition is in some section of the
1903    dynamic object, but we're not including those sections.  We have to
1904    change the definition to something the rest of the link can
1905    understand.  */
1906
1907 static bfd_boolean
1908 elf32_tic6x_adjust_dynamic_symbol (struct bfd_link_info *info,
1909                                    struct elf_link_hash_entry *h)
1910 {
1911   struct elf32_tic6x_link_hash_table *htab;
1912   bfd *dynobj;
1913   asection *s;
1914
1915   dynobj = elf_hash_table (info)->dynobj;
1916
1917   /* Make sure we know what is going on here.  */
1918   BFD_ASSERT (dynobj != NULL
1919               && (h->needs_plt
1920                   || h->u.weakdef != NULL
1921                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
1922
1923   /* If this is a function, put it in the procedure linkage table.  We
1924      will fill in the contents of the procedure linkage table later,
1925      when we know the address of the .got section.  */
1926   if (h->type == STT_FUNC
1927       || h->needs_plt)
1928     {
1929       if (h->plt.refcount <= 0
1930           || SYMBOL_CALLS_LOCAL (info, h)
1931           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1932               && h->root.type == bfd_link_hash_undefweak))
1933         {
1934           /* This case can occur if we saw a PLT32 reloc in an input
1935              file, but the symbol was never referred to by a dynamic
1936              object, or if all references were garbage collected.  In
1937              such a case, we don't actually need to build a procedure
1938              linkage table, and we can just do a PC32 reloc instead.  */
1939           h->plt.offset = (bfd_vma) -1;
1940           h->needs_plt = 0;
1941         }
1942
1943       return TRUE;
1944     }
1945
1946   /* If this is a weak symbol, and there is a real definition, the
1947      processor independent code will have arranged for us to see the
1948      real definition first, and we can just use the same value.  */
1949   if (h->u.weakdef != NULL)
1950     {
1951       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1952                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1953       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1954       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1955       h->non_got_ref = h->u.weakdef->non_got_ref;
1956       return TRUE;
1957     }
1958
1959   /* This is a reference to a symbol defined by a dynamic object which
1960      is not a function.  */
1961
1962   /* If we are creating a shared library, we must presume that the
1963      only references to the symbol are via the global offset table.
1964      For such cases we need not do anything here; the relocations will
1965      be handled correctly by relocate_section.  */
1966   if (info->shared)
1967     return TRUE;
1968
1969   /* If there are no references to this symbol that do not use the
1970      GOT, we don't need to generate a copy reloc.  */
1971   if (!h->non_got_ref)
1972     return TRUE;
1973
1974   /* If -z nocopyreloc was given, we won't generate them either.  */
1975   if (info->nocopyreloc)
1976     {
1977       h->non_got_ref = 0;
1978       return TRUE;
1979     }
1980
1981   htab = elf32_tic6x_hash_table (info);
1982   if (htab == NULL)
1983     return FALSE;
1984
1985   if (h->size == 0)
1986     {
1987       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1988                              h->root.root.string);
1989       return TRUE;
1990     }
1991
1992   /* We must allocate the symbol in our .dynbss section, which will
1993      become part of the .bss section of the executable.  There will be
1994      an entry for this symbol in the .dynsym section.  The dynamic
1995      object will contain position independent code, so all references
1996      from the dynamic object to this symbol will go through the global
1997      offset table.  The dynamic linker will use the .dynsym entry to
1998      determine the address it must put in the global offset table, so
1999      both the dynamic object and the regular object will refer to the
2000      same memory location for the variable.  */
2001
2002   /* We must generate a R_C6000_COPY reloc to tell the dynamic linker to
2003      copy the initial value out of the dynamic object and into the
2004      runtime process image.  */
2005   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2006     {
2007       htab->srelbss->size += sizeof (Elf32_External_Rela);
2008       h->needs_copy = 1;
2009     }
2010
2011   s = htab->sdynbss;
2012
2013   return _bfd_elf_adjust_dynamic_copy (h, s);
2014 }
2015
2016 static bfd_boolean
2017 elf32_tic6x_new_section_hook (bfd *abfd, asection *sec)
2018 {
2019   bfd_boolean ret;
2020
2021   ret = _bfd_elf_new_section_hook (abfd, sec);
2022   sec->use_rela_p = elf32_tic6x_tdata (abfd)->use_rela_p;
2023
2024   return ret;
2025 }
2026
2027 /* Return true if relocation REL against section SEC is a REL rather
2028    than RELA relocation.  RELOCS is the first relocation in the
2029    section and ABFD is the bfd that contains SEC.  */
2030
2031 static bfd_boolean
2032 elf32_tic6x_rel_relocation_p (bfd *abfd, asection *sec,
2033                               const Elf_Internal_Rela *relocs,
2034                               const Elf_Internal_Rela *rel)
2035 {
2036   Elf_Internal_Shdr *rel_hdr;
2037   const struct elf_backend_data *bed;
2038
2039   /* To determine which flavor of relocation this is, we depend on the
2040      fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR.  */
2041   rel_hdr = elf_section_data (sec)->rel.hdr;
2042   if (rel_hdr == NULL)
2043     return FALSE;
2044   bed = get_elf_backend_data (abfd);
2045   return ((size_t) (rel - relocs)
2046           < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
2047 }
2048
2049 /* We need dynamic symbols for every section, since segments can
2050    relocate independently.  */
2051 static bfd_boolean
2052 elf32_tic6x_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
2053                                       struct bfd_link_info *info ATTRIBUTE_UNUSED,
2054                                       asection *p)
2055 {
2056   switch (elf_section_data (p)->this_hdr.sh_type)
2057     {
2058     case SHT_PROGBITS:
2059     case SHT_NOBITS:
2060       /* If sh_type is yet undecided, assume it could be
2061          SHT_PROGBITS/SHT_NOBITS.  */
2062     case SHT_NULL:
2063       return FALSE;
2064
2065       /* There shouldn't be section relative relocations
2066          against any other section.  */
2067     default:
2068       return TRUE;
2069     }
2070 }
2071
2072 static bfd_boolean
2073 elf32_tic6x_relocate_section (bfd *output_bfd,
2074                               struct bfd_link_info *info,
2075                               bfd *input_bfd,
2076                               asection *input_section,
2077                               bfd_byte *contents,
2078                               Elf_Internal_Rela *relocs,
2079                               Elf_Internal_Sym *local_syms,
2080                               asection **local_sections)
2081 {
2082   struct elf32_tic6x_link_hash_table *htab;
2083   Elf_Internal_Shdr *symtab_hdr;
2084   struct elf_link_hash_entry **sym_hashes;
2085   bfd_vma *local_got_offsets;
2086   Elf_Internal_Rela *rel;
2087   Elf_Internal_Rela *relend;
2088   bfd_boolean ok = TRUE;
2089
2090   htab = elf32_tic6x_hash_table (info);
2091   symtab_hdr = & elf_symtab_hdr (input_bfd);
2092   sym_hashes = elf_sym_hashes (input_bfd);
2093   local_got_offsets = elf_local_got_offsets (input_bfd);
2094
2095   relend = relocs + input_section->reloc_count;
2096
2097   for (rel = relocs; rel < relend; rel ++)
2098     {
2099       int r_type;
2100       unsigned long r_symndx;
2101       arelent bfd_reloc;
2102       reloc_howto_type *howto;
2103       Elf_Internal_Sym *sym;
2104       asection *sec;
2105       struct elf_link_hash_entry *h;
2106       bfd_vma off, relocation;
2107       bfd_boolean unresolved_reloc;
2108       bfd_reloc_status_type r;
2109       struct bfd_link_hash_entry *sbh;
2110       bfd_boolean is_rel;
2111
2112       r_type = ELF32_R_TYPE (rel->r_info);
2113       r_symndx = ELF32_R_SYM (rel->r_info);
2114
2115       is_rel = elf32_tic6x_rel_relocation_p (input_bfd, input_section,
2116                                              relocs, rel);
2117
2118       if (is_rel)
2119         elf32_tic6x_info_to_howto_rel (input_bfd, &bfd_reloc, rel);
2120       else
2121         elf32_tic6x_info_to_howto (input_bfd, &bfd_reloc, rel);
2122       howto = bfd_reloc.howto;
2123       if (howto == NULL)
2124         {
2125           bfd_set_error (bfd_error_bad_value);
2126           return FALSE;
2127         }
2128
2129       h = NULL;
2130       sym = NULL;
2131       sec = NULL;
2132       unresolved_reloc = FALSE;
2133
2134       if (r_symndx < symtab_hdr->sh_info)
2135         {
2136           sym = local_syms + r_symndx;
2137           sec = local_sections[r_symndx];
2138           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2139         }
2140       else
2141         {
2142           bfd_boolean warned;
2143
2144           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2145                                    r_symndx, symtab_hdr, sym_hashes,
2146                                    h, sec, relocation,
2147                                    unresolved_reloc, warned);
2148         }
2149
2150       if (sec != NULL && elf_discarded_section (sec))
2151         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2152                                          rel, relend, howto, contents);
2153
2154       if (info->relocatable)
2155         {
2156           if (is_rel
2157               && sym != NULL
2158               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2159             {
2160               rel->r_addend = 0;
2161               relocation = sec->output_offset + sym->st_value;
2162               r = _bfd_relocate_contents (howto, input_bfd, relocation,
2163                                           contents + rel->r_offset);
2164               goto done_reloc;
2165             }
2166           continue;
2167         }
2168
2169       switch (r_type)
2170         {
2171         case R_C6000_NONE:
2172         case R_C6000_ALIGN:
2173         case R_C6000_FPHEAD:
2174         case R_C6000_NOCMP:
2175           /* No action needed.  */
2176           continue;
2177
2178         case R_C6000_PCR_S21:
2179           /* A branch to an undefined weak symbol is turned into a
2180              "b .s2 B3" instruction if the existing insn is of the
2181              form "b .s2 symbol".  */
2182           if (h ? h->root.type == bfd_link_hash_undefweak
2183               && (htab->elf.splt == NULL || h->plt.offset == (bfd_vma) -1)
2184               : r_symndx != STN_UNDEF && bfd_is_und_section (sec))
2185             {
2186               unsigned long oldval;
2187               oldval = bfd_get_32 (input_bfd, contents + rel->r_offset);
2188
2189               if ((oldval & 0x7e) == 0x12)
2190                 {
2191                   oldval &= 0xF0000001;
2192                   bfd_put_32 (input_bfd, oldval | 0x000c0362,
2193                               contents + rel->r_offset);
2194                   r = bfd_reloc_ok;
2195                   goto done_reloc;
2196                 }
2197             }
2198
2199         case R_C6000_PCR_S12:
2200         case R_C6000_PCR_S10:
2201         case R_C6000_PCR_S7:
2202           if (h != NULL
2203               && h->plt.offset != (bfd_vma) -1
2204               && htab->elf.splt != NULL)
2205             {
2206               relocation = (htab->elf.splt->output_section->vma
2207                             + htab->elf.splt->output_offset
2208                             + h->plt.offset);
2209             }
2210
2211           /* Generic PC-relative handling produces a value relative to
2212              the exact location of the relocation.  Adjust it to be
2213              relative to the start of the fetch packet instead.  */
2214           relocation += (input_section->output_section->vma
2215                          + input_section->output_offset
2216                          + rel->r_offset) & 0x1f;
2217           unresolved_reloc = FALSE;
2218           break;
2219
2220         case R_C6000_DSBT_INDEX:
2221           relocation = elf32_tic6x_hash_table (info)->params.dsbt_index;
2222           if (!info->shared || relocation != 0)
2223             break;
2224
2225           /* fall through */
2226         case R_C6000_ABS32:
2227         case R_C6000_ABS16:
2228         case R_C6000_ABS8:
2229         case R_C6000_ABS_S16:
2230         case R_C6000_ABS_L16:
2231         case R_C6000_ABS_H16:
2232           /* When generating a shared object or relocatable executable, these
2233              relocations are copied into the output file to be resolved at
2234              run time.  */
2235           if ((info->shared || elf32_tic6x_using_dsbt (output_bfd))
2236               && (input_section->flags & SEC_ALLOC)
2237               && (h == NULL
2238                   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2239                   || h->root.type != bfd_link_hash_undefweak))
2240             {
2241               Elf_Internal_Rela outrel;
2242               bfd_boolean skip, relocate;
2243               asection *sreloc;
2244
2245               unresolved_reloc = FALSE;
2246
2247               sreloc = elf_section_data (input_section)->sreloc;
2248               BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL);
2249
2250               skip = FALSE;
2251               relocate = FALSE;
2252
2253               outrel.r_offset =
2254                 _bfd_elf_section_offset (output_bfd, info, input_section,
2255                                          rel->r_offset);
2256               if (outrel.r_offset == (bfd_vma) -1)
2257                 skip = TRUE;
2258               else if (outrel.r_offset == (bfd_vma) -2)
2259                 skip = TRUE, relocate = TRUE;
2260               outrel.r_offset += (input_section->output_section->vma
2261                                   + input_section->output_offset);
2262
2263               if (skip)
2264                 memset (&outrel, 0, sizeof outrel);
2265               else if (h != NULL
2266                        && h->dynindx != -1
2267                        && (!info->shared
2268                            || !info->symbolic
2269                            || !h->def_regular))
2270                 {
2271                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2272                   outrel.r_addend = rel->r_addend;
2273                 }
2274               else
2275                 {
2276                   long indx;
2277
2278                   outrel.r_addend = relocation + rel->r_addend;
2279
2280                   if (bfd_is_abs_section (sec))
2281                     indx = 0;
2282                   else if (sec == NULL || sec->owner == NULL)
2283                     {
2284                       bfd_set_error (bfd_error_bad_value);
2285                       return FALSE;
2286                     }
2287                   else
2288                     {
2289                       asection *osec;
2290
2291                       osec = sec->output_section;
2292                       indx = elf_section_data (osec)->dynindx;
2293                       outrel.r_addend -= osec->vma;
2294                       BFD_ASSERT (indx != 0);
2295                     }
2296
2297                   outrel.r_info = ELF32_R_INFO (indx, r_type);
2298                 }
2299
2300               elf32_tic6x_install_rela (output_bfd, sreloc, &outrel);
2301
2302               /* If this reloc is against an external symbol, we do not want to
2303                  fiddle with the addend.  Otherwise, we need to include the symbol
2304                  value so that it becomes an addend for the dynamic reloc.  */
2305               if (! relocate)
2306                 continue;
2307             }
2308
2309           /* Generic logic OK.  */
2310           break;
2311
2312         case R_C6000_SBR_U15_B:
2313         case R_C6000_SBR_U15_H:
2314         case R_C6000_SBR_U15_W:
2315         case R_C6000_SBR_S16:
2316         case R_C6000_SBR_L16_B:
2317         case R_C6000_SBR_L16_H:
2318         case R_C6000_SBR_L16_W:
2319         case R_C6000_SBR_H16_B:
2320         case R_C6000_SBR_H16_H:
2321         case R_C6000_SBR_H16_W:
2322           sbh = bfd_link_hash_lookup (info->hash, "__c6xabi_DSBT_BASE",
2323                                       FALSE, FALSE, TRUE);
2324           if (sbh != NULL
2325               && (sbh->type == bfd_link_hash_defined
2326                   || sbh->type == bfd_link_hash_defweak))
2327             {
2328               if (h ? (h->root.type == bfd_link_hash_undefweak
2329                        && (htab->elf.splt == NULL
2330                            || h->plt.offset == (bfd_vma) -1))
2331                   : r_symndx != STN_UNDEF && bfd_is_und_section (sec))
2332                 relocation = 0;
2333               else
2334                 relocation -= (sbh->u.def.value
2335                                + sbh->u.def.section->output_section->vma
2336                                + sbh->u.def.section->output_offset);
2337             }
2338           else
2339             {
2340               (*_bfd_error_handler) (_("%B: SB-relative relocation but "
2341                                        "__c6xabi_DSBT_BASE not defined"),
2342                                      input_bfd);
2343               ok = FALSE;
2344               continue;
2345             }
2346           break;
2347
2348         case R_C6000_SBR_GOT_U15_W:
2349         case R_C6000_SBR_GOT_L16_W:
2350         case R_C6000_SBR_GOT_H16_W:
2351         case R_C6000_EHTYPE:
2352           /* Relocation is to the entry for this symbol in the global
2353              offset table.  */
2354           if (htab->elf.sgot == NULL)
2355             abort ();
2356
2357           if (h != NULL)
2358             {
2359               bfd_boolean dyn;
2360
2361               off = h->got.offset;
2362               dyn = htab->elf.dynamic_sections_created;
2363               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2364                   || (info->shared
2365                       && SYMBOL_REFERENCES_LOCAL (info, h))
2366                   || (ELF_ST_VISIBILITY (h->other)
2367                       && h->root.type == bfd_link_hash_undefweak))
2368                 {
2369                   /* This is actually a static link, or it is a
2370                      -Bsymbolic link and the symbol is defined
2371                      locally, or the symbol was forced to be local
2372                      because of a version file.  We must initialize
2373                      this entry in the global offset table.  Since the
2374                      offset must always be a multiple of 4, we use the
2375                      least significant bit to record whether we have
2376                      initialized it already.
2377
2378                      When doing a dynamic link, we create a .rel.got
2379                      relocation entry to initialize the value.  This
2380                      is done in the finish_dynamic_symbol routine.  */
2381                   if ((off & 1) != 0)
2382                     off &= ~1;
2383                   else
2384                     {
2385                       bfd_put_32 (output_bfd, relocation,
2386                                   htab->elf.sgot->contents + off);
2387                       h->got.offset |= 1;
2388
2389                       if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
2390                                                             h)
2391                           && !(ELF_ST_VISIBILITY (h->other)
2392                                && h->root.type == bfd_link_hash_undefweak))
2393                         elf32_tic6x_make_got_dynreloc (output_bfd, htab, sec,
2394                                                        off);
2395                     }
2396                 }
2397               else
2398                 unresolved_reloc = FALSE;
2399             }
2400           else
2401             {
2402               if (local_got_offsets == NULL)
2403                 abort ();
2404
2405               off = local_got_offsets[r_symndx];
2406
2407               /* The offset must always be a multiple of 4.  We use
2408                  the least significant bit to record whether we have
2409                  already generated the necessary reloc.  */
2410               if ((off & 1) != 0)
2411                 off &= ~1;
2412               else
2413                 {
2414                   bfd_put_32 (output_bfd, relocation,
2415                               htab->elf.sgot->contents + off);
2416
2417                   if (info->shared || elf32_tic6x_using_dsbt (output_bfd))
2418                     elf32_tic6x_make_got_dynreloc (output_bfd, htab, sec, off);
2419
2420                   local_got_offsets[r_symndx] |= 1;
2421                 }
2422             }
2423
2424           if (off >= (bfd_vma) -2)
2425             abort ();
2426
2427           if (htab->dsbt)
2428             relocation = (htab->elf.sgot->output_section->vma
2429                           + htab->elf.sgot->output_offset + off
2430                           - htab->dsbt->output_section->vma
2431                           - htab->dsbt->output_offset);
2432           else
2433             relocation = (htab->elf.sgot->output_section->vma
2434                           + htab->elf.sgot->output_offset + off
2435                           - htab->elf.sgotplt->output_section->vma
2436                           - htab->elf.sgotplt->output_offset);
2437
2438           if (rel->r_addend != 0)
2439             {
2440               /* We can't do anything for a relocation which is against
2441                  a symbol *plus offset*.  GOT holds relocations for
2442                  symbols.  Make this an error; the compiler isn't
2443                  allowed to pass us these kinds of things.  */
2444               if (h == NULL)
2445                 (*_bfd_error_handler)
2446                   (_("%B, section %A: relocation %s with non-zero addend %d"
2447                      " against local symbol"),
2448                    input_bfd,
2449                    input_section,
2450                    elf32_tic6x_howto_table[r_type].name,
2451                    rel->r_addend);
2452               else
2453                 (*_bfd_error_handler)
2454                   (_("%B, section %A: relocation %s with non-zero addend %d"
2455                      " against symbol `%s'"),
2456                    input_bfd,
2457                    input_section,
2458                    elf32_tic6x_howto_table[r_type].name,
2459                    rel->r_addend,
2460                    h->root.root.string[0] != '\0' ? h->root.root.string
2461                    : _("[whose name is lost]"));
2462
2463               bfd_set_error (bfd_error_bad_value);
2464               return FALSE;
2465             }
2466           break;
2467
2468         case R_C6000_PREL31:
2469           if (h != NULL
2470               && h->plt.offset != (bfd_vma) -1
2471               && htab->elf.splt != NULL)
2472             {
2473               relocation = (htab->elf.splt->output_section->vma
2474                             + htab->elf.splt->output_offset
2475                             + h->plt.offset);
2476             }
2477           break;
2478
2479         case R_C6000_COPY:
2480           /* Invalid in relocatable object.  */
2481         default:
2482           /* Unknown relocation.  */
2483           (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2484                                  input_bfd, r_type);
2485           ok = FALSE;
2486           continue;
2487         }
2488
2489       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2490                                     contents, rel->r_offset,
2491                                     relocation, rel->r_addend);
2492
2493     done_reloc:
2494       if (r == bfd_reloc_ok
2495           && howto->complain_on_overflow == complain_overflow_bitfield)
2496         {
2497           /* Generic overflow handling accepts cases the ABI says
2498              should be rejected for R_C6000_ABS16 and
2499              R_C6000_ABS8.  */
2500           bfd_vma value = (relocation + rel->r_addend) & 0xffffffff;
2501           bfd_vma sbit = 1 << (howto->bitsize - 1);
2502           bfd_vma sbits = (-(bfd_vma) sbit) & 0xffffffff;
2503           bfd_vma value_sbits = value & sbits;
2504
2505           if (value_sbits != 0
2506               && value_sbits != sbit
2507               && value_sbits != sbits)
2508             r = bfd_reloc_overflow;
2509         }
2510
2511       if (r != bfd_reloc_ok)
2512         {
2513           const char *name;
2514           const char *error_message;
2515
2516           if (h != NULL)
2517             name = h->root.root.string;
2518           else
2519             {
2520               name = bfd_elf_string_from_elf_section (input_bfd,
2521                                                       symtab_hdr->sh_link,
2522                                                       sym->st_name);
2523               if (name == NULL)
2524                 return FALSE;
2525               if (*name == '\0')
2526                 name = bfd_section_name (input_bfd, sec);
2527             }
2528
2529           switch (r)
2530             {
2531             case bfd_reloc_overflow:
2532               /* If the overflowing reloc was to an undefined symbol,
2533                  we have already printed one error message and there
2534                  is no point complaining again.  */
2535               if ((! h ||
2536                    h->root.type != bfd_link_hash_undefined)
2537                   && (!((*info->callbacks->reloc_overflow)
2538                         (info, (h ? &h->root : NULL), name, howto->name,
2539                          (bfd_vma) 0, input_bfd, input_section,
2540                          rel->r_offset))))
2541                   return FALSE;
2542               break;
2543
2544             case bfd_reloc_undefined:
2545               if (!((*info->callbacks->undefined_symbol)
2546                     (info, name, input_bfd, input_section,
2547                      rel->r_offset, TRUE)))
2548                 return FALSE;
2549               break;
2550
2551             case bfd_reloc_outofrange:
2552               error_message = _("out of range");
2553               goto common_error;
2554
2555             case bfd_reloc_notsupported:
2556               error_message = _("unsupported relocation");
2557               goto common_error;
2558
2559             case bfd_reloc_dangerous:
2560               error_message = _("dangerous relocation");
2561               goto common_error;
2562
2563             default:
2564               error_message = _("unknown error");
2565               /* Fall through.  */
2566
2567             common_error:
2568               BFD_ASSERT (error_message != NULL);
2569               if (!((*info->callbacks->reloc_dangerous)
2570                     (info, error_message, input_bfd, input_section,
2571                      rel->r_offset)))
2572                 return FALSE;
2573               break;
2574             }
2575         }
2576     }
2577
2578   return ok;
2579 }
2580
2581 \f
2582 /* Look through the relocs for a section during the first phase, and
2583    calculate needed space in the global offset table, procedure linkage
2584    table, and dynamic reloc sections.  */
2585
2586 static bfd_boolean
2587 elf32_tic6x_check_relocs (bfd *abfd, struct bfd_link_info *info,
2588                           asection *sec, const Elf_Internal_Rela *relocs)
2589 {
2590   struct elf32_tic6x_link_hash_table *htab;
2591   Elf_Internal_Shdr *symtab_hdr;
2592   struct elf_link_hash_entry **sym_hashes;
2593   const Elf_Internal_Rela *rel;
2594   const Elf_Internal_Rela *rel_end;
2595   asection *sreloc;
2596
2597   if (info->relocatable)
2598     return TRUE;
2599
2600   htab = elf32_tic6x_hash_table (info);
2601   symtab_hdr = &elf_symtab_hdr (abfd);
2602   sym_hashes = elf_sym_hashes (abfd);
2603
2604   /* Create dynamic sections for relocatable executables so that we can
2605      copy relocations.  */
2606   if (elf32_tic6x_using_dsbt (abfd)
2607       && ! htab->elf.dynamic_sections_created)
2608     {
2609       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
2610         return FALSE;
2611     }
2612
2613   sreloc = NULL;
2614
2615   rel_end = relocs + sec->reloc_count;
2616   for (rel = relocs; rel < rel_end; rel++)
2617     {
2618       unsigned int r_type;
2619       unsigned long r_symndx;
2620       struct elf_link_hash_entry *h;
2621       Elf_Internal_Sym *isym;
2622
2623       r_symndx = ELF32_R_SYM (rel->r_info);
2624       r_type = ELF32_R_TYPE (rel->r_info);
2625
2626       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
2627         {
2628           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
2629                                  abfd,
2630                                  r_symndx);
2631           return FALSE;
2632         }
2633
2634       if (r_symndx < symtab_hdr->sh_info)
2635         {
2636           /* A local symbol.  */
2637           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2638                                         abfd, r_symndx);
2639           if (isym == NULL)
2640             return FALSE;
2641           h = NULL;
2642         }
2643       else
2644         {
2645           isym = NULL;
2646           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2647           while (h->root.type == bfd_link_hash_indirect
2648                  || h->root.type == bfd_link_hash_warning)
2649             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2650         }
2651
2652       switch (r_type)
2653         {
2654         case R_C6000_PCR_S21:
2655         case R_C6000_PREL31:
2656           /* This symbol requires a procedure linkage table entry.  We
2657              actually build the entry in adjust_dynamic_symbol,
2658              because this might be a case of linking PIC code which is
2659              never referenced by a dynamic object, in which case we
2660              don't need to generate a procedure linkage table entry
2661              after all.  */
2662
2663           /* If this is a local symbol, we resolve it directly without
2664              creating a procedure linkage table entry.  */
2665           if (h == NULL)
2666             continue;
2667
2668           h->needs_plt = 1;
2669           h->plt.refcount += 1;
2670           break;
2671
2672         case R_C6000_SBR_GOT_U15_W:
2673         case R_C6000_SBR_GOT_L16_W:
2674         case R_C6000_SBR_GOT_H16_W:
2675         case R_C6000_EHTYPE:
2676           /* This symbol requires a global offset table entry.  */
2677           if (h != NULL)
2678             {
2679               h->got.refcount += 1;
2680             }
2681           else
2682             {
2683               bfd_signed_vma *local_got_refcounts;
2684
2685               /* This is a global offset table entry for a local symbol.  */
2686               local_got_refcounts = elf_local_got_refcounts (abfd);
2687               if (local_got_refcounts == NULL)
2688                 {
2689                   bfd_size_type size;
2690
2691                   size = symtab_hdr->sh_info;
2692                   size *= (sizeof (bfd_signed_vma)
2693                            + sizeof (bfd_vma) + sizeof(char));
2694                   local_got_refcounts = bfd_zalloc (abfd, size);
2695                   if (local_got_refcounts == NULL)
2696                     return FALSE;
2697                   elf_local_got_refcounts (abfd) = local_got_refcounts;
2698                 }
2699               local_got_refcounts[r_symndx] += 1;
2700             }
2701
2702           if (htab->elf.sgot == NULL)
2703             {
2704               if (htab->elf.dynobj == NULL)
2705                 htab->elf.dynobj = abfd;
2706               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2707                 return FALSE;
2708             }
2709           break;
2710
2711         case R_C6000_DSBT_INDEX:
2712           /* We'd like to check for nonzero dsbt_index here, but it's
2713              set up only after check_relocs is called.  Instead, we
2714              store the number of R_C6000_DSBT_INDEX relocs in the
2715              pc_count field, and potentially discard the extra space
2716              in elf32_tic6x_allocate_dynrelocs.  */
2717           if (!info->shared)
2718             break;
2719
2720           /* fall through */
2721         case R_C6000_ABS32:
2722         case R_C6000_ABS16:
2723         case R_C6000_ABS8:
2724         case R_C6000_ABS_S16:
2725         case R_C6000_ABS_L16:
2726         case R_C6000_ABS_H16:
2727           /* If we are creating a shared library, and this is a reloc
2728              against a global symbol, or a non PC relative reloc
2729              against a local symbol, then we need to copy the reloc
2730              into the shared library.  However, if we are linking with
2731              -Bsymbolic, we do not need to copy a reloc against a
2732              global symbol which is defined in an object we are
2733              including in the link (i.e., DEF_REGULAR is set).  At
2734              this point we have not seen all the input files, so it is
2735              possible that DEF_REGULAR is not set now but will be set
2736              later (it is never cleared).  In case of a weak definition,
2737              DEF_REGULAR may be cleared later by a strong definition in
2738              a shared library.  We account for that possibility below by
2739              storing information in the relocs_copied field of the hash
2740              table entry.  A similar situation occurs when creating
2741              shared libraries and symbol visibility changes render the
2742              symbol local.
2743
2744              If on the other hand, we are creating an executable, we
2745              may need to keep relocations for symbols satisfied by a
2746              dynamic library if we manage to avoid copy relocs for the
2747              symbol.  */
2748           if ((info->shared || elf32_tic6x_using_dsbt (abfd))
2749               && (sec->flags & SEC_ALLOC) != 0)
2750             {
2751               struct elf_dyn_relocs *p;
2752               struct elf_dyn_relocs **head;
2753
2754               /* We must copy these reloc types into the output file.
2755                  Create a reloc section in dynobj and make room for
2756                  this reloc.  */
2757               if (sreloc == NULL)
2758                 {
2759                   if (htab->elf.dynobj == NULL)
2760                     htab->elf.dynobj = abfd;
2761
2762                   sreloc = _bfd_elf_make_dynamic_reloc_section
2763                     (sec, htab->elf.dynobj, 2, abfd, /*rela? */ TRUE);
2764
2765                   if (sreloc == NULL)
2766                     return FALSE;
2767                 }
2768
2769               /* If this is a global symbol, we count the number of
2770                  relocations we need for this symbol.  */
2771               if (h != NULL)
2772                 {
2773                   head = &((struct elf32_tic6x_link_hash_entry *) h)->dyn_relocs;
2774                 }
2775               else
2776                 {
2777                   /* Track dynamic relocs needed for local syms too.
2778                      We really need local syms available to do this
2779                      easily.  Oh well.  */
2780                   void **vpp;
2781                   asection *s;
2782
2783                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2784                   if (s == NULL)
2785                     s = sec;
2786
2787                   vpp = &elf_section_data (s)->local_dynrel;
2788                   head = (struct elf_dyn_relocs **)vpp;
2789                 }
2790
2791               p = *head;
2792               if (p == NULL || p->sec != sec)
2793                 {
2794                   bfd_size_type amt = sizeof *p;
2795                   p = bfd_alloc (htab->elf.dynobj, amt);
2796                   if (p == NULL)
2797                     return FALSE;
2798                   p->next = *head;
2799                   *head = p;
2800                   p->sec = sec;
2801                   p->count = 0;
2802                   p->pc_count = 0;
2803                 }
2804
2805               p->count += 1;
2806               if (r_type == R_C6000_DSBT_INDEX)
2807                 p->pc_count += 1;
2808             }
2809           break;
2810
2811         case R_C6000_SBR_U15_B:
2812         case R_C6000_SBR_U15_H:
2813         case R_C6000_SBR_U15_W:
2814         case R_C6000_SBR_S16:
2815         case R_C6000_SBR_L16_B:
2816         case R_C6000_SBR_L16_H:
2817         case R_C6000_SBR_L16_W:
2818         case R_C6000_SBR_H16_B:
2819         case R_C6000_SBR_H16_H:
2820         case R_C6000_SBR_H16_W:
2821           if (h != NULL && info->executable)
2822             {
2823               /* For B14-relative addresses, we might need a copy
2824                  reloc.  */
2825               h->non_got_ref = 1;
2826             }
2827           break;
2828
2829         default:
2830           break;
2831         }
2832     }
2833
2834   return TRUE;
2835 }
2836
2837 static bfd_boolean
2838 elf32_tic6x_add_symbol_hook (bfd *abfd,
2839                              struct bfd_link_info *info ATTRIBUTE_UNUSED,
2840                              Elf_Internal_Sym *sym,
2841                              const char **namep ATTRIBUTE_UNUSED,
2842                              flagword *flagsp ATTRIBUTE_UNUSED,
2843                              asection **secp,
2844                              bfd_vma *valp)
2845 {
2846   switch (sym->st_shndx)
2847     {
2848     case SHN_TIC6X_SCOMMON:
2849       *secp = bfd_make_section_old_way (abfd, ".scommon");
2850       (*secp)->flags |= SEC_IS_COMMON;
2851       *valp = sym->st_size;
2852       bfd_set_section_alignment (abfd, *secp, bfd_log2 (sym->st_value));
2853       break;
2854     }
2855
2856   return TRUE;
2857 }
2858
2859 static void
2860 elf32_tic6x_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
2861 {
2862   elf_symbol_type *elfsym;
2863
2864   elfsym = (elf_symbol_type *) asym;
2865   switch (elfsym->internal_elf_sym.st_shndx)
2866     {
2867     case SHN_TIC6X_SCOMMON:
2868       if (tic6x_elf_scom_section.name == NULL)
2869         {
2870           /* Initialize the small common section.  */
2871           tic6x_elf_scom_section.name = ".scommon";
2872           tic6x_elf_scom_section.flags = SEC_IS_COMMON;
2873           tic6x_elf_scom_section.output_section = &tic6x_elf_scom_section;
2874           tic6x_elf_scom_section.symbol = &tic6x_elf_scom_symbol;
2875           tic6x_elf_scom_section.symbol_ptr_ptr = &tic6x_elf_scom_symbol_ptr;
2876           tic6x_elf_scom_symbol.name = ".scommon";
2877           tic6x_elf_scom_symbol.flags = BSF_SECTION_SYM;
2878           tic6x_elf_scom_symbol.section = &tic6x_elf_scom_section;
2879           tic6x_elf_scom_symbol_ptr = &tic6x_elf_scom_symbol;
2880         }
2881       asym->section = &tic6x_elf_scom_section;
2882       asym->value = elfsym->internal_elf_sym.st_size;
2883       break;
2884     }
2885 }
2886
2887 static int
2888 elf32_tic6x_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2889                                      const char *name ATTRIBUTE_UNUSED,
2890                                      Elf_Internal_Sym *sym,
2891                                      asection *input_sec,
2892                                      struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2893 {
2894   /* If we see a common symbol, which implies a relocatable link, then
2895      if a symbol was small common in an input file, mark it as small
2896      common in the output file.  */
2897   if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0)
2898     sym->st_shndx = SHN_TIC6X_SCOMMON;
2899
2900   return 1;
2901 }
2902
2903 static bfd_boolean
2904 elf32_tic6x_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
2905                                       asection *sec,
2906                                       int *retval)
2907 {
2908   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
2909     {
2910       *retval = SHN_TIC6X_SCOMMON;
2911       return TRUE;
2912     }
2913
2914   return FALSE;
2915 }
2916
2917 /* Allocate space in .plt, .got and associated reloc sections for
2918    dynamic relocs.  */
2919
2920 static bfd_boolean
2921 elf32_tic6x_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2922 {
2923   struct bfd_link_info *info;
2924   struct elf32_tic6x_link_hash_table *htab;
2925   struct elf32_tic6x_link_hash_entry *eh;
2926   struct elf_dyn_relocs *p;
2927
2928   if (h->root.type == bfd_link_hash_indirect)
2929     return TRUE;
2930
2931   if (h->root.type == bfd_link_hash_warning)
2932     /* When warning symbols are created, they **replace** the "real"
2933        entry in the hash table, thus we never get to see the real
2934        symbol in a hash traversal.  So look at it now.  */
2935     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2936   eh = (struct elf32_tic6x_link_hash_entry *) h;
2937
2938   info = (struct bfd_link_info *) inf;
2939   htab = elf32_tic6x_hash_table (info);
2940
2941   if (htab->elf.dynamic_sections_created && h->plt.refcount > 0)
2942     {
2943       /* Make sure this symbol is output as a dynamic symbol.
2944          Undefined weak syms won't yet be marked as dynamic.  */
2945       if (h->dynindx == -1 && !h->forced_local)
2946         {
2947           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2948             return FALSE;
2949         }
2950
2951       if (info->shared
2952           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2953         {
2954           asection *s = htab->elf.splt;
2955
2956           /* If this is the first .plt entry, make room for the special
2957              first entry.  */
2958           if (s->size == 0)
2959             s->size += PLT_ENTRY_SIZE;
2960
2961           h->plt.offset = s->size;
2962
2963           /* If this symbol is not defined in a regular file, and we are
2964              not generating a shared library, then set the symbol to this
2965              location in the .plt.  This is required to make function
2966              pointers compare as equal between the normal executable and
2967              the shared library.  */
2968           if (! info->shared && !h->def_regular)
2969             {
2970               h->root.u.def.section = s;
2971               h->root.u.def.value = h->plt.offset;
2972             }
2973
2974           /* Make room for this entry.  */
2975           s->size += PLT_ENTRY_SIZE;
2976           /* We also need to make an entry in the .got.plt section, which
2977              will be placed in the .got section by the linker script.  */
2978           htab->elf.sgotplt->size += 4;
2979           /* We also need to make an entry in the .rel.plt section.  */
2980           htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
2981         }
2982       else
2983         {
2984           h->plt.offset = (bfd_vma) -1;
2985           h->needs_plt = 0;
2986         }
2987     }
2988   else
2989     {
2990       h->plt.offset = (bfd_vma) -1;
2991       h->needs_plt = 0;
2992     }
2993
2994   if (h->got.refcount > 0)
2995     {
2996       asection *s;
2997
2998       /* Make sure this symbol is output as a dynamic symbol.
2999          Undefined weak syms won't yet be marked as dynamic.  */
3000       if (h->dynindx == -1
3001           && !h->forced_local)
3002         {
3003           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3004             return FALSE;
3005         }
3006
3007       s = htab->elf.sgot;
3008       h->got.offset = s->size;
3009       s->size += 4;
3010
3011       if (!(ELF_ST_VISIBILITY (h->other)
3012             && h->root.type == bfd_link_hash_undefweak))
3013         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
3014     }
3015   else
3016     h->got.offset = (bfd_vma) -1;
3017
3018   if (eh->dyn_relocs == NULL)
3019     return TRUE;
3020
3021   /* Discard relocs on undefined weak syms with non-default
3022      visibility.  */
3023   if (info->shared || elf32_tic6x_using_dsbt (htab->obfd))
3024     {
3025       /* We use the pc_count field to hold the number of
3026          R_C6000_DSBT_INDEX relocs.  */
3027       if (htab->params.dsbt_index != 0)
3028         {
3029           struct elf_dyn_relocs **pp;
3030
3031           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3032             {
3033               p->count -= p->pc_count;
3034               p->pc_count = 0;
3035               if (p->count == 0)
3036                 *pp = p->next;
3037               else
3038                 pp = &p->next;
3039             }
3040         }
3041
3042       if (eh->dyn_relocs != NULL
3043           && h->root.type == bfd_link_hash_undefweak)
3044         {
3045           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3046             eh->dyn_relocs = NULL;
3047
3048           /* Make sure undefined weak symbols are output as a dynamic
3049              symbol in PIEs.  */
3050           else if (h->dynindx == -1
3051                    && !h->forced_local)
3052             {
3053               if (! bfd_elf_link_record_dynamic_symbol (info, h))
3054                 return FALSE;
3055             }
3056         }
3057     }
3058
3059   /* Finally, allocate space.  */
3060   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3061     {
3062       asection *sreloc;
3063
3064       sreloc = elf_section_data (p->sec)->sreloc;
3065
3066       BFD_ASSERT (sreloc != NULL);
3067       sreloc->size += p->count * sizeof (Elf32_External_Rela);
3068     }
3069
3070   return TRUE;
3071 }
3072
3073 /* Find any dynamic relocs that apply to read-only sections.  */
3074
3075 static bfd_boolean
3076 elf32_tic6x_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3077 {
3078   struct elf32_tic6x_link_hash_entry *eh;
3079   struct elf_dyn_relocs *p;
3080
3081   if (h->root.type == bfd_link_hash_warning)
3082     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3083
3084   eh = (struct elf32_tic6x_link_hash_entry *) h;
3085   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3086     {
3087       asection *s = p->sec->output_section;
3088
3089       if (s != NULL && (s->flags & SEC_READONLY) != 0)
3090         {
3091           struct bfd_link_info *info = (struct bfd_link_info *) inf;
3092
3093           info->flags |= DF_TEXTREL;
3094
3095           /* Not an error, just cut short the traversal.  */
3096           return FALSE;
3097         }
3098     }
3099   return TRUE;
3100 }
3101
3102 /* Set the sizes of the dynamic sections.  */
3103
3104 static bfd_boolean
3105 elf32_tic6x_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3106 {
3107   struct elf32_tic6x_link_hash_table *htab;
3108   bfd *dynobj;
3109   asection *s;
3110   bfd_boolean relocs;
3111   bfd *ibfd;
3112
3113   htab = elf32_tic6x_hash_table (info);
3114   dynobj = htab->elf.dynobj;
3115   if (dynobj == NULL)
3116     abort ();
3117
3118   if (htab->elf.dynamic_sections_created)
3119     {
3120       /* Set the contents of the .interp section to the interpreter.  */
3121       if (info->executable)
3122         {
3123           s = bfd_get_section_by_name (dynobj, ".interp");
3124           if (s == NULL)
3125             abort ();
3126           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3127           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3128         }
3129     }
3130
3131   /* Set up .got offsets for local syms, and space for local dynamic
3132      relocs.  */
3133   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3134     {
3135       bfd_signed_vma *local_got;
3136       bfd_signed_vma *end_local_got;
3137       char *local_tls_type;
3138       bfd_vma *local_tlsdesc_gotent;
3139       bfd_size_type locsymcount;
3140       Elf_Internal_Shdr *symtab_hdr;
3141       asection *srel;
3142
3143       for (s = ibfd->sections; s != NULL; s = s->next)
3144         {
3145           struct elf_dyn_relocs *p;
3146
3147           for (p = ((struct elf_dyn_relocs *)
3148                      elf_section_data (s)->local_dynrel);
3149                p != NULL;
3150                p = p->next)
3151             {
3152               if (!bfd_is_abs_section (p->sec)
3153                   && bfd_is_abs_section (p->sec->output_section))
3154                 {
3155                   /* Input section has been discarded, either because
3156                      it is a copy of a linkonce section or due to
3157                      linker script /DISCARD/, so we'll be discarding
3158                      the relocs too.  */
3159                 }
3160               else if (p->count != 0)
3161                 {
3162                   srel = elf_section_data (p->sec)->sreloc;
3163                   srel->size += p->count * sizeof (Elf32_External_Rela);
3164                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3165                     info->flags |= DF_TEXTREL;
3166                 }
3167             }
3168         }
3169
3170       local_got = elf_local_got_refcounts (ibfd);
3171       if (!local_got)
3172         continue;
3173
3174       symtab_hdr = &elf_symtab_hdr (ibfd);
3175       locsymcount = symtab_hdr->sh_info;
3176       end_local_got = local_got + locsymcount;
3177       s = htab->elf.sgot;
3178       srel = htab->elf.srelgot;
3179       for (; local_got < end_local_got;
3180            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3181         {
3182           if (*local_got > 0)
3183             {
3184               *local_got = s->size;
3185               s->size += 4;
3186
3187               if (info->shared || elf32_tic6x_using_dsbt (output_bfd))
3188                 {
3189                   srel->size += sizeof (Elf32_External_Rela);
3190                 }
3191             }
3192           else
3193             *local_got = (bfd_vma) -1;
3194         }
3195     }
3196
3197   /* Allocate global sym .plt and .got entries, and space for global
3198      sym dynamic relocs.  */
3199   elf_link_hash_traverse (&htab->elf, elf32_tic6x_allocate_dynrelocs, info);
3200
3201   /* We now have determined the sizes of the various dynamic sections.
3202      Allocate memory for them.  */
3203   relocs = FALSE;
3204   for (s = dynobj->sections; s != NULL; s = s->next)
3205     {
3206       bfd_boolean strip_section = TRUE;
3207
3208       if ((s->flags & SEC_LINKER_CREATED) == 0)
3209         continue;
3210
3211       if (s == htab->dsbt)
3212         s->size = 4 * htab->params.dsbt_size;
3213       else if (s == htab->elf.splt
3214                || s == htab->elf.sgot
3215                || s == htab->elf.sgotplt
3216                || s == htab->sdynbss)
3217         {
3218           /* Strip this section if we don't need it; see the
3219              comment below.  */
3220           /* We'd like to strip these sections if they aren't needed, but if
3221              we've exported dynamic symbols from them we must leave them.
3222              It's too late to tell BFD to get rid of the symbols.  */
3223
3224           if (htab->elf.hplt != NULL)
3225             strip_section = FALSE;
3226
3227           /* Round up the size of the PLT section to a multiple of 32.  */
3228           if (s == htab->elf.splt && s->size > 0)
3229             s->size = (s->size + 31) & ~(bfd_vma)31;
3230         }
3231       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3232         {
3233           if (s->size != 0
3234               && s != htab->elf.srelplt)
3235             relocs = TRUE;
3236
3237           /* We use the reloc_count field as a counter if we need
3238              to copy relocs into the output file.  */
3239           s->reloc_count = 0;
3240         }
3241       else
3242         {
3243           /* It's not one of our sections, so don't allocate space.  */
3244           continue;
3245         }
3246
3247       if (s->size == 0)
3248         {
3249           /* If we don't need this section, strip it from the
3250              output file.  This is mostly to handle .rel.bss and
3251              .rel.plt.  We must create both sections in
3252              create_dynamic_sections, because they must be created
3253              before the linker maps input sections to output
3254              sections.  The linker does that before
3255              adjust_dynamic_symbol is called, and it is that
3256              function which decides whether anything needs to go
3257              into these sections.  */
3258           if (strip_section)
3259             s->flags |= SEC_EXCLUDE;
3260           continue;
3261         }
3262
3263       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3264         continue;
3265
3266       /* Allocate memory for the section contents.  We use bfd_zalloc
3267          here in case unused entries are not reclaimed before the
3268          section's contents are written out.  This should not happen,
3269          but this way if it does, we get a R_C6000_NONE reloc instead
3270          of garbage.  */
3271       s->contents = bfd_zalloc (dynobj, s->size);
3272       if (s->contents == NULL)
3273         return FALSE;
3274     }
3275
3276   if (htab->elf.dynamic_sections_created)
3277     {
3278       /* Add some entries to the .dynamic section.  We fill in the
3279          values later, in elf32_tic6x_finish_dynamic_sections, but we
3280          must add the entries now so that we get the correct size for
3281          the .dynamic section.  The DT_DEBUG entry is filled in by the
3282          dynamic linker and used by the debugger.  */
3283 #define add_dynamic_entry(TAG, VAL) \
3284   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3285
3286       if (info->executable)
3287         {
3288           if (!add_dynamic_entry (DT_DEBUG, 0))
3289             return FALSE;
3290         }
3291
3292       if (!add_dynamic_entry (DT_C6000_DSBT_BASE, 0)
3293           || !add_dynamic_entry (DT_C6000_DSBT_SIZE, htab->params.dsbt_size)
3294           || !add_dynamic_entry (DT_C6000_DSBT_INDEX,
3295                                  htab->params.dsbt_index))
3296         return FALSE;
3297
3298       if (htab->elf.splt->size != 0)
3299         {
3300           if (!add_dynamic_entry (DT_PLTGOT, 0)
3301               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3302               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3303               || !add_dynamic_entry (DT_JMPREL, 0))
3304             return FALSE;
3305         }
3306
3307       if (relocs)
3308         {
3309           if (!add_dynamic_entry (DT_RELA, 0)
3310               || !add_dynamic_entry (DT_RELASZ, 0)
3311               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3312             return FALSE;
3313
3314           /* If any dynamic relocs apply to a read-only section,
3315              then we need a DT_TEXTREL entry.  */
3316           if ((info->flags & DF_TEXTREL) == 0)
3317             elf_link_hash_traverse (&htab->elf,
3318                                     elf32_tic6x_readonly_dynrelocs, info);
3319
3320           if ((info->flags & DF_TEXTREL) != 0)
3321             {
3322               if (!add_dynamic_entry (DT_TEXTREL, 0))
3323                 return FALSE;
3324             }
3325         }
3326     }
3327 #undef add_dynamic_entry
3328
3329   return TRUE;
3330 }
3331
3332 /* This function is called after all the input files have been read,
3333    and the input sections have been assigned to output sections.  */
3334
3335 static bfd_boolean
3336 elf32_tic6x_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3337 {
3338   if (elf32_tic6x_using_dsbt (output_bfd) && !info->relocatable)
3339     {
3340       struct elf_link_hash_entry *h;
3341
3342       /* Force a PT_GNU_STACK segment to be created.  */
3343       if (! elf_tdata (output_bfd)->stack_flags)
3344         elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
3345
3346       /* Define __stacksize if it's not defined yet.  */
3347       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3348                                 FALSE, FALSE, FALSE);
3349       if (! h || h->root.type != bfd_link_hash_defined
3350           || h->type != STT_OBJECT
3351           || !h->def_regular)
3352         {
3353           struct bfd_link_hash_entry *bh = NULL;
3354
3355           if (!(_bfd_generic_link_add_one_symbol
3356                 (info, output_bfd, "__stacksize",
3357                  BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
3358                  (const char *) NULL, FALSE,
3359                  get_elf_backend_data (output_bfd)->collect, &bh)))
3360             return FALSE;
3361
3362           h = (struct elf_link_hash_entry *) bh;
3363           h->def_regular = 1;
3364           h->type = STT_OBJECT;
3365         }
3366     }
3367   return TRUE;
3368 }
3369
3370 static bfd_boolean
3371 elf32_tic6x_modify_program_headers (bfd *output_bfd,
3372                                     struct bfd_link_info *info)
3373 {
3374   struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
3375   struct elf_segment_map *m;
3376   Elf_Internal_Phdr *p;
3377
3378   /* objcopy and strip preserve what's already there using
3379      elf32_tic6x_copy_private_bfd_data ().  */
3380   if (! info)
3381     return TRUE;
3382
3383   for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
3384     if (m->p_type == PT_GNU_STACK)
3385       break;
3386
3387   if (m)
3388     {
3389       struct elf_link_hash_entry *h;
3390
3391       /* Obtain the pointer to the __stacksize symbol.  */
3392       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3393                                 FALSE, FALSE, FALSE);
3394       if (h)
3395         {
3396           while (h->root.type == bfd_link_hash_indirect
3397                  || h->root.type == bfd_link_hash_warning)
3398             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3399           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
3400         }
3401
3402       /* Set the header p_memsz from the symbol value.  We
3403          intentionally ignore the symbol section.  */
3404       if (h && h->root.type == bfd_link_hash_defined)
3405         p->p_memsz = h->root.u.def.value;
3406       else
3407         p->p_memsz = DEFAULT_STACK_SIZE;
3408
3409       p->p_align = 8;
3410     }
3411
3412   return TRUE;
3413 }
3414
3415 static bfd_boolean
3416 elf32_tic6x_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3417                                      struct bfd_link_info *info)
3418 {
3419   struct elf32_tic6x_link_hash_table *htab;
3420   bfd *dynobj;
3421   asection *sdyn;
3422
3423   htab = elf32_tic6x_hash_table (info);
3424   dynobj = htab->elf.dynobj;
3425   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3426
3427   if (elf_hash_table (info)->dynamic_sections_created)
3428     {
3429       Elf32_External_Dyn * dyncon;
3430       Elf32_External_Dyn * dynconend;
3431
3432       BFD_ASSERT (sdyn != NULL);
3433
3434       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3435       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3436
3437       for (; dyncon < dynconend; dyncon++)
3438         {
3439           Elf_Internal_Dyn dyn;
3440           asection *s;
3441
3442           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3443
3444           switch (dyn.d_tag)
3445             {
3446             default:
3447               break;
3448
3449             case DT_C6000_DSBT_BASE:
3450               s = htab->dsbt;
3451               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset);
3452               break;
3453
3454             case DT_PLTGOT:
3455               s = htab->elf.sgotplt;
3456               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3457               break;
3458
3459             case DT_JMPREL:
3460               s = htab->elf.srelplt;
3461               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3462               break;
3463
3464             case DT_PLTRELSZ:
3465               s = htab->elf.srelplt;
3466               dyn.d_un.d_val = s->size;
3467               break;
3468             }
3469           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3470         }
3471
3472       /* Fill in the first entry in the procedure linkage table.  */
3473       if (htab->elf.splt && htab->elf.splt->size > 0)
3474         {
3475           bfd_vma got_offs = (htab->elf.sgotplt->output_section->vma
3476                               + htab->elf.sgotplt->output_offset
3477                               - htab->dsbt->output_section->vma
3478                               - htab->dsbt->output_offset) / 4;
3479
3480           /* ldw .D2T2 *+b14[$GOT(0)],b2 */
3481           bfd_put_32 (output_bfd, got_offs << 8 | 0x0100006e,
3482                       htab->elf.splt->contents);
3483           /* ldw .D2T2 *+b14[$GOT(4)],b1 */
3484           bfd_put_32 (output_bfd, (got_offs + 1) << 8 | 0x0080006e,
3485                       htab->elf.splt->contents + 4);
3486           /* nop 3 */
3487           bfd_put_32 (output_bfd, 0x00004000,
3488                       htab->elf.splt->contents + 8);
3489           /* b .s2 b2 */
3490           bfd_put_32 (output_bfd, 0x00080362,
3491                       htab->elf.splt->contents + 12);
3492           /* nop 5 */
3493           bfd_put_32 (output_bfd, 0x00008000,
3494                       htab->elf.splt->contents + 16);
3495
3496           elf_section_data (htab->elf.splt->output_section)
3497             ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3498         }
3499     }
3500
3501   return TRUE;
3502 }
3503
3504 /* Return address for Ith PLT stub in section PLT, for relocation REL
3505    or (bfd_vma) -1 if it should not be included.  */
3506
3507 static bfd_vma
3508 elf32_tic6x_plt_sym_val (bfd_vma i, const asection *plt,
3509                          const arelent *rel ATTRIBUTE_UNUSED)
3510 {
3511   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3512 }
3513
3514 static int
3515 elf32_tic6x_obj_attrs_arg_type (int tag)
3516 {
3517   if (tag == Tag_ABI_compatibility)
3518     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
3519   else if (tag & 1)
3520     return ATTR_TYPE_FLAG_STR_VAL;
3521   else
3522     return ATTR_TYPE_FLAG_INT_VAL;
3523 }
3524
3525 static int
3526 elf32_tic6x_obj_attrs_order (int num)
3527 {
3528   if (num == LEAST_KNOWN_OBJ_ATTRIBUTE)
3529     return Tag_ABI_conformance;
3530   if ((num - 1) < Tag_ABI_conformance)
3531     return num - 1;
3532   return num;
3533 }
3534
3535 static bfd_boolean
3536 elf32_tic6x_obj_attrs_handle_unknown (bfd *abfd, int tag)
3537 {
3538   if ((tag & 127) < 64)
3539     {
3540       _bfd_error_handler
3541         (_("%B: error: unknown mandatory EABI object attribute %d"),
3542          abfd, tag);
3543       bfd_set_error (bfd_error_bad_value);
3544       return FALSE;
3545     }
3546   else
3547     {
3548       _bfd_error_handler
3549         (_("%B: warning: unknown EABI object attribute %d"),
3550          abfd, tag);
3551       return TRUE;
3552     }
3553 }
3554
3555 /* Merge the Tag_ISA attribute values ARCH1 and ARCH2
3556    and return the merged value.  At present, all merges succeed, so no
3557    return value for errors is defined.  */
3558
3559 int
3560 elf32_tic6x_merge_arch_attributes (int arch1, int arch2)
3561 {
3562   int min_arch, max_arch;
3563
3564   min_arch = (arch1 < arch2 ? arch1 : arch2);
3565   max_arch = (arch1 > arch2 ? arch1 : arch2);
3566
3567   /* In most cases, the numerically greatest value is the correct
3568      merged value, but merging C64 and C67 results in C674X.  */
3569   if ((min_arch == C6XABI_Tag_ISA_C67X
3570        || min_arch == C6XABI_Tag_ISA_C67XP)
3571       && (max_arch == C6XABI_Tag_ISA_C64X
3572           || max_arch == C6XABI_Tag_ISA_C64XP))
3573     return C6XABI_Tag_ISA_C674X;
3574
3575   return max_arch;
3576 }
3577
3578 /* Convert a Tag_ABI_array_object_alignment or
3579    Tag_ABI_array_object_align_expected tag value TAG to a
3580    corresponding alignment value; return the alignment, or -1 for an
3581    unknown tag value.  */
3582
3583 static int
3584 elf32_tic6x_tag_to_array_alignment (int tag)
3585 {
3586   switch (tag)
3587     {
3588     case 0:
3589       return 8;
3590
3591     case 1:
3592       return 4;
3593
3594     case 2:
3595       return 16;
3596
3597     default:
3598       return -1;
3599     }
3600 }
3601
3602 /* Convert a Tag_ABI_array_object_alignment or
3603    Tag_ABI_array_object_align_expected alignment ALIGN to a
3604    corresponding tag value; return the tag value.  */
3605
3606 static int
3607 elf32_tic6x_array_alignment_to_tag (int align)
3608 {
3609   switch (align)
3610     {
3611     case 8:
3612       return 0;
3613
3614     case 4:
3615       return 1;
3616
3617     case 16:
3618       return 2;
3619
3620     default:
3621       abort ();
3622     }
3623 }
3624
3625 /* Merge attributes from IBFD and OBFD, returning TRUE if the merge
3626    succeeded, FALSE otherwise.  */
3627
3628 static bfd_boolean
3629 elf32_tic6x_merge_attributes (bfd *ibfd, bfd *obfd)
3630 {
3631   bfd_boolean result = TRUE;
3632   obj_attribute *in_attr;
3633   obj_attribute *out_attr;
3634   int i;
3635   int array_align_in, array_align_out, array_expect_in, array_expect_out;
3636
3637   if (!elf_known_obj_attributes_proc (obfd)[0].i)
3638     {
3639       /* This is the first object.  Copy the attributes.  */
3640       _bfd_elf_copy_obj_attributes (ibfd, obfd);
3641
3642       out_attr = elf_known_obj_attributes_proc (obfd);
3643
3644       /* Use the Tag_null value to indicate the attributes have been
3645          initialized.  */
3646       out_attr[0].i = 1;
3647
3648       return TRUE;
3649     }
3650
3651   in_attr = elf_known_obj_attributes_proc (ibfd);
3652   out_attr = elf_known_obj_attributes_proc (obfd);
3653
3654   /* No specification yet for handling of unknown attributes, so just
3655      ignore them and handle known ones.  */
3656
3657   if (out_attr[Tag_ABI_stack_align_preserved].i
3658       < in_attr[Tag_ABI_stack_align_needed].i)
3659     {
3660       _bfd_error_handler
3661         (_("error: %B requires more stack alignment than %B preserves"),
3662          ibfd, obfd);
3663       result = FALSE;
3664     }
3665   if (in_attr[Tag_ABI_stack_align_preserved].i
3666       < out_attr[Tag_ABI_stack_align_needed].i)
3667     {
3668       _bfd_error_handler
3669         (_("error: %B requires more stack alignment than %B preserves"),
3670          obfd, ibfd);
3671       result = FALSE;
3672     }
3673
3674   array_align_in = elf32_tic6x_tag_to_array_alignment
3675     (in_attr[Tag_ABI_array_object_alignment].i);
3676   if (array_align_in == -1)
3677     {
3678       _bfd_error_handler
3679         (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
3680          ibfd);
3681       result = FALSE;
3682     }
3683   array_align_out = elf32_tic6x_tag_to_array_alignment
3684     (out_attr[Tag_ABI_array_object_alignment].i);
3685   if (array_align_out == -1)
3686     {
3687       _bfd_error_handler
3688         (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
3689          obfd);
3690       result = FALSE;
3691     }
3692   array_expect_in = elf32_tic6x_tag_to_array_alignment
3693     (in_attr[Tag_ABI_array_object_align_expected].i);
3694   if (array_expect_in == -1)
3695     {
3696       _bfd_error_handler
3697         (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
3698          ibfd);
3699       result = FALSE;
3700     }
3701   array_expect_out = elf32_tic6x_tag_to_array_alignment
3702     (out_attr[Tag_ABI_array_object_align_expected].i);
3703   if (array_expect_out == -1)
3704     {
3705       _bfd_error_handler
3706         (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
3707          obfd);
3708       result = FALSE;
3709     }
3710
3711   if (array_align_out < array_expect_in)
3712     {
3713       _bfd_error_handler
3714         (_("error: %B requires more array alignment than %B preserves"),
3715          ibfd, obfd);
3716       result = FALSE;
3717     }
3718   if (array_align_in < array_expect_out)
3719     {
3720       _bfd_error_handler
3721         (_("error: %B requires more array alignment than %B preserves"),
3722          obfd, ibfd);
3723       result = FALSE;
3724     }
3725
3726   for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
3727     {
3728       switch (i)
3729         {
3730         case Tag_ISA:
3731           out_attr[i].i = elf32_tic6x_merge_arch_attributes (in_attr[i].i,
3732                                                              out_attr[i].i);
3733           break;
3734
3735         case Tag_ABI_wchar_t:
3736           if (out_attr[i].i == 0)
3737             out_attr[i].i = in_attr[i].i;
3738           if (out_attr[i].i != 0
3739               && in_attr[i].i != 0
3740               && out_attr[i].i != in_attr[i].i)
3741             {
3742               _bfd_error_handler
3743                 (_("warning: %B and %B differ in wchar_t size"), obfd, ibfd);
3744             }
3745           break;
3746
3747         case Tag_ABI_stack_align_needed:
3748           if (out_attr[i].i < in_attr[i].i)
3749             out_attr[i].i = in_attr[i].i;
3750           break;
3751
3752         case Tag_ABI_stack_align_preserved:
3753           if (out_attr[i].i > in_attr[i].i)
3754             out_attr[i].i = in_attr[i].i;
3755           break;
3756
3757         case Tag_ABI_DSBT:
3758           if (out_attr[i].i != in_attr[i].i)
3759             {
3760               _bfd_error_handler
3761                 (_("warning: %B and %B differ in whether code is "
3762                    "compiled for DSBT"),
3763                  obfd, ibfd);
3764             }
3765           break;
3766
3767         case Tag_ABI_PID:
3768           if (out_attr[i].i != in_attr[i].i)
3769             {
3770               _bfd_error_handler
3771                 (_("warning: %B and %B differ in position-dependence of "
3772                    "data addressing"),
3773                  obfd, ibfd);
3774             }
3775           break;
3776
3777         case Tag_ABI_PIC:
3778           if (out_attr[i].i != in_attr[i].i)
3779             {
3780               _bfd_error_handler
3781                 (_("warning: %B and %B differ in position-dependence of "
3782                    "code addressing"),
3783                  obfd, ibfd);
3784             }
3785           break;
3786
3787         case Tag_ABI_array_object_alignment:
3788           if (array_align_out != -1
3789               && array_align_in != -1
3790               && array_align_out > array_align_in)
3791             out_attr[i].i
3792               = elf32_tic6x_array_alignment_to_tag (array_align_in);
3793           break;
3794
3795         case Tag_ABI_array_object_align_expected:
3796           if (array_expect_out != -1
3797               && array_expect_in != -1
3798               && array_expect_out < array_expect_in)
3799             out_attr[i].i
3800               = elf32_tic6x_array_alignment_to_tag (array_expect_in);
3801           break;
3802
3803         case Tag_ABI_conformance:
3804           /* Merging for this attribute is not specified.  As on ARM,
3805              treat a missing attribute as no claim to conform and only
3806              merge identical values.  */
3807           if (out_attr[i].s == NULL
3808               || in_attr[i].s == NULL
3809               || strcmp (out_attr[i].s,
3810                          in_attr[i].s) != 0)
3811             out_attr[i].s = NULL;
3812           break;
3813
3814         case Tag_ABI_compatibility:
3815           /* Merged in _bfd_elf_merge_object_attributes.  */
3816           break;
3817
3818         default:
3819           result
3820             = result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
3821           break;
3822         }
3823
3824       if (in_attr[i].type && !out_attr[i].type)
3825         out_attr[i].type = in_attr[i].type;
3826     }
3827
3828   /* Merge Tag_ABI_compatibility attributes and any common GNU ones.  */
3829   if (!_bfd_elf_merge_object_attributes (ibfd, obfd))
3830     return FALSE;
3831
3832   result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
3833
3834   return result;
3835 }
3836
3837 static bfd_boolean
3838 elf32_tic6x_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3839 {
3840   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3841     return FALSE;
3842
3843   if (!elf32_tic6x_merge_attributes (ibfd, obfd))
3844     return FALSE;
3845
3846   return TRUE;
3847 }
3848
3849 static bfd_boolean
3850 elf32_tic6x_copy_private_data (bfd * ibfd, bfd * obfd)
3851 {
3852   _bfd_elf_copy_private_bfd_data (ibfd, obfd);
3853
3854   if (! is_tic6x_elf (ibfd) || ! is_tic6x_elf (obfd))
3855     return TRUE;
3856
3857   /* Copy the stack size.  */
3858   if (elf_tdata (ibfd)->phdr && elf_tdata (obfd)->phdr
3859       && elf32_tic6x_using_dsbt (ibfd) && elf32_tic6x_using_dsbt (obfd))
3860     {
3861       unsigned i;
3862
3863       for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
3864         if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
3865           {
3866             Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
3867
3868             for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
3869               if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
3870                 {
3871                   memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
3872
3873                   /* Rewrite the phdrs, since we're only called after they
3874                      were first written.  */
3875                   if (bfd_seek (obfd,
3876                                 (bfd_signed_vma) get_elf_backend_data (obfd)
3877                                 ->s->sizeof_ehdr, SEEK_SET) != 0
3878                       || get_elf_backend_data (obfd)->s
3879                       ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
3880                                          elf_elfheader (obfd)->e_phnum) != 0)
3881                     return FALSE;
3882                   break;
3883                 }
3884
3885             break;
3886           }
3887     }
3888
3889   return TRUE;
3890 }
3891
3892 #define TARGET_LITTLE_SYM       bfd_elf32_tic6x_le_vec
3893 #define TARGET_LITTLE_NAME      "elf32-tic6x-le"
3894 #define TARGET_BIG_SYM          bfd_elf32_tic6x_be_vec
3895 #define TARGET_BIG_NAME         "elf32-tic6x-be"
3896 #define ELF_ARCH                bfd_arch_tic6x
3897 #define ELF_TARGET_ID           TIC6X_ELF_DATA
3898 #define ELF_MACHINE_CODE        EM_TI_C6000
3899 #define ELF_MAXPAGESIZE         0x1000
3900 #define bfd_elf32_bfd_reloc_type_lookup elf32_tic6x_reloc_type_lookup
3901 #define bfd_elf32_bfd_reloc_name_lookup elf32_tic6x_reloc_name_lookup
3902 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_tic6x_copy_private_data
3903 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_tic6x_merge_private_bfd_data
3904 #define bfd_elf32_mkobject              elf32_tic6x_mkobject
3905 #define bfd_elf32_bfd_link_hash_table_create  elf32_tic6x_link_hash_table_create
3906 #define bfd_elf32_bfd_link_hash_table_free    elf32_tic6x_link_hash_table_free
3907 #define bfd_elf32_new_section_hook      elf32_tic6x_new_section_hook
3908 #define elf_backend_can_gc_sections     1
3909 #define elf_backend_default_use_rela_p  1
3910 #define elf_backend_may_use_rel_p       1
3911 #define elf_backend_may_use_rela_p      1
3912 #define elf_backend_obj_attrs_arg_type  elf32_tic6x_obj_attrs_arg_type
3913 #define elf_backend_obj_attrs_handle_unknown    elf32_tic6x_obj_attrs_handle_unknown
3914 #define elf_backend_obj_attrs_order     elf32_tic6x_obj_attrs_order
3915 #define elf_backend_obj_attrs_section   ".c6xabi.attributes"
3916 #define elf_backend_obj_attrs_section_type      SHT_C6000_ATTRIBUTES
3917 #define elf_backend_obj_attrs_vendor    "c6xabi"
3918 #define elf_backend_can_refcount        1
3919 #define elf_backend_want_got_plt        1
3920 #define elf_backend_want_dynbss         1
3921 #define elf_backend_plt_readonly        1
3922 #define elf_backend_rela_normal         1
3923 #define elf_backend_got_header_size     8
3924 #define elf_backend_gc_sweep_hook       elf32_tic6x_gc_sweep_hook
3925 #define elf_backend_modify_program_headers \
3926   elf32_tic6x_modify_program_headers
3927 #define elf_backend_create_dynamic_sections \
3928   elf32_tic6x_create_dynamic_sections
3929 #define elf_backend_adjust_dynamic_symbol \
3930   elf32_tic6x_adjust_dynamic_symbol
3931 #define elf_backend_check_relocs        elf32_tic6x_check_relocs
3932 #define elf_backend_add_symbol_hook     elf32_tic6x_add_symbol_hook
3933 #define elf_backend_symbol_processing   elf32_tic6x_symbol_processing
3934 #define elf_backend_link_output_symbol_hook \
3935   elf32_tic6x_link_output_symbol_hook
3936 #define elf_backend_section_from_bfd_section \
3937   elf32_tic6x_section_from_bfd_section
3938 #define elf_backend_relocate_section    elf32_tic6x_relocate_section
3939 #define elf_backend_finish_dynamic_symbol \
3940   elf32_tic6x_finish_dynamic_symbol
3941 #define elf_backend_always_size_sections \
3942   elf32_tic6x_always_size_sections
3943 #define elf_backend_size_dynamic_sections \
3944   elf32_tic6x_size_dynamic_sections
3945 #define elf_backend_finish_dynamic_sections \
3946   elf32_tic6x_finish_dynamic_sections
3947 #define elf_info_to_howto               elf32_tic6x_info_to_howto
3948 #define elf_info_to_howto_rel           elf32_tic6x_info_to_howto_rel
3949
3950 #undef elf_backend_omit_section_dynsym
3951 #define elf_backend_omit_section_dynsym elf32_tic6x_link_omit_section_dynsym
3952 #define elf_backend_plt_sym_val         elf32_tic6x_plt_sym_val
3953
3954
3955 #include "elf32-target.h"