bfd/elf32-csky.c

   1 /* 32-bit ELF support for C-SKY.
   2    Copyright (C) 1998-2022 Free Software Foundation, Inc.
   3    Contributed by C-SKY Microsystems and Mentor Graphics.
   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
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/csky.h"
  28 #include "opcode/csky.h"
  29 #include <assert.h>
  30 #include "libiberty.h"
  31 #include "elf32-csky.h"
  32
  33 /* Data structures used for merging different arch variants.
  34    V1 (510/610) and V2 (8xx) processors are incompatible, but
  35    we can merge wthin each family.  */
  36
  37 enum merge_class
  38 {
  39   CSKY_V1,
  40   CSKY_V2
  41 };
  42
  43 typedef const struct csky_arch_for_merge
  44 {
  45   const char *name;
  46   const unsigned long arch_eflag;
  47   /* The files can merge only if they are in same class.  */
  48   enum merge_class class;
  49   /* When input files have different levels,
  50      the target sets arch_eflag to the largest level file's arch_eflag.  */
  51   unsigned int class_level;
  52   /* Control whether to print warning when merging with different arch.  */
  53   unsigned int do_warning;
  54 } csky_arch_for_merge;
  55
  56 static csky_arch_for_merge csky_archs[] =
  57 {
  58   /* 510 and 610 merge to 610 without warning.  */
  59   { "ck510",  CSKY_ARCH_510,  CSKY_V1,  0, 0},
  60   { "ck610",  CSKY_ARCH_610,  CSKY_V1,  1, 0},
  61   /* 801, 802, 803, 807, 810 merge to largest one.  */
  62   { "ck801",  CSKY_ARCH_801,  CSKY_V2,  0, 1},
  63   { "ck802",  CSKY_ARCH_802,  CSKY_V2,  1, 1},
  64   { "ck803",  CSKY_ARCH_803,  CSKY_V2,  2, 1},
  65   { "ck807",  CSKY_ARCH_807,  CSKY_V2,  3, 1},
  66   { "ck810",  CSKY_ARCH_810,  CSKY_V2,  4, 1},
  67   { "ck860",  CSKY_ARCH_860,  CSKY_V2,  5, 1},
  68   { NULL, 0, 0, 0, 0}
  69 };
  70
  71 /* Return the ARCH bits out of ABFD.  */
  72 #define bfd_csky_arch(abfd) \
  73   (elf_elfheader (abfd)->e_flags & CSKY_ARCH_MASK)
  74
  75 /* Return the ABI bits out of ABFD.  */
  76 #define bfd_csky_abi(abfd) \
  77   (elf_elfheader (abfd)->e_flags & CSKY_ABI_MASK)
  78
  79
  80 /* The index of a howto-item is implicitly equal to
  81    the corresponding Relocation Type Encoding.  */
  82 static reloc_howto_type csky_elf_howto_table[] =
  83 {
  84   /* 0 */
  85   HOWTO (R_CKCORE_NONE,               /* type */
  86          0,                           /* rightshift */
  87          0,                           /* size */
  88          0,                           /* bitsize */
  89          false,                       /* pc_relative */
  90          0,                           /* bitpos */
  91          complain_overflow_dont,      /* complain_on_overflow */
  92          NULL,                        /* special_function */
  93          "R_CKCORE_NONE",             /* name */
  94          false,                       /* partial_inplace */
  95          0,                           /* src_mask */
  96          0,                           /* dst_mask */
  97          false),                      /* pcrel_offset */
  98
  99   /* 1.  */
 100   HOWTO (R_CKCORE_ADDR32,             /* type */
 101          0,                           /* rightshift */
 102          4,                           /* size */
 103          32,                          /* bitsize */
 104          false,                       /* pc_relative */
 105          0,                           /* bitpos */
 106          complain_overflow_dont,      /* complain_on_overflow */
 107          bfd_elf_generic_reloc,       /* special_function */
 108          "R_CKCORE_ADDR32",           /* name */
 109          false,                       /* partial_inplace */
 110          0,                           /* src_mask */
 111          0xffffffff,                  /* dst_mask */
 112          false),                      /* pcrel_offset */
 113
 114   /* 2: Only for csky v1.  */
 115   HOWTO (R_CKCORE_PCREL_IMM8BY4,      /* type */
 116          2,                           /* rightshift */
 117          2,                           /* size */
 118          8,                           /* bitsize */
 119          true,                        /* pc_relative */
 120          0,                           /* bitpos */
 121          complain_overflow_bitfield,  /* complain_on_overflow */
 122          NULL,                        /* special_function */
 123          "R_CKCORE_PCREL_IMM8BY4",    /* name */
 124          false,                       /* partial_inplace */
 125          0xff,                        /* src_mask */
 126          0xff,                        /* dst_mask */
 127          true),                       /* pcrel_offset */
 128
 129   /* 3: Only for csky v1.  */
 130   HOWTO (R_CKCORE_PCREL_IMM11BY2,     /* type */
 131          1,                           /* rightshift */
 132          2,                           /* size */
 133          11,                          /* bitsize */
 134          true,                        /* pc_relative */
 135          0,                           /* bitpos */
 136          complain_overflow_signed,    /* complain_on_overflow */
 137          bfd_elf_generic_reloc,       /* special_function */
 138          "R_CKCORE_PCREL_IMM11BY2",   /* name */
 139          false,                       /* partial_inplace */
 140          0x7ff,                       /* src_mask */
 141          0x7ff,                       /* dst_mask */
 142          true),                       /* pcrel_offset */
 143
 144   /* 4: DELETED.  */
 145   HOWTO (R_CKCORE_PCREL_IMM4BY2,0,0,0,0,0,0,0,"R_CKCORE_PCREL_IMM4BY2",0,0,0,0),
 146
 147   /* 5.  */
 148   HOWTO (R_CKCORE_PCREL32,            /* type */
 149          0,                           /* rightshift */
 150          4,                           /* size */
 151          32,                          /* bitsize */
 152          true,                        /* pc_relative */
 153          0,                           /* bitpos */
 154          complain_overflow_dont,      /* complain_on_overflow */
 155          bfd_elf_generic_reloc,       /* special_function */
 156          "R_CKCORE_PCREL32",          /* name */
 157          false,                       /* partial_inplace */
 158          0x0,                         /* src_mask */
 159          0xffffffff,                  /* dst_mask */
 160          true),                       /* pcrel_offset */
 161
 162   /* 6: Only for csky v1.  */
 163   HOWTO (R_CKCORE_PCREL_JSR_IMM11BY2, /* type */
 164          1,                           /* rightshift */
 165          2,                           /* size */
 166          11,                          /* bitsize */
 167          true,                        /* pc_relative */
 168          0,                           /* bitpos */
 169          complain_overflow_signed,    /* complain_on_overflow */
 170          bfd_elf_generic_reloc,       /* special_function */
 171          "R_CKCORE_PCREL_JSR_IMM11BY2", /* name */
 172          false,                       /* partial_inplace */
 173          0x7ff,                       /* src_mask */
 174          0x7ff,                       /* dst_mask */
 175          true),                       /* pcrel_offset */
 176
 177   /* 7: GNU extension to record C++ vtable member usage.  */
 178   HOWTO (R_CKCORE_GNU_VTENTRY,        /* type */
 179          0,                           /* rightshift */
 180          4,                           /* size */
 181          0,                           /* bitsize */
 182          false,                       /* pc_relative */
 183          0,                           /* bitpos */
 184          complain_overflow_dont,      /* complain_on_overflow */
 185          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 186          "R_CKCORE_GNU_VTENTRY",      /* name */
 187          false,                       /* partial_inplace */
 188          0x0,                         /* src_mask */
 189          0x0,                         /* dst_mask */
 190          false),                      /* pcrel_offset */
 191
 192   /* 8: GNU extension to record C++ vtable hierarchy.  */
 193   HOWTO (R_CKCORE_GNU_VTINHERIT,      /* type */
 194          0,                           /* rightshift */
 195          4,                           /* size */
 196          0,                           /* bitsize */
 197          false,                       /* pc_relative */
 198          0,                           /* bitpos */
 199          complain_overflow_dont,      /* complain_on_overflow */
 200          NULL,                        /* special_function */
 201          "R_CKCORE_GNU_VTINHERIT",    /* name */
 202          false,                       /* partial_inplace */
 203          0x0,                         /* src_mask */
 204          0x0,                         /* dst_mask */
 205          false),                      /* pcrel_offset */
 206
 207   /* 9.  */
 208   HOWTO (R_CKCORE_RELATIVE,           /* type */
 209          0,                           /* rightshift */
 210          4,                           /* size */
 211          32,                          /* bitsize */
 212          false,                       /* pc_relative */
 213          0,                           /* bitpos */
 214          complain_overflow_signed,    /* complain_on_overflow */
 215          bfd_elf_generic_reloc,       /* special_function */
 216          "R_CKCORE_RELATIVE",         /* name */
 217          true,                        /* partial_inplace */
 218          0x0,                         /* src_mask */
 219          0xffffffff,                  /* dst_mask */
 220          false),                      /* pcrel_offset */
 221
 222   /* 10: None.  */
 223   /* FIXME:  It is a bug that copy relocations are not implemented.  */
 224   HOWTO (R_CKCORE_COPY,               /* type */
 225          0,                           /* rightshift */
 226          4,                           /* size */
 227          32,                          /* bitsize */
 228          false,                       /* pc_relative */
 229          0,                           /* bitpos */
 230          complain_overflow_bitfield,  /* complain_on_overflow */
 231          bfd_elf_generic_reloc,       /* special_function */
 232          "R_CKCORE_COPY",             /* name */
 233          true,                        /* partial_inplace */
 234          0xffffffff,                  /* src_mask */
 235          0xffffffff,                  /* dst_mask */
 236          false),                      /* pcrel_offset */
 237
 238   /* 11: None.  */
 239   HOWTO (R_CKCORE_GLOB_DAT,0,0,0,0,0,0,0,"R_CKCORE_GLOB_DAT",0,0,0,0),
 240
 241   /* 12: None.  */
 242   HOWTO (R_CKCORE_JUMP_SLOT,0,0,0,0,0,0,0,"R_CKCORE_JUMP_SLOT",0,0,0,0),
 243
 244   /* 13.  */
 245   HOWTO (R_CKCORE_GOTOFF,             /* type */
 246          0,                           /* rightshift */
 247          4,                           /* size */
 248          32,                          /* bitsize */
 249          false,                       /* pc_relative */
 250          0,                           /* bitpos */
 251          complain_overflow_dont,      /* complain_on_overflow */
 252          bfd_elf_generic_reloc,       /* special_function */
 253          "R_CKCORE_GOTOFF",           /* name */
 254          true,                        /* partial_inplace */
 255          0x0,                         /* src_mask */
 256          0xffffffffl,                 /* dst_mask */
 257          false),                      /* pcrel_offset */
 258
 259   /* 14.  */
 260   HOWTO (R_CKCORE_GOTPC,              /* type */
 261          0,                           /* rightshift */
 262          4,                           /* size */
 263          32,                          /* bitsize */
 264          true,                        /* pc_relative */
 265          0,                           /* bitpos */
 266          complain_overflow_dont,      /* complain_on_overflow */
 267          bfd_elf_generic_reloc,       /* special_function */
 268          "R_CKCORE_GOTPC",            /* name */
 269          true,                        /* partial_inplace */
 270          0x0,                         /* src_mask */
 271          0xffffffff,                  /* dst_mask */
 272          false),                      /* pcrel_offset */
 273
 274   /* 15.  */
 275   HOWTO (R_CKCORE_GOT32,              /* type */
 276          0,                           /* rightshift */
 277          4,                           /* size */
 278          32,                          /* bitsize */
 279          false,                       /* pc_relative */
 280          0,                           /* bitpos */
 281          complain_overflow_dont,      /* complain_on_overflow */
 282          bfd_elf_generic_reloc,       /* special_function */
 283          "R_CKCORE_GOT32",            /* name */
 284          true,                        /* partial_inplace */
 285          0x0,                         /* src_mask */
 286          0xffffffff,                  /* dst_mask */
 287          true),                       /* pcrel_offset */
 288
 289   /* 16.  */
 290   HOWTO (R_CKCORE_PLT32,              /* type */
 291          0,                           /* rightshift */
 292          4,                           /* size */
 293          32,                          /* bitsize */
 294          false,                       /* pc_relative */
 295          0,                           /* bitpos */
 296          complain_overflow_dont,      /* complain_on_overflow */
 297          bfd_elf_generic_reloc,       /* special_function */
 298          "R_CKCORE_PLT32",            /* name */
 299          true,                        /* partial_inplace */
 300          0x0,                         /* src_mask */
 301          0xffffffff,                  /* dst_mask */
 302          true),                       /* pcrel_offset */
 303
 304   /* 17: None.  */
 305   HOWTO (R_CKCORE_ADDRGOT,0,0,0,0,0,0,0,"R_CKCORE_ADDRGOT",0,0,0,0),
 306
 307   /* 18: None.  */
 308   HOWTO (R_CKCORE_ADDRPLT,0,0,0,0,0,0,0,"R_CKCORE_ADDRPLT",0,0,0,0),
 309
 310   /* 19: Only for csky v2.  */
 311   HOWTO (R_CKCORE_PCREL_IMM26BY2,     /* type */
 312          1,                           /* rightshift */
 313          4,                           /* size */
 314          26,                          /* bitsize */
 315          true,                        /* pc_relative */
 316          0,                           /* bitpos */
 317          complain_overflow_signed,    /* complain_on_overflow */
 318          bfd_elf_generic_reloc,       /* special_function */
 319          "R_CKCORE_PCREL_IMM26BY2",   /* name */
 320          false,                       /* partial_inplace */
 321          0x0,                         /* src_mask */
 322          0x3ffffff,                   /* dst_mask */
 323          true),                       /* pcrel_offset */
 324
 325   /* 20: Only for csky v2.  */
 326   HOWTO (R_CKCORE_PCREL_IMM16BY2,     /* type */
 327          1,                           /* rightshift */
 328          4,                           /* size */
 329          16,                          /* bitsize */
 330          true,                        /* pc_relative */
 331          0,                           /* bitpos */
 332          complain_overflow_signed,    /* complain_on_overflow */
 333          bfd_elf_generic_reloc,       /* special_function */
 334          "R_CKCORE_PCREL_IMM16BY2",   /* name */
 335          false,                       /* partial_inplace */
 336          0x0,                         /* src_mask */
 337          0xffff,                      /* dst_mask */
 338          true),                       /* pcrel_offset */
 339
 340   /* 21: Only for csky v2.  */
 341   HOWTO (R_CKCORE_PCREL_IMM16BY4,     /* type */
 342          2,                           /* rightshift */
 343          4,                           /* size */
 344          16,                          /* bitsize */
 345          true,                        /* pc_relative */
 346          0,                           /* bitpos */
 347          complain_overflow_bitfield,  /* complain_on_overflow */
 348          bfd_elf_generic_reloc,       /* special_function */
 349          "R_CKCORE_PCREL_IMM16BY4",   /* name */
 350          false,                       /* partial_inplace */
 351          0xffff0000,                  /* src_mask */
 352          0xffff,                      /* dst_mask */
 353          true),                       /* pcrel_offset */
 354
 355   /* 22: Only for csky v2.  */
 356   HOWTO (R_CKCORE_PCREL_IMM10BY2,     /* type */
 357          1,                           /* rightshift */
 358          2,                           /* size */
 359          10,                          /* bitsize */
 360          true,                        /* pc_relative */
 361          0,                           /* bitpos */
 362          complain_overflow_signed,    /* complain_on_overflow */
 363          bfd_elf_generic_reloc,       /* special_function */
 364          "R_CKCORE_PCREL_IMM10BY2",   /* name */
 365          false,                       /* partial_inplace */
 366          0x0,                         /* src_mask */
 367          0x3ff,                       /* dst_mask */
 368          true),                       /* pcrel_offset */
 369
 370   /* 23: Only for csky v2.  */
 371   HOWTO (R_CKCORE_PCREL_IMM10BY4,     /* type */
 372          2,                           /* rightshift */
 373          4,                           /* size */
 374          10,                          /* bitsize */
 375          true,                        /* pc_relative */
 376          0,                           /* bitpos */
 377          complain_overflow_bitfield,  /* complain_on_overflow */
 378          bfd_elf_generic_reloc,       /* special_function */
 379          "R_CKCORE_PCREL_IMM10BY4",   /* name */
 380          false,                       /* partial_inplace */
 381          0x0,                         /* src_mask */
 382          0x3ff,                       /* dst_mask */
 383          true),                       /* pcrel_offset */
 384
 385   /* 24: Only for csky v2.  */
 386   HOWTO (R_CKCORE_ADDR_HI16,          /* type */
 387          16,                          /* rightshift */
 388          4,                           /* size */
 389          16,                          /* bitsize */
 390          false,                       /* pc_relative */
 391          0,                           /* bitpos */
 392          complain_overflow_dont,      /* complain_on_overflow */
 393          bfd_elf_generic_reloc,       /* special_function */
 394          "R_CKCORE_ADDR_HI16",        /* name */
 395          false,                       /* partial_inplace */
 396          0x0,                         /* src_mask */
 397          0xffff,                      /* dst_mask */
 398          false),                      /* pcrel_offset */
 399
 400   /* 25.  */
 401   HOWTO (R_CKCORE_ADDR_LO16,          /* type */
 402          0,                           /* rightshift */
 403          4,                           /* size */
 404          16,                          /* bitsize */
 405          false,                       /* pc_relative */
 406          0,                           /* bitpos */
 407          complain_overflow_dont,      /* complain_on_overflow */
 408          bfd_elf_generic_reloc,       /* special_function */
 409          "R_CKCORE_ADDR_LO16",        /* name */
 410          false,                       /* partial_inplace */
 411          0x0,                         /* src_mask */
 412          0xffff,                      /* dst_mask */
 413          false),                      /* pcrel_offset */
 414
 415   /* 26.  */
 416   HOWTO (R_CKCORE_GOTPC_HI16,         /* type */
 417          16,                          /* rightshift */
 418          4,                           /* size */
 419          16,                          /* bitsize */
 420          true,                        /* pc_relative */
 421          0,                           /* bitpos */
 422          complain_overflow_dont,      /* complain_on_overflow */
 423          bfd_elf_generic_reloc,       /* special_function */
 424          "R_CKCORE_GOTPC_HI16",       /* name */
 425          false,                       /* partial_inplace */
 426          0x0,                         /* src_mask */
 427          0xffff,                      /* dst_mask */
 428          false),                      /* pcrel_offset */
 429
 430   /* 27.  */
 431   HOWTO (R_CKCORE_GOTPC_LO16,         /* type */
 432          0,                           /* rightshift */
 433          4,                           /* size */
 434          16,                          /* bitsize */
 435          true,                        /* pc_relative */
 436          0,                           /* bitpos */
 437          complain_overflow_dont,      /* complain_on_overflow */
 438          bfd_elf_generic_reloc,       /* special_function */
 439          "R_CKCORE_GOTPC_LO16",       /* name */
 440          false,                       /* partial_inplace */
 441          0x0,                         /* src_mask */
 442          0xffff,                      /* dst_mask */
 443          false),                      /* pcrel_offset */
 444
 445   /* 28.  */
 446   HOWTO (R_CKCORE_GOTOFF_HI16,        /* type */
 447          16,                          /* rightshift */
 448          4,                           /* size */
 449          16,                          /* bitsize */
 450          false,                       /* pc_relative */
 451          0,                           /* bitpos */
 452          complain_overflow_dont,      /* complain_on_overflow */
 453          bfd_elf_generic_reloc,       /* special_function */
 454          "R_CKCORE_GOTOFF_HI16",      /* name */
 455          false,                       /* partial_inplace */
 456          0x0,                         /* src_mask */
 457          0xffff,                      /* dst_mask */
 458          false),                      /* pcrel_offset */
 459
 460   /* 29.  */
 461   HOWTO (R_CKCORE_GOTOFF_LO16,        /* type */
 462          0,                           /* rightshift */
 463          4,                           /* size */
 464          16,                          /* bitsize */
 465          false,                       /* pc_relative */
 466          0,                           /* bitpos */
 467          complain_overflow_dont,      /* complain_on_overflow */
 468          bfd_elf_generic_reloc,       /* special_function */
 469          "R_CKCORE_GOTOFF_LO16",      /* name */
 470          false,                       /* partial_inplace */
 471          0x0,                         /* src_mask */
 472          0xffff,                      /* dst_mask */
 473          false),                      /* pcrel_offset */
 474
 475   /* 30.  */
 476   HOWTO (R_CKCORE_GOT12,              /* type */
 477          2,                           /* rightshift */
 478          4,                           /* size */
 479          12,                          /* bitsize */
 480          false,                       /* pc_relative */
 481          0,                           /* bitpos */
 482          complain_overflow_bitfield,  /* complain_on_overflow */
 483          bfd_elf_generic_reloc,       /* special_function */
 484          "R_CKCORE_GOT12",            /* name */
 485          true,                        /* partial_inplace */
 486          0x0,                         /* src_mask */
 487          0xfff,                       /* dst_mask */
 488          false),                      /* pcrel_offset */
 489
 490   /* 31.  */
 491   HOWTO (R_CKCORE_GOT_HI16,           /* type */
 492          16,                          /* rightshift */
 493          4,                           /* size */
 494          16,                          /* bitsize */
 495          false,                       /* pc_relative */
 496          0,                           /* bitpos */
 497          complain_overflow_dont,      /* complain_on_overflow */
 498          bfd_elf_generic_reloc,       /* special_function */
 499          "R_CKCORE_GOT_HI16",         /* name */
 500          true,                       /* partial_inplace */
 501          0x0,                         /* src_mask */
 502          0xffff,                      /* dst_mask */
 503          false),                      /* pcrel_offset */
 504
 505   /* 32.  */
 506   HOWTO (R_CKCORE_GOT_LO16,           /* type */
 507          0,                           /* rightshift */
 508          4,                           /* size */
 509          16,                          /* bitsize */
 510          false,                       /* pc_relative */
 511          0,                           /* bitpos */
 512          complain_overflow_dont,      /* complain_on_overflow */
 513          bfd_elf_generic_reloc,       /* special_function */
 514          "R_CKCORE_GOT_LO16",         /* name */
 515          true,                        /* partial_inplace */
 516          0x0,                         /* src_mask */
 517          0xffff,                      /* dst_mask */
 518          false),                      /* pcrel_offset */
 519
 520   /* 33.  */
 521   HOWTO (R_CKCORE_PLT12,              /* type */
 522          2,                           /* rightshift */
 523          4,                           /* size */
 524          12,                          /* bitsize */
 525          false,                       /* pc_relative */
 526          0,                           /* bitpos */
 527          complain_overflow_bitfield,  /* complain_on_overflow */
 528          bfd_elf_generic_reloc,       /* special_function */
 529          "R_CKCORE_PLT12",            /* name */
 530          true,                        /* partial_inplace */
 531          0x0,                         /* src_mask */
 532          0xfff,                       /* dst_mask */
 533          false),                      /* pcrel_offset */
 534
 535   /* 34.  */
 536   HOWTO (R_CKCORE_PLT_HI16,           /* type */
 537          16,                          /* rightshift */
 538          4,                           /* size */
 539          16,                          /* bitsize */
 540          false,                       /* pc_relative */
 541          0,                           /* bitpos */
 542          complain_overflow_dont,      /* complain_on_overflow */
 543          bfd_elf_generic_reloc,       /* special_function */
 544          "R_CKCORE_PLT_HI16",         /* name */
 545          true,                        /* partial_inplace */
 546          0x0,                         /* src_mask */
 547          0xffff,                      /* dst_mask */
 548          false),                      /* pcrel_offset */
 549
 550   /* 35.  */
 551   HOWTO (R_CKCORE_PLT_LO16,           /* type */
 552          0,                           /* rightshift */
 553          4,                           /* size */
 554          16,                          /* bitsize */
 555          false,                       /* pc_relative */
 556          0,                           /* bitpos */
 557          complain_overflow_dont,      /* complain_on_overflow */
 558          bfd_elf_generic_reloc,       /* special_function */
 559          "R_CKCORE_PLT_LO16",         /* name */
 560          true,                       /* partial_inplace */
 561          0x0,                         /* src_mask */
 562          0xffff,                      /* dst_mask */
 563          false),                      /* pcrel_offset */
 564
 565   /* 36: None.  */
 566   HOWTO (R_CKCORE_ADDRGOT_HI16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
 567
 568   /* 37: None.  */
 569   HOWTO (R_CKCORE_ADDRGOT_LO16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
 570
 571   /* 38: None.  */
 572   HOWTO (R_CKCORE_ADDRPLT_HI16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
 573
 574   /* 39: None.  */
 575   HOWTO (R_CKCORE_ADDRPLT_LO16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
 576
 577   /* 40.  */
 578   HOWTO (R_CKCORE_PCREL_JSR_IMM26BY2, /* type */
 579          1,                           /* rightshift */
 580          4,                           /* size */
 581          26,                          /* bitsize */
 582          true,                        /* pc_relative */
 583          0,                           /* bitpos */
 584          complain_overflow_signed,    /* complain_on_overflow */
 585          bfd_elf_generic_reloc,       /* special_function */
 586          "R_CKCORE_PCREL_JSR_IMM26BY2", /* name */
 587          false,                       /* partial_inplace */
 588          0x0,                         /* src_mask */
 589          0x3ffffff,                   /* dst_mask */
 590          true),                       /* pcrel_offset */
 591
 592   /* 41.  */
 593   HOWTO (R_CKCORE_TOFFSET_LO16,       /* type */
 594          0,                           /* rightshift */
 595          4,                           /* size */
 596          16,                          /* bitsize */
 597          false,                       /* pc_relative */
 598          0,                           /* bitpos */
 599          complain_overflow_unsigned,  /* complain_on_overflow */
 600          NULL,                        /* special_function */
 601          "R_CKCORE_TOFFSET_LO16",     /* name */
 602          false,                       /* partial_inplace */
 603          0x0,                         /* src_mask */
 604          0xffff,                      /* dst_mask */
 605          false),                      /* pcrel_offset */
 606
 607   /* 42.  */
 608   HOWTO (R_CKCORE_DOFFSET_LO16,       /* type */
 609          0,                           /* rightshift */
 610          4,                           /* size */
 611          16,                          /* bitsize */
 612          false,                       /* pc_relative */
 613          0,                           /* bitpos */
 614          complain_overflow_unsigned,  /* complain_on_overflow */
 615          NULL,                        /* special_function */
 616          "R_CKCORE_DOFFSET_LO16",     /* name */
 617          false,                       /* partial_inplace */
 618          0x0,                         /* src_mask */
 619          0xffff,                      /* dst_mask */
 620          false),                      /* pcrel_offset */
 621
 622   /* 43.  */
 623   HOWTO (R_CKCORE_PCREL_IMM18BY2,     /* type */
 624          1,                           /* rightshift */
 625          4,                           /* size */
 626          18,                          /* bitsize */
 627          true,                        /* pc_relative */
 628          0,                           /* bitpos */
 629          complain_overflow_signed,    /* complain_on_overflow */
 630          bfd_elf_generic_reloc,       /* special_function */
 631          "R_CKCORE_PCREL_IMM18BY2",   /* name */
 632          false,                       /* partial_inplace */
 633          0x0,                         /* src_mask */
 634          0x3ffff,                     /* dst_mask */
 635          true),                       /* pcrel_offset */
 636
 637   /* 44.  */
 638   HOWTO (R_CKCORE_DOFFSET_IMM18,      /* type */
 639          0,                           /* rightshift */
 640          4,                           /* size */
 641          18,                          /* bitsize */
 642          false,                       /* pc_relative */
 643          0,                           /* bitpos */
 644          complain_overflow_unsigned,  /* complain_on_overflow */
 645          NULL,                        /* special_function */
 646          "R_CKCORE_DOFFSET_IMM18",    /* name */
 647          false,                       /* partial_inplace */
 648          0x0,                         /* src_mask */
 649          0x3ffff,                     /* dst_mask */
 650          false),                      /* pcrel_offset */
 651
 652   /* 45.  */
 653   HOWTO (R_CKCORE_DOFFSET_IMM18BY2,   /* type */
 654          1,                           /* rightshift */
 655          4,                           /* size */
 656          18,                          /* bitsize */
 657          false,                       /* pc_relative */
 658          0,                           /* bitpos */
 659          complain_overflow_unsigned,  /* complain_on_overflow */
 660          NULL,                        /* special_function */
 661          "R_CKCORE_DOFFSET_IMM18BY2", /* name */
 662          false,                       /* partial_inplace */
 663          0x0,                         /* src_mask */
 664          0x3ffff,                     /* dst_mask */
 665          false),                      /* pcrel_offset */
 666
 667   /* 46.  */
 668   HOWTO (R_CKCORE_DOFFSET_IMM18BY4,   /* type */
 669          2,                           /* rightshift */
 670          4,                           /* size */
 671          18,                          /* bitsize */
 672          false,                       /* pc_relative */
 673          0,                           /* bitpos */
 674          complain_overflow_unsigned,  /* complain_on_overflow */
 675          NULL,                        /* special_function */
 676          "R_CKCORE_DOFFSET_IMM18BY4", /* name */
 677          false,                       /* partial_inplace */
 678          0x0,                         /* src_mask */
 679          0x3ffff,                     /* dst_mask */
 680          false),                      /* pcrel_offset */
 681
 682   /* 47.  */
 683   HOWTO (R_CKCORE_GOTOFF_IMM18,       /* type */
 684          0,                           /* rightshift */
 685          4,                           /* size */
 686          18,                          /* bitsize */
 687          false,                       /* pc_relative */
 688          0,                           /* bitpos */
 689          complain_overflow_bitfield,  /* complain_on_overflow */
 690          bfd_elf_generic_reloc,       /* special_function */
 691          "R_CKCORE_GOTOFF_IMM18",     /* name */
 692          true,                        /* partial_inplace */
 693          0xfffc,                      /* src_mask */
 694          0x3ffff,                     /* dst_mask */
 695          false),                      /* pcrel_offset */
 696
 697   /* 48.  */
 698   HOWTO (R_CKCORE_GOT_IMM18BY4,       /* type */
 699          2,                           /* rightshift */
 700          4,                           /* size */
 701          18,                          /* bitsize */
 702          false,                       /* pc_relative */
 703          0,                           /* bitpos */
 704          complain_overflow_bitfield,  /* complain_on_overflow */
 705          bfd_elf_generic_reloc,       /* special_function */
 706          "R_CKCORE_GOT_IMM18BY4",     /* name */
 707          true,                        /* partial_inplace */
 708          0xfffc,                      /* src_mask */
 709          0x3ffff,                     /* dst_mask */
 710          false),                      /* pcrel_offset */
 711
 712   /* 49.  */
 713   HOWTO (R_CKCORE_PLT_IMM18BY4,       /* type */
 714          2,                           /* rightshift */
 715          4,                           /* size */
 716          18,                          /* bitsize */
 717          false,                       /* pc_relative */
 718          0,                           /* bitpos */
 719          complain_overflow_bitfield,  /* complain_on_overflow */
 720          bfd_elf_generic_reloc,       /* special_function */
 721          "R_CKCORE_PLT_IMM18BY4",     /* name */
 722          true,                        /* partial_inplace */
 723          0xfffc,                      /* src_mask */
 724          0x3ffff,                     /* dst_mask */
 725          true),                       /* pcrel_offset */
 726
 727   /* 50: for lrw16.  */
 728   HOWTO (R_CKCORE_PCREL_IMM7BY4,      /* type */
 729          2,                           /* rightshift */
 730          2,                           /* size */
 731          7,                           /* bitsize */
 732          true,                        /* pc_relative */
 733          0,                           /* bitpos */
 734          complain_overflow_bitfield,  /* complain_on_overflow */
 735          bfd_elf_generic_reloc,       /* special_function */
 736          "R_CKCORE_PCREL_IMM7BY4",    /* name */
 737          false,                       /* partial_inplace */
 738          0xec1f,                      /* src_mask */
 739          0x31f,                       /* dst_mask */
 740          true),                       /* pcrel_offset */
 741
 742   /* 51: for static nptl.  */
 743   HOWTO (R_CKCORE_TLS_LE32,           /* type */
 744          0,                           /* rightshift */
 745          4,                           /* size */
 746          32,                          /* bitsize */
 747          false,                       /* pc_relative */
 748          0,                           /* bitpos */
 749          complain_overflow_dont,      /* complain_on_overflow */
 750          bfd_elf_generic_reloc,       /* special_function */
 751          "R_CKCORE_TLS_LE32",         /* name */
 752          false,                       /* partial_inplace */
 753          0x0,                         /* src_mask */
 754          0xffffffff,                  /* dst_mask */
 755          true),                       /* pcrel_offset */
 756
 757   /* 52: for static nptl.  */
 758   HOWTO (R_CKCORE_TLS_IE32,           /* type */
 759          0,                           /* rightshift */
 760          4,                           /* size */
 761          32,                          /* bitsize */
 762          false,                       /* pc_relative */
 763          0,                           /* bitpos */
 764          complain_overflow_dont,      /* complain_on_overflow */
 765          bfd_elf_generic_reloc,       /* special_function */
 766          "R_CKCORE_TLS_IE32",         /* name */
 767          false,                       /* partial_inplace */
 768          0x0,                         /* src_mask */
 769          0xffffffff,                  /* dst_mask */
 770          true),                       /* pcrel_offset */
 771
 772   /* 53: for pic nptl.  */
 773   HOWTO (R_CKCORE_TLS_GD32,           /* type */
 774          0,                           /* rightshift */
 775          4,                           /* size */
 776          32,                          /* bitsize */
 777          false,                       /* pc_relative */
 778          0,                           /* bitpos */
 779          complain_overflow_dont,      /* complain_on_overflow */
 780          bfd_elf_generic_reloc,       /* special_function */
 781          "R_CKCORE_TLS_GD32",         /* name */
 782          false,                       /* partial_inplace */
 783          0x0,                         /* src_mask */
 784          0xffffffff,                  /* dst_mask */
 785          true),                       /* pcrel_offset */
 786
 787   /* 54: for pic nptl.  */
 788   HOWTO (R_CKCORE_TLS_LDM32,          /* type */
 789          0,                           /* rightshift */
 790          4,                           /* size */
 791          32,                          /* bitsize */
 792          false,                       /* pc_relative */
 793          0,                           /* bitpos */
 794          complain_overflow_dont,      /* complain_on_overflow */
 795          bfd_elf_generic_reloc,       /* special_function */
 796          "R_CKCORE_TLS_LDM32",        /* name */
 797          false,                       /* partial_inplace */
 798          0x0,                         /* src_mask */
 799          0xffffffff,                  /* dst_mask */
 800          true),                       /* pcrel_offset */
 801
 802   /* 55: for pic nptl.  */
 803   HOWTO (R_CKCORE_TLS_LDO32,          /* type */
 804          0,                           /* rightshift */
 805          4,                           /* size */
 806          32,                          /* bitsize */
 807          false,                       /* pc_relative */
 808          0,                           /* bitpos */
 809          complain_overflow_dont,      /* complain_on_overflow */
 810          bfd_elf_generic_reloc,       /* special_function */
 811          "R_CKCORE_TLS_LDO32",        /* name */
 812          false,                       /* partial_inplace */
 813          0x0,                         /* src_mask */
 814          0xffffffff,                  /* dst_mask */
 815          true),                       /* pcrel_offset */
 816
 817   /* 56: for linker.  */
 818   HOWTO (R_CKCORE_TLS_DTPMOD32,0,0,0,0,0,0,0,"R_CKCORE_TLS_DTPMOD32",0,0,0,0),
 819
 820   /* 57: for linker.  */
 821   HOWTO (R_CKCORE_TLS_DTPOFF32,0,0,0,0,0,0,0,"R_CKCORE_TLS_DTPOFF32",0,0,0,0),
 822
 823   /* 58: for linker.  */
 824   HOWTO (R_CKCORE_TLS_TPOFF32,0,0,0,0,0,0,0,"R_CKCORE_TLS_TPOFF32",0,0,0,0),
 825
 826   /* 59: for ck807f.  */
 827   HOWTO (R_CKCORE_PCREL_FLRW_IMM8BY4, /* type */
 828          2,                           /* rightshift */
 829          4,                           /* size */
 830          8,                           /* bitsize */
 831          true,                        /* pc_relative */
 832          0,                           /* bitpos */
 833          complain_overflow_bitfield,  /* complain_on_overflow */
 834          bfd_elf_generic_reloc,       /* special_function */
 835          "R_CKCORE_PCREL_FLRW_IMM8BY4",/* name */
 836          false,                       /* partial_inplace */
 837          0xfe1fff0f,                  /* src_mask */
 838          0x1e000f0,                   /* dst_mask */
 839          true),                       /* pcrel_offset */
 840
 841   /* 60: for 810 not to generate jsri.  */
 842   HOWTO (R_CKCORE_NOJSRI,             /* type */
 843          0,                           /* rightshift */
 844          4,                           /* size */
 845          32,                          /* bitsize */
 846          false,                       /* pc_relative */
 847          0,                           /* bitpos */
 848          complain_overflow_dont,      /* complain_on_overflow */
 849          bfd_elf_generic_reloc,       /* special_function */
 850          "R_CKCORE_NOJSRI",           /* name */
 851          false,                       /* partial_inplace */
 852          0xffff,                      /* src_mask */
 853          0xffff,                      /* dst_mask */
 854          false),                      /* pcrel_offset */
 855
 856   /* 61: for callgraph.  */
 857   HOWTO (R_CKCORE_CALLGRAPH,          /* type */
 858          0,                           /* rightshift */
 859          0,                           /* size */
 860          0,                           /* bitsize */
 861          false,                       /* pc_relative */
 862          0,                           /* bitpos */
 863          complain_overflow_dont,      /* complain_on_overflow */
 864          NULL,                        /* special_function */
 865          "R_CKCORE_CALLGRAPH",        /* name */
 866          false,                       /* partial_inplace */
 867          0x0,                         /* src_mask */
 868          0x0,                         /* dst_mask */
 869          true),                       /* pcrel_offset */
 870
 871   /* 62: IRELATIVE*/
 872   HOWTO (R_CKCORE_IRELATIVE,0,0,0,0,0,0,0,"R_CKCORE_IRELATIVE",0,0,0,0),
 873
 874   /* 63: for bloop instruction */
 875   HOWTO (R_CKCORE_PCREL_BLOOP_IMM4BY4, /* type */
 876          1,                           /* rightshift */
 877          4,                           /* size */
 878          4,                           /* bitsize */
 879          1,                           /* pc_relative */
 880          0,                           /* bitpos */
 881          complain_overflow_signed,    /* complain_on_overflow */
 882          bfd_elf_generic_reloc,       /* special_function */
 883          "R_CKCORE_PCREL_BLOOP_IMM4BY4", /* name */
 884          false,                       /* partial_inplace */
 885          0x0,                         /* src_mask */
 886          0xf,                         /* dst_mask */
 887          true),                       /* pcrel_offset */
 888   /* 64: for bloop instruction */
 889   HOWTO (R_CKCORE_PCREL_BLOOP_IMM12BY4, /* type */
 890          1,                           /* rightshift */
 891          4,                           /* size */
 892          12,                          /* bitsize */
 893          1,                           /* pc_relative */
 894          0,                           /* bitpos */
 895          complain_overflow_signed,    /* complain_on_overflow */
 896          bfd_elf_generic_reloc,       /* special_function */
 897          "R_CKCORE_PCREL_BLOOP_IMM12BY4", /* name */
 898          false,                       /* partial_inplace */
 899          0x0,                         /* src_mask */
 900          0xfff,                       /* dst_mask */
 901          true),                       /* pcrel_offset */
 902
 903
 904 };
 905
 906
 907 /* Whether GOT overflow checking is needed.  */
 908 static int check_got_overflow = 0;
 909
 910 /* Whether the target 32 bits is forced so that the high
 911    16 bits is at the low address.  */
 912 static int need_reverse_bits;
 913
 914 /* Used for relaxation.  See csky_relocate_contents.  */
 915 static bfd_vma read_content_substitute;
 916
 917 /* NOTICE!
 918    The way the following two look-up functions work demands
 919    that BFD_RELOC_CKCORE_xxx are defined contiguously.  */
 920
 921 static reloc_howto_type *
 922 csky_elf_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 923                             bfd_reloc_code_real_type code)
 924 {
 925   int csky_code = code - BFD_RELOC_CKCORE_NONE;
 926
 927   if (csky_code < 0 || csky_code >= R_CKCORE_MAX)
 928     {
 929       switch (code)
 930         {
 931         case BFD_RELOC_NONE:
 932           csky_code = R_CKCORE_NONE;
 933           break;
 934         case BFD_RELOC_32:
 935           csky_code = R_CKCORE_ADDR32;
 936           break;
 937         case BFD_RELOC_32_PCREL:
 938           csky_code = R_CKCORE_PCREL32;
 939           break;
 940         case BFD_RELOC_VTABLE_INHERIT:
 941           csky_code = R_CKCORE_GNU_VTINHERIT;
 942           break;
 943         case BFD_RELOC_VTABLE_ENTRY:
 944           csky_code = R_CKCORE_GNU_VTENTRY;
 945           break;
 946         case BFD_RELOC_RVA:
 947           csky_code = R_CKCORE_RELATIVE;
 948           break;
 949         default:
 950           return (reloc_howto_type *)NULL;
 951         }
 952     }
 953   /* Note: when adding csky bfd reloc types in bfd-in2.h
 954      and csky elf reloc types in elf/csky.h,
 955      the order of the two reloc type tables should be consistent.  */
 956   return &csky_elf_howto_table[csky_code];
 957 }
 958
 959 static reloc_howto_type *
 960 csky_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 961                             const char *r_name)
 962 {
 963   unsigned int i;
 964   for (i = 0; i < R_CKCORE_MAX; i++)
 965     if (strcasecmp (csky_elf_howto_table[i].name, r_name) == 0)
 966       return &csky_elf_howto_table[i];
 967   return NULL;
 968 }
 969
 970 static reloc_howto_type *
 971 elf32_csky_howto_from_type (unsigned int r_type)
 972 {
 973   if (r_type < R_CKCORE_MAX)
 974     return &csky_elf_howto_table[r_type];
 975   else
 976     return NULL;
 977 }
 978
 979 static bool
 980 csky_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 981                         arelent *cache_ptr,
 982                         Elf_Internal_Rela *dst)
 983 {
 984   unsigned int r_type;
 985
 986   r_type = ELF32_R_TYPE (dst->r_info);
 987   cache_ptr->howto = elf32_csky_howto_from_type (r_type);
 988   if (cache_ptr->howto == NULL)
 989     {
 990       /* xgettext:c-format */
 991       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
 992                           abfd, r_type);
 993       bfd_set_error (bfd_error_bad_value);
 994       return false;
 995     }
 996   return true;
 997 }
 998
 999 /* The Global Offset Table max size.  */
1000 #define GOT_MAX_SIZE 0xFFFF8
1001
1002 /* The name of the dynamic interpreter.  This is put in the .interp
1003    section.  */
1004 #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
1005
1006 /* The size in bytes of an entry in the procedure linkage table.  */
1007 #define PLT_ENTRY_SIZE      12
1008 #define PLT_ENTRY_SIZE_P    16
1009
1010 /* The first entry in a procedure linkage table looks like
1011    this.  It is set up so that any shared library function that is
1012    called before the relocation has been set up calls the dynamic
1013    linker first.  */
1014 static const bfd_vma csky_elf_plt_entry_v2[PLT_ENTRY_SIZE / 4] =
1015 {
1016   0xd99c2002,  /* ldw r12, (gb, 8)  */
1017   0xea0d0000,  /* movi r13,offset   */
1018   0xe8cc0000   /* jmp r12           */
1019 };
1020
1021 static const bfd_vma csky_elf_plt_entry_v1[PLT_ENTRY_SIZE / 2 ] =
1022 {
1023   0x25f0,  /* subi r0, 32       */
1024   0x9200,  /* stw r2, (r0, 0)   */
1025   0x9310,  /* stw r3, (r0, 4)   */
1026   0x822e,  /* ldw r2, (gb, 8)   */
1027   0x7301,  /* lrw r3, #offset   */
1028   0x00c2,  /* jmp r2            */
1029 };
1030
1031 /* Branch stub support.  */
1032
1033 enum stub_insn_type
1034 {
1035   INSN16,
1036   INSN32,
1037   DATA_TYPE
1038 };
1039
1040 bool use_branch_stub = true;
1041 typedef struct
1042 {
1043   bfd_vma data;
1044   enum stub_insn_type type;
1045   unsigned int r_type;
1046   int reloc_addend;
1047 } insn_sequence;
1048
1049 static const insn_sequence elf32_csky_stub_long_branch[] =
1050 {
1051   {0xea8d0002, INSN32,    R_CKCORE_NONE,   0x0},   /* lrw t1,[pc+8] */
1052   {0x7834,     INSN16,    R_CKCORE_NONE,   0x0},   /* jmp t1 */
1053   {0x6c03,     INSN16,    R_CKCORE_NONE,   0x0},   /* nop */
1054   {0x0,        DATA_TYPE, R_CKCORE_ADDR32, 0x0}    /* .long addr */
1055 };
1056
1057 static const insn_sequence elf32_csky_stub_long_branch_jmpi[] =
1058 {
1059   {0xeac00001, INSN32,    R_CKCORE_NONE,   0x0},   /* jmpi [pc+4] */
1060   {0x0,        DATA_TYPE, R_CKCORE_ADDR32, 0x0}    /* .long addr */
1061 };
1062
1063 /* The bsr instruction offset limit.  */
1064 #define BSR_MAX_FWD_BRANCH_OFFSET       (((1 << 25) - 1) << 1)
1065 #define BSR_MAX_BWD_BRANCH_OFFSET       (-(1 << 26))
1066
1067 #define STUB_SUFFIX ".stub"
1068 #define STUB_ENTRY_NAME "__%s_veneer"
1069
1070 /* One entry per long/short branch stub defined above.  */
1071 #define DEF_STUBS \
1072   DEF_STUB(long_branch) \
1073   DEF_STUB(long_branch_jmpi)
1074
1075 #define DEF_STUB(x) csky_stub_##x,
1076 enum elf32_csky_stub_type
1077 {
1078   csky_stub_none,
1079   DEF_STUBS
1080 };
1081 #undef DEF_STUB
1082
1083 typedef struct
1084 {
1085   const insn_sequence* template_sequence;
1086   int template_size;
1087 } stub_def;
1088
1089 #define DEF_STUB(x) {elf32_csky_stub_##x, ARRAY_SIZE(elf32_csky_stub_##x)},
1090 static const stub_def stub_definitions[] = {
1091   {NULL, 0},
1092   DEF_STUBS
1093 };
1094
1095 /* The size of the thread control block.  */
1096 #define TCB_SIZE        8
1097
1098 struct csky_elf_obj_tdata
1099 {
1100   struct elf_obj_tdata root;
1101
1102   /* tls_type for each local got entry.  */
1103   char *local_got_tls_type;
1104 };
1105
1106 #define csky_elf_local_got_tls_type(bfd) \
1107   (csky_elf_tdata (bfd)->local_got_tls_type)
1108
1109 #define csky_elf_tdata(bfd) \
1110   ((struct csky_elf_obj_tdata *) (bfd)->tdata.any)
1111
1112 struct elf32_csky_stub_hash_entry
1113 {
1114   /* Base hash table entry structure.  */
1115   struct bfd_hash_entry root;
1116
1117   /* The stub section.  */
1118   asection *stub_sec;
1119
1120   /* Offset within stub_sec of the beginning of this stub.  */
1121   bfd_vma stub_offset;
1122
1123   /* Given the symbol's value and its section we can determine its final
1124      value when building the stubs (so the stub knows where to jump).  */
1125   bfd_vma target_value;
1126   asection *target_section;
1127
1128     /* Offset to apply to relocation referencing target_value.  */
1129   bfd_vma target_addend;
1130
1131   /* The stub type.  */
1132   enum elf32_csky_stub_type stub_type;
1133   /* Its encoding size in bytes.  */
1134   int stub_size;
1135   /* Its template.  */
1136   const insn_sequence *stub_template;
1137   /* The size of the template (number of entries).  */
1138   int stub_template_size;
1139
1140   /* The symbol table entry, if any, that this was derived from.  */
1141   struct csky_elf_link_hash_entry *h;
1142
1143   /* Destination symbol type.  */
1144   unsigned char st_type;
1145
1146   /* Where this stub is being called from, or, in the case of combined
1147      stub sections, the first input section in the group.  */
1148   asection *id_sec;
1149
1150   /* The name for the local symbol at the start of this stub.  The
1151      stub name in the hash table has to be unique; this does not, so
1152      it can be friendlier.  */
1153   char *output_name;
1154 };
1155
1156 #define csky_stub_hash_lookup(table, string, create, copy) \
1157   ((struct elf32_csky_stub_hash_entry *) \
1158    bfd_hash_lookup ((table), (string), (create), (copy)))
1159
1160 /* C-SKY ELF linker hash entry.  */
1161 struct csky_elf_link_hash_entry
1162 {
1163   struct elf_link_hash_entry elf;
1164   int plt_refcount;
1165   /* For sub jsri2bsr relocs count.  */
1166   int jsri2bsr_refcount;
1167
1168 #define GOT_UNKNOWN     0
1169 #define GOT_NORMAL      1
1170 #define GOT_TLS_GD      2
1171 #define GOT_TLS_IE      4
1172
1173   unsigned char tls_type;
1174
1175   /* A pointer to the most recently used stub hash entry against this
1176      symbol.  */
1177   struct elf32_csky_stub_hash_entry *stub_cache;
1178 };
1179
1180 /* Traverse an C-SKY ELF linker hash table.  */
1181 #define csky_elf_link_hash_traverse(table, func, info)                  \
1182   (elf_link_hash_traverse                                               \
1183    (&(table)->root,                                                     \
1184     (bool (*) (struct elf_link_hash_entry *, void *)) (func),           \
1185     (info)))
1186
1187 /* Get the C-SKY ELF linker hash table from a link_info structure.  */
1188 #define csky_elf_hash_table(p) \
1189   ((is_elf_hash_table ((p)->hash)                                       \
1190     && elf_hash_table_id (elf_hash_table (p)) == CSKY_ELF_DATA)         \
1191    ? (struct csky_elf_link_hash_table *) (p)->hash : NULL)
1192
1193 #define csky_elf_hash_entry(ent)  ((struct csky_elf_link_hash_entry*)(ent))
1194
1195 /* Array to keep track of which stub sections have been created, and
1196    information on stub grouping.  */
1197 struct map_stub
1198 {
1199   /* This is the section to which stubs in the group will be
1200      attached.  */
1201   asection *link_sec;
1202   /* The stub section.  */
1203   asection *stub_sec;
1204 };
1205
1206 /* C-SKY ELF linker hash table.  */
1207 struct csky_elf_link_hash_table
1208 {
1209   struct elf_link_hash_table elf;
1210
1211   /* Data for R_CKCORE_TLS_LDM32 relocations.  */
1212   union
1213   {
1214     bfd_signed_vma refcount;
1215     bfd_vma offset;
1216   } tls_ldm_got;
1217
1218   /* The stub hash table.  */
1219   struct bfd_hash_table stub_hash_table;
1220
1221   /* Linker stub bfd.  */
1222   bfd *stub_bfd;
1223
1224   /* Linker call-backs.  */
1225   asection * (*add_stub_section) (const char *, asection *);
1226   void (*layout_sections_again) (void);
1227
1228   /* Array to keep track of which stub sections have been created, and
1229    * information on stub grouping.  */
1230   struct map_stub *stub_group;
1231
1232   /* Number of elements in stub_group.  */
1233   unsigned int top_id;
1234
1235   /* Assorted information used by elf32_csky_size_stubs.  */
1236   unsigned int bfd_count;
1237   unsigned int top_index;
1238   asection **input_list;
1239 };
1240
1241 /* We can't change vectors in the bfd target which will apply to
1242    data sections, however we only do this to the text sections.  */
1243
1244 static bfd_vma
1245 csky_get_insn_32 (bfd *input_bfd,
1246                   bfd_byte *location)
1247 {
1248   if (bfd_big_endian (input_bfd))
1249     return bfd_get_32 (input_bfd, location);
1250   else
1251     return (bfd_get_16 (input_bfd, location) << 16
1252             | bfd_get_16 (input_bfd, location + 2));
1253 }
1254
1255 static void
1256 csky_put_insn_32 (bfd *input_bfd,
1257                   bfd_vma x,
1258                   bfd_byte *location)
1259 {
1260   if (bfd_big_endian (input_bfd))
1261     bfd_put_32 (input_bfd, x, location);
1262   else
1263     {
1264       bfd_put_16 (input_bfd, x >> 16, location);
1265       bfd_put_16 (input_bfd, x & 0xffff, location + 2);
1266     }
1267 }
1268
1269 /* Find or create a stub section.  Returns a pointer to the stub section, and
1270    the section to which the stub section will be attached (in *LINK_SEC_P).
1271    LINK_SEC_P may be NULL.  */
1272
1273 static asection *
1274 elf32_csky_create_or_find_stub_sec (asection **link_sec_p, asection *section,
1275                                     struct csky_elf_link_hash_table *htab)
1276 {
1277   asection *link_sec;
1278   asection *stub_sec;
1279
1280   link_sec = htab->stub_group[section->id].link_sec;
1281   stub_sec = htab->stub_group[section->id].stub_sec;
1282   if (stub_sec == NULL)
1283     {
1284       stub_sec = htab->stub_group[link_sec->id].stub_sec;
1285       if (stub_sec == NULL)
1286         {
1287           size_t namelen;
1288           bfd_size_type len;
1289           char *s_name;
1290
1291           namelen = strlen (link_sec->name);
1292           len = namelen + sizeof (STUB_SUFFIX);
1293           s_name = bfd_alloc (htab->stub_bfd, len);
1294           if (s_name == NULL)
1295             return NULL;
1296
1297           memcpy (s_name, link_sec->name, namelen);
1298           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
1299           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
1300           if (stub_sec == NULL)
1301             return NULL;
1302           htab->stub_group[link_sec->id].stub_sec = stub_sec;
1303         }
1304       htab->stub_group[section->id].stub_sec = stub_sec;
1305     }
1306
1307   if (link_sec_p)
1308     *link_sec_p = link_sec;
1309
1310   return stub_sec;
1311 }
1312
1313 /* Build a name for an entry in the stub hash table.  */
1314
1315 static char *
1316 elf32_csky_stub_name (const asection *input_section,
1317                       const asection *sym_sec,
1318                       const struct csky_elf_link_hash_entry *hash,
1319                       const Elf_Internal_Rela *rel)
1320 {
1321   char *stub_name;
1322   bfd_size_type len;
1323
1324   if (hash)
1325     {
1326       len = 8 + 1 + strlen (hash->elf.root.root.string) + 1 + 8 + 1;
1327       stub_name = bfd_malloc (len);
1328       if (stub_name != NULL)
1329         sprintf (stub_name, "%08x_%s+%x",
1330                  input_section->id & 0xffffffff,
1331                  hash->elf.root.root.string,
1332                  (int) rel->r_addend & 0xffffffff);
1333     }
1334   else
1335     {
1336       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
1337       stub_name = bfd_malloc (len);
1338       if (stub_name != NULL)
1339         sprintf (stub_name, "%08x_%x:%x+%x",
1340                  input_section->id & 0xffffffff,
1341                  sym_sec->id & 0xffffffff,
1342                  (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
1343                  (int) rel->r_addend & 0xffffffff);
1344     }
1345
1346   return stub_name;
1347 }
1348
1349 /* Determine the type of stub needed, if any, for a call.  */
1350
1351 static enum elf32_csky_stub_type
1352 csky_type_of_stub (struct bfd_link_info *info,
1353                    asection *input_sec,
1354                    const Elf_Internal_Rela *rel,
1355                    unsigned char st_type,
1356                    struct csky_elf_link_hash_entry *hash,
1357                    bfd_vma destination,
1358                    asection *sym_sec ATTRIBUTE_UNUSED,
1359                    bfd *input_bfd ATTRIBUTE_UNUSED,
1360                    const char *name ATTRIBUTE_UNUSED)
1361 {
1362   bfd_vma location;
1363   bfd_signed_vma branch_offset;
1364   unsigned int r_type;
1365   enum elf32_csky_stub_type stub_type = csky_stub_none;
1366   struct elf_link_hash_entry * h = &hash->elf;
1367
1368   /* We don't know the actual type of destination in case it is of
1369      type STT_SECTION: give up.  */
1370   if (st_type == STT_SECTION)
1371     return stub_type;
1372
1373   location = (input_sec->output_offset
1374               + input_sec->output_section->vma
1375               + rel->r_offset);
1376
1377   branch_offset = (bfd_signed_vma)(destination - location);
1378   r_type = ELF32_R_TYPE (rel->r_info);
1379   if (r_type == R_CKCORE_PCREL_IMM26BY2
1380       && ((h != NULL
1381            && ((h->def_dynamic && !h->def_regular)
1382                || (bfd_link_pic (info)
1383                    && h->root.type == bfd_link_hash_defweak)))
1384           || branch_offset > BSR_MAX_FWD_BRANCH_OFFSET
1385           || branch_offset < BSR_MAX_BWD_BRANCH_OFFSET))
1386     {
1387       if (bfd_csky_arch (info->output_bfd) == CSKY_ARCH_810
1388           || bfd_csky_arch (info->output_bfd) ==  CSKY_ARCH_807)
1389         stub_type = csky_stub_long_branch_jmpi;
1390       else
1391         stub_type = csky_stub_long_branch;
1392     }
1393
1394   return stub_type;
1395 }
1396
1397 /* Create an entry in an C-SKY ELF linker hash table.  */
1398
1399 static struct bfd_hash_entry *
1400 csky_elf_link_hash_newfunc (struct bfd_hash_entry * entry,
1401                             struct bfd_hash_table * table,
1402                             const char * string)
1403 {
1404   struct csky_elf_link_hash_entry * ret =
1405       (struct csky_elf_link_hash_entry *) entry;
1406
1407   /* Allocate the structure if it has not already been allocated by a
1408      subclass.  */
1409   if (ret == NULL)
1410     {
1411       ret = (struct csky_elf_link_hash_entry *)
1412         bfd_hash_allocate (table,
1413                            sizeof (struct csky_elf_link_hash_entry));
1414       if (ret == NULL)
1415         return (struct bfd_hash_entry *) ret;
1416     }
1417
1418   /* Call the allocation method of the superclass.  */
1419   ret = ((struct csky_elf_link_hash_entry *)
1420          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *)ret,
1421                                      table, string));
1422   if (ret != NULL)
1423     {
1424       struct csky_elf_link_hash_entry *eh;
1425
1426       eh = (struct csky_elf_link_hash_entry *) ret;
1427       eh->plt_refcount = 0;
1428       eh->jsri2bsr_refcount = 0;
1429       eh->tls_type = GOT_NORMAL;
1430       ret->stub_cache = NULL;
1431     }
1432
1433   return (struct bfd_hash_entry *) ret;
1434 }
1435
1436 /* Initialize an entry in the stub hash table.  */
1437
1438 static struct bfd_hash_entry *
1439 stub_hash_newfunc (struct bfd_hash_entry *entry,
1440                    struct bfd_hash_table *table,
1441                    const char *string)
1442 {
1443   /* Allocate the structure if it has not already been allocated by a
1444      subclass.  */
1445   if (entry == NULL)
1446     {
1447       entry = ((struct bfd_hash_entry *)
1448                bfd_hash_allocate (table,
1449                                   sizeof (struct elf32_csky_stub_hash_entry)));
1450       if (entry == NULL)
1451         return entry;
1452     }
1453
1454   /* Call the allocation method of the superclass.  */
1455   entry = bfd_hash_newfunc (entry, table, string);
1456   if (entry != NULL)
1457     {
1458       struct elf32_csky_stub_hash_entry *eh;
1459
1460       /* Initialize the local fields.  */
1461       eh = (struct elf32_csky_stub_hash_entry *) entry;
1462       eh->stub_sec = NULL;
1463       eh->stub_offset = 0;
1464       eh->target_value = 0;
1465       eh->target_section = NULL;
1466       eh->target_addend = 0;
1467       eh->stub_type = csky_stub_none;
1468       eh->stub_size = 0;
1469       eh->stub_template = NULL;
1470       eh->stub_template_size = -1;
1471       eh->h = NULL;
1472       eh->id_sec = NULL;
1473       eh->output_name = NULL;
1474     }
1475
1476   return entry;
1477 }
1478
1479 /* Free the derived linker hash table.  */
1480
1481 static void
1482 csky_elf_link_hash_table_free (bfd *obfd)
1483 {
1484   struct csky_elf_link_hash_table *ret
1485     = (struct csky_elf_link_hash_table *) obfd->link.hash;
1486
1487   bfd_hash_table_free (&ret->stub_hash_table);
1488   _bfd_elf_link_hash_table_free (obfd);
1489 }
1490
1491 /* Create an CSKY elf linker hash table.  */
1492
1493 static struct bfd_link_hash_table *
1494 csky_elf_link_hash_table_create (bfd *abfd)
1495 {
1496   struct csky_elf_link_hash_table *ret;
1497   size_t amt = sizeof (struct csky_elf_link_hash_table);
1498
1499   ret = (struct csky_elf_link_hash_table*) bfd_zmalloc (amt);
1500   if (ret == NULL)
1501     return NULL;
1502
1503   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1504                                       csky_elf_link_hash_newfunc,
1505                                       sizeof (struct csky_elf_link_hash_entry),
1506                                       CSKY_ELF_DATA))
1507     {
1508       free (ret);
1509       return NULL;
1510     }
1511
1512   if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
1513                             sizeof (struct elf32_csky_stub_hash_entry)))
1514     {
1515       free (ret);
1516       return NULL;
1517     }
1518   ret->elf.root.hash_table_free = csky_elf_link_hash_table_free;
1519   return &ret->elf.root;
1520 }
1521
1522 static bool
1523 csky_elf_mkobject (bfd *abfd)
1524 {
1525   return bfd_elf_allocate_object (abfd, sizeof (struct csky_elf_obj_tdata),
1526                                   CSKY_ELF_DATA);
1527 }
1528
1529 /* Adjust a symbol defined by a dynamic object and referenced by a
1530    regular object.  The current definition is in some section of the
1531    dynamic object, but we're not including those sections.  We have to
1532    change the definition to something the rest of the link can
1533    understand.  */
1534
1535 static bool
1536 csky_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1537                                 struct elf_link_hash_entry *h)
1538 {
1539   struct csky_elf_link_hash_entry *eh;
1540   struct csky_elf_link_hash_table *htab;
1541   asection *srel;
1542   asection *s;
1543   eh = (struct csky_elf_link_hash_entry *)h;
1544   if (eh == NULL)
1545     return false;
1546
1547   htab = csky_elf_hash_table (info);
1548   if (htab == NULL)
1549     return false;
1550
1551   /* Clear jsri2bsr_refcount, if creating shared library files.  */
1552   if (bfd_link_pic (info) && eh->jsri2bsr_refcount > 0)
1553     eh->jsri2bsr_refcount = 0;
1554
1555   /* If there is a function, put it in the procedure linkage table. We
1556      will fill in the contents of the procedure linkage table later.  */
1557   if (h->needs_plt)
1558     {
1559       /* Calls to STT_GNU_IFUNC symbols always use a PLT, even if the
1560          symbol binds locally.  */
1561       if (h->plt.refcount <= 0
1562           || (h->type != STT_GNU_IFUNC
1563               && (SYMBOL_CALLS_LOCAL (info, h)
1564                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1565                       && h->root.type == bfd_link_hash_undefweak))))
1566
1567         {
1568           /* This case can occur if we saw a PLT32 reloc in an input
1569              file, but the symbol was never referred to by a dynamic
1570              object, or if all references were garbage collected.  In
1571              such a case, we don't actually need to build a procedure
1572              linkage table, and we can just do a PC32 reloc instead.  */
1573           h->plt.offset = (bfd_vma) -1;
1574           h->needs_plt = 0;
1575           if (h->got.refcount == 0)
1576             h->got.refcount += 1;
1577         }
1578       else if (h->got.refcount != 0)
1579         {
1580           h->got.refcount -= eh->plt_refcount;
1581           eh->plt_refcount = 0;
1582         }
1583       return true;
1584     }
1585   else
1586     /* It's possible that we incorrectly decided a .plt reloc was
1587        needed for an R_CKCORE_PC32 or similar reloc to a non-function
1588        sym in check_relocs.  We can't decide accurately between function
1589        and non-function syms in check_relocs; objects loaded later in
1590        the link may change h->type.  So fix it now.  */
1591     h->plt.offset = (bfd_vma) -1;
1592
1593   /* If this is a weak symbol, and there is a real definition, the
1594      processor independent code will have arranged for us to see the
1595      real definition first, and we can just use the same value.  */
1596   if (h->is_weakalias)
1597     {
1598       struct elf_link_hash_entry *def = weakdef (h);
1599       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1600       h->root.u.def.section = def->root.u.def.section;
1601       h->root.u.def.value = def->root.u.def.value;
1602       return true;
1603     }
1604
1605   /* If there are no non-GOT references, we do not need a copy
1606      relocation.  */
1607   if (!h->non_got_ref)
1608     return true;
1609
1610   /* This is a reference to a symbol defined by a dynamic object which
1611      is not a function.  */
1612
1613   /* If we are creating a shared library, we must presume that the
1614      only references to the symbol are via the global offset table.
1615      For such cases we need not do anything here; the relocations will
1616      be handled correctly by relocate_section.  */
1617   if (bfd_link_pic (info) || htab->elf.is_relocatable_executable)
1618     return true;
1619
1620   /* We must allocate the symbol in our .dynbss section, which will
1621      become part of the .bss section of the executable.  There will be
1622      an entry for this symbol in the .dynsym section.  The dynamic
1623      object will contain position independent code, so all references
1624      from the dynamic object to this symbol will go through the global
1625      offset table.  The dynamic linker will use the .dynsym entry to
1626      determine the address it must put in the global offset table, so
1627      both the dynamic object and the regular object will refer to the
1628      same memory location for the variable.  */
1629   /* We must generate a R_CKCORE_COPY reloc to tell the dynamic linker to
1630      copy the initial value out of the dynamic object and into the
1631      runtime process image.  We need to remember the offset into the
1632      .rela.bss section we are going to use.  */
1633   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1634     {
1635       s = htab->elf.sdynrelro;
1636       srel = htab->elf.sreldynrelro;
1637     }
1638   else
1639     {
1640       s = htab->elf.sdynbss;
1641       srel = htab->elf.srelbss;
1642     }
1643   if (info->nocopyreloc == 0
1644       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1645       && h->size != 0
1646       && srel != NULL
1647       && s != NULL)
1648     {
1649       srel->size += sizeof (Elf32_External_Rela);
1650       h->needs_copy = 1;
1651       return _bfd_elf_adjust_dynamic_copy (info, h, s);
1652     }
1653
1654   h->non_got_ref = 0;
1655   return true;
1656 }
1657
1658 /* Allocate space in .plt, .got and associated reloc sections for
1659    dynamic relocs.  */
1660
1661 static bool
1662 csky_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1663 {
1664   struct bfd_link_info *info;
1665   struct csky_elf_link_hash_table *htab;
1666   struct csky_elf_link_hash_entry *eh;
1667   struct elf_dyn_relocs *p;
1668
1669   /* For indirect case, such as _ZdlPv to _ZdlPv@@GLIBCXX_3.4.  */
1670   if (h->root.type == bfd_link_hash_indirect)
1671     return true;
1672
1673   if (h->root.type == bfd_link_hash_warning)
1674     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1675
1676
1677   info = (struct bfd_link_info *) inf;
1678   htab = csky_elf_hash_table (info);
1679   if (htab == NULL)
1680     return false;
1681   /*TODO: how to deal with weak symbol relocs.  */
1682   if ((htab->elf.dynamic_sections_created || h->type == STT_GNU_IFUNC)
1683       && h->plt.refcount > 0)
1684     {
1685       /* Make sure this symbol is output as a dynamic symbol.
1686          Undefined weak syms won't yet be marked as dynamic.  */
1687       if (h->dynindx == -1 && !h->forced_local
1688           && h->root.type == bfd_link_hash_undefweak
1689           && ! bfd_elf_link_record_dynamic_symbol (info, h))
1690         return false;
1691       if (bfd_link_pic (info) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1692         {
1693           asection *splt = htab->elf.splt;
1694
1695           /* If this is the first .plt entry, make room for the special
1696              first entry.  */
1697           if (splt->size == 0)
1698             {
1699               if (bfd_csky_abi (info->output_bfd) ==  CSKY_ABI_V1)
1700                 splt->size += PLT_ENTRY_SIZE_P;
1701               else
1702                 splt->size += PLT_ENTRY_SIZE;
1703             }
1704           h->plt.offset = splt->size;
1705
1706           /* If this symbol is not defined in a regular file, and we are
1707              not generating a shared library, then set the symbol to this
1708              location in the .plt.  This is required to make function
1709              pointers compare as equal between the normal executable and
1710              the shared library.  */
1711           if (!bfd_link_pic (info) && !h->def_regular)
1712             {
1713               h->root.u.def.section = splt;
1714               h->root.u.def.value = h->plt.offset;
1715             }
1716
1717           /* Make room for this entry.  */
1718           if (bfd_csky_abi (info->output_bfd) ==  CSKY_ABI_V1)
1719             splt->size += PLT_ENTRY_SIZE_P;
1720           else
1721             splt->size += PLT_ENTRY_SIZE;
1722           /* We also need to make an entry in the .rela.plt section.  */
1723           htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
1724
1725           /* We also need to make an entry in the .got.plt section, which
1726              will be placed in the .got section by the linker script.  */
1727           htab->elf.sgotplt->size += 4;
1728         }
1729       else
1730         {
1731           h->plt.offset = (bfd_vma) -1;
1732           h->needs_plt = 0;
1733         }
1734     }
1735   else
1736     {
1737       h->plt.offset = (bfd_vma) -1;
1738       h->needs_plt = 0;
1739     }
1740
1741   if (h->got.refcount > 0)
1742     {
1743       asection *sgot;
1744       bool dyn;
1745       int indx;
1746
1747       int tls_type = csky_elf_hash_entry (h)->tls_type;
1748       /* Make sure this symbol is output as a dynamic symbol.
1749          Undefined weak syms won't yet be marked as dynamic.  */
1750       if (h->dynindx == -1 && !h->forced_local
1751           && h->root.type == bfd_link_hash_undefweak
1752           && ! bfd_elf_link_record_dynamic_symbol (info, h))
1753         return false;
1754
1755       sgot = htab->elf.sgot;
1756       h->got.offset = sgot->size;
1757       BFD_ASSERT (tls_type != GOT_UNKNOWN);
1758       if (tls_type == GOT_NORMAL)
1759         /* Non-TLS symbols need one GOT slot.  */
1760         sgot->size += 4;
1761       else
1762         {
1763           if (tls_type & GOT_TLS_GD)
1764             /* R_CKCORE_TLS_GD32 needs 2 consecutive GOT slots.  */
1765             sgot->size += 8;
1766           if (tls_type & GOT_TLS_IE)
1767             /* R_CKCORE_TLS_IE32 needs one GOT slot.  */
1768             sgot->size += 4;
1769         }
1770       dyn = htab->elf.dynamic_sections_created;
1771       indx = 0;
1772       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
1773           && (! bfd_link_pic (info) || !SYMBOL_REFERENCES_LOCAL (info, h)))
1774         indx = h->dynindx;
1775
1776       if (tls_type != GOT_NORMAL
1777           && (bfd_link_pic (info) || indx != 0)
1778           && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1779                && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1780               || h->root.type != bfd_link_hash_undefweak))
1781         {
1782           if (tls_type & GOT_TLS_IE)
1783             htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1784           if (tls_type & GOT_TLS_GD)
1785             htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1786           if ((tls_type & GOT_TLS_GD) && indx != 0)
1787             htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1788         }
1789       else if (((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1790                  && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1791                 || h->root.type != bfd_link_hash_undefweak)
1792                && (bfd_link_pic (info)
1793                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)
1794                    || h->plt.offset == (bfd_vma) -1))
1795         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1796     }
1797   else
1798     h->got.offset = (bfd_vma) -1;
1799
1800   eh = (struct csky_elf_link_hash_entry *) h;
1801   if (h->dyn_relocs == NULL)
1802     return true;
1803
1804   /* In the shared -Bsymbolic case, discard space allocated for
1805      dynamic pc-relative relocs against symbols which turn out to be
1806      defined in regular objects.  For the normal shared case, discard
1807      space for pc-relative relocs that have become local due to symbol
1808      visibility changes.  */
1809
1810   if (bfd_link_pic (info))
1811     {
1812       if (SYMBOL_CALLS_LOCAL (info, h))
1813         {
1814           struct elf_dyn_relocs **pp;
1815
1816           for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
1817             {
1818               p->count -= p->pc_count;
1819               p->pc_count = 0;
1820               if (p->count == 0)
1821                 *pp = p->next;
1822               else
1823                 pp = &p->next;
1824             }
1825         }
1826
1827       if (eh->jsri2bsr_refcount
1828           && h->root.type == bfd_link_hash_defined
1829           && h->dyn_relocs != NULL)
1830         h->dyn_relocs->count -= eh->jsri2bsr_refcount;
1831
1832       /* Also discard relocs on undefined weak syms with non-default
1833          visibility.  */
1834       if (h->dyn_relocs != NULL
1835           && h->root.type == bfd_link_hash_undefweak)
1836         {
1837           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1838               || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1839             h->dyn_relocs = NULL;
1840
1841           /* Make sure undefined weak symbols are output as a dynamic
1842              symbol in PIEs.  */
1843           else if (h->dynindx == -1
1844                    && !h->forced_local
1845                    && !bfd_elf_link_record_dynamic_symbol (info, h))
1846             return false;
1847         }
1848
1849     }
1850   else
1851     {
1852       /* For the non-shared case, discard space for relocs against
1853          symbols which turn out to need copy relocs or are not
1854          dynamic.  */
1855
1856       if (!h->non_got_ref
1857           && ((h->def_dynamic && !h->def_regular)
1858               || (htab->elf.dynamic_sections_created
1859                   && (h->root.type == bfd_link_hash_undefweak
1860                       || h->root.type == bfd_link_hash_indirect
1861                       || h->root.type == bfd_link_hash_undefined))))
1862         {
1863           /* Make sure this symbol is output as a dynamic symbol.
1864              Undefined weak syms won't yet be marked as dynamic.  */
1865           if (h->dynindx == -1 && !h->forced_local
1866               && h->root.type == bfd_link_hash_undefweak)
1867             {
1868               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1869                 return false;
1870             }
1871
1872           /* If that succeeded, we know we'll be keeping all the
1873              relocs.  */
1874           if (h->dynindx != -1)
1875             goto keep;
1876         }
1877
1878       h->dyn_relocs = NULL;
1879
1880       keep: ;
1881     }
1882
1883   /* Finally, allocate space.  */
1884   for (p = h->dyn_relocs; p != NULL; p = p->next)
1885     {
1886       asection *srelgot = htab->elf.srelgot;
1887       srelgot->size += p->count * sizeof (Elf32_External_Rela);
1888     }
1889
1890   return true;
1891 }
1892
1893 /* Set the sizes of the dynamic sections.  */
1894
1895 static bool
1896 csky_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1897                                 struct bfd_link_info *info)
1898 {
1899   struct csky_elf_link_hash_table *htab;
1900   bfd *dynobj;
1901   asection *s;
1902   bool relocs;
1903   bfd *ibfd;
1904
1905   htab = csky_elf_hash_table (info);
1906   if (htab == NULL)
1907     return false;
1908   dynobj = htab->elf.dynobj;
1909   if (dynobj == NULL)
1910     return false;
1911
1912   if (htab->elf.dynamic_sections_created)
1913     {
1914       /* Set the contents of the .interp section to the interpreter.  */
1915       if (!bfd_link_pic (info) && !info->nointerp)
1916         {
1917           s = bfd_get_section_by_name (dynobj, ".interp");
1918           BFD_ASSERT (s != NULL);
1919           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1920           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1921         }
1922     }
1923
1924   /* Set up .got offsets for local syms, and space for local dynamic
1925      relocs.  */
1926   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1927     {
1928       bfd_signed_vma *local_got_refcounts;
1929       bfd_signed_vma *end_local_got;
1930       bfd_size_type locsymcount;
1931       Elf_Internal_Shdr *symtab_hdr;
1932       asection *srelgot, *sgot;
1933       char *local_tls_type;
1934
1935       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1936         continue;
1937
1938       sgot = htab->elf.sgot;
1939       srelgot = htab->elf.srelgot;
1940
1941       for (s = ibfd->sections; s != NULL; s = s->next)
1942         {
1943           struct elf_dyn_relocs *p;
1944
1945           for (p = *((struct elf_dyn_relocs **)
1946                      &elf_section_data (s)->local_dynrel);
1947                p != NULL;
1948                p = p->next)
1949             {
1950               if (!bfd_is_abs_section (p->sec)
1951                   && bfd_is_abs_section (p->sec->output_section))
1952                 /* Input section has been discarded, either because
1953                    it is a copy of a linkonce section or due to
1954                    linker script /DISCARD/, so we'll be discarding
1955                    the relocs too.  */
1956                 ;
1957               else if (p->count != 0)
1958                 {
1959                   srelgot->size += p->count * sizeof (Elf32_External_Rela);
1960                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1961                     info->flags |= DF_TEXTREL;
1962                 }
1963             }
1964         }
1965
1966       local_got_refcounts = elf_local_got_refcounts (ibfd);
1967       if (!local_got_refcounts)
1968         continue;
1969
1970       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1971       locsymcount = symtab_hdr->sh_info;
1972       end_local_got = local_got_refcounts + locsymcount;
1973       local_tls_type = csky_elf_local_got_tls_type (ibfd);
1974
1975       for (; local_got_refcounts < end_local_got;
1976            ++local_got_refcounts, ++local_tls_type)
1977         {
1978           if (*local_got_refcounts > 0)
1979             {
1980               /* GOT_TLS_GD and GOT_TLS_IE type for TLS, GOT_NORMAL type
1981                  for GOT.  If output file is shared library, we should output
1982                  GOT_TLS_GD type relocation in .rel.got.  */
1983               *local_got_refcounts = sgot->size;
1984               if (*local_tls_type & GOT_TLS_GD)
1985                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
1986                 sgot->size += 8;
1987               if (*local_tls_type & GOT_TLS_IE)
1988                 sgot->size += 4;
1989               if (*local_tls_type == GOT_NORMAL)
1990                 sgot->size += 4;
1991               if (bfd_link_pic (info) || *local_tls_type == GOT_TLS_GD)
1992                 srelgot->size += sizeof (Elf32_External_Rela);
1993             }
1994           else
1995             *local_got_refcounts = (bfd_vma) -1;
1996         }
1997     }
1998
1999   if (htab->tls_ldm_got.refcount > 0)
2000     {
2001       /* Allocate two GOT entries and one dynamic relocation (if necessary)
2002          for R_CSKY_TLS_LDM32 relocations.  */
2003       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2004       htab->elf.sgot->size += 8;
2005       if (bfd_link_pic (info))
2006         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
2007     }
2008   else
2009     htab->tls_ldm_got.offset = -1;
2010
2011   /* Allocate global sym .plt and .got entries, and space for global
2012      sym dynamic relocs.  */
2013   elf_link_hash_traverse (&htab->elf, csky_allocate_dynrelocs, info);
2014
2015   /* Check for GOT overflow.  */
2016   if (check_got_overflow == 1
2017       && htab->elf.sgot->size + htab->elf.sgotplt->size > GOT_MAX_SIZE)
2018     {
2019       _bfd_error_handler (_("GOT table size out of range")); /*  */
2020       return false;
2021     }
2022
2023   /* We now have determined the sizes of the various dynamic sections.
2024      Allocate memory for them.  */
2025   relocs = false;
2026   for (s = dynobj->sections; s != NULL; s = s->next)
2027     {
2028       bool strip_section = true;
2029
2030       if ((s->flags & SEC_LINKER_CREATED) == 0)
2031         continue;
2032
2033       if (s == htab->elf.splt
2034           || s == htab->elf.sgot
2035           || s == htab->elf.sgotplt
2036           || s == htab->elf.sdynrelro
2037           || s == htab->elf.sreldynrelro)
2038         {
2039           /* Strip this section if we don't need it;
2040              see the comment below.  */
2041           /* We'd like to strip these sections if they aren't needed, but if
2042              we've exported dynamic symbols from them we must leave them.
2043              It's too late to tell BFD to get rid of the symbols.  */
2044
2045           if (htab->elf.hplt != NULL)
2046             strip_section = false;
2047         }
2048       else if (startswith (bfd_section_name (s), ".rel") )
2049         {
2050           if (s->size != 0 )
2051             relocs = true;
2052
2053           /* We use the reloc_count field as a counter if we need
2054              to copy relocs into the output file.  */
2055           s->reloc_count = 0;
2056         }
2057       else
2058         /* It's not one of our sections, so don't allocate space.  */
2059         continue;
2060
2061       /* Strip this section if we don't need it; see the
2062          comment below.  */
2063       if (s->size == 0)
2064         {
2065           /* If we don't need this section, strip it from the
2066              output file.  This is mostly to handle .rel.bss and
2067              .rel.plt.  We must create both sections in
2068              create_dynamic_sections, because they must be created
2069              before the linker maps input sections to output
2070              sections.  The linker does that before
2071              adjust_dynamic_symbol is called, and it is that
2072              function which decides whether anything needs to go
2073              into these sections.  */
2074           if (strip_section)
2075             s->flags |= SEC_EXCLUDE;
2076           continue;
2077         }
2078
2079       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2080         continue;
2081
2082       /* Allocate memory for the section contents.  We use bfd_zalloc
2083          here in case unused entries are not reclaimed before the
2084          section's contents are written out.  This should not happen,
2085          but this way if it does, we get a R_CKCORE_NONE reloc instead
2086          of garbage.  */
2087       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2088       if (s->contents == NULL)
2089         return false;
2090     }
2091
2092   if (htab->elf.dynamic_sections_created)
2093     htab->elf.dt_pltgot_required = htab->elf.sgot->size != 0;
2094   return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
2095 }
2096
2097 /* Finish up dynamic symbol handling.  We set the contents of various
2098    dynamic sections here.  */
2099
2100 static bool
2101 csky_elf_finish_dynamic_symbol (bfd *output_bfd,
2102                                 struct bfd_link_info *info,
2103                                 struct elf_link_hash_entry *h,
2104                                 Elf_Internal_Sym *sym)
2105 {
2106   struct csky_elf_link_hash_table *htab;
2107
2108   htab = csky_elf_hash_table (info);
2109   if (htab == NULL)
2110     return false;
2111
2112   /* Sanity check to make sure no unexpected symbol reaches here.
2113      This matches the test in csky_elf_relocate_section handling
2114      of GOT/PLT entries.  */
2115   BFD_ASSERT (! (h->dynindx == -1
2116                  && !h->forced_local
2117                  && h->root.type != bfd_link_hash_undefweak
2118                  && bfd_link_pic (info)));
2119
2120   if (h->plt.offset != (bfd_vma) -1)
2121     {
2122       bfd_vma plt_index;
2123       bfd_vma got_offset;
2124       Elf_Internal_Rela rel;
2125       bfd_byte *loc;
2126       asection *plt, *relplt, *gotplt;
2127
2128       plt = htab->elf.splt;
2129       relplt = htab->elf.srelplt;
2130       gotplt = htab->elf.sgotplt;
2131
2132       /* This symbol has an entry in the procedure linkage table.  Set
2133          it up.  */
2134       BFD_ASSERT (h->dynindx != -1
2135                   || ((h->forced_local || bfd_link_executable (info))
2136                       && h->def_regular));
2137       BFD_ASSERT (plt != NULL && gotplt != NULL && relplt != NULL);
2138       if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
2139         plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2140       else
2141         plt_index = h->plt.offset / PLT_ENTRY_SIZE_P - 1;
2142       got_offset = (plt_index + 3) * 4;
2143
2144       /* Fill in the entry in the procedure linkage table.  */
2145       if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
2146         {
2147           csky_put_insn_32 (output_bfd, csky_elf_plt_entry_v2[0],
2148                             plt->contents + h->plt.offset);
2149           csky_put_insn_32 (output_bfd,
2150                             (csky_elf_plt_entry_v2[1] | plt_index),
2151                             plt->contents + h->plt.offset + 4);
2152           csky_put_insn_32 (output_bfd, csky_elf_plt_entry_v2[2],
2153                             plt->contents + h->plt.offset + 8);
2154         }
2155       else
2156         {
2157           int i;
2158           for (i = 0; i < 6; i++)
2159             bfd_put_16 (output_bfd, csky_elf_plt_entry_v1[i],
2160                         plt->contents + h->plt.offset + i * 2);
2161           bfd_put_32 (output_bfd, plt_index,
2162                       plt->contents + h->plt.offset + i * 2);
2163         }
2164
2165       /* Fill in the entry in the .rel.plt section.  */
2166       rel.r_offset = (htab->elf.sgotplt->output_section->vma
2167                       + htab->elf.sgotplt->output_offset
2168                       + got_offset);
2169       rel.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_JUMP_SLOT);
2170       rel.r_addend = (plt->output_section->vma
2171                       + plt->output_offset
2172                       + h->plt.offset);
2173       loc = (htab->elf.srelplt->contents
2174              + plt_index * sizeof (Elf32_External_Rela));
2175
2176       if (loc != NULL)
2177         bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2178       if (! h->def_regular)
2179         {
2180           /* Mark the symbol as undefined, rather than as defined in
2181              the .plt section.  Leave the value alone.  */
2182           sym->st_shndx = SHN_UNDEF;
2183           /* If the symbol is weak, we do need to clear the value.
2184              Otherwise, the PLT entry would provide a definition for
2185              the symbol even if the symbol wasn't defined anywhere,
2186              and so the symbol would never be NULL. Leave the value if
2187              there were any relocations where pointer equality matters
2188              (this is a clue for the dynamic linker, to make function
2189              pointer comparisons work between an application and shared
2190              library).  */
2191           if (!h->ref_regular_nonweak || !h->pointer_equality_needed)
2192             sym->st_value = 0;
2193         }
2194     }
2195
2196   /* Fill in the entry in the .got section.  */
2197   if (h->got.offset != (bfd_vma) -1
2198       && ((csky_elf_hash_entry (h)->tls_type & GOT_TLS_GD) == 0)
2199       && ((csky_elf_hash_entry (h)->tls_type & GOT_TLS_IE) == 0))
2200     {
2201       Elf_Internal_Rela rel;
2202       bfd_byte *loc;
2203
2204       /* This symbol has an entry in the global offset table.
2205          Set it up.  */
2206       BFD_ASSERT (htab->elf.sgot != NULL && htab->elf.srelgot != NULL);
2207
2208       rel.r_offset = (htab->elf.sgot->output_section->vma
2209                       + htab->elf.sgot->output_offset
2210                       + (h->got.offset & ~(bfd_vma) 1));
2211
2212       /* If this is a static link, or it is a -Bsymbolic link and the
2213          symbol is defined locally or was forced to be local because
2214          of a version file, we just want to emit a RELATIVE reloc.
2215          The entry in the global offset table will already have been
2216          initialized in the relocate_section function.  */
2217       if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
2218         {
2219           BFD_ASSERT ((h->got.offset & 1) != 0);
2220           rel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
2221           rel.r_addend = (h->root.u.def.value
2222                           + h->root.u.def.section->output_offset
2223                           + h->root.u.def.section->output_section->vma);
2224         }
2225       else
2226         {
2227           BFD_ASSERT ((h->got.offset & 1) == 0);
2228           bfd_put_32 (output_bfd, (bfd_vma) 0,
2229                       htab->elf.sgot->contents + h->got.offset);
2230           rel.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_GLOB_DAT);
2231           rel.r_addend = 0;
2232         }
2233
2234       loc = htab->elf.srelgot->contents;
2235       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2236
2237       if (loc != NULL)
2238         bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2239     }
2240
2241   if (h->needs_copy)
2242     {
2243       asection *s;
2244       Elf_Internal_Rela rela;
2245       bfd_byte *loc;
2246
2247       /* This symbol needs a copy reloc.  Set it up.  */
2248       BFD_ASSERT (h->dynindx != -1
2249                   && (h->root.type == bfd_link_hash_defined
2250                       || h->root.type == bfd_link_hash_defweak));
2251
2252       rela.r_offset = (h->root.u.def.value
2253                        + h->root.u.def.section->output_section->vma
2254                        + h->root.u.def.section->output_offset);
2255       rela.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_COPY);
2256       rela.r_addend = 0;
2257       if (h->root.u.def.section == htab->elf.sdynrelro)
2258         s = htab->elf.sreldynrelro;
2259       else
2260         s = htab->elf.srelbss;
2261       BFD_ASSERT (s != NULL);
2262       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2263       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2264     }
2265
2266   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2267   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2268       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2269     sym->st_shndx = SHN_ABS;
2270
2271   return true;
2272 }
2273
2274 /* Finish up the dynamic sections.  */
2275
2276 static bool
2277 csky_elf_finish_dynamic_sections (bfd *output_bfd,
2278                                   struct bfd_link_info *info)
2279 {
2280   struct csky_elf_link_hash_table *htab;
2281   bfd *dynobj;
2282   asection *sdyn;
2283   asection *got_sec;
2284
2285   htab = csky_elf_hash_table (info);
2286   if (htab == NULL)
2287     return false;
2288
2289   dynobj = htab->elf.dynobj;
2290   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2291
2292   if (htab->elf.dynamic_sections_created)
2293     {
2294       Elf32_External_Dyn *dyncon, *dynconend;
2295
2296       BFD_ASSERT (sdyn != NULL && htab->elf.sgot != NULL);
2297
2298       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2299       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2300       for (; dyncon < dynconend; dyncon++)
2301         {
2302           Elf_Internal_Dyn dyn;
2303           bool size = false;
2304           const char *name = NULL;
2305
2306           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2307           switch (dyn.d_tag)
2308             {
2309             default:
2310               continue;
2311             case DT_RELA:
2312               name = ".rela.dyn";
2313               size = false;
2314               break;
2315             case DT_RELASZ:
2316               name = ".rela.dyn";
2317               size = true;
2318               break;
2319             case DT_PLTRELSZ:
2320               name = ".rela.plt";
2321               size = true;
2322               break;
2323             case DT_PLTGOT:
2324               dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
2325               break;
2326             case DT_JMPREL:
2327               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma
2328                                + htab->elf.srelplt->output_offset;
2329               break;
2330             }
2331
2332           if (name != NULL)
2333             {
2334               asection *s = bfd_get_section_by_name (output_bfd, name);
2335
2336               if (s == NULL)
2337                 dyn.d_un.d_val = 0;
2338               else if (!size)
2339                 dyn.d_un.d_ptr = s->vma;
2340               else
2341                 dyn.d_un.d_val = s->size;
2342             }
2343           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2344         }
2345     }
2346
2347   /* Fill in the first three entries in the global offset table.  */
2348   if (htab->elf.sgotplt)
2349     got_sec = htab->elf.sgotplt;
2350   else
2351     got_sec = htab->elf.sgot;
2352   if (got_sec != NULL)
2353     {
2354       if (got_sec->size > 0)
2355         {
2356           bfd_put_32 (output_bfd,
2357                       (sdyn == NULL ? (bfd_vma) 0
2358                        : sdyn->output_section->vma + sdyn->output_offset),
2359                       got_sec->contents);
2360           bfd_put_32 (output_bfd, (bfd_vma) 0, got_sec->contents + 4);
2361           bfd_put_32 (output_bfd, (bfd_vma) 0, got_sec->contents + 8);
2362         }
2363       elf_section_data (got_sec->output_section)->this_hdr.sh_entsize = 4;
2364     }
2365   return true;
2366 }
2367
2368 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2369
2370 static void
2371 csky_elf_copy_indirect_symbol (struct bfd_link_info *info,
2372                                struct elf_link_hash_entry *dir,
2373                                struct elf_link_hash_entry *ind)
2374 {
2375   struct csky_elf_link_hash_entry *edir, *eind;
2376
2377   edir = (struct csky_elf_link_hash_entry *) dir;
2378   eind = (struct csky_elf_link_hash_entry *) ind;
2379
2380   if (ind->root.type == bfd_link_hash_indirect
2381       && dir->got.refcount <= 0)
2382     {
2383       edir->tls_type = eind->tls_type;
2384       eind->tls_type = GOT_UNKNOWN;
2385     }
2386   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2387 }
2388
2389 /* Used to decide how to sort relocs in an optimal manner for the
2390    dynamic linker, before writing them out.  */
2391
2392 static enum elf_reloc_type_class
2393 csky_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2394                            const asection *rel_sec ATTRIBUTE_UNUSED,
2395                            const Elf_Internal_Rela *rela)
2396 {
2397   switch ((int) ELF32_R_TYPE (rela->r_info))
2398     {
2399     case R_CKCORE_RELATIVE:
2400       return reloc_class_relative;
2401     case R_CKCORE_JUMP_SLOT:
2402       return reloc_class_plt;
2403     case R_CKCORE_COPY:
2404       return reloc_class_copy;
2405     case R_CKCORE_IRELATIVE:
2406       return reloc_class_ifunc;
2407     default:
2408       return reloc_class_normal;
2409     }
2410 }
2411
2412 /* Return the section that should be marked against GC for a given
2413    relocation.  */
2414
2415 static asection *
2416 csky_elf_gc_mark_hook (asection *sec,
2417                        struct bfd_link_info *info,
2418                        Elf_Internal_Rela *rel,
2419                        struct elf_link_hash_entry *h,
2420                        Elf_Internal_Sym *sym)
2421 {
2422   if (h != NULL)
2423     {
2424       switch (ELF32_R_TYPE (rel->r_info))
2425         {
2426         case R_CKCORE_GNU_VTINHERIT:
2427         case R_CKCORE_GNU_VTENTRY:
2428           return NULL;
2429         }
2430     }
2431
2432   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2433 }
2434
2435 /* Match symbol names created by tc-csky.c:make_mapping_symbol.  */
2436
2437 static bool
2438 is_mapping_symbol_name (const char *name)
2439 {
2440   return (name && name[0] == '$'
2441           && (name[1] == 't' || name[1] == 'd')
2442           && name[2] == 0);
2443 }
2444
2445 /* Treat mapping symbols as special target symbols.  */
2446
2447 static bool
2448 csky_elf_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
2449 {
2450   return is_mapping_symbol_name (sym->name);
2451 }
2452
2453 /* Exclude mapping symbols from being treated as function symbols by
2454    objdump and nm.  */
2455
2456 static bfd_size_type
2457 csky_elf_maybe_function_sym (const asymbol *sym, asection *sec,
2458                              bfd_vma *code_off)
2459 {
2460   if ((sym->flags & BSF_LOCAL) != 0
2461       && is_mapping_symbol_name (sym->name))
2462     return 0;
2463
2464   return _bfd_elf_maybe_function_sym (sym, sec, code_off);
2465 }
2466
2467 /* Look through the relocs for a section during the first phase.
2468    Since we don't do .gots or .plts, we just need to consider the
2469    virtual table relocs for gc.  */
2470
2471 static bool
2472 csky_elf_check_relocs (bfd * abfd,
2473                        struct bfd_link_info * info,
2474                        asection * sec,
2475                        const Elf_Internal_Rela * relocs)
2476 {
2477   Elf_Internal_Shdr * symtab_hdr;
2478   struct elf_link_hash_entry ** sym_hashes;
2479   const Elf_Internal_Rela * rel;
2480   const Elf_Internal_Rela * rel_end;
2481   struct csky_elf_link_hash_table *htab;
2482   asection *sreloc;
2483
2484   /* if output type is relocatable, return.  */
2485   if (bfd_link_relocatable (info))
2486     return true;
2487
2488   htab = csky_elf_hash_table (info);
2489   if (htab == NULL)
2490     return false;
2491
2492   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2493   sym_hashes = elf_sym_hashes (abfd);
2494
2495   rel_end = relocs + sec->reloc_count;
2496   sreloc = NULL;
2497   for (rel = relocs; rel < rel_end; rel++)
2498     {
2499       struct elf_link_hash_entry *h;
2500       unsigned long r_symndx;
2501       Elf_Internal_Sym *isym;
2502       int r_type;
2503
2504       r_symndx = ELF32_R_SYM (rel->r_info);
2505       r_type = ELF32_R_TYPE (rel->r_info);
2506       if (r_symndx < symtab_hdr->sh_info)
2507         {
2508           /* A local symbol.  */
2509           isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
2510                                         abfd, r_symndx);
2511           if (isym == NULL)
2512             return false;
2513           h = NULL;
2514         }
2515       else
2516         {
2517           isym = NULL;
2518           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2519           while (h->root.type == bfd_link_hash_indirect
2520                  || h->root.type == bfd_link_hash_warning)
2521             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2522         }
2523
2524       switch (r_type)
2525         {
2526         case R_CKCORE_PCREL_IMM26BY2:
2527         case R_CKCORE_PCREL_IMM11BY2:
2528         case R_CKCORE_PCREL_JSR_IMM11BY2:
2529         case R_CKCORE_PCREL_JSR_IMM26BY2:
2530           /* If the symbol is '*UND*', means this reloc is used for
2531            * callgraph, don't need to leave to shared object. */
2532           if (r_symndx == 0)
2533             break;
2534           /* Else fall through.  */
2535         case R_CKCORE_ADDR32:
2536         case R_CKCORE_ADDR_HI16:
2537         case R_CKCORE_ADDR_LO16:
2538           if (h != NULL
2539               && bfd_link_executable (info)
2540               && r_type == R_CKCORE_ADDR32
2541               && h->type == STT_OBJECT
2542               && (sec->flags & SEC_ALLOC) != 0
2543               && (sec->flags & SEC_READONLY))
2544             /* If this reloc is in a read-only section, we might
2545                need a copy reloc.  We can't check reliably at this
2546                stage whether the section is read-only, as input
2547                sections have not yet been mapped to output sections.
2548                Tentatively set the flag for now, and correct in
2549                adjust_dynamic_symbol.  */
2550             h->non_got_ref = 1;
2551
2552           /* If we are creating a shared library or relocatable executable,
2553              and this is a reloc against a global symbol, then we need to
2554              copy the reloc into the shared library. However, if we are
2555              linking with -Bsymbolic, we do not need to copy a reloc
2556              against a global symbol which is defined in an object we are
2557              including in the link (i.e., DEF_REGULAR is set).  At
2558              this point we have not seen all the input files, so it is
2559              possible that DEF_REGULAR is not set now but will be set
2560              later (it is never cleared). We account for that possibility
2561              below by storing information in the relocs_copied field of
2562              the hash table entry.  */
2563           if ((bfd_link_pic (info) && (sec->flags & SEC_ALLOC) != 0)
2564               || (!bfd_link_pic (info)
2565                   && (sec->flags & SEC_ALLOC) != 0
2566                   && h != NULL
2567                   && (h->root.type == bfd_link_hash_defweak
2568                       || !h->def_regular)))
2569             {
2570               struct elf_dyn_relocs *p;
2571               struct elf_dyn_relocs **head;
2572               /* We must copy these reloc types into the output file.
2573                  Create a reloc section in dynobj and make room for
2574                  this reloc.  */
2575               if (sreloc == NULL)
2576                 {
2577                   if (htab->elf.dynobj == NULL)
2578                     htab->elf.dynobj = abfd;
2579
2580                   sreloc = _bfd_elf_make_dynamic_reloc_section
2581                     (sec, htab->elf.dynobj, 2, abfd, true);
2582
2583                   if (sreloc == NULL)
2584                     return false;
2585                 }
2586
2587               if (h == NULL && !use_branch_stub
2588                   && ((ELF32_R_TYPE (rel->r_info)
2589                        == R_CKCORE_PCREL_IMM26BY2)
2590                       || (ELF32_R_TYPE (rel->r_info)
2591                           == R_CKCORE_PCREL_IMM11BY2)))
2592                 break;
2593
2594               /* If this is a global symbol, we count the number of
2595                  relocations we need for this symbol.  */
2596               if (h != NULL)
2597                 {
2598                   struct csky_elf_link_hash_entry *eh;
2599                   eh = (struct  csky_elf_link_hash_entry *)h;
2600                   if ((ELF32_R_TYPE (rel->r_info)
2601                        == R_CKCORE_PCREL_JSR_IMM26BY2)
2602                       || (ELF32_R_TYPE (rel->r_info)
2603                           == R_CKCORE_PCREL_JSR_IMM11BY2))
2604                     eh->jsri2bsr_refcount += 1;
2605                   head = &h->dyn_relocs;
2606                 }
2607               else
2608                 {
2609                   /* Track dynamic relocs needed for local syms too.
2610                      We really need local syms available to do this
2611                      easily.  Oh well.  */
2612                   void **vpp;
2613                   asection *s;
2614                   Elf_Internal_Sym *loc_isym;
2615
2616                   loc_isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
2617                                                     abfd, r_symndx);
2618                   if (loc_isym == NULL)
2619                     return false;
2620                   s = bfd_section_from_elf_index (abfd, loc_isym->st_shndx);
2621                   if (s == NULL)
2622                     s = sec;
2623                   vpp = &elf_section_data (s)->local_dynrel;
2624                   head = (struct elf_dyn_relocs **)vpp;
2625                 }
2626
2627               p = *head;
2628               if (p == NULL || p->sec != sec)
2629                 {
2630                   size_t amt = sizeof *p;
2631                   p = ((struct elf_dyn_relocs *)
2632                        bfd_alloc (htab->elf.dynobj, amt));
2633                   if (p == NULL)
2634                     return false;
2635                   p->next = *head;
2636                   *head = p;
2637                   p->sec = sec;
2638                   p->count = 0;
2639                   p->pc_count = 0;
2640                 }
2641
2642               if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM26BY2
2643                   || ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM11BY2)
2644                 p->pc_count += 1;
2645               p->count += 1;
2646             }
2647           break;
2648
2649         case R_CKCORE_PLT_IMM18BY4:
2650         case R_CKCORE_PLT32:
2651           /* This symbol requires a procedure linkage table entry.  We
2652              actually build the entry in adjust_dynamic_symbol,
2653              because this might be a case of linking PIC code which is
2654              never referenced by a dynamic object, in which case we
2655              don't need to generate a procedure linkage table entry
2656              after all.  */
2657
2658           /* If this is a local symbol, we resolve it directly without
2659              creating a procedure linkage table entry.  */
2660           if (h == NULL)
2661             continue;
2662           if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PLT_IMM18BY4)
2663             check_got_overflow = 1;
2664
2665           h->needs_plt = 1;
2666           h->plt.refcount += 1;
2667           h->got.refcount += 1;
2668           ((struct  csky_elf_link_hash_entry *)h)->plt_refcount += 1;
2669           break;
2670
2671         case R_CKCORE_GOT12:
2672         case R_CKCORE_PLT12:
2673         case R_CKCORE_GOT32:
2674         case R_CKCORE_GOT_HI16:
2675         case R_CKCORE_GOT_LO16:
2676         case R_CKCORE_PLT_HI16:
2677         case R_CKCORE_PLT_LO16:
2678         case R_CKCORE_GOT_IMM18BY4:
2679         case R_CKCORE_TLS_IE32:
2680         case R_CKCORE_TLS_GD32:
2681           {
2682             int tls_type, old_tls_type;
2683
2684             if (h != NULL
2685                 && bfd_link_executable (info)
2686                 && r_type == R_CKCORE_GOT_IMM18BY4
2687                 && (sec->flags & SEC_ALLOC) != 0
2688                 && (sec->flags & SEC_READONLY))
2689               /* If this reloc is in a read-only section, we might
2690                  need a copy reloc.  We can't check reliably at this
2691                  stage whether the section is read-only, as input
2692                  sections have not yet been mapped to output sections.
2693                  Tentatively set the flag for now, and correct in
2694                  adjust_dynamic_symbol.  */
2695               h->non_got_ref = 1;
2696
2697             switch (ELF32_R_TYPE (rel->r_info))
2698               {
2699               case R_CKCORE_TLS_IE32:
2700                 tls_type = GOT_TLS_IE;
2701                 break;
2702               case R_CKCORE_TLS_GD32:
2703                 tls_type = GOT_TLS_GD;
2704                 break;
2705               default:
2706                 tls_type = GOT_NORMAL;
2707                 break;
2708               }
2709             if (h != NULL)
2710               {
2711                 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_GOT_IMM18BY4)
2712                   check_got_overflow = 1;
2713                 h->got.refcount += 1;
2714                 old_tls_type = csky_elf_hash_entry (h)->tls_type;
2715               }
2716             else
2717               {
2718                 bfd_signed_vma *local_got_refcounts;
2719
2720                 /* This is a global offset table entry for a local symbol.  */
2721                 /* we can write a new function named
2722                    elf32_csky_allocate_local_sym_info() to replace
2723                    following code.  */
2724                 local_got_refcounts = elf_local_got_refcounts (abfd);
2725                 if (local_got_refcounts == NULL)
2726                   {
2727                     bfd_size_type size;
2728
2729                     size = symtab_hdr->sh_info;
2730                     size *= (sizeof (bfd_signed_vma) + sizeof (char));
2731                     local_got_refcounts = ((bfd_signed_vma *)
2732                                            bfd_zalloc (abfd, size));
2733                     if (local_got_refcounts == NULL)
2734                       return false;
2735                     elf_local_got_refcounts (abfd) = local_got_refcounts;
2736                     csky_elf_local_got_tls_type (abfd)
2737                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
2738                   }
2739                 local_got_refcounts[r_symndx] += 1;
2740                 old_tls_type = csky_elf_local_got_tls_type (abfd)[r_symndx];
2741               }
2742
2743             /* We will already have issued an error message if there is a
2744                TLS / non-TLS mismatch, based on the symbol type.  We don't
2745                support any linker relaxations.  So just combine any TLS
2746                types needed.  */
2747             if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
2748                 && tls_type != GOT_NORMAL)
2749               tls_type |= old_tls_type;
2750
2751             if (old_tls_type != tls_type)
2752               {
2753                 if (h != NULL)
2754                   csky_elf_hash_entry (h)->tls_type = tls_type;
2755                 else
2756                   csky_elf_local_got_tls_type (abfd)[r_symndx] = tls_type;
2757               }
2758           }
2759           /* Fall through.  */
2760
2761         case R_CKCORE_TLS_LDM32:
2762           if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_TLS_LDM32)
2763             htab->tls_ldm_got.refcount++;
2764           /* Fall through.  */
2765
2766         case R_CKCORE_GOTOFF:
2767         case R_CKCORE_GOTPC:
2768         case R_CKCORE_GOTOFF_HI16:
2769         case R_CKCORE_GOTOFF_LO16:
2770         case R_CKCORE_GOTPC_HI16:
2771         case R_CKCORE_GOTPC_LO16:
2772         case R_CKCORE_GOTOFF_IMM18:
2773           if (htab->elf.sgot == NULL)
2774             {
2775               if (htab->elf.dynobj == NULL)
2776                 htab->elf.dynobj = abfd;
2777               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2778                 return false;
2779             }
2780           break;
2781
2782           /* This relocation describes the C++ object vtable hierarchy.
2783              Reconstruct it for later use during GC.  */
2784         case R_CKCORE_GNU_VTINHERIT:
2785           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2786             return false;
2787           break;
2788
2789           /* This relocation describes which C++ vtable entries are actually
2790              used.  Record for later use during GC.  */
2791         case R_CKCORE_GNU_VTENTRY:
2792           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2793             return false;
2794           break;
2795         }
2796     }
2797
2798   return true;
2799 }
2800
2801 static const struct bfd_elf_special_section csky_elf_special_sections[]=
2802 {
2803   { STRING_COMMA_LEN (".ctors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2804   { STRING_COMMA_LEN (".dtors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2805   { NULL,                     0,  0, 0,            0 }
2806 };
2807
2808 /* Function to keep CSKY specific flags in the ELF header.  */
2809
2810 static bool
2811 csky_elf_set_private_flags (bfd * abfd, flagword flags)
2812 {
2813   BFD_ASSERT (! elf_flags_init (abfd)
2814               || elf_elfheader (abfd)->e_flags == flags);
2815
2816   elf_elfheader (abfd)->e_flags = flags;
2817   elf_flags_init (abfd) = true;
2818   return true;
2819 }
2820
2821 static csky_arch_for_merge *
2822 csky_find_arch_with_eflag (const unsigned long arch_eflag)
2823 {
2824   csky_arch_for_merge *csky_arch = NULL;
2825
2826   for (csky_arch = csky_archs; csky_arch->name != NULL; csky_arch++)
2827     if (csky_arch->arch_eflag == arch_eflag)
2828       break;
2829   if (csky_arch == NULL)
2830     {
2831       _bfd_error_handler (_("warning: unrecognized arch eflag '%#lx'"),
2832                            arch_eflag);
2833       bfd_set_error (bfd_error_wrong_format);
2834     }
2835   return csky_arch;
2836 }
2837
2838 static csky_arch_for_merge *
2839 csky_find_arch_with_name (const char *name)
2840 {
2841   csky_arch_for_merge *csky_arch = NULL;
2842   const char *msg;
2843
2844   if (name == NULL)
2845     return NULL;
2846
2847   for (csky_arch = csky_archs; csky_arch->name != NULL; csky_arch++)
2848     {
2849       if (strncmp (csky_arch->name, name, strlen (csky_arch->name)) == 0)
2850         break;
2851     }
2852   if (csky_arch == NULL)
2853     {
2854       msg = _("warning: unrecognised arch name '%#x'");
2855       (*_bfd_error_handler) (msg, name);
2856       bfd_set_error (bfd_error_wrong_format);
2857     }
2858   return csky_arch;
2859 }
2860
2861 static bool
2862 elf32_csky_merge_attributes (bfd *ibfd, struct bfd_link_info *info)
2863 {
2864   bfd *obfd = info->output_bfd;
2865   obj_attribute *in_attr;
2866   obj_attribute *out_attr;
2867   obj_attribute tattr;
2868   csky_arch_for_merge *old_arch = NULL;
2869   csky_arch_for_merge *new_arch = NULL;
2870   int i;
2871   bool result = true;
2872   const char *msg = NULL;
2873
2874   const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
2875
2876   /* Skip the linker stubs file.  This preserves previous behavior
2877      of accepting unknown attributes in the first input file - but
2878      is that a bug?  */
2879   if (ibfd->flags & BFD_LINKER_CREATED)
2880     return true;
2881
2882   /* Skip any input that hasn't attribute section.
2883      This enables to link object files without attribute section with
2884      any others.  */
2885   if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
2886     {
2887       return true;
2888     }
2889
2890   if (!elf_known_obj_attributes_proc (obfd)[0].i)
2891     {
2892       /* This is the first object.  Copy the attributes.  */
2893       out_attr = elf_known_obj_attributes_proc (obfd);
2894
2895       /* If Tag_CSKY_CPU_NAME is already set, save it.  */
2896       memcpy (&tattr, &out_attr[Tag_CSKY_ARCH_NAME], sizeof (tattr));
2897
2898       _bfd_elf_copy_obj_attributes (ibfd, obfd);
2899
2900       out_attr = elf_known_obj_attributes_proc (obfd);
2901
2902       /* Restore Tag_CSKY_CPU_NAME.  */
2903       memcpy (&out_attr[Tag_CSKY_ARCH_NAME], &tattr, sizeof (tattr));
2904
2905       /* Use the Tag_null value to indicate the attributes have been
2906          initialized.  */
2907       out_attr[0].i = 1;
2908     }
2909
2910   in_attr = elf_known_obj_attributes_proc (ibfd);
2911   out_attr = elf_known_obj_attributes_proc (obfd);
2912
2913   for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
2914     {
2915       /* Merge this attribute with existing attributes.  */
2916       switch (i)
2917         {
2918         case Tag_CSKY_CPU_NAME:
2919         case Tag_CSKY_ARCH_NAME:
2920           /* Do arch merge.  */
2921           new_arch = csky_find_arch_with_name (in_attr[Tag_CSKY_ARCH_NAME].s);
2922           old_arch = csky_find_arch_with_name (out_attr[Tag_CSKY_ARCH_NAME].s);
2923
2924           if (new_arch != NULL && old_arch != NULL)
2925             {
2926               if (new_arch->class != old_arch->class)
2927                 {
2928                   msg = _("%pB: machine flag conflict with target");
2929                   (*_bfd_error_handler) (msg, ibfd);
2930                   bfd_set_error (bfd_error_wrong_format);
2931                   return false;
2932                 }
2933               else if (new_arch->class_level != old_arch->class_level)
2934                 {
2935                   csky_arch_for_merge *newest_arch =
2936                     ((new_arch->class_level > old_arch->class_level) ?
2937                   new_arch : old_arch);
2938
2939                   if (new_arch->do_warning || old_arch->do_warning)
2940                     {
2941                       msg = _("warning: file %pB's arch flag %s conflict "
2942                               "with target %s,set target arch flag to %s");
2943                       (*_bfd_error_handler) (msg, ibfd,  new_arch->name,
2944                                              old_arch->name,
2945                                              (newest_arch->name));
2946                       bfd_set_error (bfd_error_wrong_format);
2947                     }
2948
2949                   if (out_attr[Tag_CSKY_ARCH_NAME].s != NULL)
2950                     bfd_release (obfd, out_attr[Tag_CSKY_ARCH_NAME].s);
2951
2952                   out_attr[Tag_CSKY_ARCH_NAME].s =
2953                     _bfd_elf_attr_strdup (obfd, newest_arch->name);
2954                 }
2955             }
2956
2957           break;
2958
2959         case Tag_CSKY_ISA_FLAGS:
2960         case Tag_CSKY_ISA_EXT_FLAGS:
2961           /* Do ISA merge.  */
2962           break;
2963
2964         case Tag_CSKY_VDSP_VERSION:
2965           if (out_attr[i].i == 0)
2966             out_attr[i].i = in_attr[i].i;
2967           else if (out_attr[i].i != in_attr[i].i)
2968             {
2969               _bfd_error_handler
2970                 (_("Error: %pB and %pB has different VDSP version"), ibfd, obfd);
2971               result = false;
2972             }
2973           break;
2974
2975         case Tag_CSKY_FPU_VERSION:
2976           if (out_attr[i].i <= in_attr[i].i
2977               && out_attr[i].i == 0)
2978             out_attr[i].i = in_attr[i].i;
2979           break;
2980
2981         case Tag_CSKY_DSP_VERSION:
2982           if (out_attr[i].i == 0)
2983             out_attr[i].i = in_attr[i].i;
2984           else if (out_attr[i].i != in_attr[i].i)
2985             {
2986               _bfd_error_handler
2987                 (_("Error: %pB and %pB has different DSP version"), ibfd, obfd);
2988               result = false;
2989             }
2990           break;
2991
2992         case Tag_CSKY_FPU_ABI:
2993           if (out_attr[i].i != in_attr[i].i
2994               && (out_attr[i].i == 0
2995                   || (out_attr[i].i == VAL_CSKY_FPU_ABI_SOFT
2996                       && in_attr[i].i == VAL_CSKY_FPU_ABI_SOFTFP)))
2997             {
2998               out_attr[i].i = in_attr[i].i;
2999             }
3000           else if (out_attr[i].i == VAL_CSKY_FPU_ABI_HARD
3001                    && (out_attr[i].i != in_attr[i].i
3002                        && in_attr[i].i != 0))
3003             {
3004               _bfd_error_handler
3005                (_("Error: %pB and %pB has different FPU ABI"), ibfd, obfd);
3006                result = false;
3007             }
3008           break;
3009
3010         default:
3011           result =
3012             result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
3013           break;
3014         }
3015
3016       /* If out_attr was copied from in_attr then it won't have a type yet.  */
3017       if (in_attr[i].type && !out_attr[i].type)
3018         out_attr[i].type = in_attr[i].type;
3019     }
3020
3021   /* Merge Tag_compatibility attributes and any common GNU ones.  */
3022   if (!_bfd_elf_merge_object_attributes (ibfd, info))
3023     return false;
3024
3025   /* Check for any attributes not known on CSKY.  */
3026   result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
3027
3028   return result;
3029 }
3030
3031 /* Merge backend specific data from an object file to the output
3032    object file when linking.  */
3033
3034 static bool
3035 csky_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3036 {
3037   bfd *obfd = info->output_bfd;
3038   flagword old_flags;
3039   flagword new_flags;
3040   csky_arch_for_merge *old_arch = NULL;
3041   csky_arch_for_merge *new_arch = NULL;
3042   flagword newest_flag = 0;
3043   const char *sec_name;
3044   obj_attribute *out_attr;
3045
3046   /* Check if we have the same endianness.  */
3047   if (! _bfd_generic_verify_endian_match (ibfd, info))
3048     return false;
3049
3050   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3051       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3052     return true;
3053
3054   /* Merge ".csky.attribute" section.  */
3055   if (!elf32_csky_merge_attributes (ibfd, info))
3056     return false;
3057
3058   if (! elf_flags_init (obfd))
3059     {
3060       /* First call, no flags set.  */
3061       elf_flags_init (obfd) = true;
3062     }
3063
3064   /* Try to merge e_flag.  */
3065   new_flags = elf_elfheader (ibfd)->e_flags;
3066   old_flags = elf_elfheader (obfd)->e_flags;
3067   out_attr = elf_known_obj_attributes_proc (obfd);
3068
3069   /* the flags like"e , f ,g ..." , we take collection.  */
3070   newest_flag = (old_flags & (~CSKY_ARCH_MASK))
3071    | (new_flags & (~CSKY_ARCH_MASK));
3072
3073   sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
3074   if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
3075     {
3076       /* Input BFDs have no ".csky.attribute" section.  */
3077       new_arch = csky_find_arch_with_eflag (new_flags & CSKY_ARCH_MASK);
3078       old_arch = csky_find_arch_with_name (out_attr[Tag_CSKY_ARCH_NAME].s);
3079
3080       if (new_arch != NULL && old_arch != NULL)
3081         {
3082           if (new_arch->class != old_arch->class)
3083             {
3084               _bfd_error_handler
3085                 /* xgettext:c-format */
3086                 (_("%pB: machine flag conflict with target"), ibfd);
3087               bfd_set_error (bfd_error_wrong_format);
3088               return false;
3089             }
3090           else if (new_arch->class_level != old_arch->class_level)
3091             {
3092               csky_arch_for_merge *newest_arch =
3093                 (new_arch->class_level > old_arch->class_level
3094                  ? new_arch : old_arch);
3095
3096               if (new_arch->do_warning || old_arch->do_warning)
3097                 {
3098                   _bfd_error_handler
3099                     /* xgettext:c-format */
3100                     (_("warning: file %pB's arch flag %s conflicts with "
3101                        "target ck%s, using %s"),
3102                      ibfd, new_arch->name, old_arch->name,
3103                      newest_arch->name);
3104                   bfd_set_error (bfd_error_wrong_format);
3105                 }
3106
3107               if (out_attr[Tag_CSKY_ARCH_NAME].s != NULL)
3108                 bfd_release (obfd, out_attr[Tag_CSKY_ARCH_NAME].s);
3109
3110               out_attr[Tag_CSKY_ARCH_NAME].s =
3111                 _bfd_elf_attr_strdup (obfd, newest_arch->name);
3112             }
3113           else
3114             newest_flag |= ((new_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK))
3115                             | (old_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK)));
3116         }
3117       else
3118         {
3119           if (new_arch && new_arch->name != NULL)
3120             out_attr[Tag_CSKY_ARCH_NAME].s =
3121           _bfd_elf_attr_strdup (obfd, new_arch->name);
3122         }
3123     }
3124
3125   elf_elfheader (obfd)->e_flags = newest_flag;
3126
3127   return true;
3128 }
3129
3130 /* Ignore the discarded relocs in special sections in link time.  */
3131
3132 static bool
3133 csky_elf_ignore_discarded_relocs (asection *sec)
3134 {
3135   if (strcmp (sec->name, ".csky_stack_size") == 0)
3136     return true;
3137   return false;
3138 }
3139
3140 /* .csky_stack_size are not referenced directly.  This pass marks all of
3141    them as required.  */
3142
3143 static bool
3144 elf32_csky_gc_mark_extra_sections (struct bfd_link_info *info,
3145                                    elf_gc_mark_hook_fn gc_mark_hook ATTRIBUTE_UNUSED)
3146 {
3147   bfd *sub;
3148
3149   _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
3150
3151   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3152     {
3153       asection *o;
3154
3155       for (o = sub->sections; o != NULL; o = o->next)
3156         if (strcmp (o->name, ".csky_stack_size") == 0)
3157           o->gc_mark = 1;
3158     }
3159
3160   return true;
3161 }
3162
3163 /* The linker repeatedly calls this function for each input section,
3164    in the order that input sections are linked into output sections.
3165    Build lists of input sections to determine groupings between which
3166    we may insert linker stubs.  */
3167
3168 void
3169 elf32_csky_next_input_section (struct bfd_link_info *info,
3170                                asection *isec)
3171 {
3172   struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3173   if (htab == NULL)
3174     return;
3175   if (isec->output_section->index <= htab->top_index)
3176     {
3177       asection **list = htab->input_list + isec->output_section->index;
3178
3179       if (*list != bfd_abs_section_ptr)
3180         {
3181           /* Steal the link_sec pointer for our list.  */
3182 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3183           /* This happens to make the list in reverse order,
3184              which we reverse later in group_sections.  */
3185           PREV_SEC (isec) = *list;
3186           *list = isec;
3187         }
3188     }
3189 }
3190
3191 /* See whether we can group stub sections together.  Grouping stub
3192    sections may result in fewer stubs.  More importantly, we need to
3193    put all .init* and .fini* stubs at the end of the .init or
3194    .fini output sections respectively, because glibc splits the
3195    _init and _fini functions into multiple parts.  Putting a stub in
3196    the middle of a function is not a good idea.  */
3197
3198 static void
3199 group_sections (struct csky_elf_link_hash_table *htab,
3200                 bfd_size_type stub_group_size,
3201                 bool stubs_always_after_branch)
3202 {
3203   asection **list = htab->input_list;
3204
3205   do
3206     {
3207       asection *tail = *list;
3208       asection *head;
3209
3210       if (tail == bfd_abs_section_ptr)
3211         continue;
3212
3213       /* Reverse the list: we must avoid placing stubs at the
3214          beginning of the section because the beginning of the text
3215          section may be required for an interrupt vector in bare metal
3216          code.  */
3217 #define NEXT_SEC PREV_SEC
3218       head = NULL;
3219       while (tail != NULL)
3220         {
3221           /* Pop from tail.  */
3222           asection *item = tail;
3223           tail = PREV_SEC (item);
3224
3225           /* Push on head.  */
3226           NEXT_SEC (item) = head;
3227           head = item;
3228         }
3229
3230       while (head != NULL)
3231         {
3232           asection *curr;
3233           asection *next;
3234           bfd_vma stub_group_start = head->output_offset;
3235           bfd_vma end_of_next;
3236
3237           curr = head;
3238           while (NEXT_SEC (curr) != NULL)
3239             {
3240               next = NEXT_SEC (curr);
3241               end_of_next = next->output_offset + next->size;
3242               if (end_of_next - stub_group_start >= stub_group_size)
3243                 /* End of NEXT is too far from start, so stop.  */
3244                 break;
3245               curr = next;
3246             }
3247
3248           /* OK, the size from the start to the start of CURR is less
3249            * than stub_group_size and thus can be handled by one stub
3250            * section.  (Or the head section is itself larger than
3251            * stub_group_size, in which case we may be toast.)
3252            * We should really be keeping track of the total size of
3253            * stubs added here, as stubs contribute to the final output
3254            * section size.  */
3255           do
3256             {
3257               next = NEXT_SEC (head);
3258               /* Set up this stub group.  */
3259               htab->stub_group[head->id].link_sec = curr;
3260             }
3261           while (head != curr && (head = next) != NULL);
3262
3263           /* But wait, there's more!  Input sections up to stub_group_size
3264            * bytes after the stub section can be handled by it too.  */
3265           if (!stubs_always_after_branch)
3266             {
3267               stub_group_start = curr->output_offset + curr->size;
3268
3269               while (next != NULL)
3270                 {
3271                   end_of_next = next->output_offset + next->size;
3272                   if (end_of_next - stub_group_start >= stub_group_size)
3273                     /* End of NEXT is too far from stubs, so stop.  */
3274                     break;
3275                   /* Add NEXT to the stub group.  */
3276                   head = next;
3277                   next = NEXT_SEC (head);
3278                   htab->stub_group[head->id].link_sec = curr;
3279                 }
3280             }
3281           head = next;
3282         }
3283     }
3284   while (list++ != htab->input_list + htab->top_index);
3285
3286   free (htab->input_list);
3287 #undef PREV_SEC
3288 #undef NEXT_SEC
3289 }
3290
3291 /* If the symbol referenced by bsr is defined in shared object file,
3292    or it is a weak symbol and we aim to create shared object file,
3293    we must create a stub for this bsr.  */
3294
3295 static bool
3296 sym_must_create_stub (struct elf_link_hash_entry *h,
3297                       struct bfd_link_info *info)
3298 {
3299   if (h != NULL
3300       && ((h->def_dynamic && !h->def_regular)
3301           || (bfd_link_pic (info) && h->root.type == bfd_link_hash_defweak)))
3302     return true;
3303   else
3304     return false;
3305 }
3306
3307 /* Calculate the template, template size and instruction size for a stub.
3308    Return value is the instruction size.  */
3309
3310 static unsigned int
3311 find_stub_size_and_template (enum elf32_csky_stub_type stub_type,
3312                              const insn_sequence **stub_template,
3313                              int *stub_template_size)
3314 {
3315   const insn_sequence *template_sequence = NULL;
3316   int template_size = 0;
3317   int i;
3318   unsigned int size;
3319
3320   template_sequence = stub_definitions[stub_type].template_sequence;
3321   template_size = stub_definitions[stub_type].template_size;
3322
3323   size = 0;
3324   for (i = 0; i < template_size; i++)
3325     {
3326       switch (template_sequence[i].type)
3327       {
3328       case INSN16:
3329         size += 2;
3330         break;
3331
3332       case INSN32:
3333       case DATA_TYPE:
3334         size += 4;
3335         break;
3336
3337       default:
3338         BFD_FAIL ();
3339         return false;
3340       }
3341     }
3342
3343   if (stub_template)
3344     *stub_template = template_sequence;
3345   if (stub_template_size)
3346     *stub_template_size = template_size;
3347
3348   return size;
3349 }
3350
3351 /* As above, but don't actually build the stub.  Just bump offset so
3352    we know stub section sizes.  */
3353
3354 static bool
3355 csky_size_one_stub (struct bfd_hash_entry *gen_entry,
3356                     void * in_arg ATTRIBUTE_UNUSED)
3357 {
3358   struct elf32_csky_stub_hash_entry *stub_entry;
3359   const insn_sequence *template_sequence = NULL;
3360   int template_size = 0;
3361   int size = 0;
3362
3363   /* Massage our args to the form they really have.  */
3364   stub_entry = (struct elf32_csky_stub_hash_entry *) gen_entry;
3365
3366   BFD_ASSERT (stub_entry->stub_type > csky_stub_none
3367               && stub_entry->stub_type < ARRAY_SIZE (stub_definitions));
3368   size = find_stub_size_and_template (stub_entry->stub_type,
3369                                       &template_sequence, &template_size);
3370   stub_entry->stub_size = size;
3371   stub_entry->stub_template = template_sequence;
3372   stub_entry->stub_template_size = template_size;
3373
3374   size = (size + 7) & ~7;
3375   stub_entry->stub_sec->size += size;
3376   return true;
3377 }
3378
3379 /* Add a new stub entry to the stub hash.  Not all fields of the new
3380    stub entry are initialised.  */
3381
3382 static struct elf32_csky_stub_hash_entry *
3383 elf32_csky_add_stub (const char *stub_name,
3384                      asection *section,
3385                      struct csky_elf_link_hash_table *htab)
3386 {
3387   asection *link_sec;
3388   asection *stub_sec;
3389   struct elf32_csky_stub_hash_entry *stub_entry;
3390
3391   stub_sec = elf32_csky_create_or_find_stub_sec (&link_sec, section, htab);
3392   if (stub_sec == NULL)
3393     return NULL;
3394
3395   /* Enter this entry into the linker stub hash table.  */
3396   stub_entry = csky_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3397                                       true, false);
3398   if (stub_entry == NULL)
3399     {
3400       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3401                           section->owner, stub_name);
3402       return NULL;
3403     }
3404
3405   stub_entry->stub_sec = stub_sec;
3406   stub_entry->stub_offset = 0;
3407   stub_entry->id_sec = link_sec;
3408
3409   return stub_entry;
3410 }
3411
3412 /* Determine and set the size of the stub section for a final link.
3413    The basic idea here is to examine all the relocations looking for
3414    PC-relative calls to a target that is unreachable with a "bsr"
3415    instruction.  */
3416
3417 bool
3418 elf32_csky_size_stubs (bfd *output_bfd,
3419                        bfd *stub_bfd,
3420                        struct bfd_link_info *info,
3421                        bfd_signed_vma group_size,
3422                        asection *(*add_stub_section) (const char*, asection*),
3423                        void (*layout_sections_again) (void))
3424 {
3425   bfd_size_type stub_group_size;
3426   bool stubs_always_after_branch;
3427   struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3428
3429   if (htab == NULL)
3430     return false;
3431
3432   /* Propagate mach to stub bfd, because it may not have been
3433      finalized when we created stub_bfd.  */
3434   bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
3435                      bfd_get_mach (output_bfd));
3436
3437   /* Stash our params away.  */
3438   htab->stub_bfd = stub_bfd;
3439   htab->add_stub_section = add_stub_section;
3440   htab->layout_sections_again = layout_sections_again;
3441   stubs_always_after_branch = group_size < 0;
3442
3443   if (group_size < 0)
3444     stub_group_size = -group_size;
3445   else
3446     stub_group_size = group_size;
3447
3448   if (stub_group_size == 1)
3449     /* The 'bsr' range in abiv2 is +-64MB has to be used as the
3450        default maximum size.
3451        This value is 128K less than that, which allows for 131072
3452        byte stubs. If we exceed that, then we will fail to link.
3453        The user will have to relink with an explicit group size
3454        option.  */
3455     stub_group_size = 66977792;
3456
3457   group_sections (htab, stub_group_size, stubs_always_after_branch);
3458
3459   while (1)
3460     {
3461       bfd *input_bfd;
3462       unsigned int bfd_indx;
3463       asection *stub_sec;
3464       bool stub_changed = false;
3465
3466       for (input_bfd = info->input_bfds, bfd_indx = 0;
3467            input_bfd != NULL;
3468            input_bfd = input_bfd->link.next, bfd_indx++)
3469         {
3470           Elf_Internal_Shdr *symtab_hdr;
3471           asection *section;
3472           Elf_Internal_Sym *local_syms = NULL;
3473
3474           /* We'll need the symbol table in a second.  */
3475           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3476           if (symtab_hdr->sh_info == 0)
3477             continue;
3478
3479           /* Walk over each section attached to the input bfd.  */
3480           for (section = input_bfd->sections;
3481                section != NULL;
3482                section = section->next)
3483             {
3484               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3485
3486               /* If there aren't any relocs, then there's nothing more
3487                * to do.  */
3488               if ((section->flags & SEC_RELOC) == 0
3489                   || section->reloc_count == 0
3490                   || (section->flags & SEC_CODE) == 0)
3491                 continue;
3492
3493               /* If this section is a link-once section that will be
3494                  discarded, then don't create any stubs.  */
3495               if (section->output_section == NULL
3496                   || section->output_section->owner != output_bfd)
3497                 continue;
3498
3499               /* Get the relocs.  */
3500               internal_relocs = _bfd_elf_link_read_relocs (input_bfd,
3501                                                            section,
3502                                                            NULL, NULL,
3503                                                            info->keep_memory);
3504
3505               if (internal_relocs == NULL)
3506                 goto error_ret_free_local;
3507
3508               /* Now examine each relocation.  */
3509               irela = internal_relocs;
3510               irelaend = irela + section->reloc_count;
3511               for (; irela < irelaend; irela++)
3512                 {
3513                   unsigned int r_type, r_indx;
3514                   enum elf32_csky_stub_type stub_type;
3515                   struct elf32_csky_stub_hash_entry *stub_entry;
3516                   asection *sym_sec;
3517                   bfd_vma sym_value;
3518                   bfd_vma destination;
3519                   struct csky_elf_link_hash_entry *hash;
3520                   const char *sym_name;
3521                   char *stub_name;
3522                   const asection *id_sec;
3523                   unsigned char st_type;
3524
3525                   r_type = ELF32_R_TYPE (irela->r_info);
3526                   r_indx = ELF32_R_SYM (irela->r_info);
3527                   if (r_type >= (unsigned int) R_CKCORE_MAX)
3528                     {
3529                       bfd_set_error (bfd_error_bad_value);
3530                     error_ret_free_internal:
3531                       if (elf_section_data (section)->relocs == NULL)
3532                         free (internal_relocs);
3533                       goto error_ret_free_local;
3534                     }
3535
3536                   /* Only look for stubs on branch instructions.  */
3537                   if (r_type != (unsigned int) R_CKCORE_PCREL_IMM26BY2)
3538                     continue;
3539                   /* Now determine the call target, its name, value,
3540                      section.  */
3541                   sym_sec = NULL;
3542                   sym_value = 0;
3543                   destination = 0;
3544                   hash = NULL;
3545                   sym_name = NULL;
3546                   if (r_indx < symtab_hdr->sh_info)
3547                     {
3548                       /* It's a local symbol.  */
3549                       Elf_Internal_Sym *sym;
3550                       Elf_Internal_Shdr *hdr;
3551                       if (local_syms == NULL)
3552                         local_syms =
3553                           (Elf_Internal_Sym *) symtab_hdr->contents;
3554                       if (local_syms == NULL)
3555                         {
3556                           local_syms =
3557                             bfd_elf_get_elf_syms (input_bfd,
3558                                                   symtab_hdr,
3559                                                   symtab_hdr->sh_info,
3560                                                   0, NULL, NULL, NULL);
3561                           if (local_syms == NULL)
3562                             goto error_ret_free_internal;
3563                         }
3564                       sym = local_syms + r_indx;
3565                       hdr = elf_elfsections (input_bfd)[sym->st_shndx];
3566                       sym_sec = hdr->bfd_section;
3567                       if (!sym_sec)
3568                         /* This is an undefined symbol.  It can never
3569                            be resolved.  */
3570                         continue;
3571                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3572                         sym_value = sym->st_value;
3573                       destination = (sym_value + irela->r_addend
3574                                      + sym_sec->output_offset
3575                                      + sym_sec->output_section->vma);
3576                       st_type = ELF_ST_TYPE (sym->st_info);
3577                       sym_name =
3578                         bfd_elf_string_from_elf_section (input_bfd,
3579                                                          symtab_hdr->sh_link,
3580                                                          sym->st_name);
3581                     }
3582                   else
3583                     {
3584                       /* It's an external symbol.  */
3585                       int e_indx;
3586                       e_indx = r_indx - symtab_hdr->sh_info;
3587                       hash = ((struct csky_elf_link_hash_entry *)
3588                               elf_sym_hashes (input_bfd)[e_indx]);
3589
3590                       while (hash->elf.root.type == bfd_link_hash_indirect
3591                              || hash->elf.root.type == bfd_link_hash_warning)
3592                         hash = ((struct csky_elf_link_hash_entry *)
3593                                 hash->elf.root.u.i.link);
3594                       if (hash->elf.root.type == bfd_link_hash_defined
3595                           || hash->elf.root.type == bfd_link_hash_defweak)
3596                         {
3597                           sym_sec = hash->elf.root.u.def.section;
3598                           sym_value = hash->elf.root.u.def.value;
3599
3600                           struct csky_elf_link_hash_table *globals =
3601                             csky_elf_hash_table (info);
3602                           /* FIXME For a destination in a shared library.  */
3603                           if (globals->elf.splt != NULL && hash != NULL
3604                               && hash->elf.plt.offset != (bfd_vma) -1)
3605                             continue;
3606                           else if (sym_sec->output_section != NULL)
3607                             destination = (sym_value + irela->r_addend
3608                                            + sym_sec->output_offset
3609                                            + sym_sec->output_section->vma);
3610                         }
3611                       else if (hash->elf.root.type == bfd_link_hash_undefined
3612                                || (hash->elf.root.type
3613                                    == bfd_link_hash_undefweak))
3614                         /* FIXME For a destination in a shared library.  */
3615                         continue;
3616                       else
3617                         {
3618                           bfd_set_error (bfd_error_bad_value);
3619                           goto error_ret_free_internal;
3620                         }
3621                       st_type = ELF_ST_TYPE (hash->elf.type);
3622                       sym_name = hash->elf.root.root.string;
3623                     }
3624                   do
3625                     {
3626                       /* Determine what (if any) linker stub is needed.  */
3627                       stub_type = csky_type_of_stub (info, section, irela,
3628                                                      st_type, hash,
3629                                                      destination, sym_sec,
3630                                                      input_bfd, sym_name);
3631                       if (stub_type == csky_stub_none)
3632                         break;
3633
3634                       /* Support for grouping stub sections.  */
3635                       id_sec = htab->stub_group[section->id].link_sec;
3636
3637                       /* Get the name of this stub.  */
3638                       stub_name = elf32_csky_stub_name (id_sec, sym_sec, hash,
3639                                                         irela);
3640                       if (!stub_name)
3641                         goto error_ret_free_internal;
3642                       /* We've either created a stub for this reloc already,
3643                          or we are about to.  */
3644                       stub_entry
3645                         = csky_stub_hash_lookup (&htab->stub_hash_table,
3646                                                  stub_name,
3647                                                  false, false);
3648                       if (stub_entry != NULL)
3649                         {
3650                           /* The proper stub has already been created.  */
3651                           free (stub_name);
3652                           stub_entry->target_value = sym_value;
3653                           break;
3654                         }
3655                       stub_entry = elf32_csky_add_stub (stub_name, section,
3656                                                         htab);
3657                       if (stub_entry == NULL)
3658                         {
3659                           free (stub_name);
3660                           goto error_ret_free_internal;
3661                         }
3662                       stub_entry->target_value = sym_value;
3663                       stub_entry->target_section = sym_sec;
3664                       stub_entry->stub_type = stub_type;
3665                       stub_entry->h = hash;
3666                       stub_entry->st_type = st_type;
3667
3668                       if (sym_name == NULL)
3669                         sym_name = "unnamed";
3670                       stub_entry->output_name =
3671                         bfd_alloc (htab->stub_bfd,
3672                                    (sizeof (STUB_ENTRY_NAME)
3673                                     + strlen (sym_name)));
3674                       if (stub_entry->output_name == NULL)
3675                         {
3676                           free (stub_name);
3677                           goto error_ret_free_internal;
3678                         }
3679                       sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
3680                                sym_name);
3681                       stub_changed = true;
3682                     }
3683                   while (0);
3684                 }
3685               /* We're done with the internal relocs, free them.  */
3686               if (elf_section_data (section)->relocs == NULL)
3687                 free (internal_relocs);
3688             }
3689         }
3690       if (!stub_changed)
3691         break;
3692       /* OK, we've added some stubs.  Find out the new size of the
3693          stub sections.  */
3694       for (stub_sec = htab->stub_bfd->sections;
3695            stub_sec != NULL;
3696            stub_sec = stub_sec->next)
3697         {
3698           /* Ignore non-stub sections.  */
3699           if (!strstr (stub_sec->name, STUB_SUFFIX))
3700             continue;
3701           stub_sec->size = 0;
3702         }
3703       bfd_hash_traverse (&htab->stub_hash_table, csky_size_one_stub, htab);
3704       /* Ask the linker to do its stuff.  */
3705       (*htab->layout_sections_again) ();
3706     }
3707
3708   return true;
3709  error_ret_free_local:
3710   return false;
3711 }
3712
3713 static bool
3714 csky_build_one_stub (struct bfd_hash_entry *gen_entry,
3715                      void * in_arg)
3716 {
3717 #define MAXRELOCS 2
3718   struct elf32_csky_stub_hash_entry *stub_entry;
3719   struct bfd_link_info *info;
3720   asection *stub_sec;
3721   bfd *stub_bfd;
3722   bfd_byte *loc;
3723   bfd_vma sym_value;
3724   int template_size;
3725   int size;
3726   const insn_sequence *template_sequence;
3727   int i;
3728   struct csky_elf_link_hash_table * globals;
3729   int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3730   int stub_reloc_offset[MAXRELOCS] = {0, 0};
3731   int nrelocs = 0;
3732   struct elf_link_hash_entry *h = NULL;
3733
3734   /* Massage our args to the form they really have.  */
3735   stub_entry = (struct elf32_csky_stub_hash_entry *)gen_entry;
3736   info = (struct bfd_link_info *) in_arg;
3737
3738   /* Fail if the target section could not be assigned to an output
3739      section.  The user should fix his linker script.  */
3740   if (stub_entry->target_section->output_section == NULL
3741       && info->non_contiguous_regions)
3742     info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
3743                               "Retry without --enable-non-contiguous-regions.\n"),
3744                             stub_entry->target_section);
3745
3746   globals = csky_elf_hash_table (info);
3747   if (globals == NULL)
3748     return false;
3749   stub_sec = stub_entry->stub_sec;
3750
3751   /* Make a note of the offset within the stubs for this entry.  */
3752   stub_entry->stub_offset = stub_sec->size;
3753   loc = stub_sec->contents + stub_entry->stub_offset;
3754
3755   stub_bfd = stub_sec->owner;
3756
3757   /* This is the address of the stub destination.  */
3758   h = &stub_entry->h->elf;
3759   if (sym_must_create_stub (h, info)
3760       && !(bfd_link_pic (info)
3761            && h->root.type == bfd_link_hash_defweak
3762            && h->def_regular
3763            && !h->def_dynamic))
3764     sym_value = 0;
3765   else
3766     sym_value = (stub_entry->target_value
3767                  + stub_entry->target_section->output_offset
3768                  + stub_entry->target_section->output_section->vma);
3769
3770   template_sequence = stub_entry->stub_template;
3771   template_size = stub_entry->stub_template_size;
3772
3773   size = 0;
3774   for (i = 0; i < template_size; i++)
3775     switch (template_sequence[i].type)
3776       {
3777       case INSN16:
3778         bfd_put_16 (stub_bfd, (bfd_vma) template_sequence[i].data,
3779                     loc + size);
3780         size += 2;
3781         break;
3782       case INSN32:
3783         csky_put_insn_32 (stub_bfd, (bfd_vma) template_sequence[i].data,
3784                           loc + size);
3785         size += 4;
3786         break;
3787       case DATA_TYPE:
3788         bfd_put_32 (stub_bfd, (bfd_vma) template_sequence[i].data,
3789                     loc + size);
3790         stub_reloc_idx[nrelocs] = i;
3791         stub_reloc_offset[nrelocs++] = size;
3792         size += 4;
3793         break;
3794       default:
3795         BFD_FAIL ();
3796         return false;
3797       }
3798   stub_sec->size += size;
3799
3800   /* Stub size has already been computed in csky_size_one_stub. Check
3801      consistency.  */
3802   BFD_ASSERT (size == stub_entry->stub_size);
3803
3804   /* Assume there is at least one and at most MAXRELOCS entries to relocate
3805      in each stub.  */
3806   BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
3807
3808   for (i = 0; i < nrelocs; i++)
3809     {
3810       if (sym_must_create_stub (h, info))
3811         {
3812           Elf_Internal_Rela outrel;
3813           asection * sreloc = globals->elf.srelgot;
3814
3815           outrel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3816           outrel.r_info =
3817             ELF32_R_INFO (h->dynindx,
3818                           template_sequence[stub_reloc_idx[i]].r_type);
3819           outrel.r_addend = template_sequence[stub_reloc_idx[i]].reloc_addend;
3820
3821           loc = sreloc->contents;
3822           loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3823
3824           if (loc != NULL)
3825             bfd_elf32_swap_reloca_out (info->output_bfd, &outrel, loc);
3826         }
3827       _bfd_final_link_relocate (elf32_csky_howto_from_type
3828                                   (template_sequence[stub_reloc_idx[i]].r_type),
3829                                 stub_bfd, stub_sec, stub_sec->contents,
3830                                 stub_entry->stub_offset + stub_reloc_offset[i],
3831                                 sym_value + stub_entry->target_addend,
3832                                 template_sequence[stub_reloc_idx[i]].reloc_addend);
3833     }
3834
3835   return true;
3836 #undef MAXRELOCS
3837 }
3838
3839 /* Build all the stubs associated with the current output file.  The
3840    stubs are kept in a hash table attached to the main linker hash
3841    table.  We also set up the .plt entries for statically linked PIC
3842    functions here.  This function is called via arm_elf_finish in the
3843    linker.  */
3844
3845 bool
3846 elf32_csky_build_stubs (struct bfd_link_info *info)
3847 {
3848   asection *stub_sec;
3849   struct bfd_hash_table *table;
3850   struct csky_elf_link_hash_table *htab;
3851
3852   htab = csky_elf_hash_table (info);
3853
3854   if (htab == NULL)
3855     return false;
3856
3857   for (stub_sec = htab->stub_bfd->sections;
3858        stub_sec != NULL;
3859        stub_sec = stub_sec->next)
3860     {
3861       bfd_size_type size;
3862
3863       /* Ignore non-stub sections.  */
3864       if (!strstr (stub_sec->name, STUB_SUFFIX))
3865         continue;
3866
3867       /* Allocate memory to hold the linker stubs.  */
3868       size = stub_sec->size;
3869       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3870       if (stub_sec->contents == NULL && size != 0)
3871         return false;
3872       stub_sec->size = 0;
3873     }
3874
3875   /* Build the stubs as directed by the stub hash table.  */
3876   table = &htab->stub_hash_table;
3877   bfd_hash_traverse (table, csky_build_one_stub, info);
3878
3879   return true;
3880 }
3881
3882 /* Set up various things so that we can make a list of input sections
3883    for each output section included in the link.  Returns -1 on error,
3884    0 when no stubs will be needed, and 1 on success.  */
3885
3886 int
3887 elf32_csky_setup_section_lists (bfd *output_bfd,
3888                                 struct bfd_link_info *info)
3889 {
3890   bfd *input_bfd;
3891   unsigned int bfd_count;
3892   unsigned int top_id, top_index;
3893   asection *section;
3894   asection **input_list, **list;
3895   size_t amt;
3896   struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3897
3898   if (!htab)
3899     return 0;
3900
3901   /* Count the number of input BFDs and find the top input section id.  */
3902   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3903        input_bfd != NULL;
3904        input_bfd = input_bfd->link.next)
3905     {
3906       bfd_count += 1;
3907       for (section = input_bfd->sections;
3908            section != NULL;
3909            section = section->next)
3910         if (top_id < section->id)
3911           top_id = section->id;
3912     }
3913   htab->bfd_count = bfd_count;
3914   amt = sizeof (struct map_stub) * (top_id + 1);
3915   htab->stub_group = bfd_zmalloc (amt);
3916   if (htab->stub_group == NULL)
3917     return -1;
3918
3919   /* We can't use output_bfd->section_count here to find the top output
3920      section index as some sections may have been removed, and
3921      _bfd_strip_section_from_output doesn't renumber the indices.  */
3922   for (section = output_bfd->sections, top_index = 0;
3923        section != NULL;
3924        section = section->next)
3925     if (top_index < section->index)
3926       top_index = section->index;
3927   htab->top_index = top_index;
3928   amt = sizeof (asection *) * (top_index + 1);
3929   input_list = bfd_malloc (amt);
3930   htab->input_list = input_list;
3931   if (input_list == NULL)
3932     return -1;
3933   /* For sections we aren't interested in, mark their entries with a
3934      value we can check later.  */
3935   list = input_list + top_index;
3936   do
3937     *list = bfd_abs_section_ptr;
3938   while (list-- != input_list);
3939   for (section = output_bfd->sections;
3940        section != NULL;
3941        section = section->next)
3942     if ((section->flags & SEC_CODE) != 0)
3943       input_list[section->index] = NULL;
3944
3945   return 1;
3946 }
3947
3948 static bfd_reloc_status_type
3949 csky_relocate_contents (reloc_howto_type *howto,
3950                         bfd *input_bfd,
3951                         bfd_vma relocation,
3952                         bfd_byte *location)
3953 {
3954   int size;
3955   bfd_vma x = 0;
3956   bfd_reloc_status_type flag;
3957   unsigned int rightshift = howto->rightshift;
3958   unsigned int bitpos = howto->bitpos;
3959
3960   if (howto->negate)
3961     relocation = -relocation;
3962
3963   /* FIXME: these macros should be defined at file head or head file head.  */
3964 #define CSKY_INSN_ADDI_TO_SUBI        0x04000000
3965 #define CSKY_INSN_MOV_RTB             0xc41d4820   /* mov32 rx, r29, 0 */
3966 #define CSKY_INSN_MOV_RDB             0xc41c4820   /* mov32 rx, r28, 0 */
3967 #define CSKY_INSN_GET_ADDI_RZ(x)      (((x) & 0x03e00000) >> 21)
3968 #define CSKY_INSN_SET_MOV_RZ(x)       ((x) & 0x0000001f)
3969 #define CSKY_INSN_JSRI_TO_LRW         0xea9a0000
3970 #define CSKY_INSN_JSR_R26             0xe8fa0000
3971
3972   /* Get the value we are going to relocate.  */
3973   size = bfd_get_reloc_size (howto);
3974   switch (size)
3975     {
3976     default:
3977     case 0:
3978       abort ();
3979     case 1:
3980       x = bfd_get_8 (input_bfd, location);
3981       break;
3982     case 2:
3983       x = bfd_get_16 (input_bfd, location);
3984       break;
3985     case 4:
3986       if (need_reverse_bits)
3987         {
3988           x = csky_get_insn_32 (input_bfd, location);
3989
3990           if (R_CKCORE_DOFFSET_LO16 == howto->type)
3991             {
3992               if ((bfd_signed_vma) relocation < 0)
3993                 {
3994                   x |= CSKY_INSN_ADDI_TO_SUBI;
3995                   relocation = -relocation;
3996                 }
3997               else if (0 == relocation)
3998                 x = (CSKY_INSN_MOV_RDB |
3999                      CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x)));
4000             }
4001           else if (R_CKCORE_TOFFSET_LO16 == howto->type)
4002             {
4003               if ((bfd_signed_vma) relocation < 0)
4004                 {
4005                   x |= CSKY_INSN_ADDI_TO_SUBI;
4006                   relocation = -relocation;
4007                 }
4008               else if (0 == relocation)
4009                 x = (CSKY_INSN_MOV_RTB |
4010                      CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x)));
4011             }
4012         }
4013       else
4014         x = bfd_get_32 (input_bfd, location);
4015       break;
4016     }
4017   /* Check for overflow.  FIXME: We may drop bits during the addition
4018      which we don't check for.  We must either check at every single
4019      operation, which would be tedious, or we must do the computations
4020      in a type larger than bfd_vma, which would be inefficient.  */
4021   flag = bfd_reloc_ok;
4022   if (howto->complain_on_overflow != complain_overflow_dont)
4023     {
4024       bfd_vma addrmask;
4025       bfd_vma fieldmask;
4026       bfd_vma signmask;
4027       bfd_vma ss;
4028       bfd_vma a;
4029       bfd_vma b;
4030       bfd_vma sum;
4031       /* Get the values to be added together.  For signed and unsigned
4032          relocations, we assume that all values should be truncated to
4033          the size of an address.  For bitfields, all the bits matter.
4034          See also bfd_check_overflow.  */
4035 #define N_ONES(n)      (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
4036       fieldmask = N_ONES (howto->bitsize);
4037       signmask  = ~fieldmask;
4038       addrmask  = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4039       a = (relocation & addrmask) >> rightshift;
4040       if (read_content_substitute)
4041         x = read_content_substitute;
4042       b = (x & howto->src_mask & addrmask) >> bitpos;
4043
4044       switch (howto->complain_on_overflow)
4045         {
4046         case complain_overflow_signed:
4047           /* If any sign bits are set, all sign bits must be set.
4048              That is, A must be a valid negative address after
4049              shifting.  */
4050           signmask = ~(fieldmask >> 1);
4051           /* Fall through.  */
4052
4053         case complain_overflow_bitfield:
4054           /* Much like the signed check, but for a field one bit
4055              wider.  We allow a bitfield to represent numbers in the
4056              range -2**n to 2**n-1, where n is the number of bits in the
4057              field.  Note that when bfd_vma is 32 bits, a 32-bit reloc
4058              can't overflow, which is exactly what we want.  */
4059           ss = a & signmask;
4060           if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4061             flag = bfd_reloc_overflow;
4062           /* We only need this next bit of code if the sign bit of B
4063              is below the sign bit of A.  This would only happen if
4064              SRC_MASK had fewer bits than BITSIZE.  Note that if
4065              SRC_MASK has more bits than BITSIZE, we can get into
4066              trouble; we would need to verify that B is in range, as
4067              we do for A above.  */
4068           ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4069           ss >>= bitpos;
4070
4071           /* Set all the bits above the sign bit.  */
4072           b = (b ^ ss) - ss;
4073
4074           /* Now we can do the addition.  */
4075           sum = a + b;
4076
4077           /* See if the result has the correct sign.  Bits above the
4078              sign bit are junk now; ignore them.  If the sum is
4079              positive, make sure we did not have all negative inputs;
4080              if the sum is negative, make sure we did not have all
4081              positive inputs.  The test below looks only at the sign
4082              bits, and it really just
4083              SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4084
4085              We mask with addrmask here to explicitly allow an address
4086              wrap-around.  The Linux kernel relies on it, and it is
4087              the only way to write assembler code which can run when
4088              loaded at a location 0x80000000 away from the location at
4089              which it is linked.  */
4090
4091           if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4092             flag = bfd_reloc_overflow;
4093           break;
4094         case complain_overflow_unsigned:
4095           /* Checking for an unsigned overflow is relatively easy:
4096              trim the addresses and add, and trim the result as well.
4097              Overflow is normally indicated when the result does not
4098              fit in the field.  However, we also need to consider the
4099              case when, e.g., fieldmask is 0x7fffffff or smaller, an
4100              input is 0x80000000, and bfd_vma is only 32 bits; then we
4101              will get sum == 0, but there is an overflow, since the
4102              inputs did not fit in the field.  Instead of doing a
4103              separate test, we can check for this by or-ing in the
4104              operands when testing for the sum overflowing its final
4105              field.  */
4106           sum = (a + b) & addrmask;
4107           if ((a | b | sum) & signmask)
4108             flag = bfd_reloc_overflow;
4109           break;
4110         default:
4111           abort ();
4112         }
4113
4114     }
4115   /* Put RELOCATION in the right bits.  */
4116   relocation >>= rightshift;
4117
4118   if ((howto->type == R_CKCORE_DOFFSET_LO16
4119        || howto->type == R_CKCORE_TOFFSET_LO16)
4120       && relocation == 0)
4121     /* Do nothing lsli32 rx, rz, 0.  */
4122     ;
4123   else
4124     {
4125       /* Fir V1, all this relocation must be x -1.  */
4126       if (howto->type == R_CKCORE_PCREL_IMM11BY2
4127           || howto->type == R_CKCORE_PCREL_JSR_IMM11BY2
4128           || howto->type == R_CKCORE_DOFFSET_LO16
4129           || howto->type == R_CKCORE_TOFFSET_LO16)
4130         relocation -= 1;
4131       else if (howto->type == R_CKCORE_PCREL_IMM7BY4)
4132         relocation = (relocation & 0x1f) + ((relocation << 3) & 0x300);
4133       else if (howto->type == R_CKCORE_PCREL_FLRW_IMM8BY4)
4134         relocation
4135           = ((relocation << 4) & 0xf0) + ((relocation << 17) & 0x1e00000);
4136       else if (howto->type == R_CKCORE_NOJSRI)
4137         {
4138           x = (x & howto->dst_mask) | CSKY_INSN_JSRI_TO_LRW;
4139           relocation = 0;
4140           csky_put_insn_32 (input_bfd, CSKY_INSN_JSR_R26, location + 4);
4141         }
4142
4143       relocation <<= bitpos;
4144       /* Add RELOCATION to the right bits of X.  */
4145       x = ((x & ~howto->dst_mask)
4146            | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4147     }
4148   /* Put the relocated value back in the object file.  */
4149   switch (size)
4150     {
4151     default:
4152       abort ();
4153     case 1:
4154       bfd_put_8 (input_bfd, x, location);
4155       break;
4156     case 2:
4157       bfd_put_16 (input_bfd, x, location);
4158       break;
4159     case 4:
4160       if (need_reverse_bits)
4161         csky_put_insn_32 (input_bfd, x, location);
4162       else
4163         bfd_put_32 (input_bfd, x, location);
4164       break;
4165     }
4166   return flag;
4167 }
4168
4169 /* Look up an entry in the stub hash. Stub entries are cached because
4170    creating the stub name takes a bit of time.  */
4171
4172 static struct elf32_csky_stub_hash_entry *
4173 elf32_csky_get_stub_entry (const asection *input_section,
4174                            const asection *sym_sec,
4175                            struct elf_link_hash_entry *hash,
4176                            const Elf_Internal_Rela *rel,
4177                            struct csky_elf_link_hash_table *htab)
4178 {
4179   struct elf32_csky_stub_hash_entry *stub_entry;
4180   struct csky_elf_link_hash_entry *h
4181     = (struct csky_elf_link_hash_entry *) hash;
4182   const asection *id_sec;
4183
4184   if ((input_section->flags & SEC_CODE) == 0)
4185     return NULL;
4186
4187   /* If this input section is part of a group of sections sharing one
4188      stub section, then use the id of the first section in the group.
4189      Stub names need to include a section id, as there may well be
4190      more than one stub used to reach say, printf, and we need to
4191      distinguish between them.  */
4192   id_sec = htab->stub_group[input_section->id].link_sec;
4193   if (h != NULL && h->stub_cache != NULL
4194       && h->stub_cache->h == h && h->stub_cache->id_sec == id_sec)
4195     stub_entry = h->stub_cache;
4196   else
4197     {
4198       char *stub_name;
4199       stub_name = elf32_csky_stub_name (id_sec, sym_sec, h, rel);
4200       if (stub_name == NULL)
4201         return NULL;
4202       stub_entry = csky_stub_hash_lookup (&htab->stub_hash_table,
4203                                           stub_name, false, false);
4204       if (h != NULL)
4205         h->stub_cache = stub_entry;
4206       free (stub_name);
4207     }
4208
4209   return stub_entry;
4210 }
4211
4212 static bfd_reloc_status_type
4213 csky_final_link_relocate (reloc_howto_type *howto,
4214                           bfd *input_bfd,
4215                           asection *input_section,
4216                           bfd_byte *contents,
4217                           bfd_vma address,
4218                           bfd_vma value,
4219                           bfd_vma addend)
4220 {
4221   bfd_vma relocation;
4222
4223   /* Sanity check the address.  */
4224   if (address > bfd_get_section_limit (input_bfd, input_section))
4225     return bfd_reloc_outofrange;
4226
4227   /* This function assumes that we are dealing with a basic relocation
4228      against a symbol. We want to compute the value of the symbol to
4229      relocate to. This is just VALUE, the value of the symbol,
4230      plus ADDEND, any addend associated with the reloc.  */
4231   relocation = value + addend;
4232
4233   /* If the relocation is PC relative, we want to set RELOCATION to
4234      the distance between the symbol (currently in RELOCATION) and the
4235      location we are relocating. Some targets (e.g., i386-aout)
4236      arrange for the contents of the section to be the negative of the
4237      offset of the location within the section; for such targets
4238      pcrel_offset is FALSE.  Other targets (e.g., m88kbcs or ELF)
4239      simply leave the contents of the section as zero; for such
4240      targets pcrel_offset is TRUE.  If pcrel_offset is FALSE we do not
4241      need to subtract out the offset of the location within the
4242      section (which is just ADDRESS).  */
4243   if (howto->pc_relative)
4244     {
4245       relocation -= (input_section->output_section->vma
4246                      + input_section->output_offset);
4247       if (howto->pcrel_offset)
4248         relocation -= address;
4249     }
4250
4251   return csky_relocate_contents (howto, input_bfd, relocation,
4252                                  contents + address);
4253
4254 }
4255
4256 /* Return the base VMA address which should be subtracted from real addresses
4257    when resolving @dtpoff relocation.
4258    This is PT_TLS segment p_vaddr.  */
4259
4260 static bfd_vma
4261 dtpoff_base (struct bfd_link_info *info)
4262 {
4263   /* If tls_sec is NULL, we should have signalled an error already.  */
4264   if (elf_hash_table (info)->tls_sec == NULL)
4265     return 0;
4266   return elf_hash_table (info)->tls_sec->vma;
4267 }
4268
4269 /* Return the relocation value for @tpoff relocation
4270    if STT_TLS virtual address is ADDRESS.  */
4271
4272 static bfd_vma
4273 tpoff (struct bfd_link_info *info, bfd_vma address)
4274 {
4275   struct elf_link_hash_table *htab = elf_hash_table (info);
4276   bfd_vma base;
4277
4278   /* If tls_sec is NULL, we should have signalled an error already.  */
4279   if (htab->tls_sec == NULL)
4280     return 0;
4281   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
4282   return address - htab->tls_sec->vma + base;
4283 }
4284
4285 /* Relocate a csky section.  */
4286
4287 static int
4288 csky_elf_relocate_section (bfd *                  output_bfd,
4289                            struct bfd_link_info * info,
4290                            bfd *                  input_bfd,
4291                            asection *             input_section,
4292                            bfd_byte *             contents,
4293                            Elf_Internal_Rela *    relocs,
4294                            Elf_Internal_Sym *     local_syms,
4295                            asection **            local_sections)
4296 {
4297   Elf_Internal_Shdr *symtab_hdr;
4298   struct elf_link_hash_entry **sym_hashes;
4299   Elf_Internal_Rela *rel;
4300   Elf_Internal_Rela *relend;
4301   const char *name;
4302   bool ret = true;
4303   struct csky_elf_link_hash_table * htab;
4304   bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
4305
4306   htab = csky_elf_hash_table (info);
4307   if (htab == NULL)
4308     return false;
4309
4310   symtab_hdr = & elf_symtab_hdr (input_bfd);
4311   sym_hashes = elf_sym_hashes (input_bfd);
4312
4313   rel = relocs;
4314   relend = relocs + input_section->reloc_count;
4315   for (; rel < relend; rel++)
4316     {
4317       enum elf_csky_reloc_type r_type
4318         = (enum elf_csky_reloc_type) ELF32_R_TYPE (rel->r_info);
4319       unsigned long r_symndx;
4320       reloc_howto_type *howto;
4321       Elf_Internal_Sym *sym;
4322       asection *sec;
4323       bfd_vma relocation;
4324       bfd_vma off;
4325       struct elf_link_hash_entry * h;
4326       bfd_vma addend = (bfd_vma)rel->r_addend;
4327       bfd_reloc_status_type r = bfd_reloc_ok;
4328       bool unresolved_reloc = false;
4329       int do_final_relocate = true;
4330       bool relative_reloc = false;
4331       bfd_signed_vma disp;
4332
4333       /* Ignore these relocation types:
4334          R_CKCORE_GNU_VTINHERIT, R_CKCORE_GNU_VTENTRY.  */
4335       if (r_type == R_CKCORE_GNU_VTINHERIT || r_type == R_CKCORE_GNU_VTENTRY)
4336         continue;
4337
4338       if ((unsigned) r_type >= (unsigned) R_CKCORE_MAX)
4339         {
4340           /* The r_type is error, not support it.  */
4341           /* xgettext:c-format */
4342           _bfd_error_handler (_("%pB: unsupported relocation type: %#x"),
4343                               input_bfd, r_type);
4344           bfd_set_error (bfd_error_bad_value);
4345           ret = false;
4346           continue;
4347         }
4348
4349       howto = &csky_elf_howto_table[(int) r_type];
4350
4351       r_symndx = ELF32_R_SYM(rel->r_info);
4352       h = NULL;
4353       sym = NULL;
4354       sec = NULL;
4355       unresolved_reloc = false;
4356
4357       if (r_symndx < symtab_hdr->sh_info)
4358         {
4359           /* Get symbol table entry.  */
4360           sym = local_syms + r_symndx;
4361           sec = local_sections[r_symndx];
4362           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4363           addend = (bfd_vma)rel->r_addend;
4364         }
4365       else
4366         {
4367           bool warned, ignored;
4368
4369           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4370                                    r_symndx, symtab_hdr, sym_hashes,
4371                                    h, sec, relocation,
4372                                    unresolved_reloc, warned, ignored);
4373         }
4374
4375       if (sec != NULL && discarded_section (sec))
4376         {
4377           /* For relocs against symbols from removed linkonce sections,
4378              or sections discarded by a linker script, we just want the
4379              section contents zeroed.  Avoid any special processing.
4380              And if the symbol is referenced in '.csky_stack_size' section,
4381              set the address to SEC_DISCARDED(0xffffffff).  */
4382 #if 0
4383           /* The .csky_stack_size section is just for callgraph.  */
4384           if (strcmp (input_section->name, ".csky_stack_size") == 0)
4385             {
4386 /* FIXME: it should define in head file.  */
4387 #define SEC_DISCARDED   0xffffffff
4388               bfd_put_32 (input_bfd, SEC_DISCARDED, contents + rel->r_offset);
4389               rel->r_info = 0;
4390               rel->r_addend = 0;
4391               continue;
4392             }
4393           else
4394 #endif
4395             RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4396                                              rel, 1, relend, howto, 0,
4397                                              contents);
4398         }
4399
4400       if (bfd_link_relocatable (info))
4401         continue;
4402
4403       read_content_substitute = 0;
4404
4405       /* Final link.  */
4406       disp = (relocation
4407               + (bfd_signed_vma) addend
4408               - input_section->output_section->vma
4409               - input_section->output_offset
4410               - rel->r_offset);
4411 /* It is for ck8xx.  */
4412 #define CSKY_INSN_BSR32   0xe0000000
4413 /* It is for ck5xx/ck6xx.  */
4414 #define CSKY_INSN_BSR16   0xf800
4415 #define within_range(x, L)  (-(1 << (L - 1)) < (x) && (x) < (1 << (L -1)) - 2)
4416       switch (howto->type)
4417         {
4418         case R_CKCORE_PCREL_IMM18BY2:
4419           /* When h is NULL, means the instruction written as
4420              grs rx, imm32
4421              if the highest bit is set, prevent the high 32bits
4422              turn to 0xffffffff when signed extern in 64bit
4423              host machine.  */
4424           if (h == NULL && (addend & 0x80000000))
4425             addend &= 0xffffffff;
4426           break;
4427
4428         case R_CKCORE_PCREL32:
4429           break;
4430
4431         case R_CKCORE_GOT12:
4432         case R_CKCORE_PLT12:
4433         case R_CKCORE_GOT_HI16:
4434         case R_CKCORE_GOT_LO16:
4435         case R_CKCORE_PLT_HI16:
4436         case R_CKCORE_PLT_LO16:
4437         case R_CKCORE_GOT32:
4438         case R_CKCORE_GOT_IMM18BY4:
4439           /* Relocation is to the entry for this symbol in the global
4440              offset table.  */
4441           BFD_ASSERT (htab->elf.sgot != NULL);
4442           if (h != NULL)
4443             {
4444               /* Global symbol is defined by other modules.  */
4445               bool dyn;
4446               off = h->got.offset;
4447               dyn = htab->elf.dynamic_sections_created;
4448               if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4449                                                     bfd_link_pic (info), h)
4450                   || (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info,h))
4451                   || (ELF_ST_VISIBILITY(h->other)
4452                       && h->root.type == bfd_link_hash_undefweak))
4453                 {
4454                   /* This is actually a static link, or it is a
4455                      -Bsymbolic link and the symbol is defined
4456                      locally, or the symbol was forced to be local
4457                      because of a version file.  We must initialize
4458                      this entry in the global offset table.  Since the
4459                      offset must always be a multiple of 4, we use the
4460                      least significant bit to record whether we have
4461                      initialized it already.
4462                      When doing a dynamic link, we create a .rela.dyn
4463                      relocation entry to initialize the value.  This
4464                      is done in the finish_dynamic_symbol routine. FIXME  */
4465                   if (off & 1)
4466                     off &= ~1;
4467                   else
4468                     {
4469                       bfd_put_32 (output_bfd, relocation,
4470                                   htab->elf.sgot->contents + off);
4471                       h->got.offset |= 1;
4472
4473 /* TRUE if relative relocation should be generated.  GOT reference to
4474    global symbol in PIC will lead to dynamic symbol.  It becomes a
4475    problem when "time" or "times" is defined as a variable in an
4476    executable, clashing with functions of the same name in libc.  If a
4477    symbol isn't undefined weak symbol, don't make it dynamic in PIC and
4478    generate relative relocation.  */
4479 #define GENERATE_RELATIVE_RELOC_P(INFO, H) \
4480   ((H)->dynindx == -1 \
4481    && !(H)->forced_local \
4482    && (H)->root.type != bfd_link_hash_undefweak \
4483    && bfd_link_pic (INFO))
4484
4485                       if (GENERATE_RELATIVE_RELOC_P (info, h))
4486                         /* If this symbol isn't dynamic
4487                            in PIC, generate R_CKCORE_RELATIVE here.  */
4488                         relative_reloc = true;
4489                     }
4490                 }
4491               else
4492                 unresolved_reloc = false;
4493             } /* End if h != NULL.  */
4494           else
4495             {
4496               BFD_ASSERT (local_got_offsets != NULL);
4497               off = local_got_offsets[r_symndx];
4498
4499               /* The offset must always be a multiple of 4.  We use
4500                  the least significant bit to record whether we have
4501                  already generated the necessary reloc.  */
4502               if (off & 1)
4503                 off &= ~1;
4504               else
4505                 {
4506                   bfd_put_32 (output_bfd, relocation,
4507                               htab->elf.sgot->contents + off);
4508                   local_got_offsets[r_symndx] |= 1;
4509                   if (bfd_link_pic (info))
4510                     relative_reloc = true;
4511                 }
4512             }
4513           if (relative_reloc)
4514             {
4515               asection *srelgot;
4516               Elf_Internal_Rela outrel;
4517               bfd_byte *loc;
4518
4519               srelgot = htab->elf.srelgot;
4520               BFD_ASSERT (srelgot != NULL);
4521
4522               outrel.r_offset
4523                 = (htab->elf.sgot->output_section->vma
4524                    + htab->elf.sgot->output_offset  + off);
4525               outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4526               outrel.r_addend = relocation;
4527               loc = srelgot->contents;
4528               loc += (srelgot->reloc_count++ * sizeof (Elf32_External_Rela));
4529               if (loc != NULL)
4530                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4531             }
4532           relocation = htab->elf.sgot->output_offset + off;
4533           break;
4534
4535         case R_CKCORE_GOTOFF_IMM18:
4536         case R_CKCORE_GOTOFF:
4537         case R_CKCORE_GOTOFF_HI16:
4538         case R_CKCORE_GOTOFF_LO16:
4539           /* Relocation is relative to the start of the global offset
4540              table.  */
4541           /* Note that sgot->output_offset is not involved in this
4542              calculation.  We always want the start of .got.  If we
4543              defined _GLOBAL_OFFSET_TABLE in a different way, as is
4544              permitted by the ABI, we might have to change this
4545              calculation.  */
4546           relocation -= htab->elf.sgot->output_section->vma;
4547           break;
4548
4549         case R_CKCORE_GOTPC:
4550         case R_CKCORE_GOTPC_HI16:
4551         case R_CKCORE_GOTPC_LO16:
4552           /* Use global offset table as symbol value.  */
4553           relocation = htab->elf.sgot->output_section->vma;
4554           addend = -addend;
4555           unresolved_reloc = false;
4556           break;
4557
4558         case R_CKCORE_DOFFSET_IMM18:
4559         case R_CKCORE_DOFFSET_IMM18BY2:
4560         case R_CKCORE_DOFFSET_IMM18BY4:
4561           {
4562             asection *sdata = bfd_get_section_by_name (output_bfd, ".data");
4563             relocation -= sdata->output_section->vma;
4564           }
4565           break;
4566
4567         case R_CKCORE_DOFFSET_LO16:
4568           {
4569             asection *sdata = bfd_get_section_by_name (output_bfd, ".data");
4570             relocation -= sdata->output_section->vma;
4571           }
4572           break;
4573
4574         case R_CKCORE_TOFFSET_LO16:
4575           {
4576             asection *stext = bfd_get_section_by_name (output_bfd, ".text");
4577             if (stext)
4578               relocation -= stext->output_section->vma;
4579           }
4580           break;
4581
4582         case R_CKCORE_PLT_IMM18BY4:
4583         case R_CKCORE_PLT32:
4584           /* Relocation is to the entry for this symbol in the
4585              procedure linkage table.  */
4586
4587           /* Resolve a PLT32 reloc against a local symbol directly,
4588              without using the procedure linkage table.  */
4589           if (h == NULL)
4590             break;
4591
4592           if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
4593             {
4594               /* We didn't make a PLT entry for this symbol.  This
4595                  happens when statically linking PIC code, or when
4596                  using -Bsymbolic.  */
4597               if (h->got.offset != (bfd_vma) -1)
4598                 {
4599                   bool dyn;
4600
4601                   off = h->got.offset;
4602                   dyn = htab->elf.dynamic_sections_created;
4603                   if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4604                                                         bfd_link_pic (info), h)
4605                       || (bfd_link_pic (info)
4606                           && SYMBOL_REFERENCES_LOCAL (info, h))
4607                       || (ELF_ST_VISIBILITY (h->other)
4608                           && h->root.type == bfd_link_hash_undefweak))
4609                     {
4610                       /* This is actually a static link, or it is a
4611                          -Bsymbolic link and the symbol is defined
4612                          locally, or the symbol was forced to be local
4613                          because of a version file.  We must initialize
4614                          this entry in the global offset table.  Since the
4615                          offset must always be a multiple of 4, we use the
4616                          least significant bit to record whether we have
4617                          initialized it already.
4618
4619                          When doing a dynamic link, we create a .rela.dyn
4620                          relocation entry to initialize the value.  This
4621                          is done in the finish_dynamic_symbol routine.
4622                          FIXME!  */
4623                       if (off & 1)
4624                         off &= ~1;
4625                       else
4626                         {
4627                           h->got.offset |= 1;
4628                           if (GENERATE_RELATIVE_RELOC_P (info, h))
4629                             relative_reloc = true;
4630                         }
4631                     }
4632                   bfd_put_32 (output_bfd, relocation,
4633                               htab->elf.sgot->contents + off);
4634
4635                   if (relative_reloc)
4636                     {
4637                       asection *srelgot;
4638                       Elf_Internal_Rela outrel;
4639                       bfd_byte *loc;
4640
4641                       srelgot = htab->elf.srelgot;
4642                       BFD_ASSERT (srelgot != NULL);
4643
4644                       outrel.r_offset
4645                         = (htab->elf.sgot->output_section->vma
4646                            + htab->elf.sgot->output_offset  + off);
4647                       outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4648                       outrel.r_addend = relocation;
4649                       loc = srelgot->contents;
4650                       loc += (srelgot->reloc_count++
4651                               * sizeof (Elf32_External_Rela));
4652                       if (loc != NULL)
4653                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4654                     }
4655                   relocation = off + htab->elf.sgot->output_offset;
4656                 }
4657               break;
4658             }
4659           /* The relocation is the got offset.  */
4660           if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
4661             relocation = (h->plt.offset / PLT_ENTRY_SIZE + 2) * 4;
4662           else
4663             relocation = (h->plt.offset / PLT_ENTRY_SIZE_P + 2) * 4;
4664           unresolved_reloc = false;
4665           break;
4666
4667         case R_CKCORE_PCREL_IMM26BY2:
4668         case R_CKCORE_PCREL_JSR_IMM26BY2:
4669         case R_CKCORE_PCREL_JSR_IMM11BY2:
4670         case R_CKCORE_PCREL_IMM11BY2:
4671         case R_CKCORE_CALLGRAPH:
4672           /* Emit callgraph information first.  */
4673           /* TODO: deal with callgraph.  */
4674           if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_CALLGRAPH)
4675             break;
4676           /* Some reloc need further handling.  */
4677           /* h == NULL means the symbol is a local symbol,
4678              r_symndx == 0 means the symbol is 'ABS' and
4679              the relocation is already handled in assemble,
4680              here just use for callgraph.  */
4681           /* TODO: deal with callgraph.  */
4682           if (h == NULL && r_symndx == 0)
4683             {
4684               do_final_relocate = false;
4685               break;
4686             }
4687
4688           /* Ignore weak references to undefined symbols.  */
4689           if (h != NULL && h->root.type == bfd_link_hash_undefweak)
4690             {
4691               do_final_relocate = false;
4692               break;
4693             }
4694
4695           /* Using branch stub.  */
4696           if (use_branch_stub == true
4697               && ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM26BY2)
4698             {
4699               struct elf32_csky_stub_hash_entry *stub_entry = NULL;
4700               if (sym_must_create_stub (h, info))
4701                 stub_entry = elf32_csky_get_stub_entry (input_section,
4702                                                         input_section,
4703                                                         h, rel, htab);
4704               else if (disp > BSR_MAX_FWD_BRANCH_OFFSET
4705                        || disp < BSR_MAX_BWD_BRANCH_OFFSET)
4706                 stub_entry = elf32_csky_get_stub_entry (input_section,
4707                                                         input_section,
4708                                                         h, rel, htab);
4709               if (stub_entry != NULL)
4710                 relocation
4711                   = (stub_entry->stub_offset
4712                      + stub_entry->stub_sec->output_offset
4713                      + stub_entry->stub_sec->output_section->vma);
4714               break;
4715             }
4716
4717           else if (h == NULL
4718                    || (h->root.type == bfd_link_hash_defined
4719                        && h->dynindx == -1)
4720                    || ((h->def_regular && !h->def_dynamic)
4721                        && (h->root.type != bfd_link_hash_defweak
4722                            || ! bfd_link_pic (info))))
4723             {
4724               if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_JSR_IMM26BY2)
4725                 {
4726                   if (within_range (disp, 26))
4727                     {
4728                       /* In range for BSR32.  */
4729                       howto = &csky_elf_howto_table[R_CKCORE_PCREL_IMM26BY2];
4730                       read_content_substitute = CSKY_INSN_BSR32;
4731                     }
4732                   else if (bfd_csky_arch (output_bfd) == CSKY_ARCH_810)
4733                     /* if bsr32 cannot reach, generate
4734                        "lrw r25, label; jsr r25" instead of
4735                        jsri label.  */
4736                     howto = &csky_elf_howto_table[R_CKCORE_NOJSRI];
4737                 } /* if ELF32_R_TYPE (rel->r_info)...  */
4738               else if (ELF32_R_TYPE (rel->r_info)
4739                        == R_CKCORE_PCREL_JSR_IMM11BY2)
4740                 {
4741                   if (within_range (disp, 11))
4742                     {
4743                       /* In range for BSR16.  */
4744                       howto = &csky_elf_howto_table[R_CKCORE_PCREL_IMM11BY2];
4745                       read_content_substitute = CSKY_INSN_BSR16;
4746                     }
4747                 }
4748               break;
4749             } /* else if h == NULL...  */
4750
4751           else if (bfd_csky_arch (output_bfd) == CSKY_ARCH_810
4752                    && (ELF32_R_TYPE (rel->r_info)
4753                        == R_CKCORE_PCREL_JSR_IMM26BY2))
4754             {
4755               howto = &csky_elf_howto_table[R_CKCORE_NOJSRI];
4756               break;
4757             }
4758           /* Other situation, h->def_dynamic == 1,
4759              undefined_symbol when output file is shared object, etc.  */
4760           /* Else fall through.  */
4761
4762         case R_CKCORE_ADDR_HI16:
4763         case R_CKCORE_ADDR_LO16:
4764           if (bfd_link_pic (info)
4765               || (!bfd_link_pic (info)
4766                   && h != NULL
4767                   && h->dynindx != -1
4768                   && !h->non_got_ref
4769                   && ((h->def_dynamic && !h->def_regular)
4770                       || (htab->elf.dynamic_sections_created
4771                           && (h->root.type == bfd_link_hash_undefweak
4772                               || h->root.type == bfd_link_hash_undefined
4773                               || h->root.type == bfd_link_hash_indirect)))))
4774             {
4775               Elf_Internal_Rela outrel;
4776               bool skip, relocate;
4777               bfd_byte *loc;
4778
4779               /* When generating a shared object, these relocations
4780                  are copied into the output file to be resolved at
4781                  run time.  */
4782               skip = false;
4783               relocate = false;
4784
4785               outrel.r_offset =
4786                 _bfd_elf_section_offset (output_bfd, info, input_section,
4787                                          rel->r_offset);
4788               if (outrel.r_offset == (bfd_vma) -1)
4789                 skip = true;
4790               else if (outrel.r_offset == (bfd_vma) -2)
4791                 {
4792                   skip = true;
4793                   relocate = true;
4794                 }
4795               outrel.r_offset += (input_section->output_section->vma
4796                                   + input_section->output_offset);
4797               if (skip)
4798                 memset (&outrel, 0, sizeof (outrel));
4799               else if (h != NULL
4800                        && h->dynindx != -1
4801                        && (!bfd_link_pic (info)
4802                            || (!SYMBOLIC_BIND (info, h)
4803                                && h->root.type == bfd_link_hash_defweak)
4804                            || !h->def_regular))
4805                 {
4806                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4807                   outrel.r_addend = rel->r_addend;
4808                 }
4809               else
4810                 {
4811                   /* This symbol is local, or marked to become local.  */
4812                   relocate = true;
4813                   outrel.r_info = ELF32_R_INFO (0, r_type);
4814                   outrel.r_addend = relocation + rel->r_addend;
4815                 }
4816               loc = htab->elf.srelgot->contents;
4817               loc += (htab->elf.srelgot->reloc_count++
4818                       * sizeof (Elf32_External_Rela));
4819
4820               if (loc != NULL)
4821                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4822
4823               /* If this reloc is against an external symbol, we do not
4824                  want to diddle with the addend. Otherwise, we need to
4825                  include the symbol value so that it becomes an addend
4826                  for the dynamic reloc.  */
4827               if (!relocate)
4828                 continue;
4829             } /* if bfd_link_pic (info) ...  */
4830           break;
4831
4832         case R_CKCORE_ADDR32:
4833           /* r_symndx will be zero only for relocs against symbols
4834              from removed linkonce sections, or sections discarded
4835              by a linker script.
4836              This relocation don't nedd to handle, the value will
4837              be set to SEC_DISCARDED(0xffffffff).  */
4838           if (r_symndx == 0
4839               && strcmp (sec->name, ".csky_stack_size") == 0)
4840             {
4841               do_final_relocate = false;
4842               break;
4843             }
4844           if (r_symndx >= symtab_hdr->sh_info
4845               && h->non_got_ref
4846               && bfd_link_executable (info))
4847             break;
4848
4849           if (r_symndx == 0 || (input_section->flags & SEC_ALLOC) == 0)
4850             break;
4851
4852           if (bfd_link_pic (info)
4853               || (h != NULL
4854                   && h->dynindx != -1
4855                   && ((h->def_dynamic && !h->def_regular)
4856                       || (htab->elf.dynamic_sections_created
4857                           && (h->root.type == bfd_link_hash_undefweak
4858                               || h->root.type == bfd_link_hash_undefined
4859                               || h->root.type == bfd_link_hash_indirect)))))
4860             {
4861               Elf_Internal_Rela outrel;
4862               bool skip, relocate;
4863               bfd_byte *loc;
4864
4865               /* When generating a shared object, these relocations
4866                  are copied into the output file to be resolved at
4867                  run time.  */
4868               skip = false;
4869               relocate = false;
4870
4871               outrel.r_offset =
4872                 _bfd_elf_section_offset (output_bfd, info, input_section,
4873                                          rel->r_offset);
4874
4875               if (outrel.r_offset == (bfd_vma) -1)
4876                 skip = true;
4877               else if (outrel.r_offset == (bfd_vma) -2)
4878                 {
4879                   skip = true;
4880                   relocate = true;
4881                 }
4882
4883               outrel.r_offset += (input_section->output_section->vma
4884                                   + input_section->output_offset);
4885
4886               if (skip)
4887                 memset (&outrel, 0, sizeof (outrel));
4888               else if (h != NULL
4889                        && h->dynindx != -1
4890                        && (!bfd_link_pic (info)
4891                            || (!SYMBOLIC_BIND (info, h)
4892                                && h->root.type == bfd_link_hash_defweak)
4893                            || !h->def_regular))
4894                 {
4895                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4896                   outrel.r_addend = rel->r_addend;
4897                 }
4898               else
4899                 {
4900                   /* This symbol is local, or marked to become local.  */
4901                   outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4902                   outrel.r_addend = relocation + rel->r_addend;
4903                 }
4904
4905               loc = htab->elf.srelgot->contents;
4906               loc += (htab->elf.srelgot->reloc_count++
4907                       * sizeof (Elf32_External_Rela));
4908
4909               if (loc != NULL)
4910                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4911
4912               /* If this reloc is against an external symbol, we do
4913                  want to diddle with the addend. Otherwise, we need to
4914                  include the symbol value so that it becomes an addend
4915                  for the dynamic reloc.  */
4916               if (! relocate)
4917                 continue;
4918             }
4919           break;
4920
4921         case R_CKCORE_TLS_LDO32:
4922           relocation = relocation - dtpoff_base (info);
4923           break;
4924
4925         case R_CKCORE_TLS_LDM32:
4926           BFD_ASSERT (htab->elf.sgot != NULL);
4927           off = htab->tls_ldm_got.offset;
4928           if (off & 1)
4929             off &= ~1;
4930           else
4931             {
4932               /* If we don't know the module number,
4933                  create a relocation for it.  */
4934               if (!bfd_link_executable (info))
4935                 {
4936                   Elf_Internal_Rela outrel;
4937                   bfd_byte *loc;
4938
4939                   BFD_ASSERT (htab->elf.srelgot != NULL);
4940                   outrel.r_addend = 0;
4941                   outrel.r_offset
4942                     = (htab->elf.sgot->output_section->vma
4943                        + htab->elf.sgot->output_offset + off);
4944                   outrel.r_info = ELF32_R_INFO (0, R_CKCORE_TLS_DTPMOD32);
4945                   bfd_put_32 (output_bfd, outrel.r_addend,
4946                               htab->elf.sgot->contents + off);
4947
4948                   loc = htab->elf.srelgot->contents;
4949                   loc += (htab->elf.srelgot->reloc_count++
4950                           * sizeof (Elf32_External_Rela));
4951                   if (loc)
4952                     bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4953                 }
4954               else
4955                 bfd_put_32 (output_bfd, 1,
4956                             htab->elf.sgot->contents + off);
4957               htab->tls_ldm_got.offset |= 1;
4958             }
4959           relocation
4960             = (htab->elf.sgot->output_section->vma
4961                + htab->elf.sgot->output_offset + off
4962                - (input_section->output_section->vma
4963                   + input_section->output_offset + rel->r_offset));
4964           break;
4965         case R_CKCORE_TLS_LE32:
4966           if (bfd_link_dll (info))
4967             {
4968               _bfd_error_handler
4969                 /* xgettext:c-format */
4970                 (_("%pB(%pA+%#" PRIx64 "): %s relocation not permitted "
4971                    "in shared object"),
4972                  input_bfd, input_section, (uint64_t)rel->r_offset,
4973                  howto->name);
4974               return false;
4975             }
4976           else
4977             relocation = tpoff (info, relocation);
4978           break;
4979         case R_CKCORE_TLS_GD32:
4980         case R_CKCORE_TLS_IE32:
4981           {
4982             int indx;
4983             char tls_type;
4984
4985             BFD_ASSERT (htab->elf.sgot != NULL);
4986
4987             indx = 0;
4988             if (h != NULL)
4989               {
4990                 bool dyn;
4991                 dyn = htab->elf.dynamic_sections_created;
4992                 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4993                                                      bfd_link_pic (info), h)
4994                     && (!bfd_link_pic (info)
4995                         || !SYMBOL_REFERENCES_LOCAL (info, h)))
4996                   {
4997                     unresolved_reloc = false;
4998                     indx = h->dynindx;
4999                   }
5000                 off = h->got.offset;
5001                 tls_type = ((struct csky_elf_link_hash_entry *)h)->tls_type;
5002               }
5003             else
5004               {
5005                 BFD_ASSERT (local_got_offsets != NULL);
5006                 off = local_got_offsets[r_symndx];
5007                 tls_type = csky_elf_local_got_tls_type (input_bfd)[r_symndx];
5008               }
5009
5010             BFD_ASSERT (tls_type != GOT_UNKNOWN);
5011
5012             if (off & 1)
5013               off &= ~1;
5014             else
5015               {
5016                 bool need_relocs = false;
5017                 Elf_Internal_Rela outrel;
5018                 bfd_byte *loc = NULL;
5019                 int cur_off = off;
5020                 /* The GOT entries have not been initialized yet.  Do it
5021                    now, and emit any relocations.  If both an IE GOT and a
5022                    GD GOT are necessary, we emit the GD first.  */
5023                 if ((!bfd_link_executable (info) || indx != 0)
5024                     && (h == NULL
5025                         || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5026                             && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5027                         || h->root.type != bfd_link_hash_undefined))
5028                   {
5029                     need_relocs = true;
5030                     BFD_ASSERT (htab->elf.srelgot != NULL);
5031
5032                     loc = htab->elf.srelgot->contents;
5033                     loc += (htab->elf.srelgot->reloc_count
5034                             * sizeof (Elf32_External_Rela));
5035                   }
5036                 if (tls_type & GOT_TLS_GD)
5037                   {
5038                     if (need_relocs)
5039                       {
5040                         outrel.r_addend = 0;
5041                         outrel.r_offset
5042                           = (htab->elf.sgot->output_section->vma
5043                              + htab->elf.sgot->output_offset
5044                              + cur_off);
5045                         outrel.r_info
5046                           = ELF32_R_INFO (indx, R_CKCORE_TLS_DTPMOD32);
5047                         bfd_put_32 (output_bfd, outrel.r_addend,
5048                                     htab->elf.sgot->contents + cur_off);
5049                         if (loc)
5050                           bfd_elf32_swap_reloca_out (output_bfd,
5051                                                      &outrel, loc);
5052                         loc += sizeof (Elf32_External_Rela);
5053                         htab->elf.srelgot->reloc_count++;
5054                         if (indx == 0)
5055                           bfd_put_32 (output_bfd,
5056                                       relocation - dtpoff_base (info),
5057                                       (htab->elf.sgot->contents
5058                                        + cur_off + 4));
5059                         else
5060                           {
5061                             outrel.r_addend = 0;
5062                             outrel.r_info
5063                               = ELF32_R_INFO (indx, R_CKCORE_TLS_DTPOFF32);
5064                             outrel.r_offset += 4;
5065                             bfd_put_32 (output_bfd, outrel.r_addend,
5066                                         (htab->elf.sgot->contents
5067                                          + cur_off + 4));
5068                             outrel.r_info =
5069                               ELF32_R_INFO (indx,
5070                                             R_CKCORE_TLS_DTPOFF32);
5071                             if (loc)
5072                               bfd_elf32_swap_reloca_out (output_bfd,
5073                                                          &outrel,
5074                                                          loc);
5075                             htab->elf.srelgot->reloc_count++;
5076                             loc += sizeof (Elf32_External_Rela);
5077                           }
5078
5079                       }
5080                     else
5081                       {
5082                         /* If are not emitting relocations for a
5083                            general dynamic reference, then we must be in a
5084                            static link or an executable link with the
5085                            symbol binding locally.  Mark it as belonging
5086                            to module 1, the executable.  */
5087                         bfd_put_32 (output_bfd, 1,
5088                                     htab->elf.sgot->contents + cur_off);
5089                         bfd_put_32 (output_bfd,
5090                                     relocation - dtpoff_base (info),
5091                                     htab->elf.sgot->contents
5092                                     + cur_off + 4);
5093                       }
5094                     cur_off += 8;
5095                   }
5096                 if (tls_type & GOT_TLS_IE)
5097                   {
5098                     if (need_relocs)
5099                       {
5100                         if (indx == 0)
5101                           outrel.r_addend = relocation - dtpoff_base (info);
5102                         else
5103                           outrel.r_addend = 0;
5104                         outrel.r_offset
5105                           = (htab->elf.sgot->output_section->vma
5106                              + htab->elf.sgot->output_offset + cur_off);
5107                         outrel.r_info
5108                           = ELF32_R_INFO (indx, R_CKCORE_TLS_TPOFF32);
5109
5110                         bfd_put_32 (output_bfd, outrel.r_addend,
5111                                     htab->elf.sgot->contents + cur_off);
5112                         if (loc)
5113                           bfd_elf32_swap_reloca_out (output_bfd,
5114                                                      &outrel, loc);
5115                         htab->elf.srelgot->reloc_count++;
5116                         loc += sizeof (Elf32_External_Rela);
5117                       }
5118                     else
5119                       bfd_put_32 (output_bfd, tpoff (info, relocation),
5120                                   htab->elf.sgot->contents + cur_off);
5121                   }
5122                 if (h != NULL)
5123                   h->got.offset |= 1;
5124                 else
5125                   local_got_offsets[r_symndx] |= 1;
5126               }
5127             if ((tls_type & GOT_TLS_GD) && howto->type != R_CKCORE_TLS_GD32)
5128               off += 8;
5129             relocation
5130               = (htab->elf.sgot->output_section->vma
5131                  + htab->elf.sgot->output_offset + off
5132                  - (input_section->output_section->vma
5133                     + input_section->output_offset
5134                     + rel->r_offset));
5135             break;
5136           }
5137         default:
5138           /* No substitution when final linking.  */
5139           read_content_substitute = 0;
5140           break;
5141         } /* End switch (howto->type).  */
5142
5143       /* Make sure 32-bit data in the text section will not be affected by
5144          our special endianness.
5145          However, this currently affects noting, since the ADDR32 howto type
5146          does no change with the data read. But we may need this mechanism in
5147          the future.  */
5148
5149       if (bfd_get_reloc_size (howto) == 4
5150           && (howto->type == R_CKCORE_ADDR32
5151               || howto->type == R_CKCORE_PCREL32
5152               || howto->type == R_CKCORE_GOT32
5153               || howto->type == R_CKCORE_GOTOFF
5154               || howto->type == R_CKCORE_GOTPC
5155               || howto->type == R_CKCORE_PLT32
5156               || howto->type == R_CKCORE_TLS_LE32
5157               || howto->type == R_CKCORE_TLS_IE32
5158               || howto->type == R_CKCORE_TLS_LDM32
5159               || howto->type == R_CKCORE_TLS_GD32
5160               || howto->type == R_CKCORE_TLS_LDO32
5161               || howto->type == R_CKCORE_RELATIVE))
5162         need_reverse_bits = 0;
5163       else
5164         need_reverse_bits = 1;
5165       /* Do the final link.  */
5166       if (howto->type != R_CKCORE_PCREL_JSR_IMM11BY2
5167           && howto->type != R_CKCORE_PCREL_JSR_IMM26BY2
5168           && howto->type != R_CKCORE_CALLGRAPH
5169           && do_final_relocate)
5170         r = csky_final_link_relocate (howto, input_bfd, input_section,
5171                                       contents, rel->r_offset,
5172                                       relocation, addend);
5173
5174       if (r != bfd_reloc_ok)
5175         {
5176           ret = false;
5177           switch (r)
5178             {
5179             default:
5180               break;
5181             case bfd_reloc_overflow:
5182               if (h != NULL)
5183                 name = NULL;
5184               else
5185                 {
5186                   name = bfd_elf_string_from_elf_section (input_bfd,
5187                                                           symtab_hdr->sh_link,
5188                                                           sym->st_name);
5189                   if (name == NULL)
5190                     break;
5191                   if (*name == '\0')
5192                     name = bfd_section_name (sec);
5193                 }
5194               (*info->callbacks->reloc_overflow)
5195                 (info,
5196                  (h ? &h->root : NULL),
5197                  name, howto->name, (bfd_vma) 0,
5198                  input_bfd, input_section, rel->r_offset);
5199               break;
5200             }
5201         }
5202     } /* End for (;rel < relend; rel++).  */
5203   return ret;
5204 }
5205
5206 static bool
5207 csky_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
5208 {
5209   int offset;
5210   size_t size;
5211
5212   switch (note->descsz)
5213     {
5214     default:
5215       return false;
5216       /* Sizeof (struct elf_prstatus) on C-SKY V1 arch.  */
5217     case 148:
5218       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
5219       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
5220       offset = 72;
5221       size = 72;
5222       break;
5223       /* Sizeof (struct elf_prstatus) on C-SKY V1 arch.  */
5224     case 220:
5225       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
5226       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
5227       offset = 72;
5228       size = 34 * 4;
5229       break;
5230     }
5231   /* Make a ".reg/999" section.  */
5232   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5233                                           size, note->descpos + offset);
5234 }
5235
5236 static bool
5237 csky_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
5238 {
5239   switch (note->descsz)
5240     {
5241     default:
5242       return false;
5243
5244       /* Sizeof (struct elf_prpsinfo) on linux csky.  */
5245     case 124:
5246       elf_tdata (abfd)->core->program
5247         = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
5248       elf_tdata (abfd)->core->command
5249         = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
5250     }
5251
5252   /* Note that for some reason, a spurious space is tacked
5253      onto the end of the args in some (at least one anyway)
5254      implementations, so strip it off if it exists.  */
5255   {
5256     char *command = elf_tdata (abfd)->core->command;
5257     int n = strlen (command);
5258
5259     if (0 < n && command[n - 1] == ' ')
5260       command[n - 1] = '\0';
5261   }
5262
5263   return true;
5264 }
5265
5266 /* Determine whether an object attribute tag takes an integer, a
5267    string or both.  */
5268
5269 static int
5270 elf32_csky_obj_attrs_arg_type (int tag)
5271 {
5272   switch (tag)
5273     {
5274     case Tag_compatibility:
5275       return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
5276     case Tag_CSKY_ARCH_NAME:
5277     case Tag_CSKY_CPU_NAME:
5278     case Tag_CSKY_FPU_NUMBER_MODULE:
5279       return ATTR_TYPE_FLAG_STR_VAL;
5280     case Tag_CSKY_ISA_FLAGS:
5281     case Tag_CSKY_ISA_EXT_FLAGS:
5282     case Tag_CSKY_DSP_VERSION:
5283     case Tag_CSKY_VDSP_VERSION:
5284     case Tag_CSKY_FPU_VERSION:
5285     case Tag_CSKY_FPU_ABI:
5286     case Tag_CSKY_FPU_ROUNDING:
5287     case Tag_CSKY_FPU_HARDFP:
5288     case Tag_CSKY_FPU_Exception:
5289     case Tag_CSKY_FPU_DENORMAL:
5290       return ATTR_TYPE_FLAG_INT_VAL;
5291     default:
5292       break;
5293     }
5294
5295   return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
5296 }
5297
5298 /* Attribute numbers >=64 (mod 128) can be safely ignored.  */
5299
5300 static bool
5301 elf32_csky_obj_attrs_handle_unknown (bfd *abfd ATTRIBUTE_UNUSED,
5302                                      int tag ATTRIBUTE_UNUSED)
5303 {
5304   return true;
5305 }
5306
5307 /* End of external entry points for sizing and building linker stubs.  */
5308
5309 /* CPU-related basic API.  */
5310 #define TARGET_BIG_SYM                        csky_elf32_be_vec
5311 #define TARGET_BIG_NAME                       "elf32-csky-big"
5312 #define TARGET_LITTLE_SYM                     csky_elf32_le_vec
5313 #define TARGET_LITTLE_NAME                    "elf32-csky-little"
5314 #define ELF_ARCH                              bfd_arch_csky
5315 #define ELF_MACHINE_CODE                      EM_CSKY
5316 #define ELF_MACHINE_ALT1                      EM_CSKY_OLD
5317 #define ELF_MAXPAGESIZE                       0x1000
5318 #define elf_info_to_howto                     csky_elf_info_to_howto
5319 #define elf_info_to_howto_rel                 NULL
5320 #define elf_backend_special_sections          csky_elf_special_sections
5321 #define bfd_elf32_bfd_link_hash_table_create  csky_elf_link_hash_table_create
5322
5323 /* Target related API.  */
5324 #define bfd_elf32_mkobject                    csky_elf_mkobject
5325 #define bfd_elf32_bfd_merge_private_bfd_data  csky_elf_merge_private_bfd_data
5326 #define bfd_elf32_bfd_set_private_flags       csky_elf_set_private_flags
5327 #define elf_backend_copy_indirect_symbol      csky_elf_copy_indirect_symbol
5328 #define bfd_elf32_bfd_is_target_special_symbol csky_elf_is_target_special_symbol
5329 #define elf_backend_maybe_function_sym        csky_elf_maybe_function_sym
5330
5331 /* GC section related API.  */
5332 #define elf_backend_can_gc_sections           1
5333 #define elf_backend_gc_mark_hook              csky_elf_gc_mark_hook
5334 #define elf_backend_gc_mark_extra_sections    elf32_csky_gc_mark_extra_sections
5335
5336 /* Relocation related API.  */
5337 #define elf_backend_reloc_type_class          csky_elf_reloc_type_class
5338 #define bfd_elf32_bfd_reloc_type_lookup       csky_elf_reloc_type_lookup
5339 #define bfd_elf32_bfd_reloc_name_lookup       csky_elf_reloc_name_lookup
5340 #define elf_backend_ignore_discarded_relocs   csky_elf_ignore_discarded_relocs
5341 #define elf_backend_relocate_section          csky_elf_relocate_section
5342 #define elf_backend_check_relocs              csky_elf_check_relocs
5343
5344 /* Dynamic relocate related API.  */
5345 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
5346 #define elf_backend_adjust_dynamic_symbol     csky_elf_adjust_dynamic_symbol
5347 #define elf_backend_size_dynamic_sections     csky_elf_size_dynamic_sections
5348 #define elf_backend_finish_dynamic_symbol     csky_elf_finish_dynamic_symbol
5349 #define elf_backend_finish_dynamic_sections   csky_elf_finish_dynamic_sections
5350 #define elf_backend_rela_normal               1
5351 #define elf_backend_can_refcount              1
5352 #define elf_backend_plt_readonly              1
5353 #define elf_backend_want_got_sym              1
5354 #define elf_backend_want_dynrelro             1
5355 #define elf_backend_got_header_size           12
5356 #define elf_backend_want_got_plt              1
5357
5358 /* C-SKY coredump support.  */
5359 #define elf_backend_grok_prstatus             csky_elf_grok_prstatus
5360 #define elf_backend_grok_psinfo               csky_elf_grok_psinfo
5361
5362 /* Attribute sections.  */
5363 #undef  elf_backend_obj_attrs_vendor
5364 #define elf_backend_obj_attrs_vendor          "csky"
5365 #undef  elf_backend_obj_attrs_section
5366 #define elf_backend_obj_attrs_section         ".csky.attributes"
5367 #undef  elf_backend_obj_attrs_arg_type
5368 #define elf_backend_obj_attrs_arg_type        elf32_csky_obj_attrs_arg_type
5369 #undef  elf_backend_obj_attrs_section_type
5370 #define elf_backend_obj_attrs_section_type    SHT_CSKY_ATTRIBUTES
5371 #define elf_backend_obj_attrs_handle_unknown  elf32_csky_obj_attrs_handle_unknown
5372
5373 #include "elf32-target.h"