bfd/elf32-cr16.c

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