bfd/elf32-cr16.c

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