bfd/elf32-cr16.c

   1 /* BFD back-end for National Semiconductor's CR16 ELF
   2    Copyright (C) 2007-2017 Free Software Foundation, Inc.
   3    Written by M R Swami Reddy.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software Foundation,
  19    Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "libiberty.h"
  26 #include "elf-bfd.h"
  27 #include "elf/cr16.h"
  28
  29 /* The cr16 linker needs to keep track of the number of relocs that
  30    it decides to copy in check_relocs for each symbol.  This is so
  31    that it can discard PC relative relocs if it doesn't need them when
  32    linking with -Bsymbolic.  We store the information in a field
  33    extending the regular ELF linker hash table.  */
  34
  35 struct elf32_cr16_link_hash_entry
  36 {
  37   /* The basic elf link hash table entry.  */
  38   struct elf_link_hash_entry root;
  39
  40   /* For function symbols, the number of times this function is
  41      called directly (ie by name).  */
  42   unsigned int direct_calls;
  43
  44   /* For function symbols, the size of this function's stack
  45      (if <= 255 bytes).  We stuff this into "call" instructions
  46      to this target when it's valid and profitable to do so.
  47
  48      This does not include stack allocated by movm!  */
  49   unsigned char stack_size;
  50
  51   /* For function symbols, arguments (if any) for movm instruction
  52      in the prologue.  We stuff this value into "call" instructions
  53      to the target when it's valid and profitable to do so.  */
  54   unsigned char movm_args;
  55
  56   /* For function symbols, the amount of stack space that would be allocated
  57      by the movm instruction.  This is redundant with movm_args, but we
  58      add it to the hash table to avoid computing it over and over.  */
  59   unsigned char movm_stack_size;
  60
  61 /* Used to mark functions which have had redundant parts of their
  62    prologue deleted.  */
  63 #define CR16_DELETED_PROLOGUE_BYTES 0x1
  64   unsigned char flags;
  65
  66   /* Calculated value.  */
  67   bfd_vma value;
  68 };
  69
  70 /* cr16_reloc_map array maps BFD relocation enum into a CRGAS relocation type.  */
  71
  72 struct cr16_reloc_map
  73 {
  74   bfd_reloc_code_real_type bfd_reloc_enum; /* BFD relocation enum.  */
  75   unsigned short cr16_reloc_type;          /* CR16 relocation type.  */
  76 };
  77
  78 static const struct cr16_reloc_map cr16_reloc_map[R_CR16_MAX] =
  79 {
  80   {BFD_RELOC_NONE,           R_CR16_NONE},
  81   {BFD_RELOC_CR16_NUM8,      R_CR16_NUM8},
  82   {BFD_RELOC_CR16_NUM16,     R_CR16_NUM16},
  83   {BFD_RELOC_CR16_NUM32,     R_CR16_NUM32},
  84   {BFD_RELOC_CR16_NUM32a,    R_CR16_NUM32a},
  85   {BFD_RELOC_CR16_REGREL4,   R_CR16_REGREL4},
  86   {BFD_RELOC_CR16_REGREL4a,  R_CR16_REGREL4a},
  87   {BFD_RELOC_CR16_REGREL14,  R_CR16_REGREL14},
  88   {BFD_RELOC_CR16_REGREL14a, R_CR16_REGREL14a},
  89   {BFD_RELOC_CR16_REGREL16,  R_CR16_REGREL16},
  90   {BFD_RELOC_CR16_REGREL20,  R_CR16_REGREL20},
  91   {BFD_RELOC_CR16_REGREL20a, R_CR16_REGREL20a},
  92   {BFD_RELOC_CR16_ABS20,     R_CR16_ABS20},
  93   {BFD_RELOC_CR16_ABS24,     R_CR16_ABS24},
  94   {BFD_RELOC_CR16_IMM4,      R_CR16_IMM4},
  95   {BFD_RELOC_CR16_IMM8,      R_CR16_IMM8},
  96   {BFD_RELOC_CR16_IMM16,     R_CR16_IMM16},
  97   {BFD_RELOC_CR16_IMM20,     R_CR16_IMM20},
  98   {BFD_RELOC_CR16_IMM24,     R_CR16_IMM24},
  99   {BFD_RELOC_CR16_IMM32,     R_CR16_IMM32},
 100   {BFD_RELOC_CR16_IMM32a,    R_CR16_IMM32a},
 101   {BFD_RELOC_CR16_DISP4,     R_CR16_DISP4},
 102   {BFD_RELOC_CR16_DISP8,     R_CR16_DISP8},
 103   {BFD_RELOC_CR16_DISP16,    R_CR16_DISP16},
 104   {BFD_RELOC_CR16_DISP24,    R_CR16_DISP24},
 105   {BFD_RELOC_CR16_DISP24a,   R_CR16_DISP24a},
 106   {BFD_RELOC_CR16_SWITCH8,   R_CR16_SWITCH8},
 107   {BFD_RELOC_CR16_SWITCH16,  R_CR16_SWITCH16},
 108   {BFD_RELOC_CR16_SWITCH32,  R_CR16_SWITCH32},
 109   {BFD_RELOC_CR16_GOT_REGREL20, R_CR16_GOT_REGREL20},
 110   {BFD_RELOC_CR16_GOTC_REGREL20, R_CR16_GOTC_REGREL20},
 111   {BFD_RELOC_CR16_GLOB_DAT,  R_CR16_GLOB_DAT}
 112 };
 113
 114 static reloc_howto_type cr16_elf_howto_table[] =
 115 {
 116   HOWTO (R_CR16_NONE,              /* type */
 117          0,                        /* rightshift */
 118          3,                        /* size */
 119          0,                        /* bitsize */
 120          FALSE,                    /* pc_relative */
 121          0,                        /* bitpos */
 122          complain_overflow_dont,   /* complain_on_overflow */
 123          bfd_elf_generic_reloc,    /* special_function */
 124          "R_CR16_NONE",            /* name */
 125          FALSE,                    /* partial_inplace */
 126          0,                        /* src_mask */
 127          0,                        /* dst_mask */
 128          FALSE),                   /* pcrel_offset */
 129
 130   HOWTO (R_CR16_NUM8,              /* type */
 131          0,                        /* rightshift */
 132          0,                        /* size */
 133          8,                        /* bitsize */
 134          FALSE,                    /* pc_relative */
 135          0,                        /* bitpos */
 136          complain_overflow_bitfield,/* complain_on_overflow */
 137          bfd_elf_generic_reloc,    /* special_function */
 138          "R_CR16_NUM8",            /* name */
 139          FALSE,                    /* partial_inplace */
 140          0x0,                      /* src_mask */
 141          0xff,                     /* dst_mask */
 142          FALSE),                   /* pcrel_offset */
 143
 144   HOWTO (R_CR16_NUM16,             /* type */
 145          0,                        /* rightshift */
 146          1,                        /* size */
 147          16,                       /* bitsize */
 148          FALSE,                    /* pc_relative */
 149          0,                        /* bitpos */
 150          complain_overflow_bitfield,/* complain_on_overflow */
 151          bfd_elf_generic_reloc,    /* special_function */
 152          "R_CR16_NUM16",           /* name */
 153          FALSE,                    /* partial_inplace */
 154          0x0,                      /* src_mask */
 155          0xffff,                   /* dst_mask */
 156          FALSE),                   /* pcrel_offset */
 157
 158   HOWTO (R_CR16_NUM32,             /* type */
 159          0,                        /* rightshift */
 160          2,                        /* size */
 161          32,                       /* bitsize */
 162          FALSE,                    /* pc_relative */
 163          0,                        /* bitpos */
 164          complain_overflow_bitfield,/* complain_on_overflow */
 165          bfd_elf_generic_reloc,    /* special_function */
 166          "R_CR16_NUM32",           /* name */
 167          FALSE,                    /* partial_inplace */
 168          0x0,                      /* src_mask */
 169          0xffffffff,               /* dst_mask */
 170          FALSE),                   /* pcrel_offset */
 171
 172   HOWTO (R_CR16_NUM32a,            /* type */
 173          1,                        /* rightshift */
 174          2,                        /* size */
 175          32,                       /* bitsize */
 176          FALSE,                    /* pc_relative */
 177          0,                        /* bitpos */
 178          complain_overflow_bitfield,/* complain_on_overflow */
 179          bfd_elf_generic_reloc,    /* special_function */
 180          "R_CR16_NUM32a",          /* name */
 181          FALSE,                    /* partial_inplace */
 182          0x0,                      /* src_mask */
 183          0xffffffff,               /* dst_mask */
 184          FALSE),                   /* pcrel_offset */
 185
 186   HOWTO (R_CR16_REGREL4,           /* type */
 187          0,                        /* rightshift */
 188          0,                        /* size */
 189          4,                        /* bitsize */
 190          FALSE,                    /* pc_relative */
 191          0,                        /* bitpos */
 192          complain_overflow_bitfield,/* complain_on_overflow */
 193          bfd_elf_generic_reloc,    /* special_function */
 194          "R_CR16_REGREL4",         /* name */
 195          FALSE,                    /* partial_inplace */
 196          0x0,                      /* src_mask */
 197          0xf,                      /* dst_mask */
 198          FALSE),                   /* pcrel_offset */
 199
 200   HOWTO (R_CR16_REGREL4a,          /* type */
 201          0,                        /* rightshift */
 202          0,                        /* size */
 203          4,                        /* bitsize */
 204          FALSE,                    /* pc_relative */
 205          0,                        /* bitpos */
 206          complain_overflow_bitfield,/* complain_on_overflow */
 207          bfd_elf_generic_reloc,    /* special_function */
 208          "R_CR16_REGREL4a",        /* name */
 209          FALSE,                    /* partial_inplace */
 210          0x0,                      /* src_mask */
 211          0xf,                      /* dst_mask */
 212          FALSE),                   /* pcrel_offset */
 213
 214   HOWTO (R_CR16_REGREL14,          /* type */
 215          0,                        /* rightshift */
 216          1,                        /* size */
 217          14,                       /* bitsize */
 218          FALSE,                    /* pc_relative */
 219          0,                        /* bitpos */
 220          complain_overflow_bitfield,/* complain_on_overflow */
 221          bfd_elf_generic_reloc,    /* special_function */
 222          "R_CR16_REGREL14",        /* name */
 223          FALSE,                    /* partial_inplace */
 224          0x0,                      /* src_mask */
 225          0x3fff,                   /* dst_mask */
 226          FALSE),                   /* pcrel_offset */
 227
 228   HOWTO (R_CR16_REGREL14a,         /* type */
 229          0,                        /* rightshift */
 230          1,                        /* size */
 231          14,                       /* bitsize */
 232          FALSE,                    /* pc_relative */
 233          0,                        /* bitpos */
 234          complain_overflow_bitfield,/* complain_on_overflow */
 235          bfd_elf_generic_reloc,    /* special_function */
 236          "R_CR16_REGREL14a",       /* name */
 237          FALSE,                    /* partial_inplace */
 238          0x0,                      /* src_mask */
 239          0x3fff,                   /* dst_mask */
 240          FALSE),                   /* pcrel_offset */
 241
 242   HOWTO (R_CR16_REGREL16,          /* type */
 243          0,                        /* rightshift */
 244          1,                        /* size */
 245          16,                       /* bitsize */
 246          FALSE,                    /* pc_relative */
 247          0,                        /* bitpos */
 248          complain_overflow_bitfield,/* complain_on_overflow */
 249          bfd_elf_generic_reloc,    /* special_function */
 250          "R_CR16_REGREL16",        /* name */
 251          FALSE,                    /* partial_inplace */
 252          0x0,                      /* src_mask */
 253          0xffff,                   /* dst_mask */
 254          FALSE),                   /* pcrel_offset */
 255
 256   HOWTO (R_CR16_REGREL20,          /* type */
 257          0,                        /* rightshift */
 258          2,                        /* size */
 259          20,                       /* bitsize */
 260          FALSE,                    /* pc_relative */
 261          0,                        /* bitpos */
 262          complain_overflow_bitfield,/* complain_on_overflow */
 263          bfd_elf_generic_reloc,    /* special_function */
 264          "R_CR16_REGREL20",        /* name */
 265          FALSE,                    /* partial_inplace */
 266          0x0,                      /* src_mask */
 267          0xfffff,                  /* dst_mask */
 268          FALSE),                   /* pcrel_offset */
 269
 270   HOWTO (R_CR16_REGREL20a,         /* type */
 271          0,                        /* rightshift */
 272          2,                        /* size */
 273          20,                       /* bitsize */
 274          FALSE,                    /* pc_relative */
 275          0,                        /* bitpos */
 276          complain_overflow_bitfield,/* complain_on_overflow */
 277          bfd_elf_generic_reloc,    /* special_function */
 278          "R_CR16_REGREL20a",       /* name */
 279          FALSE,                    /* partial_inplace */
 280          0x0,                      /* src_mask */
 281          0xfffff,                  /* dst_mask */
 282          FALSE),                   /* pcrel_offset */
 283
 284   HOWTO (R_CR16_ABS20,             /* type */
 285          0,                        /* rightshift */
 286          2,                        /* size */
 287          20,                       /* bitsize */
 288          FALSE,                    /* pc_relative */
 289          0,                        /* bitpos */
 290          complain_overflow_bitfield,/* complain_on_overflow */
 291          bfd_elf_generic_reloc,    /* special_function */
 292          "R_CR16_ABS20",           /* name */
 293          FALSE,                    /* partial_inplace */
 294          0x0,                      /* src_mask */
 295          0xfffff,                  /* dst_mask */
 296          FALSE),                   /* pcrel_offset */
 297
 298   HOWTO (R_CR16_ABS24,             /* type */
 299          0,                        /* rightshift */
 300          2,                        /* size */
 301          24,                       /* bitsize */
 302          FALSE,                    /* pc_relative */
 303          0,                        /* bitpos */
 304          complain_overflow_bitfield,/* complain_on_overflow */
 305          bfd_elf_generic_reloc,    /* special_function */
 306          "R_CR16_ABS24",           /* name */
 307          FALSE,                    /* partial_inplace */
 308          0x0,                      /* src_mask */
 309          0xffffff,                 /* dst_mask */
 310          FALSE),                   /* pcrel_offset */
 311
 312   HOWTO (R_CR16_IMM4,              /* type */
 313          0,                        /* rightshift */
 314          0,                        /* size */
 315          4,                        /* bitsize */
 316          FALSE,                    /* pc_relative */
 317          0,                        /* bitpos */
 318          complain_overflow_bitfield,/* complain_on_overflow */
 319          bfd_elf_generic_reloc,    /* special_function */
 320          "R_CR16_IMM4",            /* name */
 321          FALSE,                    /* partial_inplace */
 322          0x0,                      /* src_mask */
 323          0xf,                      /* dst_mask */
 324          FALSE),                   /* pcrel_offset */
 325
 326   HOWTO (R_CR16_IMM8,              /* type */
 327          0,                        /* rightshift */
 328          0,                        /* size */
 329          8,                        /* bitsize */
 330          FALSE,                    /* pc_relative */
 331          0,                        /* bitpos */
 332          complain_overflow_bitfield,/* complain_on_overflow */
 333          bfd_elf_generic_reloc,    /* special_function */
 334          "R_CR16_IMM8",            /* name */
 335          FALSE,                    /* partial_inplace */
 336          0x0,                      /* src_mask */
 337          0xff,                     /* dst_mask */
 338          FALSE),                   /* pcrel_offset */
 339
 340   HOWTO (R_CR16_IMM16,             /* type */
 341          0,                        /* rightshift */
 342          1,                        /* size */
 343          16,                       /* bitsize */
 344          FALSE,                    /* pc_relative */
 345          0,                        /* bitpos */
 346          complain_overflow_bitfield,/* complain_on_overflow */
 347          bfd_elf_generic_reloc,    /* special_function */
 348          "R_CR16_IMM16",           /* name */
 349          FALSE,                    /* partial_inplace */
 350          0x0,                      /* src_mask */
 351          0xffff,                   /* dst_mask */
 352          FALSE),                   /* pcrel_offset */
 353
 354   HOWTO (R_CR16_IMM20,             /* type */
 355          0,                        /* rightshift */
 356          2,                        /* size */
 357          20,                       /* bitsize */
 358          FALSE,                    /* pc_relative */
 359          0,                        /* bitpos */
 360          complain_overflow_bitfield,/* complain_on_overflow */
 361          bfd_elf_generic_reloc,    /* special_function */
 362          "R_CR16_IMM20",           /* name */
 363          FALSE,                    /* partial_inplace */
 364          0x0,                      /* src_mask */
 365          0xfffff,                  /* dst_mask */
 366          FALSE),                   /* pcrel_offset */
 367
 368   HOWTO (R_CR16_IMM24,             /* type */
 369          0,                        /* rightshift */
 370          2,                        /* size */
 371          24,                       /* bitsize */
 372          FALSE,                    /* pc_relative */
 373          0,                        /* bitpos */
 374          complain_overflow_bitfield,/* complain_on_overflow */
 375          bfd_elf_generic_reloc,    /* special_function */
 376          "R_CR16_IMM24",           /* name */
 377          FALSE,                    /* partial_inplace */
 378          0x0,                      /* src_mask */
 379          0xffffff,                 /* dst_mask */
 380          FALSE),                   /* pcrel_offset */
 381
 382   HOWTO (R_CR16_IMM32,             /* type */
 383          0,                        /* rightshift */
 384          2,                        /* size */
 385          32,                       /* bitsize */
 386          FALSE,                    /* pc_relative */
 387          0,                        /* bitpos */
 388          complain_overflow_bitfield,/* complain_on_overflow */
 389          bfd_elf_generic_reloc,    /* special_function */
 390          "R_CR16_IMM32",           /* name */
 391          FALSE,                    /* partial_inplace */
 392          0x0,                      /* src_mask */
 393          0xffffffff,               /* dst_mask */
 394          FALSE),                   /* pcrel_offset */
 395
 396   HOWTO (R_CR16_IMM32a,            /* type */
 397          1,                        /* rightshift */
 398          2,                        /* size */
 399          32,                       /* bitsize */
 400          FALSE,                    /* pc_relative */
 401          0,                        /* bitpos */
 402          complain_overflow_bitfield,/* complain_on_overflow */
 403          bfd_elf_generic_reloc,    /* special_function */
 404          "R_CR16_IMM32a",          /* name */
 405          FALSE,                    /* partial_inplace */
 406          0x0,                      /* src_mask */
 407          0xffffffff,               /* dst_mask */
 408          FALSE),                   /* pcrel_offset */
 409
 410   HOWTO (R_CR16_DISP4,             /* type */
 411          1,                        /* rightshift */
 412          0,                        /* size (0 = byte, 1 = short, 2 = long) */
 413          4,                        /* bitsize */
 414          TRUE,                     /* pc_relative */
 415          0,                        /* bitpos */
 416          complain_overflow_unsigned, /* complain_on_overflow */
 417          bfd_elf_generic_reloc,    /* special_function */
 418          "R_CR16_DISP4",           /* name */
 419          FALSE,                    /* partial_inplace */
 420          0x0,                      /* src_mask */
 421          0xf,                      /* dst_mask */
 422          FALSE),                   /* pcrel_offset */
 423
 424   HOWTO (R_CR16_DISP8,             /* type */
 425          1,                        /* rightshift */
 426          0,                        /* size (0 = byte, 1 = short, 2 = long) */
 427          8,                        /* bitsize */
 428          TRUE,                     /* pc_relative */
 429          0,                        /* bitpos */
 430          complain_overflow_unsigned, /* complain_on_overflow */
 431          bfd_elf_generic_reloc,    /* special_function */
 432          "R_CR16_DISP8",           /* name */
 433          FALSE,                    /* partial_inplace */
 434          0x0,                      /* src_mask */
 435          0x1ff,                    /* dst_mask */
 436          FALSE),                   /* pcrel_offset */
 437
 438   HOWTO (R_CR16_DISP16,            /* type */
 439          0,                        /* rightshift REVIITS: To sync with WinIDEA*/
 440          1,                        /* size (0 = byte, 1 = short, 2 = long) */
 441          16,                       /* bitsize */
 442          TRUE,                     /* pc_relative */
 443          0,                        /* bitpos */
 444          complain_overflow_unsigned, /* complain_on_overflow */
 445          bfd_elf_generic_reloc,    /* special_function */
 446          "R_CR16_DISP16",          /* name */
 447          FALSE,                    /* partial_inplace */
 448          0x0,                      /* src_mask */
 449          0x1ffff,                  /* dst_mask */
 450          FALSE),                   /* pcrel_offset */
 451   /* REVISIT: DISP24 should be left-shift by 2 as per ISA doc
 452      but its not done, to sync with WinIDEA and CR16 4.1 tools */
 453   HOWTO (R_CR16_DISP24,            /* type */
 454          0,                        /* rightshift */
 455          2,                        /* size (0 = byte, 1 = short, 2 = long) */
 456          24,                       /* bitsize */
 457          TRUE,                     /* pc_relative */
 458          0,                        /* bitpos */
 459          complain_overflow_unsigned, /* complain_on_overflow */
 460          bfd_elf_generic_reloc,    /* special_function */
 461          "R_CR16_DISP24",          /* name */
 462          FALSE,                    /* partial_inplace */
 463          0x0,                      /* src_mask */
 464          0x1ffffff,                /* dst_mask */
 465          FALSE),                   /* pcrel_offset */
 466
 467   HOWTO (R_CR16_DISP24a,           /* type */
 468          0,                        /* rightshift */
 469          2,                        /* size (0 = byte, 1 = short, 2 = long) */
 470          24,                       /* bitsize */
 471          TRUE,                     /* pc_relative */
 472          0,                        /* bitpos */
 473          complain_overflow_unsigned, /* complain_on_overflow */
 474          bfd_elf_generic_reloc,    /* special_function */
 475          "R_CR16_DISP24a",         /* name */
 476          FALSE,                    /* partial_inplace */
 477          0x0,                      /* src_mask */
 478          0xffffff,                 /* dst_mask */
 479          FALSE),                   /* pcrel_offset */
 480
 481   /* An 8 bit switch table entry.  This is generated for an expression
 482      such as ``.byte L1 - L2''.  The offset holds the difference
 483      between the reloc address and L2.  */
 484   HOWTO (R_CR16_SWITCH8,           /* type */
 485          0,                        /* rightshift */
 486          0,                        /* size (0 = byte, 1 = short, 2 = long) */
 487          8,                        /* bitsize */
 488          FALSE,                    /* pc_relative */
 489          0,                        /* bitpos */
 490          complain_overflow_unsigned, /* complain_on_overflow */
 491          bfd_elf_generic_reloc,    /* special_function */
 492          "R_CR16_SWITCH8",         /* name */
 493          FALSE,                    /* partial_inplace */
 494          0x0,                      /* src_mask */
 495          0xff,                     /* dst_mask */
 496          TRUE),                    /* pcrel_offset */
 497
 498   /* A 16 bit switch table entry.  This is generated for an expression
 499      such as ``.word L1 - L2''.  The offset holds the difference
 500      between the reloc address and L2.  */
 501   HOWTO (R_CR16_SWITCH16,          /* type */
 502          0,                        /* rightshift */
 503          1,                        /* size (0 = byte, 1 = short, 2 = long) */
 504          16,                       /* bitsize */
 505          FALSE,                    /* pc_relative */
 506          0,                        /* bitpos */
 507          complain_overflow_unsigned, /* complain_on_overflow */
 508          bfd_elf_generic_reloc,    /* special_function */
 509          "R_CR16_SWITCH16",        /* name */
 510          FALSE,                    /* partial_inplace */
 511          0x0,                      /* src_mask */
 512          0xffff,                   /* dst_mask */
 513          TRUE),                    /* pcrel_offset */
 514
 515   /* A 32 bit switch table entry.  This is generated for an expression
 516      such as ``.long L1 - L2''.  The offset holds the difference
 517      between the reloc address and L2.  */
 518   HOWTO (R_CR16_SWITCH32,          /* 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_unsigned, /* complain_on_overflow */
 525          bfd_elf_generic_reloc,    /* special_function */
 526          "R_CR16_SWITCH32",        /* name */
 527          FALSE,                    /* partial_inplace */
 528          0x0,                      /* src_mask */
 529          0xffffffff,               /* dst_mask */
 530          TRUE),                    /* pcrel_offset */
 531
 532   HOWTO (R_CR16_GOT_REGREL20,      /* type */
 533          0,                        /* rightshift */
 534          2,                        /* size */
 535          20,                       /* bitsize */
 536          FALSE,                    /* pc_relative */
 537          0,                        /* bitpos */
 538          complain_overflow_bitfield,/* complain_on_overflow */
 539          bfd_elf_generic_reloc,    /* special_function */
 540          "R_CR16_GOT_REGREL20",    /* name */
 541          TRUE,                     /* partial_inplace */
 542          0x0,                      /* src_mask */
 543          0xfffff,                  /* dst_mask */
 544          FALSE),                   /* pcrel_offset */
 545
 546   HOWTO (R_CR16_GOTC_REGREL20,     /* type */
 547          0,                        /* rightshift */
 548          2,                        /* size */
 549          20,                       /* bitsize */
 550          FALSE,                    /* pc_relative */
 551          0,                        /* bitpos */
 552          complain_overflow_bitfield,/* complain_on_overflow */
 553          bfd_elf_generic_reloc,    /* special_function */
 554          "R_CR16_GOTC_REGREL20",   /* name */
 555          TRUE,                     /* partial_inplace */
 556          0x0,                      /* src_mask */
 557          0xfffff,                  /* dst_mask */
 558          FALSE),                   /* pcrel_offset */
 559
 560   HOWTO (R_CR16_GLOB_DAT,          /* type */
 561          0,                        /* rightshift */
 562          2,                        /* size (0 = byte, 1 = short, 2 = long) */
 563          32,                       /* bitsize */
 564          FALSE,                    /* pc_relative */
 565          0,                        /* bitpos */
 566          complain_overflow_unsigned, /* complain_on_overflow */
 567          bfd_elf_generic_reloc,    /* special_function */
 568          "R_CR16_GLOB_DAT",        /* name */
 569          FALSE,                    /* partial_inplace */
 570          0x0,                      /* src_mask */
 571          0xffffffff,               /* dst_mask */
 572          TRUE)                     /* pcrel_offset */
 573 };
 574
 575
 576 /* Create the GOT section.  */
 577
 578 static bfd_boolean
 579 _bfd_cr16_elf_create_got_section (bfd * abfd, struct bfd_link_info * info)
 580 {
 581   flagword   flags;
 582   asection * s;
 583   struct elf_link_hash_entry * h;
 584   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
 585   struct elf_link_hash_table *htab = elf_hash_table (info);
 586   int ptralign;
 587
 588   /* This function may be called more than once.  */
 589   if (htab->sgot != NULL)
 590     return TRUE;
 591
 592   switch (bed->s->arch_size)
 593     {
 594     case 16:
 595       ptralign = 1;
 596       break;
 597
 598     case 32:
 599       ptralign = 2;
 600       break;
 601
 602     default:
 603       bfd_set_error (bfd_error_bad_value);
 604       return FALSE;
 605     }
 606
 607   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 608            | SEC_LINKER_CREATED);
 609
 610   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
 611   htab->sgot= s;
 612   if (s == NULL
 613       || ! bfd_set_section_alignment (abfd, s, ptralign))
 614     return FALSE;
 615
 616   if (bed->want_got_plt)
 617     {
 618       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
 619       htab->sgotplt = s;
 620       if (s == NULL
 621           || ! bfd_set_section_alignment (abfd, s, ptralign))
 622         return FALSE;
 623     }
 624
 625   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
 626      (or .got.plt) section.  We don't do this in the linker script
 627      because we don't want to define the symbol if we are not creating
 628      a global offset table.  */
 629   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
 630   htab->hgot = h;
 631   if (h == NULL)
 632     return FALSE;
 633
 634   /* The first bit of the global offset table is the header.  */
 635   s->size += bed->got_header_size;
 636
 637   return TRUE;
 638 }
 639
 640
 641 /* Retrieve a howto ptr using a BFD reloc_code.  */
 642
 643 static reloc_howto_type *
 644 elf_cr16_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 645                             bfd_reloc_code_real_type code)
 646 {
 647   unsigned int i;
 648
 649   for (i = 0; i < R_CR16_MAX; i++)
 650     if (code == cr16_reloc_map[i].bfd_reloc_enum)
 651       return &cr16_elf_howto_table[cr16_reloc_map[i].cr16_reloc_type];
 652
 653   _bfd_error_handler (_("Unsupported CR16 relocation type: 0x%x\n"), code);
 654   return NULL;
 655 }
 656
 657 static reloc_howto_type *
 658 elf_cr16_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 659                             const char *r_name)
 660 {
 661   unsigned int i;
 662
 663   for (i = 0; ARRAY_SIZE (cr16_elf_howto_table); i++)
 664     if (cr16_elf_howto_table[i].name != NULL
 665         && strcasecmp (cr16_elf_howto_table[i].name, r_name) == 0)
 666       return cr16_elf_howto_table + i;
 667
 668   return NULL;
 669 }
 670
 671 /* Retrieve a howto ptr using an internal relocation entry.  */
 672
 673 static void
 674 elf_cr16_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 675                         Elf_Internal_Rela *dst)
 676 {
 677   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 678
 679   if (r_type >= R_CR16_MAX)
 680     {
 681       /* xgettext:c-format */
 682       _bfd_error_handler (_("%B: unrecognised CR16 reloc number: %d"),
 683                           abfd, r_type);
 684       bfd_set_error (bfd_error_bad_value);
 685       r_type = R_CR16_NONE;
 686     }
 687   cache_ptr->howto = cr16_elf_howto_table + r_type;
 688 }
 689
 690 /* Look through the relocs for a section during the first phase.
 691    Since we don't do .gots or .plts, we just need to consider the
 692    virtual table relocs for gc.  */
 693
 694 static bfd_boolean
 695 cr16_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
 696                        const Elf_Internal_Rela *relocs)
 697 {
 698   Elf_Internal_Shdr *symtab_hdr;
 699   Elf_Internal_Sym * isymbuf = NULL;
 700   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 701   const Elf_Internal_Rela *rel;
 702   const Elf_Internal_Rela *rel_end;
 703   bfd *      dynobj;
 704   bfd_vma *  local_got_offsets;
 705   asection * sgot;
 706   asection * srelgot;
 707
 708   sgot    = NULL;
 709   srelgot = NULL;
 710   bfd_boolean result = FALSE;
 711
 712   if (bfd_link_relocatable (info))
 713     return TRUE;
 714
 715   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 716   sym_hashes = elf_sym_hashes (abfd);
 717   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
 718   if (!elf_bad_symtab (abfd))
 719     sym_hashes_end -= symtab_hdr->sh_info;
 720
 721   dynobj = elf_hash_table (info)->dynobj;
 722   local_got_offsets = elf_local_got_offsets (abfd);
 723   rel_end = relocs + sec->reloc_count;
 724   for (rel = relocs; rel < rel_end; rel++)
 725     {
 726       struct elf_link_hash_entry *h;
 727       unsigned long r_symndx;
 728
 729       r_symndx = ELF32_R_SYM (rel->r_info);
 730       if (r_symndx < symtab_hdr->sh_info)
 731         h = NULL;
 732       else
 733         {
 734           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 735           while (h->root.type == bfd_link_hash_indirect
 736                  || h->root.type == bfd_link_hash_warning)
 737             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 738
 739           /* PR15323, ref flags aren't set for references in the same
 740              object.  */
 741           h->root.non_ir_ref_regular = 1;
 742         }
 743
 744       /* Some relocs require a global offset table.  */
 745       if (dynobj == NULL)
 746         {
 747           switch (ELF32_R_TYPE (rel->r_info))
 748             {
 749             case R_CR16_GOT_REGREL20:
 750             case R_CR16_GOTC_REGREL20:
 751               elf_hash_table (info)->dynobj = dynobj = abfd;
 752               if (! _bfd_cr16_elf_create_got_section (dynobj, info))
 753                 goto fail;
 754               break;
 755
 756             default:
 757               break;
 758             }
 759         }
 760
 761       switch (ELF32_R_TYPE (rel->r_info))
 762         {
 763         case R_CR16_GOT_REGREL20:
 764         case R_CR16_GOTC_REGREL20:
 765           /* This symbol requires a global offset table entry.  */
 766
 767           sgot = elf_hash_table (info)->sgot;
 768           srelgot = elf_hash_table (info)->srelgot;
 769           BFD_ASSERT (sgot != NULL && srelgot != NULL);
 770
 771           if (h != NULL)
 772             {
 773               if (h->got.offset != (bfd_vma) -1)
 774                 /* We have already allocated space in the .got.  */
 775                 break;
 776
 777               h->got.offset = sgot->size;
 778
 779               /* Make sure this symbol is output as a dynamic symbol.  */
 780               if (h->dynindx == -1)
 781                 {
 782                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
 783                     goto fail;
 784                 }
 785
 786               srelgot->size += sizeof (Elf32_External_Rela);
 787             }
 788           else
 789             {
 790               /* This is a global offset table entry for a local
 791                  symbol.  */
 792               if (local_got_offsets == NULL)
 793                 {
 794                   size_t       size;
 795                   unsigned int i;
 796
 797                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 798                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 799
 800                   if (local_got_offsets == NULL)
 801                     goto fail;
 802
 803                   elf_local_got_offsets (abfd) = local_got_offsets;
 804
 805                   for (i = 0; i < symtab_hdr->sh_info; i++)
 806                     local_got_offsets[i] = (bfd_vma) -1;
 807                 }
 808
 809               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
 810                 /* We have already allocated space in the .got.  */
 811                 break;
 812
 813               local_got_offsets[r_symndx] = sgot->size;
 814
 815               if (bfd_link_executable (info))
 816                 /* If we are generating a shared object, we need to
 817                    output a R_CR16_RELATIVE reloc so that the dynamic
 818                    linker can adjust this GOT entry.  */
 819                 srelgot->size += sizeof (Elf32_External_Rela);
 820             }
 821
 822           sgot->size += 4;
 823           break;
 824
 825         }
 826     }
 827
 828    result = TRUE;
 829   fail:
 830     if (isymbuf != NULL)
 831       free (isymbuf);
 832
 833   return result;
 834 }
 835
 836 /* Perform a relocation as part of a final link.  */
 837
 838 static bfd_reloc_status_type
 839 cr16_elf_final_link_relocate (reloc_howto_type *howto,
 840                               bfd *input_bfd,
 841                               bfd *output_bfd ATTRIBUTE_UNUSED,
 842                               asection *input_section,
 843                               bfd_byte *contents,
 844                               bfd_vma offset,
 845                               bfd_vma Rvalue,
 846                               bfd_vma addend,
 847                               struct elf_link_hash_entry * h,
 848                               unsigned long symndx  ATTRIBUTE_UNUSED,
 849                               struct bfd_link_info *info ATTRIBUTE_UNUSED,
 850                               asection *sec ATTRIBUTE_UNUSED,
 851                               int is_local ATTRIBUTE_UNUSED)
 852 {
 853   unsigned short r_type = howto->type;
 854   bfd_byte *hit_data = contents + offset;
 855   bfd_vma reloc_bits, check, Rvalue1;
 856
 857   switch (r_type)
 858     {
 859      case R_CR16_IMM4:
 860      case R_CR16_IMM20:
 861      case R_CR16_ABS20:
 862        break;
 863
 864      case R_CR16_IMM8:
 865      case R_CR16_IMM16:
 866      case R_CR16_IMM32:
 867      case R_CR16_IMM32a:
 868      case R_CR16_REGREL4:
 869      case R_CR16_REGREL4a:
 870      case R_CR16_REGREL14:
 871      case R_CR16_REGREL14a:
 872      case R_CR16_REGREL16:
 873      case R_CR16_REGREL20:
 874      case R_CR16_REGREL20a:
 875      case R_CR16_GOT_REGREL20:
 876      case R_CR16_GOTC_REGREL20:
 877      case R_CR16_ABS24:
 878      case R_CR16_DISP16:
 879      case R_CR16_DISP24:
 880        /* 'hit_data' is relative to the start of the instruction, not the
 881            relocation offset. Advance it to account for the exact offset.  */
 882        hit_data += 2;
 883        break;
 884
 885      case R_CR16_NONE:
 886        return bfd_reloc_ok;
 887        break;
 888
 889      case R_CR16_DISP4:
 890        if (is_local)
 891         Rvalue += -1;
 892        break;
 893
 894      case R_CR16_DISP8:
 895      case R_CR16_DISP24a:
 896        if (is_local)
 897         Rvalue -= -1;
 898        break;
 899
 900      case R_CR16_SWITCH8:
 901      case R_CR16_SWITCH16:
 902      case R_CR16_SWITCH32:
 903        /* We only care about the addend, where the difference between
 904           expressions is kept.  */
 905        Rvalue = 0;
 906
 907      default:
 908        break;
 909     }
 910
 911   if (howto->pc_relative)
 912     {
 913       /* Subtract the address of the section containing the location.  */
 914       Rvalue -= (input_section->output_section->vma
 915                  + input_section->output_offset);
 916       /* Subtract the position of the location within the section.  */
 917       Rvalue -= offset;
 918     }
 919
 920   /* Add in supplied addend.  */
 921   Rvalue += addend;
 922
 923   /* Complain if the bitfield overflows, whether it is considered
 924      as signed or unsigned.  */
 925   check = Rvalue >> howto->rightshift;
 926
 927   /* Assumes two's complement.  This expression avoids
 928      overflow if howto->bitsize is the number of bits in
 929      bfd_vma.  */
 930   reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
 931
 932   /* For GOT and GOTC relocs no boundary checks applied.  */
 933   if (!((r_type == R_CR16_GOT_REGREL20)
 934       || (r_type == R_CR16_GOTC_REGREL20)))
 935     {
 936       if (((bfd_vma) check & ~reloc_bits) != 0
 937           && (((bfd_vma) check & ~reloc_bits)
 938           != (-(bfd_vma) 1 & ~reloc_bits)))
 939         {
 940           /* The above right shift is incorrect for a signed
 941              value.  See if turning on the upper bits fixes the
 942              overflow.  */
 943           if (howto->rightshift && (bfd_signed_vma) Rvalue < 0)
 944             {
 945               check |= ((bfd_vma) - 1
 946                         & ~((bfd_vma) - 1
 947                          >> howto->rightshift));
 948
 949               if (((bfd_vma) check & ~reloc_bits)
 950                   != (-(bfd_vma) 1 & ~reloc_bits))
 951                  return bfd_reloc_overflow;
 952             }
 953           else
 954             return bfd_reloc_overflow;
 955         }
 956
 957       /* Drop unwanted bits from the value we are relocating to.  */
 958       Rvalue >>= (bfd_vma) howto->rightshift;
 959
 960       /* Apply dst_mask to select only relocatable part of the insn.  */
 961       Rvalue &= howto->dst_mask;
 962     }
 963
 964   switch (howto->size)
 965     {
 966       case 0:
 967         if (r_type == R_CR16_DISP8)
 968           {
 969              Rvalue1 = bfd_get_16 (input_bfd, hit_data);
 970              Rvalue = ((Rvalue1 & 0xf000) | ((Rvalue << 4) & 0xf00)
 971                        | (Rvalue1 & 0x00f0) | (Rvalue & 0xf));
 972              bfd_put_16 (input_bfd, Rvalue, hit_data);
 973           }
 974         else if (r_type == R_CR16_IMM4)
 975           {
 976              Rvalue1 = bfd_get_16 (input_bfd, hit_data);
 977              Rvalue = (((Rvalue1 & 0xff) << 8) | ((Rvalue << 4) & 0xf0)
 978                        | ((Rvalue1 & 0x0f00) >> 8));
 979              bfd_put_16 (input_bfd, Rvalue, hit_data);
 980           }
 981         else if (r_type == R_CR16_DISP4)
 982           {
 983              Rvalue1 = bfd_get_16 (input_bfd, hit_data);
 984              Rvalue = (Rvalue1 | ((Rvalue & 0xf) << 4));
 985              bfd_put_16 (input_bfd, Rvalue, hit_data);
 986           }
 987         else
 988           {
 989              bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
 990           }
 991         break;
 992
 993       case 1:
 994         if (r_type == R_CR16_DISP16)
 995           {
 996             Rvalue |= (bfd_get_16 (input_bfd, hit_data));
 997             Rvalue = ((Rvalue & 0xfffe) | ((Rvalue >> 16) & 0x1));
 998           }
 999         if (r_type == R_CR16_IMM16)
1000           {
1001             Rvalue1 = bfd_get_16 (input_bfd, hit_data);
1002
1003             /* Add or subtract the offset value.  */
1004             if (Rvalue1 & 0x8000)
1005               Rvalue -= (~Rvalue1 + 1) & 0xffff;
1006             else
1007               Rvalue += Rvalue1;
1008
1009              /* Check for range.  */
1010              if ((long) Rvalue > 0xffff || (long) Rvalue < 0x0)
1011               return bfd_reloc_overflow;
1012           }
1013
1014         bfd_put_16 (input_bfd, Rvalue, hit_data);
1015         break;
1016
1017       case 2:
1018         if ((r_type == R_CR16_ABS20) || (r_type == R_CR16_IMM20))
1019           {
1020              Rvalue1 = (bfd_get_16 (input_bfd, hit_data + 2)
1021                         | (((bfd_get_16 (input_bfd, hit_data) & 0xf) <<16)));
1022
1023              /* Add or subtract the offset value.  */
1024              if (Rvalue1 & 0x80000)
1025                 Rvalue -= (~Rvalue1 + 1) & 0xfffff;
1026               else
1027                 Rvalue += Rvalue1;
1028
1029               /* Check for range.  */
1030               if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0)
1031                return bfd_reloc_overflow;
1032
1033             bfd_put_16 (input_bfd, ((bfd_get_16 (input_bfd, hit_data) & 0xfff0)
1034                         | ((Rvalue >> 16) & 0xf)), hit_data);
1035             bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
1036           }
1037         else if (r_type == R_CR16_GOT_REGREL20)
1038           {
1039             asection *sgot = elf_hash_table (info)->sgot;
1040
1041             if (h != NULL)
1042               {
1043                 bfd_vma off;
1044
1045                 off = h->got.offset;
1046                 BFD_ASSERT (off != (bfd_vma) -1);
1047
1048                 if (! elf_hash_table (info)->dynamic_sections_created
1049                      || SYMBOL_REFERENCES_LOCAL (info, h))
1050                     /* This is actually a static link, or it is a
1051                        -Bsymbolic link and the symbol is defined
1052                        locally, or the symbol was forced to be local
1053                        because of a version file.  We must initialize
1054                        this entry in the global offset table.
1055                        When doing a dynamic link, we create a .rela.got
1056                        relocation entry to initialize the value.  This
1057                        is done in the finish_dynamic_symbol routine.  */
1058                   bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
1059
1060                   Rvalue = sgot->output_offset + off;
1061                 }
1062               else
1063                 {
1064                    bfd_vma off;
1065
1066                    off = elf_local_got_offsets (input_bfd)[symndx];
1067                    bfd_put_32 (output_bfd,Rvalue, sgot->contents + off);
1068
1069                    Rvalue = sgot->output_offset + off;
1070                 }
1071
1072              Rvalue += addend;
1073
1074              /* REVISIT: if ((long) Rvalue > 0xffffff ||
1075                                     (long) Rvalue < -0x800000).  */
1076              if ((long) Rvalue > 0xffffff || (long) Rvalue < 0)
1077                return bfd_reloc_overflow;
1078
1079
1080              bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
1081                          | (((Rvalue >> 16) & 0xf) << 8), hit_data);
1082              bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
1083
1084           }
1085         else if (r_type == R_CR16_GOTC_REGREL20)
1086           {
1087              asection *sgot = elf_hash_table (info)->sgot;
1088
1089              if (h != NULL)
1090                {
1091                  bfd_vma off;
1092
1093                  off = h->got.offset;
1094                  BFD_ASSERT (off != (bfd_vma) -1);
1095
1096                   Rvalue >>=1; /* For code symbols.  */
1097
1098                  if (! elf_hash_table (info)->dynamic_sections_created
1099                       || SYMBOL_REFERENCES_LOCAL (info, h))
1100                  /* This is actually a static link, or it is a
1101                     -Bsymbolic link and the symbol is defined
1102                      locally, or the symbol was forced to be local
1103                      because of a version file.  We must initialize
1104                      this entry in the global offset table.
1105                      When doing a dynamic link, we create a .rela.got
1106                      relocation entry to initialize the value.  This
1107                      is done in the finish_dynamic_symbol routine.  */
1108                   bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
1109
1110                   Rvalue = sgot->output_offset + off;
1111                }
1112              else
1113                {
1114                   bfd_vma off;
1115
1116                   off = elf_local_got_offsets (input_bfd)[symndx];
1117                   Rvalue >>= 1;
1118                   bfd_put_32 (output_bfd,Rvalue, sgot->contents + off);
1119                   Rvalue = sgot->output_offset + off;
1120                }
1121
1122              Rvalue += addend;
1123
1124              /* Check if any value in DISP.  */
1125              Rvalue1 =((bfd_get_32 (input_bfd, hit_data) >>16)
1126                        | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16));
1127
1128              /* Add or subtract the offset value.  */
1129              if (Rvalue1 & 0x80000)
1130                Rvalue -= (~Rvalue1 + 1) & 0xfffff;
1131              else
1132                Rvalue += Rvalue1;
1133
1134               /* Check for range.  */
1135              /* REVISIT: if ((long) Rvalue > 0xffffff
1136                              || (long) Rvalue < -0x800000).  */
1137              if ((long) Rvalue > 0xffffff || (long) Rvalue < 0)
1138                return bfd_reloc_overflow;
1139
1140              bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
1141                          | (((Rvalue >> 16) & 0xf) << 8), hit_data);
1142              bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
1143           }
1144         else
1145           {
1146              if (r_type == R_CR16_ABS24)
1147                {
1148                   Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16)
1149                              | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16)
1150                              | (((bfd_get_32 (input_bfd, hit_data) & 0xf) <<20)));
1151
1152                   /* Add or subtract the offset value.  */
1153                   if (Rvalue1 & 0x800000)
1154                     Rvalue -= (~Rvalue1 + 1) & 0xffffff;
1155                   else
1156                     Rvalue += Rvalue1;
1157
1158                  /* Check for Range.  */
1159                  if ((long) Rvalue > 0xffffff || (long) Rvalue < 0x0)
1160                    return bfd_reloc_overflow;
1161
1162                  Rvalue = ((((Rvalue >> 20) & 0xf) | (((Rvalue >> 16) & 0xf)<<8)
1163                            | (bfd_get_32 (input_bfd, hit_data) & 0xf0f0))
1164                            | ((Rvalue & 0xffff) << 16));
1165                }
1166              else if (r_type == R_CR16_DISP24)
1167                {
1168                   Rvalue = ((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8)
1169                             | (bfd_get_16 (input_bfd, hit_data)))
1170                             | (((Rvalue & 0xfffe) | ((Rvalue >> 24) & 0x1)) << 16));
1171                }
1172              else if ((r_type == R_CR16_IMM32) || (r_type == R_CR16_IMM32a))
1173                {
1174                   Rvalue1 =((((bfd_get_32 (input_bfd, hit_data)) >> 16) &0xffff)
1175                             | (((bfd_get_32 (input_bfd, hit_data)) &0xffff)) << 16);
1176
1177                  /* Add or subtract the offset value.  */
1178                  if (Rvalue1 & 0x80000000)
1179                    Rvalue -= (~Rvalue1 + 1) & 0xffffffff;
1180                  else
1181                    Rvalue += Rvalue1;
1182
1183                  /* Check for range.  */
1184                  if (Rvalue > 0xffffffff || (long) Rvalue < 0x0)
1185                    return bfd_reloc_overflow;
1186
1187                  Rvalue = (((Rvalue >> 16)& 0xffff) | (Rvalue & 0xffff) << 16);
1188                }
1189              else if (r_type == R_CR16_DISP24a)
1190                {
1191                   Rvalue = (((Rvalue & 0xfffffe) | (Rvalue >> 23)));
1192                   Rvalue = ((Rvalue >> 16) & 0xff) | ((Rvalue & 0xffff) << 16)
1193                             | (bfd_get_32 (input_bfd, hit_data));
1194                }
1195              else if ((r_type == R_CR16_REGREL20)
1196                       || (r_type == R_CR16_REGREL20a))
1197                {
1198                   Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16)
1199                              | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16));
1200                   /* Add or subtract the offset value.  */
1201                   if (Rvalue1 & 0x80000)
1202                      Rvalue -= (~Rvalue1 + 1) & 0xfffff;
1203                   else
1204                      Rvalue += Rvalue1;
1205
1206                   /* Check for range.  */
1207                   if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0)
1208                     return bfd_reloc_overflow;
1209
1210                   Rvalue = (((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8)
1211                             | ((Rvalue & 0xffff) << 16)))
1212                             | (bfd_get_32 (input_bfd, hit_data) & 0xf0ff));
1213
1214               }
1215             else if (r_type == R_CR16_NUM32)
1216               {
1217                  Rvalue1 = (bfd_get_32 (input_bfd, hit_data));
1218
1219                  /* Add or subtract the offset value */
1220                  if (Rvalue1 & 0x80000000)
1221                    Rvalue -= (~Rvalue1 + 1) & 0xffffffff;
1222                  else
1223                    Rvalue += Rvalue1;
1224
1225                 /* Check for Ranga */
1226                 if (Rvalue > 0xffffffff)
1227                   return bfd_reloc_overflow;
1228               }
1229
1230             bfd_put_32 (input_bfd, Rvalue, hit_data);
1231           }
1232         break;
1233
1234       default:
1235         return bfd_reloc_notsupported;
1236     }
1237
1238   return bfd_reloc_ok;
1239 }
1240
1241 /* Delete some bytes from a section while relaxing.  */
1242
1243 static bfd_boolean
1244 elf32_cr16_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd,
1245                                asection *sec, bfd_vma addr, int count)
1246 {
1247   Elf_Internal_Shdr *symtab_hdr;
1248   unsigned int sec_shndx;
1249   bfd_byte *contents;
1250   Elf_Internal_Rela *irel, *irelend;
1251   bfd_vma toaddr;
1252   Elf_Internal_Sym *isym;
1253   Elf_Internal_Sym *isymend;
1254   struct elf_link_hash_entry **sym_hashes;
1255   struct elf_link_hash_entry **end_hashes;
1256   struct elf_link_hash_entry **start_hashes;
1257   unsigned int symcount;
1258
1259   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1260
1261   contents = elf_section_data (sec)->this_hdr.contents;
1262
1263   toaddr = sec->size;
1264
1265   irel = elf_section_data (sec)->relocs;
1266   irelend = irel + sec->reloc_count;
1267
1268   /* Actually delete the bytes.  */
1269   memmove (contents + addr, contents + addr + count,
1270            (size_t) (toaddr - addr - count));
1271   sec->size -= count;
1272
1273   /* Adjust all the relocs.  */
1274   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1275     /* Get the new reloc address.  */
1276     if ((irel->r_offset > addr && irel->r_offset < toaddr))
1277         irel->r_offset -= count;
1278
1279   /* Adjust the local symbols defined in this section.  */
1280   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1281   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1282   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1283     {
1284       if (isym->st_shndx == sec_shndx
1285           && isym->st_value > addr
1286           && isym->st_value < toaddr)
1287         {
1288           /* Adjust the addend of SWITCH relocations in this section,
1289              which reference this local symbol.  */
1290 #if 0
1291           for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1292             {
1293               unsigned long r_symndx;
1294               Elf_Internal_Sym *rsym;
1295               bfd_vma addsym, subsym;
1296
1297               /* Skip if not a SWITCH relocation.  */
1298               if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH8
1299                   && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH16
1300                   && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH32)
1301                  continue;
1302
1303               r_symndx = ELF32_R_SYM (irel->r_info);
1304               rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx;
1305
1306               /* Skip if not the local adjusted symbol.  */
1307               if (rsym != isym)
1308                 continue;
1309
1310               addsym = isym->st_value;
1311               subsym = addsym - irel->r_addend;
1312
1313               /* Fix the addend only when -->> (addsym > addr >= subsym).  */
1314               if (subsym <= addr)
1315                 irel->r_addend -= count;
1316               else
1317                 continue;
1318             }
1319 #endif
1320
1321           isym->st_value -= count;
1322         }
1323     }
1324
1325   /* Now adjust the global symbols defined in this section.  */
1326   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1327                - symtab_hdr->sh_info);
1328   sym_hashes = start_hashes = elf_sym_hashes (abfd);
1329   end_hashes = sym_hashes + symcount;
1330
1331   for (; sym_hashes < end_hashes; sym_hashes++)
1332     {
1333       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1334
1335       /* The '--wrap SYMBOL' option is causing a pain when the object file,
1336          containing the definition of __wrap_SYMBOL, includes a direct
1337          call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
1338          the same symbol (which is __wrap_SYMBOL), but still exist as two
1339          different symbols in 'sym_hashes', we don't want to adjust
1340          the global symbol __wrap_SYMBOL twice.
1341          This check is only relevant when symbols are being wrapped.  */
1342       if (link_info->wrap_hash != NULL)
1343         {
1344           struct elf_link_hash_entry **cur_sym_hashes;
1345
1346           /* Loop only over the symbols whom been already checked.  */
1347           for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes;
1348                cur_sym_hashes++)
1349             /* If the current symbol is identical to 'sym_hash', that means
1350                the symbol was already adjusted (or at least checked).  */
1351             if (*cur_sym_hashes == sym_hash)
1352               break;
1353
1354           /* Don't adjust the symbol again.  */
1355           if (cur_sym_hashes < sym_hashes)
1356             continue;
1357         }
1358
1359       if ((sym_hash->root.type == bfd_link_hash_defined
1360           || sym_hash->root.type == bfd_link_hash_defweak)
1361           && sym_hash->root.u.def.section == sec
1362           && sym_hash->root.u.def.value > addr
1363           && sym_hash->root.u.def.value < toaddr)
1364         sym_hash->root.u.def.value -= count;
1365     }
1366
1367   return TRUE;
1368 }
1369
1370 /* Relocate a CR16 ELF section.  */
1371
1372 static bfd_boolean
1373 elf32_cr16_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
1374                              bfd *input_bfd, asection *input_section,
1375                              bfd_byte *contents, Elf_Internal_Rela *relocs,
1376                              Elf_Internal_Sym *local_syms,
1377                              asection **local_sections)
1378 {
1379   Elf_Internal_Shdr *symtab_hdr;
1380   struct elf_link_hash_entry **sym_hashes;
1381   Elf_Internal_Rela *rel, *relend;
1382
1383   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1384   sym_hashes = elf_sym_hashes (input_bfd);
1385
1386   rel = relocs;
1387   relend = relocs + input_section->reloc_count;
1388   for (; rel < relend; rel++)
1389     {
1390       int r_type;
1391       reloc_howto_type *howto;
1392       unsigned long r_symndx;
1393       Elf_Internal_Sym *sym;
1394       asection *sec;
1395       struct elf_link_hash_entry *h;
1396       bfd_vma relocation;
1397       bfd_reloc_status_type r;
1398
1399       r_symndx = ELF32_R_SYM (rel->r_info);
1400       r_type = ELF32_R_TYPE (rel->r_info);
1401       howto = cr16_elf_howto_table + (r_type);
1402
1403       h = NULL;
1404       sym = NULL;
1405       sec = NULL;
1406       if (r_symndx < symtab_hdr->sh_info)
1407         {
1408           sym = local_syms + r_symndx;
1409           sec = local_sections[r_symndx];
1410           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1411         }
1412       else
1413         {
1414           bfd_boolean unresolved_reloc, warned, ignored;
1415
1416           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1417                                    r_symndx, symtab_hdr, sym_hashes,
1418                                    h, sec, relocation,
1419                                    unresolved_reloc, warned, ignored);
1420         }
1421
1422       if (sec != NULL && discarded_section (sec))
1423         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1424                                          rel, 1, relend, howto, 0, contents);
1425
1426       if (bfd_link_relocatable (info))
1427         continue;
1428
1429       r = cr16_elf_final_link_relocate (howto, input_bfd, output_bfd,
1430                                         input_section,
1431                                         contents, rel->r_offset,
1432                                         relocation, rel->r_addend,
1433                                         (struct elf_link_hash_entry *) h,
1434                                         r_symndx,
1435                                         info, sec, h == NULL);
1436
1437       if (r != bfd_reloc_ok)
1438         {
1439           const char *name;
1440           const char *msg = NULL;
1441
1442           if (h != NULL)
1443             name = h->root.root.string;
1444           else
1445             {
1446               name = (bfd_elf_string_from_elf_section
1447                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1448               if (name == NULL || *name == '\0')
1449                 name = bfd_section_name (input_bfd, sec);
1450             }
1451
1452           switch (r)
1453             {
1454              case bfd_reloc_overflow:
1455                (*info->callbacks->reloc_overflow)
1456                  (info, (h ? &h->root : NULL), name, howto->name,
1457                   (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1458                break;
1459
1460              case bfd_reloc_undefined:
1461                (*info->callbacks->undefined_symbol)
1462                  (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1463                break;
1464
1465              case bfd_reloc_outofrange:
1466                msg = _("internal error: out of range error");
1467                goto common_error;
1468
1469              case bfd_reloc_notsupported:
1470                msg = _("internal error: unsupported relocation error");
1471                goto common_error;
1472
1473              case bfd_reloc_dangerous:
1474                msg = _("internal error: dangerous error");
1475                goto common_error;
1476
1477              default:
1478                msg = _("internal error: unknown error");
1479                /* Fall through.  */
1480
1481              common_error:
1482                (*info->callbacks->warning) (info, msg, name, input_bfd,
1483                                             input_section, rel->r_offset);
1484                break;
1485             }
1486         }
1487     }
1488
1489   return TRUE;
1490 }
1491
1492 /* This is a version of bfd_generic_get_relocated_section_contents
1493    which uses elf32_cr16_relocate_section.  */
1494
1495 static bfd_byte *
1496 elf32_cr16_get_relocated_section_contents (bfd *output_bfd,
1497                                            struct bfd_link_info *link_info,
1498                                            struct bfd_link_order *link_order,
1499                                            bfd_byte *data,
1500                                            bfd_boolean relocatable,
1501                                            asymbol **symbols)
1502 {
1503   Elf_Internal_Shdr *symtab_hdr;
1504   asection *input_section = link_order->u.indirect.section;
1505   bfd *input_bfd = input_section->owner;
1506   asection **sections = NULL;
1507   Elf_Internal_Rela *internal_relocs = NULL;
1508   Elf_Internal_Sym *isymbuf = NULL;
1509
1510   /* We only need to handle the case of relaxing, or of having a
1511      particular set of section contents, specially.  */
1512   if (relocatable
1513       || elf_section_data (input_section)->this_hdr.contents == NULL)
1514     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1515                                                        link_order, data,
1516                                                        relocatable,
1517                                                        symbols);
1518
1519   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1520
1521   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1522           (size_t) input_section->size);
1523
1524   if ((input_section->flags & SEC_RELOC) != 0
1525       && input_section->reloc_count > 0)
1526     {
1527       Elf_Internal_Sym *isym;
1528       Elf_Internal_Sym *isymend;
1529       asection **secpp;
1530       bfd_size_type amt;
1531
1532       internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
1533                                                    NULL, NULL, FALSE);
1534       if (internal_relocs == NULL)
1535         goto error_return;
1536
1537       if (symtab_hdr->sh_info != 0)
1538         {
1539           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1540           if (isymbuf == NULL)
1541             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1542                                             symtab_hdr->sh_info, 0,
1543                                             NULL, NULL, NULL);
1544           if (isymbuf == NULL)
1545             goto error_return;
1546         }
1547
1548       amt = symtab_hdr->sh_info;
1549       amt *= sizeof (asection *);
1550       sections = bfd_malloc (amt);
1551       if (sections == NULL && amt != 0)
1552         goto error_return;
1553
1554       isymend = isymbuf + symtab_hdr->sh_info;
1555       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1556         {
1557           asection *isec;
1558
1559           if (isym->st_shndx == SHN_UNDEF)
1560             isec = bfd_und_section_ptr;
1561           else if (isym->st_shndx == SHN_ABS)
1562             isec = bfd_abs_section_ptr;
1563           else if (isym->st_shndx == SHN_COMMON)
1564             isec = bfd_com_section_ptr;
1565           else
1566             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1567
1568           *secpp = isec;
1569         }
1570
1571       if (! elf32_cr16_relocate_section (output_bfd, link_info, input_bfd,
1572                                      input_section, data, internal_relocs,
1573                                      isymbuf, sections))
1574         goto error_return;
1575
1576       if (sections != NULL)
1577         free (sections);
1578       if (isymbuf != NULL
1579           && symtab_hdr->contents != (unsigned char *) isymbuf)
1580         free (isymbuf);
1581       if (elf_section_data (input_section)->relocs != internal_relocs)
1582         free (internal_relocs);
1583     }
1584
1585   return data;
1586
1587  error_return:
1588   if (sections != NULL)
1589     free (sections);
1590   if (isymbuf != NULL
1591       && symtab_hdr->contents != (unsigned char *) isymbuf)
1592     free (isymbuf);
1593   if (internal_relocs != NULL
1594       && elf_section_data (input_section)->relocs != internal_relocs)
1595     free (internal_relocs);
1596   return NULL;
1597 }
1598
1599 /* Assorted hash table functions.  */
1600
1601 /* Initialize an entry in the link hash table.  */
1602
1603 /* Create an entry in an CR16 ELF linker hash table.  */
1604
1605 static struct bfd_hash_entry *
1606 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry *entry,
1607                               struct bfd_hash_table *table,
1608                               const char *string)
1609 {
1610   struct elf32_cr16_link_hash_entry *ret =
1611     (struct elf32_cr16_link_hash_entry *) entry;
1612
1613   /* Allocate the structure if it has not already been allocated by a
1614      subclass.  */
1615   if (ret == (struct elf32_cr16_link_hash_entry *) NULL)
1616     ret = ((struct elf32_cr16_link_hash_entry *)
1617            bfd_hash_allocate (table,
1618                               sizeof (struct elf32_cr16_link_hash_entry)));
1619   if (ret == (struct elf32_cr16_link_hash_entry *) NULL)
1620     return (struct bfd_hash_entry *) ret;
1621
1622   /* Call the allocation method of the superclass.  */
1623   ret = ((struct elf32_cr16_link_hash_entry *)
1624          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1625                                      table, string));
1626   if (ret != (struct elf32_cr16_link_hash_entry *) NULL)
1627     {
1628       ret->direct_calls = 0;
1629       ret->stack_size = 0;
1630       ret->movm_args = 0;
1631       ret->movm_stack_size = 0;
1632       ret->flags = 0;
1633       ret->value = 0;
1634     }
1635
1636   return (struct bfd_hash_entry *) ret;
1637 }
1638
1639 /* Create an cr16 ELF linker hash table.  */
1640
1641 static struct bfd_link_hash_table *
1642 elf32_cr16_link_hash_table_create (bfd *abfd)
1643 {
1644   struct elf_link_hash_table *ret;
1645   bfd_size_type amt = sizeof (struct elf_link_hash_table);
1646
1647   ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
1648   if (ret == (struct elf_link_hash_table *) NULL)
1649     return NULL;
1650
1651   if (!_bfd_elf_link_hash_table_init (ret, abfd,
1652                                       elf32_cr16_link_hash_newfunc,
1653                                       sizeof (struct elf32_cr16_link_hash_entry),
1654                                       GENERIC_ELF_DATA))
1655     {
1656       free (ret);
1657       return NULL;
1658     }
1659
1660   return &ret->root;
1661 }
1662
1663 static unsigned long
1664 elf_cr16_mach (flagword flags)
1665 {
1666   switch (flags)
1667     {
1668       case EM_CR16:
1669       default:
1670       return bfd_mach_cr16;
1671     }
1672 }
1673
1674 /* The final processing done just before writing out a CR16 ELF object
1675    file.  This gets the CR16 architecture right based on the machine
1676    number.  */
1677
1678 static void
1679 _bfd_cr16_elf_final_write_processing (bfd *abfd,
1680                                       bfd_boolean linker ATTRIBUTE_UNUSED)
1681 {
1682   unsigned long val;
1683   switch (bfd_get_mach (abfd))
1684     {
1685      default:
1686      case bfd_mach_cr16:
1687         val = EM_CR16;
1688         break;
1689     }
1690
1691
1692  elf_elfheader (abfd)->e_flags |= val;
1693 }
1694
1695
1696 static bfd_boolean
1697 _bfd_cr16_elf_object_p (bfd *abfd)
1698 {
1699   bfd_default_set_arch_mach (abfd, bfd_arch_cr16,
1700                              elf_cr16_mach (elf_elfheader (abfd)->e_flags));
1701   return TRUE;
1702 }
1703
1704 /* Merge backend specific data from an object file to the output
1705    object file when linking.  */
1706
1707 static bfd_boolean
1708 _bfd_cr16_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
1709 {
1710   bfd *obfd = info->output_bfd;
1711
1712   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1713       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1714     return TRUE;
1715
1716   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1717       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1718     {
1719       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1720                                bfd_get_mach (ibfd)))
1721          return FALSE;
1722      }
1723
1724   return TRUE;
1725 }
1726
1727
1728 /* This function handles relaxing for the CR16.
1729
1730    There's quite a few relaxing opportunites available on the CR16:
1731
1732         * bcond:24 -> bcond:16                                1 byte
1733         * bcond:16 -> bcond:8                                 1 byte
1734         * arithmetic imm32 -> arithmetic imm20                12 bits
1735         * arithmetic imm20/imm16 -> arithmetic imm4           12/16 bits
1736
1737    Symbol- and reloc-reading infrastructure copied from elf-m10200.c.  */
1738
1739 static bfd_boolean
1740 elf32_cr16_relax_section (bfd *abfd, asection *sec,
1741                           struct bfd_link_info *link_info, bfd_boolean *again)
1742 {
1743   Elf_Internal_Shdr *symtab_hdr;
1744   Elf_Internal_Rela *internal_relocs;
1745   Elf_Internal_Rela *irel, *irelend;
1746   bfd_byte *contents = NULL;
1747   Elf_Internal_Sym *isymbuf = NULL;
1748
1749   /* Assume nothing changes.  */
1750   *again = FALSE;
1751
1752   /* We don't have to do anything for a relocatable link, if
1753      this section does not have relocs, or if this is not a
1754      code section.  */
1755   if (bfd_link_relocatable (link_info)
1756       || (sec->flags & SEC_RELOC) == 0
1757       || sec->reloc_count == 0
1758       || (sec->flags & SEC_CODE) == 0)
1759     return TRUE;
1760
1761   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1762
1763   /* Get a copy of the native relocations.  */
1764   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
1765                                                link_info->keep_memory);
1766   if (internal_relocs == NULL)
1767     goto error_return;
1768
1769   /* Walk through them looking for relaxing opportunities.  */
1770   irelend = internal_relocs + sec->reloc_count;
1771   for (irel = internal_relocs; irel < irelend; irel++)
1772     {
1773       bfd_vma symval;
1774
1775       /* If this isn't something that can be relaxed, then ignore
1776          this reloc.  */
1777       if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP16
1778           && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_DISP24
1779           && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM32
1780           && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM20
1781           && ELF32_R_TYPE (irel->r_info) != (int) R_CR16_IMM16)
1782         continue;
1783
1784       /* Get the section contents if we haven't done so already.  */
1785       if (contents == NULL)
1786         {
1787           /* Get cached copy if it exists.  */
1788           if (elf_section_data (sec)->this_hdr.contents != NULL)
1789             contents = elf_section_data (sec)->this_hdr.contents;
1790           /* Go get them off disk.  */
1791           else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1792             goto error_return;
1793         }
1794
1795       /* Read this BFD's local symbols if we haven't done so already.  */
1796       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1797         {
1798           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1799           if (isymbuf == NULL)
1800             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1801                                             symtab_hdr->sh_info, 0,
1802                                             NULL, NULL, NULL);
1803           if (isymbuf == NULL)
1804             goto error_return;
1805         }
1806
1807       /* Get the value of the symbol referred to by the reloc.  */
1808       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1809         {
1810           /* A local symbol.  */
1811           Elf_Internal_Sym *isym;
1812           asection *sym_sec;
1813
1814           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1815           if (isym->st_shndx == SHN_UNDEF)
1816             sym_sec = bfd_und_section_ptr;
1817           else if (isym->st_shndx == SHN_ABS)
1818             sym_sec = bfd_abs_section_ptr;
1819           else if (isym->st_shndx == SHN_COMMON)
1820             sym_sec = bfd_com_section_ptr;
1821           else
1822             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1823           symval = (isym->st_value
1824                     + sym_sec->output_section->vma
1825                     + sym_sec->output_offset);
1826         }
1827       else
1828         {
1829           unsigned long indx;
1830           struct elf_link_hash_entry *h;
1831
1832           /* An external symbol.  */
1833           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1834           h = elf_sym_hashes (abfd)[indx];
1835           BFD_ASSERT (h != NULL);
1836
1837           if (h->root.type != bfd_link_hash_defined
1838               && h->root.type != bfd_link_hash_defweak)
1839             /* This appears to be a reference to an undefined
1840                symbol.  Just ignore it--it will be caught by the
1841                regular reloc processing.  */
1842             continue;
1843
1844           symval = (h->root.u.def.value
1845                     + h->root.u.def.section->output_section->vma
1846                     + h->root.u.def.section->output_offset);
1847         }
1848
1849       /* For simplicity of coding, we are going to modify the section
1850          contents, the section relocs, and the BFD symbol table.  We
1851          must tell the rest of the code not to free up this
1852          information.  It would be possible to instead create a table
1853          of changes which have to be made, as is done in coff-mips.c;
1854          that would be more work, but would require less memory when
1855          the linker is run.  */
1856
1857       /* Try to turn a 24  branch/call into a 16bit relative
1858          branch/call.  */
1859       if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP24)
1860         {
1861           bfd_vma value = symval;
1862
1863           /* Deal with pc-relative gunk.  */
1864           value -= (sec->output_section->vma + sec->output_offset);
1865           value -= irel->r_offset;
1866           value += irel->r_addend;
1867
1868           /* See if the value will fit in 16 bits, note the high value is
1869              0xfffe + 2 as the target will be two bytes closer if we are
1870              able to relax.  */
1871           if ((long) value < 0x10000 && (long) value > -0x10002)
1872             {
1873               unsigned int code;
1874
1875               /* Get the opcode.  */
1876               code = (unsigned int) bfd_get_32 (abfd, contents + irel->r_offset);
1877
1878               /* Verify it's a 'bcond' and fix the opcode.  */
1879               if ((code  & 0xffff) == 0x0010)
1880                 bfd_put_16 (abfd, 0x1800 | ((0xf & (code >> 20)) << 4), contents + irel->r_offset);
1881               else
1882                 continue;
1883
1884               /* Note that we've changed the relocs, section contents, etc.  */
1885               elf_section_data (sec)->relocs = internal_relocs;
1886               elf_section_data (sec)->this_hdr.contents = contents;
1887               symtab_hdr->contents = (unsigned char *) isymbuf;
1888
1889               /* Fix the relocation's type.  */
1890               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1891                                            R_CR16_DISP16);
1892
1893               /* Delete two bytes of data.  */
1894               if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1895                                                    irel->r_offset + 2, 2))
1896                 goto error_return;
1897
1898               /* That will change things, so, we should relax again.
1899                  Note that this is not required, and it may be slow.  */
1900               *again = TRUE;
1901             }
1902         }
1903
1904       /* Try to turn a 16bit pc-relative branch into an
1905          8bit pc-relative branch.  */
1906       if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_DISP16)
1907         {
1908           bfd_vma value = symval;
1909
1910           /* Deal with pc-relative gunk.  */
1911           value -= (sec->output_section->vma + sec->output_offset);
1912           value -= irel->r_offset;
1913           value += irel->r_addend;
1914
1915           /* See if the value will fit in 8 bits, note the high value is
1916              0xfc + 2 as the target will be two bytes closer if we are
1917              able to relax.  */
1918           /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */
1919           if ((long) value < 0xfa && (long) value > -0x100)
1920             {
1921               unsigned short code;
1922
1923               /* Get the opcode.  */
1924               code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1925
1926               /* Verify it's a 'bcond' and fix the opcode.  */
1927               if ((code & 0xff0f) == 0x1800)
1928                 bfd_put_16 (abfd, (code & 0xf0f0), contents + irel->r_offset);
1929               else
1930                 continue;
1931
1932               /* Note that we've changed the relocs, section contents, etc.  */
1933               elf_section_data (sec)->relocs = internal_relocs;
1934               elf_section_data (sec)->this_hdr.contents = contents;
1935               symtab_hdr->contents = (unsigned char *) isymbuf;
1936
1937               /* Fix the relocation's type.  */
1938               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1939                                            R_CR16_DISP8);
1940
1941               /* Delete two bytes of data.  */
1942               if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
1943                                                    irel->r_offset + 2, 2))
1944                 goto error_return;
1945
1946               /* That will change things, so, we should relax again.
1947                  Note that this is not required, and it may be slow.  */
1948               *again = TRUE;
1949             }
1950         }
1951
1952       /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */
1953       if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM32)
1954         {
1955           bfd_vma value = symval;
1956           unsigned short is_add_mov = 0;
1957           bfd_vma value1 = 0;
1958
1959           /* Get the existing value from the mcode */
1960           value1 = ((bfd_get_32 (abfd, contents + irel->r_offset + 2) >> 16)
1961                    |(((bfd_get_32 (abfd, contents + irel->r_offset + 2) & 0xffff) << 16)));
1962
1963           /* See if the value will fit in 20 bits.  */
1964           if ((long) (value + value1) < 0xfffff && (long) (value + value1) > 0)
1965             {
1966               unsigned short code;
1967
1968               /* Get the opcode.  */
1969               code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1970
1971               /* Verify it's a 'arithmetic ADDD or MOVD instruction'.
1972                  For ADDD and MOVD only, convert to IMM32 -> IMM20.  */
1973
1974               if (((code & 0xfff0) == 0x0070) || ((code & 0xfff0) == 0x0020))
1975                  is_add_mov = 1;
1976
1977               if (is_add_mov)
1978                 {
1979                   /* Note that we've changed the relocs, section contents,
1980                      etc.  */
1981                   elf_section_data (sec)->relocs = internal_relocs;
1982                   elf_section_data (sec)->this_hdr.contents = contents;
1983                   symtab_hdr->contents = (unsigned char *) isymbuf;
1984
1985                   /* Fix the opcode.  */
1986                   if ((code & 0xfff0) == 0x0070) /* For movd.  */
1987                     bfd_put_8 (abfd, 0x05, contents + irel->r_offset + 1);
1988                   else                           /* code == 0x0020 for addd.  */
1989                     bfd_put_8 (abfd, 0x04, contents + irel->r_offset + 1);
1990
1991                   bfd_put_8 (abfd, (code & 0xf) << 4, contents + irel->r_offset);
1992
1993                   /* If existing value is nagavive adjust approriately
1994                      place the 16-20bits (ie 4 bit) in new opcode,
1995                      as the 0xffffxxxx, the higher 2 byte values removed. */
1996                   if (value1 & 0x80000000)
1997                     bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
1998                   else
1999                     bfd_put_8 (abfd, (((value1 >> 16)&0xf) | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
2000
2001                   /* Fix the relocation's type.  */
2002                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2003                                                R_CR16_IMM20);
2004
2005                   /* Delete two bytes of data.  */
2006                   if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
2007                                                       irel->r_offset + 2, 2))
2008                     goto error_return;
2009
2010                   /* That will change things, so, we should relax again.
2011                      Note that this is not required, and it may be slow.  */
2012                   *again = TRUE;
2013                 }
2014             }
2015
2016           /* See if the value will fit in 16 bits.  */
2017           if ((!is_add_mov)
2018               && ((long)(value + value1) < 0x7fff && (long)(value + value1) > 0))
2019             {
2020               unsigned short code;
2021
2022               /* Get the opcode.  */
2023               code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
2024
2025               /* Note that we've changed the relocs, section contents, etc.  */
2026               elf_section_data (sec)->relocs = internal_relocs;
2027               elf_section_data (sec)->this_hdr.contents = contents;
2028               symtab_hdr->contents = (unsigned char *) isymbuf;
2029
2030               /* Fix the opcode.  */
2031               if ((code & 0xf0) == 0x70)          /* For movd.  */
2032                 bfd_put_8 (abfd, 0x54, contents + irel->r_offset + 1);
2033               else if ((code & 0xf0) == 0x20)     /* For addd.  */
2034                 bfd_put_8 (abfd, 0x60, contents + irel->r_offset + 1);
2035               else if ((code & 0xf0) == 0x90)     /* For cmpd.  */
2036                 bfd_put_8 (abfd, 0x56, contents + irel->r_offset + 1);
2037               else
2038                 continue;
2039
2040               bfd_put_8 (abfd, 0xb0 | (code & 0xf), contents + irel->r_offset);
2041
2042               /* If existing value is nagavive adjust approriately
2043                  place the 12-16bits (ie 4 bit) in new opcode,
2044                  as the 0xfffffxxx, the higher 2 byte values removed. */
2045               if (value1 & 0x80000000)
2046                 bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
2047               else
2048                 bfd_put_16 (abfd, value1, contents + irel->r_offset + 2);
2049
2050
2051               /* Fix the relocation's type.  */
2052               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2053                                            R_CR16_IMM16);
2054
2055               /* Delete two bytes of data.  */
2056               if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
2057                                                   irel->r_offset + 2, 2))
2058                 goto error_return;
2059
2060               /* That will change things, so, we should relax again.
2061                  Note that this is not required, and it may be slow.  */
2062               *again = TRUE;
2063             }
2064         }
2065
2066 #if 0
2067       /* Try to turn a 16bit immediate address into a 4bit
2068          immediate address.  */
2069       if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20)
2070           || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM16))
2071         {
2072           bfd_vma value = symval;
2073           bfd_vma value1 = 0;
2074
2075           /* Get the existing value from the mcode */
2076           value1 = ((bfd_get_16 (abfd, contents + irel->r_offset + 2) & 0xffff));
2077
2078           if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20)
2079             {
2080               value1 |= ((bfd_get_16 (abfd, contents + irel->r_offset + 1) & 0xf000) << 0x4);
2081             }
2082
2083           /* See if the value will fit in 4 bits.  */
2084           if ((((long) (value + value1)) < 0xf)
2085               && (((long) (value + value1)) > 0))
2086             {
2087               unsigned short code;
2088
2089               /* Get the opcode.  */
2090               code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
2091
2092               /* Note that we've changed the relocs, section contents, etc.  */
2093               elf_section_data (sec)->relocs = internal_relocs;
2094               elf_section_data (sec)->this_hdr.contents = contents;
2095               symtab_hdr->contents = (unsigned char *) isymbuf;
2096
2097               /* Fix the opcode.  */
2098               if (((code & 0x0f00) == 0x0400) || ((code & 0x0f00) == 0x0500))
2099                 {
2100                   if ((code & 0x0f00) == 0x0400)      /* For movd imm20.  */
2101                     bfd_put_8 (abfd, 0x60, contents + irel->r_offset);
2102                   else                                /* For addd imm20.  */
2103                     bfd_put_8 (abfd, 0x54, contents + irel->r_offset);
2104                   bfd_put_8 (abfd, (code & 0xf0) >> 4, contents + irel->r_offset + 1);
2105                 }
2106               else
2107                 {
2108                   if ((code & 0xfff0) == 0x56b0)       /*  For cmpd imm16.  */
2109                     bfd_put_8 (abfd, 0x56, contents + irel->r_offset);
2110                   else if ((code & 0xfff0) == 0x54b0)  /*  For movd imm16.  */
2111                     bfd_put_8 (abfd, 0x54, contents + irel->r_offset);
2112                   else if ((code & 0xfff0) == 0x58b0)  /*  For movb imm16.  */
2113                     bfd_put_8 (abfd, 0x58, contents + irel->r_offset);
2114                   else if ((code & 0xfff0) == 0x5Ab0)  /*  For movw imm16.  */
2115                     bfd_put_8 (abfd, 0x5A, contents + irel->r_offset);
2116                   else if ((code & 0xfff0) == 0x60b0)  /*  For addd imm16.  */
2117                     bfd_put_8 (abfd, 0x60, contents + irel->r_offset);
2118                   else if ((code & 0xfff0) == 0x30b0)  /*  For addb imm16.  */
2119                     bfd_put_8 (abfd, 0x30, contents + irel->r_offset);
2120                   else if ((code & 0xfff0) == 0x2Cb0)  /*  For addub imm16.  */
2121                     bfd_put_8 (abfd, 0x2C, contents + irel->r_offset);
2122                   else if ((code & 0xfff0) == 0x32b0)  /*  For adduw imm16.  */
2123                     bfd_put_8 (abfd, 0x32, contents + irel->r_offset);
2124                   else if ((code & 0xfff0) == 0x38b0)  /*  For subb imm16.  */
2125                     bfd_put_8 (abfd, 0x38, contents + irel->r_offset);
2126                   else if ((code & 0xfff0) == 0x3Cb0)  /*  For subcb imm16.  */
2127                     bfd_put_8 (abfd, 0x3C, contents + irel->r_offset);
2128                   else if ((code & 0xfff0) == 0x3Fb0)  /*  For subcw imm16.  */
2129                     bfd_put_8 (abfd, 0x3F, contents + irel->r_offset);
2130                   else if ((code & 0xfff0) == 0x3Ab0)  /*  For subw imm16.  */
2131                     bfd_put_8 (abfd, 0x3A, contents + irel->r_offset);
2132                   else if ((code & 0xfff0) == 0x50b0)  /*  For cmpb imm16.  */
2133                     bfd_put_8 (abfd, 0x50, contents + irel->r_offset);
2134                   else if ((code & 0xfff0) == 0x52b0)  /*  For cmpw imm16.  */
2135                     bfd_put_8 (abfd, 0x52, contents + irel->r_offset);
2136                   else
2137                     continue;
2138
2139                   bfd_put_8 (abfd, (code & 0xf), contents + irel->r_offset + 1);
2140                 }
2141
2142               /* Fix the relocation's type.  */
2143               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2144                                            R_CR16_IMM4);
2145
2146               /* Delete two bytes of data.  */
2147               if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
2148                                                   irel->r_offset + 2, 2))
2149                 goto error_return;
2150
2151               /* That will change things, so, we should relax again.
2152                  Note that this is not required, and it may be slow.  */
2153               *again = TRUE;
2154             }
2155         }
2156 #endif
2157     }
2158
2159   if (isymbuf != NULL
2160       && symtab_hdr->contents != (unsigned char *) isymbuf)
2161     {
2162       if (! link_info->keep_memory)
2163         free (isymbuf);
2164       else
2165        /* Cache the symbols for elf_link_input_bfd.  */
2166        symtab_hdr->contents = (unsigned char *) isymbuf;
2167     }
2168
2169   if (contents != NULL
2170       && elf_section_data (sec)->this_hdr.contents != contents)
2171     {
2172       if (! link_info->keep_memory)
2173         free (contents);
2174       else
2175        /* Cache the section contents for elf_link_input_bfd.  */
2176        elf_section_data (sec)->this_hdr.contents = contents;
2177
2178     }
2179
2180   if (internal_relocs != NULL
2181       && elf_section_data (sec)->relocs != internal_relocs)
2182     free (internal_relocs);
2183
2184   return TRUE;
2185
2186  error_return:
2187   if (isymbuf != NULL
2188       && symtab_hdr->contents != (unsigned char *) isymbuf)
2189     free (isymbuf);
2190   if (contents != NULL
2191       && elf_section_data (sec)->this_hdr.contents != contents)
2192     free (contents);
2193   if (internal_relocs != NULL
2194       && elf_section_data (sec)->relocs != internal_relocs)
2195     free (internal_relocs);
2196
2197   return FALSE;
2198 }
2199
2200 static asection *
2201 elf32_cr16_gc_mark_hook (asection *sec,
2202                          struct bfd_link_info *info,
2203                          Elf_Internal_Rela *rel,
2204                          struct elf_link_hash_entry *h,
2205                          Elf_Internal_Sym *sym)
2206 {
2207   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2208 }
2209
2210 /* Create dynamic sections when linking against a dynamic object.  */
2211
2212 static bfd_boolean
2213 _bfd_cr16_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2214 {
2215   flagword   flags;
2216   asection * s;
2217   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
2218   struct elf_link_hash_table *htab = elf_hash_table (info);
2219   int ptralign = 0;
2220
2221   switch (bed->s->arch_size)
2222     {
2223     case 16:
2224       ptralign = 1;
2225       break;
2226
2227     case 32:
2228       ptralign = 2;
2229       break;
2230
2231     default:
2232       bfd_set_error (bfd_error_bad_value);
2233       return FALSE;
2234     }
2235
2236   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2237      .rel[a].bss sections.  */
2238
2239   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2240            | SEC_LINKER_CREATED);
2241
2242   s = bfd_make_section_anyway_with_flags (abfd,
2243                                           (bed->default_use_rela_p
2244                                            ? ".rela.plt" : ".rel.plt"),
2245                                           flags | SEC_READONLY);
2246   htab->srelplt = s;
2247   if (s == NULL
2248       || ! bfd_set_section_alignment (abfd, s, ptralign))
2249     return FALSE;
2250
2251   if (! _bfd_cr16_elf_create_got_section (abfd, info))
2252     return FALSE;
2253
2254   if (bed->want_dynbss)
2255     {
2256       /* The .dynbss section is a place to put symbols which are defined
2257          by dynamic objects, are referenced by regular objects, and are
2258          not functions.  We must allocate space for them in the process
2259          image and use a R_*_COPY reloc to tell the dynamic linker to
2260          initialize them at run time.  The linker script puts the .dynbss
2261          section into the .bss section of the final image.  */
2262       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2263                                               SEC_ALLOC | SEC_LINKER_CREATED);
2264       if (s == NULL)
2265         return FALSE;
2266
2267       /* The .rel[a].bss section holds copy relocs.  This section is not
2268          normally needed.  We need to create it here, though, so that the
2269          linker will map it to an output section.  We can't just create it
2270          only if we need it, because we will not know whether we need it
2271          until we have seen all the input files, and the first time the
2272          main linker code calls BFD after examining all the input files
2273          (size_dynamic_sections) the input sections have already been
2274          mapped to the output sections.  If the section turns out not to
2275          be needed, we can discard it later.  We will never need this
2276          section when generating a shared object, since they do not use
2277          copy relocs.  */
2278       if (! bfd_link_executable (info))
2279         {
2280           s = bfd_make_section_anyway_with_flags (abfd,
2281                                                   (bed->default_use_rela_p
2282                                                    ? ".rela.bss" : ".rel.bss"),
2283                                                   flags | SEC_READONLY);
2284           if (s == NULL
2285               || ! bfd_set_section_alignment (abfd, s, ptralign))
2286             return FALSE;
2287         }
2288     }
2289
2290   return TRUE;
2291 }
2292 \f
2293 /* Adjust a symbol defined by a dynamic object and referenced by a
2294    regular object.  The current definition is in some section of the
2295    dynamic object, but we're not including those sections.  We have to
2296    change the definition to something the rest of the link can
2297    understand.  */
2298
2299 static bfd_boolean
2300 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
2301                                      struct elf_link_hash_entry * h)
2302 {
2303   bfd * dynobj;
2304   asection * s;
2305
2306   dynobj = elf_hash_table (info)->dynobj;
2307
2308   /* Make sure we know what is going on here.  */
2309   BFD_ASSERT (dynobj != NULL
2310               && (h->needs_plt
2311                   || h->u.weakdef != NULL
2312                   || (h->def_dynamic
2313                       && h->ref_regular
2314                       && !h->def_regular)));
2315
2316   /* If this is a function, put it in the procedure linkage table.  We
2317      will fill in the contents of the procedure linkage table later,
2318      when we know the address of the .got section.  */
2319   if (h->type == STT_FUNC
2320       || h->needs_plt)
2321     {
2322       if (! bfd_link_executable (info)
2323           && !h->def_dynamic
2324           && !h->ref_dynamic)
2325         {
2326           /* This case can occur if we saw a PLT reloc in an input
2327              file, but the symbol was never referred to by a dynamic
2328              object.  In such a case, we don't actually need to build
2329              a procedure linkage table, and we can just do a REL32
2330              reloc instead.  */
2331           BFD_ASSERT (h->needs_plt);
2332           return TRUE;
2333         }
2334
2335       /* Make sure this symbol is output as a dynamic symbol.  */
2336       if (h->dynindx == -1)
2337         {
2338           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2339             return FALSE;
2340         }
2341
2342       /* We also need to make an entry in the .got.plt section, which
2343          will be placed in the .got section by the linker script.  */
2344
2345       s = elf_hash_table (info)->sgotplt;
2346       BFD_ASSERT (s != NULL);
2347       s->size += 4;
2348
2349       /* We also need to make an entry in the .rela.plt section.  */
2350
2351       s = elf_hash_table (info)->srelplt;
2352       BFD_ASSERT (s != NULL);
2353       s->size += sizeof (Elf32_External_Rela);
2354
2355       return TRUE;
2356     }
2357
2358   /* If this is a weak symbol, and there is a real definition, the
2359      processor independent code will have arranged for us to see the
2360      real definition first, and we can just use the same value.  */
2361   if (h->u.weakdef != NULL)
2362     {
2363       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2364                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2365       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2366       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2367       return TRUE;
2368     }
2369
2370   /* This is a reference to a symbol defined by a dynamic object which
2371      is not a function.  */
2372
2373   /* If we are creating a shared library, we must presume that the
2374      only references to the symbol are via the global offset table.
2375      For such cases we need not do anything here; the relocations will
2376      be handled correctly by relocate_section.  */
2377   if (bfd_link_executable (info))
2378     return TRUE;
2379
2380   /* If there are no references to this symbol that do not use the
2381      GOT, we don't need to generate a copy reloc.  */
2382   if (!h->non_got_ref)
2383     return TRUE;
2384
2385   /* We must allocate the symbol in our .dynbss section, which will
2386      become part of the .bss section of the executable.  There will be
2387      an entry for this symbol in the .dynsym section.  The dynamic
2388      object will contain position independent code, so all references
2389      from the dynamic object to this symbol will go through the global
2390      offset table.  The dynamic linker will use the .dynsym entry to
2391      determine the address it must put in the global offset table, so
2392      both the dynamic object and the regular object will refer to the
2393      same memory location for the variable.  */
2394
2395   s = bfd_get_linker_section (dynobj, ".dynbss");
2396   BFD_ASSERT (s != NULL);
2397
2398   /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2399      copy the initial value out of the dynamic object and into the
2400      runtime process image.  We need to remember the offset into the
2401      .rela.bss section we are going to use.  */
2402   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2403     {
2404       asection * srel;
2405
2406       srel = bfd_get_linker_section (dynobj, ".rela.bss");
2407       BFD_ASSERT (srel != NULL);
2408       srel->size += sizeof (Elf32_External_Rela);
2409       h->needs_copy = 1;
2410     }
2411
2412   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2413 }
2414
2415 /* Set the sizes of the dynamic sections.  */
2416
2417 static bfd_boolean
2418 _bfd_cr16_elf_size_dynamic_sections (bfd * output_bfd,
2419                                      struct bfd_link_info * info)
2420 {
2421   bfd * dynobj;
2422   asection * s;
2423   bfd_boolean plt;
2424   bfd_boolean relocs;
2425   bfd_boolean reltext;
2426
2427   dynobj = elf_hash_table (info)->dynobj;
2428   BFD_ASSERT (dynobj != NULL);
2429
2430   if (elf_hash_table (info)->dynamic_sections_created)
2431     {
2432       /* Set the contents of the .interp section to the interpreter.  */
2433       if (bfd_link_executable (info) && !info->nointerp)
2434         {
2435 #if 0
2436           s = bfd_get_linker_section (dynobj, ".interp");
2437           BFD_ASSERT (s != NULL);
2438           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2439           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2440 #endif
2441         }
2442     }
2443   else
2444     {
2445       /* We may have created entries in the .rela.got section.
2446          However, if we are not creating the dynamic sections, we will
2447          not actually use these entries.  Reset the size of .rela.got,
2448          which will cause it to get stripped from the output file
2449          below.  */
2450       s = elf_hash_table (info)->srelgot;
2451       if (s != NULL)
2452         s->size = 0;
2453     }
2454
2455   /* The check_relocs and adjust_dynamic_symbol entry points have
2456      determined the sizes of the various dynamic sections.  Allocate
2457      memory for them.  */
2458   plt = FALSE;
2459   relocs = FALSE;
2460   reltext = FALSE;
2461   for (s = dynobj->sections; s != NULL; s = s->next)
2462     {
2463       const char * name;
2464
2465       if ((s->flags & SEC_LINKER_CREATED) == 0)
2466         continue;
2467
2468       /* It's OK to base decisions on the section name, because none
2469          of the dynobj section names depend upon the input files.  */
2470       name = bfd_get_section_name (dynobj, s);
2471
2472       if (strcmp (name, ".plt") == 0)
2473         {
2474           /* Remember whether there is a PLT.  */
2475           plt = s->size != 0;
2476         }
2477       else if (CONST_STRNEQ (name, ".rela"))
2478         {
2479           if (s->size != 0)
2480             {
2481               asection * target;
2482
2483               /* Remember whether there are any reloc sections other
2484                  than .rela.plt.  */
2485               if (strcmp (name, ".rela.plt") != 0)
2486                 {
2487                   const char * outname;
2488
2489                   relocs = TRUE;
2490
2491                   /* If this relocation section applies to a read only
2492                      section, then we probably need a DT_TEXTREL
2493                      entry.  The entries in the .rela.plt section
2494                      really apply to the .got section, which we
2495                      created ourselves and so know is not readonly.  */
2496                   outname = bfd_get_section_name (output_bfd,
2497                                                   s->output_section);
2498                   target = bfd_get_section_by_name (output_bfd, outname + 5);
2499                   if (target != NULL
2500                       && (target->flags & SEC_READONLY) != 0
2501                       && (target->flags & SEC_ALLOC) != 0)
2502                     reltext = TRUE;
2503                 }
2504
2505               /* We use the reloc_count field as a counter if we need
2506                  to copy relocs into the output file.  */
2507               s->reloc_count = 0;
2508             }
2509         }
2510       else if (! CONST_STRNEQ (name, ".got")
2511                && strcmp (name, ".dynbss") != 0)
2512         /* It's not one of our sections, so don't allocate space.  */
2513         continue;
2514
2515       if (s->size == 0)
2516         {
2517           /* If we don't need this section, strip it from the
2518              output file.  This is mostly to handle .rela.bss and
2519              .rela.plt.  We must create both sections in
2520              create_dynamic_sections, because they must be created
2521              before the linker maps input sections to output
2522              sections.  The linker does that before
2523              adjust_dynamic_symbol is called, and it is that
2524              function which decides whether anything needs to go
2525              into these sections.  */
2526           s->flags |= SEC_EXCLUDE;
2527           continue;
2528         }
2529
2530         if ((s->flags & SEC_HAS_CONTENTS) == 0)
2531           continue;
2532
2533       /* Allocate memory for the section contents.  We use bfd_zalloc
2534          here in case unused entries are not reclaimed before the
2535          section's contents are written out.  This should not happen,
2536          but this way if it does, we get a R_CR16_NONE reloc
2537          instead of garbage.  */
2538       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2539       if (s->contents == NULL)
2540         return FALSE;
2541     }
2542
2543   if (elf_hash_table (info)->dynamic_sections_created)
2544     {
2545       /* Add some entries to the .dynamic section.  We fill in the
2546          values later, in _bfd_cr16_elf_finish_dynamic_sections,
2547          but we must add the entries now so that we get the correct
2548          size for the .dynamic section.  The DT_DEBUG entry is filled
2549          in by the dynamic linker and used by the debugger.  */
2550       if (! bfd_link_executable (info))
2551         {
2552           if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
2553             return FALSE;
2554         }
2555
2556       if (plt)
2557         {
2558           if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
2559               || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2560               || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2561               || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
2562             return FALSE;
2563         }
2564
2565       if (relocs)
2566         {
2567           if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
2568               || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
2569               || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
2570                                               sizeof (Elf32_External_Rela)))
2571             return FALSE;
2572         }
2573
2574       if (reltext)
2575         {
2576           if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
2577             return FALSE;
2578         }
2579     }
2580
2581   return TRUE;
2582 }
2583
2584 /* Finish up dynamic symbol handling.  We set the contents of various
2585    dynamic sections here.  */
2586
2587 static bfd_boolean
2588 _bfd_cr16_elf_finish_dynamic_symbol (bfd * output_bfd,
2589                                      struct bfd_link_info * info,
2590                                      struct elf_link_hash_entry * h,
2591                                      Elf_Internal_Sym * sym)
2592 {
2593   bfd * dynobj;
2594
2595   dynobj = elf_hash_table (info)->dynobj;
2596
2597   if (h->got.offset != (bfd_vma) -1)
2598     {
2599       asection *        sgot;
2600       asection *        srel;
2601       Elf_Internal_Rela rel;
2602
2603       /* This symbol has an entry in the global offset table.  Set it up.  */
2604
2605       sgot = elf_hash_table (info)->sgot;
2606       srel = elf_hash_table (info)->srelgot;
2607       BFD_ASSERT (sgot != NULL && srel != NULL);
2608
2609       rel.r_offset = (sgot->output_section->vma
2610                       + sgot->output_offset
2611                       + (h->got.offset & ~1));
2612
2613       /* If this is a -Bsymbolic link, and the symbol is defined
2614          locally, we just want to emit a RELATIVE reloc.  Likewise if
2615          the symbol was forced to be local because of a version file.
2616          The entry in the global offset table will already have been
2617          initialized in the relocate_section function.  */
2618       if (bfd_link_executable (info)
2619           && (info->symbolic || h->dynindx == -1)
2620           && h->def_regular)
2621         {
2622           rel.r_info = ELF32_R_INFO (0, R_CR16_GOT_REGREL20);
2623           rel.r_addend = (h->root.u.def.value
2624                           + h->root.u.def.section->output_section->vma
2625                           + h->root.u.def.section->output_offset);
2626         }
2627       else
2628         {
2629           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2630           rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20);
2631           rel.r_addend = 0;
2632         }
2633
2634       bfd_elf32_swap_reloca_out (output_bfd, &rel,
2635                                  (bfd_byte *) ((Elf32_External_Rela *) srel->contents
2636                                                + srel->reloc_count));
2637       ++ srel->reloc_count;
2638     }
2639
2640   if (h->needs_copy)
2641     {
2642       asection *        s;
2643       Elf_Internal_Rela rel;
2644
2645       /* This symbol needs a copy reloc.  Set it up.  */
2646       BFD_ASSERT (h->dynindx != -1
2647                   && (h->root.type == bfd_link_hash_defined
2648                       || h->root.type == bfd_link_hash_defweak));
2649
2650       s = bfd_get_linker_section (dynobj, ".rela.bss");
2651       BFD_ASSERT (s != NULL);
2652
2653       rel.r_offset = (h->root.u.def.value
2654                       + h->root.u.def.section->output_section->vma
2655                       + h->root.u.def.section->output_offset);
2656       rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20);
2657       rel.r_addend = 0;
2658       bfd_elf32_swap_reloca_out (output_bfd, &rel,
2659                                  (bfd_byte *) ((Elf32_External_Rela *) s->contents
2660                                                + s->reloc_count));
2661      ++ s->reloc_count;
2662     }
2663
2664   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2665   if (h == elf_hash_table (info)->hdynamic
2666       || h == elf_hash_table (info)->hgot)
2667     sym->st_shndx = SHN_ABS;
2668
2669   return TRUE;
2670 }
2671
2672 /* Finish up the dynamic sections.  */
2673
2674 static bfd_boolean
2675 _bfd_cr16_elf_finish_dynamic_sections (bfd * output_bfd,
2676                                        struct bfd_link_info * info)
2677 {
2678   bfd *      dynobj;
2679   asection * sgot;
2680   asection * sdyn;
2681
2682   dynobj = elf_hash_table (info)->dynobj;
2683
2684   sgot = elf_hash_table (info)->sgotplt;
2685   BFD_ASSERT (sgot != NULL);
2686   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2687
2688   if (elf_hash_table (info)->dynamic_sections_created)
2689     {
2690       Elf32_External_Dyn * dyncon;
2691       Elf32_External_Dyn * dynconend;
2692
2693       BFD_ASSERT (sdyn != NULL);
2694
2695       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2696       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2697
2698       for (; dyncon < dynconend; dyncon++)
2699         {
2700           Elf_Internal_Dyn dyn;
2701           asection * s;
2702
2703           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2704
2705           switch (dyn.d_tag)
2706             {
2707             default:
2708               break;
2709
2710             case DT_PLTGOT:
2711               s = elf_hash_table (info)->sgotplt;
2712               goto get_vma;
2713
2714             case DT_JMPREL:
2715               s = elf_hash_table (info)->srelplt;
2716             get_vma:
2717               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2718               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2719               break;
2720
2721             case DT_PLTRELSZ:
2722               s = elf_hash_table (info)->srelplt;
2723               dyn.d_un.d_val = s->size;
2724               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2725               break;
2726             }
2727         }
2728
2729     }
2730
2731   /* Fill in the first three entries in the global offset table.  */
2732   if (sgot->size > 0)
2733     {
2734       if (sdyn == NULL)
2735         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2736       else
2737         bfd_put_32 (output_bfd,
2738                     sdyn->output_section->vma + sdyn->output_offset,
2739                     sgot->contents);
2740     }
2741
2742   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2743
2744   return TRUE;
2745 }
2746
2747 /* Given a .data.rel section and a .emreloc in-memory section, store
2748    relocation information into the .emreloc section which can be
2749    used at runtime to relocate the section.  This is called by the
2750    linker when the --embedded-relocs switch is used.  This is called
2751    after the add_symbols entry point has been called for all the
2752    objects, and before the final_link entry point is called.  */
2753
2754 bfd_boolean
2755 bfd_cr16_elf32_create_embedded_relocs (bfd *abfd,
2756                                        struct bfd_link_info *info,
2757                                        asection *datasec,
2758                                        asection *relsec,
2759                                        char **errmsg)
2760 {
2761   Elf_Internal_Shdr *symtab_hdr;
2762   Elf_Internal_Sym *isymbuf = NULL;
2763   Elf_Internal_Rela *internal_relocs = NULL;
2764   Elf_Internal_Rela *irel, *irelend;
2765   bfd_byte *p;
2766   bfd_size_type amt;
2767
2768   BFD_ASSERT (! bfd_link_relocatable (info));
2769
2770   *errmsg = NULL;
2771
2772   if (datasec->reloc_count == 0)
2773     return TRUE;
2774
2775   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2776
2777   /* Get a copy of the native relocations.  */
2778   internal_relocs = (_bfd_elf_link_read_relocs
2779                      (abfd, datasec, NULL, NULL, info->keep_memory));
2780   if (internal_relocs == NULL)
2781     goto error_return;
2782
2783   amt = (bfd_size_type) datasec->reloc_count * 8;
2784   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2785   if (relsec->contents == NULL)
2786     goto error_return;
2787
2788   p = relsec->contents;
2789
2790   irelend = internal_relocs + datasec->reloc_count;
2791   for (irel = internal_relocs; irel < irelend; irel++, p += 8)
2792     {
2793       asection *targetsec;
2794
2795       /* We are going to write a four byte longword into the runtime
2796        reloc section.  The longword will be the address in the data
2797        section which must be relocated.  It is followed by the name
2798        of the target section NUL-padded or truncated to 8
2799        characters.  */
2800
2801       /* We can only relocate absolute longword relocs at run time.  */
2802       if (!((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
2803           || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32)))
2804         {
2805           *errmsg = _("unsupported reloc type");
2806           bfd_set_error (bfd_error_bad_value);
2807           goto error_return;
2808         }
2809
2810       /* Get the target section referred to by the reloc.  */
2811       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2812         {
2813           /* A local symbol.  */
2814           Elf_Internal_Sym *isym;
2815
2816           /* Read this BFD's local symbols if we haven't done so already.  */
2817           if (isymbuf == NULL)
2818             {
2819               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2820               if (isymbuf == NULL)
2821                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2822                                                 symtab_hdr->sh_info, 0,
2823                                                 NULL, NULL, NULL);
2824               if (isymbuf == NULL)
2825                 goto error_return;
2826             }
2827
2828           isym = isymbuf + ELF32_R_SYM (irel->r_info);
2829           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2830         }
2831       else
2832         {
2833           unsigned long indx;
2834           struct elf_link_hash_entry *h;
2835
2836           /* An external symbol.  */
2837           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2838           h = elf_sym_hashes (abfd)[indx];
2839           BFD_ASSERT (h != NULL);
2840           if (h->root.type == bfd_link_hash_defined
2841               || h->root.type == bfd_link_hash_defweak)
2842             targetsec = h->root.u.def.section;
2843           else
2844             targetsec = NULL;
2845         }
2846
2847       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2848       memset (p + 4, 0, 4);
2849       if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
2850           && (targetsec != NULL) )
2851          strncpy ((char *) p + 4, targetsec->output_section->name, 4);
2852     }
2853
2854   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2855     free (isymbuf);
2856   if (internal_relocs != NULL
2857       && elf_section_data (datasec)->relocs != internal_relocs)
2858     free (internal_relocs);
2859   return TRUE;
2860
2861 error_return:
2862   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2863     free (isymbuf);
2864   if (internal_relocs != NULL
2865       && elf_section_data (datasec)->relocs != internal_relocs)
2866     free (internal_relocs);
2867   return FALSE;
2868 }
2869
2870
2871 /* Classify relocation types, such that combreloc can sort them
2872    properly.  */
2873
2874 static enum elf_reloc_type_class
2875 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2876                                 const asection *rel_sec ATTRIBUTE_UNUSED,
2877                                 const Elf_Internal_Rela *rela)
2878 {
2879   switch ((int) ELF32_R_TYPE (rela->r_info))
2880     {
2881     case R_CR16_GOT_REGREL20:
2882     case R_CR16_GOTC_REGREL20:
2883       return reloc_class_relative;
2884     default:
2885       return reloc_class_normal;
2886     }
2887 }
2888
2889 /* Definitions for setting CR16 target vector.  */
2890 #define TARGET_LITTLE_SYM                 cr16_elf32_vec
2891 #define TARGET_LITTLE_NAME                "elf32-cr16"
2892 #define ELF_ARCH                          bfd_arch_cr16
2893 #define ELF_MACHINE_CODE                  EM_CR16
2894 #define ELF_MACHINE_ALT1                  EM_CR16_OLD
2895 #define ELF_MAXPAGESIZE                   0x1
2896 #define elf_symbol_leading_char           '_'
2897
2898 #define bfd_elf32_bfd_reloc_type_lookup   elf_cr16_reloc_type_lookup
2899 #define bfd_elf32_bfd_reloc_name_lookup   elf_cr16_reloc_name_lookup
2900 #define elf_info_to_howto                 elf_cr16_info_to_howto
2901 #define elf_info_to_howto_rel             0
2902 #define elf_backend_relocate_section      elf32_cr16_relocate_section
2903 #define bfd_elf32_bfd_relax_section       elf32_cr16_relax_section
2904 #define bfd_elf32_bfd_get_relocated_section_contents \
2905                                 elf32_cr16_get_relocated_section_contents
2906 #define elf_backend_gc_mark_hook          elf32_cr16_gc_mark_hook
2907 #define elf_backend_can_gc_sections       1
2908 #define elf_backend_rela_normal           1
2909 #define elf_backend_check_relocs          cr16_elf_check_relocs
2910 /* So we can set bits in e_flags.  */
2911 #define elf_backend_final_write_processing \
2912                                  _bfd_cr16_elf_final_write_processing
2913 #define elf_backend_object_p     _bfd_cr16_elf_object_p
2914
2915 #define bfd_elf32_bfd_merge_private_bfd_data \
2916                                  _bfd_cr16_elf_merge_private_bfd_data
2917
2918
2919 #define bfd_elf32_bfd_link_hash_table_create \
2920                                   elf32_cr16_link_hash_table_create
2921
2922 #define elf_backend_create_dynamic_sections \
2923                                   _bfd_cr16_elf_create_dynamic_sections
2924 #define elf_backend_adjust_dynamic_symbol \
2925                                   _bfd_cr16_elf_adjust_dynamic_symbol
2926 #define elf_backend_size_dynamic_sections \
2927                                   _bfd_cr16_elf_size_dynamic_sections
2928 #define elf_backend_omit_section_dynsym \
2929       ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2930 #define elf_backend_finish_dynamic_symbol \
2931                                    _bfd_cr16_elf_finish_dynamic_symbol
2932 #define elf_backend_finish_dynamic_sections \
2933                                    _bfd_cr16_elf_finish_dynamic_sections
2934
2935 #define elf_backend_reloc_type_class   _bfd_cr16_elf_reloc_type_class
2936
2937
2938 #define elf_backend_want_got_plt        1
2939 #define elf_backend_plt_readonly        1
2940 #define elf_backend_want_plt_sym        0
2941 #define elf_backend_got_header_size     12
2942 #define elf_backend_dtrel_excludes_plt  1
2943
2944 #include "elf32-target.h"