bfd/elf32-cr16.c

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