bfd/elf32-cr16.c

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