bfd/elf32-tic6x.c

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