bfd/elf32-cr16.c

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