bfd/elf32-tic6x.c

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