bfd/elf32-cr16.c

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