bfd/elf32-nds32.c

   1 /* NDS32-specific support for 32-bit ELF.
   2    Copyright (C) 2012-2019 Free Software Foundation, Inc.
   3    Contributed by Andes Technology Corporation.
   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, MA
  20    02110-1301, USA.  */
  21
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28 #include "libiberty.h"
  29 #include "elf/nds32.h"
  30 #include "opcode/nds32.h"
  31 #include "elf32-nds32.h"
  32 #include "opcode/cgen.h"
  33 #include "../opcodes/nds32-opc.h"
  34
  35 /* Relocation HOWTO functions.  */
  36 static bfd_reloc_status_type nds32_elf_ignore_reloc
  37   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  38 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type nds32_elf_hi20_reloc
  41   (bfd *, arelent *, asymbol *, void *,
  42    asection *, bfd *, char **);
  43 static bfd_reloc_status_type nds32_elf_lo12_reloc
  44   (bfd *, arelent *, asymbol *, void *,
  45    asection *, bfd *, char **);
  46 static bfd_reloc_status_type nds32_elf_generic_reloc
  47   (bfd *, arelent *, asymbol *, void *,
  48    asection *, bfd *, char **);
  49 static bfd_reloc_status_type nds32_elf_sda15_reloc
  50   (bfd *, arelent *, asymbol *, void *,
  51    asection *, bfd *, char **);
  52
  53 /* Helper functions for HOWTO.  */
  54 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
  55   (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
  56    asection *, bfd_vma, bfd_vma);
  57
  58 /* Nds32 helper functions.  */
  59 static bfd_vma calculate_memory_address
  60   (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
  61 static int nds32_get_section_contents (bfd *, asection *,
  62                                        bfd_byte **, bfd_boolean);
  63 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
  64                                  Elf_Internal_Sym **);
  65 static bfd_boolean  nds32_relax_fp_as_gp
  66   (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
  67    Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
  68    Elf_Internal_Sym *isymbuf);
  69 static bfd_boolean nds32_fag_remove_unused_fpbase
  70   (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
  71    Elf_Internal_Rela *irelend);
  72
  73 enum
  74 {
  75   MACH_V1 = bfd_mach_n1h,
  76   MACH_V2 = bfd_mach_n1h_v2,
  77   MACH_V3 = bfd_mach_n1h_v3,
  78   MACH_V3M = bfd_mach_n1h_v3m
  79 };
  80
  81 #define MIN(a, b) ((a) > (b) ? (b) : (a))
  82 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  83
  84 /* The name of the dynamic interpreter.  This is put in the .interp
  85    section.  */
  86 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
  87
  88 #define NDS32_GUARD_SEC_P(flags) ((flags) & SEC_ALLOC \
  89                                   && (flags) & SEC_LOAD \
  90                                   && (flags) & SEC_READONLY)
  91
  92 /* The nop opcode we use.  */
  93 #define NDS32_NOP32 0x40000009
  94 #define NDS32_NOP16 0x9200
  95
  96 /* The size in bytes of an entry in the procedure linkage table.  */
  97 #define PLT_ENTRY_SIZE 24
  98 #define PLT_HEADER_SIZE 24
  99
 100 /* The first entry in a procedure linkage table are reserved,
 101    and the initial contents are unimportant (we zero them out).
 102    Subsequent entries look like this.  */
 103 #define PLT0_ENTRY_WORD0  0x46f00000            /* sethi   r15, HI20(.got+4)      */
 104 #define PLT0_ENTRY_WORD1  0x58f78000            /* ori     r15, r25, LO12(.got+4) */
 105 #define PLT0_ENTRY_WORD2  0x05178000            /* lwi     r17, [r15+0]           */
 106 #define PLT0_ENTRY_WORD3  0x04f78001            /* lwi     r15, [r15+4]           */
 107 #define PLT0_ENTRY_WORD4  0x4a003c00            /* jr      r15                    */
 108
 109 /* $ta is change to $r15 (from $r25).  */
 110 #define PLT0_PIC_ENTRY_WORD0  0x46f00000        /* sethi   r15, HI20(got[1]@GOT)  */
 111 #define PLT0_PIC_ENTRY_WORD1  0x58f78000        /* ori     r15, r15, LO12(got[1]@GOT) */
 112 #define PLT0_PIC_ENTRY_WORD2  0x40f7f400        /* add     r15, gp, r15           */
 113 #define PLT0_PIC_ENTRY_WORD3  0x05178000        /* lwi     r17, [r15+0]           */
 114 #define PLT0_PIC_ENTRY_WORD4  0x04f78001        /* lwi     r15, [r15+4]           */
 115 #define PLT0_PIC_ENTRY_WORD5  0x4a003c00        /* jr      r15                    */
 116
 117 #define PLT_ENTRY_WORD0  0x46f00000             /* sethi   r15, HI20(&got[n+3])      */
 118 #define PLT_ENTRY_WORD1  0x04f78000             /* lwi     r15, r15, LO12(&got[n+3]) */
 119 #define PLT_ENTRY_WORD2  0x4a003c00             /* jr      r15                       */
 120 #define PLT_ENTRY_WORD3  0x45000000             /* movi    r16, sizeof(RELA) * n     */
 121 #define PLT_ENTRY_WORD4  0x48000000             /* j      .plt0.                     */
 122
 123 #define PLT_PIC_ENTRY_WORD0  0x46f00000         /* sethi  r15, HI20(got[n+3]@GOT)    */
 124 #define PLT_PIC_ENTRY_WORD1  0x58f78000         /* ori    r15, r15,    LO12(got[n+3]@GOT) */
 125 #define PLT_PIC_ENTRY_WORD2  0x38febc02         /* lw     r15, [gp+r15]              */
 126 #define PLT_PIC_ENTRY_WORD3  0x4a003c00         /* jr     r15                        */
 127 #define PLT_PIC_ENTRY_WORD4  0x45000000         /* movi   r16, sizeof(RELA) * n      */
 128 #define PLT_PIC_ENTRY_WORD5  0x48000000         /* j      .plt0                      */
 129
 130 /* These are macros used to get the relocation accurate value.  */
 131 #define ACCURATE_8BIT_S1        (0x100)
 132 #define ACCURATE_U9BIT_S1       (0x400)
 133 #define ACCURATE_12BIT_S1       (0x2000)
 134 #define ACCURATE_14BIT_S1       (0x4000)
 135 #define ACCURATE_19BIT          (0x40000)
 136
 137 /* These are macros used to get the relocation conservative value.  */
 138 #define CONSERVATIVE_8BIT_S1    (0x100 - 4)
 139 #define CONSERVATIVE_14BIT_S1   (0x4000 - 4)
 140 #define CONSERVATIVE_16BIT_S1   (0x10000 - 4)
 141 #define CONSERVATIVE_24BIT_S1   (0x1000000 - 4)
 142 /* These must be more conservative because the address may be in
 143    different segment.  */
 144 #define CONSERVATIVE_15BIT      (0x4000 - 0x1000)
 145 #define CONSERVATIVE_15BIT_S1   (0x8000 - 0x1000)
 146 #define CONSERVATIVE_15BIT_S2   (0x10000 - 0x1000)
 147 #define CONSERVATIVE_19BIT      (0x40000 - 0x1000)
 148 #define CONSERVATIVE_20BIT      (0x80000 - 0x1000)
 149
 150 /* Size of small data/bss sections, used to calculate SDA_BASE.  */
 151 static long got_size = 0;
 152 static int is_SDA_BASE_set = 0;
 153
 154 /* Convert ELF-VER in eflags to string for debugging purpose.  */
 155 static const char *const nds32_elfver_strtab[] =
 156 {
 157   "ELF-1.2",
 158   "ELF-1.3",
 159   "ELF-1.4",
 160 };
 161
 162 /* The nds32 linker needs to keep track of the number of relocs that it
 163    decides to copy in check_relocs for each symbol.  This is so that
 164    it can discard PC relative relocs if it doesn't need them when
 165    linking with -Bsymbolic.  We store the information in a field
 166    extending the regular ELF linker hash table.  */
 167
 168 /* This structure keeps track of the number of PC relative relocs we
 169    have copied for a given symbol.  */
 170
 171 struct elf_nds32_pcrel_relocs_copied
 172 {
 173   /* Next section.  */
 174   struct elf_nds32_pcrel_relocs_copied *next;
 175   /* A section in dynobj.  */
 176   asection *section;
 177   /* Number of relocs copied in this section.  */
 178   bfd_size_type count;
 179 };
 180
 181 enum elf_nds32_tls_type
 182 {
 183   GOT_UNKNOWN = (0),
 184   GOT_NORMAL = (1 << 0),
 185   GOT_TLS_LE = (1 << 1),
 186   GOT_TLS_IE = (1 << 2),
 187   GOT_TLS_IEGP = (1 << 3),
 188   GOT_TLS_LD = (1 << 4),
 189   GOT_TLS_GD = (1 << 5),
 190   GOT_TLS_DESC = (1 << 6),
 191 };
 192
 193 /* Nds32 ELF linker hash entry.  */
 194
 195 struct elf_nds32_link_hash_entry
 196 {
 197   struct elf_link_hash_entry root;
 198
 199   /* Track dynamic relocs copied for this symbol.  */
 200   struct elf_dyn_relocs *dyn_relocs;
 201
 202   /* For checking relocation type.  */
 203   enum elf_nds32_tls_type tls_type;
 204
 205   int offset_to_gp;
 206 };
 207
 208 /* Get the nds32 ELF linker hash table from a link_info structure.  */
 209
 210 #define FP_BASE_NAME "_FP_BASE_"
 211 static int check_start_export_sym = 0;
 212
 213 /* The offset for executable tls relaxation.  */
 214 #define TP_OFFSET 0x0
 215
 216 typedef struct
 217 {
 218   int min_id;
 219   int max_id;
 220   int count;
 221   int bias;
 222   int init;
 223 } elf32_nds32_relax_group_t;
 224
 225 struct elf_nds32_obj_tdata
 226 {
 227   struct elf_obj_tdata root;
 228
 229   /* tls_type for each local got entry.  */
 230   char *local_got_tls_type;
 231
 232   /* GOTPLT entries for TLS descriptors.  */
 233   bfd_vma *local_tlsdesc_gotent;
 234
 235   /* for R_NDS32_RELAX_GROUP handling.  */
 236   elf32_nds32_relax_group_t relax_group;
 237
 238   unsigned int hdr_size;
 239   int* offset_to_gp;
 240 };
 241
 242 #define elf_nds32_tdata(bfd) \
 243   ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
 244
 245 #define elf32_nds32_local_got_tls_type(bfd) \
 246   (elf_nds32_tdata (bfd)->local_got_tls_type)
 247
 248 #define elf32_nds32_local_gp_offset(bfd) \
 249   (elf_nds32_tdata (bfd)->offset_to_gp)
 250
 251 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
 252
 253 #define elf32_nds32_relax_group_ptr(bfd) \
 254   &(elf_nds32_tdata (bfd)->relax_group)
 255
 256 static bfd_boolean
 257 nds32_elf_mkobject (bfd *abfd)
 258 {
 259   return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
 260                                   NDS32_ELF_DATA);
 261 }
 262
 263 /* Relocations used for relocation.  */
 264 /* Define HOWTO2 (for relocation) and HOWTO3 (for relaxation) to
 265    initialize array nds32_elf_howto_table in any order. The benefit
 266    is that we can add any new relocations with any numbers and don't
 267    need to fill the gap by lots of EMPTY_HOWTO. */
 268 #define HOWTO2(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 269   [C] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
 270
 271 static reloc_howto_type nds32_elf_howto_table[] =
 272 {
 273   /* This reloc does nothing.  */
 274   HOWTO2 (R_NDS32_NONE,         /* type  */
 275          0,                     /* rightshift  */
 276          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 277          32,                    /* bitsize  */
 278          FALSE,                 /* pc_relative  */
 279          0,                     /* bitpos  */
 280          complain_overflow_bitfield,/* complain_on_overflow  */
 281          bfd_elf_generic_reloc, /* special_function  */
 282          "R_NDS32_NONE",        /* name  */
 283          FALSE,                 /* partial_inplace  */
 284          0,                     /* src_mask  */
 285          0,                     /* dst_mask  */
 286          FALSE),                /* pcrel_offset  */
 287
 288   /* A 16 bit absolute relocation.  */
 289   HOWTO2 (R_NDS32_16,           /* type  */
 290          0,                     /* rightshift  */
 291          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 292          16,                    /* bitsize  */
 293          FALSE,                 /* pc_relative  */
 294          0,                     /* bitpos  */
 295          complain_overflow_bitfield,/* complain_on_overflow  */
 296          nds32_elf_generic_reloc,/* special_function  */
 297          "R_NDS32_16",          /* name  */
 298          FALSE,                 /* partial_inplace  */
 299          0xffff,                /* src_mask  */
 300          0xffff,                /* dst_mask  */
 301          FALSE),                /* pcrel_offset  */
 302
 303   /* A 32 bit absolute relocation.  */
 304   HOWTO2 (R_NDS32_32,           /* type  */
 305          0,                     /* rightshift  */
 306          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 307          32,                    /* bitsize  */
 308          FALSE,                 /* pc_relative  */
 309          0,                     /* bitpos  */
 310          complain_overflow_bitfield,/* complain_on_overflow  */
 311          nds32_elf_generic_reloc,/* special_function  */
 312          "R_NDS32_32",          /* name  */
 313          FALSE,                 /* partial_inplace  */
 314          0xffffffff,            /* src_mask  */
 315          0xffffffff,            /* dst_mask  */
 316          FALSE),                /* pcrel_offset  */
 317
 318   /* A 20 bit address.  */
 319   HOWTO2 (R_NDS32_20,           /* type  */
 320          0,                     /* rightshift  */
 321          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 322          20,                    /* bitsize  */
 323          FALSE,                 /* pc_relative  */
 324          0,                     /* bitpos  */
 325          complain_overflow_unsigned,/* complain_on_overflow  */
 326          nds32_elf_generic_reloc,/* special_function  */
 327          "R_NDS32_20",          /* name  */
 328          FALSE,                 /* partial_inplace  */
 329          0xfffff,               /* src_mask  */
 330          0xfffff,               /* dst_mask  */
 331          FALSE),                /* pcrel_offset  */
 332
 333   /* An PC Relative 9-bit relocation, shifted by 2.
 334      This reloc is complicated because relocations are relative to pc & -4.
 335      i.e. branches in the right insn slot use the address of the left insn
 336      slot for pc.  */
 337   /* It's not clear whether this should have partial_inplace set or not.
 338      Branch relaxing in the assembler can store the addend in the insn,
 339      and if bfd_install_relocation gets called the addend may get added
 340      again.  */
 341   HOWTO2 (R_NDS32_9_PCREL,      /* type  */
 342          1,                     /* rightshift  */
 343          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 344          8,                     /* bitsize  */
 345          TRUE,                  /* pc_relative  */
 346          0,                     /* bitpos  */
 347          complain_overflow_signed,/* complain_on_overflow  */
 348          nds32_elf_9_pcrel_reloc,/* special_function  */
 349          "R_NDS32_9_PCREL",     /* name  */
 350          FALSE,                 /* partial_inplace  */
 351          0xff,                  /* src_mask  */
 352          0xff,                  /* dst_mask  */
 353          TRUE),                 /* pcrel_offset  */
 354
 355   /* A relative 15 bit relocation, right shifted by 1.  */
 356   HOWTO2 (R_NDS32_15_PCREL,     /* type  */
 357          1,                     /* rightshift  */
 358          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 359          14,                    /* bitsize  */
 360          TRUE,                  /* pc_relative  */
 361          0,                     /* bitpos  */
 362          complain_overflow_signed,/* complain_on_overflow  */
 363          bfd_elf_generic_reloc, /* special_function  */
 364          "R_NDS32_15_PCREL",    /* name  */
 365          FALSE,                 /* partial_inplace  */
 366          0x3fff,                /* src_mask  */
 367          0x3fff,                /* dst_mask  */
 368          TRUE),                 /* pcrel_offset  */
 369
 370   /* A relative 17 bit relocation, right shifted by 1.  */
 371   HOWTO2 (R_NDS32_17_PCREL,     /* type  */
 372          1,                     /* rightshift  */
 373          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 374          16,                    /* bitsize  */
 375          TRUE,                  /* pc_relative  */
 376          0,                     /* bitpos  */
 377          complain_overflow_signed,/* complain_on_overflow  */
 378          bfd_elf_generic_reloc, /* special_function  */
 379          "R_NDS32_17_PCREL",    /* name  */
 380          FALSE,                 /* partial_inplace  */
 381          0xffff,                /* src_mask  */
 382          0xffff,                /* dst_mask  */
 383          TRUE),                 /* pcrel_offset  */
 384
 385   /* A relative 25 bit relocation, right shifted by 1.  */
 386   /* It's not clear whether this should have partial_inplace set or not.
 387      Branch relaxing in the assembler can store the addend in the insn,
 388      and if bfd_install_relocation gets called the addend may get added
 389      again.  */
 390   HOWTO2 (R_NDS32_25_PCREL,     /* type  */
 391          1,                     /* rightshift  */
 392          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 393          24,                    /* bitsize  */
 394          TRUE,                  /* pc_relative  */
 395          0,                     /* bitpos  */
 396          complain_overflow_signed,/* complain_on_overflow  */
 397          bfd_elf_generic_reloc, /* special_function  */
 398          "R_NDS32_25_PCREL",    /* name  */
 399          FALSE,                 /* partial_inplace  */
 400          0xffffff,              /* src_mask  */
 401          0xffffff,              /* dst_mask  */
 402          TRUE),                 /* pcrel_offset  */
 403
 404   /* High 20 bits of address when lower 12 is or'd in.  */
 405   HOWTO2 (R_NDS32_HI20,         /* type  */
 406          12,                    /* rightshift  */
 407          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 408          20,                    /* bitsize  */
 409          FALSE,                 /* pc_relative  */
 410          0,                     /* bitpos  */
 411          complain_overflow_dont,/* complain_on_overflow  */
 412          nds32_elf_hi20_reloc,  /* special_function  */
 413          "R_NDS32_HI20",        /* name  */
 414          FALSE,                 /* partial_inplace  */
 415          0x000fffff,            /* src_mask  */
 416          0x000fffff,            /* dst_mask  */
 417          FALSE),                /* pcrel_offset  */
 418
 419   /* Lower 12 bits of address.  */
 420   HOWTO2 (R_NDS32_LO12S3,       /* type  */
 421          3,                     /* rightshift  */
 422          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 423          9,                     /* bitsize  */
 424          FALSE,                 /* pc_relative  */
 425          0,                     /* bitpos  */
 426          complain_overflow_dont,/* complain_on_overflow  */
 427          nds32_elf_lo12_reloc,  /* special_function  */
 428          "R_NDS32_LO12S3",      /* name  */
 429          FALSE,                 /* partial_inplace  */
 430          0x000001ff,            /* src_mask  */
 431          0x000001ff,            /* dst_mask  */
 432          FALSE),                /* pcrel_offset  */
 433
 434   /* Lower 12 bits of address.  */
 435   HOWTO2 (R_NDS32_LO12S2,       /* type  */
 436          2,                     /* rightshift  */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 438          10,                    /* bitsize  */
 439          FALSE,                 /* pc_relative  */
 440          0,                     /* bitpos  */
 441          complain_overflow_dont,/* complain_on_overflow  */
 442          nds32_elf_lo12_reloc,  /* special_function  */
 443          "R_NDS32_LO12S2",      /* name  */
 444          FALSE,                 /* partial_inplace  */
 445          0x000003ff,            /* src_mask  */
 446          0x000003ff,            /* dst_mask  */
 447          FALSE),                /* pcrel_offset  */
 448
 449   /* Lower 12 bits of address.  */
 450   HOWTO2 (R_NDS32_LO12S1,       /* type  */
 451          1,                     /* rightshift  */
 452          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 453          11,                    /* bitsize  */
 454          FALSE,                 /* pc_relative  */
 455          0,                     /* bitpos  */
 456          complain_overflow_dont,/* complain_on_overflow  */
 457          nds32_elf_lo12_reloc,  /* special_function  */
 458          "R_NDS32_LO12S1",      /* name  */
 459          FALSE,                 /* partial_inplace  */
 460          0x000007ff,            /* src_mask  */
 461          0x000007ff,            /* dst_mask  */
 462          FALSE),                /* pcrel_offset  */
 463
 464   /* Lower 12 bits of address.  */
 465   HOWTO2 (R_NDS32_LO12S0,       /* type  */
 466          0,                     /* rightshift  */
 467          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 468          12,                    /* bitsize  */
 469          FALSE,                 /* pc_relative  */
 470          0,                     /* bitpos  */
 471          complain_overflow_dont,/* complain_on_overflow  */
 472          nds32_elf_lo12_reloc,  /* special_function  */
 473          "R_NDS32_LO12S0",      /* name  */
 474          FALSE,                 /* partial_inplace  */
 475          0x00000fff,            /* src_mask  */
 476          0x00000fff,            /* dst_mask  */
 477          FALSE),                /* pcrel_offset  */
 478
 479   /* Small data area 15 bits offset.  */
 480   HOWTO2 (R_NDS32_SDA15S3,      /* type  */
 481          3,                     /* rightshift  */
 482          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 483          15,                    /* bitsize  */
 484          FALSE,                 /* pc_relative  */
 485          0,                     /* bitpos  */
 486          complain_overflow_signed,/* complain_on_overflow  */
 487          nds32_elf_sda15_reloc, /* special_function  */
 488          "R_NDS32_SDA15S3",     /* name  */
 489          FALSE,                 /* partial_inplace  */
 490          0x00007fff,            /* src_mask  */
 491          0x00007fff,            /* dst_mask  */
 492          FALSE),                /* pcrel_offset  */
 493
 494   /* Small data area 15 bits offset.  */
 495   HOWTO2 (R_NDS32_SDA15S2,      /* type  */
 496          2,                     /* rightshift  */
 497          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 498          15,                    /* bitsize  */
 499          FALSE,                 /* pc_relative  */
 500          0,                     /* bitpos  */
 501          complain_overflow_signed,/* complain_on_overflow  */
 502          nds32_elf_sda15_reloc, /* special_function  */
 503          "R_NDS32_SDA15S2",     /* name  */
 504          FALSE,                 /* partial_inplace  */
 505          0x00007fff,            /* src_mask  */
 506          0x00007fff,            /* dst_mask  */
 507          FALSE),                /* pcrel_offset  */
 508
 509   /* Small data area 15 bits offset.  */
 510   HOWTO2 (R_NDS32_SDA15S1,      /* type  */
 511          1,                     /* rightshift  */
 512          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 513          15,                    /* bitsize  */
 514          FALSE,                 /* pc_relative  */
 515          0,                     /* bitpos  */
 516          complain_overflow_signed,/* complain_on_overflow  */
 517          nds32_elf_sda15_reloc, /* special_function  */
 518          "R_NDS32_SDA15S1",     /* name  */
 519          FALSE,                 /* partial_inplace  */
 520          0x00007fff,            /* src_mask  */
 521          0x00007fff,            /* dst_mask  */
 522          FALSE),                /* pcrel_offset  */
 523
 524   /* Small data area 15 bits offset.  */
 525   HOWTO2 (R_NDS32_SDA15S0,      /* type  */
 526          0,                     /* rightshift  */
 527          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 528          15,                    /* bitsize  */
 529          FALSE,                 /* pc_relative  */
 530          0,                     /* bitpos  */
 531          complain_overflow_signed,/* complain_on_overflow  */
 532          nds32_elf_sda15_reloc, /* special_function  */
 533          "R_NDS32_SDA15S0",     /* name  */
 534          FALSE,                 /* partial_inplace  */
 535          0x00007fff,            /* src_mask  */
 536          0x00007fff,            /* dst_mask  */
 537          FALSE),                /* pcrel_offset  */
 538
 539   /* GNU extension to record C++ vtable hierarchy  */
 540   HOWTO2 (R_NDS32_GNU_VTINHERIT,/* type  */
 541          0,                     /* rightshift  */
 542          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 543          0,                     /* bitsize  */
 544          FALSE,                 /* pc_relative  */
 545          0,                     /* bitpos  */
 546          complain_overflow_dont,/* complain_on_overflow  */
 547          NULL,                  /* special_function  */
 548          "R_NDS32_GNU_VTINHERIT",/* name  */
 549          FALSE,                 /* partial_inplace  */
 550          0,                     /* src_mask  */
 551          0,                     /* dst_mask  */
 552          FALSE),                /* pcrel_offset  */
 553
 554   /* GNU extension to record C++ vtable member usage  */
 555   HOWTO2 (R_NDS32_GNU_VTENTRY,  /* type  */
 556          0,                     /* rightshift  */
 557          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 558          0,                     /* bitsize  */
 559          FALSE,                 /* pc_relative  */
 560          0,                     /* bitpos  */
 561          complain_overflow_dont,/* complain_on_overflow  */
 562          _bfd_elf_rel_vtable_reloc_fn,/* special_function  */
 563          "R_NDS32_GNU_VTENTRY", /* name  */
 564          FALSE,                 /* partial_inplace  */
 565          0,                     /* src_mask  */
 566          0,                     /* dst_mask  */
 567          FALSE),                /* pcrel_offset  */
 568
 569   /* A 16 bit absolute relocation.  */
 570   HOWTO2 (R_NDS32_16_RELA,      /* type  */
 571          0,                     /* rightshift  */
 572          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 573          16,                    /* bitsize  */
 574          FALSE,                 /* pc_relative  */
 575          0,                     /* bitpos  */
 576          complain_overflow_bitfield,/* complain_on_overflow  */
 577          bfd_elf_generic_reloc, /* special_function  */
 578          "R_NDS32_16_RELA",     /* name  */
 579          FALSE,                 /* partial_inplace  */
 580          0xffff,                /* src_mask  */
 581          0xffff,                /* dst_mask  */
 582          FALSE),                /* pcrel_offset  */
 583
 584   /* A 32 bit absolute relocation.  */
 585   HOWTO2 (R_NDS32_32_RELA,      /* type  */
 586          0,                     /* rightshift  */
 587          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 588          32,                    /* bitsize  */
 589          FALSE,                 /* pc_relative  */
 590          0,                     /* bitpos  */
 591          complain_overflow_bitfield,/* complain_on_overflow  */
 592          bfd_elf_generic_reloc, /* special_function  */
 593          "R_NDS32_32_RELA",     /* name  */
 594          FALSE,                 /* partial_inplace  */
 595          0xffffffff,            /* src_mask  */
 596          0xffffffff,            /* dst_mask  */
 597          FALSE),                /* pcrel_offset  */
 598
 599   /* A 20 bit address.  */
 600   HOWTO2 (R_NDS32_20_RELA,      /* type  */
 601          0,                     /* rightshift  */
 602          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 603          20,                    /* bitsize  */
 604          FALSE,                 /* pc_relative  */
 605          0,                     /* bitpos  */
 606          complain_overflow_signed,/* complain_on_overflow  */
 607          bfd_elf_generic_reloc, /* special_function  */
 608          "R_NDS32_20_RELA",     /* name  */
 609          FALSE,                 /* partial_inplace  */
 610          0xfffff,               /* src_mask  */
 611          0xfffff,               /* dst_mask  */
 612          FALSE),                /* pcrel_offset  */
 613
 614   HOWTO2 (R_NDS32_9_PCREL_RELA, /* type  */
 615          1,                     /* rightshift  */
 616          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
 617          8,                     /* bitsize  */
 618          TRUE,                  /* pc_relative  */
 619          0,                     /* bitpos  */
 620          complain_overflow_signed,/* complain_on_overflow  */
 621          bfd_elf_generic_reloc, /* special_function  */
 622          "R_NDS32_9_PCREL_RELA",/* name  */
 623          FALSE,                 /* partial_inplace  */
 624          0xff,                  /* src_mask  */
 625          0xff,                  /* dst_mask  */
 626          TRUE),                 /* pcrel_offset  */
 627
 628   /* A relative 15 bit relocation, right shifted by 1.  */
 629   HOWTO2 (R_NDS32_15_PCREL_RELA,/* type  */
 630          1,                     /* rightshift  */
 631          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 632          14,                    /* bitsize  */
 633          TRUE,                  /* pc_relative  */
 634          0,                     /* bitpos  */
 635          complain_overflow_signed,/* complain_on_overflow  */
 636          bfd_elf_generic_reloc, /* special_function  */
 637          "R_NDS32_15_PCREL_RELA",/* name  */
 638          FALSE,                 /* partial_inplace  */
 639          0x3fff,                /* src_mask  */
 640          0x3fff,                /* dst_mask  */
 641          TRUE),                 /* pcrel_offset  */
 642
 643   /* A relative 17 bit relocation, right shifted by 1.  */
 644   HOWTO2 (R_NDS32_17_PCREL_RELA,/* type  */
 645          1,                     /* rightshift  */
 646          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 647          16,                    /* bitsize  */
 648          TRUE,                  /* pc_relative  */
 649          0,                     /* bitpos  */
 650          complain_overflow_signed,/* complain_on_overflow  */
 651          bfd_elf_generic_reloc, /* special_function  */
 652          "R_NDS32_17_PCREL_RELA",/* name  */
 653          FALSE,                 /* partial_inplace  */
 654          0xffff,                /* src_mask  */
 655          0xffff,                /* dst_mask  */
 656          TRUE),                 /* pcrel_offset  */
 657
 658   /* A relative 25 bit relocation, right shifted by 2.  */
 659   HOWTO2 (R_NDS32_25_PCREL_RELA,/* type  */
 660          1,                     /* rightshift  */
 661          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 662          24,                    /* bitsize  */
 663          TRUE,                  /* pc_relative  */
 664          0,                     /* bitpos  */
 665          complain_overflow_signed,/* complain_on_overflow  */
 666          bfd_elf_generic_reloc, /* special_function  */
 667          "R_NDS32_25_PCREL_RELA",/* name  */
 668          FALSE,                 /* partial_inplace  */
 669          0xffffff,              /* src_mask  */
 670          0xffffff,              /* dst_mask  */
 671          TRUE),                 /* pcrel_offset  */
 672
 673   /* High 20 bits of address when lower 16 is or'd in.  */
 674   HOWTO2 (R_NDS32_HI20_RELA,    /* type  */
 675          12,                    /* rightshift  */
 676          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 677          20,                    /* bitsize  */
 678          FALSE,                 /* pc_relative  */
 679          0,                     /* bitpos  */
 680          complain_overflow_dont,/* complain_on_overflow  */
 681          bfd_elf_generic_reloc, /* special_function  */
 682          "R_NDS32_HI20_RELA",   /* name  */
 683          FALSE,                 /* partial_inplace  */
 684          0x000fffff,            /* src_mask  */
 685          0x000fffff,            /* dst_mask  */
 686          FALSE),                /* pcrel_offset  */
 687
 688   /* Lower 12 bits of address.  */
 689   HOWTO2 (R_NDS32_LO12S3_RELA,  /* type  */
 690          3,                     /* rightshift  */
 691          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 692          9,                     /* bitsize  */
 693          FALSE,                 /* pc_relative  */
 694          0,                     /* bitpos  */
 695          complain_overflow_dont,/* complain_on_overflow  */
 696          bfd_elf_generic_reloc, /* special_function  */
 697          "R_NDS32_LO12S3_RELA", /* name  */
 698          FALSE,                 /* partial_inplace  */
 699          0x000001ff,            /* src_mask  */
 700          0x000001ff,            /* dst_mask  */
 701          FALSE),                /* pcrel_offset  */
 702
 703   /* Lower 12 bits of address.  */
 704   HOWTO2 (R_NDS32_LO12S2_RELA,  /* type  */
 705          2,                     /* rightshift  */
 706          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 707          10,                    /* bitsize  */
 708          FALSE,                 /* pc_relative  */
 709          0,                     /* bitpos  */
 710          complain_overflow_dont,/* complain_on_overflow  */
 711          bfd_elf_generic_reloc, /* special_function  */
 712          "R_NDS32_LO12S2_RELA", /* name  */
 713          FALSE,                 /* partial_inplace  */
 714          0x000003ff,            /* src_mask  */
 715          0x000003ff,            /* dst_mask  */
 716          FALSE),                /* pcrel_offset  */
 717
 718   /* Lower 12 bits of address.  */
 719   HOWTO2 (R_NDS32_LO12S1_RELA,  /* type  */
 720          1,                     /* rightshift  */
 721          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 722          11,                    /* bitsize  */
 723          FALSE,                 /* pc_relative  */
 724          0,                     /* bitpos  */
 725          complain_overflow_dont,/* complain_on_overflow  */
 726          bfd_elf_generic_reloc, /* special_function  */
 727          "R_NDS32_LO12S1_RELA", /* name  */
 728          FALSE,                 /* partial_inplace  */
 729          0x000007ff,            /* src_mask  */
 730          0x000007ff,            /* dst_mask  */
 731          FALSE),                /* pcrel_offset  */
 732
 733   /* Lower 12 bits of address.  */
 734   HOWTO2 (R_NDS32_LO12S0_RELA,  /* type  */
 735          0,                     /* rightshift  */
 736          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 737          12,                    /* bitsize  */
 738          FALSE,                 /* pc_relative  */
 739          0,                     /* bitpos  */
 740          complain_overflow_dont,/* complain_on_overflow  */
 741          bfd_elf_generic_reloc, /* special_function  */
 742          "R_NDS32_LO12S0_RELA", /* name  */
 743          FALSE,                 /* partial_inplace  */
 744          0x00000fff,            /* src_mask  */
 745          0x00000fff,            /* dst_mask  */
 746          FALSE),                /* pcrel_offset  */
 747
 748   /* Small data area 15 bits offset.  */
 749   HOWTO2 (R_NDS32_SDA15S3_RELA, /* type  */
 750          3,                     /* rightshift  */
 751          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 752          15,                    /* bitsize  */
 753          FALSE,                 /* pc_relative  */
 754          0,                     /* bitpos  */
 755          complain_overflow_signed,/* complain_on_overflow  */
 756          bfd_elf_generic_reloc, /* special_function  */
 757          "R_NDS32_SDA15S3_RELA",/* name  */
 758          FALSE,                 /* partial_inplace  */
 759          0x00007fff,            /* src_mask  */
 760          0x00007fff,            /* dst_mask  */
 761          FALSE),                /* pcrel_offset  */
 762
 763   /* Small data area 15 bits offset.  */
 764   HOWTO2 (R_NDS32_SDA15S2_RELA, /* type  */
 765          2,                     /* rightshift  */
 766          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 767          15,                    /* bitsize  */
 768          FALSE,                 /* pc_relative  */
 769          0,                     /* bitpos  */
 770          complain_overflow_signed,/* complain_on_overflow  */
 771          bfd_elf_generic_reloc, /* special_function  */
 772          "R_NDS32_SDA15S2_RELA",/* name  */
 773          FALSE,                 /* partial_inplace  */
 774          0x00007fff,            /* src_mask  */
 775          0x00007fff,            /* dst_mask  */
 776          FALSE),                /* pcrel_offset  */
 777
 778   HOWTO2 (R_NDS32_SDA15S1_RELA, /* type  */
 779          1,                     /* rightshift  */
 780          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 781          15,                    /* bitsize  */
 782          FALSE,                 /* pc_relative  */
 783          0,                     /* bitpos  */
 784          complain_overflow_signed,/* complain_on_overflow  */
 785          bfd_elf_generic_reloc, /* special_function  */
 786          "R_NDS32_SDA15S1_RELA",/* name  */
 787          FALSE,                 /* partial_inplace  */
 788          0x00007fff,            /* src_mask  */
 789          0x00007fff,            /* dst_mask  */
 790          FALSE),                /* pcrel_offset  */
 791
 792   HOWTO2 (R_NDS32_SDA15S0_RELA, /* type  */
 793          0,                     /* rightshift  */
 794          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 795          15,                    /* bitsize  */
 796          FALSE,                 /* pc_relative  */
 797          0,                     /* bitpos  */
 798          complain_overflow_signed,/* complain_on_overflow  */
 799          bfd_elf_generic_reloc, /* special_function  */
 800          "R_NDS32_SDA15S0_RELA",/* name  */
 801          FALSE,                 /* partial_inplace  */
 802          0x00007fff,            /* src_mask  */
 803          0x00007fff,            /* dst_mask  */
 804          FALSE),                /* pcrel_offset  */
 805
 806   /* GNU extension to record C++ vtable hierarchy  */
 807   HOWTO2 (R_NDS32_RELA_GNU_VTINHERIT,/* type  */
 808          0,                     /* rightshift  */
 809          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 810          0,                     /* bitsize  */
 811          FALSE,                 /* pc_relative  */
 812          0,                     /* bitpos  */
 813          complain_overflow_dont,/* complain_on_overflow  */
 814          NULL,                  /* special_function  */
 815          "R_NDS32_RELA_GNU_VTINHERIT",/* name  */
 816          FALSE,                 /* partial_inplace  */
 817          0,                     /* src_mask  */
 818          0,                     /* dst_mask  */
 819          FALSE),                /* pcrel_offset  */
 820
 821   /* GNU extension to record C++ vtable member usage  */
 822   HOWTO2 (R_NDS32_RELA_GNU_VTENTRY,/* type  */
 823          0,                     /* rightshift  */
 824          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 825          0,                     /* bitsize  */
 826          FALSE,                 /* pc_relative  */
 827          0,                     /* bitpos  */
 828          complain_overflow_dont,/* complain_on_overflow  */
 829          _bfd_elf_rel_vtable_reloc_fn,/* special_function  */
 830          "R_NDS32_RELA_GNU_VTENTRY",/* name  */
 831          FALSE,                 /* partial_inplace  */
 832          0,                     /* src_mask  */
 833          0,                     /* dst_mask  */
 834          FALSE),                /* pcrel_offset  */
 835
 836   /* Like R_NDS32_20, but referring to the GOT table entry for
 837      the symbol.  */
 838   HOWTO2 (R_NDS32_GOT20,        /* type  */
 839          0,                     /* rightshift  */
 840          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 841          20,                    /* bitsize  */
 842          FALSE,                 /* pc_relative  */
 843          0,                     /* bitpos  */
 844          complain_overflow_signed,/* complain_on_overflow  */
 845          bfd_elf_generic_reloc, /* special_function  */
 846          "R_NDS32_GOT20",       /* name  */
 847          FALSE,                 /* partial_inplace  */
 848          0xfffff,               /* src_mask  */
 849          0xfffff,               /* dst_mask  */
 850          FALSE),                /* pcrel_offset  */
 851
 852   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
 853      entry for the symbol.  */
 854   HOWTO2 (R_NDS32_25_PLTREL,    /* type  */
 855          1,                     /* rightshift  */
 856          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 857          24,                    /* bitsize  */
 858          TRUE,                  /* pc_relative  */
 859          0,                     /* bitpos  */
 860          complain_overflow_signed,/* complain_on_overflow  */
 861          bfd_elf_generic_reloc, /* special_function  */
 862          "R_NDS32_25_PLTREL",   /* name  */
 863          FALSE,                 /* partial_inplace  */
 864          0xffffff,              /* src_mask  */
 865          0xffffff,              /* dst_mask  */
 866          TRUE),                 /* pcrel_offset  */
 867
 868   /* This is used only by the dynamic linker.  The symbol should exist
 869      both in the object being run and in some shared library.  The
 870      dynamic linker copies the data addressed by the symbol from the
 871      shared library into the object, because the object being
 872      run has to have the data at some particular address.  */
 873   HOWTO2 (R_NDS32_COPY,         /* type  */
 874          0,                     /* rightshift  */
 875          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 876          32,                    /* bitsize  */
 877          FALSE,                 /* pc_relative  */
 878          0,                     /* bitpos  */
 879          complain_overflow_bitfield,/* complain_on_overflow  */
 880          bfd_elf_generic_reloc, /* special_function  */
 881          "R_NDS32_COPY",        /* name  */
 882          FALSE,                 /* partial_inplace  */
 883          0xffffffff,            /* src_mask  */
 884          0xffffffff,            /* dst_mask  */
 885          FALSE),                /* pcrel_offset  */
 886
 887   /* Like R_NDS32_20, but used when setting global offset table
 888      entries.  */
 889   HOWTO2 (R_NDS32_GLOB_DAT,     /* type  */
 890          0,                     /* rightshift  */
 891          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 892          32,                    /* bitsize  */
 893          FALSE,                 /* pc_relative  */
 894          0,                     /* bitpos  */
 895          complain_overflow_bitfield,/* complain_on_overflow  */
 896          bfd_elf_generic_reloc, /* special_function  */
 897          "R_NDS32_GLOB_DAT",    /* name  */
 898          FALSE,                 /* partial_inplace  */
 899          0xffffffff,            /* src_mask  */
 900          0xffffffff,            /* dst_mask  */
 901          FALSE),                /* pcrel_offset  */
 902
 903   /* Marks a procedure linkage table entry for a symbol.  */
 904   HOWTO2 (R_NDS32_JMP_SLOT,     /* type  */
 905          0,                     /* rightshift  */
 906          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 907          32,                    /* bitsize  */
 908          FALSE,                 /* pc_relative  */
 909          0,                     /* bitpos  */
 910          complain_overflow_bitfield,/* complain_on_overflow  */
 911          bfd_elf_generic_reloc, /* special_function  */
 912          "R_NDS32_JMP_SLOT",    /* name  */
 913          FALSE,                 /* partial_inplace  */
 914          0xffffffff,            /* src_mask  */
 915          0xffffffff,            /* dst_mask  */
 916          FALSE),                /* pcrel_offset  */
 917
 918   /* Used only by the dynamic linker.  When the object is run, this
 919      longword is set to the load address of the object, plus the
 920      addend.  */
 921   HOWTO2 (R_NDS32_RELATIVE,     /* type  */
 922          0,                     /* rightshift  */
 923          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 924          32,                    /* bitsize  */
 925          FALSE,                 /* pc_relative  */
 926          0,                     /* bitpos  */
 927          complain_overflow_bitfield,/* complain_on_overflow  */
 928          bfd_elf_generic_reloc, /* special_function  */
 929          "R_NDS32_RELATIVE",    /* name  */
 930          FALSE,                 /* partial_inplace  */
 931          0xffffffff,            /* src_mask  */
 932          0xffffffff,            /* dst_mask  */
 933          FALSE),                /* pcrel_offset  */
 934
 935   HOWTO2 (R_NDS32_GOTOFF,       /* type  */
 936          0,                     /* rightshift  */
 937          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 938          20,                    /* bitsize  */
 939          FALSE,                 /* pc_relative  */
 940          0,                     /* bitpos  */
 941          complain_overflow_signed,/* complain_on_overflow  */
 942          bfd_elf_generic_reloc, /* special_function  */
 943          "R_NDS32_GOTOFF",      /* name  */
 944          FALSE,                 /* partial_inplace  */
 945          0xfffff,               /* src_mask  */
 946          0xfffff,               /* dst_mask  */
 947          FALSE),                /* pcrel_offset  */
 948
 949   /* An PC Relative 20-bit relocation used when setting PIC offset
 950      table register.  */
 951   HOWTO2 (R_NDS32_GOTPC20,      /* type  */
 952          0,                     /* rightshift  */
 953          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 954          20,                    /* bitsize  */
 955          TRUE,                  /* pc_relative  */
 956          0,                     /* bitpos  */
 957          complain_overflow_signed,/* complain_on_overflow  */
 958          bfd_elf_generic_reloc, /* special_function  */
 959          "R_NDS32_GOTPC20",     /* name  */
 960          FALSE,                 /* partial_inplace  */
 961          0xfffff,               /* src_mask  */
 962          0xfffff,               /* dst_mask  */
 963          TRUE),                 /* pcrel_offset  */
 964
 965   /* Like R_NDS32_HI20, but referring to the GOT table entry for
 966      the symbol.  */
 967   HOWTO2 (R_NDS32_GOT_HI20,     /* type  */
 968          12,                    /* rightshift  */
 969          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 970          20,                    /* bitsize  */
 971          FALSE,                 /* pc_relative  */
 972          0,                     /* bitpos  */
 973          complain_overflow_dont,/* complain_on_overflow  */
 974          bfd_elf_generic_reloc, /* special_function  */
 975          "R_NDS32_GOT_HI20",    /* name  */
 976          FALSE,                 /* partial_inplace  */
 977          0x000fffff,            /* src_mask  */
 978          0x000fffff,            /* dst_mask  */
 979          FALSE),                /* pcrel_offset  */
 980   HOWTO2 (R_NDS32_GOT_LO12,     /* type  */
 981          0,                     /* rightshift  */
 982          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
 983          12,                    /* bitsize  */
 984          FALSE,                 /* pc_relative  */
 985          0,                     /* bitpos  */
 986          complain_overflow_dont,/* complain_on_overflow  */
 987          bfd_elf_generic_reloc, /* special_function  */
 988          "R_NDS32_GOT_LO12",    /* name  */
 989          FALSE,                 /* partial_inplace  */
 990          0x00000fff,            /* src_mask  */
 991          0x00000fff,            /* dst_mask  */
 992          FALSE),                /* pcrel_offset  */
 993
 994   /* An PC Relative relocation used when setting PIC offset table register.
 995      Like R_NDS32_HI20, but referring to the GOT table entry for
 996      the symbol.  */
 997   HOWTO2 (R_NDS32_GOTPC_HI20,   /* type  */
 998          12,                    /* rightshift  */
 999          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1000          20,                    /* bitsize  */
1001          FALSE,                 /* pc_relative  */
1002          0,                     /* bitpos  */
1003          complain_overflow_dont,/* complain_on_overflow  */
1004          bfd_elf_generic_reloc, /* special_function  */
1005          "R_NDS32_GOTPC_HI20",  /* name  */
1006          FALSE,                 /* partial_inplace  */
1007          0x000fffff,            /* src_mask  */
1008          0x000fffff,            /* dst_mask  */
1009          TRUE),                 /* pcrel_offset  */
1010   HOWTO2 (R_NDS32_GOTPC_LO12,   /* type  */
1011          0,                     /* rightshift  */
1012          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1013          12,                    /* bitsize  */
1014          FALSE,                 /* pc_relative  */
1015          0,                     /* bitpos  */
1016          complain_overflow_dont,/* complain_on_overflow  */
1017          bfd_elf_generic_reloc, /* special_function  */
1018          "R_NDS32_GOTPC_LO12",  /* name  */
1019          FALSE,                 /* partial_inplace  */
1020          0x00000fff,            /* src_mask  */
1021          0x00000fff,            /* dst_mask  */
1022          TRUE),                 /* pcrel_offset  */
1023
1024   HOWTO2 (R_NDS32_GOTOFF_HI20,  /* type  */
1025          12,                    /* rightshift  */
1026          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1027          20,                    /* bitsize  */
1028          FALSE,                 /* pc_relative  */
1029          0,                     /* bitpos  */
1030          complain_overflow_dont,/* complain_on_overflow  */
1031          bfd_elf_generic_reloc, /* special_function  */
1032          "R_NDS32_GOTOFF_HI20", /* name  */
1033          FALSE,                 /* partial_inplace  */
1034          0x000fffff,            /* src_mask  */
1035          0x000fffff,            /* dst_mask  */
1036          FALSE),                /* pcrel_offset  */
1037   HOWTO2 (R_NDS32_GOTOFF_LO12,  /* type  */
1038          0,                     /* rightshift  */
1039          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1040          12,                    /* bitsize  */
1041          FALSE,                 /* pc_relative  */
1042          0,                     /* bitpos  */
1043          complain_overflow_dont,/* complain_on_overflow  */
1044          bfd_elf_generic_reloc, /* special_function  */
1045          "R_NDS32_GOTOFF_LO12", /* name  */
1046          FALSE,                 /* partial_inplace  */
1047          0x00000fff,            /* src_mask  */
1048          0x00000fff,            /* dst_mask  */
1049          FALSE),                /* pcrel_offset  */
1050
1051   /* Alignment hint for relaxable instruction.  This is used with
1052      R_NDS32_LABEL as a pair.  Relax this instruction from 4 bytes to 2
1053      in order to make next label aligned on word boundary.  */
1054   HOWTO2 (R_NDS32_INSN16,       /* type  */
1055          0,                     /* rightshift  */
1056          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1057          32,                    /* bitsize  */
1058          FALSE,                 /* pc_relative  */
1059          0,                     /* bitpos  */
1060          complain_overflow_dont,/* complain_on_overflow  */
1061          nds32_elf_ignore_reloc,/* special_function  */
1062          "R_NDS32_INSN16",      /* name  */
1063          FALSE,                 /* partial_inplace  */
1064          0x00000fff,            /* src_mask  */
1065          0x00000fff,            /* dst_mask  */
1066          FALSE),                /* pcrel_offset  */
1067
1068   /* Alignment hint for label.  */
1069   HOWTO2 (R_NDS32_LABEL,        /* type  */
1070          0,                     /* rightshift  */
1071          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1072          32,                    /* bitsize  */
1073          FALSE,                 /* pc_relative  */
1074          0,                     /* bitpos  */
1075          complain_overflow_dont,/* complain_on_overflow  */
1076          nds32_elf_ignore_reloc,/* special_function  */
1077          "R_NDS32_LABEL",       /* name  */
1078          FALSE,                 /* partial_inplace  */
1079          0xffffffff,            /* src_mask  */
1080          0xffffffff,            /* dst_mask  */
1081          FALSE),                /* pcrel_offset  */
1082
1083   /* Relax hint for unconditional call sequence  */
1084   HOWTO2 (R_NDS32_LONGCALL1,    /* type  */
1085          0,                     /* rightshift  */
1086          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1087          32,                    /* bitsize  */
1088          FALSE,                 /* pc_relative  */
1089          0,                     /* bitpos  */
1090          complain_overflow_dont,/* complain_on_overflow  */
1091          nds32_elf_ignore_reloc,/* special_function  */
1092          "R_NDS32_LONGCALL1",   /* name  */
1093          FALSE,                 /* partial_inplace  */
1094          0xffffffff,            /* src_mask  */
1095          0xffffffff,            /* dst_mask  */
1096          FALSE),                /* pcrel_offset  */
1097
1098   /* Relax hint for conditional call sequence.  */
1099   HOWTO2 (R_NDS32_LONGCALL2,    /* type  */
1100          0,                     /* rightshift  */
1101          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1102          32,                    /* bitsize  */
1103          FALSE,                 /* pc_relative  */
1104          0,                     /* bitpos  */
1105          complain_overflow_dont,/* complain_on_overflow  */
1106          nds32_elf_ignore_reloc,/* special_function  */
1107          "R_NDS32_LONGCALL2",   /* name  */
1108          FALSE,                 /* partial_inplace  */
1109          0xffffffff,            /* src_mask  */
1110          0xffffffff,            /* dst_mask  */
1111          FALSE),                /* pcrel_offset  */
1112
1113   /* Relax hint for conditional call sequence.  */
1114   HOWTO2 (R_NDS32_LONGCALL3,    /* type  */
1115          0,                     /* rightshift  */
1116          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1117          32,                    /* bitsize  */
1118          FALSE,                 /* pc_relative  */
1119          0,                     /* bitpos  */
1120          complain_overflow_dont,/* complain_on_overflow  */
1121          nds32_elf_ignore_reloc,/* special_function  */
1122          "R_NDS32_LONGCALL3",   /* name  */
1123          FALSE,                 /* partial_inplace  */
1124          0xffffffff,            /* src_mask  */
1125          0xffffffff,            /* dst_mask  */
1126          FALSE),                /* pcrel_offset  */
1127
1128   /* Relax hint for unconditional branch sequence.  */
1129   HOWTO2 (R_NDS32_LONGJUMP1,    /* type  */
1130          0,                     /* rightshift  */
1131          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1132          32,                    /* bitsize  */
1133          FALSE,                 /* pc_relative  */
1134          0,                     /* bitpos  */
1135          complain_overflow_dont,/* complain_on_overflow  */
1136          nds32_elf_ignore_reloc,/* special_function  */
1137          "R_NDS32_LONGJUMP1",   /* name  */
1138          FALSE,                 /* partial_inplace  */
1139          0xffffffff,            /* src_mask  */
1140          0xffffffff,            /* dst_mask  */
1141          FALSE),                /* pcrel_offset  */
1142
1143   /* Relax hint for conditional branch sequence.  */
1144   HOWTO2 (R_NDS32_LONGJUMP2,    /* type  */
1145          0,                     /* rightshift  */
1146          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1147          32,                    /* bitsize  */
1148          FALSE,                 /* pc_relative  */
1149          0,                     /* bitpos  */
1150          complain_overflow_dont,/* complain_on_overflow  */
1151          nds32_elf_ignore_reloc,/* special_function  */
1152          "R_NDS32_LONGJUMP2",   /* name  */
1153          FALSE,                 /* partial_inplace  */
1154          0xffffffff,            /* src_mask  */
1155          0xffffffff,            /* dst_mask  */
1156          FALSE),                /* pcrel_offset  */
1157
1158   /* Relax hint for conditional branch sequence.  */
1159   HOWTO2 (R_NDS32_LONGJUMP3,    /* type  */
1160          0,                     /* rightshift  */
1161          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1162          32,                    /* bitsize  */
1163          FALSE,                 /* pc_relative  */
1164          0,                     /* bitpos  */
1165          complain_overflow_dont,/* complain_on_overflow  */
1166          nds32_elf_ignore_reloc,/* special_function  */
1167          "R_NDS32_LONGJUMP3",   /* name  */
1168          FALSE,                 /* partial_inplace  */
1169          0xffffffff,            /* src_mask  */
1170          0xffffffff,            /* dst_mask  */
1171          FALSE),                /* pcrel_offset  */
1172
1173   /* Relax hint for load/store sequence.   */
1174   HOWTO2 (R_NDS32_LOADSTORE,    /* type  */
1175          0,                     /* rightshift  */
1176          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1177          32,                    /* bitsize  */
1178          FALSE,                 /* pc_relative  */
1179          0,                     /* bitpos  */
1180          complain_overflow_dont,/* complain_on_overflow  */
1181          nds32_elf_ignore_reloc,/* special_function  */
1182          "R_NDS32_LOADSTORE",   /* name  */
1183          FALSE,                 /* partial_inplace  */
1184          0xffffffff,            /* src_mask  */
1185          0xffffffff,            /* dst_mask  */
1186          FALSE),                /* pcrel_offset  */
1187
1188   /* Relax hint for load/store sequence.  */
1189   HOWTO2 (R_NDS32_9_FIXED_RELA, /* type  */
1190          0,                     /* rightshift  */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1192          16,                    /* bitsize  */
1193          FALSE,                 /* pc_relative  */
1194          0,                     /* bitpos  */
1195          complain_overflow_dont,/* complain_on_overflow  */
1196          nds32_elf_ignore_reloc,/* special_function  */
1197          "R_NDS32_9_FIXED_RELA",/* name  */
1198          FALSE,                 /* partial_inplace  */
1199          0x000000ff,            /* src_mask  */
1200          0x000000ff,            /* dst_mask  */
1201          FALSE),                /* pcrel_offset  */
1202
1203   /* Relax hint for load/store sequence.  */
1204   HOWTO2 (R_NDS32_15_FIXED_RELA,/* type  */
1205          0,                     /* rightshift  */
1206          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1207          32,                    /* bitsize  */
1208          FALSE,                 /* pc_relative  */
1209          0,                     /* bitpos  */
1210          complain_overflow_dont,/* complain_on_overflow  */
1211          nds32_elf_ignore_reloc,/* special_function  */
1212          "R_NDS32_15_FIXED_RELA",/* name  */
1213          FALSE,                 /* partial_inplace  */
1214          0x00003fff,            /* src_mask  */
1215          0x00003fff,            /* dst_mask  */
1216          FALSE),                /* pcrel_offset  */
1217
1218   /* Relax hint for load/store sequence.  */
1219   HOWTO2 (R_NDS32_17_FIXED_RELA,/* type  */
1220          0,                     /* rightshift  */
1221          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1222          32,                    /* bitsize  */
1223          FALSE,                 /* pc_relative  */
1224          0,                     /* bitpos  */
1225          complain_overflow_dont,/* complain_on_overflow  */
1226          nds32_elf_ignore_reloc,/* special_function  */
1227          "R_NDS32_17_FIXED_RELA",/* name  */
1228          FALSE,                 /* partial_inplace  */
1229          0x0000ffff,            /* src_mask  */
1230          0x0000ffff,            /* dst_mask  */
1231          FALSE),                /* pcrel_offset  */
1232
1233   /* Relax hint for load/store sequence.  */
1234   HOWTO2 (R_NDS32_25_FIXED_RELA,/* type  */
1235          0,                     /* rightshift  */
1236          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1237          32,                    /* bitsize  */
1238          FALSE,                 /* pc_relative  */
1239          0,                     /* bitpos  */
1240          complain_overflow_dont,/* complain_on_overflow  */
1241          nds32_elf_ignore_reloc,/* special_function  */
1242          "R_NDS32_25_FIXED_RELA",/* name  */
1243          FALSE,                 /* partial_inplace  */
1244          0x00ffffff,            /* src_mask  */
1245          0x00ffffff,            /* dst_mask  */
1246          FALSE),                /* pcrel_offset  */
1247
1248   /* High 20 bits of PLT symbol offset relative to PC.  */
1249   HOWTO2 (R_NDS32_PLTREL_HI20,  /* type  */
1250          12,                    /* rightshift  */
1251          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1252          20,                    /* bitsize  */
1253          FALSE,                 /* pc_relative  */
1254          0,                     /* bitpos  */
1255          complain_overflow_dont,/* complain_on_overflow  */
1256          bfd_elf_generic_reloc, /* special_function  */
1257          "R_NDS32_PLTREL_HI20", /* name  */
1258          FALSE,                 /* partial_inplace  */
1259          0x000fffff,            /* src_mask  */
1260          0x000fffff,            /* dst_mask  */
1261          FALSE),                /* pcrel_offset  */
1262
1263   /* Low 12 bits of PLT symbol offset relative to PC.  */
1264   HOWTO2 (R_NDS32_PLTREL_LO12,  /* type  */
1265          0,                     /* rightshift  */
1266          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1267          12,                    /* bitsize  */
1268          FALSE,                 /* pc_relative  */
1269          0,                     /* bitpos  */
1270          complain_overflow_dont,/* complain_on_overflow  */
1271          bfd_elf_generic_reloc, /* special_function  */
1272          "R_NDS32_PLTREL_LO12", /* name  */
1273          FALSE,                 /* partial_inplace  */
1274          0x00000fff,            /* src_mask  */
1275          0x00000fff,            /* dst_mask  */
1276          FALSE),                /* pcrel_offset  */
1277
1278   /* High 20 bits of PLT symbol offset relative to GOT (GP).  */
1279   HOWTO2 (R_NDS32_PLT_GOTREL_HI20,      /* type  */
1280          12,                    /* rightshift  */
1281          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1282          20,                    /* bitsize  */
1283          FALSE,                 /* pc_relative  */
1284          0,                     /* bitpos  */
1285          complain_overflow_dont,/* complain_on_overflow  */
1286          bfd_elf_generic_reloc, /* special_function  */
1287          "R_NDS32_PLT_GOTREL_HI20",/* name  */
1288          FALSE,                 /* partial_inplace  */
1289          0x000fffff,            /* src_mask  */
1290          0x000fffff,            /* dst_mask  */
1291          FALSE),                /* pcrel_offset  */
1292
1293   /* Low 12 bits of PLT symbol offset relative to GOT (GP).  */
1294   HOWTO2 (R_NDS32_PLT_GOTREL_LO12,/* type  */
1295          0,                     /* rightshift  */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1297          12,                    /* bitsize  */
1298          FALSE,                 /* pc_relative  */
1299          0,                     /* bitpos  */
1300          complain_overflow_dont,/* complain_on_overflow  */
1301          bfd_elf_generic_reloc, /* special_function  */
1302          "R_NDS32_PLT_GOTREL_LO12",/* name  */
1303          FALSE,                 /* partial_inplace  */
1304          0x00000fff,            /* src_mask  */
1305          0x00000fff,            /* dst_mask  */
1306          FALSE),                /* pcrel_offset  */
1307
1308   /* Small data area 12 bits offset.  */
1309   HOWTO2 (R_NDS32_SDA12S2_DP_RELA,/* type  */
1310          2,                     /* rightshift  */
1311          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1312          12,                    /* bitsize  */
1313          FALSE,                 /* pc_relative  */
1314          0,                     /* bitpos  */
1315          complain_overflow_signed,/* complain_on_overflow  */
1316          bfd_elf_generic_reloc, /* special_function  */
1317          "R_NDS32_SDA12S2_DP_RELA",/* name  */
1318          FALSE,                 /* partial_inplace  */
1319          0x00000fff,            /* src_mask  */
1320          0x00000fff,            /* dst_mask  */
1321          FALSE),                /* pcrel_offset  */
1322
1323   /* Small data area 12 bits offset.  */
1324   HOWTO2 (R_NDS32_SDA12S2_SP_RELA,/* type  */
1325          2,                     /* rightshift  */
1326          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1327          12,                    /* bitsize  */
1328          FALSE,                 /* pc_relative  */
1329          0,                     /* bitpos  */
1330          complain_overflow_signed,/* complain_on_overflow  */
1331          bfd_elf_generic_reloc, /* special_function  */
1332          "R_NDS32_SDA12S2_SP_RELA",/* name  */
1333          FALSE,                 /* partial_inplace  */
1334          0x00000fff,            /* src_mask  */
1335          0x00000fff,            /* dst_mask  */
1336          FALSE),                /* pcrel_offset  */
1337   /* Lower 12 bits of address.  */
1338
1339   HOWTO2 (R_NDS32_LO12S2_DP_RELA,       /* type  */
1340          2,                     /* rightshift  */
1341          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1342          10,                    /* bitsize  */
1343          FALSE,                 /* pc_relative  */
1344          0,                     /* bitpos  */
1345          complain_overflow_dont,/* complain_on_overflow  */
1346          bfd_elf_generic_reloc, /* special_function  */
1347          "R_NDS32_LO12S2_DP_RELA",/* name  */
1348          FALSE,                 /* partial_inplace  */
1349          0x000003ff,            /* src_mask  */
1350          0x000003ff,            /* dst_mask  */
1351          FALSE),                /* pcrel_offset  */
1352
1353   /* Lower 12 bits of address.  */
1354   HOWTO2 (R_NDS32_LO12S2_SP_RELA,/* type  */
1355          2,                     /* rightshift  */
1356          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1357          10,                    /* bitsize  */
1358          FALSE,                 /* pc_relative  */
1359          0,                     /* bitpos  */
1360          complain_overflow_dont,/* complain_on_overflow  */
1361          bfd_elf_generic_reloc, /* special_function  */
1362          "R_NDS32_LO12S2_SP_RELA",/* name  */
1363          FALSE,                 /* partial_inplace  */
1364          0x000003ff,            /* src_mask  */
1365          0x000003ff,            /* dst_mask  */
1366          FALSE),                /* pcrel_offset  */
1367   /* Lower 12 bits of address.  Special identity for or case.  */
1368   HOWTO2 (R_NDS32_LO12S0_ORI_RELA,/* type  */
1369          0,                     /* rightshift  */
1370          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1371          12,                    /* bitsize  */
1372          FALSE,                 /* pc_relative  */
1373          0,                     /* bitpos  */
1374          complain_overflow_dont,/* complain_on_overflow  */
1375          bfd_elf_generic_reloc, /* special_function  */
1376          "R_NDS32_LO12S0_ORI_RELA",/* name  */
1377          FALSE,                 /* partial_inplace  */
1378          0x00000fff,            /* src_mask  */
1379          0x00000fff,            /* dst_mask  */
1380          FALSE),                /* pcrel_offset  */
1381   /* Small data area 19 bits offset.  */
1382   HOWTO2 (R_NDS32_SDA16S3_RELA, /* type  */
1383          3,                     /* rightshift  */
1384          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1385          16,                    /* bitsize  */
1386          FALSE,                 /* pc_relative  */
1387          0,                     /* bitpos  */
1388          complain_overflow_signed,/* complain_on_overflow  */
1389          bfd_elf_generic_reloc, /* special_function  */
1390          "R_NDS32_SDA16S3_RELA",/* name  */
1391          FALSE,                 /* partial_inplace  */
1392          0x0000ffff,            /* src_mask  */
1393          0x0000ffff,            /* dst_mask  */
1394          FALSE),                /* pcrel_offset  */
1395
1396   /* Small data area 15 bits offset.  */
1397   HOWTO2 (R_NDS32_SDA17S2_RELA, /* type  */
1398          2,                     /* rightshift  */
1399          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1400          17,                    /* bitsize  */
1401          FALSE,                 /* pc_relative  */
1402          0,                     /* bitpos  */
1403          complain_overflow_signed,/* complain_on_overflow  */
1404          bfd_elf_generic_reloc, /* special_function  */
1405          "R_NDS32_SDA17S2_RELA",/* name  */
1406          FALSE,                 /* partial_inplace  */
1407          0x0001ffff,            /* src_mask  */
1408          0x0001ffff,            /* dst_mask  */
1409          FALSE),                /* pcrel_offset  */
1410
1411   HOWTO2 (R_NDS32_SDA18S1_RELA, /* type  */
1412          1,                     /* rightshift  */
1413          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1414          18,                    /* bitsize  */
1415          FALSE,                 /* pc_relative  */
1416          0,                     /* bitpos  */
1417          complain_overflow_signed,/* complain_on_overflow  */
1418          bfd_elf_generic_reloc, /* special_function  */
1419          "R_NDS32_SDA18S1_RELA",/* name  */
1420          FALSE,                 /* partial_inplace  */
1421          0x0003ffff,            /* src_mask  */
1422          0x0003ffff,            /* dst_mask  */
1423          FALSE),                /* pcrel_offset  */
1424
1425   HOWTO2 (R_NDS32_SDA19S0_RELA, /* type  */
1426          0,                     /* rightshift  */
1427          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1428          19,                    /* bitsize  */
1429          FALSE,                 /* pc_relative  */
1430          0,                     /* bitpos  */
1431          complain_overflow_signed,/* complain_on_overflow  */
1432          bfd_elf_generic_reloc, /* special_function  */
1433          "R_NDS32_SDA19S0_RELA",/* name  */
1434          FALSE,                 /* partial_inplace  */
1435          0x0007ffff,            /* src_mask  */
1436          0x0007ffff,            /* dst_mask  */
1437          FALSE),                /* pcrel_offset  */
1438   HOWTO2 (R_NDS32_DWARF2_OP1_RELA,/* type  */
1439          0,                     /* rightshift  */
1440          0,                     /* size (0 = byte, 1 = short, 2 = long)  */
1441          8,                     /* bitsize  */
1442          FALSE,                 /* pc_relative  */
1443          0,                     /* bitpos  */
1444          complain_overflow_dont,/* complain_on_overflow  */
1445          nds32_elf_ignore_reloc,/* special_function  */
1446          "R_NDS32_DWARF2_OP1_RELA",/* name  */
1447          FALSE,                 /* partial_inplace  */
1448          0xff,                  /* src_mask  */
1449          0xff,                  /* dst_mask  */
1450          FALSE),                /* pcrel_offset  */
1451   HOWTO2 (R_NDS32_DWARF2_OP2_RELA,/* type  */
1452          0,                     /* rightshift  */
1453          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1454          16,                    /* bitsize  */
1455          FALSE,                 /* pc_relative  */
1456          0,                     /* bitpos  */
1457          complain_overflow_dont,/* complain_on_overflow  */
1458          nds32_elf_ignore_reloc,/* special_function  */
1459          "R_NDS32_DWARF2_OP2_RELA",/* name  */
1460          FALSE,                 /* partial_inplace  */
1461          0xffff,                /* src_mask  */
1462          0xffff,                /* dst_mask  */
1463          FALSE),                /* pcrel_offset  */
1464   HOWTO2 (R_NDS32_DWARF2_LEB_RELA,/* type  */
1465          0,                     /* rightshift  */
1466          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1467          32,                    /* bitsize  */
1468          FALSE,                 /* pc_relative  */
1469          0,                     /* bitpos  */
1470          complain_overflow_dont,/* complain_on_overflow  */
1471          nds32_elf_ignore_reloc,/* special_function  */
1472          "R_NDS32_DWARF2_LEB_RELA",/* name  */
1473          FALSE,                 /* partial_inplace  */
1474          0xffffffff,            /* src_mask  */
1475          0xffffffff,            /* dst_mask  */
1476          FALSE),                /* pcrel_offset  */
1477   HOWTO2 (R_NDS32_UPDATE_TA_RELA,/* type  */
1478          0,                     /* rightshift  */
1479          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1480          16,                    /* bitsize  */
1481          FALSE,                 /* pc_relative  */
1482          0,                     /* bitpos  */
1483          complain_overflow_dont,/* complain_on_overflow  */
1484          nds32_elf_ignore_reloc,/* special_function  */
1485          "R_NDS32_UPDATE_TA_RELA",/* name  */
1486          FALSE,                 /* partial_inplace  */
1487          0xffff,                /* src_mask  */
1488          0xffff,                /* dst_mask  */
1489          FALSE),                /* pcrel_offset  */
1490   /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1491      entry for the symbol.  */
1492   HOWTO2 (R_NDS32_9_PLTREL,     /* type  */
1493          1,                     /* rightshift  */
1494          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1495          8,                     /* bitsize  */
1496          TRUE,                  /* pc_relative  */
1497          0,                     /* bitpos  */
1498          complain_overflow_signed,/* complain_on_overflow  */
1499          bfd_elf_generic_reloc, /* special_function  */
1500          "R_NDS32_9_PLTREL",    /* name  */
1501          FALSE,                 /* partial_inplace  */
1502          0xff,                  /* src_mask  */
1503          0xff,                  /* dst_mask  */
1504          TRUE),                 /* pcrel_offset  */
1505   /* Low 20 bits of PLT symbol offset relative to GOT (GP).  */
1506   HOWTO2 (R_NDS32_PLT_GOTREL_LO20,/* type  */
1507          0,                     /* rightshift  */
1508          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1509          20,                    /* bitsize  */
1510          FALSE,                 /* pc_relative  */
1511          0,                     /* bitpos  */
1512          complain_overflow_dont,/* complain_on_overflow  */
1513          bfd_elf_generic_reloc, /* special_function  */
1514          "R_NDS32_PLT_GOTREL_LO20",/* name  */
1515          FALSE,                 /* partial_inplace  */
1516          0x000fffff,            /* src_mask  */
1517          0x000fffff,            /* dst_mask  */
1518          FALSE),                /* pcrel_offset  */
1519   /* low 15 bits of PLT symbol offset relative to GOT (GP)  */
1520   HOWTO2 (R_NDS32_PLT_GOTREL_LO15,/* type  */
1521          0,                     /* rightshift  */
1522          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1523          15,                    /* bitsize  */
1524          FALSE,                 /* pc_relative  */
1525          0,                     /* bitpos  */
1526          complain_overflow_dont,/* complain_on_overflow  */
1527          bfd_elf_generic_reloc, /* special_function  */
1528          "R_NDS32_PLT_GOTREL_LO15",/* name  */
1529          FALSE,                 /* partial_inplace  */
1530          0x00007fff,            /* src_mask  */
1531          0x00007fff,            /* dst_mask  */
1532          FALSE),                /* pcrel_offset  */
1533   /* Low 19 bits of PLT symbol offset relative to GOT (GP).  */
1534   HOWTO2 (R_NDS32_PLT_GOTREL_LO19,/* type  */
1535          0,                     /* rightshift  */
1536          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1537          19,                    /* bitsize  */
1538          FALSE,                 /* pc_relative  */
1539          0,                     /* bitpos  */
1540          complain_overflow_dont,/* complain_on_overflow  */
1541          bfd_elf_generic_reloc, /* special_function  */
1542          "R_NDS32_PLT_GOTREL_LO19",/* name  */
1543          FALSE,                 /* partial_inplace  */
1544          0x0007ffff,            /* src_mask  */
1545          0x0007ffff,            /* dst_mask  */
1546          FALSE),                /* pcrel_offset  */
1547   HOWTO2 (R_NDS32_GOT_LO15,     /* type  */
1548          0,                     /* rightshift  */
1549          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1550          15,                    /* bitsize  */
1551          FALSE,                 /* pc_relative  */
1552          0,                     /* bitpos  */
1553          complain_overflow_dont,/* complain_on_overflow  */
1554          bfd_elf_generic_reloc, /* special_function  */
1555          "R_NDS32_GOT_LO15",    /* name  */
1556          FALSE,                 /* partial_inplace  */
1557          0x00007fff,            /* src_mask  */
1558          0x00007fff,            /* dst_mask  */
1559          FALSE),                /* pcrel_offset  */
1560   HOWTO2 (R_NDS32_GOT_LO19,     /* type  */
1561          0,                     /* rightshift  */
1562          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1563          19,                    /* bitsize  */
1564          FALSE,                 /* pc_relative  */
1565          0,                     /* bitpos  */
1566          complain_overflow_dont,/* complain_on_overflow  */
1567          bfd_elf_generic_reloc, /* special_function  */
1568          "R_NDS32_GOT_LO19",    /* name  */
1569          FALSE,                 /* partial_inplace  */
1570          0x0007ffff,            /* src_mask  */
1571          0x0007ffff,            /* dst_mask  */
1572          FALSE),                /* pcrel_offset  */
1573   HOWTO2 (R_NDS32_GOTOFF_LO15,  /* type  */
1574          0,                     /* rightshift  */
1575          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1576          15,                    /* bitsize  */
1577          FALSE,                 /* pc_relative  */
1578          0,                     /* bitpos  */
1579          complain_overflow_dont,/* complain_on_overflow  */
1580          bfd_elf_generic_reloc, /* special_function  */
1581          "R_NDS32_GOTOFF_LO15", /* name  */
1582          FALSE,                 /* partial_inplace  */
1583          0x00007fff,            /* src_mask  */
1584          0x00007fff,            /* dst_mask  */
1585          FALSE),                /* pcrel_offset  */
1586   HOWTO2 (R_NDS32_GOTOFF_LO19,  /* type  */
1587          0,                     /* rightshift  */
1588          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1589          19,                    /* bitsize  */
1590          FALSE,                 /* pc_relative  */
1591          0,                     /* bitpos  */
1592          complain_overflow_dont,/* complain_on_overflow  */
1593          bfd_elf_generic_reloc, /* special_function  */
1594          "R_NDS32_GOTOFF_LO19", /* name  */
1595          FALSE,                 /* partial_inplace  */
1596          0x0007ffff,            /* src_mask  */
1597          0x0007ffff,            /* dst_mask  */
1598          FALSE),                /* pcrel_offset  */
1599   /* GOT 15 bits offset.  */
1600   HOWTO2 (R_NDS32_GOT15S2_RELA, /* type  */
1601          2,                     /* rightshift  */
1602          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1603          15,                    /* bitsize  */
1604          FALSE,                 /* pc_relative  */
1605          0,                     /* bitpos  */
1606          complain_overflow_signed,/* complain_on_overflow  */
1607          bfd_elf_generic_reloc, /* special_function  */
1608          "R_NDS32_GOT15S2_RELA",/* name  */
1609          FALSE,                 /* partial_inplace  */
1610          0x00007fff,            /* src_mask  */
1611          0x00007fff,            /* dst_mask  */
1612          FALSE),                /* pcrel_offset  */
1613   /* GOT 17 bits offset.  */
1614   HOWTO2 (R_NDS32_GOT17S2_RELA, /* type  */
1615          2,                     /* rightshift  */
1616          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1617          17,                    /* bitsize  */
1618          FALSE,                 /* pc_relative  */
1619          0,                     /* bitpos  */
1620          complain_overflow_signed,/* complain_on_overflow  */
1621          bfd_elf_generic_reloc, /* special_function  */
1622          "R_NDS32_GOT17S2_RELA",/* name  */
1623          FALSE,                 /* partial_inplace  */
1624          0x0001ffff,            /* src_mask  */
1625          0x0001ffff,            /* dst_mask  */
1626          FALSE),                /* pcrel_offset  */
1627   /* A 5 bit address.  */
1628   HOWTO2 (R_NDS32_5_RELA,       /* type  */
1629          0,                     /* rightshift  */
1630          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1631          5,                     /* bitsize  */
1632          FALSE,                 /* pc_relative  */
1633          0,                     /* bitpos  */
1634          complain_overflow_signed,/* complain_on_overflow  */
1635          bfd_elf_generic_reloc, /* special_function  */
1636          "R_NDS32_5_RELA",      /* name  */
1637          FALSE,                 /* partial_inplace  */
1638          0x1f,                  /* src_mask  */
1639          0x1f,                  /* dst_mask  */
1640          FALSE),                /* pcrel_offset  */
1641   HOWTO2 (R_NDS32_10_UPCREL_RELA,/* type  */
1642          1,                     /* rightshift  */
1643          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1644          9,                     /* bitsize  */
1645          TRUE,                  /* pc_relative  */
1646          0,                     /* bitpos  */
1647          complain_overflow_unsigned,/* complain_on_overflow  */
1648          bfd_elf_generic_reloc, /* special_function  */
1649          "R_NDS32_10_UPCREL_RELA",/* name  */
1650          FALSE,                 /* partial_inplace  */
1651          0x1ff,                 /* src_mask  */
1652          0x1ff,                 /* dst_mask  */
1653          TRUE),                 /* pcrel_offset  */
1654   HOWTO2 (R_NDS32_SDA_FP7U2_RELA,/* type  */
1655          2,                     /* rightshift  */
1656          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1657          7,                     /* bitsize  */
1658          FALSE,                 /* pc_relative  */
1659          0,                     /* bitpos  */
1660          complain_overflow_unsigned,/* complain_on_overflow  */
1661          bfd_elf_generic_reloc, /* special_function  */
1662          "R_NDS32_SDA_FP7U2_RELA",/* name  */
1663          FALSE,                 /* partial_inplace  */
1664          0x0000007f,            /* src_mask  */
1665          0x0000007f,            /* dst_mask  */
1666          FALSE),                /* pcrel_offset  */
1667   HOWTO2 (R_NDS32_WORD_9_PCREL_RELA,/* type  */
1668          1,                     /* rightshift  */
1669          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1670          8,                     /* bitsize  */
1671          TRUE,                  /* pc_relative  */
1672          0,                     /* bitpos  */
1673          complain_overflow_signed,/* complain_on_overflow  */
1674          bfd_elf_generic_reloc, /* special_function  */
1675          "R_NDS32_WORD_9_PCREL_RELA",/* name  */
1676          FALSE,                 /* partial_inplace  */
1677          0xff,                  /* src_mask  */
1678          0xff,                  /* dst_mask  */
1679          TRUE),                 /* pcrel_offset  */
1680   HOWTO2 (R_NDS32_25_ABS_RELA,  /* type  */
1681          1,                     /* rightshift  */
1682          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1683          24,                    /* bitsize  */
1684          FALSE,                 /* pc_relative  */
1685          0,                     /* bitpos  */
1686          complain_overflow_dont,/* complain_on_overflow  */
1687          bfd_elf_generic_reloc, /* special_function  */
1688          "R_NDS32_25_ABS_RELA", /* name  */
1689          FALSE,                 /* partial_inplace  */
1690          0xffffff,              /* src_mask  */
1691          0xffffff,              /* dst_mask  */
1692          FALSE),                /* pcrel_offset  */
1693
1694   /* A relative 17 bit relocation for ifc, right shifted by 1.  */
1695   HOWTO2 (R_NDS32_17IFC_PCREL_RELA,/* type  */
1696          1,                     /* rightshift  */
1697          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1698          16,                    /* bitsize  */
1699          TRUE,                  /* pc_relative  */
1700          0,                     /* bitpos  */
1701          complain_overflow_signed,/* complain_on_overflow  */
1702          bfd_elf_generic_reloc, /* special_function  */
1703          "R_NDS32_17IFC_PCREL_RELA",/* name  */
1704          FALSE,                 /* partial_inplace  */
1705          0xffff,                /* src_mask  */
1706          0xffff,                /* dst_mask  */
1707          TRUE),                 /* pcrel_offset  */
1708
1709   /* A relative unsigned 10 bit relocation for ifc, right shifted by 1.  */
1710   HOWTO2 (R_NDS32_10IFCU_PCREL_RELA,/* type  */
1711          1,                     /* rightshift  */
1712          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
1713          9,                     /* bitsize  */
1714          TRUE,                  /* pc_relative  */
1715          0,                     /* bitpos  */
1716          complain_overflow_unsigned,/* complain_on_overflow  */
1717          bfd_elf_generic_reloc, /* special_function  */
1718          "R_NDS32_10IFCU_PCREL_RELA",/* name  */
1719          FALSE,                 /* partial_inplace  */
1720          0x1ff,                 /* src_mask  */
1721          0x1ff,                 /* dst_mask  */
1722          TRUE),                 /* pcrel_offset  */
1723
1724   /* Like R_NDS32_HI20, but referring to the TLS LE entry for the symbol.  */
1725   HOWTO2 (R_NDS32_TLS_LE_HI20,  /* type  */
1726          12,                    /* rightshift  */
1727          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1728          20,                    /* bitsize  */
1729          FALSE,                 /* pc_relative  */
1730          0,                     /* bitpos  */
1731          complain_overflow_dont,/* complain_on_overflow  */
1732          bfd_elf_generic_reloc, /* special_function  */
1733          "R_NDS32_TLS_LE_HI20", /* name  */
1734          FALSE,                 /* partial_inplace  */
1735          0x000fffff,            /* src_mask  */
1736          0x000fffff,            /* dst_mask  */
1737          FALSE),                /* pcrel_offset  */
1738
1739   HOWTO2 (R_NDS32_TLS_LE_LO12,  /* type  */
1740          0,                     /* rightshift  */
1741          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1742          12,                    /* bitsize  */
1743          FALSE,                 /* pc_relative  */
1744          0,                     /* bitpos  */
1745          complain_overflow_dont,/* complain_on_overflow  */
1746          bfd_elf_generic_reloc, /* special_function  */
1747          "R_NDS32_TLS_LE_LO12", /* name  */
1748          FALSE,                 /* partial_inplace  */
1749          0x00000fff,            /* src_mask  */
1750          0x00000fff,            /* dst_mask  */
1751          FALSE),                /* pcrel_offset  */
1752
1753   /* Like R_NDS32_HI20, but referring to the TLS IE entry for the symbol.  */
1754   HOWTO2 (R_NDS32_TLS_IE_HI20,  /* type  */
1755          12,                    /* rightshift  */
1756          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1757          20,                    /* bitsize  */
1758          FALSE,                 /* pc_relative  */
1759          0,                     /* bitpos  */
1760          complain_overflow_dont,/* complain_on_overflow  */
1761          bfd_elf_generic_reloc, /* special_function  */
1762          "R_NDS32_TLS_IE_HI20", /* name  */
1763          FALSE,                 /* partial_inplace  */
1764          0x000fffff,            /* src_mask  */
1765          0x000fffff,            /* dst_mask  */
1766          FALSE),                /* pcrel_offset  */
1767
1768   HOWTO2 (R_NDS32_TLS_IE_LO12S2,/* type  */
1769          2,                     /* rightshift  */
1770          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1771          10,                    /* bitsize  */
1772          FALSE,                 /* pc_relative  */
1773          0,                     /* bitpos  */
1774          complain_overflow_dont,/* complain_on_overflow  */
1775          bfd_elf_generic_reloc, /* special_function  */
1776          "R_NDS32_TLS_IE_LO12S2",/* name  */
1777          FALSE,                 /* partial_inplace  */
1778          0x000003ff,            /* src_mask  */
1779          0x000003ff,            /* dst_mask  */
1780          FALSE),                /* pcrel_offset  */
1781
1782   /* TLS LE TP offset relocation  */
1783   HOWTO2 (R_NDS32_TLS_TPOFF,    /* type  */
1784          0,                     /* rightshift  */
1785          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1786          32,                    /* bitsize  */
1787          FALSE,                 /* pc_relative  */
1788          0,                     /* bitpos  */
1789          complain_overflow_bitfield,/* complain_on_overflow  */
1790          bfd_elf_generic_reloc, /* special_function  */
1791          "R_NDS32_TLS_TPOFF",   /* name  */
1792          FALSE,                 /* partial_inplace  */
1793          0xffffffff,            /* src_mask  */
1794          0xffffffff,            /* dst_mask  */
1795          FALSE),                /* pcrel_offset  */
1796
1797   /* A 20 bit address.  */
1798   HOWTO2 (R_NDS32_TLS_LE_20,    /* type  */
1799          0,                     /* rightshift  */
1800          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1801          20,                    /* bitsize  */
1802          FALSE,                 /* pc_relative  */
1803          0,                     /* bitpos  */
1804          complain_overflow_signed,/* complain_on_overflow  */
1805          bfd_elf_generic_reloc, /* special_function  */
1806          "R_NDS32_TLS_LE_20",   /* name  */
1807          FALSE,                 /* partial_inplace  */
1808          0xfffff,               /* src_mask  */
1809          0xfffff,               /* dst_mask  */
1810          FALSE),                /* pcrel_offset  */
1811
1812   HOWTO2 (R_NDS32_TLS_LE_15S0,  /* type  */
1813          0,                     /* rightshift  */
1814          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1815          15,                    /* bitsize  */
1816          FALSE,                 /* pc_relative  */
1817          0,                     /* bitpos  */
1818          complain_overflow_signed,/* complain_on_overflow  */
1819          bfd_elf_generic_reloc, /* special_function  */
1820          "R_NDS32_TLS_LE_15S0", /* name  */
1821          FALSE,                 /* partial_inplace  */
1822          0x7fff,                /* src_mask  */
1823          0x7fff,                /* dst_mask  */
1824          FALSE),                /* pcrel_offset  */
1825   HOWTO2 (R_NDS32_TLS_LE_15S1,  /* type  */
1826          1,                     /* rightshift  */
1827          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1828          15,                    /* bitsize  */
1829          FALSE,                 /* pc_relative  */
1830          0,                     /* bitpos  */
1831          complain_overflow_signed,/* complain_on_overflow  */
1832          bfd_elf_generic_reloc, /* special_function  */
1833          "R_NDS32_TLS_LE_15S1", /* name  */
1834          FALSE,                 /* partial_inplace  */
1835          0x7fff,                /* src_mask  */
1836          0x7fff,                /* dst_mask  */
1837          FALSE),                /* pcrel_offset  */
1838   HOWTO2 (R_NDS32_TLS_LE_15S2,  /* type  */
1839          2,                     /* rightshift  */
1840          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1841          15,                    /* bitsize  */
1842          FALSE,                 /* pc_relative  */
1843          0,                     /* bitpos  */
1844          complain_overflow_signed,/* complain_on_overflow  */
1845          bfd_elf_generic_reloc, /* special_function  */
1846          "R_NDS32_TLS_LE_15S2", /* name  */
1847          FALSE,                 /* partial_inplace  */
1848          0x7fff,                /* src_mask  */
1849          0x7fff,                /* dst_mask  */
1850          FALSE),                /* pcrel_offset  */
1851
1852   /* Relax hint for unconditional call sequence  */
1853   HOWTO2 (R_NDS32_LONGCALL4,    /* type  */
1854          0,                     /* rightshift  */
1855          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1856          32,                    /* bitsize  */
1857          FALSE,                 /* pc_relative  */
1858          0,                     /* bitpos  */
1859          complain_overflow_dont,/* complain_on_overflow  */
1860          nds32_elf_ignore_reloc,/* special_function  */
1861          "R_NDS32_LONGCALL4",   /* name  */
1862          FALSE,                 /* partial_inplace  */
1863          0xffffffff,            /* src_mask  */
1864          0xffffffff,            /* dst_mask  */
1865          FALSE),                /* pcrel_offset  */
1866
1867   /* Relax hint for conditional call sequence.  */
1868   HOWTO2 (R_NDS32_LONGCALL5,    /* type  */
1869          0,                     /* rightshift  */
1870          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1871          32,                    /* bitsize  */
1872          FALSE,                 /* pc_relative  */
1873          0,                     /* bitpos  */
1874          complain_overflow_dont,/* complain_on_overflow  */
1875          nds32_elf_ignore_reloc,/* special_function  */
1876          "R_NDS32_LONGCALL5",   /* name  */
1877          FALSE,                 /* partial_inplace  */
1878          0xffffffff,            /* src_mask  */
1879          0xffffffff,            /* dst_mask  */
1880          FALSE),                /* pcrel_offset  */
1881
1882   /* Relax hint for conditional call sequence.  */
1883   HOWTO2 (R_NDS32_LONGCALL6,    /* type  */
1884          0,                     /* rightshift  */
1885          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1886          32,                    /* bitsize  */
1887          FALSE,                 /* pc_relative  */
1888          0,                     /* bitpos  */
1889          complain_overflow_dont,/* complain_on_overflow  */
1890          nds32_elf_ignore_reloc,/* special_function  */
1891          "R_NDS32_LONGCALL6",   /* name  */
1892          FALSE,                 /* partial_inplace  */
1893          0xffffffff,            /* src_mask  */
1894          0xffffffff,            /* dst_mask  */
1895          FALSE),                /* pcrel_offset  */
1896
1897   /* Relax hint for unconditional branch sequence.  */
1898   HOWTO2 (R_NDS32_LONGJUMP4,    /* type  */
1899          0,                     /* rightshift  */
1900          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1901          32,                    /* bitsize  */
1902          FALSE,                 /* pc_relative  */
1903          0,                     /* bitpos  */
1904          complain_overflow_dont,/* complain_on_overflow  */
1905          nds32_elf_ignore_reloc,/* special_function  */
1906          "R_NDS32_LONGJUMP4",   /* name  */
1907          FALSE,                 /* partial_inplace  */
1908          0xffffffff,            /* src_mask  */
1909          0xffffffff,            /* dst_mask  */
1910          FALSE),                /* pcrel_offset  */
1911
1912   /* Relax hint for conditional branch sequence.  */
1913   HOWTO2 (R_NDS32_LONGJUMP5,    /* type  */
1914          0,                     /* rightshift  */
1915          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1916          32,                    /* bitsize  */
1917          FALSE,                 /* pc_relative  */
1918          0,                     /* bitpos  */
1919          complain_overflow_dont,/* complain_on_overflow  */
1920          nds32_elf_ignore_reloc,/* special_function  */
1921          "R_NDS32_LONGJUMP5",   /* name  */
1922          FALSE,                 /* partial_inplace  */
1923          0xffffffff,            /* src_mask  */
1924          0xffffffff,            /* dst_mask  */
1925          FALSE),                /* pcrel_offset  */
1926
1927   /* Relax hint for conditional branch sequence.  */
1928   HOWTO2 (R_NDS32_LONGJUMP6,    /* type  */
1929          0,                     /* rightshift  */
1930          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1931          32,                    /* bitsize  */
1932          FALSE,                 /* pc_relative  */
1933          0,                     /* bitpos  */
1934          complain_overflow_dont,/* complain_on_overflow  */
1935          nds32_elf_ignore_reloc,/* special_function  */
1936          "R_NDS32_LONGJUMP6",   /* name  */
1937          FALSE,                 /* partial_inplace  */
1938          0xffffffff,            /* src_mask  */
1939          0xffffffff,            /* dst_mask  */
1940          FALSE),                /* pcrel_offset  */
1941
1942   /* Relax hint for conditional branch sequence.  */
1943   HOWTO2 (R_NDS32_LONGJUMP7,    /* type  */
1944          0,                     /* rightshift  */
1945          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1946          32,                    /* bitsize  */
1947          FALSE,                 /* pc_relative  */
1948          0,                     /* bitpos  */
1949          complain_overflow_dont,/* complain_on_overflow  */
1950          nds32_elf_ignore_reloc,/* special_function  */
1951          "R_NDS32_LONGJUMP7",   /* name  */
1952          FALSE,                 /* partial_inplace  */
1953          0xffffffff,            /* src_mask  */
1954          0xffffffff,            /* dst_mask  */
1955          FALSE),                /* pcrel_offset  */
1956
1957   HOWTO2 (R_NDS32_TLS_IE_LO12,  /* type  */
1958          0,                     /* rightshift  */
1959          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1960          12,                    /* bitsize  */
1961          FALSE,                 /* pc_relative  */
1962          0,                     /* bitpos  */
1963          complain_overflow_dont,/* complain_on_overflow  */
1964          bfd_elf_generic_reloc, /* special_function  */
1965          "R_NDS32_TLS_IE_LO12", /* name  */
1966          FALSE,                 /* partial_inplace  */
1967          0x00000fff,            /* src_mask  */
1968          0x00000fff,            /* dst_mask  */
1969          FALSE),                /* pcrel_offset  */
1970
1971   /* Like R_NDS32_HI20, but referring to the TLS IE (PIE)
1972      entry for the symbol.  */
1973   HOWTO2 (R_NDS32_TLS_IEGP_HI20,/* type  */
1974          12,                    /* rightshift  */
1975          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1976          20,                    /* bitsize  */
1977          FALSE,                 /* pc_relative  */
1978          0,                     /* bitpos  */
1979          complain_overflow_dont,/* complain_on_overflow  */
1980          bfd_elf_generic_reloc, /* special_function  */
1981          "R_NDS32_TLS_IEGP_HI20",/* name  */
1982          FALSE,                 /* partial_inplace  */
1983          0x000fffff,            /* src_mask  */
1984          0x000fffff,            /* dst_mask  */
1985          FALSE),                /* pcrel_offset  */
1986
1987   HOWTO2 (R_NDS32_TLS_IEGP_LO12,/* type  */
1988          0,                     /* rightshift  */
1989          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
1990          12,                    /* bitsize  */
1991          FALSE,                 /* pc_relative  */
1992          0,                     /* bitpos  */
1993          complain_overflow_dont,/* complain_on_overflow  */
1994          bfd_elf_generic_reloc, /* special_function  */
1995          "R_NDS32_TLS_IEGP_LO12",/* name  */
1996          FALSE,                 /* partial_inplace  */
1997          0x00000fff,            /* src_mask  */
1998          0x00000fff,            /* dst_mask  */
1999          FALSE),                /* pcrel_offset  */
2000
2001   HOWTO2 (R_NDS32_TLS_IEGP_LO12S2,/* type  */
2002          2,                     /* rightshift  */
2003          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2004          10,                    /* bitsize  */
2005          FALSE,                 /* pc_relative  */
2006          0,                     /* bitpos  */
2007          complain_overflow_dont,/* complain_on_overflow  */
2008          bfd_elf_generic_reloc, /* special_function  */
2009          "R_NDS32_TLS_IEGP_LO12S2",/* name  */
2010          FALSE,                 /* partial_inplace  */
2011          0x000003ff,            /* src_mask  */
2012          0x000003ff,            /* dst_mask  */
2013          FALSE),                /* pcrel_offset  */
2014
2015   /* TLS description relocation  */
2016   HOWTO2 (R_NDS32_TLS_DESC,     /* type  */
2017          12,                    /* rightshift  */
2018          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2019          20,                    /* bitsize  */
2020          FALSE,                 /* pc_relative  */
2021          0,                     /* bitpos  */
2022          complain_overflow_dont,/* complain_on_overflow  */
2023          nds32_elf_hi20_reloc,  /* special_function  */
2024          "R_NDS32_TLS_DESC_HI20",/* name  */
2025          FALSE,                 /* partial_inplace  */
2026          0x000fffff,            /* src_mask  */
2027          0x000fffff,            /* dst_mask  */
2028          FALSE),                /* pcrel_offset  */
2029
2030   /* TLS GD/LD description offset high part.  */
2031   HOWTO2 (R_NDS32_TLS_DESC_HI20,/* type  */
2032          12,                    /* rightshift  */
2033          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2034          20,                    /* bitsize  */
2035          FALSE,                 /* pc_relative  */
2036          0,                     /* bitpos  */
2037          complain_overflow_dont,/* complain_on_overflow  */
2038          nds32_elf_hi20_reloc,  /* special_function  */
2039          "R_NDS32_TLS_DESC_HI20",/* name  */
2040          FALSE,                 /* partial_inplace  */
2041          0x000fffff,            /* src_mask  */
2042          0x000fffff,            /* dst_mask  */
2043          FALSE),                /* pcrel_offset  */
2044
2045   /* TLS GD/LD description offset low part.  */
2046   HOWTO2 (R_NDS32_TLS_DESC_LO12,/* type  */
2047          0,                     /* rightshift  */
2048          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2049          12,                    /* bitsize  */
2050          FALSE,                 /* pc_relative  */
2051          0,                     /* bitpos  */
2052          complain_overflow_dont,/* complain_on_overflow  */
2053          nds32_elf_lo12_reloc,  /* special_function  */
2054          "R_NDS32_TLS_DESC_LO12",/* name  */
2055          FALSE,                 /* partial_inplace  */
2056          0x00000fff,            /* src_mask  */
2057          0x00000fff,            /* dst_mask  */
2058          FALSE),                /* pcrel_offset  */
2059
2060   /* TLS GD/LD description offset set (movi).  */
2061   HOWTO2 (R_NDS32_TLS_DESC_20,  /* type  */
2062          0,                     /* rightshift  */
2063          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2064          20,                    /* bitsize  */
2065          FALSE,                 /* pc_relative  */
2066          0,                     /* bitpos  */
2067          complain_overflow_signed,/* complain_on_overflow  */
2068          bfd_elf_generic_reloc, /* special_function  */
2069          "R_NDS32_TLS_DESC_20", /* name  */
2070          FALSE,                 /* partial_inplace  */
2071          0x000fffff,            /* src_mask  */
2072          0x000fffff,            /* dst_mask  */
2073          FALSE),                /* pcrel_offset  */
2074
2075   /* TLS GD/LD description offset set (lwi.gp).  */
2076   HOWTO2 (R_NDS32_TLS_DESC_SDA17S2,/* type  */
2077          2,                     /* rightshift  */
2078          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2079          17,                    /* bitsize  */
2080          FALSE,                 /* pc_relative  */
2081          0,                     /* bitpos  */
2082          complain_overflow_signed,/* complain_on_overflow  */
2083          bfd_elf_generic_reloc, /* special_function  */
2084          "R_NDS32_TLS_DESC_SDA17S2",/* name  */
2085          FALSE,                 /* partial_inplace  */
2086          0x0001ffff,            /* src_mask  */
2087          0x0001ffff,            /* dst_mask  */
2088          FALSE),                /* pcrel_offset  */
2089 };
2090
2091 /* Relocations used for relaxation.  */
2092 #define HOWTO3(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
2093   [C-R_NDS32_RELAX_ENTRY] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
2094
2095 static reloc_howto_type nds32_elf_relax_howto_table[] = {
2096   HOWTO3 (R_NDS32_RELAX_ENTRY,  /* type  */
2097          0,                     /* rightshift  */
2098          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2099          32,                    /* bitsize  */
2100          FALSE,                 /* pc_relative  */
2101          0,                     /* bitpos  */
2102          complain_overflow_dont,/* complain_on_overflow  */
2103          nds32_elf_ignore_reloc,/* special_function  */
2104          "R_NDS32_RELAX_ENTRY", /* name  */
2105          FALSE,                 /* partial_inplace  */
2106          0xffffffff,            /* src_mask  */
2107          0xffffffff,            /* dst_mask  */
2108          FALSE),                /* pcrel_offset  */
2109   HOWTO3 (R_NDS32_GOT_SUFF,     /* type  */
2110          0,                     /* rightshift  */
2111          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2112          32,                    /* bitsize  */
2113          FALSE,                 /* pc_relative  */
2114          0,                     /* bitpos  */
2115          complain_overflow_dont,/* complain_on_overflow  */
2116          nds32_elf_ignore_reloc,/* special_function  */
2117          "R_NDS32_GOT_SUFF",    /* name  */
2118          FALSE,                 /* partial_inplace  */
2119          0xffffffff,            /* src_mask  */
2120          0xffffffff,            /* dst_mask  */
2121          FALSE),                /* pcrel_offset  */
2122   HOWTO3 (R_NDS32_GOTOFF_SUFF,  /* type  */
2123          0,                     /* rightshift  */
2124          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2125          32,                    /* bitsize  */
2126          FALSE,                 /* pc_relative  */
2127          0,                     /* bitpos  */
2128          complain_overflow_bitfield,/* complain_on_overflow  */
2129          nds32_elf_ignore_reloc,/* special_function  */
2130          "R_NDS32_GOTOFF_SUFF", /* name  */
2131          FALSE,                 /* partial_inplace  */
2132          0xffffffff,            /* src_mask  */
2133          0xffffffff,            /* dst_mask  */
2134          FALSE),                /* pcrel_offset  */
2135   HOWTO3 (R_NDS32_PLT_GOT_SUFF, /* type  */
2136          0,                     /* rightshift  */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2138          32,                    /* bitsize  */
2139          FALSE,                 /* pc_relative  */
2140          0,                     /* bitpos  */
2141          complain_overflow_dont,/* complain_on_overflow  */
2142          nds32_elf_ignore_reloc,/* special_function  */
2143          "R_NDS32_PLT_GOT_SUFF",/* name  */
2144          FALSE,                 /* partial_inplace  */
2145          0xffffffff,            /* src_mask  */
2146          0xffffffff,            /* dst_mask  */
2147          FALSE),                /* pcrel_offset  */
2148   HOWTO3 (R_NDS32_MULCALL_SUFF, /* type  */
2149          0,                     /* rightshift  */
2150          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2151          32,                    /* bitsize  */
2152          FALSE,                 /* pc_relative  */
2153          0,                     /* bitpos  */
2154          complain_overflow_dont,/* complain_on_overflow  */
2155          nds32_elf_ignore_reloc,/* special_function  */
2156          "R_NDS32_MULCALL_SUFF",/* name  */
2157          FALSE,                 /* partial_inplace  */
2158          0xffffffff,            /* src_mask  */
2159          0xffffffff,            /* dst_mask  */
2160          FALSE),                /* pcrel_offset  */
2161   HOWTO3 (R_NDS32_PTR,          /* type  */
2162          0,                     /* rightshift  */
2163          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2164          32,                    /* bitsize  */
2165          FALSE,                 /* pc_relative  */
2166          0,                     /* bitpos  */
2167          complain_overflow_dont,/* complain_on_overflow  */
2168          nds32_elf_ignore_reloc,/* special_function  */
2169          "R_NDS32_PTR",         /* name  */
2170          FALSE,                 /* partial_inplace  */
2171          0xffffffff,            /* src_mask  */
2172          0xffffffff,            /* dst_mask  */
2173          FALSE),                /* pcrel_offset  */
2174   HOWTO3 (R_NDS32_PTR_COUNT,    /* type  */
2175          0,                     /* rightshift  */
2176          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2177          32,                    /* bitsize  */
2178          FALSE,                 /* pc_relative  */
2179          0,                     /* bitpos  */
2180          complain_overflow_dont,/* complain_on_overflow  */
2181          nds32_elf_ignore_reloc,/* special_function  */
2182          "R_NDS32_PTR_COUNT",   /* name  */
2183          FALSE,                 /* partial_inplace  */
2184          0xffffffff,            /* src_mask  */
2185          0xffffffff,            /* dst_mask  */
2186          FALSE),                /* pcrel_offset  */
2187   HOWTO3 (R_NDS32_PTR_RESOLVED, /* type  */
2188          0,                     /* rightshift  */
2189          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2190          32,                    /* bitsize  */
2191          FALSE,                 /* pc_relative  */
2192          0,                     /* bitpos  */
2193          complain_overflow_dont,/* complain_on_overflow  */
2194          nds32_elf_ignore_reloc,/* special_function  */
2195          "R_NDS32_PTR_RESOLVED",/* name  */
2196          FALSE,                 /* partial_inplace  */
2197          0xffffffff,            /* src_mask  */
2198          0xffffffff,            /* dst_mask  */
2199          FALSE),                /* pcrel_offset  */
2200   HOWTO3 (R_NDS32_PLTBLOCK,     /* type  */
2201          0,                     /* rightshift  */
2202          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2203          32,                    /* bitsize  */
2204          FALSE,                 /* pc_relative  */
2205          0,                     /* bitpos  */
2206          complain_overflow_dont,/* complain_on_overflow  */
2207          nds32_elf_ignore_reloc,/* special_function  */
2208          "R_NDS32_PLTBLOCK",    /* name  */
2209          FALSE,                 /* partial_inplace  */
2210          0xffffffff,            /* src_mask  */
2211          0xffffffff,            /* dst_mask  */
2212          FALSE),                /* pcrel_offset  */
2213   HOWTO3 (R_NDS32_RELAX_REGION_BEGIN,/* type  */
2214          0,                     /* rightshift  */
2215          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2216          32,                    /* bitsize  */
2217          FALSE,                 /* pc_relative  */
2218          0,                     /* bitpos  */
2219          complain_overflow_dont,/* complain_on_overflow  */
2220          nds32_elf_ignore_reloc,/* special_function  */
2221          "R_NDS32_RELAX_REGION_BEGIN",/* name  */
2222          FALSE,                 /* partial_inplace  */
2223          0xffffffff,            /* src_mask  */
2224          0xffffffff,            /* dst_mask  */
2225          FALSE),                /* pcrel_offset  */
2226   HOWTO3 (R_NDS32_RELAX_REGION_END,/* type  */
2227          0,                     /* rightshift  */
2228          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2229          32,                    /* bitsize  */
2230          FALSE,                 /* pc_relative  */
2231          0,                     /* bitpos  */
2232          complain_overflow_dont,/* complain_on_overflow  */
2233          nds32_elf_ignore_reloc,/* special_function  */
2234          "R_NDS32_RELAX_REGION_END",/* name  */
2235          FALSE,                 /* partial_inplace  */
2236          0xffffffff,            /* src_mask  */
2237          0xffffffff,            /* dst_mask  */
2238          FALSE),                /* pcrel_offset  */
2239   HOWTO3 (R_NDS32_MINUEND,      /* type  */
2240          0,                     /* rightshift  */
2241          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2242          32,                    /* bitsize  */
2243          FALSE,                 /* pc_relative  */
2244          0,                     /* bitpos  */
2245          complain_overflow_dont,/* complain_on_overflow  */
2246          nds32_elf_ignore_reloc,/* special_function  */
2247          "R_NDS32_MINUEND",     /* name  */
2248          FALSE,                 /* partial_inplace  */
2249          0xffffffff,            /* src_mask  */
2250          0xffffffff,            /* dst_mask  */
2251          FALSE),                /* pcrel_offset  */
2252   HOWTO3 (R_NDS32_SUBTRAHEND,   /* type  */
2253          0,                     /* rightshift  */
2254          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2255          32,                    /* bitsize  */
2256          FALSE,                 /* pc_relative  */
2257          0,                     /* bitpos  */
2258          complain_overflow_dont,/* complain_on_overflow  */
2259          nds32_elf_ignore_reloc,/* special_function  */
2260          "R_NDS32_SUBTRAHEND",  /* name  */
2261          FALSE,                 /* partial_inplace  */
2262          0xffffffff,            /* src_mask  */
2263          0xffffffff,            /* dst_mask  */
2264          FALSE),                /* pcrel_offset  */
2265   HOWTO3 (R_NDS32_DIFF8,        /* type  */
2266          0,                     /* rightshift  */
2267          0,                     /* size (0 = byte, 1 = short, 2 = long)  */
2268          8,                     /* bitsize  */
2269          FALSE,                 /* pc_relative  */
2270          0,                     /* bitpos  */
2271          complain_overflow_dont,/* complain_on_overflow  */
2272          nds32_elf_ignore_reloc,/* special_function  */
2273          "R_NDS32_DIFF8",       /* name  */
2274          FALSE,                 /* partial_inplace  */
2275          0x000000ff,            /* src_mask  */
2276          0x000000ff,            /* dst_mask  */
2277          FALSE),                /* pcrel_offset  */
2278   HOWTO3 (R_NDS32_DIFF16,       /* type  */
2279          0,                     /* rightshift  */
2280          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
2281          16,                    /* bitsize  */
2282          FALSE,                 /* pc_relative  */
2283          0,                     /* bitpos  */
2284          complain_overflow_dont,/* complain_on_overflow  */
2285          nds32_elf_ignore_reloc,/* special_function  */
2286          "R_NDS32_DIFF16",      /* name  */
2287          FALSE,                 /* partial_inplace  */
2288          0x0000ffff,            /* src_mask  */
2289          0x0000ffff,            /* dst_mask  */
2290          FALSE),                /* pcrel_offset  */
2291   HOWTO3 (R_NDS32_DIFF32,       /* type  */
2292          0,                     /* rightshift  */
2293          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2294          32,                    /* bitsize  */
2295          FALSE,                 /* pc_relative  */
2296          0,                     /* bitpos  */
2297          complain_overflow_dont,/* complain_on_overflow  */
2298          nds32_elf_ignore_reloc,/* special_function  */
2299          "R_NDS32_DIFF32",      /* name  */
2300          FALSE,                 /* partial_inplace  */
2301          0xffffffff,            /* src_mask  */
2302          0xffffffff,            /* dst_mask  */
2303          FALSE),                /* pcrel_offset  */
2304   HOWTO3 (R_NDS32_DIFF_ULEB128, /* type  */
2305          0,                     /* rightshift  */
2306          0,                     /* size (0 = byte, 1 = short, 2 = long)  */
2307          0,                     /* bitsize  */
2308          FALSE,                 /* pc_relative  */
2309          0,                     /* bitpos  */
2310          complain_overflow_dont,/* complain_on_overflow  */
2311          nds32_elf_ignore_reloc,/* special_function  */
2312          "R_NDS32_DIFF_ULEB128",/* name  */
2313          FALSE,                 /* partial_inplace  */
2314          0xffffffff,            /* src_mask  */
2315          0xffffffff,            /* dst_mask  */
2316          FALSE),                /* pcrel_offset  */
2317   HOWTO3 (R_NDS32_DATA,         /* type  */
2318          0,                     /* rightshift  */
2319          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2320          32,                    /* bitsize  */
2321          FALSE,                 /* pc_relative  */
2322          0,                     /* bitpos  */
2323          complain_overflow_dont,/* complain_on_overflow  */
2324          nds32_elf_ignore_reloc,/* special_function  */
2325          "R_NDS32_DATA",        /* name  */
2326          FALSE,                 /* partial_inplace  */
2327          0xffffffff,            /* src_mask  */
2328          0xffffffff,            /* dst_mask  */
2329          FALSE),                /* pcrel_offset  */
2330   HOWTO3 (R_NDS32_TRAN,         /* type  */
2331          0,                     /* rightshift  */
2332          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2333          32,                    /* bitsize  */
2334          FALSE,                 /* pc_relative  */
2335          0,                     /* bitpos  */
2336          complain_overflow_dont,/* complain_on_overflow  */
2337          nds32_elf_ignore_reloc,/* special_function  */
2338          "R_NDS32_TRAN",        /* name  */
2339          FALSE,                 /* partial_inplace  */
2340          0xffffffff,            /* src_mask  */
2341          0xffffffff,            /* dst_mask  */
2342          FALSE),                /* pcrel_offset  */
2343   HOWTO3 (R_NDS32_TLS_LE_ADD,   /* type  */
2344          0,                     /* rightshift  */
2345          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2346          32,                    /* bitsize  */
2347          FALSE,                 /* pc_relative  */
2348          0,                     /* bitpos  */
2349          complain_overflow_dont,/* complain_on_overflow  */
2350          nds32_elf_ignore_reloc,/* special_function  */
2351          "R_NDS32_TLS_LE_ADD",  /* name  */
2352          FALSE,                 /* partial_inplace  */
2353          0xffffffff,            /* src_mask  */
2354          0xffffffff,            /* dst_mask  */
2355          FALSE),                /* pcrel_offset  */
2356   HOWTO3 (R_NDS32_TLS_LE_LS,    /* type  */
2357          0,                     /* rightshift  */
2358          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2359          32,                    /* bitsize  */
2360          FALSE,                 /* pc_relative  */
2361          0,                     /* bitpos  */
2362          complain_overflow_dont,/* complain_on_overflow  */
2363          nds32_elf_ignore_reloc,/* special_function  */
2364          "R_NDS32_TLS_LE_LS",   /* name  */
2365          FALSE,                 /* partial_inplace  */
2366          0xffffffff,            /* src_mask  */
2367          0xffffffff,            /* dst_mask  */
2368          FALSE),                /* pcrel_offset  */
2369   HOWTO3 (R_NDS32_EMPTY,        /* type  */
2370          0,                     /* rightshift  */
2371          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2372          32,                    /* bitsize  */
2373          FALSE,                 /* pc_relative  */
2374          0,                     /* bitpos  */
2375          complain_overflow_dont,/* complain_on_overflow  */
2376          nds32_elf_ignore_reloc,/* special_function  */
2377          "R_NDS32_EMPTY",       /* name  */
2378          FALSE,                 /* partial_inplace  */
2379          0xffffffff,            /* src_mask  */
2380          0xffffffff,            /* dst_mask  */
2381          FALSE),                /* pcrel_offset  */
2382   /* TLS GD/LD description address base addition.  */
2383   HOWTO3 (R_NDS32_TLS_DESC_ADD, /* type  */
2384          0,                     /* rightshift  */
2385          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2386          32,                    /* bitsize  */
2387          FALSE,                 /* pc_relative  */
2388          0,                     /* bitpos  */
2389          complain_overflow_dont,/* complain_on_overflow  */
2390          nds32_elf_ignore_reloc,/* special_function  */
2391          "R_NDS32_TLS_DESC_ADD",/* name  */
2392          FALSE,                 /* partial_inplace  */
2393          0xffffffff,            /* src_mask  */
2394          0xffffffff,            /* dst_mask  */
2395          FALSE),                /* pcrel_offset  */
2396   /* TLS GD/LD description function load.  */
2397   HOWTO3 (R_NDS32_TLS_DESC_FUNC,/* type  */
2398          0,                     /* rightshift  */
2399          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2400          32,                    /* bitsize  */
2401          FALSE,                 /* pc_relative  */
2402          0,                     /* bitpos  */
2403          complain_overflow_dont,/* complain_on_overflow  */
2404          nds32_elf_ignore_reloc,/* special_function  */
2405          "R_NDS32_TLS_DESC_FUNC",/* name  */
2406          FALSE,                 /* partial_inplace  */
2407          0xffffffff,            /* src_mask  */
2408          0xffffffff,            /* dst_mask  */
2409          FALSE),                /* pcrel_offset  */
2410   /* TLS DESC resolve function call.  */
2411   HOWTO3 (R_NDS32_TLS_DESC_CALL,/* type  */
2412          0,                     /* rightshift  */
2413          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2414          32,                    /* bitsize  */
2415          FALSE,                 /* pc_relative  */
2416          0,                     /* bitpos  */
2417          complain_overflow_dont,/* complain_on_overflow  */
2418          nds32_elf_ignore_reloc,/* special_function  */
2419          "R_NDS32_TLS_DESC_CALL",/* name  */
2420          FALSE,                 /* partial_inplace  */
2421          0xffffffff,            /* src_mask  */
2422          0xffffffff,            /* dst_mask  */
2423          FALSE),                /* pcrel_offset  */
2424   /* TLS DESC variable access.  */
2425   HOWTO3 (R_NDS32_TLS_DESC_MEM, /* type  */
2426          0,                     /* rightshift  */
2427          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2428          32,                    /* bitsize  */
2429          FALSE,                 /* pc_relative  */
2430          0,                     /* bitpos  */
2431          complain_overflow_dont,/* complain_on_overflow  */
2432          nds32_elf_ignore_reloc,/* special_function  */
2433          "R_NDS32_TLS_DESC_MEM",/* name  */
2434          FALSE,                 /* partial_inplace  */
2435          0xffffffff,            /* src_mask  */
2436          0xffffffff,            /* dst_mask  */
2437          FALSE),                /* pcrel_offset  */
2438   /* TLS GD/LD description mark (@tlsdec).  */
2439   HOWTO3 (R_NDS32_RELAX_REMOVE, /* type  */
2440          0,                     /* rightshift  */
2441          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2442          32,                    /* bitsize  */
2443          FALSE,                 /* pc_relative  */
2444          0,                     /* bitpos  */
2445          complain_overflow_dont,/* complain_on_overflow  */
2446          nds32_elf_ignore_reloc,/* special_function  */
2447          "R_NDS32_REMOVE",      /* name  */
2448          FALSE,                 /* partial_inplace  */
2449          0xffffffff,            /* src_mask  */
2450          0xffffffff,            /* dst_mask  */
2451          FALSE),                /* pcrel_offset  */
2452   /* TLS GD/LD description mark (@tlsdec).  */
2453   HOWTO3 (R_NDS32_RELAX_GROUP,  /* type  */
2454          0,                     /* rightshift  */
2455          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2456          32,                    /* bitsize  */
2457          FALSE,                 /* pc_relative  */
2458          0,                     /* bitpos  */
2459          complain_overflow_dont,/* complain_on_overflow  */
2460          nds32_elf_ignore_reloc,/* special_function  */
2461          "R_NDS32_GROUP",       /* name  */
2462          FALSE,                 /* partial_inplace  */
2463          0xffffffff,            /* src_mask  */
2464          0xffffffff,            /* dst_mask  */
2465          FALSE),                /* pcrel_offset  */
2466   HOWTO3 (R_NDS32_TLS_IEGP_LW,  /* type  */
2467          0,                     /* rightshift  */
2468          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2469          32,                    /* bitsize  */
2470          FALSE,                 /* pc_relative  */
2471          0,                     /* bitpos  */
2472          complain_overflow_dont,/* complain_on_overflow  */
2473          nds32_elf_ignore_reloc,/* special_function  */
2474          "R_NDS32_TLS_IEGP_LW", /* name  */
2475          FALSE,                 /* partial_inplace  */
2476          0xffffffff,            /* src_mask  */
2477          0xffffffff,            /* dst_mask  */
2478          FALSE),                /* pcrel_offset  */
2479   /* LA and FLSI relaxation.  */
2480   HOWTO3 (R_NDS32_LSI,          /* type  */
2481          0,                     /* rightshift  */
2482          2,                     /* size (0 = byte, 1 = short, 2 = long)  */
2483          32,                    /* bitsize  */
2484          FALSE,                 /* pc_relative  */
2485          0,                     /* bitpos  */
2486          complain_overflow_dont,/* complain_on_overflow  */
2487          nds32_elf_ignore_reloc,/* special_function  */
2488          "R_NDS32_LSI",         /* name  */
2489          FALSE,                 /* partial_inplace  */
2490          0xffffffff,            /* src_mask  */
2491          0xffffffff,            /* dst_mask  */
2492          FALSE),
2493 };
2494
2495 static unsigned long dl_tlsdesc_lazy_trampoline[] =
2496 {
2497   0x46200000,                   /* sethi $r2,#0x0      */
2498   0x58210000,                   /* ori $r2,$r2,#0x0    */
2499   0x40217400,                   /* add $r2,$r2,$gp     */
2500   0x04210000,                   /* lwi $r2,[$r2+#0x0]  */
2501   0x46300000,                   /* sethi $r3,#0x0      */
2502   0x58318000,                   /* ori $r3,$r3,#0x0    */
2503   0x4031f400,                   /* add $r3,$r3,$gp     */
2504   0x4a000800,                   /* jr $r2              */
2505 };
2506
2507 static void
2508 nds32_put_trampoline (void *contents, const unsigned long *template,
2509                       unsigned count)
2510 {
2511   unsigned ix;
2512
2513   for (ix = 0; ix != count; ix++)
2514     {
2515       unsigned long insn = template[ix];
2516       bfd_putb32 (insn, (char *) contents + ix * 4);
2517     }
2518 }
2519
2520 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2521    This prototype is the same as qsort ().  */
2522
2523 void
2524 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2525                       int (*compar) (const void *lhs, const void *rhs))
2526 {
2527   char *ptr = (char *) base;
2528   int i, j;
2529   char *tmp = xmalloc (size);
2530
2531   /* If i is less than j, i is inserted before j.
2532
2533      |---- j ----- i --------------|
2534       \          / \              /
2535          sorted         unsorted
2536    */
2537
2538   for (i = 1; i < (int) nmemb; i++)
2539     {
2540       for (j = (i - 1); j >= 0; j--)
2541         if (compar (ptr + i * size, ptr + j * size) >= 0)
2542           break;
2543
2544       j++;
2545
2546       if (i == j)
2547         continue; /* i is in order.  */
2548
2549       memcpy (tmp, ptr + i * size, size);
2550       memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2551       memcpy (ptr + j * size, tmp, size);
2552     }
2553   free (tmp);
2554 }
2555
2556 /* Sort relocation by r_offset.
2557
2558    We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2559    algorithm.  Relocations at the same r_offset must keep their order.
2560    For example, RELAX_ENTRY must be the very first relocation entry.
2561
2562    Currently, this function implements insertion-sort.
2563
2564    FIXME: If we already sort them in assembler, why bother sort them
2565           here again?  */
2566
2567 static int
2568 compar_reloc (const void *lhs, const void *rhs)
2569 {
2570   const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2571   const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2572
2573   if (l->r_offset > r->r_offset)
2574     return 1;
2575   else if (l->r_offset == r->r_offset)
2576     return 0;
2577   else
2578     return -1;
2579 }
2580
2581 /* Functions listed below are only used for old relocs.
2582      nds32_elf_9_pcrel_reloc
2583      nds32_elf_do_9_pcrel_reloc
2584      nds32_elf_hi20_reloc
2585      nds32_elf_relocate_hi20
2586      nds32_elf_lo12_reloc
2587      nds32_elf_sda15_reloc
2588      nds32_elf_generic_reloc.  */
2589
2590 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc.  */
2591
2592 static bfd_reloc_status_type
2593 nds32_elf_9_pcrel_reloc (bfd *       abfd,
2594                          arelent *   reloc_entry,
2595                          asymbol *   symbol,
2596                          void *      data,
2597                          asection *  input_section,
2598                          bfd *       output_bfd,
2599                          char **     error_message ATTRIBUTE_UNUSED)
2600 {
2601   /* This part is from bfd_elf_generic_reloc.  */
2602   if (output_bfd != (bfd *) NULL
2603       && (symbol->flags & BSF_SECTION_SYM) == 0
2604       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2605     {
2606       reloc_entry->address += input_section->output_offset;
2607       return bfd_reloc_ok;
2608     }
2609
2610   if (output_bfd != NULL)
2611     {
2612       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2613       return bfd_reloc_continue;
2614     }
2615
2616   return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2617                                      input_section,
2618                                      data, reloc_entry->address,
2619                                      symbol->section,
2620                                      (symbol->value
2621                                       + symbol->section->output_section->vma
2622                                       + symbol->section->output_offset),
2623                                      reloc_entry->addend);
2624 }
2625
2626 /* Utility to actually perform an R_NDS32_9_PCREL reloc.  */
2627 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2628
2629 static bfd_reloc_status_type
2630 nds32_elf_do_9_pcrel_reloc (bfd *               abfd,
2631                             reloc_howto_type *  howto,
2632                             asection *          input_section,
2633                             bfd_byte *          data,
2634                             bfd_vma             offset,
2635                             asection *          symbol_section ATTRIBUTE_UNUSED,
2636                             bfd_vma             symbol_value,
2637                             bfd_vma             addend)
2638 {
2639   bfd_signed_vma relocation;
2640   unsigned short x;
2641   bfd_reloc_status_type status;
2642
2643   /* Sanity check the address (offset in section).  */
2644   if (offset > bfd_get_section_limit (abfd, input_section))
2645     return bfd_reloc_outofrange;
2646
2647   relocation = symbol_value + addend;
2648   /* Make it pc relative.  */
2649   relocation -= (input_section->output_section->vma
2650                  + input_section->output_offset);
2651   /* These jumps mask off the lower two bits of the current address
2652      before doing pcrel calculations.  */
2653   relocation -= (offset & -(bfd_vma) 2);
2654
2655   if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2656     status = bfd_reloc_overflow;
2657   else
2658     status = bfd_reloc_ok;
2659
2660   x = bfd_getb16 (data + offset);
2661
2662   relocation >>= howto->rightshift;
2663   relocation <<= howto->bitpos;
2664   x = (x & ~howto->dst_mask)
2665       | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2666
2667   bfd_putb16 ((bfd_vma) x, data + offset);
2668
2669   return status;
2670 }
2671
2672 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2673    HI20_SLO is for the add3 and load/store with displacement instructions.
2674    HI20 is for the or3 instruction.
2675    For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2676    the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2677    we must add one to the high 16 bytes (which will get subtracted off when
2678    the low 16 bits are added).
2679    These relocs have to be done in combination with an R_NDS32_LO12 reloc
2680    because there is a carry from the LO12 to the HI20.  Here we just save
2681    the information we need; we do the actual relocation when we see the LO12.
2682    This code is copied from the elf32-mips.c.  We also support an arbitrary
2683    number of HI20 relocs to be associated with a single LO12 reloc.  The
2684    assembler sorts the relocs to ensure each HI20 immediately precedes its
2685    LO12.  However if there are multiple copies, the assembler may not find
2686    the real LO12 so it picks the first one it finds.  */
2687
2688 struct nds32_hi20
2689 {
2690   struct nds32_hi20 *next;
2691   bfd_byte *addr;
2692   bfd_vma addend;
2693 };
2694
2695 static struct nds32_hi20 *nds32_hi20_list;
2696
2697 static bfd_reloc_status_type
2698 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED,
2699                       arelent *reloc_entry,
2700                       asymbol *symbol,
2701                       void *data,
2702                       asection *input_section,
2703                       bfd *output_bfd,
2704                       char **error_message ATTRIBUTE_UNUSED)
2705 {
2706   bfd_reloc_status_type ret;
2707   bfd_vma relocation;
2708   struct nds32_hi20 *n;
2709
2710   /* This part is from bfd_elf_generic_reloc.
2711      If we're relocating, and this an external symbol, we don't want
2712      to change anything.  */
2713   if (output_bfd != (bfd *) NULL
2714       && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2715     {
2716       reloc_entry->address += input_section->output_offset;
2717       return bfd_reloc_ok;
2718     }
2719
2720   /* Sanity check the address (offset in section).  */
2721   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2722     return bfd_reloc_outofrange;
2723
2724   ret = bfd_reloc_ok;
2725   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2726     ret = bfd_reloc_undefined;
2727
2728   if (bfd_is_com_section (symbol->section))
2729     relocation = 0;
2730   else
2731     relocation = symbol->value;
2732
2733   relocation += symbol->section->output_section->vma;
2734   relocation += symbol->section->output_offset;
2735   relocation += reloc_entry->addend;
2736
2737   /* Save the information, and let LO12 do the actual relocation.  */
2738   n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2739   if (n == NULL)
2740     return bfd_reloc_outofrange;
2741
2742   n->addr = (bfd_byte *) data + reloc_entry->address;
2743   n->addend = relocation;
2744   n->next = nds32_hi20_list;
2745   nds32_hi20_list = n;
2746
2747   if (output_bfd != (bfd *) NULL)
2748     reloc_entry->address += input_section->output_offset;
2749
2750   return ret;
2751 }
2752
2753 /* Handle an NDS32 ELF HI20 reloc.  */
2754
2755 static void
2756 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2757                          int type ATTRIBUTE_UNUSED,
2758                          Elf_Internal_Rela *relhi,
2759                          Elf_Internal_Rela *rello,
2760                          bfd_byte *contents,
2761                          bfd_vma addend)
2762 {
2763   unsigned long insn;
2764   bfd_vma addlo;
2765
2766   insn = bfd_getb32 (contents + relhi->r_offset);
2767
2768   addlo = bfd_getb32 (contents + rello->r_offset);
2769   addlo &= 0xfff;
2770
2771   addend += ((insn & 0xfffff) << 20) + addlo;
2772
2773   insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2774   bfd_putb32 (insn, contents + relhi->r_offset);
2775 }
2776
2777 /* Do an R_NDS32_LO12 relocation.  This is a straightforward 12 bit
2778    inplace relocation; this function exists in order to do the
2779    R_NDS32_HI20_[SU]LO relocation described above.  */
2780
2781 static bfd_reloc_status_type
2782 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2783                       void *data, asection *input_section, bfd *output_bfd,
2784                       char **error_message)
2785 {
2786   /* This part is from bfd_elf_generic_reloc.
2787      If we're relocating, and this an external symbol, we don't want
2788      to change anything.  */
2789   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2790       && reloc_entry->addend == 0)
2791     {
2792       reloc_entry->address += input_section->output_offset;
2793       return bfd_reloc_ok;
2794     }
2795
2796   if (nds32_hi20_list != NULL)
2797     {
2798       struct nds32_hi20 *l;
2799
2800       l = nds32_hi20_list;
2801       while (l != NULL)
2802         {
2803           unsigned long insn;
2804           unsigned long val;
2805           unsigned long vallo;
2806           struct nds32_hi20 *next;
2807
2808           /* Do the HI20 relocation.  Note that we actually don't need
2809              to know anything about the LO12 itself, except where to
2810              find the low 12 bits of the addend needed by the LO12.  */
2811           insn = bfd_getb32 (l->addr);
2812           vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2813           vallo &= 0xfff;
2814           switch (reloc_entry->howto->type)
2815             {
2816             case R_NDS32_LO12S3:
2817               vallo <<= 3;
2818               break;
2819
2820             case R_NDS32_LO12S2:
2821               vallo <<= 2;
2822               break;
2823
2824             case R_NDS32_LO12S1:
2825               vallo <<= 1;
2826               break;
2827
2828             case R_NDS32_LO12S0:
2829               vallo <<= 0;
2830               break;
2831             }
2832
2833           val = ((insn & 0xfffff) << 12) + vallo;
2834           val += l->addend;
2835
2836           insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2837           bfd_putb32 ((bfd_vma) insn, l->addr);
2838
2839           next = l->next;
2840           free (l);
2841           l = next;
2842         }
2843
2844       nds32_hi20_list = NULL;
2845     }
2846
2847   /* Now do the LO12 reloc in the usual way.
2848      ??? It would be nice to call bfd_elf_generic_reloc here,
2849      but we have partial_inplace set.  bfd_elf_generic_reloc will
2850      pass the handling back to bfd_install_relocation which will install
2851      a section relative addend which is wrong.  */
2852   return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2853                                   input_section, output_bfd, error_message);
2854 }
2855
2856 /* Do generic partial_inplace relocation.
2857    This is a local replacement for bfd_elf_generic_reloc.  */
2858
2859 static bfd_reloc_status_type
2860 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2861                          asymbol *symbol, void *data, asection *input_section,
2862                          bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2863 {
2864   bfd_reloc_status_type ret;
2865   bfd_vma relocation;
2866   bfd_byte *inplace_address;
2867
2868   /* This part is from bfd_elf_generic_reloc.
2869      If we're relocating, and this an external symbol, we don't want
2870      to change anything.  */
2871   if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2872       && reloc_entry->addend == 0)
2873     {
2874       reloc_entry->address += input_section->output_offset;
2875       return bfd_reloc_ok;
2876     }
2877
2878   /* Now do the reloc in the usual way.
2879      ??? It would be nice to call bfd_elf_generic_reloc here,
2880      but we have partial_inplace set.  bfd_elf_generic_reloc will
2881      pass the handling back to bfd_install_relocation which will install
2882      a section relative addend which is wrong.  */
2883
2884   /* Sanity check the address (offset in section).  */
2885   if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2886     return bfd_reloc_outofrange;
2887
2888   ret = bfd_reloc_ok;
2889   if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2890     ret = bfd_reloc_undefined;
2891
2892   if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2893     relocation = 0;
2894   else
2895     relocation = symbol->value;
2896
2897   /* Only do this for a final link.  */
2898   if (output_bfd == (bfd *) NULL)
2899     {
2900       relocation += symbol->section->output_section->vma;
2901       relocation += symbol->section->output_offset;
2902     }
2903
2904   relocation += reloc_entry->addend;
2905   switch (reloc_entry->howto->type)
2906     {
2907     case R_NDS32_LO12S3:
2908       relocation >>= 3;
2909       break;
2910
2911     case R_NDS32_LO12S2:
2912       relocation >>= 2;
2913       break;
2914
2915     case R_NDS32_LO12S1:
2916       relocation >>= 1;
2917       break;
2918
2919     case R_NDS32_LO12S0:
2920     default:
2921       relocation >>= 0;
2922       break;
2923     }
2924
2925   inplace_address = (bfd_byte *) data + reloc_entry->address;
2926
2927 #define DOIT(x)                                         \
2928   x = ((x & ~reloc_entry->howto->dst_mask) |            \
2929   (((x & reloc_entry->howto->src_mask) +  relocation) & \
2930   reloc_entry->howto->dst_mask))
2931
2932   switch (reloc_entry->howto->size)
2933     {
2934     case 1:
2935       {
2936         short x = bfd_getb16 (inplace_address);
2937
2938         DOIT (x);
2939         bfd_putb16 ((bfd_vma) x, inplace_address);
2940       }
2941       break;
2942     case 2:
2943       {
2944         unsigned long x = bfd_getb32 (inplace_address);
2945
2946         DOIT (x);
2947         bfd_putb32 ((bfd_vma) x, inplace_address);
2948       }
2949       break;
2950     default:
2951       BFD_ASSERT (0);
2952     }
2953
2954   if (output_bfd != (bfd *) NULL)
2955     reloc_entry->address += input_section->output_offset;
2956
2957   return ret;
2958 }
2959
2960 /* Handle the R_NDS32_SDA15 reloc.
2961    This reloc is used to compute the address of objects in the small data area
2962    and to perform loads and stores from that area.
2963    The lower 15 bits are sign extended and added to the register specified
2964    in the instruction, which is assumed to point to _SDA_BASE_.
2965
2966    Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2967    the access size, this must be taken care of.  */
2968
2969 static bfd_reloc_status_type
2970 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2971                        asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2972                        asection *input_section, bfd *output_bfd,
2973                        char **error_message ATTRIBUTE_UNUSED)
2974 {
2975   /* This part is from bfd_elf_generic_reloc.  */
2976   if (output_bfd != (bfd *) NULL
2977       && (symbol->flags & BSF_SECTION_SYM) == 0
2978       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2979     {
2980       reloc_entry->address += input_section->output_offset;
2981       return bfd_reloc_ok;
2982     }
2983
2984   if (output_bfd != NULL)
2985     {
2986       /* FIXME: See bfd_perform_relocation.  Is this right?  */
2987       return bfd_reloc_continue;
2988     }
2989
2990   /* FIXME: not sure what to do here yet.  But then again, the linker
2991      may never call us.  */
2992   abort ();
2993 }
2994
2995 /* nds32_elf_ignore_reloc is the special function for
2996    relocation types which don't need to be relocated
2997    like relaxation relocation types.
2998    This function simply return bfd_reloc_ok when it is
2999    invoked.  */
3000
3001 static bfd_reloc_status_type
3002 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3003                         asymbol *symbol ATTRIBUTE_UNUSED,
3004                         void *data ATTRIBUTE_UNUSED, asection *input_section,
3005                         bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
3006 {
3007   if (output_bfd != NULL)
3008     reloc_entry->address += input_section->output_offset;
3009
3010   return bfd_reloc_ok;
3011 }
3012 \f
3013
3014 /* Map BFD reloc types to NDS32 ELF reloc types.  */
3015
3016 struct nds32_reloc_map_entry
3017 {
3018   bfd_reloc_code_real_type bfd_reloc_val;
3019   unsigned char elf_reloc_val;
3020 };
3021
3022 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
3023 {
3024   {BFD_RELOC_NONE, R_NDS32_NONE},
3025   {BFD_RELOC_16, R_NDS32_16_RELA},
3026   {BFD_RELOC_32, R_NDS32_32_RELA},
3027   {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
3028   {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
3029
3030   {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
3031   {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
3032   {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
3033   {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
3034   {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
3035   {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
3036   {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
3037   {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
3038   {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
3039   {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
3040   {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
3041   {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
3042   {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
3043   {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
3044   {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
3045   {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
3046   {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
3047   {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
3048   {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
3049   {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
3050   {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
3051   {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
3052   {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
3053   {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
3054   {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
3055   {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
3056   {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
3057   {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
3058   {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
3059   {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
3060   {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
3061   {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
3062   {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
3063   {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
3064   {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
3065   {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
3066   {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
3067   {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
3068   {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
3069   {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
3070   {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
3071   {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
3072   {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
3073   {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
3074   {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
3075   {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
3076   {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
3077   {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
3078   {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
3079   {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
3080   {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
3081   {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
3082   {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
3083   {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
3084   {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
3085   {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
3086   {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
3087   {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
3088   {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
3089   {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
3090   {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
3091   {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
3092   {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
3093   {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
3094   {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
3095   {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
3096   {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
3097   {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
3098   {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
3099   {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
3100   {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
3101   {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
3102   {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
3103   {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
3104   {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
3105   {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
3106   {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
3107   {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
3108   {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
3109   {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
3110   {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
3111   {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
3112   {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
3113   {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
3114   {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
3115   {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
3116   {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
3117   {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
3118   {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
3119   {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
3120   {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
3121   {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
3122   {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
3123   {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
3124   {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
3125   {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
3126   {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
3127   {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
3128   {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
3129   {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
3130   {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
3131   {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
3132   /* Not sure.  */
3133   {BFD_RELOC_NDS32_TPOFF, R_NDS32_TLS_TPOFF},
3134   /* Missing: BFD_RELOC_NDS32_GOTTPOFF.  */
3135   {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
3136   {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
3137   {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
3138   {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
3139   {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
3140   {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
3141   {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
3142   {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
3143   {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
3144   {BFD_RELOC_NDS32_TLS_IE_LO12, R_NDS32_TLS_IE_LO12},
3145   {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
3146   {BFD_RELOC_NDS32_TLS_IEGP_HI20, R_NDS32_TLS_IEGP_HI20},
3147   {BFD_RELOC_NDS32_TLS_IEGP_LO12, R_NDS32_TLS_IEGP_LO12},
3148   {BFD_RELOC_NDS32_TLS_IEGP_LO12S2, R_NDS32_TLS_IEGP_LO12S2},
3149   {BFD_RELOC_NDS32_TLS_IEGP_LW, R_NDS32_TLS_IEGP_LW},
3150   {BFD_RELOC_NDS32_TLS_DESC, R_NDS32_TLS_DESC},
3151   {BFD_RELOC_NDS32_TLS_DESC_HI20, R_NDS32_TLS_DESC_HI20},
3152   {BFD_RELOC_NDS32_TLS_DESC_LO12, R_NDS32_TLS_DESC_LO12},
3153   {BFD_RELOC_NDS32_TLS_DESC_20, R_NDS32_TLS_DESC_20},
3154   {BFD_RELOC_NDS32_TLS_DESC_SDA17S2, R_NDS32_TLS_DESC_SDA17S2},
3155   {BFD_RELOC_NDS32_TLS_DESC_ADD, R_NDS32_TLS_DESC_ADD},
3156   {BFD_RELOC_NDS32_TLS_DESC_FUNC, R_NDS32_TLS_DESC_FUNC},
3157   {BFD_RELOC_NDS32_TLS_DESC_CALL, R_NDS32_TLS_DESC_CALL},
3158   {BFD_RELOC_NDS32_TLS_DESC_MEM, R_NDS32_TLS_DESC_MEM},
3159   {BFD_RELOC_NDS32_REMOVE, R_NDS32_RELAX_REMOVE},
3160   {BFD_RELOC_NDS32_GROUP, R_NDS32_RELAX_GROUP},
3161   {BFD_RELOC_NDS32_LSI, R_NDS32_LSI},
3162 };
3163
3164 /* Patch tag.  */
3165
3166 static reloc_howto_type *
3167 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3168                                  const char *r_name)
3169 {
3170   unsigned int i;
3171
3172   for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
3173     if (nds32_elf_howto_table[i].name != NULL
3174         && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
3175       return &nds32_elf_howto_table[i];
3176
3177   for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
3178     if (nds32_elf_relax_howto_table[i].name != NULL
3179         && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
3180       return &nds32_elf_relax_howto_table[i];
3181
3182   return NULL;
3183 }
3184
3185 static reloc_howto_type *
3186 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
3187 {
3188   if (code < R_NDS32_RELAX_ENTRY)
3189     {
3190       BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
3191       return &nds32_elf_howto_table[code];
3192     }
3193   else
3194     {
3195       if ((size_t) (code - R_NDS32_RELAX_ENTRY)
3196           >= ARRAY_SIZE (nds32_elf_relax_howto_table))
3197         {
3198           int i = code;
3199           i += 1;
3200         }
3201
3202       BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
3203                   < ARRAY_SIZE (nds32_elf_relax_howto_table));
3204       return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
3205     }
3206 }
3207
3208 static reloc_howto_type *
3209 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3210                                  bfd_reloc_code_real_type code)
3211 {
3212   unsigned int i;
3213
3214   for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
3215     {
3216       if (nds32_reloc_map[i].bfd_reloc_val == code)
3217         return bfd_elf32_bfd_reloc_type_table_lookup
3218           (nds32_reloc_map[i].elf_reloc_val);
3219     }
3220
3221   return NULL;
3222 }
3223
3224 /* Set the howto pointer for an NDS32 ELF reloc.  */
3225
3226 static bfd_boolean
3227 nds32_info_to_howto_rel (bfd *abfd, arelent *cache_ptr,
3228                          Elf_Internal_Rela *dst)
3229 {
3230   enum elf_nds32_reloc_type r_type;
3231
3232   r_type = ELF32_R_TYPE (dst->r_info);
3233   if (r_type > R_NDS32_GNU_VTENTRY)
3234     {
3235       /* xgettext:c-format */
3236       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3237                           abfd, r_type);
3238       bfd_set_error (bfd_error_bad_value);
3239       return FALSE;
3240     }
3241
3242   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) <= R_NDS32_GNU_VTENTRY);
3243   cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3244   return TRUE;
3245 }
3246
3247 static bfd_boolean
3248 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
3249                      Elf_Internal_Rela *dst)
3250 {
3251   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
3252
3253   if ((r_type == R_NDS32_NONE)
3254       || ((r_type > R_NDS32_GNU_VTENTRY)
3255           && (r_type < R_NDS32_max)))
3256     {
3257       cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3258       return TRUE;
3259     }
3260
3261   /* xgettext:c-format */
3262   _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r_type);
3263   bfd_set_error (bfd_error_bad_value);
3264   return FALSE;
3265 }
3266
3267 /* Support for core dump NOTE sections.
3268    Reference to include/linux/elfcore.h in Linux.  */
3269
3270 static bfd_boolean
3271 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3272 {
3273   int offset;
3274   size_t size;
3275
3276   switch (note->descsz)
3277     {
3278     case 0x114:
3279       /* Linux/NDS32 32-bit, ABI1.  */
3280
3281       /* pr_cursig */
3282       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3283
3284       /* pr_pid */
3285       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3286
3287       /* pr_reg */
3288       offset = 72;
3289       size = 200;
3290       break;
3291
3292     case 0xfc:
3293       /* Linux/NDS32 32-bit.  */
3294
3295       /* pr_cursig */
3296       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3297
3298       /* pr_pid */
3299       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3300
3301       /* pr_reg */
3302       offset = 72;
3303       size = 176;
3304       break;
3305
3306     default:
3307       return FALSE;
3308     }
3309
3310   /* Make a ".reg" section.  */
3311   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3312                                           size, note->descpos + offset);
3313 }
3314
3315 static bfd_boolean
3316 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3317 {
3318   switch (note->descsz)
3319     {
3320     case 124:
3321       /* Linux/NDS32.  */
3322
3323       /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform.  */
3324       elf_tdata (abfd)->core->program =
3325         _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3326       elf_tdata (abfd)->core->command =
3327         _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3328       break;
3329
3330     default:
3331       return FALSE;
3332     }
3333
3334   /* Note that for some reason, a spurious space is tacked
3335      onto the end of the args in some (at least one anyway)
3336      implementations, so strip it off if it exists.  */
3337   {
3338     char *command = elf_tdata (abfd)->core->command;
3339     int n = strlen (command);
3340
3341     if (0 < n && command[n - 1] == ' ')
3342       command[n - 1] = '\0';
3343   }
3344
3345   return TRUE;
3346 }
3347
3348 /* Hook called by the linker routine which adds symbols from an object
3349    file.  We must handle the special NDS32 section numbers here.
3350    We also keep watching for whether we need to create the sdata special
3351    linker sections.  */
3352
3353 static bfd_boolean
3354 nds32_elf_add_symbol_hook (bfd *abfd,
3355                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
3356                            Elf_Internal_Sym *sym,
3357                            const char **namep ATTRIBUTE_UNUSED,
3358                            flagword *flagsp ATTRIBUTE_UNUSED,
3359                            asection **secp, bfd_vma *valp)
3360 {
3361   switch (sym->st_shndx)
3362     {
3363     case SHN_COMMON:
3364       /* Common symbols less than the GP size are automatically
3365          treated as SHN_MIPS_SCOMMON symbols.  */
3366       if (sym->st_size > elf_gp_size (abfd)
3367           || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3368         break;
3369
3370       /* st_value is the alignemnt constraint.
3371          That might be its actual size if it is an array or structure.  */
3372       switch (sym->st_value)
3373         {
3374         case 1:
3375           *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3376           break;
3377         case 2:
3378           *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3379           break;
3380         case 4:
3381           *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3382           break;
3383         case 8:
3384           *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3385           break;
3386         default:
3387           return TRUE;
3388         }
3389
3390       (*secp)->flags |= SEC_IS_COMMON;
3391       *valp = sym->st_size;
3392       break;
3393     }
3394
3395   return TRUE;
3396 }
3397
3398 /* This function can figure out the best location for a base register to access
3399    data relative to this base register
3400    INPUT:
3401    sda_d0: size of first DOUBLE WORD data section
3402    sda_w0: size of first WORD data section
3403    sda_h0: size of first HALF WORD data section
3404    sda_b : size of BYTE data section
3405    sda_hi: size of second HALF WORD data section
3406    sda_w1: size of second WORD data section
3407    sda_d1: size of second DOUBLE WORD data section
3408    OUTPUT:
3409    offset (always positive) from the beginning of sda_d0 if OK
3410    a negative error value if fail
3411    NOTE:
3412    these 7 sections have to be located back to back if exist
3413    a pass in 0 value for non-existing section   */
3414
3415 /* Due to the interpretation of simm15 field of load/store depending on
3416    data accessing size, the organization of base register relative data shall
3417    like the following figure
3418    -------------------------------------------
3419    |  DOUBLE WORD sized data (range +/- 128K)
3420    -------------------------------------------
3421    |  WORD sized data (range +/- 64K)
3422    -------------------------------------------
3423    |  HALF WORD sized data (range +/- 32K)
3424    -------------------------------------------
3425    |  BYTE sized data (range +/- 16K)
3426    -------------------------------------------
3427    |  HALF WORD sized data (range +/- 32K)
3428    -------------------------------------------
3429    |  WORD sized data (range +/- 64K)
3430    -------------------------------------------
3431    |  DOUBLE WORD sized data (range +/- 128K)
3432    -------------------------------------------
3433    Its base register shall be set to access these data freely.  */
3434
3435 /* We have to figure out the SDA_BASE value, so that we can adjust the
3436    symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
3437    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
3438    target data.  We don't need to adjust the symbol value for an
3439    external symbol if we are producing relocatable output.  */
3440
3441 static asection *sda_rela_sec = NULL;
3442
3443 #define SDA_SECTION_NUM 10
3444
3445 static bfd_reloc_status_type
3446 nds32_elf_final_sda_base (bfd *                   output_bfd,
3447                           struct bfd_link_info *  info,
3448                           bfd_vma *               psb,
3449                           bfd_boolean             add_symbol)
3450 {
3451   int relax_fp_as_gp;
3452   struct elf_nds32_link_hash_table *table;
3453   struct bfd_link_hash_entry *h, *h2;
3454   long unsigned int total = 0;
3455   asection *first = NULL, *final = NULL, *temp;
3456   bfd_vma sda_base = 0;
3457
3458   h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3459   if (!h || (h->type != bfd_link_hash_defined
3460              && h->type != bfd_link_hash_defweak))
3461     {
3462       /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3463          4 byte-aligned.  Therefore, it has to set the first section ".data"
3464          4 byte-aligned.  */
3465       static const char sec_name[SDA_SECTION_NUM][10] =
3466         {
3467           ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3468           ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3469         };
3470       size_t i = 0;
3471
3472       if (output_bfd->sections == NULL)
3473         {
3474           *psb = elf_gp (output_bfd);
3475           return bfd_reloc_ok;
3476         }
3477
3478       /* Get the first and final section.  */
3479       while (i < ARRAY_SIZE (sec_name))
3480         {
3481           temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3482           if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3483             first = temp;
3484           if (temp && (temp->size != 0 || temp->rawsize != 0))
3485             final = temp;
3486
3487           /* Summarize the sections in order to check if joining .bss.  */
3488           if (temp && temp->size != 0)
3489             total += temp->size;
3490           else if (temp && temp->rawsize != 0)
3491             total += temp->rawsize;
3492
3493           i++;
3494         }
3495
3496       /* Check .bss size.  */
3497       temp = bfd_get_section_by_name (output_bfd, ".bss");
3498       if (temp)
3499         {
3500           if (temp->size != 0)
3501             total += temp->size;
3502           else if (temp->rawsize != 0)
3503             total += temp->rawsize;
3504
3505           if (total < 0x80000)
3506             {
3507               if (!first && (temp->size != 0 || temp->rawsize != 0))
3508                 first = temp;
3509               if ((temp->size != 0 || temp->rawsize != 0))
3510                 final = temp;
3511             }
3512         }
3513
3514       if (first && final)
3515         {
3516           /* The middle of data region.  */
3517           sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3518
3519           /* Find the section sda_base located.  */
3520           i = 0;
3521           while (i < ARRAY_SIZE (sec_name))
3522             {
3523               final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3524               if (final && (final->size != 0 || final->rawsize != 0)
3525                   && sda_base >= final->vma)
3526                 {
3527                   first = final;
3528                   i++;
3529                 }
3530               else
3531                 break;
3532             }
3533         }
3534       else
3535         {
3536           /* If there is not any default data section in output bfd, try to find
3537              the first data section.  If no data section be found, just simplily
3538              choose the first output section.  */
3539           temp = output_bfd->sections;
3540           while (temp)
3541             {
3542               if (temp->flags & SEC_ALLOC
3543                   && (((temp->flags & SEC_DATA)
3544                        && ((temp->flags & SEC_READONLY) == 0))
3545                       || (temp->flags & SEC_LOAD) == 0)
3546                   && (temp->size != 0 || temp->rawsize != 0))
3547                 {
3548                   if (!first)
3549                     first = temp;
3550                   final = temp;
3551                 }
3552               temp = temp->next;
3553             }
3554
3555           /* There is no data or bss section.  */
3556           if (!first || (first->size == 0 && first->rawsize == 0))
3557             {
3558               first = output_bfd->sections;
3559               while (first && first->size == 0 && first->rawsize == 0)
3560                 first = first->next;
3561             }
3562
3563           /* There is no concrete section.  */
3564           if (!first)
3565             {
3566               *psb = elf_gp (output_bfd);
3567               return bfd_reloc_ok;
3568             }
3569
3570           if (final && (final->vma + final->rawsize - first->vma) <= 0x4000)
3571             sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3572           else
3573             sda_base = first->vma + 0x2000;
3574         }
3575
3576       sda_base -= first->vma;
3577       sda_base = sda_base & (~7);
3578
3579       if (!_bfd_generic_link_add_one_symbol
3580           (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3581            (bfd_vma) sda_base, (const char *) NULL, FALSE,
3582            get_elf_backend_data (output_bfd)->collect, &h))
3583         return FALSE;
3584
3585       sda_rela_sec = first;
3586     }
3587
3588   /* Set _FP_BASE_ to _SDA_BASE_.  */
3589   table = nds32_elf_hash_table (info);
3590   relax_fp_as_gp = table->relax_fp_as_gp;
3591   h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME, FALSE, FALSE, FALSE);
3592   /* _SDA_BASE_ is difined in linker script.  */
3593   if (!first)
3594     {
3595       first = h->u.def.section;
3596       sda_base = h->u.def.value;
3597     }
3598
3599   if (relax_fp_as_gp && h2
3600       && (h2->type == bfd_link_hash_undefweak
3601           || h2->type == bfd_link_hash_undefined))
3602     {
3603       /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3604          And set FP equal to SDA_BASE to do relaxation for
3605          la $fp, _FP_BASE_.  */
3606       if (!_bfd_generic_link_add_one_symbol
3607           (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3608            first, sda_base, (const char *) NULL,
3609            FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3610         return FALSE;
3611     }
3612
3613   if (add_symbol)
3614     {
3615       if (h)
3616         {
3617           /* Now set gp.  */
3618           elf_gp (output_bfd) = (h->u.def.value
3619                                  + h->u.def.section->output_section->vma
3620                                  + h->u.def.section->output_offset);
3621         }
3622       else
3623         {
3624           _bfd_error_handler (_("error: can't find symbol: %s"), "_SDA_BASE_");
3625           return bfd_reloc_dangerous;
3626         }
3627     }
3628
3629   *psb = h->u.def.value
3630     + h->u.def.section->output_section->vma
3631     + h->u.def.section->output_offset;
3632   return bfd_reloc_ok;
3633 }
3634 \f
3635
3636 /* Return size of a PLT entry.  */
3637 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3638
3639 /* Create an entry in an nds32 ELF linker hash table.  */
3640
3641 static struct bfd_hash_entry *
3642 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3643                              struct bfd_hash_table *table,
3644                              const char *string)
3645 {
3646   struct elf_nds32_link_hash_entry *ret;
3647
3648   ret = (struct elf_nds32_link_hash_entry *) entry;
3649
3650   /* Allocate the structure if it has not already been allocated by a
3651      subclass.  */
3652   if (ret == NULL)
3653     ret = (struct elf_nds32_link_hash_entry *)
3654        bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3655
3656   if (ret == NULL)
3657     return (struct bfd_hash_entry *) ret;
3658
3659   /* Call the allocation method of the superclass.  */
3660   ret = (struct elf_nds32_link_hash_entry *)
3661     _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3662
3663   if (ret != NULL)
3664     {
3665       struct elf_nds32_link_hash_entry *eh;
3666
3667       eh = (struct elf_nds32_link_hash_entry *) ret;
3668       eh->dyn_relocs = NULL;
3669       eh->tls_type = GOT_UNKNOWN;
3670       eh->offset_to_gp = 0;
3671     }
3672
3673   return (struct bfd_hash_entry *) ret;
3674 }
3675
3676 /* Create an nds32 ELF linker hash table.  */
3677
3678 static struct bfd_link_hash_table *
3679 nds32_elf_link_hash_table_create (bfd *abfd)
3680 {
3681   struct elf_nds32_link_hash_table *ret;
3682
3683   bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3684
3685   ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3686   if (ret == NULL)
3687     return NULL;
3688
3689   /* Patch tag.  */
3690   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3691                                       nds32_elf_link_hash_newfunc,
3692                                       sizeof (struct elf_nds32_link_hash_entry),
3693                                       NDS32_ELF_DATA))
3694     {
3695       free (ret);
3696       return NULL;
3697     }
3698
3699   ret->sdynbss = NULL;
3700   ret->srelbss = NULL;
3701   ret->sym_ld_script = NULL;
3702
3703   return &ret->root.root;
3704 }
3705
3706 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3707    shortcuts to them in our hash table.  */
3708
3709 static bfd_boolean
3710 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3711 {
3712   struct elf_link_hash_table *ehtab;
3713
3714   if (!_bfd_elf_create_got_section (dynobj, info))
3715     return FALSE;
3716
3717   ehtab = elf_hash_table (info);
3718   ehtab->sgot = bfd_get_section_by_name (dynobj, ".got");
3719   ehtab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3720   if (!ehtab->sgot || !ehtab->sgotplt)
3721     abort ();
3722
3723   /* _bfd_elf_create_got_section will create it for us.  */
3724   ehtab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3725   if (ehtab->srelgot == NULL
3726       || !bfd_set_section_flags (dynobj, ehtab->srelgot,
3727                                  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3728                                   | SEC_IN_MEMORY | SEC_LINKER_CREATED
3729                                   | SEC_READONLY))
3730       || !bfd_set_section_alignment (dynobj, ehtab->srelgot, 2))
3731     return FALSE;
3732
3733   return TRUE;
3734 }
3735
3736 /* Create dynamic sections when linking against a dynamic object.  */
3737
3738 static bfd_boolean
3739 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3740 {
3741   struct elf_link_hash_table *ehtab;
3742   struct elf_nds32_link_hash_table *htab;
3743   flagword flags, pltflags;
3744   register asection *s;
3745   const struct elf_backend_data *bed;
3746   int ptralign = 2;             /* 32-bit  */
3747   const char *secname;
3748   char *relname;
3749   flagword secflags;
3750   asection *sec;
3751
3752   bed = get_elf_backend_data (abfd);
3753   ehtab = elf_hash_table (info);
3754   htab = nds32_elf_hash_table (info);
3755
3756   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3757      .rel[a].bss sections.  */
3758
3759   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3760            | SEC_LINKER_CREATED);
3761
3762   pltflags = flags;
3763   pltflags |= SEC_CODE;
3764   if (bed->plt_not_loaded)
3765     pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3766   if (bed->plt_readonly)
3767     pltflags |= SEC_READONLY;
3768
3769   s = bfd_make_section (abfd, ".plt");
3770   ehtab->splt = s;
3771   if (s == NULL
3772       || !bfd_set_section_flags (abfd, s, pltflags)
3773       || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3774     return FALSE;
3775
3776   if (bed->want_plt_sym)
3777     {
3778       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3779          .plt section.  */
3780       struct bfd_link_hash_entry *bh = NULL;
3781       struct elf_link_hash_entry *h;
3782
3783       if (!(_bfd_generic_link_add_one_symbol
3784             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3785              (bfd_vma) 0, (const char *) NULL, FALSE,
3786              get_elf_backend_data (abfd)->collect, &bh)))
3787         return FALSE;
3788
3789       h = (struct elf_link_hash_entry *) bh;
3790       h->def_regular = 1;
3791       h->type = STT_OBJECT;
3792
3793       if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3794         return FALSE;
3795     }
3796
3797   s = bfd_make_section (abfd,
3798                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3799   ehtab->srelplt = s;
3800   if (s == NULL
3801       || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3802       || !bfd_set_section_alignment (abfd, s, ptralign))
3803     return FALSE;
3804
3805   if (ehtab->sgot == NULL && !create_got_section (abfd, info))
3806     return FALSE;
3807
3808   for (sec = abfd->sections; sec; sec = sec->next)
3809     {
3810       secflags = bfd_get_section_flags (abfd, sec);
3811       if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3812           || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3813         continue;
3814       secname = bfd_get_section_name (abfd, sec);
3815       relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3816       strcpy (relname, ".rela");
3817       strcat (relname, secname);
3818       if (bfd_get_section_by_name (abfd, secname))
3819         continue;
3820       s = bfd_make_section (abfd, relname);
3821       if (s == NULL
3822           || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3823           || !bfd_set_section_alignment (abfd, s, ptralign))
3824         return FALSE;
3825     }
3826
3827   if (bed->want_dynbss)
3828     {
3829       /* The .dynbss section is a place to put symbols which are defined
3830          by dynamic objects, are referenced by regular objects, and are
3831          not functions.  We must allocate space for them in the process
3832          image and use a R_*_COPY reloc to tell the dynamic linker to
3833          initialize them at run time.  The linker script puts the .dynbss
3834          section into the .bss section of the final image.  */
3835       s = bfd_make_section (abfd, ".dynbss");
3836       htab->sdynbss = s;
3837       if (s == NULL
3838           || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3839         return FALSE;
3840       /* The .rel[a].bss section holds copy relocs.  This section is not
3841          normally needed.  We need to create it here, though, so that the
3842          linker will map it to an output section.  We can't just create it
3843          only if we need it, because we will not know whether we need it
3844          until we have seen all the input files, and the first time the
3845          main linker code calls BFD after examining all the input files
3846          (size_dynamic_sections) the input sections have already been
3847          mapped to the output sections.  If the section turns out not to
3848          be needed, we can discard it later.  We will never need this
3849          section when generating a shared object, since they do not use
3850          copy relocs.  */
3851       if (!bfd_link_pic (info))
3852         {
3853           s = bfd_make_section (abfd, (bed->default_use_rela_p
3854                                        ? ".rela.bss" : ".rel.bss"));
3855           htab->srelbss = s;
3856           if (s == NULL
3857               || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3858               || !bfd_set_section_alignment (abfd, s, ptralign))
3859             return FALSE;
3860         }
3861     }
3862
3863   return TRUE;
3864 }
3865
3866 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3867 static void
3868 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3869                                 struct elf_link_hash_entry *dir,
3870                                 struct elf_link_hash_entry *ind)
3871 {
3872   struct elf_nds32_link_hash_entry *edir, *eind;
3873
3874   edir = (struct elf_nds32_link_hash_entry *) dir;
3875   eind = (struct elf_nds32_link_hash_entry *) ind;
3876
3877   if (eind->dyn_relocs != NULL)
3878     {
3879       if (edir->dyn_relocs != NULL)
3880         {
3881           struct elf_dyn_relocs **pp;
3882           struct elf_dyn_relocs *p;
3883
3884           if (ind->root.type == bfd_link_hash_indirect)
3885             abort ();
3886
3887           /* Add reloc counts against the weak sym to the strong sym
3888              list.  Merge any entries against the same section.  */
3889           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3890             {
3891               struct elf_dyn_relocs *q;
3892
3893               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3894                 if (q->sec == p->sec)
3895                   {
3896                     q->pc_count += p->pc_count;
3897                     q->count += p->count;
3898                     *pp = p->next;
3899                     break;
3900                   }
3901               if (q == NULL)
3902                 pp = &p->next;
3903             }
3904           *pp = edir->dyn_relocs;
3905         }
3906
3907       edir->dyn_relocs = eind->dyn_relocs;
3908       eind->dyn_relocs = NULL;
3909     }
3910
3911   if (ind->root.type == bfd_link_hash_indirect)
3912     {
3913       if (dir->got.refcount <= 0)
3914         {
3915           edir->tls_type = eind->tls_type;
3916           eind->tls_type = GOT_UNKNOWN;
3917         }
3918     }
3919
3920   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3921 }
3922 \f
3923
3924 /* Find dynamic relocs for H that apply to read-only sections.  */
3925
3926 static asection *
3927 readonly_dynrelocs (struct elf_link_hash_entry *h)
3928 {
3929   struct elf_dyn_relocs *p;
3930
3931   for (p = elf32_nds32_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
3932     {
3933       asection *s = p->sec->output_section;
3934
3935       if (s != NULL && (s->flags & SEC_READONLY) != 0)
3936         return p->sec;
3937     }
3938   return NULL;
3939 }
3940
3941 /* Adjust a symbol defined by a dynamic object and referenced by a
3942    regular object.  The current definition is in some section of the
3943    dynamic object, but we're not including those sections.  We have to
3944    change the definition to something the rest of the link can
3945    understand.  */
3946
3947 static bfd_boolean
3948 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3949                                  struct elf_link_hash_entry *h)
3950 {
3951   struct elf_nds32_link_hash_table *htab;
3952   bfd *dynobj;
3953   asection *s;
3954   unsigned int power_of_two;
3955
3956   dynobj = elf_hash_table (info)->dynobj;
3957
3958   /* Make sure we know what is going on here.  */
3959   BFD_ASSERT (dynobj != NULL
3960               && (h->needs_plt
3961                   || h->is_weakalias
3962                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3963
3964
3965   /* If this is a function, put it in the procedure linkage table.  We
3966      will fill in the contents of the procedure linkage table later,
3967      when we know the address of the .got section.  */
3968   if (h->type == STT_FUNC || h->needs_plt)
3969     {
3970       if (!bfd_link_pic (info)
3971           && !h->def_dynamic
3972           && !h->ref_dynamic
3973           && h->root.type != bfd_link_hash_undefweak
3974           && h->root.type != bfd_link_hash_undefined)
3975         {
3976           /* This case can occur if we saw a PLT reloc in an input
3977              file, but the symbol was never referred to by a dynamic
3978              object.  In such a case, we don't actually need to build
3979              a procedure linkage table, and we can just do a PCREL
3980              reloc instead.  */
3981           h->plt.offset = (bfd_vma) - 1;
3982           h->needs_plt = 0;
3983         }
3984
3985       return TRUE;
3986     }
3987   else
3988     h->plt.offset = (bfd_vma) - 1;
3989
3990   /* If this is a weak symbol, and there is a real definition, the
3991      processor independent code will have arranged for us to see the
3992      real definition first, and we can just use the same value.  */
3993   if (h->is_weakalias)
3994     {
3995       struct elf_link_hash_entry *def = weakdef (h);
3996       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3997       h->root.u.def.section = def->root.u.def.section;
3998       h->root.u.def.value = def->root.u.def.value;
3999       return TRUE;
4000     }
4001
4002   /* This is a reference to a symbol defined by a dynamic object which
4003      is not a function.  */
4004
4005   /* If we are creating a shared library, we must presume that the
4006      only references to the symbol are via the global offset table.
4007      For such cases we need not do anything here; the relocations will
4008      be handled correctly by relocate_section.  */
4009   if (bfd_link_pic (info))
4010     return TRUE;
4011
4012   /* If there are no references to this symbol that do not use the
4013      GOT, we don't need to generate a copy reloc.  */
4014   if (!h->non_got_ref)
4015     return TRUE;
4016
4017   /* If -z nocopyreloc was given, we won't generate them either.  */
4018   if (0 && info->nocopyreloc)
4019     {
4020       h->non_got_ref = 0;
4021       return TRUE;
4022     }
4023
4024   /* If we don't find any dynamic relocs in read-only sections, then
4025      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
4026   if (!readonly_dynrelocs (h))
4027     {
4028       h->non_got_ref = 0;
4029       return TRUE;
4030     }
4031
4032   /* We must allocate the symbol in our .dynbss section, which will
4033      become part of the .bss section of the executable.  There will be
4034      an entry for this symbol in the .dynsym section.  The dynamic
4035      object will contain position independent code, so all references
4036      from the dynamic object to this symbol will go through the global
4037      offset table.  The dynamic linker will use the .dynsym entry to
4038      determine the address it must put in the global offset table, so
4039      both the dynamic object and the regular object will refer to the
4040      same memory location for the variable.  */
4041
4042   htab = nds32_elf_hash_table (info);
4043   s = htab->sdynbss;
4044   BFD_ASSERT (s != NULL);
4045
4046   /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
4047      to copy the initial value out of the dynamic object and into the
4048      runtime process image.  We need to remember the offset into the
4049      .rela.bss section we are going to use.  */
4050   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4051     {
4052       asection *srel;
4053
4054       srel = htab->srelbss;
4055       BFD_ASSERT (srel != NULL);
4056       srel->size += sizeof (Elf32_External_Rela);
4057       h->needs_copy = 1;
4058     }
4059
4060   /* We need to figure out the alignment required for this symbol.  I
4061      have no idea how ELF linkers handle this.  */
4062   power_of_two = bfd_log2 (h->size);
4063   if (power_of_two > 3)
4064     power_of_two = 3;
4065
4066   /* Apply the required alignment.  */
4067   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
4068   if (power_of_two > bfd_get_section_alignment (dynobj, s))
4069     {
4070       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
4071         return FALSE;
4072     }
4073
4074   /* Define the symbol as being at this point in the section.  */
4075   h->root.u.def.section = s;
4076   h->root.u.def.value = s->size;
4077
4078   /* Increment the section size to make room for the symbol.  */
4079   s->size += h->size;
4080
4081   return TRUE;
4082 }
4083
4084 /* Allocate space in .plt, .got and associated reloc sections for
4085    dynamic relocs.  */
4086
4087 static bfd_boolean
4088 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
4089 {
4090   struct bfd_link_info *info;
4091   struct elf_link_hash_table *ehtab;
4092   struct elf_nds32_link_hash_table *htab;
4093   struct elf_nds32_link_hash_entry *eh;
4094   struct elf_dyn_relocs *p;
4095
4096   if (h->root.type == bfd_link_hash_indirect)
4097     return TRUE;
4098
4099   /* When warning symbols are created, they **replace** the "real"
4100      entry in the hash table, thus we never get to see the real
4101      symbol in a hash traversal. So look at it now.  */
4102   if (h->root.type == bfd_link_hash_warning)
4103     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4104
4105   eh = (struct elf_nds32_link_hash_entry *) h;
4106
4107   info = (struct bfd_link_info *) inf;
4108   ehtab = elf_hash_table (info);
4109   htab = nds32_elf_hash_table (info);
4110   if (htab == NULL)
4111     return FALSE;
4112
4113   eh = (struct elf_nds32_link_hash_entry *) h;
4114
4115   if ((htab->root.dynamic_sections_created || h->type == STT_GNU_IFUNC)
4116       && h->plt.refcount > 0
4117       && !(bfd_link_pie (info) && h->def_regular))
4118     {
4119       /* Make sure this symbol is output as a dynamic symbol.
4120          Undefined weak syms won't yet be marked as dynamic.  */
4121       if (h->dynindx == -1 && !h->forced_local)
4122         {
4123           if (!bfd_elf_link_record_dynamic_symbol (info, h))
4124             return FALSE;
4125         }
4126
4127       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
4128         {
4129           asection *s = ehtab->splt;
4130
4131           /* If this is the first .plt entry, make room for the special
4132              first entry.  */
4133           if (s->size == 0)
4134             s->size += PLT_ENTRY_SIZE;
4135
4136           h->plt.offset = s->size;
4137
4138           /* If this symbol is not defined in a regular file, and we are
4139              not generating a shared library, then set the symbol to this
4140              location in the .plt.  This is required to make function
4141              pointers compare as equal between the normal executable and
4142              the shared library.  */
4143           if (!bfd_link_pic (info) && !h->def_regular)
4144             {
4145               h->root.u.def.section = s;
4146               h->root.u.def.value = h->plt.offset;
4147             }
4148
4149           /* Make room for this entry.  */
4150           s->size += PLT_ENTRY_SIZE;
4151
4152           /* We also need to make an entry in the .got.plt section, which
4153              will be placed in the .got section by the linker script.  */
4154           ehtab->sgotplt->size += 4;
4155
4156           /* We also need to make an entry in the .rel.plt section.  */
4157           ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4158           if (htab->tls_desc_trampoline)
4159             htab->next_tls_desc_index++;
4160         }
4161       else
4162         {
4163           h->plt.offset = (bfd_vma) - 1;
4164           h->needs_plt = 0;
4165         }
4166     }
4167   else
4168     {
4169       h->plt.offset = (bfd_vma) - 1;
4170       h->needs_plt = 0;
4171     }
4172
4173   if (h->got.refcount > 0)
4174     {
4175       asection *sgot;
4176       bfd_boolean dyn;
4177       int tls_type = elf32_nds32_hash_entry (h)->tls_type;
4178
4179       /* Make sure this symbol is output as a dynamic symbol.
4180          Undefined weak syms won't yet be marked as dynamic.  */
4181       if (h->dynindx == -1 && !h->forced_local)
4182         {
4183           if (!bfd_elf_link_record_dynamic_symbol (info, h))
4184             return FALSE;
4185         }
4186
4187       sgot = elf_hash_table (info)->sgot;
4188       h->got.offset = sgot->size;
4189
4190       if (tls_type == GOT_UNKNOWN)
4191         abort ();
4192
4193       /* Non-TLS symbols, and TLS_IE need one GOT slot.  */
4194       if (tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4195         sgot->size += 4;
4196       else
4197         {
4198           /* TLS_DESC, TLS_GD, and TLS_LD need 2 consecutive GOT slots.  */
4199           if (tls_type & GOT_TLS_DESC)
4200             sgot->size += 8;
4201         }
4202
4203       dyn = htab->root.dynamic_sections_created;
4204
4205       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
4206         {
4207           if (tls_type == GOT_TLS_DESC && htab->tls_desc_trampoline)
4208             {
4209               /* TLS_DESC with trampoline needs a relocation slot
4210                  within .rela.plt.  */
4211               htab->num_tls_desc++;
4212               ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4213               htab->tls_trampoline = -1;
4214             }
4215           else
4216             {
4217               /* other relocations, including TLS_DESC without trampoline, need
4218                  a relocation slot within .rela.got.  */
4219               ehtab->srelgot->size += sizeof (Elf32_External_Rela);
4220             }
4221         }
4222     }
4223   else
4224     h->got.offset = (bfd_vma)-1;
4225
4226   if (eh->dyn_relocs == NULL)
4227     return TRUE;
4228
4229   /* In the shared -Bsymbolic case, discard space allocated for
4230      dynamic pc-relative relocs against symbols which turn out to be
4231      defined in regular objects.  For the normal shared case, discard
4232      space for pc-relative relocs that have become local due to symbol
4233      visibility changes.  */
4234
4235   if (bfd_link_pic (info))
4236     {
4237       if (h->def_regular && (h->forced_local || info->symbolic))
4238         {
4239           struct elf_dyn_relocs **pp;
4240
4241           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
4242             {
4243               p->count -= p->pc_count;
4244               p->pc_count = 0;
4245               if (p->count == 0)
4246                 *pp = p->next;
4247               else
4248                 pp = &p->next;
4249             }
4250         }
4251     }
4252   else
4253     {
4254       /* For the non-shared case, discard space for relocs against
4255          symbols which turn out to need copy relocs or are not dynamic.  */
4256
4257       if (!h->non_got_ref
4258           && ((h->def_dynamic
4259                && !h->def_regular)
4260               || (htab->root.dynamic_sections_created
4261                   && (h->root.type == bfd_link_hash_undefweak
4262                       || h->root.type == bfd_link_hash_undefined))))
4263         {
4264           /* Make sure this symbol is output as a dynamic symbol.
4265              Undefined weak syms won't yet be marked as dynamic.  */
4266           if (h->dynindx == -1 && !h->forced_local)
4267             {
4268               if (!bfd_elf_link_record_dynamic_symbol (info, h))
4269                 return FALSE;
4270             }
4271
4272           /* If that succeeded, we know we'll be keeping all the
4273              relocs.  */
4274           if (h->dynindx != -1)
4275             goto keep;
4276         }
4277
4278       eh->dyn_relocs = NULL;
4279
4280 keep:;
4281     }
4282
4283   /* Finally, allocate space.  */
4284   for (p = eh->dyn_relocs; p != NULL; p = p->next)
4285     {
4286       asection *sreloc = elf_section_data (p->sec)->sreloc;
4287       sreloc->size += p->count * sizeof (Elf32_External_Rela);
4288     }
4289
4290   return TRUE;
4291 }
4292
4293 /* Add relocation REL to the end of relocation section SRELOC.  */
4294
4295 static void
4296 elf32_nds32_add_dynreloc (bfd *output_bfd,
4297                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
4298                           asection *sreloc, Elf_Internal_Rela *rel)
4299 {
4300   bfd_byte *loc;
4301   if (sreloc == NULL)
4302     abort ();
4303
4304   loc = sreloc->contents;
4305   loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4306   if (sreloc->reloc_count * sizeof (Elf32_External_Rela) > sreloc->size)
4307     abort ();
4308
4309   bfd_elf32_swap_reloca_out (output_bfd, rel, loc);
4310 }
4311
4312 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
4313    read-only sections.  */
4314
4315 static bfd_boolean
4316 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
4317 {
4318   asection *sec;
4319
4320   if (h->root.type == bfd_link_hash_indirect)
4321     return TRUE;
4322
4323   sec = readonly_dynrelocs (h);
4324   if (sec != NULL)
4325     {
4326       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
4327
4328       info->flags |= DF_TEXTREL;
4329       info->callbacks->minfo
4330         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
4331          sec->owner, h->root.root.string, sec);
4332
4333       /* Not an error, just cut short the traversal.  */
4334       return FALSE;
4335     }
4336   return TRUE;
4337 }
4338
4339 /* Set the sizes of the dynamic sections.  */
4340
4341 static bfd_boolean
4342 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
4343                                  struct bfd_link_info *info)
4344 {
4345   struct elf_nds32_link_hash_table *htab;
4346   bfd *dynobj;
4347   asection *s;
4348   bfd_boolean relocs;
4349   bfd_boolean plt;
4350   bfd *ibfd;
4351
4352   htab = nds32_elf_hash_table (info);
4353   if (htab == NULL)
4354     return FALSE;
4355
4356   dynobj = elf_hash_table (info)->dynobj;
4357   BFD_ASSERT (dynobj != NULL);
4358
4359   if (elf_hash_table (info)->dynamic_sections_created)
4360     {
4361       /* Set the contents of the .interp section to the interpreter.  */
4362       if (bfd_link_executable (info) && !info->nointerp)
4363         {
4364           s = bfd_get_section_by_name (dynobj, ".interp");
4365           BFD_ASSERT (s != NULL);
4366           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4367           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4368         }
4369     }
4370
4371   /* Set up .got offsets for local syms, and space for local dynamic
4372      relocs.  */
4373   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4374     {
4375       bfd_signed_vma *local_got;
4376       bfd_signed_vma *end_local_got;
4377       bfd_size_type locsymcount;
4378       Elf_Internal_Shdr *symtab_hdr;
4379       asection *sgot;
4380       char *local_tls_type;
4381       unsigned long symndx;
4382       bfd_vma *local_tlsdesc_gotent;
4383
4384       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4385         continue;
4386
4387       for (s = ibfd->sections; s != NULL; s = s->next)
4388         {
4389           struct elf_dyn_relocs *p;
4390
4391           for (p = ((struct elf_dyn_relocs *)
4392                     elf_section_data (s)->local_dynrel);
4393                p != NULL; p = p->next)
4394             {
4395               if (!bfd_is_abs_section (p->sec)
4396                   && bfd_is_abs_section (p->sec->output_section))
4397                 {
4398                   /* Input section has been discarded, either because
4399                      it is a copy of a linkonce section or due to
4400                      linker script /DISCARD/, so we'll be discarding
4401                      the relocs too.  */
4402                 }
4403               else if (p->count != 0)
4404                 {
4405                   asection *sreloc = elf_section_data (p->sec)->sreloc;
4406                   sreloc->size += p->count * sizeof (Elf32_External_Rela);
4407                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4408                     info->flags |= DF_TEXTREL;
4409                 }
4410             }
4411         }
4412
4413       local_got = elf_local_got_refcounts (ibfd);
4414       if (!local_got)
4415         continue;
4416
4417       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4418       locsymcount = symtab_hdr->sh_info;
4419       end_local_got = local_got + locsymcount;
4420       sgot = elf_hash_table (info)->sgot;
4421       local_tls_type = elf32_nds32_local_got_tls_type (ibfd);
4422       local_tlsdesc_gotent = elf32_nds32_local_tlsdesc_gotent (ibfd);
4423       for (symndx = 0; local_got < end_local_got;
4424            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent, ++symndx)
4425         {
4426           if (*local_got > 0)
4427             {
4428               int num_of_got_entry_needed = 0;
4429               *local_got = sgot->size;
4430               *local_tlsdesc_gotent = sgot->size;
4431
4432               /* TLS_NORMAL, and TLS_IE need one slot in .got.  */
4433               if (*local_tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4434                 num_of_got_entry_needed = 1;
4435               /* TLS_GD, TLS_LD, and TLS_DESC need an 8-byte structure in the GOT.  */
4436               else if (*local_tls_type & GOT_TLS_DESC)
4437                 num_of_got_entry_needed = 2;
4438
4439               sgot->size += (num_of_got_entry_needed << 2);
4440
4441               /* non-relax-able TLS_DESCs need a slot in .rela.plt.
4442                  others need a slot in .rela.got.  */
4443               if (*local_tls_type == GOT_TLS_DESC)
4444                 {
4445                   if (bfd_link_pic (info))
4446                     {
4447                       if (htab->tls_desc_trampoline)
4448                         {
4449                           htab->num_tls_desc++;
4450                           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
4451                           htab->tls_trampoline = -1;
4452                         }
4453                       else
4454                         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4455                     }
4456                   else
4457                     {
4458                       /* TLS_DESC -> TLS_LE  */
4459                     }
4460                 }
4461               else
4462                 {
4463                   htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4464                 }
4465             }
4466           else
4467             {
4468               *local_got = (bfd_vma) -1;
4469               *local_tlsdesc_gotent = (bfd_vma) -1;
4470             }
4471         }
4472     }
4473
4474   /* Allocate global sym .plt and .got entries, and space for global
4475      sym dynamic relocs.  */
4476   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4477
4478   /* For every jump slot reserved in the sgotplt, reloc_count is
4479      incremented.  However, when we reserve space for TLS descriptors,
4480      it's not incremented, so in order to compute the space reserved
4481      for them, it suffices to multiply the reloc count by the jump
4482      slot size.  */
4483   if (htab->tls_desc_trampoline && htab->root.srelplt)
4484     htab->sgotplt_jump_table_size = elf32_nds32_compute_jump_table_size (htab);
4485
4486   if (htab->tls_trampoline)
4487     {
4488       htab->tls_trampoline = htab->root.splt->size;
4489
4490       /* If we're not using lazy TLS relocations, don't generate the
4491          PLT and GOT entries they require.  */
4492       if (!(info->flags & DF_BIND_NOW))
4493         {
4494           htab->dt_tlsdesc_got = htab->root.sgot->size;
4495           htab->root.sgot->size += 4;
4496
4497           htab->dt_tlsdesc_plt = htab->root.splt->size;
4498           htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
4499         }
4500     }
4501
4502   /* We now have determined the sizes of the various dynamic sections.
4503      Allocate memory for them.  */
4504   /* The check_relocs and adjust_dynamic_symbol entry points have
4505      determined the sizes of the various dynamic sections.  Allocate
4506      memory for them.  */
4507   plt = FALSE;
4508   relocs = FALSE;
4509   for (s = dynobj->sections; s != NULL; s = s->next)
4510     {
4511       if ((s->flags & SEC_LINKER_CREATED) == 0)
4512         continue;
4513
4514       if (s == htab->root.splt)
4515         {
4516           /* Strip this section if we don't need it; see the
4517              comment below.  */
4518           plt = s->size != 0;
4519         }
4520       else if (s == elf_hash_table (info)->sgot)
4521         {
4522           got_size += s->size;
4523         }
4524       else if (s == elf_hash_table (info)->sgotplt)
4525         {
4526           got_size += s->size;
4527         }
4528       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4529         {
4530           if (s->size != 0 && s != elf_hash_table (info)->srelplt)
4531             relocs = TRUE;
4532
4533           /* We use the reloc_count field as a counter if we need
4534              to copy relocs into the output file.  */
4535           s->reloc_count = 0;
4536         }
4537       else
4538         {
4539           /* It's not one of our sections, so don't allocate space.  */
4540           continue;
4541         }
4542
4543       if (s->size == 0)
4544         {
4545           /* If we don't need this section, strip it from the
4546              output file.  This is mostly to handle .rela.bss and
4547              .rela.plt.  We must create both sections in
4548              create_dynamic_sections, because they must be created
4549              before the linker maps input sections to output
4550              sections.  The linker does that before
4551              adjust_dynamic_symbol is called, and it is that
4552              function which decides whether anything needs to go
4553              into these sections.  */
4554           s->flags |= SEC_EXCLUDE;
4555           continue;
4556         }
4557
4558       /* Allocate memory for the section contents.  We use bfd_zalloc
4559          here in case unused entries are not reclaimed before the
4560          section's contents are written out.  This should not happen,
4561          but this way if it does, we get a R_NDS32_NONE reloc instead
4562          of garbage.  */
4563       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4564       if (s->contents == NULL)
4565         return FALSE;
4566     }
4567
4568
4569   if (htab->root.dynamic_sections_created)
4570     {
4571       /* Add some entries to the .dynamic section.  We fill in the
4572          values later, in nds32_elf_finish_dynamic_sections, but we
4573          must add the entries now so that we get the correct size for
4574          the .dynamic section.  The DT_DEBUG entry is filled in by the
4575          dynamic linker and used by the debugger.  */
4576 #define add_dynamic_entry(TAG, VAL) \
4577   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4578
4579       if (bfd_link_executable (info))
4580         {
4581           if (!add_dynamic_entry (DT_DEBUG, 0))
4582             return FALSE;
4583         }
4584
4585       if (elf_hash_table (info)->splt->size != 0)
4586         {
4587           if (!add_dynamic_entry (DT_PLTGOT, 0)
4588               || !add_dynamic_entry (DT_PLTRELSZ, 0)
4589               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4590               || !add_dynamic_entry (DT_JMPREL, 0))
4591             return FALSE;
4592         }
4593
4594       if (htab->tls_desc_trampoline && plt)
4595         {
4596           if (htab->dt_tlsdesc_plt
4597               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
4598                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
4599             return FALSE;
4600         }
4601
4602       if (relocs)
4603         {
4604           if (!add_dynamic_entry (DT_RELA, 0)
4605               || !add_dynamic_entry (DT_RELASZ, 0)
4606               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4607             return FALSE;
4608
4609           /* If any dynamic relocs apply to a read-only section,
4610              then we need a DT_TEXTREL entry.  */
4611           if ((info->flags & DF_TEXTREL) == 0)
4612             elf_link_hash_traverse (&htab->root, maybe_set_textrel,
4613                                     (void *) info);
4614
4615           if ((info->flags & DF_TEXTREL) != 0)
4616             {
4617               if (!add_dynamic_entry (DT_TEXTREL, 0))
4618                 return FALSE;
4619             }
4620         }
4621     }
4622 #undef add_dynamic_entry
4623
4624   return TRUE;
4625 }
4626
4627 static bfd_reloc_status_type
4628 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4629                          bfd_vma relocation, bfd_byte *location)
4630 {
4631   int size;
4632   bfd_vma x = 0;
4633   bfd_reloc_status_type flag;
4634   unsigned int rightshift = howto->rightshift;
4635   unsigned int bitpos = howto->bitpos;
4636
4637   /* If the size is negative, negate RELOCATION.  This isn't very
4638      general.  */
4639   if (howto->size < 0)
4640     relocation = -relocation;
4641
4642   /* Get the value we are going to relocate.  */
4643   size = bfd_get_reloc_size (howto);
4644   switch (size)
4645     {
4646     default:
4647       abort ();
4648       break;
4649     case 0:
4650       return bfd_reloc_ok;
4651     case 2:
4652       x = bfd_getb16 (location);
4653       break;
4654     case 4:
4655       x = bfd_getb32 (location);
4656       break;
4657     }
4658
4659   /* Check for overflow.  FIXME: We may drop bits during the addition
4660      which we don't check for.  We must either check at every single
4661      operation, which would be tedious, or we must do the computations
4662      in a type larger than bfd_vma, which would be inefficient.  */
4663   flag = bfd_reloc_ok;
4664   if (howto->complain_on_overflow != complain_overflow_dont)
4665     {
4666       bfd_vma addrmask, fieldmask, signmask, ss;
4667       bfd_vma a, b, sum;
4668
4669       /* Get the values to be added together.  For signed and unsigned
4670          relocations, we assume that all values should be truncated to
4671          the size of an address.  For bitfields, all the bits matter.
4672          See also bfd_check_overflow.  */
4673       fieldmask = N_ONES (howto->bitsize);
4674       signmask = ~fieldmask;
4675       addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4676       a = (relocation & addrmask) >> rightshift;
4677       b = (x & howto->src_mask & addrmask) >> bitpos;
4678
4679       switch (howto->complain_on_overflow)
4680         {
4681         case complain_overflow_signed:
4682           /* If any sign bits are set, all sign bits must be set.
4683              That is, A must be a valid negative address after
4684              shifting.  */
4685           signmask = ~(fieldmask >> 1);
4686           /* Fall through.  */
4687
4688         case complain_overflow_bitfield:
4689           /* Much like the signed check, but for a field one bit
4690              wider.  We allow a bitfield to represent numbers in the
4691              range -2**n to 2**n-1, where n is the number of bits in the
4692              field.  Note that when bfd_vma is 32 bits, a 32-bit reloc
4693              can't overflow, which is exactly what we want.  */
4694           ss = a & signmask;
4695           if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4696             flag = bfd_reloc_overflow;
4697
4698           /* We only need this next bit of code if the sign bit of B
4699              is below the sign bit of A.  This would only happen if
4700              SRC_MASK had fewer bits than BITSIZE.  Note that if
4701              SRC_MASK has more bits than BITSIZE, we can get into
4702              trouble; we would need to verify that B is in range, as
4703              we do for A above.  */
4704           ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4705           ss >>= bitpos;
4706
4707           /* Set all the bits above the sign bit.  */
4708           b = (b ^ ss) - ss;
4709
4710           /* Now we can do the addition.  */
4711           sum = a + b;
4712
4713           /* See if the result has the correct sign.  Bits above the
4714              sign bit are junk now; ignore them.  If the sum is
4715              positive, make sure we did not have all negative inputs;
4716              if the sum is negative, make sure we did not have all
4717              positive inputs.  The test below looks only at the sign
4718              bits, and it really just
4719              SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4720
4721              We mask with addrmask here to explicitly allow an address
4722              wrap-around.  The Linux kernel relies on it, and it is
4723              the only way to write assembler code which can run when
4724              loaded at a location 0x80000000 away from the location at
4725              which it is linked.  */
4726           if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4727             flag = bfd_reloc_overflow;
4728
4729           break;
4730
4731         case complain_overflow_unsigned:
4732           /* Checking for an unsigned overflow is relatively easy:
4733              trim the addresses and add, and trim the result as well.
4734              Overflow is normally indicated when the result does not
4735              fit in the field.  However, we also need to consider the
4736              case when, e.g., fieldmask is 0x7fffffff or smaller, an
4737              input is 0x80000000, and bfd_vma is only 32 bits; then we
4738              will get sum == 0, but there is an overflow, since the
4739              inputs did not fit in the field.  Instead of doing a
4740              separate test, we can check for this by or-ing in the
4741              operands when testing for the sum overflowing its final
4742              field.  */
4743           sum = (a + b) & addrmask;
4744           if ((a | b | sum) & signmask)
4745             flag = bfd_reloc_overflow;
4746           break;
4747
4748         default:
4749           abort ();
4750         }
4751     }
4752
4753   /* Put RELOCATION in the right bits.  */
4754   relocation >>= (bfd_vma) rightshift;
4755   relocation <<= (bfd_vma) bitpos;
4756
4757   /* Add RELOCATION to the right bits of X.  */
4758   /* FIXME : 090616
4759      Because the relaxation may generate duplicate relocation at one address,
4760      an addition to immediate in the instruction may cause the relocation added
4761      several times.
4762      This bug should be fixed in assembler, but a check is also needed here.  */
4763   if (howto->partial_inplace)
4764     x = ((x & ~howto->dst_mask)
4765          | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4766   else
4767     x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4768
4769
4770   /* Put the relocated value back in the object file.  */
4771   switch (size)
4772     {
4773     default:
4774     case 0:
4775     case 1:
4776     case 8:
4777       abort ();
4778       break;
4779     case 2:
4780       bfd_putb16 (x, location);
4781       break;
4782     case 4:
4783       bfd_putb32 (x, location);
4784       break;
4785     }
4786
4787   return flag;
4788 }
4789
4790 static bfd_reloc_status_type
4791 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4792                                asection *input_section, bfd_byte *contents,
4793                                bfd_vma address, bfd_vma value, bfd_vma addend)
4794 {
4795   bfd_vma relocation;
4796
4797   /* Sanity check the address.  */
4798   if (address > bfd_get_section_limit (input_bfd, input_section))
4799     return bfd_reloc_outofrange;
4800
4801   /* This function assumes that we are dealing with a basic relocation
4802      against a symbol.  We want to compute the value of the symbol to
4803      relocate to.  This is just VALUE, the value of the symbol, plus
4804      ADDEND, any addend associated with the reloc.  */
4805   relocation = value + addend;
4806
4807   /* If the relocation is PC relative, we want to set RELOCATION to
4808      the distance between the symbol (currently in RELOCATION) and the
4809      location we are relocating.  If pcrel_offset is FALSE we do not
4810      need to subtract out the offset of the location within the
4811      section (which is just ADDRESS).  */
4812   if (howto->pc_relative)
4813     {
4814       relocation -= (input_section->output_section->vma
4815                      + input_section->output_offset);
4816       if (howto->pcrel_offset)
4817         relocation -= address;
4818     }
4819
4820   return nds32_relocate_contents (howto, input_bfd, relocation,
4821                                   contents + address);
4822 }
4823
4824 static bfd_boolean
4825 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4826                               const char *name,
4827                               Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4828                               asection *input_sec,
4829                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4830 {
4831   const char *source;
4832   FILE *sym_ld_script = NULL;
4833   struct elf_nds32_link_hash_table *table;
4834
4835   table = nds32_elf_hash_table (info);
4836   sym_ld_script = table->sym_ld_script;
4837   if (!sym_ld_script)
4838     return TRUE;
4839
4840   if (!h || !name || *name == '\0')
4841     return TRUE;
4842
4843   if (input_sec->flags & SEC_EXCLUDE)
4844     return TRUE;
4845
4846   if (!check_start_export_sym)
4847     {
4848       fprintf (sym_ld_script, "SECTIONS\n{\n");
4849       check_start_export_sym = 1;
4850     }
4851
4852   if (h->root.type == bfd_link_hash_defined
4853       || h->root.type == bfd_link_hash_defweak)
4854     {
4855       if (!h->root.u.def.section->output_section)
4856         return TRUE;
4857
4858       if (bfd_is_const_section (input_sec))
4859         source = input_sec->name;
4860       else
4861         source = input_sec->owner->filename;
4862
4863       fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4864                h->root.root.string,
4865                (long) (h->root.u.def.value
4866                 + h->root.u.def.section->output_section->vma
4867                 + h->root.u.def.section->output_offset), source);
4868     }
4869
4870   return TRUE;
4871 }
4872
4873 /* Relocate an NDS32/D ELF section.
4874    There is some attempt to make this function usable for many architectures,
4875    both for RELA and REL type relocs, if only to serve as a learning tool.
4876
4877    The RELOCATE_SECTION function is called by the new ELF backend linker
4878    to handle the relocations for a section.
4879
4880    The relocs are always passed as Rela structures; if the section
4881    actually uses Rel structures, the r_addend field will always be
4882    zero.
4883
4884    This function is responsible for adjust the section contents as
4885    necessary, and (if using Rela relocs and generating a
4886    relocatable output file) adjusting the reloc addend as
4887    necessary.
4888
4889    This function does not have to worry about setting the reloc
4890    address or the reloc symbol index.
4891
4892    LOCAL_SYMS is a pointer to the swapped in local symbols.
4893
4894    LOCAL_SECTIONS is an array giving the section in the input file
4895    corresponding to the st_shndx field of each local symbol.
4896
4897    The global hash table entry for the global symbols can be found
4898    via elf_sym_hashes (input_bfd).
4899
4900    When generating relocatable output, this function must handle
4901    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
4902    going to be the section symbol corresponding to the output
4903    section, which means that the addend must be adjusted
4904    accordingly.  */
4905
4906 /* Return the base VMA address which should be subtracted from real addresses
4907    when resolving @dtpoff relocation.
4908    This is PT_TLS segment p_vaddr.  */
4909
4910 /* Return the relocation value for @tpoff relocation
4911    if STT_TLS virtual address is ADDRESS.  */
4912
4913 /* Return the relocation value for @gottpoff relocation
4914    if STT_TLS virtual address is ADDRESS.  */
4915
4916 static bfd_vma
4917 gottpoff (struct bfd_link_info *info, bfd_vma address)
4918 {
4919   bfd_vma tp_base;
4920   bfd_vma tp_offset;
4921
4922   /* If tls_sec is NULL, we should have signalled an error already.  */
4923   if (elf_hash_table (info)->tls_sec == NULL)
4924     return 0;
4925
4926   tp_base = elf_hash_table (info)->tls_sec->vma;
4927   tp_offset = address - tp_base;
4928
4929   return tp_offset;
4930 }
4931
4932 static bfd_boolean
4933 patch_tls_desc_to_ie (bfd_byte *contents, Elf_Internal_Rela *rel, bfd *ibfd)
4934 {
4935   /* TLS_GD/TLS_LD model #1
4936      46 00 00 00 sethi $r0,#0x0
4937      58 00 00 00 ori $r0,$r0,#0x0
4938      40 00 74 00 add $r0,$r0,$gp
4939      04 10 00 00 lwi $r1,[$r0+#0x0]
4940      4b e0 04 01 jral $lp,$r1  */
4941
4942   /* TLS_GD/TLS_LD model #2
4943      46 00 00 00 sethi $r0,#0x0
4944      58 00 00 00 ori $r0,$r0,#0x0
4945      38 10 74 02 lw $r1,[$r0+($gp<<#0x0)]
4946      40 00 74 00 add $r0,$r0,$gp
4947      4b e0 04 01 jral $lp,$r1  */
4948
4949   /* TLS_IE model (non-PIC)
4950      46 00 00 00 sethi $r0,#0x0
4951      04 00 00 00 lwi $r0,[$r0+#0x0]
4952      38 00 64 02 lw $r0,[$r0+($r25<<#0x0)]  */
4953
4954   /* TLS_IE model (PIC)
4955      46 00 00 00 sethi $r0,#0x0
4956      58 00 00 00 ori $r0,$r0,#0x0
4957      38 00 74 02 lw $r0,[$r0+($gp<<#0x0)]
4958      38 00 64 02 lw $r0,[$r0+($r25<<#0x0)]  */
4959
4960   /* TLS_GD_TO_IE model
4961      46 00 00 00 sethi $r0,#0x0
4962      58 00 00 00 ori $r0,$r0,#0x0
4963      40 00 74 00 add $r0,$rM,$gp
4964      04 00 00 01 lwi $r0,[$r0+#0x4]
4965      40 00 64 00 add $r0,$r0,$r25  */
4966
4967   bfd_boolean rz = FALSE;
4968
4969   typedef struct
4970     {
4971       uint32_t opcode;
4972       uint32_t mask;
4973     } pat_t;
4974
4975   uint32_t patch[3] =
4976     {
4977       0x40007400, /* add $r0,$rM,$gp     */
4978       0x04000001, /* lwi $r0,[$r0+#0x4]  */
4979       0x40006400, /* add $r0,$r0,$r25    */
4980     };
4981
4982   pat_t mode0[3] =
4983     {
4984         { 0x40000000, 0xfe0003ff },
4985         { 0x04000000, 0xfe000000 },
4986         { 0x4be00001, 0xffff83ff },
4987     };
4988
4989   pat_t mode1[3] =
4990     {
4991         { 0x38007402, 0xfe007fff },
4992         { 0x40007400, 0xfe007fff },
4993         { 0x4be00001, 0xffff83ff },
4994     };
4995
4996   unsigned char *p = contents + rel->r_offset;
4997
4998   uint32_t insn;
4999   uint32_t regidx = 0;
5000   insn = bfd_getb32 (p);
5001   if (INSN_SETHI == (0xfe0fffffu & insn))
5002     {
5003       regidx = 0x1f & (insn >> 20);
5004       p += 4;
5005     }
5006
5007   insn = bfd_getb32 (p);
5008   if (INSN_ORI == (0xfe007fffu & insn))
5009     {
5010       regidx = 0x1f & (insn >> 20);
5011       p += 4;
5012     }
5013
5014   if (patch[2] == bfd_getb32 (p + 8)) /* Character instruction.  */
5015     {
5016       /* already patched?  */
5017       if ((patch[0] == (0xfff07fffu & bfd_getb32 (p + 0))) &&
5018           (patch[1] == bfd_getb32 (p + 4)))
5019         rz = TRUE;
5020     }
5021   else if (mode0[0].opcode == (mode0[0].mask & bfd_getb32 (p + 0)))
5022     {
5023       if ((mode0[1].opcode == (mode0[1].mask & bfd_getb32 (p + 4))) &&
5024           (mode0[2].opcode == (mode0[2].mask & bfd_getb32 (p + 8))))
5025         {
5026           bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5027           bfd_putb32 (patch[1], p + 4);
5028           bfd_putb32 (patch[2], p + 8);
5029           rz = TRUE;
5030         }
5031     }
5032   else if (mode1[0].opcode == (mode1[0].mask & bfd_getb32 (p + 0)))
5033     {
5034       if ((mode1[1].opcode == (mode1[1].mask & bfd_getb32 (p + 4))) &&
5035           (mode1[2].opcode == (mode1[2].mask & bfd_getb32 (p + 8))))
5036         {
5037           bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5038           bfd_putb32 (patch[1], p + 4);
5039           bfd_putb32 (patch[2], p + 8);
5040           rz = TRUE;
5041         }
5042     }
5043
5044   if (!rz)
5045     {
5046       printf ("%s: %s @ 0x%08x\n", __func__, ibfd->filename,
5047               (int) rel->r_offset);
5048       BFD_ASSERT(0); /* Unsupported pattern.  */
5049     }
5050
5051   return rz;
5052 }
5053
5054 static enum elf_nds32_tls_type
5055 get_tls_type (enum elf_nds32_reloc_type r_type, struct elf_link_hash_entry *h);
5056
5057 static unsigned int
5058 ones32 (register unsigned int x)
5059 {
5060   /* 32-bit recursive reduction using SWAR...
5061      but first step is mapping 2-bit values
5062      into sum of 2 1-bit values in sneaky way.  */
5063   x -= ((x >> 1) & 0x55555555);
5064   x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
5065   x = (((x >> 4) + x) & 0x0f0f0f0f);
5066   x += (x >> 8);
5067   x += (x >> 16);
5068   return (x & 0x0000003f);
5069 }
5070
5071 #if !HAVE_FLS
5072 static unsigned int
5073 fls (register unsigned int x)
5074 {
5075   return ffs (x & (-x));
5076 }
5077 #endif /* !HAVE_FLS */
5078
5079 #define nds32_elf_local_tlsdesc_gotent(bfd) \
5080   (elf_nds32_tdata (bfd)->local_tlsdesc_gotent)
5081
5082 static bfd_boolean
5083 nds32_elf_relocate_section (bfd *                  output_bfd ATTRIBUTE_UNUSED,
5084                             struct bfd_link_info * info,
5085                             bfd *                  input_bfd,
5086                             asection *             input_section,
5087                             bfd_byte *             contents,
5088                             Elf_Internal_Rela *    relocs,
5089                             Elf_Internal_Sym *     local_syms,
5090                             asection **            local_sections)
5091 {
5092   Elf_Internal_Shdr *symtab_hdr;
5093   struct elf_link_hash_entry **sym_hashes;
5094   Elf_Internal_Rela *rel, *relend;
5095   bfd_boolean ret = TRUE;               /* Assume success.  */
5096   int align = 0;
5097   bfd_reloc_status_type r;
5098   const char *errmsg = NULL;
5099   bfd_vma gp;
5100   struct elf_link_hash_table *ehtab;
5101   struct elf_nds32_link_hash_table *htab;
5102   bfd *dynobj;
5103   bfd_vma *local_got_offsets;
5104   asection *sgot, *splt, *sreloc;
5105   bfd_vma high_address;
5106   struct elf_nds32_link_hash_table *table;
5107   int eliminate_gc_relocs;
5108   bfd_vma fpbase_addr;
5109
5110   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5111   sym_hashes = elf_sym_hashes (input_bfd);
5112   ehtab = elf_hash_table (info);
5113   htab = nds32_elf_hash_table (info);
5114   high_address = bfd_get_section_limit (input_bfd, input_section);
5115
5116   dynobj = htab->root.dynobj;
5117   local_got_offsets = elf_local_got_offsets (input_bfd);
5118
5119   sgot = ehtab->sgot;
5120   splt = ehtab->splt;
5121   sreloc = NULL;
5122
5123   rel = relocs;
5124   relend = relocs + input_section->reloc_count;
5125
5126   table = nds32_elf_hash_table (info);
5127   eliminate_gc_relocs = table->eliminate_gc_relocs;
5128
5129   /* By this time, we can adjust the value of _SDA_BASE_.  */
5130   /* Explain _SDA_BASE_  */
5131   if ((!bfd_link_relocatable (info)))
5132     {
5133       is_SDA_BASE_set = 1;
5134       r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
5135       if (r != bfd_reloc_ok)
5136         return FALSE;
5137     }
5138
5139   /* Do TLS model conversion once at first.  */
5140   nds32_elf_unify_tls_model (input_bfd, input_section, contents, info);
5141
5142   /* Use gp as fp to prevent truncated fit.  Because in relaxation time
5143      the fp value is set as gp, and it has be reverted for instruction
5144      setting fp.  */
5145   fpbase_addr = elf_gp (output_bfd);
5146
5147   /* Deal with (dynamic) relocations.  */
5148   for (rel = relocs; rel < relend; rel++)
5149     {
5150       enum elf_nds32_reloc_type r_type;
5151       reloc_howto_type *howto = NULL;
5152       unsigned long r_symndx;
5153       struct elf_link_hash_entry *h = NULL;
5154       Elf_Internal_Sym *sym = NULL;
5155       asection *sec;
5156       bfd_vma relocation;
5157       bfd_vma relocation_sym = 0xdeadbeef;
5158       Elf_Internal_Rela *lorel;
5159       bfd_vma off;
5160
5161       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
5162          ensure it's zero (we use REL relocs, not RELA).  Therefore this
5163          should be assigning zero to `addend', but for clarity we use
5164          `r_addend'.  */
5165
5166       bfd_vma addend = rel->r_addend;
5167       bfd_vma offset = rel->r_offset;
5168
5169       r_type = ELF32_R_TYPE (rel->r_info);
5170       if (r_type >= R_NDS32_max)
5171         {
5172           /* xgettext:c-format */
5173           _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
5174                               input_bfd, r_type);
5175           bfd_set_error (bfd_error_bad_value);
5176           ret = FALSE;
5177           continue;
5178         }
5179
5180       if (r_type == R_NDS32_GNU_VTENTRY
5181           || r_type == R_NDS32_GNU_VTINHERIT
5182           || r_type == R_NDS32_NONE
5183           || r_type == R_NDS32_RELA_GNU_VTENTRY
5184           || r_type == R_NDS32_RELA_GNU_VTINHERIT
5185           || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
5186           || r_type == R_NDS32_DATA
5187           || r_type == R_NDS32_TRAN)
5188         continue;
5189
5190       /* If we enter the fp-as-gp region.  Resolve the address
5191          of best fp-base.  */
5192       if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
5193           && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5194         {
5195           int dist;
5196
5197           /* Distance to relocation of best fp-base is encoded in R_SYM.  */
5198           dist =  rel->r_addend >> 16;
5199           fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
5200                                                   local_syms, symtab_hdr);
5201         }
5202       else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
5203                && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5204         {
5205           fpbase_addr = elf_gp (output_bfd);
5206         }
5207
5208       /* Skip the relocations used for relaxation.  */
5209       /* We have to update LONGCALL and LONGJUMP
5210          relocations when generating the relocatable files.  */
5211       if (!bfd_link_relocatable (info)
5212           && (r_type >= R_NDS32_RELAX_ENTRY
5213               || (r_type >= R_NDS32_LONGCALL4
5214                   && r_type <= R_NDS32_LONGJUMP7)))
5215         continue;
5216
5217       howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
5218       r_symndx = ELF32_R_SYM (rel->r_info);
5219
5220       /* This is a final link.  */
5221       sym = NULL;
5222       sec = NULL;
5223       h = NULL;
5224
5225       if (r_symndx < symtab_hdr->sh_info)
5226         {
5227           /* Local symbol.  */
5228           sym = local_syms + r_symndx;
5229           sec = local_sections[r_symndx];
5230
5231           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
5232           addend = rel->r_addend;
5233
5234           /* keep symbol location for static TLS_IE GOT entry  */
5235           relocation_sym = relocation;
5236           if (bfd_link_relocatable (info))
5237             {
5238               /* This is a relocatable link.  We don't have to change
5239                  anything, unless the reloc is against a section symbol,
5240                  in which case we have to adjust according to where the
5241                  section symbol winds up in the output section.  */
5242               if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5243                 rel->r_addend += sec->output_offset + sym->st_value;
5244
5245               continue;
5246             }
5247         }
5248       else
5249         {
5250           /* External symbol.  */
5251           if (bfd_link_relocatable (info))
5252             continue;
5253           bfd_boolean warned, ignored, unresolved_reloc;
5254           int symndx = r_symndx - symtab_hdr->sh_info;
5255
5256           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
5257                                    r_symndx, symtab_hdr, sym_hashes, h, sec,
5258                                    relocation, unresolved_reloc, warned,
5259                                    ignored);
5260
5261           /* keep symbol location for static TLS_IE GOT entry  */
5262           relocation_sym = relocation;
5263
5264           /* la $fp, _FP_BASE_ is per-function (region).
5265              Handle it specially.  */
5266           switch ((int) r_type)
5267             {
5268             case R_NDS32_HI20_RELA:
5269             case R_NDS32_LO12S0_RELA:
5270               if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5271                           FP_BASE_NAME) == 0)
5272                 {
5273                   if (!bfd_link_pie (info))
5274                     {
5275                       _bfd_error_handler
5276                         ("%pB: warning: _FP_BASE_ setting insns relaxation failed.",
5277                          input_bfd);
5278                     }
5279                   relocation = fpbase_addr;
5280                 }
5281               break;
5282             case R_NDS32_SDA19S0_RELA:
5283             case R_NDS32_SDA15S0_RELA:
5284             case R_NDS32_20_RELA:
5285               if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5286                           FP_BASE_NAME) == 0)
5287                 {
5288                   relocation = fpbase_addr;
5289                   break;
5290                 }
5291             }
5292         }
5293
5294       /* Sanity check the address.  */
5295       if (offset > high_address)
5296         {
5297           r = bfd_reloc_outofrange;
5298           goto check_reloc;
5299         }
5300
5301       if (r_type >= R_NDS32_RELAX_ENTRY)
5302         continue;
5303
5304       switch ((int) r_type)
5305         {
5306         case R_NDS32_GOTOFF:
5307           /* Relocation is relative to the start of the global offset
5308              table (for ld24 rx, #uimm24), e.g. access at label+addend
5309
5310              ld24 rx. #label@GOTOFF + addend
5311              sub  rx, r12.  */
5312         case R_NDS32_GOTOFF_HI20:
5313         case R_NDS32_GOTOFF_LO12:
5314         case R_NDS32_GOTOFF_LO15:
5315         case R_NDS32_GOTOFF_LO19:
5316           BFD_ASSERT (sgot != NULL);
5317
5318           relocation -= elf_gp (output_bfd);
5319           break;
5320
5321         case R_NDS32_9_PLTREL:
5322         case R_NDS32_25_PLTREL:
5323           /* Relocation is to the entry for this symbol in the
5324              procedure linkage table.  */
5325
5326           /* The native assembler will generate a 25_PLTREL reloc
5327              for a local symbol if you assemble a call from one
5328              section to another when using -K pic.  */
5329           if (h == NULL)
5330             break;
5331
5332           if (h->forced_local)
5333             break;
5334
5335           /* We didn't make a PLT entry for this symbol.  This
5336              happens when statically linking PIC code, or when
5337              using -Bsymbolic.  */
5338           if (h->plt.offset == (bfd_vma) - 1)
5339             break;
5340
5341           relocation = (splt->output_section->vma
5342                         + splt->output_offset + h->plt.offset);
5343           break;
5344
5345         case R_NDS32_PLT_GOTREL_HI20:
5346         case R_NDS32_PLT_GOTREL_LO12:
5347         case R_NDS32_PLT_GOTREL_LO15:
5348         case R_NDS32_PLT_GOTREL_LO19:
5349         case R_NDS32_PLT_GOTREL_LO20:
5350           if (h == NULL
5351               || h->forced_local
5352               || h->plt.offset == (bfd_vma) -1
5353               || (bfd_link_pie (info) && h->def_regular))
5354             {
5355               /* Maybe we should find better checking to optimize
5356                  PIE PLT relocations.  */
5357               /* We didn't make a PLT entry for this symbol.  This
5358                  happens when statically linking PIC code, or when
5359                  using -Bsymbolic.  */
5360               if (h)
5361                 h->plt.offset = (bfd_vma) -1;   /* Cancel PLT trampoline.  */
5362               relocation -= elf_gp (output_bfd);
5363               break;
5364             }
5365
5366           relocation = (splt->output_section->vma
5367                         + splt->output_offset + h->plt.offset);
5368
5369           relocation -= elf_gp (output_bfd);
5370           break;
5371
5372         case R_NDS32_PLTREL_HI20:
5373         case R_NDS32_PLTREL_LO12:
5374
5375           /* Relocation is to the entry for this symbol in the
5376              procedure linkage table.  */
5377
5378           /* The native assembler will generate a 25_PLTREL reloc
5379              for a local symbol if you assemble a call from one
5380              section to another when using -K pic.  */
5381           if (h == NULL)
5382             break;
5383
5384           if (h->forced_local)
5385             break;
5386
5387           if (h->plt.offset == (bfd_vma) - 1)
5388             /* We didn't make a PLT entry for this symbol.  This
5389                happens when statically linking PIC code, or when
5390                using -Bsymbolic.  */
5391             break;
5392
5393           if (splt == NULL)
5394             break;
5395
5396           relocation = (splt->output_section->vma
5397                         + splt->output_offset
5398                         + h->plt.offset + 4)
5399                        - (input_section->output_section->vma
5400                           + input_section->output_offset
5401                           + rel->r_offset);
5402
5403           break;
5404
5405         case R_NDS32_GOTPC20:
5406           /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5407              ld24 rx,#_GLOBAL_OFFSET_TABLE_  */
5408           relocation = elf_gp (output_bfd);
5409           break;
5410
5411         case R_NDS32_GOTPC_HI20:
5412         case R_NDS32_GOTPC_LO12:
5413           /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5414              bl .+4
5415              seth rx,#high(_GLOBAL_OFFSET_TABLE_)
5416              or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
5417              or
5418              bl .+4
5419              seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
5420              add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)  */
5421           relocation = elf_gp (output_bfd);
5422           relocation -= (input_section->output_section->vma
5423                          + input_section->output_offset + rel->r_offset);
5424           break;
5425
5426         case R_NDS32_GOT20:
5427           /* Fall through.  */
5428         case R_NDS32_GOT_HI20:
5429         case R_NDS32_GOT_LO12:
5430         case R_NDS32_GOT_LO15:
5431         case R_NDS32_GOT_LO19:
5432           /* Relocation is to the entry for this symbol in the global
5433              offset table.  */
5434           BFD_ASSERT (sgot != NULL);
5435
5436           if (h != NULL)
5437             {
5438               /* External symbol  */
5439               bfd_boolean dyn;
5440
5441               off = h->got.offset;
5442               BFD_ASSERT (off != (bfd_vma) - 1);
5443               dyn = htab->root.dynamic_sections_created;
5444               if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
5445                                                     bfd_link_pic (info),
5446                                                     h)
5447                   || (bfd_link_pic (info)
5448                       && (info->symbolic
5449                           || h->dynindx == -1
5450                           || h->forced_local) && h->def_regular))
5451                 {
5452                   /* This is actually a static link, or it is a
5453                      -Bsymbolic link and the symbol is defined
5454                      locally, or the symbol was forced to be local
5455                      because of a version file.  We must initialize
5456                      this entry in the global offset table.  Since the
5457                      offset must always be a multiple of 4, we use the
5458                      least significant bit to record whether we have
5459                      initialized it already.
5460
5461                      When doing a dynamic link, we create a .rela.got
5462                      relocation entry to initialize the value.  This
5463                      is done in the finish_dynamic_symbol routine.  */
5464                   if ((off & 1) != 0)   /* clear LSB  */
5465                     off &= ~1;
5466                   else
5467                     {
5468                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5469                       h->got.offset |= 1;
5470                     }
5471                 }
5472               relocation = sgot->output_section->vma + sgot->output_offset + off
5473                            - elf_gp (output_bfd);
5474             }
5475           else
5476             {
5477               /* Local symbol  */
5478               bfd_byte *loc;
5479
5480               BFD_ASSERT (local_got_offsets != NULL
5481                           && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5482
5483               off = local_got_offsets[r_symndx];
5484
5485               /* The offset must always be a multiple of 4.  We use
5486                  the least significant bit to record whether we have
5487                  already processed this entry.  */
5488               if ((off & 1) != 0)       /* clear LSB  */
5489                 off &= ~1;
5490               else
5491                 {
5492                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5493
5494                   if (bfd_link_pic (info))
5495                     {
5496                       asection *srelgot;
5497                       Elf_Internal_Rela outrel;
5498
5499                       /* We need to generate a R_NDS32_RELATIVE reloc
5500                          for the dynamic linker.  */
5501                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5502                       BFD_ASSERT (srelgot != NULL);
5503
5504                       outrel.r_offset = (elf_gp (output_bfd)
5505                                          + sgot->output_offset + off);
5506                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5507                       outrel.r_addend = relocation;
5508                       loc = srelgot->contents;
5509                       loc +=
5510                         srelgot->reloc_count * sizeof (Elf32_External_Rela);
5511                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5512                       ++srelgot->reloc_count;
5513                     }
5514                   local_got_offsets[r_symndx] |= 1;
5515                 }
5516               relocation = sgot->output_section->vma + sgot->output_offset + off
5517                            - elf_gp (output_bfd);
5518             }
5519
5520           break;
5521
5522         case R_NDS32_16_RELA:
5523         case R_NDS32_20_RELA:
5524         case R_NDS32_5_RELA:
5525         case R_NDS32_32_RELA:
5526         case R_NDS32_9_PCREL_RELA:
5527         case R_NDS32_WORD_9_PCREL_RELA:
5528         case R_NDS32_10_UPCREL_RELA:
5529         case R_NDS32_15_PCREL_RELA:
5530         case R_NDS32_17_PCREL_RELA:
5531         case R_NDS32_25_PCREL_RELA:
5532         case R_NDS32_HI20_RELA:
5533         case R_NDS32_LO12S3_RELA:
5534         case R_NDS32_LO12S2_RELA:
5535         case R_NDS32_LO12S2_DP_RELA:
5536         case R_NDS32_LO12S2_SP_RELA:
5537         case R_NDS32_LO12S1_RELA:
5538         case R_NDS32_LO12S0_RELA:
5539         case R_NDS32_LO12S0_ORI_RELA:
5540           if (bfd_link_pic (info) && r_symndx != 0
5541               && (input_section->flags & SEC_ALLOC) != 0
5542               && (eliminate_gc_relocs == 0
5543                   || (sec && (sec->flags & SEC_EXCLUDE) == 0))
5544               && ((r_type != R_NDS32_9_PCREL_RELA
5545                    && r_type != R_NDS32_WORD_9_PCREL_RELA
5546                    && r_type != R_NDS32_10_UPCREL_RELA
5547                    && r_type != R_NDS32_15_PCREL_RELA
5548                    && r_type != R_NDS32_17_PCREL_RELA
5549                    && r_type != R_NDS32_25_PCREL_RELA
5550                    && !(r_type == R_NDS32_32_RELA
5551                         && strcmp (input_section->name, ".eh_frame") == 0))
5552                   || (h != NULL && h->dynindx != -1
5553                       && (!info->symbolic || !h->def_regular))))
5554             {
5555               Elf_Internal_Rela outrel;
5556               bfd_boolean skip, relocate;
5557               bfd_byte *loc;
5558
5559               /* When generating a shared object, these relocations
5560                  are copied into the output file to be resolved at run
5561                  time.  */
5562
5563               if (sreloc == NULL)
5564                 {
5565                   const char *name;
5566
5567                   name = bfd_elf_string_from_elf_section
5568                     (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
5569                      elf_section_data (input_section)->rela.hdr->sh_name);
5570                   if (name == NULL)
5571                     return FALSE;
5572
5573                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5574                               && strcmp (bfd_get_section_name (input_bfd,
5575                                                                input_section),
5576                                          name + 5) == 0);
5577
5578                   sreloc = bfd_get_section_by_name (dynobj, name);
5579                   BFD_ASSERT (sreloc != NULL);
5580                 }
5581
5582               skip = FALSE;
5583               relocate = FALSE;
5584
5585               outrel.r_offset = _bfd_elf_section_offset (output_bfd,
5586                                                          info,
5587                                                          input_section,
5588                                                          rel->r_offset);
5589               if (outrel.r_offset == (bfd_vma) - 1)
5590                 skip = TRUE;
5591               else if (outrel.r_offset == (bfd_vma) - 2)
5592                 skip = TRUE, relocate = TRUE;
5593               outrel.r_offset += (input_section->output_section->vma
5594                                   + input_section->output_offset);
5595
5596               if (skip)
5597                 memset (&outrel, 0, sizeof outrel);
5598               else if (r_type == R_NDS32_17_PCREL_RELA
5599                        || r_type == R_NDS32_15_PCREL_RELA
5600                        || r_type == R_NDS32_25_PCREL_RELA)
5601                 {
5602                   BFD_ASSERT (h != NULL && h->dynindx != -1);
5603                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5604                   outrel.r_addend = rel->r_addend;
5605                 }
5606               else
5607                 {
5608                   /* h->dynindx may be -1 if this symbol was marked to
5609                      become local.  */
5610                   if (h == NULL
5611                       || ((info->symbolic || h->dynindx == -1)
5612                           && h->def_regular)
5613                       || (bfd_link_pie (info) && h->def_regular))
5614                     {
5615                       relocate = TRUE;
5616                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5617                       outrel.r_addend = relocation + rel->r_addend;
5618
5619                       if (h)
5620                         {
5621                           h->plt.offset = (bfd_vma) -1;   /* cancel PLT trampoline.  */
5622
5623                           BFD_ASSERT (sgot != NULL);
5624                           /* If we did not allocate got entry for the symbol,
5625                              we can not fill the nonexistent got entry.  */
5626                           if (h->got.offset != (bfd_vma) -1
5627                               && (h->got.offset & 1) == 0)
5628                             {
5629                               bfd_put_32 (output_bfd, outrel.r_addend,
5630                                           sgot->contents + h->got.offset);
5631                             }
5632                         }
5633                     }
5634                   else
5635                     {
5636                       if (h->dynindx == -1)
5637                         {
5638                           _bfd_error_handler
5639                             (_("%pB: relocation %s against `%s' can not be used when "
5640                                "making a shared object; recompile with -fPIC"),
5641                              input_bfd, nds32_elf_howto_table[r_type].name, h->root.root.string);
5642                           bfd_set_error (bfd_error_bad_value);
5643                           return FALSE;
5644                         }
5645
5646                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5647                       outrel.r_addend = rel->r_addend;
5648                     }
5649                 }
5650
5651               loc = sreloc->contents;
5652               loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
5653               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5654               ++sreloc->reloc_count;
5655
5656               /* If this reloc is against an external symbol, we do
5657                  not want to fiddle with the addend.  Otherwise, we
5658                  need to include the symbol value so that it becomes
5659                  an addend for the dynamic reloc.  */
5660               if (!relocate)
5661                 continue;
5662             }
5663           break;
5664
5665         case R_NDS32_25_ABS_RELA:
5666           if (bfd_link_pic (info))
5667             {
5668               _bfd_error_handler
5669                 (_("%pB: warning: %s unsupported in shared mode"),
5670                  input_bfd, "R_NDS32_25_ABS_RELA");
5671               return FALSE;
5672             }
5673           break;
5674
5675         case R_NDS32_9_PCREL:
5676           r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5677                                           contents, offset,
5678                                           sec, relocation, addend);
5679           goto check_reloc;
5680
5681         case R_NDS32_HI20:
5682           /* We allow an arbitrary number of HI20 relocs before the
5683              LO12 reloc.  This permits gcc to emit the HI and LO relocs
5684              itself.  */
5685           for (lorel = rel + 1;
5686                (lorel < relend
5687                 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5688             continue;
5689           if (lorel < relend
5690               && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5691                   || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5692                   || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5693                   || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5694             {
5695               nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5696                                        contents, relocation + addend);
5697               r = bfd_reloc_ok;
5698             }
5699           else
5700             r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5701                                           contents, offset, relocation,
5702                                           addend);
5703           goto check_reloc;
5704
5705         case R_NDS32_GOT17S2_RELA:
5706         case R_NDS32_GOT15S2_RELA:
5707           BFD_ASSERT (sgot != NULL);
5708
5709           if (h != NULL)
5710             {
5711               bfd_boolean dyn;
5712
5713               off = h->got.offset;
5714               BFD_ASSERT (off != (bfd_vma) - 1);
5715
5716               dyn = htab->root.dynamic_sections_created;
5717               if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5718                   (dyn, bfd_link_pic (info), h)
5719                   || (bfd_link_pic (info)
5720                       && (info->symbolic
5721                           || h->dynindx == -1
5722                           || h->forced_local)
5723                       && h->def_regular))
5724                 {
5725                   /* This is actually a static link, or it is a
5726                      -Bsymbolic link and the symbol is defined
5727                      locally, or the symbol was forced to be local
5728                      because of a version file.  We must initialize
5729                      this entry in the global offset table.  Since the
5730                      offset must always be a multiple of 4, we use the
5731                      least significant bit to record whether we have
5732                      initialized it already.
5733
5734                      When doing a dynamic link, we create a .rela.got
5735                      relocation entry to initialize the value.  This
5736                      is done in the finish_dynamic_symbol routine.  */
5737                   if ((off & 1) != 0)
5738                     off &= ~1;
5739                   else
5740                     {
5741                       bfd_put_32 (output_bfd, relocation,
5742                                   sgot->contents + off);
5743                       h->got.offset |= 1;
5744                     }
5745                 }
5746             }
5747           else
5748             {
5749               bfd_byte *loc;
5750
5751               BFD_ASSERT (local_got_offsets != NULL
5752                           && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5753
5754               off = local_got_offsets[r_symndx];
5755
5756               /* The offset must always be a multiple of 4.  We use
5757                  the least significant bit to record whether we have
5758                  already processed this entry.  */
5759               if ((off & 1) != 0)
5760                 off &= ~1;
5761               else
5762                 {
5763                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5764
5765                   if (bfd_link_pic (info))
5766                     {
5767                       asection *srelgot;
5768                       Elf_Internal_Rela outrel;
5769
5770                       /* We need to generate a R_NDS32_RELATIVE reloc
5771                          for the dynamic linker.  */
5772                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5773                       BFD_ASSERT (srelgot != NULL);
5774
5775                       outrel.r_offset = (elf_gp (output_bfd)
5776                                          + sgot->output_offset + off);
5777                       outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5778                       outrel.r_addend = relocation;
5779                       loc = srelgot->contents;
5780                       loc +=
5781                         srelgot->reloc_count * sizeof (Elf32_External_Rela);
5782                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5783                       ++srelgot->reloc_count;
5784                     }
5785                   local_got_offsets[r_symndx] |= 1;
5786                 }
5787             }
5788           relocation = sgot->output_section->vma + sgot->output_offset + off
5789             - elf_gp (output_bfd);
5790
5791           if (relocation & align)
5792             {
5793               /* Incorrect alignment.  */
5794               _bfd_error_handler
5795                 (_("%pB: warning: unaligned access to GOT entry"), input_bfd);
5796               ret = FALSE;
5797               r = bfd_reloc_dangerous;
5798               goto check_reloc;
5799             }
5800           break;
5801
5802         case R_NDS32_SDA16S3_RELA:
5803         case R_NDS32_SDA15S3_RELA:
5804         case R_NDS32_SDA15S3:
5805           align = 0x7;
5806           goto handle_sda;
5807
5808         case R_NDS32_SDA17S2_RELA:
5809         case R_NDS32_SDA15S2_RELA:
5810         case R_NDS32_SDA12S2_SP_RELA:
5811         case R_NDS32_SDA12S2_DP_RELA:
5812         case R_NDS32_SDA15S2:
5813         case R_NDS32_SDA_FP7U2_RELA:
5814           align = 0x3;
5815           goto handle_sda;
5816
5817         case R_NDS32_SDA18S1_RELA:
5818         case R_NDS32_SDA15S1_RELA:
5819         case R_NDS32_SDA15S1:
5820           align = 0x1;
5821           goto handle_sda;
5822
5823         case R_NDS32_SDA19S0_RELA:
5824         case R_NDS32_SDA15S0_RELA:
5825         case R_NDS32_SDA15S0:
5826           align = 0x0;
5827 handle_sda:
5828           BFD_ASSERT (sec != NULL);
5829
5830           /* If the symbol is in the abs section, the out_bfd will be null.
5831              This happens when the relocation has a symbol@GOTOFF.  */
5832           r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5833           if (r != bfd_reloc_ok)
5834             {
5835               _bfd_error_handler
5836                 (_("%pB: warning: relocate SDA_BASE failed"), input_bfd);
5837               ret = FALSE;
5838               goto check_reloc;
5839             }
5840
5841           /* At this point `relocation' contains the object's
5842              address.  */
5843           if (r_type == R_NDS32_SDA_FP7U2_RELA)
5844             {
5845               relocation -= fpbase_addr;
5846             }
5847           else
5848             relocation -= gp;
5849           /* Now it contains the offset from _SDA_BASE_.  */
5850
5851           /* Make sure alignment is correct.  */
5852
5853           if (relocation & align)
5854             {
5855               /* Incorrect alignment.  */
5856               _bfd_error_handler
5857                 /* xgettext:c-format */
5858                 (_("%pB(%pA): warning: unaligned small data access"
5859                    " of type %d"),
5860                  input_bfd, input_section, r_type);
5861               ret = FALSE;
5862               goto check_reloc;
5863             }
5864           break;
5865
5866         case R_NDS32_17IFC_PCREL_RELA:
5867         case R_NDS32_10IFCU_PCREL_RELA:
5868           /* Do nothing.  */
5869           break;
5870
5871         case R_NDS32_TLS_LE_HI20:
5872         case R_NDS32_TLS_LE_LO12:
5873         case R_NDS32_TLS_LE_20:
5874         case R_NDS32_TLS_LE_15S0:
5875         case R_NDS32_TLS_LE_15S1:
5876         case R_NDS32_TLS_LE_15S2:
5877           /* We do not have garbage collection for got entries.
5878              Therefore, IE to LE may have one empty entry, and DESC to
5879              LE may have two.  */
5880           if (elf_hash_table (info)->tls_sec != NULL)
5881             relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5882           break;
5883
5884         case R_NDS32_TLS_IE_HI20:
5885         case R_NDS32_TLS_IE_LO12S2:
5886         case R_NDS32_TLS_DESC_HI20:
5887         case R_NDS32_TLS_DESC_LO12:
5888         case R_NDS32_TLS_IE_LO12:
5889         case R_NDS32_TLS_IEGP_HI20:
5890         case R_NDS32_TLS_IEGP_LO12:
5891         case R_NDS32_TLS_IEGP_LO12S2:
5892           {
5893             /* Relocation is to the entry for this symbol in the global
5894                offset table.  */
5895             enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
5896             asection *srelgot;
5897             Elf_Internal_Rela outrel;
5898             bfd_byte *loc;
5899             int indx = 0;
5900
5901             eff_tls_type = org_tls_type = get_tls_type (r_type, h);
5902
5903             BFD_ASSERT (sgot != NULL);
5904             if (h != NULL)
5905               {
5906                 bfd_boolean dyn;
5907
5908                 off = h->got.offset;
5909                 BFD_ASSERT (off != (bfd_vma) -1);
5910                 dyn = htab->root.dynamic_sections_created;
5911                 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5912                 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5913                     && (!bfd_link_pic (info)
5914                         || !SYMBOL_REFERENCES_LOCAL (info, h)))
5915                   indx = h->dynindx;
5916               }
5917             else
5918               {
5919                 BFD_ASSERT (local_got_offsets != NULL
5920                             && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5921                 off = local_got_offsets[r_symndx];
5922                 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5923               }
5924
5925             relocation = sgot->output_section->vma + sgot->output_offset + off;
5926
5927             if (1 < ones32 (tls_type))
5928               {
5929                 eff_tls_type = 1 << (fls (tls_type) - 1);
5930                 /* TLS model shall be handled in nds32_elf_unify_tls_model ().  */
5931
5932                 /* TLS model X -> LE is not implement yet!
5933                    workaround here!  */
5934                 if (eff_tls_type == GOT_TLS_LE)
5935                   {
5936                     eff_tls_type = 1 << (fls (tls_type ^ eff_tls_type) - 1);
5937                   }
5938               }
5939
5940             /* The offset must always be a multiple of 4.  We use
5941                the least significant bit to record whether we have
5942                already processed this entry.  */
5943             bfd_boolean need_relocs = FALSE;
5944             srelgot = ehtab->srelgot;
5945             if ((bfd_link_pic (info) || indx != 0)
5946                 && (h == NULL || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5947                     || h->root.type != bfd_link_hash_undefweak))
5948               {
5949                 need_relocs = TRUE;
5950                 BFD_ASSERT (srelgot != NULL);
5951               }
5952
5953             if (off & 1)
5954               {
5955                 off &= ~1;
5956                 relocation &= ~1;
5957
5958                 if (eff_tls_type & GOT_TLS_DESC)
5959                   {
5960                     relocation -= elf_gp (output_bfd);
5961                     if ((R_NDS32_TLS_DESC_HI20 == r_type) && (!need_relocs))
5962                       {
5963                         /* TLS model shall be converted.  */
5964                         BFD_ASSERT(0);
5965                       }
5966                   }
5967                 else if (eff_tls_type & GOT_TLS_IEGP)
5968                   {
5969                     relocation -= elf_gp (output_bfd);
5970                   }
5971               }
5972             else
5973               {
5974                 if ((eff_tls_type & GOT_TLS_LE) && (tls_type ^ eff_tls_type))
5975                   {
5976                     /* TLS model workaround shall be applied.  */
5977                     BFD_ASSERT(0);
5978                   }
5979                 else if (eff_tls_type & (GOT_TLS_IE | GOT_TLS_IEGP))
5980                   {
5981                     if (eff_tls_type & GOT_TLS_IEGP)
5982                       relocation -= elf_gp(output_bfd);
5983
5984                     if (need_relocs)
5985                       {
5986                         if (indx == 0)
5987                           outrel.r_addend = gottpoff (info, relocation_sym);
5988                         else
5989                           outrel.r_addend = 0;
5990                         outrel.r_offset = (sgot->output_section->vma
5991                                            + sgot->output_offset + off);
5992                         outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_TPOFF);
5993
5994                         elf32_nds32_add_dynreloc (output_bfd, info, srelgot,
5995                                                   &outrel);
5996                       }
5997                     else
5998                       {
5999                         bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6000                                     sgot->contents + off);
6001                       }
6002                   }
6003                 else if (eff_tls_type & GOT_TLS_DESC)
6004                   {
6005                     relocation -= elf_gp (output_bfd);
6006                     if (need_relocs)
6007                       {
6008                         if (indx == 0)
6009                           outrel.r_addend = gottpoff (info, relocation_sym);
6010                         else
6011                           outrel.r_addend = 0;
6012                         outrel.r_offset = (sgot->output_section->vma
6013                                            + sgot->output_offset + off);
6014                         outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_DESC);
6015
6016                         if (htab->tls_desc_trampoline)
6017                           {
6018                             asection *srelplt;
6019                             srelplt = ehtab->srelplt;
6020                             loc = srelplt->contents;
6021                             loc += htab->next_tls_desc_index++ * sizeof (Elf32_External_Rela);
6022                             BFD_ASSERT (loc + sizeof (Elf32_External_Rela)
6023                                         <= srelplt->contents + srelplt->size);
6024
6025                             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6026                           }
6027                         else
6028                           {
6029                             loc = srelgot->contents;
6030                             loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
6031                             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6032                             ++srelgot->reloc_count;
6033                           }
6034                       }
6035                     else
6036                       {
6037                         /* feed me!  */
6038                         bfd_put_32 (output_bfd, 0xdeadbeef,
6039                                     sgot->contents + off);
6040                         bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6041                                     sgot->contents + off + 4);
6042                         patch_tls_desc_to_ie (contents, rel, input_bfd);
6043                         BFD_ASSERT(0);
6044                       }
6045                   }
6046                 else
6047                   {
6048                     /* TLS model workaround shall be applied.  */
6049                     BFD_ASSERT(0);
6050                   }
6051
6052                 if (h != NULL)
6053                   h->got.offset |= 1;
6054                 else
6055                   local_got_offsets[r_symndx] |= 1;
6056               }
6057           }
6058         break;
6059           /* DON'T fall through.  */
6060
6061         default:
6062           /* OLD_NDS32_RELOC.  */
6063
6064           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6065                                         contents, offset, relocation, addend);
6066           goto check_reloc;
6067         }
6068
6069       switch ((int) r_type)
6070         {
6071         case R_NDS32_20_RELA:
6072         case R_NDS32_5_RELA:
6073         case R_NDS32_9_PCREL_RELA:
6074         case R_NDS32_WORD_9_PCREL_RELA:
6075         case R_NDS32_10_UPCREL_RELA:
6076         case R_NDS32_15_PCREL_RELA:
6077         case R_NDS32_17_PCREL_RELA:
6078         case R_NDS32_25_PCREL_RELA:
6079         case R_NDS32_25_ABS_RELA:
6080         case R_NDS32_HI20_RELA:
6081         case R_NDS32_LO12S3_RELA:
6082         case R_NDS32_LO12S2_RELA:
6083         case R_NDS32_LO12S2_DP_RELA:
6084         case R_NDS32_LO12S2_SP_RELA:
6085         case R_NDS32_LO12S1_RELA:
6086         case R_NDS32_LO12S0_RELA:
6087         case R_NDS32_LO12S0_ORI_RELA:
6088         case R_NDS32_SDA16S3_RELA:
6089         case R_NDS32_SDA17S2_RELA:
6090         case R_NDS32_SDA18S1_RELA:
6091         case R_NDS32_SDA19S0_RELA:
6092         case R_NDS32_SDA15S3_RELA:
6093         case R_NDS32_SDA15S2_RELA:
6094         case R_NDS32_SDA12S2_DP_RELA:
6095         case R_NDS32_SDA12S2_SP_RELA:
6096         case R_NDS32_SDA15S1_RELA:
6097         case R_NDS32_SDA15S0_RELA:
6098         case R_NDS32_SDA_FP7U2_RELA:
6099         case R_NDS32_9_PLTREL:
6100         case R_NDS32_25_PLTREL:
6101         case R_NDS32_GOT20:
6102         case R_NDS32_GOT_HI20:
6103         case R_NDS32_GOT_LO12:
6104         case R_NDS32_GOT_LO15:
6105         case R_NDS32_GOT_LO19:
6106         case R_NDS32_GOT15S2_RELA:
6107         case R_NDS32_GOT17S2_RELA:
6108         case R_NDS32_GOTPC20:
6109         case R_NDS32_GOTPC_HI20:
6110         case R_NDS32_GOTPC_LO12:
6111         case R_NDS32_GOTOFF:
6112         case R_NDS32_GOTOFF_HI20:
6113         case R_NDS32_GOTOFF_LO12:
6114         case R_NDS32_GOTOFF_LO15:
6115         case R_NDS32_GOTOFF_LO19:
6116         case R_NDS32_PLTREL_HI20:
6117         case R_NDS32_PLTREL_LO12:
6118         case R_NDS32_PLT_GOTREL_HI20:
6119         case R_NDS32_PLT_GOTREL_LO12:
6120         case R_NDS32_PLT_GOTREL_LO15:
6121         case R_NDS32_PLT_GOTREL_LO19:
6122         case R_NDS32_PLT_GOTREL_LO20:
6123         case R_NDS32_17IFC_PCREL_RELA:
6124         case R_NDS32_10IFCU_PCREL_RELA:
6125         case R_NDS32_TLS_LE_HI20:
6126         case R_NDS32_TLS_LE_LO12:
6127         case R_NDS32_TLS_IE_HI20:
6128         case R_NDS32_TLS_IE_LO12S2:
6129         case R_NDS32_TLS_LE_20:
6130         case R_NDS32_TLS_LE_15S0:
6131         case R_NDS32_TLS_LE_15S1:
6132         case R_NDS32_TLS_LE_15S2:
6133         case R_NDS32_TLS_DESC_HI20:
6134         case R_NDS32_TLS_DESC_LO12:
6135         case R_NDS32_TLS_IE_LO12:
6136         case R_NDS32_TLS_IEGP_HI20:
6137         case R_NDS32_TLS_IEGP_LO12:
6138         case R_NDS32_TLS_IEGP_LO12S2:
6139           /* Instruction related relocs must handle endian properly.  */
6140           /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER.  */
6141           r = nds32_elf_final_link_relocate (howto, input_bfd,
6142                                              input_section, contents,
6143                                              rel->r_offset, relocation,
6144                                              rel->r_addend);
6145           break;
6146
6147         default:
6148           /* All other relocs can use default handler.  */
6149           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6150                                         contents, rel->r_offset,
6151                                         relocation, rel->r_addend);
6152           break;
6153         }
6154
6155 check_reloc:
6156
6157       if (r != bfd_reloc_ok)
6158         {
6159           /* FIXME: This should be generic enough to go in a utility.  */
6160           const char *name;
6161
6162           if (h != NULL)
6163             name = h->root.root.string;
6164           else
6165             {
6166               name = bfd_elf_string_from_elf_section
6167                       (input_bfd, symtab_hdr->sh_link, sym->st_name);
6168               if (name == NULL || *name == '\0')
6169                 name = bfd_section_name (input_bfd, sec);
6170             }
6171
6172           if (errmsg != NULL)
6173             goto common_error;
6174
6175           switch (r)
6176             {
6177             case bfd_reloc_overflow:
6178               (*info->callbacks->reloc_overflow)
6179                 (info, (h ? &h->root : NULL), name, howto->name,
6180                  (bfd_vma) 0, input_bfd, input_section, offset);
6181               break;
6182
6183             case bfd_reloc_undefined:
6184               (*info->callbacks->undefined_symbol)
6185                 (info, name, input_bfd, input_section, offset, TRUE);
6186               break;
6187
6188             case bfd_reloc_outofrange:
6189               errmsg = _("internal error: out of range error");
6190               goto common_error;
6191
6192             case bfd_reloc_notsupported:
6193               errmsg = _("internal error: unsupported relocation error");
6194               goto common_error;
6195
6196             case bfd_reloc_dangerous:
6197               errmsg = _("internal error: dangerous error");
6198               goto common_error;
6199
6200             default:
6201               errmsg = _("internal error: unknown error");
6202               /* Fall through.  */
6203
6204 common_error:
6205               (*info->callbacks->warning) (info, errmsg, name, input_bfd,
6206                                            input_section, offset);
6207               break;
6208             }
6209         }
6210     }
6211
6212   /* Resotre header size to avoid overflow load.  */
6213   if (elf_nds32_tdata (input_bfd)->hdr_size != 0)
6214     symtab_hdr->sh_size = elf_nds32_tdata (input_bfd)->hdr_size;
6215
6216   return ret;
6217 }
6218
6219 /* Finish up dynamic symbol handling.  We set the contents of various
6220    dynamic sections here.  */
6221
6222 static bfd_boolean
6223 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6224                                  struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
6225 {
6226   struct elf_link_hash_table *ehtab;
6227   struct elf_nds32_link_hash_entry *hent;
6228   bfd_byte *loc;
6229
6230   ehtab = elf_hash_table (info);
6231   hent = (struct elf_nds32_link_hash_entry *) h;
6232
6233   if (h->plt.offset != (bfd_vma) - 1)
6234     {
6235       asection *splt;
6236       asection *sgot;
6237       asection *srela;
6238
6239       bfd_vma plt_index;
6240       bfd_vma got_offset;
6241       bfd_vma local_plt_offset;
6242       Elf_Internal_Rela rela;
6243
6244       /* This symbol has an entry in the procedure linkage table.  Set
6245          it up.  */
6246
6247       BFD_ASSERT (h->dynindx != -1);
6248
6249       splt = ehtab->splt;
6250       sgot = ehtab->sgotplt;
6251       srela = ehtab->srelplt;
6252       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
6253
6254       /* Get the index in the procedure linkage table which
6255          corresponds to this symbol.  This is the index of this symbol
6256          in all the symbols for which we are making plt entries.  The
6257          first entry in the procedure linkage table is reserved.  */
6258       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
6259
6260       /* Get the offset into the .got table of the entry that
6261          corresponds to this function.  Each .got entry is 4 bytes.
6262          The first three are reserved.  */
6263       got_offset = (plt_index + 3) * 4;
6264
6265       /* Fill in the entry in the procedure linkage table.  */
6266       if (!bfd_link_pic (info))
6267         {
6268           unsigned long insn;
6269
6270           insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
6271                                       + sgot->output_offset + got_offset) >> 12)
6272                                     & 0xfffff);
6273           bfd_putb32 (insn, splt->contents + h->plt.offset);
6274
6275           insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
6276                                       + sgot->output_offset + got_offset) & 0x0fff)
6277                                     >> 2);
6278           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6279
6280           insn = PLT_ENTRY_WORD2;
6281           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6282
6283           insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
6284           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6285
6286           insn = PLT_ENTRY_WORD4
6287                  + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
6288           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6289           local_plt_offset = 12;
6290         }
6291       else
6292         {
6293           /* sda_base must be set at this time.  */
6294           unsigned long insn;
6295           long offset;
6296
6297           offset = sgot->output_section->vma + sgot->output_offset + got_offset
6298                    - elf_gp (output_bfd);
6299           insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
6300           bfd_putb32 (insn, splt->contents + h->plt.offset);
6301
6302           insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
6303           bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6304
6305           insn = PLT_PIC_ENTRY_WORD2;
6306           bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6307
6308           insn = PLT_PIC_ENTRY_WORD3;
6309           bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6310
6311           insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
6312           bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6313
6314           insn = PLT_PIC_ENTRY_WORD5
6315             + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
6316           bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
6317
6318           local_plt_offset = 16;
6319         }
6320
6321       /* Fill in the entry in the global offset table,
6322          so it will fall through to the next instruction for the first time.  */
6323       bfd_put_32 (output_bfd,
6324                   (splt->output_section->vma + splt->output_offset
6325                    + h->plt.offset + local_plt_offset),
6326                   sgot->contents + got_offset);
6327
6328       /* Fill in the entry in the .rela.plt section.  */
6329       rela.r_offset = (sgot->output_section->vma
6330                        + sgot->output_offset + got_offset);
6331       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
6332       rela.r_addend = 0;
6333       loc = srela->contents;
6334       loc += plt_index * sizeof (Elf32_External_Rela);
6335       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6336
6337       if (!h->def_regular)
6338         {
6339           /* Mark the symbol as undefined, rather than as defined in
6340              the .plt section.  Leave the value alone.  */
6341           sym->st_shndx = SHN_UNDEF;
6342           if (!h->ref_regular_nonweak)
6343             sym->st_value = 0;
6344         }
6345     }
6346
6347   if (h->got.offset != (bfd_vma) - 1
6348       && hent->tls_type == GOT_NORMAL)
6349     {
6350       asection *sgot;
6351       asection *srelagot;
6352       Elf_Internal_Rela rela;
6353
6354       /* This symbol has an entry in the global offset table.
6355          Set it up.  */
6356
6357       sgot = ehtab->sgot;
6358       srelagot = ehtab->srelgot;
6359       BFD_ASSERT (sgot != NULL && srelagot != NULL);
6360
6361       rela.r_offset = (sgot->output_section->vma
6362                        + sgot->output_offset + (h->got.offset & ~1));
6363
6364       /* If this is a -Bsymbolic link, and the symbol is defined
6365          locally, we just want to emit a RELATIVE reloc.  Likewise if
6366          the symbol was forced to be local because of a version file.
6367          The entry in the global offset table will already have been
6368          initialized in the relocate_section function.  */
6369       if ((bfd_link_pic (info)
6370            && (info->symbolic || h->dynindx == -1 || h->forced_local)
6371            && h->def_regular)
6372           || (bfd_link_pie (info) && h->def_regular))
6373         {
6374           rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
6375           rela.r_addend = (h->root.u.def.value
6376                            + h->root.u.def.section->output_section->vma
6377                            + h->root.u.def.section->output_offset);
6378
6379           if ((h->got.offset & 1) == 0)
6380             {
6381               bfd_put_32 (output_bfd, rela.r_addend,
6382                           sgot->contents + h->got.offset);
6383             }
6384         }
6385       else
6386         {
6387           BFD_ASSERT ((h->got.offset & 1) == 0);
6388           bfd_put_32 (output_bfd, (bfd_vma) 0,
6389                       sgot->contents + h->got.offset);
6390           rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
6391           rela.r_addend = 0;
6392         }
6393
6394       loc = srelagot->contents;
6395       loc += srelagot->reloc_count * sizeof (Elf32_External_Rela);
6396       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6397       ++srelagot->reloc_count;
6398       BFD_ASSERT (loc < (srelagot->contents + srelagot->size));
6399     }
6400
6401   if (h->needs_copy)
6402     {
6403       asection *s;
6404       Elf_Internal_Rela rela;
6405
6406       /* This symbols needs a copy reloc.  Set it up.  */
6407
6408       BFD_ASSERT (h->dynindx != -1
6409                   && (h->root.type == bfd_link_hash_defined
6410                       || h->root.type == bfd_link_hash_defweak));
6411
6412       s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
6413       BFD_ASSERT (s != NULL);
6414
6415       rela.r_offset = (h->root.u.def.value
6416                        + h->root.u.def.section->output_section->vma
6417                        + h->root.u.def.section->output_offset);
6418       rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
6419       rela.r_addend = 0;
6420       loc = s->contents;
6421       loc += s->reloc_count * sizeof (Elf32_External_Rela);
6422       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6423       ++s->reloc_count;
6424     }
6425
6426   /* Mark some specially defined symbols as absolute.  */
6427   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
6428       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
6429     sym->st_shndx = SHN_ABS;
6430
6431   return TRUE;
6432 }
6433
6434
6435 /* Finish up the dynamic sections.  */
6436
6437 static bfd_boolean
6438 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6439 {
6440   bfd *dynobj;
6441   asection *sdyn;
6442   asection *sgotplt;
6443   struct elf_link_hash_table *ehtab;
6444   struct elf_nds32_link_hash_table *htab;
6445
6446   ehtab = elf_hash_table (info);
6447   htab = nds32_elf_hash_table (info);
6448   if (htab == NULL)
6449     return FALSE;
6450
6451   dynobj = elf_hash_table (info)->dynobj;
6452
6453   sgotplt = ehtab->sgotplt;
6454   /* A broken linker script might have discarded the dynamic sections.
6455      Catch this here so that we do not seg-fault later on.  */
6456   if (sgotplt != NULL && bfd_is_abs_section (sgotplt->output_section))
6457     return FALSE;
6458   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6459
6460   if (elf_hash_table (info)->dynamic_sections_created)
6461     {
6462       asection *splt;
6463       Elf32_External_Dyn *dyncon, *dynconend;
6464
6465       BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6466
6467       dyncon = (Elf32_External_Dyn *) sdyn->contents;
6468       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6469
6470       for (; dyncon < dynconend; dyncon++)
6471         {
6472           Elf_Internal_Dyn dyn;
6473           asection *s;
6474
6475           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
6476
6477           switch (dyn.d_tag)
6478             {
6479             default:
6480               break;
6481
6482             case DT_PLTGOT:
6483               /* name = ".got";  */
6484               s = ehtab->sgot->output_section;
6485               goto get_vma;
6486             case DT_JMPREL:
6487               s = ehtab->srelplt->output_section;
6488 get_vma:
6489               BFD_ASSERT (s != NULL);
6490               dyn.d_un.d_ptr = s->vma;
6491               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6492               break;
6493
6494             case DT_PLTRELSZ:
6495               s = ehtab->srelplt->output_section;
6496               BFD_ASSERT (s != NULL);
6497               dyn.d_un.d_val = s->size;
6498               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6499               break;
6500
6501             case DT_RELASZ:
6502               /* My reading of the SVR4 ABI indicates that the
6503                  procedure linkage table relocs (DT_JMPREL) should be
6504                  included in the overall relocs (DT_RELA).  This is
6505                  what Solaris does.  However, UnixWare can not handle
6506                  that case.  Therefore, we override the DT_RELASZ entry
6507                  here to make it not include the JMPREL relocs.  Since
6508                  the linker script arranges for .rela.plt to follow all
6509                  other relocation sections, we don't have to worry
6510                  about changing the DT_RELA entry.  */
6511               if (ehtab->srelplt != NULL)
6512                 {
6513                   s = ehtab->srelplt->output_section;
6514                   dyn.d_un.d_val -= s->size;
6515                 }
6516               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6517               break;
6518
6519             case DT_TLSDESC_PLT:
6520               s = htab->root.splt;
6521               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6522                                 + htab->dt_tlsdesc_plt);
6523               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6524               break;
6525
6526             case DT_TLSDESC_GOT:
6527               s = htab->root.sgot;
6528               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6529                                 + htab->dt_tlsdesc_got);
6530               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6531               break;
6532             }
6533         }
6534
6535       /* Fill in the first entry in the procedure linkage table.  */
6536       splt = ehtab->splt;
6537       if (splt && splt->size > 0)
6538         {
6539           if (bfd_link_pic (info))
6540             {
6541               unsigned long insn;
6542               long offset;
6543
6544               offset = sgotplt->output_section->vma + sgotplt->output_offset + 4
6545                 - elf_gp (output_bfd);
6546               insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
6547               bfd_putb32 (insn, splt->contents);
6548
6549               /* here has a typo?  */
6550               insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
6551               bfd_putb32 (insn, splt->contents + 4);
6552
6553               insn = PLT0_PIC_ENTRY_WORD2;
6554               bfd_putb32 (insn, splt->contents + 8);
6555
6556               insn = PLT0_PIC_ENTRY_WORD3;
6557               bfd_putb32 (insn, splt->contents + 12);
6558
6559               insn = PLT0_PIC_ENTRY_WORD4;
6560               bfd_putb32 (insn, splt->contents + 16);
6561
6562               insn = PLT0_PIC_ENTRY_WORD5;
6563               bfd_putb32 (insn, splt->contents + 20);
6564             }
6565           else
6566             {
6567               unsigned long insn;
6568               unsigned long addr;
6569
6570               /* addr = .got + 4 */
6571               addr = sgotplt->output_section->vma + sgotplt->output_offset + 4;
6572               insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
6573               bfd_putb32 (insn, splt->contents);
6574
6575               insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
6576               bfd_putb32 (insn, splt->contents + 4);
6577
6578               insn = PLT0_ENTRY_WORD2;
6579               bfd_putb32 (insn, splt->contents + 8);
6580
6581               insn = PLT0_ENTRY_WORD3;
6582               bfd_putb32 (insn, splt->contents + 12);
6583
6584               insn = PLT0_ENTRY_WORD4;
6585               bfd_putb32 (insn, splt->contents + 16);
6586             }
6587
6588           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
6589             PLT_ENTRY_SIZE;
6590         }
6591
6592       if (htab->dt_tlsdesc_plt)
6593         {
6594           /* Calculate addresses.  */
6595           asection *sgot = sgot = ehtab->sgot;
6596           bfd_vma pltgot = sgotplt->output_section->vma
6597             + sgotplt->output_offset;
6598           bfd_vma tlsdesc_got = sgot->output_section->vma + sgot->output_offset
6599             + htab->dt_tlsdesc_got;
6600
6601           /* Get GP offset.  */
6602           pltgot -= elf_gp (output_bfd) - 4; /* PLTGOT[1]  */
6603           tlsdesc_got -= elf_gp (output_bfd);
6604
6605           /* Do relocation.  */
6606           dl_tlsdesc_lazy_trampoline[0] += ((1 << 20) - 1) & (tlsdesc_got >> 12);
6607           dl_tlsdesc_lazy_trampoline[1] += 0xfff & tlsdesc_got;
6608           dl_tlsdesc_lazy_trampoline[4] += ((1 << 20) - 1) & (pltgot >> 12);
6609           dl_tlsdesc_lazy_trampoline[5] +=  0xfff & pltgot;
6610
6611           /* Insert .plt.  */
6612           nds32_put_trampoline (splt->contents + htab->dt_tlsdesc_plt,
6613                                 dl_tlsdesc_lazy_trampoline,
6614                                 ARRAY_SIZE (dl_tlsdesc_lazy_trampoline));
6615         }
6616     }
6617
6618   /* Fill in the first three entries in the global offset table.  */
6619   if (sgotplt && sgotplt->size > 0)
6620     {
6621       if (sdyn == NULL)
6622         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
6623       else
6624         bfd_put_32 (output_bfd,
6625                     sdyn->output_section->vma + sdyn->output_offset,
6626                     sgotplt->contents);
6627       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
6628       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
6629
6630       elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
6631     }
6632
6633   return TRUE;
6634 }
6635 \f
6636
6637 /* Set the right machine number.  */
6638
6639 static bfd_boolean
6640 nds32_elf_object_p (bfd *abfd)
6641 {
6642   static unsigned int cur_arch = 0;
6643
6644   if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
6645     {
6646       /* E_N1_ARCH is a wild card, so it is set only when no others exist.  */
6647       cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
6648     }
6649
6650   switch (cur_arch)
6651     {
6652     default:
6653     case E_N1_ARCH:
6654       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
6655       break;
6656     case E_N1H_ARCH:
6657       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
6658       break;
6659     case E_NDS_ARCH_STAR_V2_0:
6660       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
6661       break;
6662     case E_NDS_ARCH_STAR_V3_0:
6663       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
6664       break;
6665     case E_NDS_ARCH_STAR_V3_M:
6666       bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
6667       break;
6668     }
6669
6670   return TRUE;
6671 }
6672
6673 /* Store the machine number in the flags field.  */
6674
6675 static bfd_boolean
6676 nds32_elf_final_write_processing (bfd *abfd)
6677 {
6678   unsigned long val;
6679   static unsigned int cur_mach = 0;
6680
6681   if (bfd_mach_n1 != bfd_get_mach (abfd))
6682     {
6683       cur_mach = bfd_get_mach (abfd);
6684     }
6685
6686   switch (cur_mach)
6687     {
6688     case bfd_mach_n1:
6689       /* Only happen when object is empty, since the case is abandon.  */
6690       val = E_N1_ARCH;
6691       val |= E_NDS_ABI_AABI;
6692       val |= E_NDS32_ELF_VER_1_4;
6693       break;
6694     case bfd_mach_n1h:
6695       val = E_N1H_ARCH;
6696       break;
6697     case bfd_mach_n1h_v2:
6698       val = E_NDS_ARCH_STAR_V2_0;
6699       break;
6700     case bfd_mach_n1h_v3:
6701       val = E_NDS_ARCH_STAR_V3_0;
6702       break;
6703     case bfd_mach_n1h_v3m:
6704       val = E_NDS_ARCH_STAR_V3_M;
6705       break;
6706     default:
6707       val = 0;
6708       break;
6709     }
6710
6711   elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
6712   elf_elfheader (abfd)->e_flags |= val;
6713   return _bfd_elf_final_write_processing (abfd);
6714 }
6715
6716 /* Function to keep NDS32 specific file flags.  */
6717
6718 static bfd_boolean
6719 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
6720 {
6721   BFD_ASSERT (!elf_flags_init (abfd)
6722               || elf_elfheader (abfd)->e_flags == flags);
6723
6724   elf_elfheader (abfd)->e_flags = flags;
6725   elf_flags_init (abfd) = TRUE;
6726   return TRUE;
6727 }
6728
6729 static unsigned int
6730 convert_e_flags (unsigned int e_flags, unsigned int arch)
6731 {
6732   if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
6733     {
6734       /* From 0.9 to 1.0.  */
6735       e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
6736
6737       /* Invert E_NDS32_HAS_NO_MAC_INST.  */
6738       e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6739       if (arch == E_NDS_ARCH_STAR_V1_0)
6740         {
6741           /* Done.  */
6742           return e_flags;
6743         }
6744     }
6745
6746   /* From 1.0 to 2.0.  */
6747   e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
6748
6749   /* Clear E_NDS32_HAS_MFUSR_PC_INST.  */
6750   e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
6751
6752   /* Invert E_NDS32_HAS_NO_MAC_INST.  */
6753   e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6754   return e_flags;
6755 }
6756
6757 static bfd_boolean
6758 nds32_check_vec_size (bfd *ibfd)
6759 {
6760   static unsigned int nds32_vec_size = 0;
6761
6762   asection *sec_t = NULL;
6763   bfd_byte *contents = NULL;
6764
6765   sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
6766
6767   if (sec_t && sec_t->size >= 4)
6768     {
6769       /* Get vec_size in file.  */
6770       unsigned int flag_t;
6771
6772       nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
6773       flag_t = bfd_get_32 (ibfd, contents);
6774
6775       /* The value could only be 4 or 16.  */
6776
6777       if (!nds32_vec_size)
6778         /* Set if not set yet.  */
6779         nds32_vec_size = (flag_t & 0x3);
6780       else if (nds32_vec_size != (flag_t & 0x3))
6781         {
6782           _bfd_error_handler
6783             /* xgettext:c-format */
6784             (_("%pB: ISR vector size mismatch"
6785                " with previous modules, previous %u-byte, current %u-byte"),
6786              ibfd,
6787              nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
6788              (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
6789           return FALSE;
6790         }
6791       else
6792         /* Only keep the first vec_size section.  */
6793         sec_t->flags |= SEC_EXCLUDE;
6794     }
6795
6796   return TRUE;
6797 }
6798
6799 /* Merge backend specific data from an object file to the output
6800    object file when linking.  */
6801
6802 static bfd_boolean
6803 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6804 {
6805   bfd *obfd = info->output_bfd;
6806   flagword out_flags;
6807   flagword in_flags;
6808   flagword out_16regs;
6809   flagword in_no_mac;
6810   flagword out_no_mac;
6811   flagword in_16regs;
6812   flagword out_version;
6813   flagword in_version;
6814   flagword out_fpu_config;
6815   flagword in_fpu_config;
6816
6817   /* TODO: Revise to use object-attributes instead.  */
6818   if (!nds32_check_vec_size (ibfd))
6819     return FALSE;
6820
6821   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6822       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6823     return TRUE;
6824
6825   if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6826     {
6827       _bfd_error_handler
6828         (_("%pB: warning: endian mismatch with previous modules"), ibfd);
6829
6830       bfd_set_error (bfd_error_bad_value);
6831       return FALSE;
6832     }
6833
6834   /* -B option in objcopy cannot work as expected. e_flags = 0 shall be
6835      treat as generic one without checking and merging.  */
6836   if (elf_elfheader (ibfd)->e_flags)
6837     {
6838       in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6839       if (in_version == E_NDS32_ELF_VER_1_2)
6840         {
6841           _bfd_error_handler
6842             (_("%pB: warning: older version of object file encountered, "
6843                "please recompile with current tool chain"), ibfd);
6844         }
6845
6846       /* We may need to merge V1 and V2 arch object files to V2.  */
6847       if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6848           != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6849         {
6850           /* Need to convert version.  */
6851           if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6852               == E_NDS_ARCH_STAR_RESERVED)
6853             {
6854               elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6855             }
6856           else if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6857                    == E_NDS_ARCH_STAR_V3_M
6858                    && (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6859                    == E_NDS_ARCH_STAR_V3_0)
6860             {
6861               elf_elfheader (ibfd)->e_flags =
6862                 (elf_elfheader (ibfd)->e_flags & (~EF_NDS_ARCH))
6863                 | E_NDS_ARCH_STAR_V3_0;
6864             }
6865           else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6866                    == E_NDS_ARCH_STAR_V0_9
6867                    || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6868                    > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6869             {
6870               elf_elfheader (obfd)->e_flags =
6871                 convert_e_flags (elf_elfheader (obfd)->e_flags,
6872                                  (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6873             }
6874           else
6875             {
6876               elf_elfheader (ibfd)->e_flags =
6877                 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6878                                  (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6879             }
6880         }
6881
6882       /* Extract some flags.  */
6883       in_flags = elf_elfheader (ibfd)->e_flags
6884         & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6885              | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6886
6887       /* The following flags need special treatment.  */
6888       in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6889       in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6890       in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6891
6892       /* Extract some flags.  */
6893       out_flags = elf_elfheader (obfd)->e_flags
6894         & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6895              | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6896
6897       /* The following flags need special treatment.  */
6898       out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6899       out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6900       out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6901       out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6902       if (!elf_flags_init (obfd))
6903         {
6904           /* If the input is the default architecture then do not
6905              bother setting the flags for the output architecture,
6906              instead allow future merges to do this.  If no future
6907              merges ever set these flags then they will retain their
6908              unitialised values, which surprise surprise, correspond
6909              to the default values.  */
6910           if (bfd_get_arch_info (ibfd)->the_default)
6911             return TRUE;
6912
6913           elf_flags_init (obfd) = TRUE;
6914           elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6915
6916           if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6917               && bfd_get_arch_info (obfd)->the_default)
6918             {
6919               return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6920                                         bfd_get_mach (ibfd));
6921             }
6922
6923           return TRUE;
6924         }
6925
6926       /* Check flag compatibility.  */
6927       if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6928         {
6929           _bfd_error_handler
6930             (_("%pB: error: ABI mismatch with previous modules"), ibfd);
6931           bfd_set_error (bfd_error_bad_value);
6932           return FALSE;
6933         }
6934
6935       if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6936         {
6937           if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6938             {
6939               _bfd_error_handler
6940                 (_("%pB: error: instruction set mismatch with previous modules"),
6941                  ibfd);
6942
6943               bfd_set_error (bfd_error_bad_value);
6944               return FALSE;
6945             }
6946         }
6947
6948       /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6949          and perf ext1 and DIV are mergerd to perf ext1.  */
6950       if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6951         {
6952           elf_elfheader (obfd)->e_flags =
6953             (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6954             | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6955             | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6956                ?  E_NDS32_HAS_EXT_INST : 0)
6957             | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6958                ?  E_NDS32_HAS_EXT_INST : 0)
6959             | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6960             | ((in_version > out_version) ? out_version : in_version);
6961         }
6962       else
6963         {
6964           if (in_version != out_version)
6965             _bfd_error_handler
6966               /* xgettext:c-format */
6967               (_("%pB: warning: incompatible elf-versions %s and %s"),
6968                ibfd, nds32_elfver_strtab[out_version],
6969                nds32_elfver_strtab[in_version]);
6970
6971           elf_elfheader (obfd)->e_flags = in_flags | out_flags
6972             | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6973             | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6974             | (in_version > out_version ?  out_version : in_version);
6975         }
6976     }
6977
6978   return TRUE;
6979 }
6980
6981 /* Display the flags field.  */
6982
6983 static bfd_boolean
6984 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6985 {
6986   FILE *file = (FILE *) ptr;
6987
6988   BFD_ASSERT (abfd != NULL && ptr != NULL);
6989
6990   _bfd_elf_print_private_bfd_data (abfd, ptr);
6991
6992   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6993
6994   switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6995     {
6996     default:
6997     case E_N1_ARCH:
6998       fprintf (file, _(": n1 instructions"));
6999       break;
7000     case E_N1H_ARCH:
7001       fprintf (file, _(": n1h instructions"));
7002       break;
7003     }
7004
7005   fputc ('\n', file);
7006
7007   return TRUE;
7008 }
7009
7010 static unsigned int
7011 nds32_elf_action_discarded (asection *sec)
7012 {
7013
7014   if (strncmp
7015       (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
7016     return 0;
7017
7018   return _bfd_elf_default_action_discarded (sec);
7019 }
7020
7021 static asection *
7022 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
7023                         Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
7024                         Elf_Internal_Sym *sym)
7025 {
7026   if (h != NULL)
7027     switch (ELF32_R_TYPE (rel->r_info))
7028       {
7029       case R_NDS32_GNU_VTINHERIT:
7030       case R_NDS32_GNU_VTENTRY:
7031       case R_NDS32_RELA_GNU_VTINHERIT:
7032       case R_NDS32_RELA_GNU_VTENTRY:
7033         return NULL;
7034       }
7035
7036   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
7037 }
7038
7039 static enum elf_nds32_tls_type
7040 get_tls_type (enum elf_nds32_reloc_type r_type,
7041               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7042 {
7043   enum elf_nds32_tls_type tls_type;
7044
7045   switch (r_type)
7046     {
7047     case R_NDS32_TLS_LE_HI20:
7048     case R_NDS32_TLS_LE_LO12:
7049       tls_type = GOT_TLS_LE;
7050       break;
7051     case R_NDS32_TLS_IE_HI20:
7052     case R_NDS32_TLS_IE_LO12S2:
7053     case R_NDS32_TLS_IE_LO12:
7054       tls_type = GOT_TLS_IE;
7055       break;
7056     case R_NDS32_TLS_IEGP_HI20:
7057     case R_NDS32_TLS_IEGP_LO12:
7058     case R_NDS32_TLS_IEGP_LO12S2:
7059       tls_type = GOT_TLS_IEGP;
7060       break;
7061     case R_NDS32_TLS_DESC_HI20:
7062     case R_NDS32_TLS_DESC_LO12:
7063     case R_NDS32_TLS_DESC_ADD:
7064     case R_NDS32_TLS_DESC_FUNC:
7065     case R_NDS32_TLS_DESC_CALL:
7066       tls_type = GOT_TLS_DESC;
7067       break;
7068     default:
7069       tls_type = GOT_NORMAL;
7070       break;
7071     }
7072
7073   return tls_type;
7074 }
7075
7076 /* Ensure that we have allocated bookkeeping structures for ABFD's local
7077    symbols.  */
7078
7079 static bfd_boolean
7080 elf32_nds32_allocate_local_sym_info (bfd *abfd)
7081 {
7082   if (elf_local_got_refcounts (abfd) == NULL)
7083     {
7084       bfd_size_type num_syms;
7085       bfd_size_type size;
7086       char *data;
7087
7088       num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
7089       /* This space is for got_refcounts, got_tls_type, tlsdesc_gotent, and
7090          gp_offset.  The details can refer to struct elf_nds32_obj_tdata.  */
7091       size = num_syms * (sizeof (bfd_signed_vma) + sizeof (char)
7092                          + sizeof (bfd_vma) + sizeof (int)
7093                          + sizeof (bfd_boolean) + sizeof (bfd_vma));
7094       data = bfd_zalloc (abfd, size);
7095       if (data == NULL)
7096         return FALSE;
7097
7098       elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data;
7099       data += num_syms * sizeof (bfd_signed_vma);
7100
7101       elf32_nds32_local_got_tls_type (abfd) = (char *) data;
7102       data += num_syms * sizeof (char);
7103
7104       elf32_nds32_local_tlsdesc_gotent (abfd) = (bfd_vma *) data;
7105       data += num_syms * sizeof (bfd_vma);
7106
7107       elf32_nds32_local_gp_offset (abfd) = (int *) data;
7108       data += num_syms * sizeof (int);
7109     }
7110
7111   return TRUE;
7112 }
7113
7114 /* Look through the relocs for a section during the first phase.
7115    Since we don't do .gots or .plts, we just need to consider the
7116    virtual table relocs for gc.  */
7117
7118 static bfd_boolean
7119 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7120                         asection *sec, const Elf_Internal_Rela *relocs)
7121 {
7122   Elf_Internal_Shdr *symtab_hdr;
7123   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
7124   const Elf_Internal_Rela *rel;
7125   const Elf_Internal_Rela *rel_end;
7126   struct elf_link_hash_table *ehtab;
7127   struct elf_nds32_link_hash_table *htab;
7128   bfd *dynobj;
7129   asection *sreloc = NULL;
7130
7131   /* No need for relocation if relocatable already.  */
7132   if (bfd_link_relocatable (info))
7133     {
7134       elf32_nds32_check_relax_group (abfd, sec);
7135       return TRUE;
7136     }
7137
7138   /* Don't do anything special with non-loaded, non-alloced sections.
7139      In particular, any relocs in such sections should not affect GOT
7140      and PLT reference counting (ie. we don't allow them to create GOT
7141      or PLT entries), there's no possibility or desire to optimize TLS
7142      relocs, and there's not much point in propagating relocs to shared
7143      libs that the dynamic linker won't relocate.  */
7144   if ((sec->flags & SEC_ALLOC) == 0)
7145     return TRUE;
7146
7147   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7148   sym_hashes = elf_sym_hashes (abfd);
7149   sym_hashes_end =
7150     sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
7151   if (!elf_bad_symtab (abfd))
7152     sym_hashes_end -= symtab_hdr->sh_info;
7153
7154   ehtab = elf_hash_table (info);
7155   htab = nds32_elf_hash_table (info);
7156   dynobj = htab->root.dynobj;
7157
7158   rel_end = relocs + sec->reloc_count;
7159   for (rel = relocs; rel < rel_end; rel++)
7160     {
7161       enum elf_nds32_reloc_type r_type;
7162       struct elf_link_hash_entry *h;
7163       unsigned long r_symndx;
7164       enum elf_nds32_tls_type tls_type, old_tls_type;
7165
7166       r_symndx = ELF32_R_SYM (rel->r_info);
7167       r_type = ELF32_R_TYPE (rel->r_info);
7168       if (r_symndx < symtab_hdr->sh_info)
7169         h = NULL;
7170       else
7171         {
7172           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7173           while (h->root.type == bfd_link_hash_indirect
7174                  || h->root.type == bfd_link_hash_warning)
7175             h = (struct elf_link_hash_entry *) h->root.u.i.link;
7176         }
7177
7178       /* Create .got section if necessary.
7179          Some relocs require a global offset table.  We create
7180          got section here, since these relocation need a got section
7181          and if it is not created yet.  */
7182       if (ehtab->sgot == NULL)
7183         {
7184           switch (r_type)
7185             {
7186             case R_NDS32_GOT_HI20:
7187             case R_NDS32_GOT_LO12:
7188             case R_NDS32_GOT_LO15:
7189             case R_NDS32_GOT_LO19:
7190             case R_NDS32_GOT17S2_RELA:
7191             case R_NDS32_GOT15S2_RELA:
7192             case R_NDS32_GOTOFF:
7193             case R_NDS32_GOTOFF_HI20:
7194             case R_NDS32_GOTOFF_LO12:
7195             case R_NDS32_GOTOFF_LO15:
7196             case R_NDS32_GOTOFF_LO19:
7197             case R_NDS32_GOTPC20:
7198             case R_NDS32_GOTPC_HI20:
7199             case R_NDS32_GOTPC_LO12:
7200             case R_NDS32_GOT20:
7201             case R_NDS32_TLS_IE_HI20:
7202             case R_NDS32_TLS_IE_LO12:
7203             case R_NDS32_TLS_IE_LO12S2:
7204             case R_NDS32_TLS_IEGP_HI20:
7205             case R_NDS32_TLS_IEGP_LO12:
7206             case R_NDS32_TLS_IEGP_LO12S2:
7207             case R_NDS32_TLS_DESC_HI20:
7208             case R_NDS32_TLS_DESC_LO12:
7209               if (dynobj == NULL)
7210                 htab->root.dynobj = dynobj = abfd;
7211               if (!create_got_section (dynobj, info))
7212                 return FALSE;
7213               break;
7214
7215             default:
7216               break;
7217             }
7218         }
7219
7220       /* Check relocation type.  */
7221       switch ((int) r_type)
7222         {
7223         case R_NDS32_GOT_HI20:
7224         case R_NDS32_GOT_LO12:
7225         case R_NDS32_GOT_LO15:
7226         case R_NDS32_GOT_LO19:
7227         case R_NDS32_GOT20:
7228         case R_NDS32_TLS_LE_HI20:
7229         case R_NDS32_TLS_LE_LO12:
7230         case R_NDS32_TLS_IE_HI20:
7231         case R_NDS32_TLS_IE_LO12:
7232         case R_NDS32_TLS_IE_LO12S2:
7233         case R_NDS32_TLS_IEGP_HI20:
7234         case R_NDS32_TLS_IEGP_LO12:
7235         case R_NDS32_TLS_IEGP_LO12S2:
7236         case R_NDS32_TLS_DESC_HI20:
7237         case R_NDS32_TLS_DESC_LO12:
7238           tls_type = get_tls_type (r_type, h);
7239           if (h)
7240             {
7241               if (tls_type != GOT_TLS_LE)
7242                 h->got.refcount += 1;
7243               old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
7244             }
7245           else
7246             {
7247               /* This is a global offset table entry for a local symbol.  */
7248               if (!elf32_nds32_allocate_local_sym_info (abfd))
7249                 return FALSE;
7250
7251               BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7252               if (tls_type != GOT_TLS_LE)
7253                 elf_local_got_refcounts (abfd)[r_symndx] += 1;
7254               old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
7255             }
7256
7257           /* We would already have issued an error message if there
7258              is a TLS/non-TLS mismatch, based on the symbol
7259              type.  So just combine any TLS types needed.  */
7260           if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
7261               && tls_type != GOT_NORMAL)
7262             tls_type |= old_tls_type;
7263
7264           /* DESC to IE/IEGP if link to executable.  */
7265           if ((tls_type & (GOT_TLS_DESC | GOT_TLS_IEGP))
7266               && (bfd_link_executable (info)))
7267             tls_type |= (bfd_link_pie (info) ? GOT_TLS_IEGP : GOT_TLS_IE);
7268
7269           if (old_tls_type != tls_type)
7270             {
7271               if (h != NULL)
7272                 elf32_nds32_hash_entry (h)->tls_type = tls_type;
7273               else
7274                 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
7275             }
7276           break;
7277         case R_NDS32_9_PLTREL:
7278         case R_NDS32_25_PLTREL:
7279         case R_NDS32_PLTREL_HI20:
7280         case R_NDS32_PLTREL_LO12:
7281         case R_NDS32_PLT_GOTREL_HI20:
7282         case R_NDS32_PLT_GOTREL_LO12:
7283         case R_NDS32_PLT_GOTREL_LO15:
7284         case R_NDS32_PLT_GOTREL_LO19:
7285         case R_NDS32_PLT_GOTREL_LO20:
7286
7287           /* This symbol requires a procedure linkage table entry.  We
7288              actually build the entry in adjust_dynamic_symbol,
7289              because this might be a case of linking PIC code without
7290              linking in any dynamic objects, in which case we don't
7291              need to generate a procedure linkage table after all.  */
7292
7293           /* If this is a local symbol, we resolve it directly without
7294              creating a procedure linkage table entry.  */
7295           if (h == NULL)
7296             continue;
7297
7298           if (h->forced_local
7299               || (bfd_link_pie (info) && h->def_regular))
7300             break;
7301
7302           elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
7303           h->needs_plt = 1;
7304           h->plt.refcount += 1;
7305           break;
7306
7307         case R_NDS32_16_RELA:
7308         case R_NDS32_20_RELA:
7309         case R_NDS32_5_RELA:
7310         case R_NDS32_32_RELA:
7311         case R_NDS32_HI20_RELA:
7312         case R_NDS32_LO12S3_RELA:
7313         case R_NDS32_LO12S2_RELA:
7314         case R_NDS32_LO12S2_DP_RELA:
7315         case R_NDS32_LO12S2_SP_RELA:
7316         case R_NDS32_LO12S1_RELA:
7317         case R_NDS32_LO12S0_RELA:
7318         case R_NDS32_LO12S0_ORI_RELA:
7319         case R_NDS32_SDA16S3_RELA:
7320         case R_NDS32_SDA17S2_RELA:
7321         case R_NDS32_SDA18S1_RELA:
7322         case R_NDS32_SDA19S0_RELA:
7323         case R_NDS32_SDA15S3_RELA:
7324         case R_NDS32_SDA15S2_RELA:
7325         case R_NDS32_SDA12S2_DP_RELA:
7326         case R_NDS32_SDA12S2_SP_RELA:
7327         case R_NDS32_SDA15S1_RELA:
7328         case R_NDS32_SDA15S0_RELA:
7329         case R_NDS32_SDA_FP7U2_RELA:
7330         case R_NDS32_15_PCREL_RELA:
7331         case R_NDS32_17_PCREL_RELA:
7332         case R_NDS32_25_PCREL_RELA:
7333
7334           if (h != NULL && !bfd_link_pic (info))
7335             {
7336               h->non_got_ref = 1;
7337               h->plt.refcount += 1;
7338             }
7339
7340           /* If we are creating a shared library, and this is a reloc against
7341              a global symbol, or a non PC relative reloc against a local
7342              symbol, then we need to copy the reloc into the shared library.
7343              However, if we are linking with -Bsymbolic, we do not need to
7344              copy a reloc against a global symbol which is defined in an
7345              object we are including in the link (i.e., DEF_REGULAR is set).
7346              At this point we have not seen all the input files, so it is
7347              possible that DEF_REGULAR is not set now but will be set later
7348              (it is never cleared).  We account for that possibility below by
7349              storing information in the dyn_relocs field of the hash table
7350              entry.  A similar situation occurs when creating shared libraries
7351              and symbol visibility changes render the symbol local.
7352
7353              If on the other hand, we are creating an executable, we may need
7354              to keep relocations for symbols satisfied by a dynamic library
7355              if we manage to avoid copy relocs for the symbol.  */
7356           if ((bfd_link_pic (info)
7357                && (sec->flags & SEC_ALLOC) != 0
7358                && ((r_type != R_NDS32_25_PCREL_RELA
7359                     && r_type != R_NDS32_15_PCREL_RELA
7360                     && r_type != R_NDS32_17_PCREL_RELA
7361                     && !(r_type == R_NDS32_32_RELA
7362                          && strcmp (sec->name, ".eh_frame") == 0))
7363                    || (h != NULL
7364                        && (!info->symbolic
7365                            || h->root.type == bfd_link_hash_defweak
7366                            || !h->def_regular))))
7367               || (!bfd_link_pic (info)
7368                   && (sec->flags & SEC_ALLOC) != 0
7369                   && h != NULL
7370                   && (h->root.type == bfd_link_hash_defweak
7371                       || !h->def_regular)))
7372             {
7373               struct elf_dyn_relocs *p;
7374               struct elf_dyn_relocs **head;
7375
7376               if (dynobj == NULL)
7377                 htab->root.dynobj = dynobj = abfd;
7378
7379               /* When creating a shared object, we must copy these
7380                  relocs into the output file.  We create a reloc
7381                  section in dynobj and make room for the reloc.  */
7382               if (sreloc == NULL)
7383                 {
7384                   const char *name;
7385
7386                   name = bfd_elf_string_from_elf_section
7387                     (abfd, elf_elfheader (abfd)->e_shstrndx,
7388                      elf_section_data (sec)->rela.hdr->sh_name);
7389                   if (name == NULL)
7390                     return FALSE;
7391
7392                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
7393                               && strcmp (bfd_get_section_name (abfd, sec),
7394                                          name + 5) == 0);
7395
7396                   sreloc = bfd_get_section_by_name (dynobj, name);
7397                   if (sreloc == NULL)
7398                     {
7399                       flagword flags;
7400
7401                       sreloc = bfd_make_section (dynobj, name);
7402                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
7403                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
7404                       if ((sec->flags & SEC_ALLOC) != 0)
7405                         flags |= SEC_ALLOC | SEC_LOAD;
7406                       if (sreloc == NULL
7407                           || !bfd_set_section_flags (dynobj, sreloc, flags)
7408                           || !bfd_set_section_alignment (dynobj, sreloc, 2))
7409                         return FALSE;
7410
7411                       elf_section_type (sreloc) = SHT_RELA;
7412                     }
7413                   elf_section_data (sec)->sreloc = sreloc;
7414                 }
7415
7416               /* If this is a global symbol, we count the number of
7417                  relocations we need for this symbol.  */
7418               if (h != NULL)
7419                 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
7420               else
7421                 {
7422                   asection *s;
7423                   void *vpp;
7424
7425                   Elf_Internal_Sym *isym;
7426                   isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
7427                   if (isym == NULL)
7428                     return FALSE;
7429
7430                   /* Track dynamic relocs needed for local syms too.  */
7431                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
7432                   if (s == NULL)
7433                     return FALSE;
7434
7435                   vpp = &elf_section_data (s)->local_dynrel;
7436                   head = (struct elf_dyn_relocs **) vpp;
7437                 }
7438
7439               p = *head;
7440               if (p == NULL || p->sec != sec)
7441                 {
7442                   bfd_size_type amt = sizeof (*p);
7443                   p = (struct elf_dyn_relocs *) bfd_alloc (dynobj, amt);
7444                   if (p == NULL)
7445                     return FALSE;
7446                   p->next = *head;
7447                   *head = p;
7448                   p->sec = sec;
7449                   p->count = 0;
7450                   p->pc_count = 0;
7451                 }
7452
7453               p->count += 1;
7454
7455               /* Since eh_frame is readonly, R_NDS32_32_RELA
7456                  reloc for eh_frame will cause shared library has
7457                  TEXTREL entry in the dynamic section. This lead glibc
7458                  testsuites to failure (bug-13092) and cause kernel fail
7459                  (bug-11819).  I think the best solution is to replace
7460                  absolute reloc with pc relative reloc in the eh_frame.
7461                  To do that, we need to support the following issues:
7462
7463                  === For GCC ===
7464                  * gcc/config/nds32/nds32.h: Define
7465                  ASM_PREFERRED_EH_DATA_FORMAT to encode DW_EH_PE_pcrel
7466                  and DW_EH_PE_sdata4 into DWARF exception header when
7467                  option have '-fpic'.
7468
7469                  === For binutils ===
7470                  * bfd/: Define new reloc R_NDS32_32_PCREL_RELA.
7471                  * gas/config/tc-nds32.h: Define DIFF_EXPR_OK. This
7472                  may break our nds DIFF mechanism, therefore, we
7473                  must disable all linker relaxations to ensure
7474                  correctness.
7475                  * gas/config/tc-nds32.c (nds32_apply_fix): Replace
7476                  R_NDS32_32_RELA with R_NDS32_32_PCREL_RELA, and
7477                  do the necessary modification.
7478
7479                  Unfortunately, it still have some problems for nds32
7480                  to support pc relative reloc in the eh_frame. So I use
7481                  another solution to fix this issue.
7482
7483                  However, I find that ld always emit TEXTREL marker for
7484                  R_NDS32_NONE relocs in rel.dyn. These none relocs are
7485                  correspond to R_NDS32_32_RELA for .eh_frame section.
7486                  It means that we always reserve redundant entries of rel.dyn
7487                  for these relocs which actually do nothing in dynamic linker.
7488
7489                  Therefore, we regard these relocs as pc relative relocs
7490                  here and increase the pc_count.  */
7491               if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
7492                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
7493                   || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
7494                   || (r_type == R_NDS32_32_RELA
7495                       && strcmp (sec->name, ".eh_frame") == 0))
7496                 p->pc_count += 1;
7497             }
7498           break;
7499
7500           /* This relocation describes the C++ object vtable hierarchy.
7501              Reconstruct it for later use during GC.  */
7502         case R_NDS32_RELA_GNU_VTINHERIT:
7503         case R_NDS32_GNU_VTINHERIT:
7504           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7505             return FALSE;
7506           break;
7507
7508           /* This relocation describes which C++ vtable entries are actually
7509              used.  Record for later use during GC.  */
7510         case R_NDS32_GNU_VTENTRY:
7511           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7512             return FALSE;
7513           break;
7514         case R_NDS32_RELA_GNU_VTENTRY:
7515           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
7516             return FALSE;
7517           break;
7518         }
7519     }
7520
7521   return TRUE;
7522 }
7523
7524 /* Write VAL in uleb128 format to P, returning a pointer to the
7525    following byte.
7526    This code is copied from elf-attr.c.  */
7527
7528 static bfd_byte *
7529 write_uleb128 (bfd_byte *p, unsigned int val)
7530 {
7531   bfd_byte c;
7532   do
7533     {
7534       c = val & 0x7f;
7535       val >>= 7;
7536       if (val)
7537         c |= 0x80;
7538       *(p++) = c;
7539     }
7540   while (val);
7541   return p;
7542 }
7543
7544 static bfd_signed_vma
7545 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
7546                   Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
7547 {
7548   bfd_signed_vma foff;
7549   bfd_vma symval, addend;
7550   asection *sym_sec;
7551
7552   /* Get the value of the symbol referred to by the reloc.  */
7553   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
7554     {
7555       Elf_Internal_Sym *isym;
7556
7557       /* A local symbol.  */
7558       isym = isymbuf + ELF32_R_SYM (irel->r_info);
7559
7560       if (isym->st_shndx == SHN_UNDEF)
7561         sym_sec = bfd_und_section_ptr;
7562       else if (isym->st_shndx == SHN_ABS)
7563         sym_sec = bfd_abs_section_ptr;
7564       else if (isym->st_shndx == SHN_COMMON)
7565         sym_sec = bfd_com_section_ptr;
7566       else
7567         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
7568       symval = isym->st_value + sym_sec->output_section->vma
7569                + sym_sec->output_offset;
7570     }
7571   else
7572     {
7573       unsigned long indx;
7574       struct elf_link_hash_entry *h;
7575
7576       /* An external symbol.  */
7577       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
7578       h = elf_sym_hashes (abfd)[indx];
7579       BFD_ASSERT (h != NULL);
7580
7581       if (h->root.type != bfd_link_hash_defined
7582           && h->root.type != bfd_link_hash_defweak)
7583         /* This appears to be a reference to an undefined
7584            symbol.  Just ignore it--it will be caught by the
7585            regular reloc processing.  */
7586         return 0;
7587
7588       if (h->root.u.def.section->flags & SEC_MERGE)
7589         {
7590           sym_sec = h->root.u.def.section;
7591           symval = _bfd_merged_section_offset (abfd, &sym_sec,
7592                                                elf_section_data (sym_sec)->sec_info,
7593                                                h->root.u.def.value);
7594           symval = symval + sym_sec->output_section->vma
7595                    + sym_sec->output_offset;
7596         }
7597       else
7598         symval = (h->root.u.def.value
7599                   + h->root.u.def.section->output_section->vma
7600                   + h->root.u.def.section->output_offset);
7601     }
7602
7603   addend = irel->r_addend;
7604
7605   foff = (symval + addend
7606           - (irel->r_offset + sec->output_section->vma + sec->output_offset));
7607   return foff;
7608 }
7609 \f
7610
7611 /* Convert a 32-bit instruction to 16-bit one.
7612    INSN is the input 32-bit instruction, INSN16 is the output 16-bit
7613    instruction.  If INSN_TYPE is not NULL, it the CGEN instruction
7614    type of INSN16.  Return 1 if successful.  */
7615
7616 static int
7617 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7618                              int *pinsn_type)
7619 {
7620   uint16_t insn16 = 0;
7621   int insn_type = 0;
7622   unsigned long mach = bfd_get_mach (abfd);
7623
7624   if (N32_SH5 (insn) != 0)
7625     return 0;
7626
7627   switch (N32_SUB5 (insn))
7628     {
7629     case N32_ALU1_ADD_SLLI:
7630     case N32_ALU1_ADD_SRLI:
7631       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7632         {
7633           insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
7634                                 N32_RB5 (insn));
7635           insn_type = NDS32_INSN_ADD333;
7636         }
7637       else if (N32_IS_RT4 (insn))
7638         {
7639           if (N32_RT5 (insn) == N32_RA5 (insn))
7640             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
7641           else if (N32_RT5 (insn) == N32_RB5 (insn))
7642             insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
7643           insn_type = NDS32_INSN_ADD45;
7644         }
7645       break;
7646
7647     case N32_ALU1_SUB_SLLI:
7648     case N32_ALU1_SUB_SRLI:
7649       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7650         {
7651           insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
7652                                 N32_RB5 (insn));
7653           insn_type = NDS32_INSN_SUB333;
7654         }
7655       else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7656         {
7657           insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
7658           insn_type = NDS32_INSN_SUB45;
7659         }
7660       break;
7661
7662     case N32_ALU1_AND_SLLI:
7663     case N32_ALU1_AND_SRLI:
7664       /* and $rt, $rt, $rb -> and33 for v3, v3m.  */
7665       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7666           && N32_IS_RB3 (insn))
7667         {
7668           if (N32_RT5 (insn) == N32_RA5 (insn))
7669             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
7670           else if (N32_RT5 (insn) == N32_RB5 (insn))
7671             insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
7672           if (insn16)
7673             insn_type = NDS32_INSN_AND33;
7674         }
7675       break;
7676
7677     case N32_ALU1_XOR_SLLI:
7678     case N32_ALU1_XOR_SRLI:
7679       /* xor $rt, $rt, $rb -> xor33 for v3, v3m.  */
7680       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7681           && N32_IS_RB3 (insn))
7682         {
7683           if (N32_RT5 (insn) == N32_RA5 (insn))
7684             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
7685           else if (N32_RT5 (insn) == N32_RB5 (insn))
7686             insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
7687           if (insn16)
7688             insn_type = NDS32_INSN_XOR33;
7689         }
7690       break;
7691
7692     case N32_ALU1_OR_SLLI:
7693     case N32_ALU1_OR_SRLI:
7694       /* or $rt, $rt, $rb -> or33 for v3, v3m.  */
7695       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7696           && N32_IS_RB3 (insn))
7697         {
7698           if (N32_RT5 (insn) == N32_RA5 (insn))
7699             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
7700           else if (N32_RT5 (insn) == N32_RB5 (insn))
7701             insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
7702           if (insn16)
7703             insn_type = NDS32_INSN_OR33;
7704         }
7705       break;
7706     case N32_ALU1_NOR:
7707       /* nor $rt, $ra, $ra -> not33 for v3, v3m.  */
7708       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
7709           && N32_RA5 (insn) == N32_RB5 (insn))
7710         {
7711           insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
7712           insn_type = NDS32_INSN_NOT33;
7713         }
7714       break;
7715     case N32_ALU1_SRAI:
7716       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7717         {
7718           insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
7719           insn_type = NDS32_INSN_SRAI45;
7720         }
7721       break;
7722
7723     case N32_ALU1_SRLI:
7724       if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7725         {
7726           insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
7727           insn_type = NDS32_INSN_SRLI45;
7728         }
7729       break;
7730
7731     case N32_ALU1_SLLI:
7732       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
7733         {
7734           insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
7735                                 N32_UB5 (insn));
7736           insn_type = NDS32_INSN_SLLI333;
7737         }
7738       break;
7739
7740     case N32_ALU1_ZEH:
7741       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7742         {
7743           insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
7744           insn_type = NDS32_INSN_ZEH33;
7745         }
7746       break;
7747
7748     case N32_ALU1_SEB:
7749       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7750         {
7751           insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
7752           insn_type = NDS32_INSN_SEB33;
7753         }
7754       break;
7755
7756     case N32_ALU1_SEH:
7757       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7758         {
7759           insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
7760           insn_type = NDS32_INSN_SEH33;
7761         }
7762       break;
7763
7764     case N32_ALU1_SLT:
7765       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7766         {
7767           /* Implicit r15.  */
7768           insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7769           insn_type = NDS32_INSN_SLT45;
7770         }
7771       break;
7772
7773     case N32_ALU1_SLTS:
7774       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7775         {
7776           /* Implicit r15.  */
7777           insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7778           insn_type = NDS32_INSN_SLTS45;
7779         }
7780       break;
7781     }
7782
7783   if ((insn16 & 0x8000) == 0)
7784     return 0;
7785
7786   if (pinsn16)
7787     *pinsn16 = insn16;
7788   if (pinsn_type)
7789     *pinsn_type = insn_type;
7790   return 1;
7791 }
7792
7793 static int
7794 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7795                              int *pinsn_type)
7796 {
7797   uint16_t insn16 = 0;
7798   int insn_type;
7799   unsigned long mach = bfd_get_mach (abfd);
7800
7801   /* TODO: bset, bclr, btgl, btst.  */
7802   if (__GF (insn, 6, 4) != 0)
7803     return 0;
7804
7805   switch (N32_IMMU (insn, 6))
7806     {
7807     case N32_ALU2_MUL:
7808       if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7809           && N32_IS_RB3 (insn))
7810         {
7811           if (N32_RT5 (insn) == N32_RA5 (insn))
7812             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7813           else if (N32_RT5 (insn) == N32_RB5 (insn))
7814             insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7815           if (insn16)
7816             insn_type = NDS32_INSN_MUL33;
7817         }
7818     }
7819
7820   if ((insn16 & 0x8000) == 0)
7821     return 0;
7822
7823   if (pinsn16)
7824     *pinsn16 = insn16;
7825   if (pinsn_type)
7826     *pinsn_type = insn_type;
7827   return 1;
7828 }
7829
7830 int
7831 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7832                         int *pinsn_type)
7833 {
7834   int op6;
7835   uint16_t insn16 = 0;
7836   int insn_type = 0;
7837   unsigned long mach = bfd_get_mach (abfd);
7838
7839   /* Decode 32-bit instruction.  */
7840   if (insn & 0x80000000)
7841     {
7842       /* Not 32-bit insn.  */
7843       return 0;
7844     }
7845
7846   op6 = N32_OP6 (insn);
7847
7848   /* Convert it to 16-bit instruction.  */
7849   switch (op6)
7850     {
7851     case N32_OP6_MOVI:
7852       if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7853         {
7854           insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7855           insn_type = NDS32_INSN_MOVI55;
7856         }
7857       else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7858                && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7859         {
7860           insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7861                                N32_IMM20S (insn) - 16);
7862           insn_type = NDS32_INSN_MOVPI45;
7863         }
7864       break;
7865
7866     case N32_OP6_ADDI:
7867       if (N32_IMM15S (insn) == 0)
7868         {
7869           /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7870              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
7871           if (mach <= MACH_V2
7872               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7873             {
7874               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7875               insn_type = NDS32_INSN_MOV55;
7876             }
7877         }
7878       else if (N32_IMM15S (insn) > 0)
7879         {
7880           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7881             {
7882               insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7883                                     N32_IMM15S (insn));
7884               insn_type = NDS32_INSN_ADDI333;
7885             }
7886           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7887                    && N32_IMM15S (insn) < 32)
7888             {
7889               insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7890               insn_type = NDS32_INSN_ADDI45;
7891             }
7892           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7893                    && N32_RT5 (insn) == N32_RA5 (insn)
7894                    && N32_IMM15S (insn) < 512)
7895             {
7896               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7897               insn_type = NDS32_INSN_ADDI10_SP;
7898             }
7899           else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7900                    && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7901                    && (N32_IMM15S (insn) % 4 == 0))
7902             {
7903               insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7904                                    N32_IMM15S (insn) >> 2);
7905               insn_type = NDS32_INSN_ADDRI36_SP;
7906             }
7907         }
7908       else
7909         {
7910           /* Less than 0.  */
7911           if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7912             {
7913               insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7914                                     0 - N32_IMM15S (insn));
7915               insn_type = NDS32_INSN_SUBI333;
7916             }
7917           else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7918                    && N32_IMM15S (insn) > -32)
7919             {
7920               insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7921                                    0 - N32_IMM15S (insn));
7922               insn_type = NDS32_INSN_SUBI45;
7923             }
7924           else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7925                    && N32_RT5 (insn) == N32_RA5 (insn)
7926                    && N32_IMM15S (insn) >= -512)
7927             {
7928               insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7929               insn_type = NDS32_INSN_ADDI10_SP;
7930             }
7931         }
7932       break;
7933
7934     case N32_OP6_ORI:
7935       if (N32_IMM15S (insn) == 0)
7936         {
7937           /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7938              because `mov55 $sp, $sp' is ifret16 in V3 ISA.  */
7939           if (mach <= MACH_V2
7940               || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7941             {
7942               insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7943               insn_type = NDS32_INSN_MOV55;
7944             }
7945         }
7946       break;
7947
7948     case N32_OP6_SUBRI:
7949       if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7950           && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7951         {
7952           insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7953           insn_type = NDS32_INSN_NEG33;
7954         }
7955       break;
7956
7957     case N32_OP6_ANDI:
7958       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7959         {
7960           if (N32_IMM15U (insn) == 1)
7961             {
7962               insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7963               insn_type = NDS32_INSN_XLSB33;
7964             }
7965           else if (N32_IMM15U (insn) == 0x7ff)
7966             {
7967               insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7968               insn_type = NDS32_INSN_X11B33;
7969             }
7970           else if (N32_IMM15U (insn) == 0xff)
7971             {
7972               insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7973               insn_type = NDS32_INSN_ZEB33;
7974             }
7975           else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7976                    && N32_IMM15U (insn) < 256)
7977             {
7978               int imm15u = N32_IMM15U (insn);
7979
7980               if (__builtin_popcount (imm15u) == 1)
7981                 {
7982                   /* BMSKI33 */
7983                   int imm3u = __builtin_ctz (imm15u);
7984
7985                   insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7986                   insn_type = NDS32_INSN_BMSKI33;
7987                 }
7988               else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7989                 {
7990                   /* FEXTI33 */
7991                   int imm3u = __builtin_ctz (imm15u + 1) - 1;
7992
7993                   insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7994                   insn_type = NDS32_INSN_FEXTI33;
7995                 }
7996             }
7997         }
7998       break;
7999
8000     case N32_OP6_SLTI:
8001       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8002           && IS_WITHIN_U (N32_IMM15S (insn), 5))
8003         {
8004           insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
8005           insn_type = NDS32_INSN_SLTI45;
8006         }
8007       break;
8008
8009     case N32_OP6_SLTSI:
8010       if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8011           && IS_WITHIN_U (N32_IMM15S (insn), 5))
8012         {
8013           insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
8014           insn_type = NDS32_INSN_SLTSI45;
8015         }
8016       break;
8017
8018     case N32_OP6_LWI:
8019       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8020         {
8021           insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
8022           insn_type = NDS32_INSN_LWI450;
8023         }
8024       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8025                && IS_WITHIN_U (N32_IMM15S (insn), 3))
8026         {
8027           insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
8028                                 N32_IMM15S (insn));
8029           insn_type = NDS32_INSN_LWI333;
8030         }
8031       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8032                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8033         {
8034           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8035           insn_type = NDS32_INSN_LWI37;
8036         }
8037       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8038                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8039         {
8040           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
8041           insn_type = NDS32_INSN_LWI37_SP;
8042         }
8043       else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
8044                && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
8045         {
8046           insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
8047                                N32_IMM15S (insn) + 32);
8048           insn_type = NDS32_INSN_LWI45_FE;
8049         }
8050       break;
8051
8052     case N32_OP6_SWI:
8053       if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8054         {
8055           insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
8056           insn_type = NDS32_INSN_SWI450;
8057         }
8058       else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8059                && IS_WITHIN_U (N32_IMM15S (insn), 3))
8060         {
8061           insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
8062                                 N32_IMM15S (insn));
8063           insn_type = NDS32_INSN_SWI333;
8064         }
8065       else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8066                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8067         {
8068           insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8069           insn_type = NDS32_INSN_SWI37;
8070         }
8071       else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8072                && IS_WITHIN_U (N32_IMM15S (insn), 7))
8073         {
8074           insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
8075           insn_type = NDS32_INSN_SWI37_SP;
8076         }
8077       break;
8078
8079     case N32_OP6_LWI_BI:
8080       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8081           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8082         {
8083           insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8084                                 N32_IMM15S (insn));
8085           insn_type = NDS32_INSN_LWI333_BI;
8086         }
8087       break;
8088
8089     case N32_OP6_SWI_BI:
8090       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8091           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8092         {
8093           insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8094                                 N32_IMM15S (insn));
8095           insn_type = NDS32_INSN_SWI333_BI;
8096         }
8097       break;
8098
8099     case N32_OP6_LHI:
8100       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8101           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8102         {
8103           insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
8104                                 N32_IMM15S (insn));
8105           insn_type = NDS32_INSN_LHI333;
8106         }
8107       break;
8108
8109     case N32_OP6_SHI:
8110       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8111           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8112         {
8113           insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
8114                                 N32_IMM15S (insn));
8115           insn_type = NDS32_INSN_SHI333;
8116         }
8117       break;
8118
8119     case N32_OP6_LBI:
8120       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8121           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8122         {
8123           insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
8124                                 N32_IMM15S (insn));
8125           insn_type = NDS32_INSN_LBI333;
8126         }
8127       break;
8128
8129     case N32_OP6_SBI:
8130       if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8131           && IS_WITHIN_U (N32_IMM15S (insn), 3))
8132         {
8133           insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
8134                                 N32_IMM15S (insn));
8135           insn_type = NDS32_INSN_SBI333;
8136         }
8137       break;
8138
8139     case N32_OP6_ALU1:
8140       return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
8141
8142     case N32_OP6_ALU2:
8143       return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
8144
8145     case N32_OP6_BR1:
8146       if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
8147         goto done;
8148
8149       if ((insn & N32_BIT (14)) == 0)
8150         {
8151           /* N32_BR1_BEQ */
8152           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8153               && N32_RT5 (insn) != REG_R5)
8154             insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
8155           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8156                    && N32_RA5 (insn) != REG_R5)
8157             insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
8158           insn_type = NDS32_INSN_BEQS38;
8159           break;
8160         }
8161       else
8162         {
8163           /* N32_BR1_BNE */
8164           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8165               && N32_RT5 (insn) != REG_R5)
8166             insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
8167           else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8168                    && N32_RA5 (insn) != REG_R5)
8169             insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
8170           insn_type = NDS32_INSN_BNES38;
8171           break;
8172         }
8173       break;
8174
8175     case N32_OP6_BR2:
8176       switch (N32_BR2_SUB (insn))
8177         {
8178         case N32_BR2_BEQZ:
8179           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8180             {
8181               insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
8182               insn_type = NDS32_INSN_BEQZ38;
8183             }
8184           else if (N32_RT5 (insn) == REG_R15
8185                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
8186             {
8187               insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
8188               insn_type = NDS32_INSN_BEQZS8;
8189             }
8190           break;
8191
8192         case N32_BR2_BNEZ:
8193           if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8194             {
8195               insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
8196               insn_type = NDS32_INSN_BNEZ38;
8197             }
8198           else if (N32_RT5 (insn) == REG_R15
8199                    && IS_WITHIN_S (N32_IMM16S (insn), 8))
8200             {
8201               insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
8202               insn_type = NDS32_INSN_BNEZS8;
8203             }
8204           break;
8205
8206         case N32_BR2_SOP0:
8207           if (__GF (insn, 20, 5) == 0 && IS_WITHIN_U (N32_IMM16S (insn), 9))
8208             {
8209               insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
8210               insn_type = NDS32_INSN_IFCALL9;
8211             }
8212           break;
8213         }
8214       break;
8215
8216     case N32_OP6_JI:
8217       if ((insn & N32_BIT (24)) == 0)
8218         {
8219           /* N32_JI_J */
8220           if (IS_WITHIN_S (N32_IMM24S (insn), 8))
8221             {
8222               insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
8223               insn_type = NDS32_INSN_J8;
8224             }
8225         }
8226       break;
8227
8228     case N32_OP6_JREG:
8229       if (__GF (insn, 8, 2) != 0)
8230         goto done;
8231
8232       switch (N32_IMMU (insn, 5))
8233         {
8234         case N32_JREG_JR:
8235           if (N32_JREG_HINT (insn) == 0)
8236             {
8237               /* jr */
8238               insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
8239               insn_type = NDS32_INSN_JR5;
8240             }
8241           else if (N32_JREG_HINT (insn) == 1)
8242             {
8243               /* ret */
8244               insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
8245               insn_type = NDS32_INSN_RET5;
8246             }
8247           else if (N32_JREG_HINT (insn) == 3)
8248             {
8249               /* ifret = mov55 $sp, $sp */
8250               insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
8251               insn_type = NDS32_INSN_IFRET;
8252             }
8253           break;
8254
8255         case N32_JREG_JRAL:
8256           /* It's convertible when return rt5 is $lp and address
8257              translation is kept.  */
8258           if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
8259             {
8260               insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
8261               insn_type = NDS32_INSN_JRAL5;
8262             }
8263           break;
8264         }
8265       break;
8266
8267     case N32_OP6_MISC:
8268       if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
8269         {
8270           /* For v3, swid above 31 are used for ex9.it.  */
8271           insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
8272           insn_type = NDS32_INSN_BREAK16;
8273         }
8274       break;
8275
8276     default:
8277       /* This instruction has no 16-bit variant.  */
8278       goto done;
8279     }
8280
8281 done:
8282   /* Bit-15 of insn16 should be set for a valid instruction.  */
8283   if ((insn16 & 0x8000) == 0)
8284     return 0;
8285
8286   if (pinsn16)
8287     *pinsn16 = insn16;
8288   if (pinsn_type)
8289     *pinsn_type = insn_type;
8290   return 1;
8291 }
8292
8293 static int
8294 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
8295                           Elf_Internal_Rela *reloc)
8296 {
8297   uint16_t insn16 = 0;
8298
8299   if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
8300       || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
8301     return 0;
8302
8303   if (!N32_IS_RT3 (insn))
8304     return 0;
8305
8306   switch (N32_OP6 (insn))
8307     {
8308     case N32_OP6_LWI:
8309       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8310         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8311       break;
8312     case N32_OP6_SWI:
8313       if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8314         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8315       break;
8316     case N32_OP6_HWGP:
8317       if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
8318         break;
8319
8320       if (__GF (insn, 17, 3) == 6)
8321         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
8322       else if (__GF (insn, 17, 3) == 7)
8323         insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
8324       break;
8325     }
8326
8327   if ((insn16 & 0x8000) == 0)
8328     return 0;
8329
8330   *pinsn16 = insn16;
8331   return 1;
8332 }
8333
8334 /* Convert a 16-bit instruction to 32-bit one.
8335    INSN16 it the input and PINSN it the point to output.
8336    Return non-zero on successful.  Otherwise 0 is returned.  */
8337
8338 int
8339 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
8340 {
8341   uint32_t insn = 0xffffffff;
8342   unsigned long mach = bfd_get_mach (abfd);
8343
8344   /* NOTE: push25, pop25 and movd44 do not have 32-bit variants.  */
8345
8346   switch (__GF (insn16, 9, 6))
8347     {
8348     case 0x4:                   /* add45 */
8349       insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
8350                        N16_RA5 (insn16));
8351       goto done;
8352     case 0x5:                   /* sub45 */
8353       insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
8354                        N16_RA5 (insn16));
8355       goto done;
8356     case 0x6:                   /* addi45 */
8357       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8358                         N16_IMM5U (insn16));
8359       goto done;
8360     case 0x7:                   /* subi45 */
8361       insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8362                         -N16_IMM5U (insn16));
8363       goto done;
8364     case 0x8:                   /* srai45 */
8365       insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
8366                        N16_IMM5U (insn16));
8367       goto done;
8368     case 0x9:                   /* srli45 */
8369       insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
8370                        N16_IMM5U (insn16));
8371       goto done;
8372     case 0xa:                   /* slli333 */
8373       insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
8374                        N16_IMM3U (insn16));
8375       goto done;
8376     case 0xc:                   /* add333 */
8377       insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
8378                        N16_RB3 (insn16));
8379       goto done;
8380     case 0xd:                   /* sub333 */
8381       insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
8382                        N16_RB3 (insn16));
8383       goto done;
8384     case 0xe:                   /* addi333 */
8385       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8386                         N16_IMM3U (insn16));
8387       goto done;
8388     case 0xf:                   /* subi333 */
8389       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8390                         -N16_IMM3U (insn16));
8391       goto done;
8392     case 0x10:                  /* lwi333 */
8393       insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
8394                         N16_IMM3U (insn16));
8395       goto done;
8396     case 0x12:                  /* lhi333 */
8397       insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
8398                         N16_IMM3U (insn16));
8399       goto done;
8400     case 0x13:                  /* lbi333 */
8401       insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
8402                         N16_IMM3U (insn16));
8403       goto done;
8404     case 0x11:                  /* lwi333.bi */
8405       insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8406                         N16_IMM3U (insn16));
8407       goto done;
8408     case 0x14:                  /* swi333 */
8409       insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
8410                         N16_IMM3U (insn16));
8411       goto done;
8412     case 0x16:                  /* shi333 */
8413       insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
8414                         N16_IMM3U (insn16));
8415       goto done;
8416     case 0x17:                  /* sbi333 */
8417       insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
8418                         N16_IMM3U (insn16));
8419       goto done;
8420     case 0x15:                  /* swi333.bi */
8421       insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8422                         N16_IMM3U (insn16));
8423       goto done;
8424     case 0x18:                  /* addri36.sp */
8425       insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
8426                         N16_IMM6U (insn16) << 2);
8427       goto done;
8428     case 0x19:                  /* lwi45.fe */
8429       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
8430                         (N16_IMM5U (insn16) - 32));
8431       goto done;
8432     case 0x1a:                  /* lwi450 */
8433       insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8434       goto done;
8435     case 0x1b:                  /* swi450 */
8436       insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8437       goto done;
8438
8439       /* These are r15 implied instructions.  */
8440     case 0x30:                  /* slts45 */
8441       insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8442       goto done;
8443     case 0x31:                  /* slt45 */
8444       insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8445       goto done;
8446     case 0x32:                  /* sltsi45 */
8447       insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8448       goto done;
8449     case 0x33:                  /* slti45 */
8450       insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8451       goto done;
8452     case 0x34:                  /* beqzs8, bnezs8 */
8453       if (insn16 & N32_BIT (8))
8454         insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
8455       else
8456         insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
8457       goto done;
8458
8459     case 0x35:                  /* break16, ex9.it */
8460       /* Only consider range of v3 break16.  */
8461       insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
8462       goto done;
8463
8464     case 0x3c:                  /* ifcall9 */
8465       insn = N32_BR2 (SOP0, 0, N16_IMM9U (insn16));
8466       goto done;
8467     case 0x3d:                  /* movpi45 */
8468       insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
8469       goto done;
8470
8471     case 0x3f:                  /* MISC33 */
8472       switch (insn16 & 0x7)
8473         {
8474         case 2:                 /* neg33 */
8475           insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8476           break;
8477         case 3:                 /* not33 */
8478           insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
8479                            N16_RA3 (insn16));
8480           break;
8481         case 4:                 /* mul33 */
8482           insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
8483                            N16_RA3 (insn16));
8484           break;
8485         case 5:                 /* xor33 */
8486           insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
8487                            N16_RA3 (insn16));
8488           break;
8489         case 6:                 /* and33 */
8490           insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
8491                            N16_RA3 (insn16));
8492           break;
8493         case 7:                 /* or33 */
8494           insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
8495                            N16_RA3 (insn16));
8496           break;
8497         }
8498       goto done;
8499
8500     case 0xb:
8501       switch (insn16 & 0x7)
8502         {
8503         case 0:                 /* zeb33 */
8504           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
8505           break;
8506         case 1:                 /* zeh33 */
8507           insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8508           break;
8509         case 2:                 /* seb33 */
8510           insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8511           break;
8512         case 3:                 /* seh33 */
8513           insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8514           break;
8515         case 4:                 /* xlsb33 */
8516           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
8517           break;
8518         case 5:                 /* x11b33 */
8519           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
8520           break;
8521         case 6:                 /* bmski33 */
8522           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8523                             1 << __GF (insn16, 3, 3));
8524           break;
8525         case 7:                 /* fexti33 */
8526           insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8527                             (1 << (__GF (insn16, 3, 3) + 1)) - 1);
8528           break;
8529         }
8530       goto done;
8531     }
8532
8533   switch (__GF (insn16, 10, 5))
8534     {
8535     case 0x0:                   /* mov55 or ifret16 */
8536       if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
8537           && N16_RT5 (insn16) == N16_RA5 (insn16))
8538         insn = N32_JREG (JR, 0, 0, 0, 3);
8539       else
8540         insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
8541       goto done;
8542     case 0x1:                   /* movi55 */
8543       insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
8544       goto done;
8545     case 0x1b:                  /* addi10s (V2) */
8546       insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
8547       goto done;
8548     }
8549
8550   switch (__GF (insn16, 11, 4))
8551     {
8552     case 0x7:                   /* lwi37.fp/swi37.fp */
8553       if (insn16 & N32_BIT (7)) /* swi37.fp */
8554         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8555       else                      /* lwi37.fp */
8556         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8557       goto done;
8558     case 0x8:                   /* beqz38 */
8559       insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8560       goto done;
8561     case 0x9:                   /* bnez38 */
8562       insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8563       goto done;
8564     case 0xa:                   /* beqs38/j8, implied r5 */
8565       if (N16_RT38 (insn16) == 5)
8566         insn = N32_JI (J, N16_IMM8S (insn16));
8567       else
8568         insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8569       goto done;
8570     case 0xb:                   /* bnes38 and others.  */
8571       if (N16_RT38 (insn16) == 5)
8572         {
8573           switch (__GF (insn16, 5, 3))
8574             {
8575             case 0:             /* jr5 */
8576               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
8577               break;
8578             case 4:             /* ret5 */
8579               insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
8580               break;
8581             case 1:             /* jral5 */
8582               insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
8583               break;
8584             case 2:             /* ex9.it imm5 */
8585               /* ex9.it had no 32-bit variantl.  */
8586               break;
8587             case 5:             /* add5.pc */
8588               /* add5.pc had no 32-bit variantl.  */
8589               break;
8590             }
8591         }
8592       else                      /* bnes38 */
8593         insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8594       goto done;
8595     case 0xe:                   /* lwi37/swi37 */
8596       if (insn16 & (1 << 7))    /* swi37.sp */
8597         insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8598       else                      /* lwi37.sp */
8599         insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8600       goto done;
8601     }
8602
8603 done:
8604   if (insn & 0x80000000)
8605     return 0;
8606
8607   if (pinsn)
8608     *pinsn = insn;
8609   return 1;
8610 }
8611 \f
8612
8613 static bfd_boolean
8614 is_sda_access_insn (unsigned long insn)
8615 {
8616   switch (N32_OP6 (insn))
8617     {
8618     case N32_OP6_LWI:
8619     case N32_OP6_LHI:
8620     case N32_OP6_LHSI:
8621     case N32_OP6_LBI:
8622     case N32_OP6_LBSI:
8623     case N32_OP6_SWI:
8624     case N32_OP6_SHI:
8625     case N32_OP6_SBI:
8626     case N32_OP6_LWC:
8627     case N32_OP6_LDC:
8628     case N32_OP6_SWC:
8629     case N32_OP6_SDC:
8630       return TRUE;
8631     default:
8632       ;
8633     }
8634   return FALSE;
8635 }
8636
8637 static unsigned long
8638 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
8639 {
8640   uint32_t oinsn = 0;
8641
8642   switch (type)
8643     {
8644     case R_NDS32_GOT_LO12:
8645     case R_NDS32_GOTOFF_LO12:
8646     case R_NDS32_PLTREL_LO12:
8647     case R_NDS32_PLT_GOTREL_LO12:
8648     case R_NDS32_LO12S0_RELA:
8649       switch (N32_OP6 (insn))
8650         {
8651         case N32_OP6_LBI:
8652           /* lbi.gp */
8653           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
8654           break;
8655         case N32_OP6_LBSI:
8656           /* lbsi.gp */
8657           oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
8658           break;
8659         case N32_OP6_SBI:
8660           /* sbi.gp */
8661           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
8662           break;
8663         case N32_OP6_ORI:
8664           /* addi.gp */
8665           oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
8666           break;
8667         }
8668       break;
8669
8670     case R_NDS32_LO12S1_RELA:
8671       switch (N32_OP6 (insn))
8672         {
8673         case N32_OP6_LHI:
8674           /* lhi.gp */
8675           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
8676           break;
8677         case N32_OP6_LHSI:
8678           /* lhsi.gp */
8679           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
8680           break;
8681         case N32_OP6_SHI:
8682           /* shi.gp */
8683           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
8684           break;
8685         }
8686       break;
8687
8688     case R_NDS32_LO12S2_RELA:
8689       switch (N32_OP6 (insn))
8690         {
8691         case N32_OP6_LWI:
8692           /* lwi.gp */
8693           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
8694           break;
8695         case N32_OP6_SWI:
8696           /* swi.gp */
8697           oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
8698           break;
8699         }
8700       break;
8701
8702     case R_NDS32_LO12S2_DP_RELA:
8703     case R_NDS32_LO12S2_SP_RELA:
8704       oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
8705       break;
8706     }
8707
8708   if (oinsn)
8709     *pinsn = oinsn;
8710
8711   return oinsn != 0;
8712 }
8713
8714 /* Linker hasn't found the correct merge section for non-section symbol
8715    in relax time, this work is left to the function elf_link_input_bfd().
8716    So for non-section symbol, _bfd_merged_section_offset is also needed
8717    to find the correct symbol address.  */
8718
8719 static bfd_vma
8720 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
8721                           asection **psec, Elf_Internal_Rela *rel)
8722 {
8723   asection *sec = *psec;
8724   bfd_vma relocation;
8725
8726   relocation = (sec->output_section->vma
8727                 + sec->output_offset + sym->st_value);
8728   if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
8729     {
8730       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8731         rel->r_addend =
8732           _bfd_merged_section_offset (abfd, psec,
8733                                       elf_section_data (sec)->sec_info,
8734                                       sym->st_value + rel->r_addend);
8735       else
8736         rel->r_addend =
8737           _bfd_merged_section_offset (abfd, psec,
8738                                       elf_section_data (sec)->sec_info,
8739                                       sym->st_value) + rel->r_addend;
8740
8741       if (sec != *psec)
8742         {
8743           /* If we have changed the section, and our original section is
8744              marked with SEC_EXCLUDE, it means that the original
8745              SEC_MERGE section has been completely subsumed in some
8746              other SEC_MERGE section.  In this case, we need to leave
8747              some info around for --emit-relocs.  */
8748           if ((sec->flags & SEC_EXCLUDE) != 0)
8749             sec->kept_section = *psec;
8750           sec = *psec;
8751         }
8752       rel->r_addend -= relocation;
8753       rel->r_addend += sec->output_section->vma + sec->output_offset;
8754     }
8755   return relocation;
8756 }
8757
8758 static bfd_vma
8759 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
8760                           Elf_Internal_Sym *isymbuf,
8761                           Elf_Internal_Shdr *symtab_hdr)
8762 {
8763   bfd_signed_vma foff;
8764   bfd_vma symval, addend;
8765   Elf_Internal_Rela irel_fn;
8766   Elf_Internal_Sym *isym;
8767   asection *sym_sec;
8768
8769   /* Get the value of the symbol referred to by the reloc.  */
8770   if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8771     {
8772       /* A local symbol.  */
8773       isym = isymbuf + ELF32_R_SYM (irel->r_info);
8774
8775       if (isym->st_shndx == SHN_UNDEF)
8776         sym_sec = bfd_und_section_ptr;
8777       else if (isym->st_shndx == SHN_ABS)
8778         sym_sec = bfd_abs_section_ptr;
8779       else if (isym->st_shndx == SHN_COMMON)
8780         sym_sec = bfd_com_section_ptr;
8781       else
8782         sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8783       memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8784       symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8785       addend = irel_fn.r_addend;
8786     }
8787   else
8788     {
8789       unsigned long indx;
8790       struct elf_link_hash_entry *h;
8791
8792       /* An external symbol.  */
8793       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8794       h = elf_sym_hashes (abfd)[indx];
8795       BFD_ASSERT (h != NULL);
8796
8797       while (h->root.type == bfd_link_hash_indirect
8798              || h->root.type == bfd_link_hash_warning)
8799         h = (struct elf_link_hash_entry *) h->root.u.i.link;
8800
8801       if (h->root.type != bfd_link_hash_defined
8802           && h->root.type != bfd_link_hash_defweak)
8803         /* This appears to be a reference to an undefined
8804            symbol.  Just ignore it--it will be caught by the
8805            regular reloc processing.  */
8806         return 0;
8807
8808       if (h->root.u.def.section->flags & SEC_MERGE)
8809         {
8810           sym_sec = h->root.u.def.section;
8811           symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8812                                                (sym_sec)->sec_info, h->root.u.def.value);
8813           symval = symval + sym_sec->output_section->vma
8814                    + sym_sec->output_offset;
8815         }
8816       else
8817         symval = (h->root.u.def.value
8818                   + h->root.u.def.section->output_section->vma
8819                   + h->root.u.def.section->output_offset);
8820       addend = irel->r_addend;
8821     }
8822
8823   foff = symval + addend;
8824
8825   return foff;
8826 }
8827
8828 static int
8829 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8830               asection *sec, Elf_Internal_Rela *rel)
8831 {
8832   bfd_byte *contents;
8833   unsigned short insn16;
8834
8835   if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8836     return FALSE;
8837   contents = elf_section_data (sec)->this_hdr.contents;
8838   insn16 = bfd_getb16 (contents + rel->r_offset);
8839   if (insn16 == NDS32_NOP16)
8840     return TRUE;
8841   return FALSE;
8842 }
8843
8844 /* It checks whether the instruction could be converted to
8845    16-bit form and returns the converted one.
8846
8847    `internal_relocs' is supposed to be sorted.  */
8848
8849 static int
8850 is_convert_32_to_16 (bfd *abfd, asection *sec,
8851                      Elf_Internal_Rela *reloc,
8852                      Elf_Internal_Rela *internal_relocs,
8853                      Elf_Internal_Rela *irelend,
8854                      uint16_t *insn16)
8855 {
8856 #define NORMAL_32_TO_16 (1 << 0)
8857 #define SPECIAL_32_TO_16 (1 << 1)
8858   bfd_byte *contents = NULL;
8859   bfd_signed_vma off;
8860   bfd_vma mem_addr;
8861   uint32_t insn = 0;
8862   Elf_Internal_Rela *pc_rel;
8863   Elf_Internal_Shdr *symtab_hdr;
8864   Elf_Internal_Sym *isymbuf = NULL;
8865   int convert_type;
8866   bfd_vma offset;
8867
8868   if (reloc->r_offset + 4 > sec->size)
8869     return FALSE;
8870
8871   offset = reloc->r_offset;
8872
8873   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8874     return FALSE;
8875   insn = bfd_getb32 (contents + offset);
8876
8877   if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8878     convert_type = NORMAL_32_TO_16;
8879   else if (special_convert_32_to_16 (insn, insn16, reloc))
8880     convert_type = SPECIAL_32_TO_16;
8881   else
8882     return FALSE;
8883
8884   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8885   if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8886     return FALSE;
8887
8888   /* Find the first relocation of the same relocation-type,
8889      so we iteratie them forward.  */
8890   pc_rel = reloc;
8891   while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8892     pc_rel--;
8893
8894   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8895     {
8896       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8897           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8898           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8899           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8900         {
8901           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8902           if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8903               || off == 0)
8904             return FALSE;
8905           break;
8906         }
8907       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8908         {
8909           /* movi => movi55  */
8910           mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8911                                                symtab_hdr);
8912           /* mem_addr is unsigned, but the value should
8913              be between [-16, 15].  */
8914           if ((mem_addr + 0x10) >> 5)
8915             return FALSE;
8916           break;
8917         }
8918       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8919                || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8920         {
8921           /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8922              because it can be relaxed to addi for TLS_LE_ADD.  */
8923           return FALSE;
8924         }
8925       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8926                 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8927                && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8928                && convert_type == SPECIAL_32_TO_16)
8929         {
8930           /* fp-as-gp
8931              We've selected a best fp-base for this access, so we can
8932              always resolve it anyway.  Do nothing.  */
8933           break;
8934         }
8935       else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8936                 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8937                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8938                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8939                || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8940                    && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8941         {
8942           /* Prevent unresolved addi instruction translate
8943              to addi45 or addi333.  */
8944           return FALSE;
8945         }
8946       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8947         {
8948           off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8949           if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8950             return FALSE;
8951           break;
8952         }
8953     }
8954
8955   return TRUE;
8956 }
8957
8958 static void
8959 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8960                     Elf_Internal_Rela *reloc,
8961                     Elf_Internal_Rela *internal_relocs,
8962                     Elf_Internal_Rela *irelend,
8963                     unsigned short insn16)
8964 {
8965   Elf_Internal_Rela *pc_rel;
8966   bfd_vma offset;
8967
8968   offset = reloc->r_offset;
8969   bfd_putb16 (insn16, contents + offset);
8970   /* Find the first relocation of the same relocation-type,
8971      so we iteratie them forward.  */
8972   pc_rel = reloc;
8973   while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8974     pc_rel--;
8975
8976   for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8977     {
8978       if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8979           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8980           || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8981         {
8982           pc_rel->r_info =
8983             ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8984         }
8985       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8986         pc_rel->r_info =
8987           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8988       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8989         pc_rel->r_info =
8990           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8991       else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8992                || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8993         pc_rel->r_info =
8994           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8995       else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8996         pc_rel->r_info =
8997           ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8998     }
8999 }
9000
9001 /* Find a relocation of type specified by `reloc_type'
9002    of the same r_offset with reloc.
9003    If not found, return irelend.
9004
9005    Assuming relocations are sorted by r_offset,
9006    we find the relocation from `reloc' backward untill relocs,
9007    or find it from `reloc' forward untill irelend.  */
9008
9009 static Elf_Internal_Rela *
9010 find_relocs_at_address (Elf_Internal_Rela *reloc,
9011                         Elf_Internal_Rela *relocs,
9012                         Elf_Internal_Rela *irelend,
9013                         enum elf_nds32_reloc_type reloc_type)
9014 {
9015   Elf_Internal_Rela *rel_t;
9016
9017   /* Find backward.  */
9018   for (rel_t = reloc;
9019        rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
9020        rel_t--)
9021     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
9022       return rel_t;
9023
9024   /* We didn't find it backward.  Try find it forward.  */
9025   for (rel_t = reloc;
9026        rel_t < irelend && rel_t->r_offset == reloc->r_offset;
9027        rel_t++)
9028     if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
9029       return rel_t;
9030
9031   return irelend;
9032 }
9033
9034 /* Find a relocation of specified type and offset.
9035    `reloc' is just a refence point to find a relocation at specified offset.
9036    If not found, return irelend.
9037
9038    Assuming relocations are sorted by r_offset,
9039    we find the relocation from `reloc' backward untill relocs,
9040    or find it from `reloc' forward untill irelend.  */
9041
9042 static Elf_Internal_Rela *
9043 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
9044                              Elf_Internal_Rela *relocs,
9045                              Elf_Internal_Rela *irelend,
9046                              enum elf_nds32_reloc_type reloc_type,
9047                              bfd_vma offset_p)
9048 {
9049   Elf_Internal_Rela *rel_t = NULL;
9050
9051   /* First, we try to find a relocation of offset `offset_p',
9052      and then we use find_relocs_at_address to find specific type.  */
9053
9054   if (reloc->r_offset > offset_p)
9055     {
9056       /* Find backward.  */
9057       for (rel_t = reloc;
9058            rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
9059         /* Do nothing.  */;
9060     }
9061   else if (reloc->r_offset < offset_p)
9062     {
9063       /* Find forward.  */
9064       for (rel_t = reloc;
9065            rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
9066         /* Do nothing.  */;
9067     }
9068   else
9069     rel_t = reloc;
9070
9071   /* Not found?  */
9072   if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
9073     return irelend;
9074
9075   return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
9076 }
9077
9078 typedef struct nds32_elf_blank nds32_elf_blank_t;
9079 struct nds32_elf_blank
9080 {
9081   /* Where the blank begins.  */
9082   bfd_vma offset;
9083   /* The size of the blank.  */
9084   bfd_vma size;
9085   /* The accumulative size before this blank.  */
9086   bfd_vma total_size;
9087   nds32_elf_blank_t *next;
9088   nds32_elf_blank_t *prev;
9089 };
9090
9091 static nds32_elf_blank_t *blank_free_list = NULL;
9092
9093 static nds32_elf_blank_t *
9094 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
9095 {
9096   nds32_elf_blank_t *blank_t;
9097
9098   if (blank_free_list)
9099     {
9100       blank_t = blank_free_list;
9101       blank_free_list = blank_free_list->next;
9102     }
9103   else
9104     blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
9105
9106   if (blank_t == NULL)
9107     return NULL;
9108
9109   blank_t->offset = offset_p;
9110   blank_t->size = size_p;
9111   blank_t->total_size = 0;
9112   blank_t->next = NULL;
9113   blank_t->prev = NULL;
9114
9115   return blank_t;
9116 }
9117
9118 static void
9119 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
9120 {
9121   if (blank_free_list)
9122     {
9123       blank_free_list->prev = blank_p;
9124       blank_p->next = blank_free_list;
9125     }
9126   else
9127     blank_p->next = NULL;
9128
9129   blank_p->prev = NULL;
9130   blank_free_list = blank_p;
9131 }
9132
9133 static void
9134 clean_nds32_elf_blank (void)
9135 {
9136   nds32_elf_blank_t *blank_t;
9137
9138   while (blank_free_list)
9139     {
9140       blank_t = blank_free_list;
9141       blank_free_list = blank_free_list->next;
9142       free (blank_t);
9143     }
9144 }
9145
9146 static nds32_elf_blank_t *
9147 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
9148 {
9149   nds32_elf_blank_t *blank_t;
9150
9151   if (!blank_p)
9152     return NULL;
9153   blank_t = blank_p;
9154
9155   while (blank_t && addr < blank_t->offset)
9156     blank_t = blank_t->prev;
9157   while (blank_t && blank_t->next && addr >= blank_t->next->offset)
9158     blank_t = blank_t->next;
9159
9160   return blank_t;
9161 }
9162
9163 static bfd_vma
9164 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9165                            int overwrite)
9166 {
9167   nds32_elf_blank_t *blank_t;
9168
9169   blank_t = search_nds32_elf_blank (*blank_p, addr);
9170   if (!blank_t)
9171     return 0;
9172
9173   if (overwrite)
9174     *blank_p = blank_t;
9175
9176   if (addr < blank_t->offset + blank_t->size)
9177     return blank_t->total_size + (addr - blank_t->offset);
9178   else
9179     return blank_t->total_size + blank_t->size;
9180 }
9181
9182 static bfd_boolean
9183 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
9184 {
9185   nds32_elf_blank_t *blank_t, *blank_t2;
9186
9187   if (!*blank_p)
9188     {
9189       *blank_p = create_nds32_elf_blank (addr, len);
9190       return *blank_p ? TRUE : FALSE;
9191     }
9192
9193   blank_t = search_nds32_elf_blank (*blank_p, addr);
9194
9195   if (blank_t == NULL)
9196     {
9197       blank_t = create_nds32_elf_blank (addr, len);
9198       if (!blank_t)
9199         return FALSE;
9200       while ((*blank_p)->prev != NULL)
9201         *blank_p = (*blank_p)->prev;
9202       blank_t->next = *blank_p;
9203       (*blank_p)->prev = blank_t;
9204       (*blank_p) = blank_t;
9205       return TRUE;
9206     }
9207
9208   if (addr < blank_t->offset + blank_t->size)
9209     {
9210       /* Extend the origin blank.  */
9211       if (addr + len > blank_t->offset + blank_t->size)
9212         blank_t->size = addr + len - blank_t->offset;
9213     }
9214   else
9215     {
9216       blank_t2 = create_nds32_elf_blank (addr, len);
9217       if (!blank_t2)
9218         return FALSE;
9219       if (blank_t->next)
9220         {
9221           blank_t->next->prev = blank_t2;
9222           blank_t2->next = blank_t->next;
9223         }
9224       blank_t2->prev = blank_t;
9225       blank_t->next = blank_t2;
9226       *blank_p = blank_t2;
9227     }
9228
9229   return TRUE;
9230 }
9231
9232 static bfd_boolean
9233 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9234                                      bfd_vma len)
9235 {
9236   nds32_elf_blank_t *blank_t;
9237
9238   if (!insert_nds32_elf_blank (blank_p, addr, len))
9239     return FALSE;
9240
9241   blank_t = *blank_p;
9242
9243   if (!blank_t->prev)
9244     {
9245       blank_t->total_size = 0;
9246       blank_t = blank_t->next;
9247     }
9248
9249   while (blank_t)
9250     {
9251       blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
9252       blank_t = blank_t->next;
9253     }
9254
9255   return TRUE;
9256 }
9257
9258 static void
9259 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
9260 {
9261   nds32_elf_blank_t *blank_t;
9262   bfd_vma total_size = 0;
9263
9264   if (!blank_p)
9265     return;
9266
9267   blank_t = blank_p;
9268   while (blank_t->prev)
9269     blank_t = blank_t->prev;
9270   while (blank_t)
9271     {
9272       blank_t->total_size = total_size;
9273       total_size += blank_t->size;
9274       blank_t = blank_t->next;
9275     }
9276 }
9277
9278 static bfd_boolean
9279 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
9280                                nds32_elf_blank_t *blank_p)
9281 {
9282   Elf_Internal_Shdr *symtab_hdr;        /* Symbol table header of this bfd.  */
9283   Elf_Internal_Sym *isym = NULL;        /* Symbol table of this bfd.  */
9284   Elf_Internal_Sym *isymend;            /* Symbol entry iterator.  */
9285   unsigned int sec_shndx;               /* The section the be relaxed.  */
9286   bfd_byte *contents;                   /* Contents data of iterating section.  */
9287   Elf_Internal_Rela *internal_relocs;
9288   Elf_Internal_Rela *irel;
9289   Elf_Internal_Rela *irelend;
9290   struct elf_link_hash_entry **sym_hashes;
9291   struct elf_link_hash_entry **end_hashes;
9292   unsigned int symcount;
9293   asection *sect;
9294   nds32_elf_blank_t *blank_t;
9295   nds32_elf_blank_t *blank_t2;
9296   nds32_elf_blank_t *blank_head;
9297
9298   blank_head = blank_t = blank_p;
9299   while (blank_head->prev != NULL)
9300     blank_head = blank_head->prev;
9301   while (blank_t->next != NULL)
9302     blank_t = blank_t->next;
9303
9304   if (blank_t->offset + blank_t->size <= sec->size)
9305     {
9306       blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
9307       blank_t->next->prev = blank_t;
9308     }
9309   if (blank_head->offset > 0)
9310     {
9311       blank_head->prev = create_nds32_elf_blank (0, 0);
9312       blank_head->prev->next = blank_head;
9313       blank_head = blank_head->prev;
9314     }
9315
9316   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
9317
9318   /* The deletion must stop at the next ALIGN reloc for an alignment
9319      power larger than the number of bytes we are deleting.  */
9320
9321   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9322   if (!nds32_get_local_syms (abfd, sec, &isym))
9323     return FALSE;
9324
9325   if (isym == NULL)
9326     {
9327       isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9328                                    symtab_hdr->sh_info, 0, NULL, NULL, NULL);
9329       symtab_hdr->contents = (bfd_byte *) isym;
9330     }
9331
9332   if (isym == NULL || symtab_hdr->sh_info == 0)
9333     return FALSE;
9334
9335   blank_t = blank_head;
9336   calc_nds32_blank_total (blank_head);
9337
9338   for (sect = abfd->sections; sect != NULL; sect = sect->next)
9339     {
9340       /* Adjust all the relocs.  */
9341
9342       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
9343       internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
9344                                                    TRUE /* keep_memory */);
9345       irelend = internal_relocs + sect->reloc_count;
9346
9347       blank_t = blank_head;
9348       blank_t2 = blank_head;
9349
9350       if (!(sect->flags & SEC_RELOC))
9351         continue;
9352
9353       nds32_get_section_contents (abfd, sect, &contents, TRUE);
9354
9355       for (irel = internal_relocs; irel < irelend; irel++)
9356         {
9357           bfd_vma raddr;
9358
9359           if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
9360               && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
9361               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9362             {
9363               unsigned long val = 0;
9364               unsigned long mask;
9365               long before, between;
9366               long offset = 0;
9367
9368               switch (ELF32_R_TYPE (irel->r_info))
9369                 {
9370                 case R_NDS32_DIFF8:
9371                   offset = bfd_get_8 (abfd, contents + irel->r_offset);
9372                   break;
9373                 case R_NDS32_DIFF16:
9374                   offset = bfd_get_16 (abfd, contents + irel->r_offset);
9375                   break;
9376                 case R_NDS32_DIFF32:
9377                   val = bfd_get_32 (abfd, contents + irel->r_offset);
9378                   /* Get the signed bit and mask for the high part.  The
9379                      gcc will alarm when right shift 32-bit since the
9380                      type size of long may be 32-bit.  */
9381                   mask = 0 - (val >> 31);
9382                   if (mask)
9383                     offset = (val | (mask - 0xffffffff));
9384                   else
9385                     offset = val;
9386                   break;
9387                 default:
9388                   BFD_ASSERT (0);
9389                 }
9390
9391               /*                  DIFF value
9392                 0            |encoded in location|
9393                 |------------|-------------------|---------
9394                             sym+off(addend)
9395                 -- before ---| *****************
9396                 --------------------- between ---|
9397
9398                 We only care how much data are relax between DIFF,
9399                 marked as ***.  */
9400
9401               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9402               between = get_nds32_elf_blank_total (&blank_t,
9403                                                    irel->r_addend + offset, 0);
9404               if (between == before)
9405                 goto done_adjust_diff;
9406
9407               switch (ELF32_R_TYPE (irel->r_info))
9408                 {
9409                 case R_NDS32_DIFF8:
9410                   bfd_put_8 (abfd, offset - (between - before),
9411                              contents + irel->r_offset);
9412                   break;
9413                 case R_NDS32_DIFF16:
9414                   bfd_put_16 (abfd, offset - (between - before),
9415                               contents + irel->r_offset);
9416                   break;
9417                 case R_NDS32_DIFF32:
9418                   bfd_put_32 (abfd, offset - (between - before),
9419                               contents + irel->r_offset);
9420                   break;
9421                 }
9422             }
9423           else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
9424               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9425             {
9426               bfd_vma val = 0;
9427               unsigned int len = 0;
9428               unsigned long before, between;
9429               bfd_byte *endp, *p;
9430
9431               val = _bfd_read_unsigned_leb128 (abfd, contents + irel->r_offset,
9432                                                &len);
9433
9434               before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9435               between = get_nds32_elf_blank_total (&blank_t,
9436                                                    irel->r_addend + val, 0);
9437               if (between == before)
9438                 goto done_adjust_diff;
9439
9440               p = contents + irel->r_offset;
9441               endp = p + len -1;
9442               memset (p, 0x80, len);
9443               *(endp) = 0;
9444               p = write_uleb128 (p, val - (between - before)) - 1;
9445               if (p < endp)
9446                 *p |= 0x80;
9447             }
9448 done_adjust_diff:
9449
9450           if (sec == sect)
9451             {
9452               raddr = irel->r_offset;
9453               irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
9454                                                            irel->r_offset, 1);
9455
9456               if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
9457                 continue;
9458               if (blank_t2 && blank_t2->next
9459                   && (blank_t2->offset > raddr
9460                       || blank_t2->next->offset <= raddr))
9461                 _bfd_error_handler
9462                   (_("%pB: error: search_nds32_elf_blank reports wrong node"),
9463                    abfd);
9464
9465               /* Mark reloc in deleted portion as NONE.
9466                  For some relocs like R_NDS32_LABEL that doesn't modify the
9467                  content in the section.  R_NDS32_LABEL doesn't belong to the
9468                  instruction in the section, so we should preserve it.  */
9469               if (raddr >= blank_t2->offset
9470                   && raddr < blank_t2->offset + blank_t2->size
9471                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
9472                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
9473                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
9474                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
9475                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
9476                   && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
9477                 {
9478                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
9479                                                R_NDS32_NONE);
9480                   continue;
9481                 }
9482             }
9483
9484           if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
9485               || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
9486               || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
9487             continue;
9488
9489           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
9490               && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
9491               && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
9492             {
9493               if (irel->r_addend <= sec->size)
9494                 irel->r_addend -=
9495                   get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
9496             }
9497         }
9498     }
9499
9500   /* Adjust the local symbols defined in this section.  */
9501   blank_t = blank_head;
9502   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
9503     {
9504       if (isym->st_shndx == sec_shndx)
9505         {
9506           if (isym->st_value <= sec->size)
9507             {
9508               bfd_vma ahead;
9509               bfd_vma orig_addr = isym->st_value;
9510
9511               ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
9512               isym->st_value -= ahead;
9513
9514               /* Adjust function size.  */
9515               if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
9516                   && isym->st_size > 0)
9517                 isym->st_size -=
9518                   get_nds32_elf_blank_total
9519                   (&blank_t, orig_addr + isym->st_size, 0) - ahead;
9520             }
9521         }
9522     }
9523
9524   /* Now adjust the global symbols defined in this section.  */
9525   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
9526               - symtab_hdr->sh_info);
9527   sym_hashes = elf_sym_hashes (abfd);
9528   end_hashes = sym_hashes + symcount;
9529   blank_t = blank_head;
9530   for (; sym_hashes < end_hashes; sym_hashes++)
9531     {
9532       struct elf_link_hash_entry *sym_hash = *sym_hashes;
9533
9534       if ((sym_hash->root.type == bfd_link_hash_defined
9535            || sym_hash->root.type == bfd_link_hash_defweak)
9536           && sym_hash->root.u.def.section == sec)
9537         {
9538           if (sym_hash->root.u.def.value <= sec->size)
9539             {
9540               bfd_vma ahead;
9541               bfd_vma orig_addr = sym_hash->root.u.def.value;
9542
9543               ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
9544               sym_hash->root.u.def.value -= ahead;
9545
9546               /* Adjust function size.  */
9547               if (sym_hash->type == STT_FUNC)
9548                 sym_hash->size -=
9549                   get_nds32_elf_blank_total
9550                   (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
9551
9552             }
9553         }
9554     }
9555
9556   contents = elf_section_data (sec)->this_hdr.contents;
9557   blank_t = blank_head;
9558   while (blank_t->next)
9559     {
9560       /* Actually delete the bytes.  */
9561
9562       /* If current blank is the last blank overlap with current section,
9563          go to finish process.  */
9564       if (sec->size <= (blank_t->next->offset))
9565         break;
9566
9567       memmove (contents + blank_t->offset - blank_t->total_size,
9568                contents + blank_t->offset + blank_t->size,
9569                blank_t->next->offset - (blank_t->offset + blank_t->size));
9570
9571       blank_t = blank_t->next;
9572     }
9573
9574   if (sec->size > (blank_t->offset + blank_t->size))
9575     {
9576       /* There are remaining code between blank and section boundary.
9577          Move the remaining code to appropriate location.  */
9578       memmove (contents + blank_t->offset - blank_t->total_size,
9579                contents + blank_t->offset + blank_t->size,
9580                sec->size - (blank_t->offset + blank_t->size));
9581       sec->size -= blank_t->total_size + blank_t->size;
9582     }
9583   else
9584     /* This blank is not entirely included in the section,
9585        reduce the section size by only part of the blank size.  */
9586     sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
9587
9588   while (blank_head)
9589     {
9590       blank_t = blank_head;
9591       blank_head = blank_head->next;
9592       remove_nds32_elf_blank (blank_t);
9593     }
9594
9595   return TRUE;
9596 }
9597
9598 /* Get the contents of a section.  */
9599
9600 static int
9601 nds32_get_section_contents (bfd *abfd, asection *sec,
9602                             bfd_byte **contents_p, bfd_boolean cache)
9603 {
9604   /* Get the section contents.  */
9605   if (elf_section_data (sec)->this_hdr.contents != NULL)
9606     *contents_p = elf_section_data (sec)->this_hdr.contents;
9607   else
9608     {
9609       if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
9610         return FALSE;
9611       if (cache)
9612         elf_section_data (sec)->this_hdr.contents = *contents_p;
9613     }
9614
9615   return TRUE;
9616 }
9617
9618 /* Get the contents of the internal symbol of abfd.  */
9619
9620 static int
9621 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
9622                       Elf_Internal_Sym **isymbuf_p)
9623 {
9624   Elf_Internal_Shdr *symtab_hdr;
9625   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9626
9627   /* Read this BFD's local symbols if we haven't done so already.  */
9628   if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
9629     {
9630       *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
9631       if (*isymbuf_p == NULL)
9632         {
9633           *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9634                                              symtab_hdr->sh_info, 0,
9635                                              NULL, NULL, NULL);
9636           if (*isymbuf_p == NULL)
9637             return FALSE;
9638         }
9639     }
9640   symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
9641
9642   return TRUE;
9643 }
9644
9645 /* Range of small data.  */
9646 static bfd_vma sdata_range[2][2];
9647 static bfd_vma const sdata_init_range[2] =
9648 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
9649
9650 static int
9651 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
9652                      bfd_byte *contents, bfd_vma addr)
9653 {
9654   unsigned long insn = bfd_getb32 (contents + addr);
9655
9656   if (insn & 0x80000000)
9657     return 2;
9658
9659   return 4;
9660 }
9661
9662 /* Set the gp relax range.  We have to measure the safe range
9663    to do gp relaxation.  */
9664
9665 static void
9666 relax_range_measurement (bfd *abfd)
9667 {
9668   asection *sec_f, *sec_b;
9669   /* For upper bound.   */
9670   bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
9671   bfd_vma align;
9672   static int decide_relax_range = 0;
9673   int i;
9674   int range_number = ARRAY_SIZE (sdata_init_range);
9675
9676   if (decide_relax_range)
9677     return;
9678   decide_relax_range = 1;
9679
9680   if (sda_rela_sec == NULL)
9681     {
9682       /* Since there is no data sections, we assume the range is page size.  */
9683       for (i = 0; i < range_number; i++)
9684         {
9685           sdata_range[i][0] = sdata_init_range[i] - 0x1000;
9686           sdata_range[i][1] = sdata_init_range[i] - 0x1000;
9687         }
9688       return;
9689     }
9690
9691   /* Get the biggest alignment power after the gp located section.  */
9692   sec_f = sda_rela_sec->output_section;
9693   sec_b = sec_f->next;
9694   align = 0;
9695   while (sec_b != NULL)
9696     {
9697       if ((unsigned)(1 << sec_b->alignment_power) > align)
9698         align = (1 << sec_b->alignment_power);
9699       sec_b = sec_b->next;
9700     }
9701
9702   /* I guess we can not determine the section before
9703      gp located section, so we assume the align is max page size.  */
9704   for (i = 0; i < range_number; i++)
9705     {
9706       sdata_range[i][1] = sdata_init_range[i] - align;
9707       BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9708       sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9709       BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9710     }
9711 }
9712
9713 /* These are macros used to check flags encoded in r_addend.
9714    They are only used by nds32_elf_relax_section ().  */
9715 #define GET_SEQ_LEN(addend)     ((addend) & 0x000000ff)
9716 #define IS_1ST_CONVERT(addend)  ((addend) & 0x80000000)
9717 #define IS_OPTIMIZE(addend)     ((addend) & 0x40000000)
9718 #define IS_16BIT_ON(addend)     ((addend) & 0x20000000)
9719
9720 static const char * unrecognized_reloc_msg =
9721   /* xgettext:c-format */
9722   N_("%pB: warning: %s points to unrecognized reloc at %#" PRIx64);
9723
9724 /* Relax LONGCALL1 relocation for nds32_elf_relax_section.  */
9725
9726 static bfd_boolean
9727 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9728                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9729                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9730                            Elf_Internal_Shdr *symtab_hdr)
9731 {
9732   /* There are 3 variations for LONGCALL1
9733      case 4-4-2; 16-bit on, optimize off or optimize for space
9734      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9735      ori   ta, ta, lo12(symbol) ; LO12S0
9736      jral5 ta                   ;
9737
9738      case 4-4-4; 16-bit off, optimize don't care
9739      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9740      ori   ta, ta, lo12(symbol) ; LO12S0
9741      jral  ta                   ;
9742
9743      case 4-4-4; 16-bit on, optimize for speed
9744      sethi ta, hi20(symbol)     ; LONGCALL1/HI20
9745      ori   ta, ta, lo12(symbol) ; LO12S0
9746      jral  ta                   ;
9747      Check code for -mlong-calls output.  */
9748
9749   /* Get the reloc for the address from which the register is
9750      being loaded.  This reloc will tell us which function is
9751      actually being called.  */
9752
9753   bfd_vma laddr;
9754   int seq_len;  /* Original length of instruction sequence.  */
9755   uint32_t insn;
9756   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9757   bfd_signed_vma foff;
9758   uint16_t insn16;
9759
9760   irelend = internal_relocs + sec->reloc_count;
9761   seq_len = GET_SEQ_LEN (irel->r_addend);
9762   laddr = irel->r_offset;
9763   *insn_len = seq_len;
9764
9765   hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9766                                            R_NDS32_HI20_RELA, laddr);
9767   lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9768                                            R_NDS32_LO12S0_ORI_RELA,
9769                                            laddr + 4);
9770
9771   if (hi_irelfn == irelend || lo_irelfn == irelend)
9772     {
9773       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
9774                           (uint64_t) irel->r_offset);
9775       return FALSE;
9776     }
9777
9778   /* Get the value of the symbol referred to by the reloc.  */
9779   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9780
9781   /* This condition only happened when symbol is undefined.  */
9782   if (foff == 0
9783       || foff < -CONSERVATIVE_24BIT_S1
9784       || foff >= CONSERVATIVE_24BIT_S1)
9785     return FALSE;
9786
9787   /* Relax to: jal symbol; 25_PCREL.  */
9788   /* For simplicity of coding, we are going to modify the section
9789      contents, the section relocs, and the BFD symbol table.  We
9790      must tell the rest of the code not to free up this
9791      information.  It would be possible to instead create a table
9792      of changes which have to be made, as is done in coff-mips.c;
9793      that would be more work, but would require less memory when
9794      the linker is run.  */
9795
9796   /* Replace the long call with a jal.  */
9797   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9798                                R_NDS32_25_PCREL_RELA);
9799   irel->r_addend = hi_irelfn->r_addend;
9800
9801   /* We don't resolve this here but resolve it in relocate_section.  */
9802   insn = INSN_JAL;
9803   bfd_putb32 (insn, contents + irel->r_offset);
9804
9805   hi_irelfn->r_info =
9806     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9807   lo_irelfn->r_info =
9808     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9809   *insn_len = 4;
9810
9811   if (seq_len & 0x2)
9812     {
9813       insn16 = NDS32_NOP16;
9814       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9815       lo_irelfn->r_info =
9816         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9817       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9818       *insn_len += 2;
9819     }
9820   return TRUE;
9821 }
9822
9823 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9824 /* Relax LONGCALL2 relocation for nds32_elf_relax_section.  */
9825
9826 static bfd_boolean
9827 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9828                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9829                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9830                            Elf_Internal_Shdr *symtab_hdr)
9831 {
9832   /* bltz  rt, .L1   ; LONGCALL2
9833      jal   symbol   ; 25_PCREL
9834      .L1: */
9835
9836   /* Get the reloc for the address from which the register is
9837      being loaded.  This reloc will tell us which function is
9838      actually being called.  */
9839
9840   bfd_vma laddr;
9841   uint32_t insn;
9842   Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9843   bfd_signed_vma foff;
9844
9845   irelend = internal_relocs + sec->reloc_count;
9846   laddr = irel->r_offset;
9847   i1_irelfn =
9848     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9849                                  R_NDS32_25_PCREL_RELA, laddr + 4);
9850
9851   if (i1_irelfn == irelend)
9852     {
9853       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
9854                           (uint64_t) irel->r_offset);
9855       return FALSE;
9856     }
9857
9858   insn = bfd_getb32 (contents + laddr);
9859
9860   /* Get the value of the symbol referred to by the reloc.  */
9861   foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr);
9862
9863   if (foff == 0
9864       || foff < -CONSERVATIVE_16BIT_S1
9865       || foff >= CONSERVATIVE_16BIT_S1)
9866     return FALSE;
9867
9868   /* Relax to   bgezal   rt, label ; 17_PCREL
9869      or         bltzal   rt, label ; 17_PCREL */
9870
9871   /* Convert to complimentary conditional call.  */
9872   insn = CONVERT_CONDITION_CALL (insn);
9873
9874   /* For simplicity of coding, we are going to modify the section
9875      contents, the section relocs, and the BFD symbol table.  We
9876      must tell the rest of the code not to free up this
9877      information.  It would be possible to instead create a table
9878      of changes which have to be made, as is done in coff-mips.c;
9879      that would be more work, but would require less memory when
9880      the linker is run.  */
9881
9882   /* Clean unnessary relocations.  */
9883   i1_irelfn->r_info =
9884     ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9885   cond_irelfn =
9886     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9887                                  R_NDS32_17_PCREL_RELA, laddr);
9888   if (cond_irelfn != irelend)
9889     cond_irelfn->r_info =
9890       ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9891
9892   /* Replace the long call with a bgezal.  */
9893   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9894                                R_NDS32_17_PCREL_RELA);
9895   irel->r_addend = i1_irelfn->r_addend;
9896
9897   bfd_putb32 (insn, contents + irel->r_offset);
9898
9899   *insn_len = 4;
9900   return TRUE;
9901 }
9902
9903 /* Relax LONGCALL3 relocation for nds32_elf_relax_section.  */
9904
9905 static bfd_boolean
9906 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9907                            Elf_Internal_Rela *internal_relocs, int *insn_len,
9908                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9909                            Elf_Internal_Shdr *symtab_hdr)
9910 {
9911   /* There are 3 variations for LONGCALL3
9912      case 4-4-4-2; 16-bit on, optimize off or optimize for space
9913      bltz  rt,   $1                ; LONGCALL3
9914      sethi ta,   hi20(symbol)      ; HI20
9915      ori   ta, ta,  lo12(symbol)   ; LO12S0
9916      jral5 ta                      ;
9917      $1
9918
9919      case 4-4-4-4; 16-bit off, optimize don't care
9920      bltz  rt,   $1                ; LONGCALL3
9921      sethi ta,   hi20(symbol)      ; HI20
9922      ori   ta, ta,  lo12(symbol)   ; LO12S0
9923      jral  ta                      ;
9924      $1
9925
9926      case 4-4-4-4; 16-bit on, optimize for speed
9927      bltz  rt,   $1                ; LONGCALL3
9928      sethi ta,   hi20(symbol)      ; HI20
9929      ori   ta, ta,  lo12(symbol)   ; LO12S0
9930      jral  ta                      ;
9931      $1 */
9932
9933   /* Get the reloc for the address from which the register is
9934      being loaded.  This reloc will tell us which function is
9935      actually being called.  */
9936
9937   bfd_vma laddr;
9938   int seq_len;  /* Original length of instruction sequence.  */
9939   uint32_t insn;
9940   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9941   bfd_signed_vma foff;
9942   uint16_t insn16;
9943
9944   irelend = internal_relocs + sec->reloc_count;
9945   seq_len = GET_SEQ_LEN (irel->r_addend);
9946   laddr = irel->r_offset;
9947   *insn_len = seq_len;
9948
9949   hi_irelfn =
9950     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9951                                  R_NDS32_HI20_RELA, laddr + 4);
9952   lo_irelfn =
9953     find_relocs_at_address_addr (irel, internal_relocs, irelend,
9954                                  R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9955
9956   if (hi_irelfn == irelend || lo_irelfn == irelend)
9957     {
9958       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
9959                           (uint64_t) irel->r_offset);
9960       return FALSE;
9961     }
9962
9963   /* Get the value of the symbol referred to by the reloc.  */
9964   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9965
9966   if (foff == 0
9967       || foff < -CONSERVATIVE_24BIT_S1
9968       || foff >= CONSERVATIVE_24BIT_S1)
9969     return FALSE;
9970
9971   insn = bfd_getb32 (contents + laddr);
9972   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9973     {
9974       /* Relax to  bgezal   rt, label ; 17_PCREL
9975          or        bltzal   rt, label ; 17_PCREL */
9976
9977       /* Convert to complimentary conditional call.  */
9978       insn = CONVERT_CONDITION_CALL (insn);
9979       bfd_putb32 (insn, contents + irel->r_offset);
9980
9981       *insn_len = 4;
9982       irel->r_info =
9983         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9984       hi_irelfn->r_info =
9985         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9986       lo_irelfn->r_info =
9987         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9988
9989       cond_irelfn =
9990         find_relocs_at_address_addr (irel, internal_relocs, irelend,
9991                                      R_NDS32_17_PCREL_RELA, laddr);
9992       if (cond_irelfn != irelend)
9993         {
9994           cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9995                                               R_NDS32_17_PCREL_RELA);
9996           cond_irelfn->r_addend = hi_irelfn->r_addend;
9997         }
9998
9999       if (seq_len & 0x2)
10000         {
10001           insn16 = NDS32_NOP16;
10002           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10003           hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10004                                             R_NDS32_INSN16);
10005           hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10006           insn_len += 2;
10007         }
10008     }
10009   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10010     {
10011       /* Relax to the following instruction sequence
10012          bltz  rt,   $1 ; LONGCALL2
10013          jal   symbol   ; 25_PCREL
10014          $1     */
10015       *insn_len = 8;
10016       insn = INSN_JAL;
10017       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10018
10019       hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10020                                         R_NDS32_25_PCREL_RELA);
10021       irel->r_info =
10022         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
10023
10024       lo_irelfn->r_info =
10025         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10026
10027       if (seq_len & 0x2)
10028         {
10029           insn16 = NDS32_NOP16;
10030           bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10031           lo_irelfn->r_info =
10032             ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
10033           lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10034           insn_len += 2;
10035         }
10036     }
10037   return TRUE;
10038 }
10039
10040 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section.  */
10041
10042 static bfd_boolean
10043 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10044                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10045                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10046                            Elf_Internal_Shdr *symtab_hdr)
10047 {
10048   /* There are 3 variations for LONGJUMP1
10049      case 4-4-2; 16-bit bit on, optimize off or optimize for space
10050      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
10051      ori   ta, ta, lo12(symbol)  ; LO12S0
10052      jr5   ta                    ;
10053
10054      case 4-4-4; 16-bit off, optimize don't care
10055      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
10056      ori   ta, ta, lo12(symbol)  ; LO12S0
10057      jr    ta                    ;
10058
10059      case 4-4-4; 16-bit on, optimize for speed
10060      sethi ta, hi20(symbol)      ; LONGJUMP1/HI20
10061      ori   ta, ta, lo12(symbol)  ; LO12S0
10062      jr    ta                    ;      */
10063
10064   /* Get the reloc for the address from which the register is
10065      being loaded.  This reloc will tell us which function is
10066      actually being called.  */
10067
10068   bfd_vma laddr;
10069   int seq_len;  /* Original length of instruction sequence.  */
10070   int insn16_on;        /* 16-bit on/off.  */
10071   uint32_t insn;
10072   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
10073   bfd_signed_vma foff;
10074   uint16_t insn16;
10075   unsigned long reloc;
10076
10077   irelend = internal_relocs + sec->reloc_count;
10078   seq_len = GET_SEQ_LEN (irel->r_addend);
10079   laddr = irel->r_offset;
10080   *insn_len = seq_len;
10081   insn16_on = IS_16BIT_ON (irel->r_addend);
10082
10083   hi_irelfn =
10084     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10085                                  R_NDS32_HI20_RELA, laddr);
10086   lo_irelfn =
10087     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10088                                  R_NDS32_LO12S0_ORI_RELA, laddr + 4);
10089   if (hi_irelfn == irelend || lo_irelfn == irelend)
10090     {
10091       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
10092                           (uint64_t) irel->r_offset);
10093       return FALSE;
10094     }
10095
10096   /* Get the value of the symbol referred to by the reloc.  */
10097   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10098
10099   if (foff == 0
10100       || foff >= CONSERVATIVE_24BIT_S1
10101       || foff < -CONSERVATIVE_24BIT_S1)
10102     return FALSE;
10103
10104   if (insn16_on
10105       && foff >= -ACCURATE_8BIT_S1
10106       && foff < ACCURATE_8BIT_S1
10107       && (seq_len & 0x2))
10108     {
10109       /* j8     label */
10110       /* 16-bit on, but not optimized for speed.  */
10111       reloc = R_NDS32_9_PCREL_RELA;
10112       insn16 = INSN_J8;
10113       bfd_putb16 (insn16, contents + irel->r_offset);
10114       *insn_len = 2;
10115       irel->r_info =
10116         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10117     }
10118   else
10119     {
10120       /* j     label */
10121       reloc = R_NDS32_25_PCREL_RELA;
10122       insn = INSN_J;
10123       bfd_putb32 (insn, contents + irel->r_offset);
10124       *insn_len = 4;
10125       irel->r_info =
10126         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
10127       irel->r_addend = 0;
10128     }
10129
10130   hi_irelfn->r_info =
10131     ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10132   lo_irelfn->r_info =
10133     ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10134
10135   if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
10136     {
10137       insn16 = NDS32_NOP16;
10138       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10139       lo_irelfn->r_info =
10140         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10141                       R_NDS32_INSN16);
10142       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10143       *insn_len += 2;
10144     }
10145   return TRUE;
10146 }
10147
10148 /* Revert condition branch.  This function does not check if the input
10149    instruction is condition branch or not.  */
10150
10151 static void
10152 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
10153                            uint16_t *re_insn16, uint32_t *re_insn)
10154 {
10155   uint32_t comp_insn = 0;
10156   uint16_t comp_insn16 = 0;
10157
10158   if (insn)
10159     {
10160       if (N32_OP6 (insn) == N32_OP6_BR1)
10161         {
10162           /* beqs label.  */
10163           comp_insn = (insn ^ 0x4000) & 0xffffc000;
10164           if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
10165             {
10166               /* Insn can be contracted to 16-bit implied r5.  */
10167               comp_insn16 =
10168                 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
10169               comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10170             }
10171         }
10172       else if (N32_OP6 (insn) == N32_OP6_BR3)
10173         {
10174           /* bnec $ta, imm11, label.  */
10175           comp_insn = (insn ^ 0x80000) & 0xffffff00;
10176         }
10177       else
10178         {
10179           comp_insn = (insn ^ 0x10000) & 0xffffc000;
10180           if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
10181               || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
10182             {
10183               if (N32_IS_RT3 (insn))
10184                 {
10185                   /* Insn can be contracted to 16-bit.  */
10186                   comp_insn16 =
10187                     (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
10188                   comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10189                 }
10190               else if (N32_RT5 (insn) == REG_R15)
10191                 {
10192                   /* Insn can be contracted to 16-bit.  */
10193                   comp_insn16 =
10194                     (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
10195                 }
10196             }
10197         }
10198     }
10199   else
10200     {
10201       switch ((insn16 & 0xf000) >> 12)
10202         {
10203         case 0xc:
10204           /* beqz38 or bnez38 */
10205           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10206           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
10207           comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
10208           break;
10209
10210         case 0xd:
10211           /* beqs38 or bnes38 */
10212           comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10213           comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
10214           comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
10215             | (REG_R5 << 15);
10216           break;
10217
10218         case 0xe:
10219           /* beqzS8 or bnezS8 */
10220           comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
10221           comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
10222           comp_insn |= REG_R15 << 20;
10223           break;
10224
10225         default:
10226           break;
10227         }
10228     }
10229   if (comp_insn && re_insn)
10230     *re_insn = comp_insn;
10231   if (comp_insn16 && re_insn16)
10232     *re_insn16 = comp_insn16;
10233 }
10234
10235 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section.  */
10236
10237 static bfd_boolean
10238 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10239                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10240                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10241                            Elf_Internal_Shdr *symtab_hdr)
10242 {
10243   /* There are 3 variations for LONGJUMP2
10244      case 2-4;  1st insn convertible, 16-bit on,
10245      optimize off or optimize for space
10246      bnes38  rt, ra, $1 ; LONGJUMP2
10247      j       label      ; 25_PCREL
10248      $1:
10249
10250      case 4-4; 1st insn not convertible
10251      bne  rt, ra, $1 ; LONGJUMP2
10252      j    label      ; 25_PCREL
10253      $1:
10254
10255      case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10256      bne  rt, ra, $1 ; LONGJUMP2
10257      j    label      ; 25_PCREL
10258      $1: */
10259
10260   /* Get the reloc for the address from which the register is
10261      being loaded.  This reloc will tell us which function is
10262      actually being called.  */
10263
10264   bfd_vma laddr;
10265   int seq_len;  /* Original length of instruction sequence.  */
10266   Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
10267   int first_size;
10268   unsigned int i;
10269   bfd_signed_vma foff;
10270   uint32_t insn, re_insn = 0;
10271   uint16_t insn16, re_insn16 = 0;
10272   unsigned long reloc, cond_reloc;
10273
10274   enum elf_nds32_reloc_type checked_types[] =
10275     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10276
10277   irelend = internal_relocs + sec->reloc_count;
10278   seq_len = GET_SEQ_LEN (irel->r_addend);
10279   laddr = irel->r_offset;
10280   *insn_len = seq_len;
10281   first_size = (seq_len == 6) ? 2 : 4;
10282
10283   i2_irelfn =
10284     find_relocs_at_address_addr (irel, internal_relocs,
10285                                  irelend, R_NDS32_25_PCREL_RELA,
10286                                  laddr + first_size);
10287
10288   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10289     {
10290       cond_irelfn =
10291         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10292                                      checked_types[i], laddr);
10293       if (cond_irelfn != irelend)
10294         break;
10295     }
10296
10297   if (i2_irelfn == irelend || cond_irelfn == irelend)
10298     {
10299       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
10300                           (uint64_t) irel->r_offset);
10301       return FALSE;
10302     }
10303
10304   /* Get the value of the symbol referred to by the reloc.  */
10305   foff = calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr);
10306   if (foff == 0
10307       || foff < -CONSERVATIVE_16BIT_S1
10308       || foff >= CONSERVATIVE_16BIT_S1)
10309     return FALSE;
10310
10311   /* Get the all corresponding instructions.  */
10312   if (first_size == 4)
10313     {
10314       insn = bfd_getb32 (contents + laddr);
10315       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10316     }
10317   else
10318     {
10319       insn16 = bfd_getb16 (contents + laddr);
10320       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10321     }
10322
10323   if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
10324       && foff < ACCURATE_8BIT_S1 - first_size)
10325     {
10326       if (first_size == 4)
10327         {
10328           /* Don't convert it to 16-bit now, keep this as relaxable for
10329              ``label reloc; INSN16''.  */
10330
10331           /* Save comp_insn32 to buffer.  */
10332           bfd_putb32 (re_insn, contents + irel->r_offset);
10333           *insn_len = 4;
10334           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10335             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10336           cond_reloc = R_NDS32_INSN16;
10337         }
10338       else
10339         {
10340           bfd_putb16 (re_insn16, contents + irel->r_offset);
10341           *insn_len = 2;
10342           reloc = R_NDS32_9_PCREL_RELA;
10343           cond_reloc = R_NDS32_NONE;
10344         }
10345     }
10346   else if (N32_OP6 (re_insn) == N32_OP6_BR1
10347            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10348                && foff < ACCURATE_14BIT_S1 - first_size))
10349     {
10350       /* beqs     label    ; 15_PCREL */
10351       bfd_putb32 (re_insn, contents + irel->r_offset);
10352       *insn_len = 4;
10353       reloc = R_NDS32_15_PCREL_RELA;
10354       cond_reloc = R_NDS32_NONE;
10355     }
10356   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10357            && foff >= -CONSERVATIVE_16BIT_S1
10358            && foff < CONSERVATIVE_16BIT_S1)
10359     {
10360       /* beqz     label ; 17_PCREL */
10361       bfd_putb32 (re_insn, contents + irel->r_offset);
10362       *insn_len = 4;
10363       reloc = R_NDS32_17_PCREL_RELA;
10364       cond_reloc = R_NDS32_NONE;
10365     }
10366   else
10367     return FALSE;
10368
10369   /* Set all relocations.  */
10370   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
10371   irel->r_addend = i2_irelfn->r_addend;
10372
10373   cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10374                                       cond_reloc);
10375   cond_irelfn->r_addend = 0;
10376
10377   if ((seq_len ^ *insn_len ) & 0x2)
10378     {
10379       insn16 = NDS32_NOP16;
10380       bfd_putb16 (insn16, contents + irel->r_offset + 4);
10381       i2_irelfn->r_offset = 4;
10382       i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10383                                         R_NDS32_INSN16);
10384       i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10385       *insn_len += 2;
10386     }
10387   else
10388     i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10389                                       R_NDS32_NONE);
10390   return TRUE;
10391 }
10392
10393 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section.  */
10394
10395 static bfd_boolean
10396 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10397                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10398                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10399                            Elf_Internal_Shdr *symtab_hdr)
10400 {
10401   /* There are 5 variations for LONGJUMP3
10402      case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
10403      optimize off or optimize for space
10404      bnes38   rt, ra, $1            ; LONGJUMP3
10405      sethi    ta, hi20(symbol)      ; HI20
10406      ori      ta, ta, lo12(symbol)  ; LO12S0
10407      jr5      ta                    ;
10408      $1:                            ;
10409
10410      case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
10411      bnes38   rt, ra, $1           ; LONGJUMP3
10412      sethi    ta, hi20(symbol)     ; HI20
10413      ori      ta, ta, lo12(symbol) ; LO12S0
10414      jr5      ta                   ;
10415      $1:                           ; LABEL
10416
10417      case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
10418      optimize off or optimize for space
10419      bne   rt, ra, $1           ; LONGJUMP3
10420      sethi ta, hi20(symbol)     ; HI20
10421      ori   ta, ta, lo12(symbol) ; LO12S0
10422      jr5   ta                   ;
10423      $1:                        ;
10424
10425      case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
10426      16-bit off if no INSN16
10427      bne   rt, ra, $1           ; LONGJUMP3
10428      sethi ta, hi20(symbol)     ; HI20
10429      ori   ta, ta, lo12(symbol) ; LO12S0
10430      jr    ta                   ;
10431      $1:                        ;
10432
10433      case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
10434      16-bit off if no INSN16
10435      bne   rt, ra, $1           ; LONGJUMP3
10436      sethi ta, hi20(symbol)     ; HI20
10437      ori   ta, ta, lo12(symbol) ; LO12S0
10438      jr    ta                   ;
10439      $1:                        ; LABEL */
10440
10441   /* Get the reloc for the address from which the register is
10442      being loaded.  This reloc will tell us which function is
10443      actually being called.  */
10444   enum elf_nds32_reloc_type checked_types[] =
10445     { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10446
10447   int reloc_off = 0, cond_removed = 0, convertible;
10448   bfd_vma laddr;
10449   int seq_len;  /* Original length of instruction sequence.  */
10450   Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
10451   int first_size;
10452   unsigned int i;
10453   bfd_signed_vma foff;
10454   uint32_t insn, re_insn = 0;
10455   uint16_t insn16, re_insn16 = 0;
10456   unsigned long reloc, cond_reloc;
10457
10458   irelend = internal_relocs + sec->reloc_count;
10459   seq_len = GET_SEQ_LEN (irel->r_addend);
10460   laddr = irel->r_offset;
10461   *insn_len = seq_len;
10462
10463   convertible = IS_1ST_CONVERT (irel->r_addend);
10464
10465   if (convertible)
10466     first_size = 2;
10467   else
10468     first_size = 4;
10469
10470   /* Get all needed relocations.  */
10471   hi_irelfn =
10472     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10473                                  R_NDS32_HI20_RELA, laddr + first_size);
10474   lo_irelfn =
10475     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10476                                  R_NDS32_LO12S0_ORI_RELA,
10477                                  laddr + first_size + 4);
10478
10479   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10480     {
10481       cond_irelfn =
10482         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10483                                      checked_types[i], laddr);
10484       if (cond_irelfn != irelend)
10485         break;
10486     }
10487
10488   if (hi_irelfn == irelend
10489       || lo_irelfn == irelend
10490       || cond_irelfn == irelend)
10491     {
10492       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
10493                           (uint64_t) irel->r_offset);
10494       return FALSE;
10495     }
10496
10497   /* Get the value of the symbol referred to by the reloc.  */
10498   foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10499
10500   if (foff == 0
10501       || foff < -CONSERVATIVE_24BIT_S1
10502       || foff >= CONSERVATIVE_24BIT_S1)
10503     return FALSE;
10504
10505   /* Get the all corresponding instructions.  */
10506   if (first_size == 4)
10507     {
10508       insn = bfd_getb32 (contents + laddr);
10509       nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10510     }
10511   else
10512     {
10513       insn16 = bfd_getb16 (contents + laddr);
10514       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10515     }
10516
10517   /* For simplicity of coding, we are going to modify the section
10518      contents, the section relocs, and the BFD symbol table.  We
10519      must tell the rest of the code not to free up this
10520      information.  It would be possible to instead create a table
10521      of changes which have to be made, as is done in coff-mips.c;
10522      that would be more work, but would require less memory when
10523      the linker is run.  */
10524
10525   if (re_insn16
10526       && foff >= -ACCURATE_8BIT_S1 - first_size
10527       && foff < ACCURATE_8BIT_S1 - first_size)
10528     {
10529       if (!(seq_len & 0x2))
10530         {
10531           /* Don't convert it to 16-bit now, keep this as relaxable
10532              for ``label reloc; INSN1a''6.  */
10533           /* Save comp_insn32 to buffer.  */
10534           bfd_putb32 (re_insn, contents + irel->r_offset);
10535           *insn_len = 4;
10536           reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10537             R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10538           cond_reloc = R_NDS32_INSN16;
10539         }
10540       else
10541         {
10542           /* Not optimize for speed; convert sequence to 16-bit.  */
10543           /* Save comp_insn16 to buffer.  */
10544           bfd_putb16 (re_insn16, contents + irel->r_offset);
10545           *insn_len = 2;
10546           reloc = R_NDS32_9_PCREL_RELA;
10547           cond_reloc = R_NDS32_NONE;
10548         }
10549       cond_removed = 1;
10550     }
10551   else if (N32_OP6 (re_insn) == N32_OP6_BR1
10552            && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10553                && foff < ACCURATE_14BIT_S1 - first_size))
10554     {
10555       /* beqs     label    ; 15_PCREL */
10556       bfd_putb32 (re_insn, contents + irel->r_offset);
10557       *insn_len = 4;
10558       reloc = R_NDS32_15_PCREL_RELA;
10559       cond_reloc = R_NDS32_NONE;
10560       cond_removed = 1;
10561     }
10562   else if (N32_OP6 (re_insn) == N32_OP6_BR2
10563            && foff >= -CONSERVATIVE_16BIT_S1
10564            && foff < CONSERVATIVE_16BIT_S1)
10565     {
10566       /* beqz     label ; 17_PCREL */
10567       bfd_putb32 (re_insn, contents + irel->r_offset);
10568       *insn_len = 4;
10569       reloc = R_NDS32_17_PCREL_RELA;
10570       cond_reloc = R_NDS32_NONE;
10571       cond_removed = 1;
10572     }
10573   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10574            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10575     {
10576       /* Relax to one of the following 3 variations
10577
10578          case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
10579          for space
10580          bnes38  rt, $1 ; LONGJUMP2
10581          j       label  ; 25_PCREL
10582          $1
10583
10584          case 4-4; 1st insn not convertible, others don't care
10585          bne   rt, ra, $1 ; LONGJUMP2
10586          j     label      ; 25_PCREL
10587          $1
10588
10589          case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10590          bne   rt, ra, $1 ; LONGJUMP2
10591          j     label      ; 25_PCREL
10592          $1 */
10593
10594       /* Offset for first instruction.  */
10595
10596       /* Use j label as second instruction.  */
10597       *insn_len = 4 + first_size;
10598       insn = INSN_J;
10599       bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10600       reloc = R_NDS32_LONGJUMP2;
10601       cond_reloc = R_NDS32_25_PLTREL;
10602     }
10603     else
10604       return FALSE;
10605
10606     if (cond_removed == 1)
10607       {
10608         /* Set all relocations.  */
10609         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10610         irel->r_addend = hi_irelfn->r_addend;
10611
10612         cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10613                                             cond_reloc);
10614         cond_irelfn->r_addend = 0;
10615         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10616                                           R_NDS32_NONE);
10617       }
10618     else
10619       {
10620         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10621         irel->r_addend = irel->r_addend;
10622         hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10623                                           cond_reloc);
10624       }
10625
10626   if ((seq_len ^ *insn_len ) & 0x2)
10627     {
10628       insn16 = NDS32_NOP16;
10629       bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10630       lo_irelfn->r_offset = *insn_len;
10631       lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10632                                         R_NDS32_INSN16);
10633       lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10634       *insn_len += 2;
10635     }
10636   else
10637     lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10638                                       R_NDS32_NONE);
10639   return TRUE;
10640 }
10641
10642 /* Relax LONGCALL4 relocation for nds32_elf_relax_section.  */
10643
10644 static bfd_boolean
10645 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10646                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10647                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10648                            Elf_Internal_Shdr *symtab_hdr)
10649 {
10650   /* The pattern for LONGCALL4.  Support for function cse.
10651      sethi ta, hi20(symbol)     ; LONGCALL4/HI20
10652      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10653      jral  ta                   ; PTR_RES/EMPTY/INSN16  */
10654
10655   bfd_vma laddr;
10656   uint32_t insn;
10657   Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
10658   Elf_Internal_Rela *irelend;
10659   bfd_signed_vma foff;
10660
10661   irelend = internal_relocs + sec->reloc_count;
10662   laddr = irel->r_offset;
10663
10664   /* Get the reloc for the address from which the register is
10665      being loaded.  This reloc will tell us which function is
10666      actually being called.  */
10667   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10668                                          R_NDS32_HI20_RELA, laddr);
10669
10670   if (hi_irel == irelend)
10671     {
10672       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10673                           (uint64_t) irel->r_offset);
10674       return FALSE;
10675     }
10676
10677   /* Get the value of the symbol referred to by the reloc.  */
10678   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10679
10680   /* This condition only happened when symbol is undefined.  */
10681   if (foff == 0
10682       || foff < -CONSERVATIVE_24BIT_S1
10683       || foff >= CONSERVATIVE_24BIT_S1)
10684     return FALSE;
10685
10686   /* Relax to: jal symbol; 25_PCREL.  */
10687   /* For simplicity of coding, we are going to modify the section
10688      contents, the section relocs, and the BFD symbol table.  We
10689      must tell the rest of the code not to free up this
10690      information.  It would be possible to instead create a table
10691      of changes which have to be made, as is done in coff-mips.c;
10692      that would be more work, but would require less memory when
10693      the linker is run.  */
10694
10695   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10696                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
10697   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10698                                           R_NDS32_EMPTY, irel->r_addend);
10699
10700   if (ptr_irel == irelend || em_irel == irelend)
10701     {
10702       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10703                           (uint64_t) irel->r_offset);
10704       return FALSE;
10705     }
10706   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
10707   insn = bfd_getb32 (contents + irel->r_addend);
10708   if (insn & 0x80000000)
10709     return FALSE;
10710
10711   /* Replace the long call with a jal.  */
10712   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10713                                   R_NDS32_25_PCREL_RELA);
10714   ptr_irel->r_addend = 1;
10715
10716   /* We don't resolve this here but resolve it in relocate_section.  */
10717   insn = INSN_JAL;
10718   bfd_putb32 (insn, contents + em_irel->r_offset);
10719
10720   irel->r_info =
10721     ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10722
10723   /* If there is function cse, HI20 can not remove now.  */
10724   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10725                                            R_NDS32_LONGCALL4, laddr);
10726   if (call_irel == irelend)
10727     {
10728       *insn_len = 0;
10729       hi_irel->r_info =
10730         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10731     }
10732
10733   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10734                                           R_NDS32_INSN16, irel->r_addend);
10735   if (insn_irel != irelend)
10736     insn_irel->r_info =
10737       ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10738
10739   return TRUE;
10740 }
10741
10742 /* Relax LONGCALL5 relocation for nds32_elf_relax_section.  */
10743
10744 static bfd_boolean
10745 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10746                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10747                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10748                            Elf_Internal_Shdr *symtab_hdr)
10749 {
10750   /* The pattern for LONGCALL5.
10751      bltz  rt, .L1      ; LONGCALL5/17_PCREL
10752      jal   symbol       ; 25_PCREL
10753      .L1:  */
10754
10755   bfd_vma laddr;
10756   uint32_t insn;
10757   Elf_Internal_Rela *cond_irel, *irelend;
10758   bfd_signed_vma foff;
10759
10760   irelend = internal_relocs + sec->reloc_count;
10761   laddr = irel->r_offset;
10762   insn = bfd_getb32 (contents + laddr);
10763
10764   /* Get the reloc for the address from which the register is
10765      being loaded.  This reloc will tell us which function is
10766      actually being called.  */
10767   cond_irel =
10768     find_relocs_at_address_addr (irel, internal_relocs, irelend,
10769                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
10770   if (cond_irel == irelend)
10771     {
10772       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
10773                           (uint64_t) irel->r_offset);
10774       return FALSE;
10775     }
10776
10777   /* Get the value of the symbol referred to by the reloc.  */
10778   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
10779
10780   if (foff == 0
10781       || foff < -CONSERVATIVE_16BIT_S1
10782       || foff >= CONSERVATIVE_16BIT_S1)
10783     return FALSE;
10784
10785   /* Relax to   bgezal   rt, label ; 17_PCREL
10786      or         bltzal   rt, label ; 17_PCREL.  */
10787
10788   /* Convert to complimentary conditional call.  */
10789   insn = CONVERT_CONDITION_CALL (insn);
10790
10791   /* For simplicity of coding, we are going to modify the section
10792      contents, the section relocs, and the BFD symbol table.  We
10793      must tell the rest of the code not to free up this
10794      information.  It would be possible to instead create a table
10795      of changes which have to be made, as is done in coff-mips.c;
10796      that would be more work, but would require less memory when
10797      the linker is run.  */
10798
10799   /* Modify relocation and contents.  */
10800   cond_irel->r_info =
10801     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10802
10803   /* Replace the long call with a bgezal.  */
10804   bfd_putb32 (insn, contents + cond_irel->r_offset);
10805   *insn_len = 0;
10806
10807   /* Clean unnessary relocations.  */
10808   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10809
10810   cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10811                                            R_NDS32_17_PCREL_RELA, laddr);
10812   cond_irel->r_info =
10813     ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10814
10815   return TRUE;
10816 }
10817
10818 /* Relax LONGCALL6 relocation for nds32_elf_relax_section.  */
10819
10820 static bfd_boolean
10821 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10822                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10823                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10824                            Elf_Internal_Shdr *symtab_hdr)
10825 {
10826   /* The pattern for LONGCALL6.
10827      bltz  rt,   .L1                    ; LONGCALL6/17_PCREL
10828      sethi ta,   hi20(symbol)           ; HI20/PTR
10829      ori   ta, ta,  lo12(symbol)        ; LO12S0_ORI/PTR
10830      jral  ta                           ; PTR_RES/EMPTY/INSN16
10831      .L1  */
10832
10833   bfd_vma laddr;
10834   uint32_t insn;
10835   Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10836   bfd_signed_vma foff;
10837
10838   irelend = internal_relocs + sec->reloc_count;
10839   laddr = irel->r_offset;
10840
10841   /* Get the reloc for the address from which the register is
10842      being loaded.  This reloc will tell us which function is
10843      actually being called.  */
10844   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10845                                          R_NDS32_EMPTY, irel->r_addend);
10846
10847   if (em_irel == irelend)
10848     {
10849       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
10850                           (uint64_t) irel->r_offset);
10851       return FALSE;
10852     }
10853
10854   /* Get the value of the symbol referred to by the reloc.  */
10855   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
10856
10857   if (foff == 0
10858       || foff < -CONSERVATIVE_24BIT_S1
10859       || foff >= CONSERVATIVE_24BIT_S1)
10860     return FALSE;
10861
10862   /* Check these is enough space to insert jal in R_NDS32_EMPTY.  */
10863   insn = bfd_getb32 (contents + irel->r_addend);
10864   if (insn & 0x80000000)
10865     return FALSE;
10866
10867   insn = bfd_getb32 (contents + laddr);
10868   if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10869     {
10870       /* Relax to  bgezal   rt, label ; 17_PCREL
10871          or        bltzal   rt, label ; 17_PCREL.  */
10872
10873       /* Convert to complimentary conditional call.  */
10874       *insn_len = 0;
10875       insn = CONVERT_CONDITION_CALL (insn);
10876       bfd_putb32 (insn, contents + em_irel->r_offset);
10877
10878       em_irel->r_info =
10879         ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10880
10881       /* Set resolved relocation.  */
10882       cond_irel =
10883         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10884                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
10885       if (cond_irel == irelend)
10886         {
10887           _bfd_error_handler (unrecognized_reloc_msg, abfd,
10888                               "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10889           return FALSE;
10890         }
10891       cond_irel->r_addend = 1;
10892
10893       /* Clear relocations.  */
10894
10895       irel->r_info =
10896         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10897
10898       cond_irel =
10899         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10900                                      R_NDS32_17_PCREL_RELA, laddr);
10901       if (cond_irel != irelend)
10902         cond_irel->r_info =
10903           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10904
10905       cond_irel =
10906         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10907                                      R_NDS32_INSN16, irel->r_addend);
10908       if (cond_irel != irelend)
10909         cond_irel->r_info =
10910           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10911
10912     }
10913   else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10914     {
10915       /* Relax to the following instruction sequence
10916          bltz  rt, .L1  ; LONGCALL2/17_PCREL
10917          jal   symbol   ; 25_PCREL/PTR_RES
10918          .L1  */
10919       *insn_len = 4;
10920       /* Convert instruction.  */
10921       insn = INSN_JAL;
10922       bfd_putb32 (insn, contents + em_irel->r_offset);
10923
10924       /* Convert relocations.  */
10925       em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10926                                       R_NDS32_25_PCREL_RELA);
10927       irel->r_info =
10928         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10929
10930       /* Set resolved relocation.  */
10931       cond_irel =
10932         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10933                                      R_NDS32_PTR_RESOLVED, irel->r_addend);
10934       if (cond_irel == irelend)
10935         {
10936           _bfd_error_handler (unrecognized_reloc_msg, abfd,
10937                               "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10938           return FALSE;
10939         }
10940       cond_irel->r_addend = 1;
10941
10942       cond_irel =
10943         find_relocs_at_address_addr (irel, internal_relocs, irelend,
10944                                      R_NDS32_INSN16, irel->r_addend);
10945       if (cond_irel != irelend)
10946         cond_irel->r_info =
10947           ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10948     }
10949   return TRUE;
10950 }
10951
10952 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section.  */
10953
10954 static bfd_boolean
10955 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10956                            Elf_Internal_Rela *internal_relocs, int *insn_len,
10957                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10958                            Elf_Internal_Shdr *symtab_hdr)
10959 {
10960   /* The pattern for LONGJUMP4.
10961      sethi ta, hi20(symbol)     ; LONGJUMP4/HI20
10962      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10963      jr    ta                   ; PTR_RES/INSN16/EMPTY  */
10964
10965   bfd_vma laddr;
10966   int seq_len;  /* Original length of instruction sequence.  */
10967   uint32_t insn;
10968   Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10969   bfd_signed_vma foff;
10970
10971   irelend = internal_relocs + sec->reloc_count;
10972   seq_len = GET_SEQ_LEN (irel->r_addend);
10973   laddr = irel->r_offset;
10974   *insn_len = seq_len;
10975
10976   /* Get the reloc for the address from which the register is
10977      being loaded.  This reloc will tell us which function is
10978      actually being called.  */
10979
10980   hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10981                                          R_NDS32_HI20_RELA, laddr);
10982
10983   if (hi_irel == irelend)
10984     {
10985       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10986                           (uint64_t) irel->r_offset);
10987       return FALSE;
10988     }
10989
10990   /* Get the value of the symbol referred to by the reloc.  */
10991   foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10992
10993   if (foff == 0
10994       || foff >= CONSERVATIVE_24BIT_S1
10995       || foff < -CONSERVATIVE_24BIT_S1)
10996     return FALSE;
10997
10998   /* Convert it to "j label", it may be converted to j8 in the final
10999      pass of relaxation.  Therefore, we do not consider this currently.  */
11000   ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11001                                           R_NDS32_PTR_RESOLVED, irel->r_addend);
11002   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11003                                          R_NDS32_EMPTY, irel->r_addend);
11004
11005   if (ptr_irel == irelend || em_irel == irelend)
11006     {
11007       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
11008                           (uint64_t) irel->r_offset);
11009       return FALSE;
11010     }
11011
11012   em_irel->r_info =
11013     ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
11014   ptr_irel->r_addend = 1;
11015
11016   /* Write instruction.  */
11017   insn = INSN_J;
11018   bfd_putb32 (insn, contents + em_irel->r_offset);
11019
11020   /* Clear relocations.  */
11021   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11022
11023   /* If there is function cse, HI20 can not remove now.  */
11024   call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11025                                            R_NDS32_LONGJUMP4, laddr);
11026   if (call_irel == irelend)
11027     {
11028       *insn_len = 0;
11029       hi_irel->r_info =
11030         ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
11031     }
11032
11033   return TRUE;
11034 }
11035
11036 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section.  */
11037
11038 static bfd_boolean
11039 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11040                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11041                            int *seq_len, bfd_byte *contents,
11042                            Elf_Internal_Sym *isymbuf,
11043                            Elf_Internal_Shdr *symtab_hdr)
11044 {
11045   /* There are 2 variations for LONGJUMP5
11046      case 2-4;  1st insn convertible, 16-bit on.
11047      bnes38  rt, ra, .L1        ; LONGJUMP5/9_PCREL/INSN16
11048      j       label              ; 25_PCREL/INSN16
11049      $1:
11050
11051      case 4-4; 1st insn not convertible
11052      bne  rt, ra, .L1   ; LONGJUMP5/15_PCREL/INSN16
11053      j    label         ; 25_PCREL/INSN16
11054      .L1:  */
11055
11056   bfd_vma laddr;
11057   Elf_Internal_Rela *cond_irel,  *irelend;
11058   unsigned int i;
11059   bfd_signed_vma foff;
11060   uint32_t insn, re_insn = 0;
11061   uint16_t insn16, re_insn16 = 0;
11062   unsigned long reloc;
11063
11064   enum elf_nds32_reloc_type checked_types[] =
11065     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11066       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11067
11068   irelend = internal_relocs + sec->reloc_count;
11069   laddr = irel->r_offset;
11070
11071   /* Get the reloc for the address from which the register is
11072      being loaded.  This reloc will tell us which function is
11073      actually being called.  */
11074
11075   cond_irel =
11076     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11077                                  R_NDS32_25_PCREL_RELA, irel->r_addend);
11078   if (cond_irel == irelend)
11079     {
11080       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
11081                           (uint64_t) irel->r_offset);
11082       return FALSE;
11083     }
11084
11085   /* Get the value of the symbol referred to by the reloc.  */
11086   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11087
11088   if (foff == 0
11089       || foff < -CONSERVATIVE_16BIT_S1
11090       || foff >= CONSERVATIVE_16BIT_S1)
11091     return FALSE;
11092
11093   /* Get the all corresponding instructions.  */
11094   insn = bfd_getb32 (contents + laddr);
11095   /* Check instruction size.  */
11096   if (insn & 0x80000000)
11097     {
11098       *seq_len = 0;
11099       insn16 = insn >> 16;
11100       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11101     }
11102   else
11103     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11104
11105   if (N32_OP6 (re_insn) == N32_OP6_BR1
11106       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11107     {
11108       /* beqs label ; 15_PCREL.  */
11109       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11110       reloc = R_NDS32_15_PCREL_RELA;
11111     }
11112   else if (N32_OP6 (re_insn) == N32_OP6_BR2
11113            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11114     {
11115       /* beqz label ; 17_PCREL.  */
11116       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11117       reloc = R_NDS32_17_PCREL_RELA;
11118     }
11119   else if ( N32_OP6 (re_insn) == N32_OP6_BR3
11120            && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
11121     {
11122       /* beqc label ; 9_PCREL.  */
11123       bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11124       reloc = R_NDS32_WORD_9_PCREL_RELA;
11125     }
11126   else
11127     return FALSE;
11128
11129   /* Set all relocations.  */
11130   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
11131
11132   /* Clean relocations.  */
11133   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11134   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11135     {
11136       cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11137                                                checked_types[i], laddr);
11138       if (cond_irel != irelend)
11139         {
11140           if (*seq_len == 0
11141               && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11142             {
11143               /* If the branch instruction is 2 byte, it cannot remove
11144                  directly.  Only convert it to nop16 and remove it after
11145                  checking alignment issue.  */
11146               insn16 = NDS32_NOP16;
11147               bfd_putb16 (insn16, contents + laddr);
11148               cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11149             }
11150           else
11151             cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11152                                               R_NDS32_NONE);
11153         }
11154     }
11155   *insn_len = 0;
11156
11157   return TRUE;
11158 }
11159
11160 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section.  */
11161
11162 static bfd_boolean
11163 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11164                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11165                            int *seq_len, bfd_byte *contents,
11166                            Elf_Internal_Sym *isymbuf,
11167                            Elf_Internal_Shdr *symtab_hdr)
11168 {
11169   /* There are 5 variations for LONGJUMP6
11170      case : 2-4-4-4; 1st insn convertible, 16-bit on.
11171      bnes38   rt, ra, .L1               ; LONGJUMP6/15_PCREL/INSN16
11172      sethi    ta, hi20(symbol)          ; HI20/PTR
11173      ori      ta, ta, lo12(symbol)      ; LO12S0_ORI/PTR
11174      jr       ta                        ; PTR_RES/INSN16/EMPTY
11175      .L1:
11176
11177      case : 4-4-4-4; 1st insn not convertible, 16-bit on.
11178      bne   rt, ra, .L1          ; LONGJUMP6/15_PCREL/INSN16
11179      sethi ta, hi20(symbol)     ; HI20/PTR
11180      ori   ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11181      jr    ta                   ; PTR_RES/INSN16/EMPTY
11182      .L1:  */
11183
11184   enum elf_nds32_reloc_type checked_types[] =
11185     { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11186       R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11187
11188   int reloc_off = 0, cond_removed = 0;
11189   bfd_vma laddr;
11190   Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
11191   unsigned int i;
11192   bfd_signed_vma foff;
11193   uint32_t insn, re_insn = 0;
11194   uint16_t insn16, re_insn16 = 0;
11195   unsigned long reloc;
11196
11197   irelend = internal_relocs + sec->reloc_count;
11198   laddr = irel->r_offset;
11199
11200   /* Get the reloc for the address from which the register is
11201      being loaded.  This reloc will tell us which function is
11202      actually being called.  */
11203   em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11204                                          R_NDS32_EMPTY, irel->r_addend);
11205
11206   if (em_irel == irelend)
11207     {
11208       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
11209                           (uint64_t) irel->r_offset);
11210       return FALSE;
11211     }
11212
11213   /* Get the value of the symbol referred to by the reloc.  */
11214   foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
11215
11216   if (foff == 0
11217       || foff < -CONSERVATIVE_24BIT_S1
11218       || foff >= CONSERVATIVE_24BIT_S1)
11219     return FALSE;
11220
11221   insn = bfd_getb32 (contents + laddr);
11222   /* Check instruction size.  */
11223   if (insn & 0x80000000)
11224     {
11225       *seq_len = 0;
11226       insn16 = insn >> 16;
11227       nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11228     }
11229   else
11230     nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11231
11232   /* For simplicity of coding, we are going to modify the section
11233      contents, the section relocs, and the BFD symbol table.  We
11234      must tell the rest of the code not to free up this
11235      information.  It would be possible to instead create a table
11236      of changes which have to be made, as is done in coff-mips.c;
11237      that would be more work, but would require less memory when
11238      the linker is run.  */
11239
11240   if (N32_OP6 (re_insn) == N32_OP6_BR1
11241       && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11242     {
11243       /* beqs     label    ; 15_PCREL.  */
11244       bfd_putb32 (re_insn, contents + em_irel->r_offset);
11245       reloc = R_NDS32_15_PCREL_RELA;
11246       cond_removed = 1;
11247     }
11248   else if (N32_OP6 (re_insn) == N32_OP6_BR2
11249            && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11250     {
11251       /* beqz     label ; 17_PCREL.  */
11252       bfd_putb32 (re_insn, contents + em_irel->r_offset);
11253       reloc = R_NDS32_17_PCREL_RELA;
11254       cond_removed = 1;
11255     }
11256   else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
11257            && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
11258     {
11259       /* Relax to one of the following 2 variations
11260
11261          case 2-4;  1st insn convertible, 16-bit on.
11262          bnes38  rt, ra, .L1    ; LONGJUMP5/9_PCREL/INSN16
11263          j       label          ; 25_PCREL/INSN16
11264          $1:
11265
11266          case 4-4; 1st insn not convertible
11267          bne  rt, ra, .L1       ; LONGJUMP5/15_PCREL/INSN16
11268          j    label             ; 25_PCREL/INSN16
11269          .L1:  */
11270
11271       /* Use j label as second instruction.  */
11272       insn = INSN_J;
11273       reloc = R_NDS32_25_PCREL_RELA;
11274       bfd_putb32 (insn, contents + em_irel->r_offset);
11275     }
11276   else
11277     return FALSE;
11278
11279   /* Set all relocations.  */
11280   em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
11281
11282   cond_irel =
11283     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11284                                  R_NDS32_PTR_RESOLVED, em_irel->r_offset);
11285   cond_irel->r_addend = 1;
11286
11287   /* Use INSN16 of first branch instruction to distinguish if keeping
11288      INSN16 of final instruction or not.  */
11289   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11290                                            R_NDS32_INSN16, irel->r_offset);
11291   if (insn_irel == irelend)
11292     {
11293       /* Clean the final INSN16.  */
11294       insn_irel =
11295         find_relocs_at_address_addr (irel, internal_relocs, irelend,
11296                                      R_NDS32_INSN16, em_irel->r_offset);
11297       insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11298                                         R_NDS32_NONE);
11299     }
11300
11301   if (cond_removed == 1)
11302     {
11303       *insn_len = 0;
11304
11305       /* Clear relocations.  */
11306       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11307
11308       for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11309         {
11310           cond_irel =
11311             find_relocs_at_address_addr (irel, internal_relocs, irelend,
11312                                          checked_types[i], laddr);
11313           if (cond_irel != irelend)
11314             {
11315               if (*seq_len == 0
11316                   && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11317                 {
11318                   /* If the branch instruction is 2 byte, it cannot remove
11319                      directly.  Only convert it to nop16 and remove it after
11320                      checking alignment issue.  */
11321                   insn16 = NDS32_NOP16;
11322                   bfd_putb16 (insn16, contents + laddr);
11323                   cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11324                 }
11325               else
11326                 cond_irel->r_info =
11327                   ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
11328             }
11329         }
11330     }
11331   else
11332     {
11333       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11334                                    R_NDS32_LONGJUMP5);
11335     }
11336
11337   return TRUE;
11338 }
11339
11340 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section.  */
11341
11342 static bfd_boolean
11343 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11344                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11345                            int *seq_len, bfd_byte *contents,
11346                            Elf_Internal_Sym *isymbuf,
11347                            Elf_Internal_Shdr *symtab_hdr)
11348 {
11349   /* There are 2 variations for LONGJUMP5
11350      case 2-4;  1st insn convertible, 16-bit on.
11351      movi55  ta, imm11          ; LONGJUMP7/INSN16
11352      beq     rt, ta, label      ; 15_PCREL
11353
11354      case 4-4; 1st insn not convertible
11355      movi55  ta, imm11          ; LONGJUMP7/INSN16
11356      beq     rt, ta, label      ; 15_PCREL  */
11357
11358   bfd_vma laddr;
11359   Elf_Internal_Rela *cond_irel,  *irelend, *insn_irel;
11360   bfd_signed_vma foff;
11361   uint32_t insn, re_insn = 0;
11362   uint16_t insn16;
11363   uint32_t imm11;
11364
11365   irelend = internal_relocs + sec->reloc_count;
11366   laddr = irel->r_offset;
11367
11368   /* Get the reloc for the address from which the register is
11369      being loaded.  This reloc will tell us which function is
11370      actually being called.  */
11371
11372   cond_irel =
11373     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11374                                  R_NDS32_15_PCREL_RELA, irel->r_addend);
11375   if (cond_irel == irelend)
11376     {
11377       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
11378                           (uint64_t) irel->r_offset);
11379       return FALSE;
11380     }
11381
11382   /* Get the value of the symbol referred to by the reloc.  */
11383   foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11384
11385   if (foff == 0
11386       || foff < -CONSERVATIVE_8BIT_S1
11387       || foff >= CONSERVATIVE_8BIT_S1)
11388     return FALSE;
11389
11390   /* Get the first instruction for its size.  */
11391   insn = bfd_getb32 (contents + laddr);
11392   if (insn & 0x80000000)
11393     {
11394       *seq_len = 0;
11395       /* Get the immediate from movi55.  */
11396       imm11 = N16_IMM5S (insn >> 16);
11397     }
11398   else
11399     {
11400       /* Get the immediate from movi.  */
11401       imm11 = N32_IMM20S (insn);
11402     }
11403
11404   /* Get the branch instruction.  */
11405   insn = bfd_getb32 (contents + irel->r_addend);
11406   /* Convert instruction to BR3.  */
11407   if ((insn >> 14) & 0x1)
11408     re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
11409   else
11410     re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
11411
11412   bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11413
11414   /* Set all relocations.  */
11415   cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11416                                     R_NDS32_WORD_9_PCREL_RELA);
11417
11418   /* Clean relocations.  */
11419   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11420   insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11421                                            R_NDS32_INSN16, irel->r_offset);
11422   if (insn_irel != irelend)
11423     {
11424       if (*seq_len == 0)
11425         {
11426           /* If the first insntruction is 16bit, convert it to nop16.  */
11427           insn16 = NDS32_NOP16;
11428           bfd_putb16 (insn16, contents + laddr);
11429           insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11430         }
11431       else
11432         cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11433                                           R_NDS32_NONE);
11434     }
11435   *insn_len = 0;
11436
11437   return TRUE;
11438 }
11439
11440 /* We figure out and reassign the best gp value in nds32_elf_final_sda_base
11441    for each relax round. But the gp may changed dramatically and then cause
11442    the truncated to fit errors for the the converted gp instructions.
11443    Therefore, we must reserve the minimum but safe enough size to prevent it.  */
11444
11445 static bfd_boolean
11446 nds32_elf_relax_guard (bfd_vma *access_addr, bfd_vma local_sda, asection *sec,
11447                        Elf_Internal_Rela *irel, bfd_boolean *again,
11448                        bfd_boolean init,
11449                        struct elf_nds32_link_hash_table *table,
11450                        Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
11451
11452 {
11453   int offset_to_gp;
11454   static bfd_boolean sec_pass = FALSE;
11455   static asection *first_sec = NULL, *sym_sec;
11456   /* Record the number of instructions which may be removed.  */
11457   static int count = 0, record_count;
11458   Elf_Internal_Sym *isym;
11459   struct elf_link_hash_entry *h = NULL;
11460   int indx;
11461   unsigned long r_symndx;
11462   bfd *abfd = sec->owner;
11463   static bfd_vma record_sda = 0;
11464   int sda_offset = 0;
11465
11466   /* Force doing relaxation when hyper-relax is high.  */
11467   if (table->hyper_relax == 2)
11468     return TRUE;
11469
11470   /* Do not relax the load/store patterns for the first
11471      relax round.  */
11472   if (init)
11473     {
11474       if (!first_sec)
11475         first_sec = sec;
11476       else if (first_sec == sec)
11477         {
11478           record_count = count;
11479           count = 0;
11480           sec_pass = TRUE;
11481         }
11482
11483       if (!sec_pass)
11484         *again = TRUE;
11485
11486       return TRUE;
11487     }
11488
11489   /* Generally, _SDA_BASE_ is fixed or smaller. But the large
11490      DATA_SEGMENT_ALIGN size in the linker script may make it
11491      get even bigger.  */
11492   if (record_sda == 0)
11493     record_sda = local_sda;
11494   else if (local_sda > record_sda)
11495     sda_offset = local_sda - record_sda;
11496
11497   /* Assume the instruction will be removed in the best case.  */
11498   count++;
11499
11500   /* We record the offset to gp for each symbol, and then check
11501      if it is changed dramatically after relaxing.
11502      (global symbol): elf32_nds32_hash_entry (h)->offset_to_gp
11503      (local symbol) : elf32_nds32_local_gp_offset (abfd)[r_symndx].  */
11504   r_symndx = ELF32_R_SYM (irel->r_info);
11505   if (r_symndx >= symtab_hdr->sh_info)
11506     {
11507       /* Global symbols.  */
11508       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11509       h = elf_sym_hashes (abfd)[indx];
11510       sym_sec = h->root.u.def.section;
11511       if (NDS32_GUARD_SEC_P (sym_sec->flags)
11512           || bfd_is_abs_section (sym_sec))
11513         {
11514           /* Forbid doing relaxation when hyper-relax is low.  */
11515           if (table->hyper_relax == 0)
11516             return FALSE;
11517
11518           offset_to_gp = *access_addr - local_sda;
11519           if (elf32_nds32_hash_entry (h)->offset_to_gp == 0)
11520             elf32_nds32_hash_entry (h)->offset_to_gp = offset_to_gp;
11521           else if (abs (elf32_nds32_hash_entry (h)->offset_to_gp)
11522                    < abs (offset_to_gp) - sda_offset)
11523             {
11524               /* This may cause the error, so we reserve the
11525                  safe enough size for relaxing.  */
11526               if (*access_addr >= local_sda)
11527                 *access_addr += (record_count * 4);
11528               else
11529                 *access_addr -= (record_count * 4);
11530             }
11531           return sec_pass;
11532         }
11533     }
11534   else
11535     {
11536       /* Local symbols.  */
11537       if (!elf32_nds32_allocate_local_sym_info (abfd))
11538         return FALSE;
11539       isym = isymbuf + r_symndx;
11540
11541       sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
11542       if (NDS32_GUARD_SEC_P (sym_sec->flags))
11543         {
11544           /* Forbid doing relaxation when hyper-relax is low.  */
11545           if (table->hyper_relax == 0)
11546             return FALSE;
11547
11548           offset_to_gp = *access_addr - local_sda;
11549           if (elf32_nds32_local_gp_offset (abfd)[r_symndx] == 0)
11550             elf32_nds32_local_gp_offset (abfd)[r_symndx] = offset_to_gp;
11551           else if (abs (elf32_nds32_local_gp_offset (abfd)[r_symndx])
11552                    < abs (offset_to_gp) - sda_offset)
11553             {
11554               /* This may cause the error, so we reserve the
11555                  safe enough size for relaxing.  */
11556               if (*access_addr >= local_sda)
11557                 *access_addr += (record_count * 4);
11558               else
11559                 *access_addr -= (record_count * 4);
11560             }
11561           return sec_pass;
11562         }
11563     }
11564
11565   return TRUE;
11566 }
11567
11568 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
11569
11570 /* Relax LOADSTORE relocation for nds32_elf_relax_section.  */
11571
11572 static bfd_boolean
11573 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
11574                            asection *sec, Elf_Internal_Rela *irel,
11575                            Elf_Internal_Rela *internal_relocs, int *insn_len,
11576                            bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11577                            Elf_Internal_Shdr *symtab_hdr, int load_store_relax,
11578                            struct elf_nds32_link_hash_table *table)
11579 {
11580   int eliminate_sethi = 0, range_type;
11581   unsigned int i;
11582   bfd_vma local_sda, laddr;
11583   int seq_len;  /* Original length of instruction sequence.  */
11584   uint32_t insn;
11585   Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
11586   bfd_vma access_addr = 0;
11587   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
11588   struct elf_link_hash_entry *h = NULL;
11589   int indx;
11590   enum elf_nds32_reloc_type checked_types[] =
11591     { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
11592       R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
11593       R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
11594       R_NDS32_TLS_LE_HI20
11595     };
11596
11597   irelend = internal_relocs + sec->reloc_count;
11598   seq_len = GET_SEQ_LEN (irel->r_addend);
11599   laddr = irel->r_offset;
11600   *insn_len = seq_len;
11601
11602   /* Get the high part relocation.  */
11603   for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11604     {
11605       hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11606                                                checked_types[i], laddr);
11607       if (hi_irelfn != irelend)
11608         break;
11609     }
11610
11611   if (hi_irelfn == irelend)
11612     {
11613       /* Not R_NDS32_HI20_RELA.  */
11614       if (i != 0)
11615         _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
11616                             (uint64_t) irel->r_offset);
11617       return FALSE;
11618     }
11619
11620   range_type = GET_LOADSTORE_RANGE (irel->r_addend);
11621   nds32_elf_final_sda_base (sec->output_section->owner,
11622                             link_info, &local_sda, FALSE);
11623
11624   switch (ELF32_R_TYPE (hi_irelfn->r_info))
11625     {
11626     case R_NDS32_HI20_RELA:
11627       insn = bfd_getb32 (contents + laddr);
11628       access_addr =
11629         calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
11630
11631       if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
11632         {
11633           indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
11634           h = elf_sym_hashes (abfd)[indx];
11635         }
11636
11637       /* Try movi.  */
11638       if (range_type == NDS32_LOADSTORE_IMM
11639           && access_addr < CONSERVATIVE_20BIT
11640           && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11641         {
11642           eliminate_sethi = 1;
11643           break;
11644         }
11645
11646       if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11647         {
11648           eliminate_sethi = 1;
11649           break;
11650         }
11651       else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, hi_irelfn,
11652                                        NULL, FALSE, table, isymbuf, symtab_hdr))
11653         return FALSE;
11654
11655       if (!load_store_relax)
11656         return FALSE;
11657
11658       /* Case for set gp register.  */
11659       if (N32_RT5 (insn) == REG_GP)
11660         return FALSE;
11661
11662       if (range_type == NDS32_LOADSTORE_FLOAT_S
11663           || range_type == NDS32_LOADSTORE_FLOAT_D)
11664         {
11665           range_l = sdata_range[0][0];
11666           range_h = sdata_range[0][1];
11667         }
11668       else
11669         {
11670           range_l = sdata_range[1][0];
11671           range_h = sdata_range[1][1];
11672         }
11673       break;
11674
11675     default:
11676       return FALSE;
11677     }
11678
11679   /* Delete sethi instruction.  */
11680   if (eliminate_sethi == 1
11681       || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
11682       || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11683     {
11684       hi_irelfn->r_info =
11685         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
11686       irel->r_info =
11687         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11688       *insn_len = 0;
11689       return TRUE;
11690     }
11691
11692   return FALSE;
11693 }
11694
11695 /* Relax LO12 relocation for nds32_elf_relax_section.  */
11696
11697 static void
11698 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
11699                       asection *sec, Elf_Internal_Rela *irel,
11700                       Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
11701                       Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
11702                       struct elf_nds32_link_hash_table *table)
11703 {
11704   uint32_t insn;
11705   bfd_vma local_sda, laddr;
11706   unsigned long reloc;
11707   bfd_vma access_addr;
11708   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
11709   Elf_Internal_Rela *irelfn = NULL, *irelend;
11710   struct elf_link_hash_entry *h = NULL;
11711   int indx;
11712
11713   /* For SDA base relative relaxation.  */
11714   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11715                             &local_sda, FALSE);
11716
11717   irelend = internal_relocs + sec->reloc_count;
11718   laddr = irel->r_offset;
11719   insn = bfd_getb32 (contents + laddr);
11720
11721   if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
11722     return;
11723
11724   access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11725
11726   if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
11727     {
11728       indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11729       h = elf_sym_hashes (abfd)[indx];
11730     }
11731
11732   /* Try movi.  */
11733   if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
11734       && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11735     {
11736       reloc = R_NDS32_20_RELA;
11737       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11738       insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11739       bfd_putb32 (insn, contents + laddr);
11740     }
11741   else
11742     {
11743       if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11744         {
11745           /* Fall through.  */
11746         }
11747       else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, irel, NULL,
11748                                        FALSE, table, isymbuf, symtab_hdr))
11749         return;
11750
11751       range_l = sdata_range[1][0];
11752       range_h = sdata_range[1][1];
11753       switch (ELF32_R_TYPE (irel->r_info))
11754         {
11755         case R_NDS32_LO12S0_RELA:
11756           reloc = R_NDS32_SDA19S0_RELA;
11757           break;
11758         case R_NDS32_LO12S1_RELA:
11759           reloc = R_NDS32_SDA18S1_RELA;
11760           break;
11761         case R_NDS32_LO12S2_RELA:
11762           reloc = R_NDS32_SDA17S2_RELA;
11763           break;
11764         case R_NDS32_LO12S2_DP_RELA:
11765           range_l = sdata_range[0][0];
11766           range_h = sdata_range[0][1];
11767           reloc = R_NDS32_SDA12S2_DP_RELA;
11768           break;
11769         case R_NDS32_LO12S2_SP_RELA:
11770           range_l = sdata_range[0][0];
11771           range_h = sdata_range[0][1];
11772           reloc = R_NDS32_SDA12S2_SP_RELA;
11773           break;
11774         default:
11775           return;
11776         }
11777
11778       /* There are range_h and range_l because linker has to promise
11779          all sections move cross one page together.  */
11780       if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11781           || (local_sda > access_addr && (local_sda - access_addr) <= range_l)
11782           || (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0))
11783         {
11784           if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11785             {
11786               /* Maybe we should add R_NDS32_INSN16 reloc type here
11787                  or manually do some optimization.  sethi can't be
11788                  eliminated when updating $gp so the relative ori
11789                  needs to be preserved.  */
11790               return;
11791             }
11792           if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11793                                         &insn))
11794             return;
11795           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11796           bfd_putb32 (insn, contents + laddr);
11797
11798           irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11799                                            R_NDS32_INSN16);
11800           /* SDA17 must keep INSN16 for converting fp_as_gp.  */
11801           if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11802             irelfn->r_info =
11803               ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11804
11805         }
11806     }
11807   return;
11808 }
11809
11810 /* Relax PTR relocation for nds32_elf_relax_section.  */
11811
11812 static bfd_boolean
11813 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11814                      Elf_Internal_Rela *internal_relocs, int *insn_len,
11815                      int *seq_len, bfd_byte *contents)
11816 {
11817   Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11818
11819   irelend = internal_relocs + sec->reloc_count;
11820
11821   re_irel =
11822     find_relocs_at_address_addr (irel, internal_relocs, irelend,
11823                                  R_NDS32_PTR_RESOLVED, irel->r_addend);
11824
11825   if (re_irel == irelend)
11826     {
11827       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
11828                           (uint64_t) irel->r_offset);
11829       return FALSE;
11830     }
11831
11832   if (re_irel->r_addend != 1)
11833     return FALSE;
11834
11835   /* Pointed target is relaxed and no longer needs this void *,
11836      change the type to NONE.  */
11837   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11838
11839   /* Find PTR_COUNT to decide remove it or not.  If PTR_COUNT does
11840      not exist, it means only count 1 and remove it directly.  */
11841   /* TODO: I hope we can obsolate R_NDS32_COUNT in the future.  */
11842   count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11843                                        R_NDS32_PTR_COUNT);
11844   ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11845                                      R_NDS32_PTR);
11846   if (count_irel != irelend)
11847     {
11848       if (--count_irel->r_addend > 0)
11849         return FALSE;
11850     }
11851
11852   if (ptr_irel != irelend)
11853     return FALSE;
11854
11855   /* If the PTR_COUNT is already 0, remove current instruction.  */
11856   *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11857   *insn_len = 0;
11858   return TRUE;
11859 }
11860
11861 /* Relax LWC relocation for nds32_elf_relax_section.  */
11862
11863 static void
11864 nds32_elf_relax_flsi (struct bfd_link_info *link_info, bfd *abfd,
11865                       asection *sec, Elf_Internal_Rela *irel,
11866                       Elf_Internal_Rela *internal_relocs,
11867                       bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11868                       Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11869 {
11870   /* Pattern:
11871      sethi    ra, hi20(symbol)      ; HI20/LOADSTORE
11872      ori      ra, ra, lo12(symbol)  ; LO12S0/PTR/PTR/.../INSN16
11873      flsi     fsa, [ra + offset1]   ; LSI/PTR_RESOLVED/INSN16
11874      flsi     fsb, [ra + offset2]   ; LSI/PTR_RESOLVED/INSN16
11875      ...  */
11876
11877   uint32_t insn;
11878   bfd_vma local_sda, laddr;
11879   unsigned long reloc;
11880   bfd_vma access_addr, flsi_offset;
11881   bfd_vma range_l = 0, range_h = 0;     /* Upper/lower bound.  */
11882   Elf_Internal_Rela *irelend, *re_irel;
11883   unsigned int opcode;
11884
11885   irelend = internal_relocs + sec->reloc_count;
11886   laddr = irel->r_offset;
11887   insn = bfd_getb32 (contents + laddr);
11888
11889   if ((insn & 0x80000000) || !is_sda_access_insn (insn))
11890     return;
11891
11892   /* Can not do relaxation for bi format.  */
11893   if ((insn & 0x1000))
11894     return;
11895
11896   /* Only deal with flsi, fssi, fldi, fsdi, so far.  */
11897   opcode = N32_OP6 (insn);
11898   if ((opcode == N32_OP6_LWC) || (opcode == N32_OP6_SWC))
11899     reloc = R_NDS32_SDA12S2_SP_RELA;
11900   else if ((opcode == N32_OP6_LDC) || (opcode == N32_OP6_SDC))
11901     reloc = R_NDS32_SDA12S2_DP_RELA;
11902   else
11903     return;
11904
11905   re_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11906                                     R_NDS32_PTR_RESOLVED);
11907   if (re_irel == irelend)
11908     {
11909       _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LSI",
11910                           (uint64_t) irel->r_offset);
11911       return;
11912     }
11913
11914   /* For SDA base relative relaxation.  */
11915   nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11916                             &local_sda, FALSE);
11917   access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11918   flsi_offset = (insn & 0xfff) << 2;
11919   access_addr += flsi_offset;
11920   range_l = sdata_range[0][0];
11921   range_h = sdata_range[0][1];
11922
11923   if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11924       || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11925     {
11926       /* Turn flsi instruction into sda access format.  */
11927       insn = (insn & 0x7ff07000) | (REG_GP << 15);
11928
11929       /* Add relocation type to flsi.  */
11930       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11931       irel->r_addend += flsi_offset;
11932       bfd_putb32 (insn, contents + re_irel->r_offset);
11933
11934       re_irel->r_addend |= 1;
11935       *again = TRUE;
11936     }
11937 }
11938
11939 static bfd_boolean
11940 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11941                           Elf_Internal_Rela *internal_relocs,
11942                           bfd_byte *contents,
11943                           nds32_elf_blank_t **relax_blank_list,
11944                           int optimize, int opt_size)
11945 {
11946   /* This code block is used to adjust 4-byte alignment by relax a pair
11947      of instruction a time.
11948
11949      It recognizes three types of relocations.
11950      1. R_NDS32_LABEL - a alignment.
11951      2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11952      3. is_16bit_NOP () - remove a 16-bit instruction.  */
11953
11954   /* TODO: It seems currently implementation only support 4-byte alignment.
11955      We should handle any-alignment.  */
11956
11957   Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11958   Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11959   Elf_Internal_Rela rel_temp;
11960   Elf_Internal_Rela *irelend;
11961   bfd_vma address;
11962   uint16_t insn16;
11963
11964   /* Checking for branch relaxation relies on the relocations to
11965      be sorted on 'r_offset'.  This is not guaranteed so we must sort.  */
11966   nds32_insertion_sort (internal_relocs, sec->reloc_count,
11967                         sizeof (Elf_Internal_Rela), compar_reloc);
11968
11969   irelend = internal_relocs + sec->reloc_count;
11970
11971   /* Force R_NDS32_LABEL before R_NDS32_INSN16.  */
11972   /* FIXME: Can we generate the right order in assembler?
11973      So we don't have to swapping them here.  */
11974
11975   for (label_rel = internal_relocs, insn_rel = internal_relocs;
11976        label_rel < irelend; label_rel++)
11977     {
11978       if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11979         continue;
11980
11981       /* Find the first reloc has the same offset with label_rel.  */
11982       while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11983         insn_rel++;
11984
11985       for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11986            insn_rel++)
11987         /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11988            address.  */
11989         if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11990           break;
11991
11992       if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11993           && insn_rel < label_rel)
11994         {
11995           /* Swap the two reloc if the R_NDS32_INSN16 is
11996              before R_NDS32_LABEL.  */
11997           memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11998           memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11999           memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
12000         }
12001     }
12002
12003   label_rel = NULL;
12004   insn_rel = NULL;
12005   /* If there were a sequence of R_NDS32_LABEL end up with .align 2
12006      or higher, remove other R_NDS32_LABEL with lower alignment.
12007      If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
12008      then the R_NDS32_LABEL sequence is broke.  */
12009   for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
12010     {
12011       if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
12012         {
12013           if (label_rel == NULL)
12014             {
12015               if (tmp_rel->r_addend < 2)
12016                 label_rel = tmp_rel;
12017               continue;
12018             }
12019           else if (tmp_rel->r_addend > 1)
12020             {
12021               /* Remove all LABEL relocation from label_rel to tmp_rel
12022                  including relocations with same offset as tmp_rel.  */
12023               for (tmp2_rel = label_rel; tmp2_rel < tmp_rel; tmp2_rel++)
12024                 {
12025                   if (tmp2_rel->r_offset == tmp_rel->r_offset)
12026                     break;
12027
12028                   if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
12029                       && tmp2_rel->r_addend < 2)
12030                     tmp2_rel->r_info =
12031                       ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
12032                                     R_NDS32_NONE);
12033                 }
12034               label_rel = NULL;
12035             }
12036         }
12037       else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
12038         {
12039           /* A new INSN16 which can be converted, so clear label_rel.  */
12040           if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
12041                                    irelend, &insn16)
12042               || is_16bit_NOP (abfd, sec, tmp_rel))
12043             label_rel = NULL;
12044         }
12045     }
12046
12047   label_rel = NULL;
12048   insn_rel = NULL;
12049   /* Optimized for speed and nothing has not been relaxed.
12050      It's time to align labels.
12051      We may convert a 16-bit instruction right before a label to
12052      32-bit, in order to align the label if necessary
12053      all reloc entries has been sorted by r_offset.  */
12054   for (irel = internal_relocs;
12055        irel < irelend && irel->r_offset < sec->size; irel++)
12056     {
12057       if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
12058           && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
12059         continue;
12060
12061       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
12062         {
12063           /* A new INSN16 found, resize the old one.  */
12064           if (is_convert_32_to_16
12065               (abfd, sec, irel, internal_relocs, irelend, &insn16)
12066               || is_16bit_NOP (abfd, sec, irel))
12067             {
12068               if (insn_rel)
12069                 {
12070                   /* Previous INSN16 reloc exists, reduce its
12071                      size to 16-bit.  */
12072                   if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12073                                            irelend, &insn16))
12074                     {
12075                       nds32_elf_write_16 (abfd, contents, insn_rel,
12076                                           internal_relocs, irelend, insn16);
12077
12078                       if (!insert_nds32_elf_blank_recalc_total
12079                           (relax_blank_list, insn_rel->r_offset + 2, 2))
12080                         return FALSE;
12081                     }
12082                   else if (is_16bit_NOP (abfd, sec, insn_rel))
12083                     {
12084                       if (!insert_nds32_elf_blank_recalc_total
12085                           (relax_blank_list, insn_rel->r_offset, 2))
12086                         return FALSE;
12087                     }
12088                   insn_rel->r_info =
12089                     ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
12090                 }
12091               /* Save the new one for later use.  */
12092               insn_rel = irel;
12093             }
12094           else
12095             irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
12096                                          R_NDS32_NONE);
12097         }
12098       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
12099         {
12100           /* Search for label.  */
12101           int force_relax = 0;
12102
12103           /* Label on 16-bit instruction or optimization
12104              needless, just reset this reloc.  */
12105           insn16 = bfd_getb16 (contents + irel->r_offset);
12106           if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
12107             {
12108               irel->r_info =
12109                 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
12110               continue;
12111             }
12112
12113           address =
12114             irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
12115                                                         irel->r_offset, 1);
12116
12117           if (!insn_rel)
12118             {
12119               /* Check if there is case which can not be aligned.  */
12120               if (irel->r_addend == 2 && address & 0x2)
12121                 return FALSE;
12122               continue;
12123             }
12124
12125           /* Try to align this label.  */
12126
12127           if ((irel->r_addend & 0x1f) < 2)
12128             {
12129               /* Check if there is a INSN16 at the same address.
12130                  Label_rel always seats before insn_rel after
12131                  our sort.  */
12132
12133               /* Search for INSN16 at LABEL location.  If INSN16 is at
12134                  same location and this LABEL alignment is lower than 2,
12135                  the INSN16 can be converted to 2-byte.  */
12136               for (tmp_rel = irel;
12137                    tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
12138                    tmp_rel++)
12139                 {
12140                   if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
12141                       && (is_convert_32_to_16
12142                           (abfd, sec, tmp_rel, internal_relocs,
12143                            irelend, &insn16)
12144                           || is_16bit_NOP (abfd, sec, tmp_rel)))
12145                     {
12146                       force_relax = 1;
12147                       break;
12148                     }
12149                 }
12150             }
12151
12152           if (force_relax || irel->r_addend == 1 || address & 0x2)
12153             {
12154               /* Label not aligned.  */
12155               /* Previous reloc exists, reduce its size to 16-bit.  */
12156               if (is_convert_32_to_16 (abfd, sec, insn_rel,
12157                                        internal_relocs, irelend, &insn16))
12158                 {
12159                   nds32_elf_write_16 (abfd, contents, insn_rel,
12160                                       internal_relocs, irelend, insn16);
12161
12162                   if (!insert_nds32_elf_blank_recalc_total
12163                       (relax_blank_list, insn_rel->r_offset + 2, 2))
12164                     return FALSE;
12165                 }
12166               else if (is_16bit_NOP (abfd, sec, insn_rel))
12167                 {
12168                   if (!insert_nds32_elf_blank_recalc_total
12169                       (relax_blank_list, insn_rel->r_offset, 2))
12170                     return FALSE;
12171                 }
12172
12173             }
12174           /* INSN16 reloc is used.  */
12175           insn_rel = NULL;
12176         }
12177     }
12178
12179   address =
12180     sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
12181   if (insn_rel && (address & 0x2 || opt_size))
12182     {
12183       if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12184                                irelend, &insn16))
12185         {
12186           nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
12187                               irelend, insn16);
12188           if (!insert_nds32_elf_blank_recalc_total
12189               (relax_blank_list, insn_rel->r_offset + 2, 2))
12190             return FALSE;
12191           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12192                                            R_NDS32_NONE);
12193         }
12194       else if (is_16bit_NOP (abfd, sec, insn_rel))
12195         {
12196           if (!insert_nds32_elf_blank_recalc_total
12197               (relax_blank_list, insn_rel->r_offset, 2))
12198             return FALSE;
12199           insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12200                                            R_NDS32_NONE);
12201         }
12202     }
12203   insn_rel = NULL;
12204   return TRUE;
12205 }
12206
12207 static bfd_boolean
12208 nds32_elf_relax_section (bfd *abfd, asection *sec,
12209                          struct bfd_link_info *link_info, bfd_boolean *again)
12210 {
12211   nds32_elf_blank_t *relax_blank_list = NULL;
12212   Elf_Internal_Shdr *symtab_hdr;
12213   Elf_Internal_Rela *internal_relocs;
12214   Elf_Internal_Rela *irel;
12215   Elf_Internal_Rela *irelend;
12216   Elf_Internal_Sym *isymbuf = NULL;
12217   bfd_byte *contents = NULL;
12218   bfd_boolean result = TRUE;
12219   int optimize = 0;
12220   int opt_size = 0;
12221   uint32_t insn;
12222   uint16_t insn16;
12223
12224   /* Target dependnet option.  */
12225   struct elf_nds32_link_hash_table *table;
12226   int load_store_relax;
12227
12228   relax_blank_list = NULL;
12229
12230   *again = FALSE;
12231
12232   /* Nothing to do for
12233    * relocatable link or
12234    * non-relocatable section or
12235    * non-code section or
12236    * empty content or
12237    * no reloc entry.  */
12238   if (bfd_link_relocatable (link_info)
12239       || (sec->flags & SEC_RELOC) == 0
12240       || (sec->flags & SEC_EXCLUDE) != 0
12241       || (sec->flags & SEC_CODE) == 0
12242       || sec->size == 0
12243       || sec->reloc_count == 0)
12244     return TRUE;
12245
12246   /* 09.12.11 Workaround.  */
12247   /*  We have to adjust align for R_NDS32_LABEL if needed.
12248       The adjust approach only can fix 2-byte align once.  */
12249   if (sec->alignment_power > 2)
12250     return TRUE;
12251
12252   /* Do TLS model conversion once at first.  */
12253   nds32_elf_unify_tls_model (abfd, sec, contents, link_info);
12254
12255   /* The optimization type to do.  */
12256
12257   table = nds32_elf_hash_table (link_info);
12258
12259   /* Save the first section for abs symbol relaxation.
12260      This is used for checking gp relaxation in the
12261      nds32_elf_relax_loadstore and nds32_elf_relax_lo12.  */
12262   nds32_elf_relax_guard (NULL, 0, sec, NULL, again, TRUE,
12263                          table, NULL, NULL);
12264
12265   /* The begining of general relaxation.  */
12266
12267   if (is_SDA_BASE_set == 0)
12268     {
12269       bfd_vma gp;
12270       is_SDA_BASE_set = 1;
12271       nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12272                                 &gp, FALSE);
12273       relax_range_measurement (abfd);
12274     }
12275
12276   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12277   /* Relocations MUST be kept in memory, because relaxation adjust them.  */
12278   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12279                                                TRUE /* keep_memory */);
12280   if (internal_relocs == NULL)
12281     goto error_return;
12282
12283   irelend = internal_relocs + sec->reloc_count;
12284   irel = find_relocs_at_address (internal_relocs, internal_relocs,
12285                                  irelend, R_NDS32_RELAX_ENTRY);
12286
12287   if (irel == irelend)
12288     return TRUE;
12289
12290   if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12291     {
12292       if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12293         return TRUE;
12294
12295       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12296         optimize = 1;
12297
12298       if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12299         opt_size = 1;
12300     }
12301
12302   load_store_relax = table->load_store_relax;
12303
12304   /* Get symbol table and section content.  */
12305   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12306       || !nds32_get_local_syms (abfd, sec, &isymbuf))
12307     goto error_return;
12308
12309   /* Do relax loop only when finalize is not done.
12310      Take care of relaxable relocs except INSN16.  */
12311   for (irel = internal_relocs; irel < irelend; irel++)
12312     {
12313       int seq_len;              /* Original length of instruction sequence.  */
12314       int insn_len = 0;         /* Final length of instruction sequence.  */
12315       bfd_boolean removed;
12316
12317       insn = 0;
12318       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12319           && (irel->r_addend & 0x1f) >= 2)
12320         optimize = 1;
12321
12322       /* Relocation Types
12323          R_NDS32_LONGCALL1      53
12324          R_NDS32_LONGCALL2      54
12325          R_NDS32_LONGCALL3      55
12326          R_NDS32_LONGJUMP1      56
12327          R_NDS32_LONGJUMP2      57
12328          R_NDS32_LONGJUMP3      58
12329          R_NDS32_LOADSTORE      59  */
12330       if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12331           && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12332         seq_len = GET_SEQ_LEN (irel->r_addend);
12333
12334       /* Relocation Types
12335          R_NDS32_LONGCALL4      107
12336          R_NDS32_LONGCALL5      108
12337          R_NDS32_LONGCALL6      109
12338          R_NDS32_LONGJUMP4      110
12339          R_NDS32_LONGJUMP5      111
12340          R_NDS32_LONGJUMP6      112
12341          R_NDS32_LONGJUMP7      113  */
12342       else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12343                && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12344         seq_len = 4;
12345
12346         /* Relocation Types
12347          R_NDS32_LO12S0_RELA            30
12348          R_NDS32_LO12S1_RELA            29
12349          R_NDS32_LO12S2_RELA            28
12350          R_NDS32_LO12S2_SP_RELA         71
12351          R_NDS32_LO12S2_DP_RELA         70
12352          R_NDS32_GOT_LO12               46
12353          R_NDS32_GOTOFF_LO12            50
12354          R_NDS32_PLTREL_LO12            65
12355          R_NDS32_PLT_GOTREL_LO12        67
12356          R_NDS32_17IFC_PCREL_RELA       96
12357          R_NDS32_GOT_SUFF               193
12358          R_NDS32_GOTOFF_SUFF            194
12359          R_NDS32_PLT_GOT_SUFF           195
12360          R_NDS32_MULCALL_SUFF           196
12361          R_NDS32_PTR                    197  */
12362       else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12363                 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12364                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12365                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12366                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12367                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12368                || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12369                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12370                || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12371                || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12372                    && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12373                || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12374                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12375                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12376                || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS
12377                || ELF32_R_TYPE (irel->r_info) == R_NDS32_LSI)
12378         seq_len = 0;
12379       else
12380         continue;
12381
12382       insn_len = seq_len;
12383       removed = FALSE;
12384
12385       switch (ELF32_R_TYPE (irel->r_info))
12386         {
12387         case R_NDS32_LONGCALL1:
12388           removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12389                                                &insn_len, contents, isymbuf,
12390                                                symtab_hdr);
12391           break;
12392         case R_NDS32_LONGCALL2:
12393           removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12394                                                &insn_len, contents, isymbuf,
12395                                                symtab_hdr);
12396           break;
12397         case R_NDS32_LONGCALL3:
12398           removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12399                                                &insn_len, contents, isymbuf,
12400                                                symtab_hdr);
12401           break;
12402         case R_NDS32_LONGJUMP1:
12403           removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12404                                                &insn_len, contents, isymbuf,
12405                                                symtab_hdr);
12406           break;
12407         case R_NDS32_LONGJUMP2:
12408           removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12409                                                &insn_len, contents, isymbuf,
12410                                                symtab_hdr);
12411           break;
12412         case R_NDS32_LONGJUMP3:
12413           removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12414                                                &insn_len, contents, isymbuf,
12415                                                symtab_hdr);
12416           break;
12417         case R_NDS32_LONGCALL4:
12418           removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12419                                                &insn_len, contents, isymbuf,
12420                                                symtab_hdr);
12421           break;
12422         case R_NDS32_LONGCALL5:
12423           removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12424                                                &insn_len, contents, isymbuf,
12425                                                symtab_hdr);
12426           break;
12427         case R_NDS32_LONGCALL6:
12428           removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12429                                                &insn_len, contents, isymbuf,
12430                                                symtab_hdr);
12431           break;
12432         case R_NDS32_LONGJUMP4:
12433           removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12434                                                &insn_len, contents, isymbuf,
12435                                                symtab_hdr);
12436           break;
12437         case R_NDS32_LONGJUMP5:
12438           removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12439                                                &insn_len, &seq_len, contents,
12440                                                isymbuf, symtab_hdr);
12441           break;
12442         case R_NDS32_LONGJUMP6:
12443           removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12444                                                &insn_len, &seq_len, contents,
12445                                                isymbuf, symtab_hdr);
12446           break;
12447         case R_NDS32_LONGJUMP7:
12448           removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12449                                                &insn_len, &seq_len, contents,
12450                                                isymbuf, symtab_hdr);
12451           break;
12452         case R_NDS32_LOADSTORE:
12453           removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12454                                                internal_relocs, &insn_len,
12455                                                contents, isymbuf, symtab_hdr,
12456                                                load_store_relax, table);
12457           break;
12458         case R_NDS32_LO12S0_RELA:
12459         case R_NDS32_LO12S1_RELA:
12460         case R_NDS32_LO12S2_RELA:
12461         case R_NDS32_LO12S2_DP_RELA:
12462         case R_NDS32_LO12S2_SP_RELA:
12463           /* Relax for low part.  */
12464           nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12465                                 contents, isymbuf, symtab_hdr, table);
12466
12467           /* It is impossible to delete blank, so just continue.  */
12468           continue;
12469         case R_NDS32_PTR:
12470           removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12471                                          &insn_len, &seq_len, contents);
12472           break;
12473         case R_NDS32_LSI:
12474           nds32_elf_relax_flsi (link_info, abfd, sec, irel, internal_relocs,
12475                                 contents, isymbuf, symtab_hdr, again);
12476           continue;
12477         case R_NDS32_GOT_LO12:
12478         case R_NDS32_GOTOFF_LO12:
12479         case R_NDS32_PLTREL_LO12:
12480         case R_NDS32_PLT_GOTREL_LO12:
12481         case R_NDS32_GOTPC_LO12:
12482         case R_NDS32_TLS_LE_LO12:
12483         case R_NDS32_TLS_LE_ADD:
12484         case R_NDS32_TLS_LE_LS:
12485         case R_NDS32_PLT_GOT_SUFF:
12486         case R_NDS32_GOT_SUFF:
12487         case R_NDS32_GOTOFF_SUFF:
12488           continue;
12489         default:
12490           continue;
12491         }
12492
12493       if (removed && seq_len - insn_len > 0)
12494         {
12495           if (!insert_nds32_elf_blank
12496               (&relax_blank_list, irel->r_offset + insn_len,
12497                seq_len - insn_len))
12498             goto error_return;
12499           *again = TRUE;
12500         }
12501     }
12502
12503   calc_nds32_blank_total (relax_blank_list);
12504
12505   if (table->relax_fp_as_gp)
12506     {
12507       if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12508                                  irelend, isymbuf))
12509         goto error_return;
12510
12511       if (!*again)
12512         {
12513           if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12514                                                irelend))
12515             goto error_return;
12516         }
12517     }
12518
12519   if (!*again)
12520     {
12521       if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12522                                      &relax_blank_list, optimize, opt_size))
12523         goto error_return;
12524     }
12525
12526   /* It doesn't matter optimize_for_space_no_align anymore.
12527        If object file is assembled with flag '-Os',
12528        the we don't adjust jump-destination on 4-byte boundary.  */
12529
12530   if (relax_blank_list)
12531     {
12532       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12533       relax_blank_list = NULL;
12534     }
12535
12536   if (!*again)
12537     {
12538       /* Closing the section, so we don't relax it anymore.  */
12539       bfd_vma sec_size_align;
12540       Elf_Internal_Rela *tmp_rel;
12541
12542       /* Pad to alignment boundary.  Only handle current section alignment.  */
12543       sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12544                        & ((-1U) << sec->alignment_power);
12545       if ((sec_size_align - sec->size) & 0x2)
12546         {
12547           insn16 = NDS32_NOP16;
12548           bfd_putb16 (insn16, contents + sec->size);
12549           sec->size += 2;
12550         }
12551
12552       while (sec_size_align != sec->size)
12553         {
12554           insn = NDS32_NOP32;
12555           bfd_putb32 (insn, contents + sec->size);
12556           sec->size += 4;
12557         }
12558
12559       tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12560                                         irelend, R_NDS32_RELAX_ENTRY);
12561       if (tmp_rel != irelend)
12562         tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12563
12564       clean_nds32_elf_blank ();
12565     }
12566
12567 finish:
12568   if (internal_relocs != NULL
12569       && elf_section_data (sec)->relocs != internal_relocs)
12570     free (internal_relocs);
12571
12572   if (contents != NULL
12573       && elf_section_data (sec)->this_hdr.contents != contents)
12574     free (contents);
12575
12576   if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12577     free (isymbuf);
12578
12579   return result;
12580
12581 error_return:
12582   result = FALSE;
12583   goto finish;
12584 }
12585
12586 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12587 {
12588   {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12589   {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12590   {NULL, 0, 0, 0, 0}
12591 };
12592
12593 static bfd_boolean
12594 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12595                             struct bfd_link_info *info,
12596                             void *finfo ATTRIBUTE_UNUSED,
12597                             bfd_boolean (*func) (void *, const char *,
12598                                                  Elf_Internal_Sym *,
12599                                                  asection *,
12600                                                  struct elf_link_hash_entry *)
12601                             ATTRIBUTE_UNUSED)
12602 {
12603   FILE *sym_ld_script = NULL;
12604   struct elf_nds32_link_hash_table *table;
12605
12606   table = nds32_elf_hash_table (info);
12607   sym_ld_script = table->sym_ld_script;
12608
12609   if (check_start_export_sym)
12610     fprintf (sym_ld_script, "}\n");
12611
12612   return TRUE;
12613 }
12614
12615 static enum elf_reloc_type_class
12616 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12617                             const asection *rel_sec ATTRIBUTE_UNUSED,
12618                             const Elf_Internal_Rela *rela)
12619 {
12620   switch ((int) ELF32_R_TYPE (rela->r_info))
12621     {
12622     case R_NDS32_RELATIVE:
12623       return reloc_class_relative;
12624     case R_NDS32_JMP_SLOT:
12625       return reloc_class_plt;
12626     case R_NDS32_COPY:
12627       return reloc_class_copy;
12628     default:
12629       return reloc_class_normal;
12630     }
12631 }
12632
12633 /* Put target dependent option into info hash table.  */
12634 void
12635 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12636                                    int relax_fp_as_gp,
12637                                    int eliminate_gc_relocs,
12638                                    FILE * sym_ld_script,
12639                                    int hyper_relax,
12640                                    int tls_desc_trampoline,
12641                                    int load_store_relax)
12642 {
12643   struct elf_nds32_link_hash_table *table;
12644
12645   table = nds32_elf_hash_table (link_info);
12646   if (table == NULL)
12647     return;
12648
12649   table->relax_fp_as_gp = relax_fp_as_gp;
12650   table->eliminate_gc_relocs = eliminate_gc_relocs;
12651   table->sym_ld_script = sym_ld_script;
12652   table->hyper_relax = hyper_relax;
12653   table->tls_desc_trampoline = tls_desc_trampoline;
12654   table ->load_store_relax = load_store_relax;
12655 }
12656 \f
12657
12658 /* These functions and data-structures are used for fp-as-gp
12659    optimization.  */
12660
12661 #define FAG_THRESHOLD   3       /* At least 3 gp-access.  */
12662 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12663    the read-only section and read-write section.  */
12664 #define FAG_WINDOW      (508 - 32)
12665
12666 /* An nds32_fag represent a gp-relative access.
12667    We find best fp-base by using a sliding window
12668    to find a base address which can cover most gp-access.  */
12669 struct nds32_fag
12670 {
12671   struct nds32_fag *next;       /* NULL-teminated linked list.  */
12672   bfd_vma addr;                 /* The address of this fag.  */
12673   Elf_Internal_Rela **relas;    /* The relocations associated with this fag.
12674                                    It is used for applying FP7U2_FLAG.  */
12675   int count;                    /* How many times this address is referred.
12676                                    There should be exactly `count' relocations
12677                                    in relas.  */
12678   int relas_capcity;            /* The buffer size of relas.
12679                                    We use an array instead of linked-list,
12680                                    and realloc is used to adjust buffer size.  */
12681 };
12682
12683 static void
12684 nds32_fag_init (struct nds32_fag *head)
12685 {
12686   memset (head, 0, sizeof (struct nds32_fag));
12687 }
12688
12689 static void
12690 nds32_fag_verify (struct nds32_fag *head)
12691 {
12692   struct nds32_fag *iter;
12693   struct nds32_fag *prev;
12694
12695   prev = NULL;
12696   iter = head->next;
12697   while (iter)
12698     {
12699       if (prev && prev->addr >= iter->addr)
12700         puts ("Bug in fp-as-gp insertion.");
12701       prev = iter;
12702       iter = iter->next;
12703     }
12704 }
12705
12706 /* Insert a fag in ascending order.
12707    If a fag of the same address already exists,
12708    they are chained by relas array.  */
12709
12710 static void
12711 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12712                   Elf_Internal_Rela * rel)
12713 {
12714   struct nds32_fag *iter;
12715   struct nds32_fag *new_fag;
12716   const int INIT_RELAS_CAP = 4;
12717
12718   for (iter = head;
12719        iter->next && iter->next->addr <= addr;
12720        iter = iter->next)
12721     /* Find somewhere to insert.  */ ;
12722
12723   /* `iter' will be equal to `head' if the list is empty.  */
12724   if (iter != head && iter->addr == addr)
12725     {
12726       /* The address exists in the list.
12727          Insert `rel' into relocation list, relas.  */
12728
12729       /* Check whether relas is big enough.  */
12730       if (iter->count >= iter->relas_capcity)
12731         {
12732           iter->relas_capcity *= 2;
12733           iter->relas = bfd_realloc
12734             (iter->relas, iter->relas_capcity * sizeof (void *));
12735         }
12736       iter->relas[iter->count++] = rel;
12737       return;
12738     }
12739
12740   /* This is a new address.  Create a fag node for it.  */
12741   new_fag = bfd_malloc (sizeof (struct nds32_fag));
12742   memset (new_fag, 0, sizeof (*new_fag));
12743   new_fag->addr = addr;
12744   new_fag->count = 1;
12745   new_fag->next = iter->next;
12746   new_fag->relas_capcity = INIT_RELAS_CAP;
12747   new_fag->relas = (Elf_Internal_Rela **)
12748     bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12749   new_fag->relas[0] = rel;
12750   iter->next = new_fag;
12751
12752   nds32_fag_verify (head);
12753 }
12754
12755 static void
12756 nds32_fag_free_list (struct nds32_fag *head)
12757 {
12758   struct nds32_fag *iter;
12759
12760   iter = head->next;
12761   while (iter)
12762     {
12763       struct nds32_fag *tmp = iter;
12764       iter = iter->next;
12765       free (tmp->relas);
12766       tmp->relas = NULL;
12767       free (tmp);
12768     }
12769 }
12770
12771 /* Find the best fp-base address.
12772    The relocation associated with that address is returned,
12773    so we can track the symbol instead of a fixed address.
12774
12775    When relaxation, the address of an datum may change,
12776    because a text section is shrinked, so the data section
12777    moves forward.  If the aligments of text and data section
12778    are different, their distance may change too.
12779    Therefore, tracking a fixed address is not appriate.  */
12780
12781 static int
12782 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12783 {
12784   struct nds32_fag *base;       /* First fag in the window.  */
12785   struct nds32_fag *last;       /* First fag outside the window.  */
12786   int accu = 0;                 /* Usage accumulation.  */
12787   struct nds32_fag *best;       /* Best fag.  */
12788   int baccu = 0;                /* Best accumulation.  */
12789
12790   /* Use first fag for initial, and find the last fag in the window.
12791
12792      In each iteration, we could simply subtract previous fag
12793      and accumulate following fags which are inside the window,
12794      untill we each the end.  */
12795
12796   if (head->next == NULL)
12797     {
12798       *bestpp = NULL;
12799       return 0;
12800     }
12801
12802   /* Initialize base.  */
12803   base = head->next;
12804   best = base;
12805   for (last = base;
12806        last && last->addr < base->addr + FAG_WINDOW;
12807        last = last->next)
12808     accu += last->count;
12809
12810   baccu = accu;
12811
12812   /* Record the best base in each iteration.  */
12813   while (base->next)
12814     {
12815       accu -= base->count;
12816       base = base->next;
12817       /* Account fags in window.  */
12818       for (/* Nothing.  */;
12819            last && last->addr < base->addr + FAG_WINDOW;
12820            last = last->next)
12821         accu += last->count;
12822
12823       /* A better fp-base?  */
12824       if (accu > baccu)
12825         {
12826           best = base;
12827           baccu = accu;
12828         }
12829     }
12830
12831   if (bestpp)
12832     *bestpp = best;
12833   return baccu;
12834 }
12835
12836 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12837    so we can convert it fo fp-relative access later.
12838    `best_fag' is the best fp-base.  Only those inside the window
12839    of best_fag is applied the flag.  */
12840
12841 static bfd_boolean
12842 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12843                       asection *sec, struct nds32_fag *best_fag,
12844                       Elf_Internal_Rela *internal_relocs,
12845                       Elf_Internal_Rela *irelend)
12846 {
12847   struct nds32_fag *ifag;
12848   bfd_vma best_fpbase, gp;
12849   bfd *output_bfd;
12850
12851   output_bfd = sec->output_section->owner;
12852   nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12853   best_fpbase = best_fag->addr;
12854
12855   if (best_fpbase > gp + sdata_range[1][1]
12856       || best_fpbase < gp - sdata_range[1][0])
12857     return FALSE;
12858
12859   /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12860      so we know they can be converted to lwi37.fp.   */
12861   for (ifag = best_fag;
12862        ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12863     {
12864       int i;
12865
12866       for (i = 0; i < ifag->count; i++)
12867         {
12868           Elf_Internal_Rela *insn16_rel;
12869           Elf_Internal_Rela *fag_rel;
12870
12871           fag_rel = ifag->relas[i];
12872
12873           /* Only if this is within the WINDOWS, FP7U2_FLAG
12874              is applied.  */
12875
12876           insn16_rel = find_relocs_at_address
12877             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12878
12879           if (insn16_rel != irelend)
12880             insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12881         }
12882     }
12883   return TRUE;
12884 }
12885
12886 /* Reset INSN16 to clean fp as gp.  */
12887
12888 static void
12889 nds32_fag_unmark_relax (struct nds32_fag *fag,
12890                         Elf_Internal_Rela *internal_relocs,
12891                         Elf_Internal_Rela *irelend)
12892 {
12893   struct nds32_fag *ifag;
12894   int i;
12895   Elf_Internal_Rela *insn16_rel;
12896   Elf_Internal_Rela *fag_rel;
12897
12898   for (ifag = fag; ifag; ifag = ifag->next)
12899     {
12900       for (i = 0; i < ifag->count; i++)
12901         {
12902           fag_rel = ifag->relas[i];
12903
12904           /* Restore the INSN16 relocation.  */
12905           insn16_rel = find_relocs_at_address
12906             (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12907
12908           if (insn16_rel != irelend)
12909             insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12910         }
12911     }
12912 }
12913
12914 /* This is the main function of fp-as-gp optimization.
12915    It should be called by relax_section.  */
12916
12917 static bfd_boolean
12918 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12919                       bfd *abfd, asection *sec,
12920                       Elf_Internal_Rela *internal_relocs,
12921                       Elf_Internal_Rela *irelend,
12922                       Elf_Internal_Sym *isymbuf)
12923 {
12924   Elf_Internal_Rela *begin_rel = NULL;
12925   Elf_Internal_Rela *irel;
12926   struct nds32_fag fag_head;
12927   Elf_Internal_Shdr *symtab_hdr;
12928   bfd_byte *contents;
12929   bfd_boolean ifc_inside = FALSE;
12930
12931   /* FIXME: Can we bfd_elf_link_read_relocs for the relocs?  */
12932
12933   /* Per-function fp-base selection.
12934      1. Create a list for all the gp-relative access.
12935      2. Base on those gp-relative address,
12936         find a fp-base which can cover most access.
12937      3. Use the fp-base for fp-as-gp relaxation.
12938
12939      NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12940      we should
12941      1. delete the `la $fp, _FP_BASE_' instruction and
12942      2. not convert lwi.gp to lwi37.fp.
12943
12944      To delete the _FP_BASE_ instruction, we simply apply
12945      R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12946
12947      To suppress the conversion, we simply NOT to apply
12948      R_NDS32_INSN16_FP7U2_FLAG flag.  */
12949
12950   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12951
12952   if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12953       || !nds32_get_local_syms (abfd, sec, &isymbuf))
12954     return FALSE;
12955
12956   /* Check whether it is worth for fp-as-gp optimization,
12957      i.e., at least 3 gp-load.
12958
12959      Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12960      apply this optimization.  */
12961
12962   for (irel = internal_relocs; irel < irelend; irel++)
12963     {
12964       /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12965          One we enter the begin of the region, we track all the LW/ST
12966          instructions, so when we leave the region, we try to find
12967          the best fp-base address for those LW/ST instructions.  */
12968
12969       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12970           && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12971         {
12972           /* Begin of the region.  */
12973           if (begin_rel)
12974             /* xgettext:c-format */
12975             _bfd_error_handler (_("%pB: nested OMIT_FP in %pA"), abfd, sec);
12976
12977           begin_rel = irel;
12978           nds32_fag_init (&fag_head);
12979           ifc_inside = FALSE;
12980         }
12981       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12982                && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12983         {
12984           int accu;
12985           struct nds32_fag *best_fag, *tmp_fag;
12986           int dist;
12987
12988           /* End of the region.
12989              Check whether it is worth to do fp-as-gp.  */
12990
12991           if (begin_rel == NULL)
12992             {
12993               /* xgettext:c-format */
12994               _bfd_error_handler (_("%pB: unmatched OMIT_FP in %pA"),
12995                                   abfd, sec);
12996               continue;
12997             }
12998
12999           accu = nds32_fag_find_base (&fag_head, &best_fag);
13000
13001           /* Clean FP7U2_FLAG because they may set ever.  */
13002           tmp_fag = fag_head.next;
13003           nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
13004
13005           /* Check if it is worth, and FP_BASE is near enough to SDA_BASE.  */
13006           if (accu < FAG_THRESHOLD
13007               || !nds32_fag_mark_relax (link_info, sec, best_fag,
13008                                         internal_relocs, irelend))
13009             {
13010               /* Not worth to do fp-as-gp.  */
13011               begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13012               begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13013               irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13014               irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13015               nds32_fag_free_list (&fag_head);
13016               begin_rel = NULL;
13017               continue;
13018             }
13019
13020           /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
13021              so we use it to record the distance to the reloction of best
13022              fp-base.  */
13023           dist = best_fag->relas[0] - begin_rel;
13024           BFD_ASSERT (dist > 0 && dist < 0xffffff);
13025           /* Use high 16 bits of addend to record the _FP_BASE_ matched
13026              relocation.  And get the base value when relocating.  */
13027           begin_rel->r_addend &= (0x1 << 16) - 1;
13028           begin_rel->r_addend |= dist << 16;
13029
13030           nds32_fag_free_list (&fag_head);
13031           begin_rel = NULL;
13032         }
13033
13034       if (begin_rel == NULL || ifc_inside)
13035         /* Skip if we are not in the region of fp-as-gp.  */
13036         continue;
13037
13038       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
13039           || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
13040         {
13041           bfd_vma addr;
13042           uint32_t insn;
13043
13044           /* A gp-relative access is found.  Insert it to the fag-list.  */
13045
13046           /* Rt is necessary an RT3, so it can be converted to lwi37.fp.  */
13047           insn = bfd_getb32 (contents + irel->r_offset);
13048           if (!N32_IS_RT3 (insn))
13049             continue;
13050
13051           addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
13052           nds32_fag_insert (&fag_head, addr, irel);
13053         }
13054       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
13055         {
13056           begin_rel = NULL;
13057         }
13058       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
13059                || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13060         {
13061           /* Suppress fp as gp when encounter ifc.  */
13062           ifc_inside = TRUE;
13063         }
13064     }
13065
13066   return TRUE;
13067 }
13068
13069 /* Remove unused `la $fp, _FD_BASE_' instruction.  */
13070
13071 static bfd_boolean
13072 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
13073                                 Elf_Internal_Rela *internal_relocs,
13074                                 Elf_Internal_Rela *irelend)
13075 {
13076   Elf_Internal_Rela *irel;
13077   Elf_Internal_Shdr *symtab_hdr;
13078   bfd_byte *contents = NULL;
13079   nds32_elf_blank_t *relax_blank_list = NULL;
13080   bfd_boolean result = TRUE;
13081   bfd_boolean unused_region = FALSE;
13082
13083   /*
13084      NOTE: Disable fp-as-gp if we encounter ifcall relocations:
13085        R_NDS32_17IFC_PCREL_RELA
13086        R_NDS32_10IFCU_PCREL_RELA.  */
13087
13088   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13089   nds32_get_section_contents (abfd, sec, &contents, TRUE);
13090
13091   for (irel = internal_relocs; irel < irelend; irel++)
13092     {
13093       /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
13094          we marked to in previous pass.
13095          DO NOT scan relocations again, since we've alreadly decided it
13096          and set the flag.  */
13097       const char *syname;
13098       int syndx;
13099       uint32_t insn;
13100
13101       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
13102           && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13103         unused_region = TRUE;
13104       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
13105                && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13106         unused_region = FALSE;
13107
13108       /* We're not in the region.  */
13109       if (!unused_region)
13110         continue;
13111
13112       /* _FP_BASE_ must be a GLOBAL symbol.  */
13113       syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
13114       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
13115         continue;
13116
13117       /* The symbol name must be _FP_BASE_.  */
13118       syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
13119       if (strcmp (syname, FP_BASE_NAME) != 0)
13120         continue;
13121
13122       if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
13123         {
13124           /* addi.gp  $fp, -256  */
13125           insn = bfd_getb32 (contents + irel->r_offset);
13126           if (insn != INSN_ADDIGP_TO_FP)
13127             continue;
13128         }
13129       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
13130         {
13131           /* addi  $fp, $gp, -256  */
13132           insn = bfd_getb32 (contents + irel->r_offset);
13133           if (insn != INSN_ADDI_GP_TO_FP)
13134             continue;
13135         }
13136       else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
13137         {
13138           /* movi  $fp, FP_BASE  */
13139           insn = bfd_getb32 (contents + irel->r_offset);
13140           if (insn != INSN_MOVI_TO_FP)
13141             continue;
13142         }
13143       else
13144         continue;
13145
13146       /* We got here because a FP_BASE instruction is found.  */
13147       if (!insert_nds32_elf_blank_recalc_total
13148           (&relax_blank_list, irel->r_offset, 4))
13149         goto error_return;
13150     }
13151
13152 finish:
13153   if (relax_blank_list)
13154     {
13155       nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
13156       relax_blank_list = NULL;
13157     }
13158   return result;
13159
13160 error_return:
13161   result = FALSE;
13162   goto finish;
13163 }
13164
13165 /* This is a version of bfd_generic_get_relocated_section_contents.
13166    We need this variety because relaxation will modify the dwarf
13167    infomation.  When there is undefined symbol reference error mesage,
13168    linker need to dump line number where the symbol be used.  However
13169    the address is be relaxed, it can not get the original dwarf contents.
13170    The variety only modify function call for reading in the section.  */
13171
13172 static bfd_byte *
13173 nds32_elf_get_relocated_section_contents (bfd *abfd,
13174                                           struct bfd_link_info *link_info,
13175                                           struct bfd_link_order *link_order,
13176                                           bfd_byte *data,
13177                                           bfd_boolean relocatable,
13178                                           asymbol **symbols)
13179 {
13180   bfd *input_bfd = link_order->u.indirect.section->owner;
13181   asection *input_section = link_order->u.indirect.section;
13182   long reloc_size;
13183   arelent **reloc_vector;
13184   long reloc_count;
13185
13186   reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13187   if (reloc_size < 0)
13188     return NULL;
13189
13190   /* Read in the section.  */
13191   if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
13192     return NULL;
13193
13194   if (reloc_size == 0)
13195     return data;
13196
13197   reloc_vector = (arelent **) bfd_malloc (reloc_size);
13198   if (reloc_vector == NULL)
13199     return NULL;
13200
13201   reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
13202                                         reloc_vector, symbols);
13203   if (reloc_count < 0)
13204     goto error_return;
13205
13206   if (reloc_count > 0)
13207     {
13208       arelent **parent;
13209       for (parent = reloc_vector; *parent != NULL; parent++)
13210         {
13211           char *error_message = NULL;
13212           asymbol *symbol;
13213           bfd_reloc_status_type r;
13214
13215           symbol = *(*parent)->sym_ptr_ptr;
13216           if (symbol->section && discarded_section (symbol->section))
13217             {
13218               bfd_vma off;
13219               static reloc_howto_type none_howto
13220                 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13221                          "unused", FALSE, 0, 0, FALSE);
13222
13223               off = (*parent)->address * bfd_octets_per_byte (input_bfd);
13224               _bfd_clear_contents ((*parent)->howto, input_bfd,
13225                                    input_section, data, off);
13226               (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13227               (*parent)->addend = 0;
13228               (*parent)->howto = &none_howto;
13229               r = bfd_reloc_ok;
13230             }
13231           else
13232             r = bfd_perform_relocation (input_bfd, *parent, data,
13233                                         input_section,
13234                                         relocatable ? abfd : NULL,
13235                                         &error_message);
13236
13237           if (relocatable)
13238             {
13239               asection *os = input_section->output_section;
13240
13241               /* A partial link, so keep the relocs.  */
13242               os->orelocation[os->reloc_count] = *parent;
13243               os->reloc_count++;
13244             }
13245
13246           if (r != bfd_reloc_ok)
13247             {
13248               switch (r)
13249                 {
13250                 case bfd_reloc_undefined:
13251                   (*link_info->callbacks->undefined_symbol)
13252                     (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13253                      input_bfd, input_section, (*parent)->address, TRUE);
13254                   break;
13255                 case bfd_reloc_dangerous:
13256                   BFD_ASSERT (error_message != NULL);
13257                   (*link_info->callbacks->reloc_dangerous)
13258                     (link_info, error_message,
13259                      input_bfd, input_section, (*parent)->address);
13260                   break;
13261                 case bfd_reloc_overflow:
13262                   (*link_info->callbacks->reloc_overflow)
13263                     (link_info, NULL,
13264                      bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13265                      (*parent)->howto->name, (*parent)->addend,
13266                      input_bfd, input_section, (*parent)->address);
13267                   break;
13268                 case bfd_reloc_outofrange:
13269                   /* PR ld/13730:
13270                      This error can result when processing some partially
13271                      complete binaries.  Do not abort, but issue an error
13272                      message instead.  */
13273                   link_info->callbacks->einfo
13274                     /* xgettext:c-format */
13275                     (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
13276                      abfd, input_section, * parent);
13277                   goto error_return;
13278
13279                 default:
13280                   abort ();
13281                   break;
13282                 }
13283             }
13284         }
13285     }
13286
13287   free (reloc_vector);
13288   return data;
13289
13290 error_return:
13291   free (reloc_vector);
13292   return NULL;
13293 }
13294
13295 /* Check target symbol.  */
13296
13297 static bfd_boolean
13298 nds32_elf_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
13299 {
13300   if (!sym || !sym->name || sym->name[0] != '$')
13301     return FALSE;
13302   return TRUE;
13303 }
13304
13305 /* nds32 find maybe function sym.  Ignore target special symbol
13306    first, and then go the general function.  */
13307
13308 static bfd_size_type
13309 nds32_elf_maybe_function_sym (const asymbol *sym, asection *sec,
13310                               bfd_vma *code_off)
13311 {
13312   if (nds32_elf_is_target_special_symbol (NULL, (asymbol *) sym))
13313     return 0;
13314
13315   return _bfd_elf_maybe_function_sym (sym, sec, code_off);
13316 }
13317 \f
13318
13319 /* Do TLS model conversion.  */
13320
13321 typedef struct relax_group_list_t
13322 {
13323   Elf_Internal_Rela *relo;
13324   struct relax_group_list_t *next;
13325   struct relax_group_list_t *next_sibling;
13326   int id;
13327 } relax_group_list_t;
13328
13329 int
13330 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem);
13331
13332 int
13333 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem);
13334
13335 void
13336 dump_chain (relax_group_list_t *pHead);
13337
13338 int
13339 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem)
13340 {
13341   relax_group_list_t *pNext = pHead;
13342
13343   /* Find place.  */
13344   while (pNext->next)
13345     {
13346       if (pNext->next->id > (int) pElem->r_addend)
13347         break;
13348
13349       pNext = pNext->next;
13350     }
13351
13352   /* Insert node.  */
13353   relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13354   if (!pNew)
13355     return FALSE;
13356
13357   relax_group_list_t *tmp = pNext->next;
13358   pNext->next = pNew;
13359
13360   pNew->id = pElem->r_addend;
13361   pNew->relo = pElem;
13362   pNew->next = tmp;
13363   pNew->next_sibling = NULL;
13364
13365   return TRUE;
13366 }
13367
13368 int
13369 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem)
13370 {
13371   relax_group_list_t *pNext = pNode;
13372
13373   /* Find place.  */
13374   while (pNext->next_sibling)
13375     {
13376       pNext = pNext->next_sibling;
13377     }
13378
13379   /* Insert node.  */
13380   relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13381   if (!pNew)
13382     return FALSE;
13383
13384   relax_group_list_t *tmp = pNext->next_sibling;
13385   pNext->next_sibling = pNew;
13386
13387   pNew->id = -1;
13388   pNew->relo = pElem;
13389   pNew->next = NULL;
13390   pNew->next_sibling = tmp;
13391
13392   return TRUE;
13393 }
13394
13395 void
13396 dump_chain (relax_group_list_t *pHead)
13397 {
13398   relax_group_list_t *pNext = pHead->next;
13399   while (pNext)
13400     {
13401       printf("group %d @ 0x%08x", pNext->id, (unsigned)pNext->relo->r_offset);
13402       relax_group_list_t *pNextSib = pNext->next_sibling;
13403       while (pNextSib)
13404         {
13405           printf(", %d", (unsigned) ELF32_R_TYPE (pNextSib->relo->r_info));
13406           pNextSib = pNextSib->next_sibling;
13407         }
13408       pNext = pNext->next;
13409       printf("\n");
13410     }
13411 }
13412
13413 /* Check R_NDS32_RELAX_GROUP of each section.
13414    There might be multiple sections in one object file.  */
13415
13416 int
13417 elf32_nds32_check_relax_group (bfd *abfd, asection *asec)
13418 {
13419   elf32_nds32_relax_group_t *relax_group_ptr =
13420     elf32_nds32_relax_group_ptr (abfd);
13421
13422   int min_id = relax_group_ptr->min_id;
13423   int max_id = relax_group_ptr->max_id;
13424
13425   Elf_Internal_Rela *rel;
13426   Elf_Internal_Rela *relend;
13427   Elf_Internal_Rela *relocs;
13428   enum elf_nds32_reloc_type rtype;
13429
13430   do
13431     {
13432       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
13433       relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13434                                           TRUE /* keep_memory  */);
13435       if (relocs == NULL)
13436         break;
13437
13438       /* Check R_NDS32_RELAX_GROUP.  */
13439       relend = relocs + asec->reloc_count;
13440       for (rel = relocs; rel < relend; rel++)
13441         {
13442           int id;
13443           rtype = ELF32_R_TYPE (rel->r_info);
13444           if (rtype != R_NDS32_RELAX_GROUP)
13445             continue;
13446
13447           id = rel->r_addend;
13448           if (id < min_id)
13449             min_id = id;
13450           else if (id > max_id)
13451             max_id = id;
13452         }
13453     }
13454   while (FALSE);
13455
13456   if ((relocs != NULL) && (elf_section_data (asec)->relocs != relocs))
13457     free (relocs);
13458
13459   if ((min_id != relax_group_ptr->min_id)
13460       || (max_id != relax_group_ptr->max_id))
13461     {
13462       relax_group_ptr->count = max_id - min_id + 1;
13463       BFD_ASSERT(min_id <= relax_group_ptr->min_id);
13464       relax_group_ptr->min_id = min_id;
13465       BFD_ASSERT(max_id >= relax_group_ptr->max_id);
13466       relax_group_ptr->max_id = max_id;
13467     }
13468
13469   return relax_group_ptr->count;
13470 }
13471
13472 /* Reorder RELAX_GROUP ID when command line option '-r' is applied.  */
13473 struct section_id_list_t *relax_group_section_id_list = NULL;
13474
13475 struct section_id_list_t *
13476 elf32_nds32_lookup_section_id (int id, struct section_id_list_t **lst_ptr)
13477 {
13478   struct section_id_list_t *result = NULL;
13479   struct section_id_list_t *lst = *lst_ptr;
13480
13481   if (NULL == lst)
13482     {
13483       result = (struct section_id_list_t *) calloc
13484         (1, sizeof (struct section_id_list_t));
13485       BFD_ASSERT (result); /* Feed me.  */
13486       result->id = id;
13487       *lst_ptr = result;
13488     }
13489   else
13490     {
13491       struct section_id_list_t *cur = lst;
13492       struct section_id_list_t *prv = NULL;
13493       struct section_id_list_t *sec = NULL;
13494
13495       while (cur)
13496         {
13497           if (cur->id < id)
13498             {
13499               prv = cur;
13500               cur = cur->next;
13501               continue;
13502             }
13503
13504           if (cur->id > id)
13505             {
13506               cur = NULL; /* To insert after prv.  */
13507               sec = cur;  /* In case prv == NULL.  */
13508             }
13509
13510           break;
13511         }
13512
13513       if (NULL == cur)
13514         {
13515           /* Insert after prv.  */
13516           result = (struct section_id_list_t *) calloc
13517             (1, sizeof (struct section_id_list_t));
13518           BFD_ASSERT (result); /* Feed me.  */
13519           result->id = id;
13520           if (NULL != prv)
13521             {
13522               result->next = prv->next;
13523               prv->next = result;
13524             }
13525           else
13526             {
13527               *lst_ptr = result;
13528               result->next = sec;
13529             }
13530         }
13531     }
13532
13533   return result;
13534 }
13535
13536 int
13537 elf32_nds32_unify_relax_group (bfd *abfd, asection *asec)
13538 {
13539   static int next_relax_group_bias = 0;
13540
13541   elf32_nds32_relax_group_t *relax_group_ptr =
13542     elf32_nds32_relax_group_ptr (abfd);
13543
13544   bfd_boolean result = TRUE;
13545   Elf_Internal_Rela *rel;
13546   Elf_Internal_Rela *relend;
13547   Elf_Internal_Rela *relocs = NULL;
13548   enum elf_nds32_reloc_type rtype;
13549   struct section_id_list_t *node = NULL;
13550   int count = 0;
13551
13552   do
13553     {
13554       if (0 == relax_group_ptr->count)
13555         break;
13556
13557       /* Check if this section has been handled.  */
13558       node = elf32_nds32_lookup_section_id (asec->id, &relax_group_section_id_list);
13559       if (NULL == node)
13560         break; /* Hit, the section id has handled.  */
13561
13562       /* Relocations MUST be kept in memory, because relaxation adjust them.  */
13563       relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13564                                           TRUE /* keep_memory  */);
13565       if (relocs == NULL)
13566         {
13567           BFD_ASSERT (0); /* feed me */
13568           break;
13569         }
13570
13571       /* Allocate group id bias for this bfd!  */
13572       if (0 == relax_group_ptr->init)
13573         {
13574           relax_group_ptr->bias = next_relax_group_bias;
13575           next_relax_group_bias += relax_group_ptr->count;
13576           relax_group_ptr->init = 1;
13577         }
13578
13579       /* Reorder relax group groups.  */
13580       relend = relocs + asec->reloc_count;
13581       for (rel = relocs; rel < relend; rel++)
13582         {
13583           rtype = ELF32_R_TYPE(rel->r_info);
13584           if (rtype != R_NDS32_RELAX_GROUP)
13585             continue;
13586
13587           /* Change it.  */
13588           rel->r_addend += relax_group_ptr->bias;
13589           /* Debugging count.  */
13590           count++;
13591         }
13592     }
13593   while (FALSE);
13594
13595   if (relocs != NULL && elf_section_data (asec)->relocs != relocs)
13596     free (relocs);
13597
13598   return result;
13599 }
13600
13601 int
13602 nds32_elf_unify_tls_model (bfd *inbfd, asection *insec, bfd_byte *incontents,
13603                            struct bfd_link_info *lnkinfo)
13604 {
13605   bfd_boolean result = TRUE;
13606   Elf_Internal_Rela *irel;
13607   Elf_Internal_Rela *irelend;
13608   Elf_Internal_Rela *internal_relocs;
13609   unsigned long r_symndx;
13610   enum elf_nds32_reloc_type r_type;
13611
13612   Elf_Internal_Sym *local_syms = NULL;
13613   bfd_byte *contents = NULL;
13614
13615   relax_group_list_t chain = { .id = -1, .next = NULL, .next_sibling = NULL };
13616
13617   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (inbfd)->symtab_hdr;
13618   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
13619   sym_hashes = elf_sym_hashes (inbfd);
13620   sym_hashes_end =
13621     sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
13622   if (!elf_bad_symtab (inbfd))
13623     sym_hashes_end -= symtab_hdr->sh_info;
13624
13625   /* Reorder RELAX_GROUP when command line option '-r' is applied.  */
13626   if (bfd_link_relocatable (lnkinfo))
13627     {
13628       elf32_nds32_unify_relax_group (inbfd, insec);
13629       return result;
13630     }
13631
13632   /* Relocations MUST be kept in memory, because relaxation adjust them.  */
13633   internal_relocs = _bfd_elf_link_read_relocs (inbfd, insec, NULL, NULL,
13634                                                TRUE /* keep_memory  */);
13635   if (internal_relocs == NULL)
13636     goto error_return;
13637
13638   irelend = internal_relocs + insec->reloc_count;
13639   irel = find_relocs_at_address (internal_relocs, internal_relocs,
13640                                  irelend, R_NDS32_RELAX_ENTRY);
13641   if (irel == irelend)
13642     goto finish;
13643
13644   /* Chain/remove groups.  */
13645   for (irel = internal_relocs; irel < irelend; irel++)
13646     {
13647       r_symndx = ELF32_R_SYM (irel->r_info);
13648       r_type = ELF32_R_TYPE (irel->r_info);
13649       if (r_type != R_NDS32_RELAX_GROUP)
13650         continue;
13651
13652       /* Remove it.  */
13653       irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_NONE);
13654       /* Chain it now.  */
13655       if (!list_insert (&chain, irel))
13656         goto error_return;
13657     }
13658
13659   /* Collect group relocations.  */
13660   /* Presume relocations are sorted.  */
13661   relax_group_list_t *pNext = chain.next;
13662   while (pNext)
13663     {
13664       for (irel = internal_relocs; irel < irelend; irel++)
13665         {
13666           if (irel->r_offset == pNext->relo->r_offset)
13667             {
13668               /* Ignore Non-TLS relocation types.  */
13669               r_type = ELF32_R_TYPE (irel->r_info);
13670               if ((R_NDS32_TLS_LE_HI20 > r_type)
13671                   || (R_NDS32_RELAX_ENTRY == r_type))
13672                 continue;
13673
13674               if (!list_insert_sibling (pNext, irel))
13675                 goto error_return;
13676             }
13677           else if (irel->r_offset > pNext->relo->r_offset)
13678             {
13679               pNext = pNext->next;
13680               if (!pNext)
13681                 break;
13682
13683               bfd_vma current_offset = pNext->relo->r_offset;
13684               if (irel->r_offset > current_offset)
13685                 irel = internal_relocs; /* restart from head */
13686               else
13687                 --irel; /* Check current irel again.  */
13688               continue;
13689             }
13690           else
13691             {
13692               /* This shouldn't be reached.  */
13693             }
13694         }
13695       if (pNext)
13696         pNext = pNext->next;
13697     }
13698
13699 #ifdef DUBUG_VERBOSE
13700   dump_chain(&chain);
13701 #endif
13702
13703   /* Get symbol table and section content.  */
13704   if (incontents)
13705     contents = incontents;
13706   else if (!nds32_get_section_contents (inbfd, insec, &contents, TRUE)
13707            || !nds32_get_local_syms (inbfd, insec, &local_syms))
13708     goto error_return;
13709
13710   char *local_got_tls_type = elf32_nds32_local_got_tls_type (inbfd);
13711
13712   /* Convert TLS model each group if necessary.  */
13713   pNext = chain.next;
13714
13715   int cur_grp_id = -1;
13716   int sethi_rt = -1;
13717   int add_rt = -1;
13718   enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
13719
13720   tls_type = org_tls_type = eff_tls_type = 0;
13721
13722   while (pNext)
13723     {
13724       relax_group_list_t *pNextSig = pNext->next_sibling;
13725       while (pNextSig)
13726         {
13727           struct elf_link_hash_entry *h = NULL;
13728
13729           irel = pNextSig->relo;
13730           r_symndx = ELF32_R_SYM(irel->r_info);
13731           r_type = ELF32_R_TYPE(irel->r_info);
13732
13733           if (pNext->id != cur_grp_id)
13734             {
13735               cur_grp_id = pNext->id;
13736               org_tls_type = get_tls_type (r_type, NULL);
13737               if (r_symndx >= symtab_hdr->sh_info)
13738                 {
13739                   h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13740                   while (h->root.type == bfd_link_hash_indirect
13741                          || h->root.type == bfd_link_hash_warning)
13742                     h = (struct elf_link_hash_entry *) h->root.u.i.link;
13743                   tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
13744                 }
13745               else
13746                 {
13747                   tls_type = local_got_tls_type
13748                     ? local_got_tls_type[r_symndx]
13749                     : GOT_NORMAL;
13750                 }
13751
13752               eff_tls_type = 1 << (fls (tls_type) - 1);
13753               sethi_rt = N32_RT5(bfd_getb32 (contents + irel->r_offset));
13754             }
13755
13756           if (eff_tls_type != org_tls_type)
13757             {
13758               switch (org_tls_type)
13759                 {
13760                   /* DESC to IEGP/IE/LE.  */
13761                 case GOT_TLS_DESC:
13762                   switch (eff_tls_type)
13763                     {
13764                     case GOT_TLS_IE:
13765                       switch (r_type)
13766                         {
13767                         case R_NDS32_TLS_DESC_HI20:
13768                           irel->r_info = ELF32_R_INFO(r_symndx,
13769                                                       R_NDS32_TLS_IE_HI20);
13770                           break;
13771                         case R_NDS32_TLS_DESC_LO12:
13772                           irel->r_info = ELF32_R_INFO(r_symndx,
13773                                                       R_NDS32_TLS_IE_LO12);
13774                           break;
13775                         case R_NDS32_TLS_DESC_ADD:
13776                           {
13777                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13778                             add_rt = N32_RT5 (insn);
13779                             insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13780                             bfd_putb32 (insn, contents + irel->r_offset);
13781
13782                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13783                           }
13784                           break;
13785                         case R_NDS32_TLS_DESC_FUNC:
13786                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13787                           irel->r_info = ELF32_R_INFO(r_symndx,
13788                                                       R_NDS32_RELAX_REMOVE);
13789                           break;
13790                         case R_NDS32_TLS_DESC_CALL:
13791                           {
13792                             uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13793                                                      REG_TP);
13794                             bfd_putb32 (insn, contents + irel->r_offset);
13795
13796                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13797                           }
13798                           break;
13799                         case R_NDS32_LOADSTORE:
13800                         case R_NDS32_PTR:
13801                         case R_NDS32_PTR_RESOLVED:
13802                         case R_NDS32_NONE:
13803                         case R_NDS32_LABEL:
13804                           break;
13805                         default:
13806                           BFD_ASSERT(0);
13807                           break;
13808                         }
13809                       break;
13810                     case GOT_TLS_IEGP:
13811                       switch (r_type)
13812                         {
13813                         case R_NDS32_TLS_DESC_HI20:
13814                           irel->r_info = ELF32_R_INFO(r_symndx,
13815                                                       R_NDS32_TLS_IEGP_HI20);
13816                           break;
13817                         case R_NDS32_TLS_DESC_LO12:
13818                           irel->r_info = ELF32_R_INFO(r_symndx,
13819                                                       R_NDS32_TLS_IEGP_LO12);
13820                           break;
13821                         case R_NDS32_TLS_DESC_ADD:
13822                           {
13823                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13824                             add_rt = N32_RT5 (insn);
13825                             insn = N32_MEM(LW, add_rt, sethi_rt, REG_GP, 0);
13826                             bfd_putb32 (insn, contents + irel->r_offset);
13827
13828                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13829                           }
13830                           break;
13831                         case R_NDS32_TLS_DESC_FUNC:
13832                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13833                           irel->r_info = ELF32_R_INFO(r_symndx,
13834                                                       R_NDS32_RELAX_REMOVE);
13835                           break;
13836                         case R_NDS32_TLS_DESC_CALL:
13837                           {
13838                             uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13839                                                      REG_TP);
13840                             bfd_putb32 (insn, contents + irel->r_offset);
13841
13842                             irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13843                           }
13844                           break;
13845                         case R_NDS32_LOADSTORE:
13846                         case R_NDS32_PTR:
13847                         case R_NDS32_PTR_RESOLVED:
13848                         case R_NDS32_NONE:
13849                         case R_NDS32_LABEL:
13850                           break;
13851                         default:
13852                           BFD_ASSERT(0);
13853                           break;
13854                         }
13855                       break;
13856                     case GOT_TLS_LE:
13857                       switch (r_type)
13858                         {
13859                         case R_NDS32_TLS_DESC_HI20:
13860                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13861                           break;
13862                         case R_NDS32_TLS_DESC_LO12:
13863                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13864                           break;
13865                         case R_NDS32_TLS_DESC_ADD:
13866                           {
13867                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13868
13869                             add_rt = N32_RT5 (insn);
13870                             insn = N32_ALU1 (ADD, REG_R0, sethi_rt, REG_TP);
13871                             bfd_putb32 (insn, contents + irel->r_offset);
13872
13873                             irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_ADD);
13874                           }
13875                           break;
13876                         case R_NDS32_TLS_DESC_FUNC:
13877                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13878                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13879                           break;
13880                         case R_NDS32_TLS_DESC_CALL:
13881                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13882                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13883                           break;
13884                         case R_NDS32_LOADSTORE:
13885                         case R_NDS32_PTR:
13886                         case R_NDS32_PTR_RESOLVED:
13887                         case R_NDS32_NONE:
13888                         case R_NDS32_LABEL:
13889                           break;
13890                         default:
13891                           BFD_ASSERT(0);
13892                           break;
13893                         }
13894                       break;
13895                     default:
13896                       break;
13897                     }
13898                   break;
13899                   /* IEGP to IE/LE.  */
13900                 case GOT_TLS_IEGP:
13901                   switch (eff_tls_type)
13902                     {
13903                     case GOT_TLS_IE:
13904                       switch (r_type)
13905                         {
13906                         case R_NDS32_TLS_IEGP_HI20:
13907                           irel->r_info = ELF32_R_INFO(r_symndx,
13908                                                       R_NDS32_TLS_IE_HI20);
13909                           break;
13910                         case R_NDS32_TLS_IEGP_LO12:
13911                           irel->r_info = ELF32_R_INFO(r_symndx,
13912                                                       R_NDS32_TLS_IE_LO12);
13913                           break;
13914                         case R_NDS32_PTR_RESOLVED:
13915                           {
13916                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13917
13918                             add_rt = N32_RT5 (insn);
13919                             insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13920                             bfd_putb32 (insn, contents + irel->r_offset);
13921                           }
13922                           break;
13923                         case R_NDS32_TLS_IEGP_LW:
13924                           break;
13925                         case R_NDS32_LOADSTORE:
13926                         case R_NDS32_PTR:
13927                         case R_NDS32_NONE:
13928                         case R_NDS32_LABEL:
13929                           break;
13930                         default:
13931                           BFD_ASSERT(0);
13932                           break;
13933                         }
13934                       break;
13935                     case GOT_TLS_LE:
13936                       switch (r_type)
13937                         {
13938                         case R_NDS32_TLS_IEGP_HI20:
13939                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13940                           break;
13941                         case R_NDS32_TLS_IEGP_LO12:
13942                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13943                           break;
13944                         case R_NDS32_TLS_IEGP_LW:
13945                           bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13946                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13947                           break;
13948                         case R_NDS32_LOADSTORE:
13949                         case R_NDS32_PTR:
13950                         case R_NDS32_NONE:
13951                         case R_NDS32_LABEL:
13952                         case R_NDS32_PTR_RESOLVED:
13953                           break;
13954                         default:
13955                           BFD_ASSERT(0);
13956                           break;
13957                         }
13958                       break;
13959                     default:
13960                       break;
13961                     }
13962                   break;
13963                   /* IE to LE. */
13964                 case GOT_TLS_IE:
13965                   switch (eff_tls_type)
13966                     {
13967                     case GOT_TLS_LE:
13968                       switch (r_type)
13969                         {
13970                         case R_NDS32_TLS_IE_HI20:
13971                           irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13972                           break;
13973                         case R_NDS32_TLS_IE_LO12S2:
13974                           {
13975                             uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13976
13977                             add_rt = N32_RT5 (insn);
13978                             insn = N32_TYPE2 (ORI, add_rt, sethi_rt, 0);
13979                             bfd_putb32 (insn, contents + irel->r_offset);
13980
13981                             irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13982                           }
13983                           break;
13984                         case R_NDS32_LOADSTORE:
13985                         case R_NDS32_PTR:
13986                         case R_NDS32_NONE:
13987                         case R_NDS32_LABEL:
13988                           break;
13989                         default:
13990                           BFD_ASSERT(0);
13991                           break;
13992                         }
13993                       break;
13994                     default:
13995                       break;
13996                     }
13997                   break;
13998                 default:
13999                   break;
14000                 }
14001             }
14002           pNextSig = pNextSig->next_sibling;
14003         }
14004
14005 #if 1
14006       pNext = pNext->next;
14007 #else
14008       while (pNext)
14009         {
14010           if (pNext->id != cur_grp_id)
14011             break;
14012           pNext = pNext->next;
14013         }
14014 #endif
14015     }
14016
14017 finish:
14018   if (incontents)
14019     contents = NULL;
14020
14021   if (internal_relocs != NULL
14022       && elf_section_data (insec)->relocs != internal_relocs)
14023     free (internal_relocs);
14024
14025   if (contents != NULL
14026       && elf_section_data (insec)->this_hdr.contents != contents)
14027     free (contents);
14028
14029   if (local_syms != NULL && symtab_hdr->contents != (bfd_byte *) local_syms)
14030     free (local_syms);
14031
14032   if (chain.next)
14033     {
14034       pNext = chain.next;
14035       relax_group_list_t *pDel;
14036       while (pNext)
14037         {
14038           pDel = pNext;
14039           pNext = pNext->next;
14040           free (pDel);
14041         }
14042     }
14043
14044   return result;
14045
14046 error_return:
14047   result = FALSE;
14048   goto finish;
14049 }
14050
14051 /* End TLS model conversion.  */
14052
14053 #define ELF_ARCH                                bfd_arch_nds32
14054 #define ELF_MACHINE_CODE                        EM_NDS32
14055 #define ELF_MAXPAGESIZE                         0x1000
14056 #define ELF_TARGET_ID                           NDS32_ELF_DATA
14057
14058 #define TARGET_BIG_SYM                          nds32_elf32_be_vec
14059 #define TARGET_BIG_NAME                         "elf32-nds32be"
14060 #define TARGET_LITTLE_SYM                       nds32_elf32_le_vec
14061 #define TARGET_LITTLE_NAME                      "elf32-nds32le"
14062
14063 #define elf_info_to_howto                       nds32_info_to_howto
14064 #define elf_info_to_howto_rel                   nds32_info_to_howto_rel
14065
14066 #define bfd_elf32_bfd_link_hash_table_create    nds32_elf_link_hash_table_create
14067 #define bfd_elf32_bfd_merge_private_bfd_data    nds32_elf_merge_private_bfd_data
14068 #define bfd_elf32_bfd_print_private_bfd_data    nds32_elf_print_private_bfd_data
14069 #define bfd_elf32_bfd_relax_section             nds32_elf_relax_section
14070 #define bfd_elf32_bfd_set_private_flags         nds32_elf_set_private_flags
14071
14072 #define bfd_elf32_mkobject                      nds32_elf_mkobject
14073 #define elf_backend_action_discarded            nds32_elf_action_discarded
14074 #define elf_backend_add_symbol_hook             nds32_elf_add_symbol_hook
14075 #define elf_backend_check_relocs                nds32_elf_check_relocs
14076 #define elf_backend_adjust_dynamic_symbol       nds32_elf_adjust_dynamic_symbol
14077 #define elf_backend_create_dynamic_sections     nds32_elf_create_dynamic_sections
14078 #define elf_backend_finish_dynamic_sections     nds32_elf_finish_dynamic_sections
14079 #define elf_backend_finish_dynamic_symbol       nds32_elf_finish_dynamic_symbol
14080 #define elf_backend_size_dynamic_sections       nds32_elf_size_dynamic_sections
14081 #define elf_backend_relocate_section            nds32_elf_relocate_section
14082 #define elf_backend_gc_mark_hook                nds32_elf_gc_mark_hook
14083 #define elf_backend_grok_prstatus               nds32_elf_grok_prstatus
14084 #define elf_backend_grok_psinfo                 nds32_elf_grok_psinfo
14085 #define elf_backend_reloc_type_class            nds32_elf_reloc_type_class
14086 #define elf_backend_copy_indirect_symbol        nds32_elf_copy_indirect_symbol
14087 #define elf_backend_link_output_symbol_hook     nds32_elf_output_symbol_hook
14088 #define elf_backend_output_arch_syms            nds32_elf_output_arch_syms
14089 #define elf_backend_object_p                    nds32_elf_object_p
14090 #define elf_backend_final_write_processing      nds32_elf_final_write_processing
14091 #define elf_backend_special_sections            nds32_elf_special_sections
14092 #define bfd_elf32_bfd_get_relocated_section_contents \
14093                                 nds32_elf_get_relocated_section_contents
14094 #define bfd_elf32_bfd_is_target_special_symbol  nds32_elf_is_target_special_symbol
14095 #define elf_backend_maybe_function_sym          nds32_elf_maybe_function_sym
14096
14097 #define elf_backend_can_gc_sections             1
14098 #define elf_backend_can_refcount                1
14099 #define elf_backend_want_got_plt                1
14100 #define elf_backend_plt_readonly                1
14101 #define elf_backend_want_plt_sym                0
14102 #define elf_backend_got_header_size             12
14103 #define elf_backend_may_use_rel_p               1
14104 #define elf_backend_default_use_rela_p          1
14105 #define elf_backend_may_use_rela_p              1
14106 #define elf_backend_dtrel_excludes_plt          0
14107
14108 #include "elf32-target.h"
14109
14110 #undef ELF_MAXPAGESIZE
14111 #define ELF_MAXPAGESIZE                         0x2000
14112
14113 #undef  TARGET_BIG_SYM
14114 #define TARGET_BIG_SYM                          nds32_elf32_linux_be_vec
14115 #undef  TARGET_BIG_NAME
14116 #define TARGET_BIG_NAME                         "elf32-nds32be-linux"
14117 #undef  TARGET_LITTLE_SYM
14118 #define TARGET_LITTLE_SYM                       nds32_elf32_linux_le_vec
14119 #undef  TARGET_LITTLE_NAME
14120 #define TARGET_LITTLE_NAME                      "elf32-nds32le-linux"
14121 #undef  elf32_bed
14122 #define elf32_bed                               elf32_nds32_lin_bed
14123
14124 #include "elf32-target.h"