bfd/elf32-cr16.c

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