bfd/elf32-cr16.c

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