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