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 = 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 /* Update the got entry reference counts for the section being removed.  */
2211
2212 static bfd_boolean
2213 elf32_cr16_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
2214                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
2215                           asection *sec ATTRIBUTE_UNUSED,
2216                           const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
2217 {
2218   /* We don't support garbage collection of GOT and PLT relocs yet.  */
2219   return TRUE;
2220 }
2221
2222 /* Create dynamic sections when linking against a dynamic object.  */
2223
2224 static bfd_boolean
2225 _bfd_cr16_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2226 {
2227   flagword   flags;
2228   asection * s;
2229   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
2230   struct elf_link_hash_table *htab = elf_hash_table (info);
2231   int ptralign = 0;
2232
2233   switch (bed->s->arch_size)
2234     {
2235     case 16:
2236       ptralign = 1;
2237       break;
2238
2239     case 32:
2240       ptralign = 2;
2241       break;
2242
2243     default:
2244       bfd_set_error (bfd_error_bad_value);
2245       return FALSE;
2246     }
2247
2248   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2249      .rel[a].bss sections.  */
2250
2251   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2252            | SEC_LINKER_CREATED);
2253
2254   s = bfd_make_section_anyway_with_flags (abfd,
2255                                           (bed->default_use_rela_p
2256                                            ? ".rela.plt" : ".rel.plt"),
2257                                           flags | SEC_READONLY);
2258   htab->srelplt = s;
2259   if (s == NULL
2260       || ! bfd_set_section_alignment (abfd, s, ptralign))
2261     return FALSE;
2262
2263   if (! _bfd_cr16_elf_create_got_section (abfd, info))
2264     return FALSE;
2265
2266   if (bed->want_dynbss)
2267     {
2268       /* The .dynbss section is a place to put symbols which are defined
2269          by dynamic objects, are referenced by regular objects, and are
2270          not functions.  We must allocate space for them in the process
2271          image and use a R_*_COPY reloc to tell the dynamic linker to
2272          initialize them at run time.  The linker script puts the .dynbss
2273          section into the .bss section of the final image.  */
2274       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2275                                               SEC_ALLOC | SEC_LINKER_CREATED);
2276       if (s == NULL)
2277         return FALSE;
2278
2279       /* The .rel[a].bss section holds copy relocs.  This section is not
2280          normally needed.  We need to create it here, though, so that the
2281          linker will map it to an output section.  We can't just create it
2282          only if we need it, because we will not know whether we need it
2283          until we have seen all the input files, and the first time the
2284          main linker code calls BFD after examining all the input files
2285          (size_dynamic_sections) the input sections have already been
2286          mapped to the output sections.  If the section turns out not to
2287          be needed, we can discard it later.  We will never need this
2288          section when generating a shared object, since they do not use
2289          copy relocs.  */
2290       if (! bfd_link_executable (info))
2291         {
2292           s = bfd_make_section_anyway_with_flags (abfd,
2293                                                   (bed->default_use_rela_p
2294                                                    ? ".rela.bss" : ".rel.bss"),
2295                                                   flags | SEC_READONLY);
2296           if (s == NULL
2297               || ! bfd_set_section_alignment (abfd, s, ptralign))
2298             return FALSE;
2299         }
2300     }
2301
2302   return TRUE;
2303 }
2304 \f
2305 /* Adjust a symbol defined by a dynamic object and referenced by a
2306    regular object.  The current definition is in some section of the
2307    dynamic object, but we're not including those sections.  We have to
2308    change the definition to something the rest of the link can
2309    understand.  */
2310
2311 static bfd_boolean
2312 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
2313                                      struct elf_link_hash_entry * h)
2314 {
2315   bfd * dynobj;
2316   asection * s;
2317
2318   dynobj = elf_hash_table (info)->dynobj;
2319
2320   /* Make sure we know what is going on here.  */
2321   BFD_ASSERT (dynobj != NULL
2322               && (h->needs_plt
2323                   || h->u.weakdef != NULL
2324                   || (h->def_dynamic
2325                       && h->ref_regular
2326                       && !h->def_regular)));
2327
2328   /* If this is a function, put it in the procedure linkage table.  We
2329      will fill in the contents of the procedure linkage table later,
2330      when we know the address of the .got section.  */
2331   if (h->type == STT_FUNC
2332       || h->needs_plt)
2333     {
2334       if (! bfd_link_executable (info)
2335           && !h->def_dynamic
2336           && !h->ref_dynamic)
2337         {
2338           /* This case can occur if we saw a PLT reloc in an input
2339              file, but the symbol was never referred to by a dynamic
2340              object.  In such a case, we don't actually need to build
2341              a procedure linkage table, and we can just do a REL32
2342              reloc instead.  */
2343           BFD_ASSERT (h->needs_plt);
2344           return TRUE;
2345         }
2346
2347       /* Make sure this symbol is output as a dynamic symbol.  */
2348       if (h->dynindx == -1)
2349         {
2350           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2351             return FALSE;
2352         }
2353
2354       /* We also need to make an entry in the .got.plt section, which
2355          will be placed in the .got section by the linker script.  */
2356
2357       s = elf_hash_table (info)->sgotplt;
2358       BFD_ASSERT (s != NULL);
2359       s->size += 4;
2360
2361       /* We also need to make an entry in the .rela.plt section.  */
2362
2363       s = elf_hash_table (info)->srelplt;
2364       BFD_ASSERT (s != NULL);
2365       s->size += sizeof (Elf32_External_Rela);
2366
2367       return TRUE;
2368     }
2369
2370   /* If this is a weak symbol, and there is a real definition, the
2371      processor independent code will have arranged for us to see the
2372      real definition first, and we can just use the same value.  */
2373   if (h->u.weakdef != NULL)
2374     {
2375       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2376                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2377       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2378       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2379       return TRUE;
2380     }
2381
2382   /* This is a reference to a symbol defined by a dynamic object which
2383      is not a function.  */
2384
2385   /* If we are creating a shared library, we must presume that the
2386      only references to the symbol are via the global offset table.
2387      For such cases we need not do anything here; the relocations will
2388      be handled correctly by relocate_section.  */
2389   if (bfd_link_executable (info))
2390     return TRUE;
2391
2392   /* If there are no references to this symbol that do not use the
2393      GOT, we don't need to generate a copy reloc.  */
2394   if (!h->non_got_ref)
2395     return TRUE;
2396
2397   /* We must allocate the symbol in our .dynbss section, which will
2398      become part of the .bss section of the executable.  There will be
2399      an entry for this symbol in the .dynsym section.  The dynamic
2400      object will contain position independent code, so all references
2401      from the dynamic object to this symbol will go through the global
2402      offset table.  The dynamic linker will use the .dynsym entry to
2403      determine the address it must put in the global offset table, so
2404      both the dynamic object and the regular object will refer to the
2405      same memory location for the variable.  */
2406
2407   s = bfd_get_linker_section (dynobj, ".dynbss");
2408   BFD_ASSERT (s != NULL);
2409
2410   /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2411      copy the initial value out of the dynamic object and into the
2412      runtime process image.  We need to remember the offset into the
2413      .rela.bss section we are going to use.  */
2414   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2415     {
2416       asection * srel;
2417
2418       srel = bfd_get_linker_section (dynobj, ".rela.bss");
2419       BFD_ASSERT (srel != NULL);
2420       srel->size += sizeof (Elf32_External_Rela);
2421       h->needs_copy = 1;
2422     }
2423
2424   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2425 }
2426
2427 /* Set the sizes of the dynamic sections.  */
2428
2429 static bfd_boolean
2430 _bfd_cr16_elf_size_dynamic_sections (bfd * output_bfd,
2431                                      struct bfd_link_info * info)
2432 {
2433   bfd * dynobj;
2434   asection * s;
2435   bfd_boolean plt;
2436   bfd_boolean relocs;
2437   bfd_boolean reltext;
2438
2439   dynobj = elf_hash_table (info)->dynobj;
2440   BFD_ASSERT (dynobj != NULL);
2441
2442   if (elf_hash_table (info)->dynamic_sections_created)
2443     {
2444       /* Set the contents of the .interp section to the interpreter.  */
2445       if (bfd_link_executable (info) && !info->nointerp)
2446         {
2447 #if 0
2448           s = bfd_get_linker_section (dynobj, ".interp");
2449           BFD_ASSERT (s != NULL);
2450           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2451           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2452 #endif
2453         }
2454     }
2455   else
2456     {
2457       /* We may have created entries in the .rela.got section.
2458          However, if we are not creating the dynamic sections, we will
2459          not actually use these entries.  Reset the size of .rela.got,
2460          which will cause it to get stripped from the output file
2461          below.  */
2462       s = elf_hash_table (info)->srelgot;
2463       if (s != NULL)
2464         s->size = 0;
2465     }
2466
2467   /* The check_relocs and adjust_dynamic_symbol entry points have
2468      determined the sizes of the various dynamic sections.  Allocate
2469      memory for them.  */
2470   plt = FALSE;
2471   relocs = FALSE;
2472   reltext = FALSE;
2473   for (s = dynobj->sections; s != NULL; s = s->next)
2474     {
2475       const char * name;
2476
2477       if ((s->flags & SEC_LINKER_CREATED) == 0)
2478         continue;
2479
2480       /* It's OK to base decisions on the section name, because none
2481          of the dynobj section names depend upon the input files.  */
2482       name = bfd_get_section_name (dynobj, s);
2483
2484       if (strcmp (name, ".plt") == 0)
2485         {
2486           /* Remember whether there is a PLT.  */
2487           plt = s->size != 0;
2488         }
2489       else if (CONST_STRNEQ (name, ".rela"))
2490         {
2491           if (s->size != 0)
2492             {
2493               asection * target;
2494
2495               /* Remember whether there are any reloc sections other
2496                  than .rela.plt.  */
2497               if (strcmp (name, ".rela.plt") != 0)
2498                 {
2499                   const char * outname;
2500
2501                   relocs = TRUE;
2502
2503                   /* If this relocation section applies to a read only
2504                      section, then we probably need a DT_TEXTREL
2505                      entry.  The entries in the .rela.plt section
2506                      really apply to the .got section, which we
2507                      created ourselves and so know is not readonly.  */
2508                   outname = bfd_get_section_name (output_bfd,
2509                                                   s->output_section);
2510                   target = bfd_get_section_by_name (output_bfd, outname + 5);
2511                   if (target != NULL
2512                       && (target->flags & SEC_READONLY) != 0
2513                       && (target->flags & SEC_ALLOC) != 0)
2514                     reltext = TRUE;
2515                 }
2516
2517               /* We use the reloc_count field as a counter if we need
2518                  to copy relocs into the output file.  */
2519               s->reloc_count = 0;
2520             }
2521         }
2522       else if (! CONST_STRNEQ (name, ".got")
2523                && strcmp (name, ".dynbss") != 0)
2524         /* It's not one of our sections, so don't allocate space.  */
2525         continue;
2526
2527       if (s->size == 0)
2528         {
2529           /* If we don't need this section, strip it from the
2530              output file.  This is mostly to handle .rela.bss and
2531              .rela.plt.  We must create both sections in
2532              create_dynamic_sections, because they must be created
2533              before the linker maps input sections to output
2534              sections.  The linker does that before
2535              adjust_dynamic_symbol is called, and it is that
2536              function which decides whether anything needs to go
2537              into these sections.  */
2538           s->flags |= SEC_EXCLUDE;
2539           continue;
2540         }
2541
2542         if ((s->flags & SEC_HAS_CONTENTS) == 0)
2543           continue;
2544
2545       /* Allocate memory for the section contents.  We use bfd_zalloc
2546          here in case unused entries are not reclaimed before the
2547          section's contents are written out.  This should not happen,
2548          but this way if it does, we get a R_CR16_NONE reloc
2549          instead of garbage.  */
2550       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2551       if (s->contents == NULL)
2552         return FALSE;
2553     }
2554
2555   if (elf_hash_table (info)->dynamic_sections_created)
2556     {
2557       /* Add some entries to the .dynamic section.  We fill in the
2558          values later, in _bfd_cr16_elf_finish_dynamic_sections,
2559          but we must add the entries now so that we get the correct
2560          size for the .dynamic section.  The DT_DEBUG entry is filled
2561          in by the dynamic linker and used by the debugger.  */
2562       if (! bfd_link_executable (info))
2563         {
2564           if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
2565             return FALSE;
2566         }
2567
2568       if (plt)
2569         {
2570           if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
2571               || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2572               || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2573               || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
2574             return FALSE;
2575         }
2576
2577       if (relocs)
2578         {
2579           if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
2580               || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
2581               || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
2582                                               sizeof (Elf32_External_Rela)))
2583             return FALSE;
2584         }
2585
2586       if (reltext)
2587         {
2588           if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
2589             return FALSE;
2590         }
2591     }
2592
2593   return TRUE;
2594 }
2595
2596 /* Finish up dynamic symbol handling.  We set the contents of various
2597    dynamic sections here.  */
2598
2599 static bfd_boolean
2600 _bfd_cr16_elf_finish_dynamic_symbol (bfd * output_bfd,
2601                                      struct bfd_link_info * info,
2602                                      struct elf_link_hash_entry * h,
2603                                      Elf_Internal_Sym * sym)
2604 {
2605   bfd * dynobj;
2606
2607   dynobj = elf_hash_table (info)->dynobj;
2608
2609   if (h->got.offset != (bfd_vma) -1)
2610     {
2611       asection *        sgot;
2612       asection *        srel;
2613       Elf_Internal_Rela rel;
2614
2615       /* This symbol has an entry in the global offset table.  Set it up.  */
2616
2617       sgot = elf_hash_table (info)->sgot;
2618       srel = elf_hash_table (info)->srelgot;
2619       BFD_ASSERT (sgot != NULL && srel != NULL);
2620
2621       rel.r_offset = (sgot->output_section->vma
2622                       + sgot->output_offset
2623                       + (h->got.offset & ~1));
2624
2625       /* If this is a -Bsymbolic link, and the symbol is defined
2626          locally, we just want to emit a RELATIVE reloc.  Likewise if
2627          the symbol was forced to be local because of a version file.
2628          The entry in the global offset table will already have been
2629          initialized in the relocate_section function.  */
2630       if (bfd_link_executable (info)
2631           && (info->symbolic || h->dynindx == -1)
2632           && h->def_regular)
2633         {
2634           rel.r_info = ELF32_R_INFO (0, R_CR16_GOT_REGREL20);
2635           rel.r_addend = (h->root.u.def.value
2636                           + h->root.u.def.section->output_section->vma
2637                           + h->root.u.def.section->output_offset);
2638         }
2639       else
2640         {
2641           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2642           rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20);
2643           rel.r_addend = 0;
2644         }
2645
2646       bfd_elf32_swap_reloca_out (output_bfd, &rel,
2647                                  (bfd_byte *) ((Elf32_External_Rela *) srel->contents
2648                                                + srel->reloc_count));
2649       ++ srel->reloc_count;
2650     }
2651
2652   if (h->needs_copy)
2653     {
2654       asection *        s;
2655       Elf_Internal_Rela rel;
2656
2657       /* This symbol needs a copy reloc.  Set it up.  */
2658       BFD_ASSERT (h->dynindx != -1
2659                   && (h->root.type == bfd_link_hash_defined
2660                       || h->root.type == bfd_link_hash_defweak));
2661
2662       s = bfd_get_linker_section (dynobj, ".rela.bss");
2663       BFD_ASSERT (s != NULL);
2664
2665       rel.r_offset = (h->root.u.def.value
2666                       + h->root.u.def.section->output_section->vma
2667                       + h->root.u.def.section->output_offset);
2668       rel.r_info = ELF32_R_INFO (h->dynindx, R_CR16_GOT_REGREL20);
2669       rel.r_addend = 0;
2670       bfd_elf32_swap_reloca_out (output_bfd, &rel,
2671                                  (bfd_byte *) ((Elf32_External_Rela *) s->contents
2672                                                + s->reloc_count));
2673      ++ s->reloc_count;
2674     }
2675
2676   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2677   if (h == elf_hash_table (info)->hdynamic
2678       || h == elf_hash_table (info)->hgot)
2679     sym->st_shndx = SHN_ABS;
2680
2681   return TRUE;
2682 }
2683
2684 /* Finish up the dynamic sections.  */
2685
2686 static bfd_boolean
2687 _bfd_cr16_elf_finish_dynamic_sections (bfd * output_bfd,
2688                                        struct bfd_link_info * info)
2689 {
2690   bfd *      dynobj;
2691   asection * sgot;
2692   asection * sdyn;
2693
2694   dynobj = elf_hash_table (info)->dynobj;
2695
2696   sgot = elf_hash_table (info)->sgotplt;
2697   BFD_ASSERT (sgot != NULL);
2698   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2699
2700   if (elf_hash_table (info)->dynamic_sections_created)
2701     {
2702       Elf32_External_Dyn * dyncon;
2703       Elf32_External_Dyn * dynconend;
2704
2705       BFD_ASSERT (sdyn != NULL);
2706
2707       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2708       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2709
2710       for (; dyncon < dynconend; dyncon++)
2711         {
2712           Elf_Internal_Dyn dyn;
2713           asection * s;
2714
2715           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2716
2717           switch (dyn.d_tag)
2718             {
2719             default:
2720               break;
2721
2722             case DT_PLTGOT:
2723               s = elf_hash_table (info)->sgotplt;
2724               goto get_vma;
2725
2726             case DT_JMPREL:
2727               s = elf_hash_table (info)->srelplt;
2728             get_vma:
2729               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2730               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2731               break;
2732
2733             case DT_PLTRELSZ:
2734               s = elf_hash_table (info)->srelplt;
2735               dyn.d_un.d_val = s->size;
2736               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2737               break;
2738             }
2739         }
2740
2741     }
2742
2743   /* Fill in the first three entries in the global offset table.  */
2744   if (sgot->size > 0)
2745     {
2746       if (sdyn == NULL)
2747         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2748       else
2749         bfd_put_32 (output_bfd,
2750                     sdyn->output_section->vma + sdyn->output_offset,
2751                     sgot->contents);
2752     }
2753
2754   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2755
2756   return TRUE;
2757 }
2758
2759 /* Given a .data.rel section and a .emreloc in-memory section, store
2760    relocation information into the .emreloc section which can be
2761    used at runtime to relocate the section.  This is called by the
2762    linker when the --embedded-relocs switch is used.  This is called
2763    after the add_symbols entry point has been called for all the
2764    objects, and before the final_link entry point is called.  */
2765
2766 bfd_boolean
2767 bfd_cr16_elf32_create_embedded_relocs (bfd *abfd,
2768                                        struct bfd_link_info *info,
2769                                        asection *datasec,
2770                                        asection *relsec,
2771                                        char **errmsg)
2772 {
2773   Elf_Internal_Shdr *symtab_hdr;
2774   Elf_Internal_Sym *isymbuf = NULL;
2775   Elf_Internal_Rela *internal_relocs = NULL;
2776   Elf_Internal_Rela *irel, *irelend;
2777   bfd_byte *p;
2778   bfd_size_type amt;
2779
2780   BFD_ASSERT (! bfd_link_relocatable (info));
2781
2782   *errmsg = NULL;
2783
2784   if (datasec->reloc_count == 0)
2785     return TRUE;
2786
2787   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2788
2789   /* Get a copy of the native relocations.  */
2790   internal_relocs = (_bfd_elf_link_read_relocs
2791                      (abfd, datasec, NULL, NULL, info->keep_memory));
2792   if (internal_relocs == NULL)
2793     goto error_return;
2794
2795   amt = (bfd_size_type) datasec->reloc_count * 8;
2796   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2797   if (relsec->contents == NULL)
2798     goto error_return;
2799
2800   p = relsec->contents;
2801
2802   irelend = internal_relocs + datasec->reloc_count;
2803   for (irel = internal_relocs; irel < irelend; irel++, p += 8)
2804     {
2805       asection *targetsec;
2806
2807       /* We are going to write a four byte longword into the runtime
2808        reloc section.  The longword will be the address in the data
2809        section which must be relocated.  It is followed by the name
2810        of the target section NUL-padded or truncated to 8
2811        characters.  */
2812
2813       /* We can only relocate absolute longword relocs at run time.  */
2814       if (!((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
2815           || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32)))
2816         {
2817           *errmsg = _("unsupported reloc type");
2818           bfd_set_error (bfd_error_bad_value);
2819           goto error_return;
2820         }
2821
2822       /* Get the target section referred to by the reloc.  */
2823       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2824         {
2825           /* A local symbol.  */
2826           Elf_Internal_Sym *isym;
2827
2828           /* Read this BFD's local symbols if we haven't done so already.  */
2829           if (isymbuf == NULL)
2830             {
2831               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2832               if (isymbuf == NULL)
2833                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2834                                                 symtab_hdr->sh_info, 0,
2835                                                 NULL, NULL, NULL);
2836               if (isymbuf == NULL)
2837                 goto error_return;
2838             }
2839
2840           isym = isymbuf + ELF32_R_SYM (irel->r_info);
2841           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2842         }
2843       else
2844         {
2845           unsigned long indx;
2846           struct elf_link_hash_entry *h;
2847
2848           /* An external symbol.  */
2849           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2850           h = elf_sym_hashes (abfd)[indx];
2851           BFD_ASSERT (h != NULL);
2852           if (h->root.type == bfd_link_hash_defined
2853               || h->root.type == bfd_link_hash_defweak)
2854             targetsec = h->root.u.def.section;
2855           else
2856             targetsec = NULL;
2857         }
2858
2859       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2860       memset (p + 4, 0, 4);
2861       if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
2862           && (targetsec != NULL) )
2863          strncpy ((char *) p + 4, targetsec->output_section->name, 4);
2864     }
2865
2866   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2867     free (isymbuf);
2868   if (internal_relocs != NULL
2869       && elf_section_data (datasec)->relocs != internal_relocs)
2870     free (internal_relocs);
2871   return TRUE;
2872
2873 error_return:
2874   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2875     free (isymbuf);
2876   if (internal_relocs != NULL
2877       && elf_section_data (datasec)->relocs != internal_relocs)
2878     free (internal_relocs);
2879   return FALSE;
2880 }
2881
2882
2883 /* Classify relocation types, such that combreloc can sort them
2884    properly.  */
2885
2886 static enum elf_reloc_type_class
2887 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2888                                 const asection *rel_sec ATTRIBUTE_UNUSED,
2889                                 const Elf_Internal_Rela *rela)
2890 {
2891   switch ((int) ELF32_R_TYPE (rela->r_info))
2892     {
2893     case R_CR16_GOT_REGREL20:
2894     case R_CR16_GOTC_REGREL20:
2895       return reloc_class_relative;
2896     default:
2897       return reloc_class_normal;
2898     }
2899 }
2900
2901 /* Definitions for setting CR16 target vector.  */
2902 #define TARGET_LITTLE_SYM                 cr16_elf32_vec
2903 #define TARGET_LITTLE_NAME                "elf32-cr16"
2904 #define ELF_ARCH                          bfd_arch_cr16
2905 #define ELF_MACHINE_CODE                  EM_CR16
2906 #define ELF_MACHINE_ALT1                  EM_CR16_OLD
2907 #define ELF_MAXPAGESIZE                   0x1
2908 #define elf_symbol_leading_char           '_'
2909
2910 #define bfd_elf32_bfd_reloc_type_lookup   elf_cr16_reloc_type_lookup
2911 #define bfd_elf32_bfd_reloc_name_lookup   elf_cr16_reloc_name_lookup
2912 #define elf_info_to_howto                 elf_cr16_info_to_howto
2913 #define elf_info_to_howto_rel             0
2914 #define elf_backend_relocate_section      elf32_cr16_relocate_section
2915 #define bfd_elf32_bfd_relax_section       elf32_cr16_relax_section
2916 #define bfd_elf32_bfd_get_relocated_section_contents \
2917                                 elf32_cr16_get_relocated_section_contents
2918 #define elf_backend_gc_mark_hook          elf32_cr16_gc_mark_hook
2919 #define elf_backend_gc_sweep_hook         elf32_cr16_gc_sweep_hook
2920 #define elf_backend_can_gc_sections       1
2921 #define elf_backend_rela_normal           1
2922 #define elf_backend_check_relocs          cr16_elf_check_relocs
2923 /* So we can set bits in e_flags.  */
2924 #define elf_backend_final_write_processing \
2925                                  _bfd_cr16_elf_final_write_processing
2926 #define elf_backend_object_p     _bfd_cr16_elf_object_p
2927
2928 #define bfd_elf32_bfd_merge_private_bfd_data \
2929                                  _bfd_cr16_elf_merge_private_bfd_data
2930
2931
2932 #define bfd_elf32_bfd_link_hash_table_create \
2933                                   elf32_cr16_link_hash_table_create
2934
2935 #define elf_backend_create_dynamic_sections \
2936                                   _bfd_cr16_elf_create_dynamic_sections
2937 #define elf_backend_adjust_dynamic_symbol \
2938                                   _bfd_cr16_elf_adjust_dynamic_symbol
2939 #define elf_backend_size_dynamic_sections \
2940                                   _bfd_cr16_elf_size_dynamic_sections
2941 #define elf_backend_omit_section_dynsym \
2942       ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2943 #define elf_backend_finish_dynamic_symbol \
2944                                    _bfd_cr16_elf_finish_dynamic_symbol
2945 #define elf_backend_finish_dynamic_sections \
2946                                    _bfd_cr16_elf_finish_dynamic_sections
2947
2948 #define elf_backend_reloc_type_class   _bfd_cr16_elf_reloc_type_class
2949
2950
2951 #define elf_backend_want_got_plt        1
2952 #define elf_backend_plt_readonly        1
2953 #define elf_backend_want_plt_sym        0
2954 #define elf_backend_got_header_size     12
2955 #define elf_backend_dtrel_excludes_plt  1
2956
2957 #include "elf32-target.h"