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