bfd/elf32-cr16.c

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