bfd/elf32-cr16.c

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